From: nakai Date: Thu, 29 Jan 2009 01:23:57 +0000 (+0000) Subject: 20090128版のjhcコードをマージ X-Git-Tag: v3.0.1~6^2~221^2~1043 X-Git-Url: http://git.osdn.net/view?a=commitdiff_plain;h=00ddd06177add0e9772fb617ce5e0002010f64eb;p=ultramonkey-l7%2Fultramonkey-l7-v3.git 20090128版のjhcコードをマージ git-svn-id: http://10.144.169.20/repos/um/branches/l7vsd-3.x-shamshel@6436 1ed66053-1c2d-0410-8867-f7571e6e31d3 --- diff --git a/module/protocol/protocol_module_sessionless.cpp b/module/protocol/protocol_module_sessionless.cpp new file mode 100644 index 00000000..c593d075 --- /dev/null +++ b/module/protocol/protocol_module_sessionless.cpp @@ -0,0 +1,2440 @@ +#include +#include +#include +#include +#include +#include +#include +#include "protocol_module_sessionless.h" + +namespace l7vs +{ +//construct +protocol_module_sessionless::protocol_module_sessionless() : + http_protocol_module_base(MODULE_NAME) +{ + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + putLogDebug(010000, "in/out_function: protocol_module_sessionless::" + "protocol_module_sessionless()", __FILE__, __LINE__ ); + + boost::format formatter( + "out_function: protocol_module_sessionless::protocol_module_sessionless(): " + "modename=%s"); + formatter % MODULE_NAME; + putLogDebug(010001, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ +} +//desconstruct +protocol_module_sessionless::~protocol_module_sessionless() +{ + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + putLogDebug(010002, "in/out_function: protocol_module_sessionless::" + "~protocol_module_sessionless()", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ +} +//! tcp protocol support check +//! @return tcp support is true +//! @return tcp not-support is false +bool protocol_module_sessionless::is_tcp() +{ + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + putLogDebug(010003, + "in/out_function: bool protocol_module_sessionless::is_tcp(): " + "return_value=true", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + return true; +} + +//! udp protocol support check +//! @return udp support is true +//! @return udp not-support is false +bool protocol_module_sessionless::is_udp() +{ + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + putLogDebug(010004, + "in/out_function: bool protocol_module_sessionless::is_udp(): " + "return_value=false", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + return false; +} + +//replication—pƒCƒ“ƒ^[ƒtƒFƒCƒX +void protocol_module_sessionless::replication_interrupt() +{ +} +/*! + *initialize + * + *@param [in] inrslist_begin + *@param [in] inrslist_end + *@param [in] inrslist_next + *@param [in] inlist_lock + *@param [in] inlist_unlock + */ +void protocol_module_sessionless::initialize( + rs_list_itr_func_type inrslist_begin, + rs_list_itr_func_type inrslist_end, + rs_list_itr_func_type inrslist_next, + boost::function inlist_lock, + boost::function inlist_unlock) +{ + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + putLogDebug( + 010005, + "in_function: void protocol_module_sessionless::initialize(" + "rs_list_itr_func_type inlist_begin, rs_list_itr_func_type inlist_end," + "rs_list_itr_func_type inlist_next,boost::function< void( void ) > " + "inlist_lock,boost::function< void( void ) > inlist_unlock )", + __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + //RealServerƒŠƒXƒg‚ÌŠe‘€ìŠÖ”‚ðÝ’è‚·‚é + //RealServerƒŠƒXƒgæ“ªŽæ“¾ŠÖ” + rs_list_begin = inrslist_begin; + //RealServerƒŠƒXƒg––’[Žæ“¾ŠÖ” + rs_list_end = inrslist_end; + //RealServerƒŠƒXƒgŽŸ—v‘fŽæ“¾ŠÖ” + rs_list_next = inrslist_next; + //RealServerƒŠƒXƒgƒƒbƒNŠÖ” + rs_list_lock = inlist_lock; + //RealServerƒŠƒXƒgƒAƒ“ƒƒbƒNŠÖ” + rs_list_unlock = inlist_unlock; + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + putLogDebug( + 010006, + "out_function: void protocol_module_sessionless::initialize(" + "rs_list_itr_func_type inlist_begin, rs_list_itr_func_type inlist_end," + "rs_list_itr_func_type inlist_next,boost::function< void( void ) > " + "inlist_lock,boost::function< void( void ) > inlist_unlock )", + __FILE__, __LINE__ ); + } + /*-------- DEBUG LOG --------*/ +} + +/*! + *finalize + * + */ +void protocol_module_sessionless::finalize() +{ + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + putLogDebug(010007, + "int_function: void protocol_module_sessionless::finalize()", + __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + //ƒƒOo—Í‚ÌŠe‘€ìŠÖ”‚ð‰Šú‰»‚·‚é + //ƒƒOƒŒƒxƒ‹Žæ“¾ŠÖ” + getloglevel.clear(); + //ƒƒOo—͊֐”iFatalj + putLogFatal.clear(); + //ƒƒOo—͊֐”iErrorj + putLogError.clear(); + //ƒƒOo—͊֐”iWarnj + putLogWarn.clear(); + //ƒƒOo—͊֐”iInfoj + putLogInfo.clear(); + //ƒƒOo—͊֐”iDebugj + putLogDebug.clear(); + + //RealServerƒŠƒXƒg‚ÌŠe‘€ìŠÖ”‚ð‰Šú‰»‚·‚é + //RealServerƒŠƒXƒgæ“ªŽæ“¾ŠÖ” + rs_list_begin.clear(); + //RealServerƒŠƒXƒg––’[Žæ“¾ŠÖ” + rs_list_end.clear(); + //RealServerƒŠƒXƒgŽŸ—v‘fŽæ“¾ŠÖ” + rs_list_next.clear(); + //RealServerƒŠƒXƒgƒƒbƒNŠÖ” + rs_list_lock.clear(); + //RealServerƒŠƒXƒgƒAƒ“ƒƒbƒNŠÖ” + rs_list_unlock.clear(); + + //Replication‚ÌŠe‘€ìŠÖ”‚ð‰Šú‰»‚·‚é + //ƒRƒ“ƒ|[ƒlƒ“ƒg—̈抄‚è“–‚Ċ֐” + replication_pay_memory.clear(); + //ƒRƒ“ƒ|[ƒlƒ“ƒg—̈惍ƒbƒNŠÖ” + replication_area_lock.clear(); + //ƒRƒ“ƒ|[ƒlƒ“ƒg—̈æƒAƒ“ƒƒbƒNŠÖ” + replication_area_unlock.clear(); + + //ScheduleModule‚̐U•ªŠÖ”‚ð‰Šú‰»‚·‚é + //ClientU‚蕪‚¯ˆ—ŠÖ” + schedule_tcp.clear(); + schedule_udp.clear(); + + //Šeƒ‚ƒWƒ…[ƒ‹ƒIƒvƒVƒ‡ƒ“‚ð‰Šú‰»‚·‚é + //‘—MŒ³Ý’èŽwŽ¦ + forwarded_for = 0; + //sorryURI + boost::array tmp; + sorry_uri.swap(tmp); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + putLogDebug(010007, + "out_function: void protocol_module_sessionless::finalize()", + __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ +} + +/*! + *is_use_sorry + * + */ +bool protocol_module_sessionless::is_use_sorry() +{ + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + putLogDebug(010007, + "in/out_function: bool protocol_module_sessionless::is_use_sorry(): " + "return_value=true", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + return true; +} + +/*! + *check_parameter + * + *@param [in] args + *@retval check_message_result_return + */ +protocol_module_sessionless::check_message_result protocol_module_sessionless::check_parameter( + const std::vector& args) +{ + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format formatter( + "int_function: protocol_module_sessionless::check_message_result " + "protocol_module_sessionless::check_parameter(" + "const std::vector& args ): args=%s"); + std::string argsdump; + for (std::vector::const_iterator it = args.begin(); it + != args.end(); ++it) + { + argsdump += *it; + } + formatter % argsdump; + putLogDebug(010010, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + //ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉTRUE‚ðÝ’è‚·‚é + check_message_result check_result; + check_result.flag = true; + bool forward_checked = false; + bool sorryuri_checked = false; + const std::string regex_match_str = "([^?#]*)(\\?([^#]*))?(#(.*))?"; + + //ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ‚Ì—v‘f”•ªŒJ‚è•Ô‚µ + typedef std::vector::const_iterator vec_str_it; + + try + { + vec_str_it it = args.begin(); + vec_str_it it_end = args.end(); + for (; it != it_end; ++it) + { + //ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-F" + if (*it == "-F" || *it == "--forward-for") + { + //‘—MŒ³Ý’èŽwŽ¦Ý’èƒtƒ‰ƒO‚ðON + forward_checked = true; + } + //ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-S" + else if (*it == "-S" || *it == "--sorryURI") + { + //sorryURIÝ’èƒtƒ‰ƒO = OFF + if (!sorryuri_checked) + { + //ŽŸ—v‘f‚ª‘¶Ý‚·‚éê‡ + if (++it != it_end) + { + //ŽŸ—v‘f‚Ì•¶Žš—ñ’· „ 127 + if (it->size() > 127) + { + std::ostringstream ostr; + ostr << "\"-S/--sorryURI\" option value'" << *it + << "'is too long."; + + //ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é + check_result.flag = false; + //ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚ðÝ’è‚·‚é + check_result.message = ostr.str(); + putLogError(0170000, check_result.message, + __FILE__, __LINE__ ); + //ŒJ‚è•Ô‚µˆ—‚ðI—¹‚·‚é + break; + } + //ŽŸ—v‘f‚Ì•¶Žš—ñ’· … 127 + else + { + //³‹K•\Œ»‚ÅURIihttp‚©‚çƒ|[ƒg‚Ü‚Å‚Ì•”•ª‚ð‘ΏۊOj‚̑Ó–«‚ðƒ`ƒFƒbƒN‚·‚é + //³‹K•\Œ»‚Í([^?#]*)(\?([^#]*))?(#(.*))?’Ê‚è + boost::regex uri(regex_match_str); + boost::cmatch what; + if (boost::regex_match(it->c_str(), what, uri)) + { + //ƒ`ƒFƒbƒNOK‚̏ꍇ + //sorryURIÝ’èƒtƒ‰ƒO‚ðON + sorryuri_checked = true; + } + //ƒ`ƒFƒbƒNNG‚̏ꍇ + else + { + std::ostringstream ostr; + ostr << "\"-S/--sorryURI\" option value '" + << *it << "' is not a valid URI."; + + //ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é + check_result.flag = false; + //ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚ðÝ’è‚·‚é + check_result.message = ostr.str(); + putLogError(0170000, check_result.message, + __FILE__, __LINE__ ); + //ŒJ‚è•Ô‚µˆ—‚ðI—¹‚·‚é + break; + } + } + } + //ŽŸ—v‘f‚ª‘¶Ý‚µ‚È‚¢ê‡ + else + { + //ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é + check_result.flag = false; + //ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚ðÝ’è‚·‚é + check_result.message + = "You have to set option value \"-S/--sorryURI\"."; + putLogError(0170000, check_result.message, __FILE__, + __LINE__ ); + //ŒJ‚è•Ô‚µˆ—‚ðI—¹‚·‚é + break; + } + } + //sorryURIÝ’èƒtƒ‰ƒO = ON + else + { + //ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é + check_result.flag = false; + //ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚ðÝ’è‚·‚é + check_result.message + = "Cannot set multiple option \"-S/--sorryURI\"."; + putLogError(0170000, check_result.message, __FILE__, + __LINE__ ); + //ŒJ‚è•Ô‚µˆ—‚ðI—¹‚·‚é + break; + } + } + //ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = ã‹LˆÈŠO + else + { + //ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é + check_result.flag = false; + //ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚ðÝ’è‚·‚é + check_result.message = "Option error."; + putLogError(0170000, check_result.message, __FILE__, __LINE__ ); + //ŒJ‚è•Ô‚µˆ—‚ðI—¹‚·‚é + break; + } + } + } catch (const std::exception& ex) + { + check_result.flag = false; + std::cerr << "check parameter exception: result=false, error=" + << ex.what() << "." << std::endl; + boost::format formatter( + "function protocol_module_sessionless::check_message_result " + "protocol_module_sessionless::check_parameter() exception: " + "result=false, error=%s."); + formatter % ex.what(); + putLogError(0170000, formatter.str(), __FILE__, __LINE__ ); + } catch (...) + { + check_result.flag = false; + std::cerr << "Unkown exception." << std::endl; + putLogError(0170000, + "function protocol_module_sessionless::check_message_result " + "protocol_module_sessionless::check_parameter() :" + "Unkown exception.", __FILE__, __LINE__ ); + } + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format + formatter( + "out_function: protocol_module_sessionless::check_message_result " + "protocol_module_sessionless::check_parameter(" + "const std::vector& args ): return_value=(" + "check_message_result.flag=%d, check_message_result.message=%s"); + formatter % check_result.flag % check_result.message; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + return check_result; +} + +/*! + *set_parameter + * + *@param [in] args + *@retval + */ +protocol_module_sessionless::check_message_result protocol_module_sessionless::set_parameter( + const std::vector& args) +{ + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format formatter( + "int_function: protocol_module_sessionless::check_message_result " + "protocol_module_sessionless::set_parameter(" + "const std::vector& args ): args=%s"); + std::string argsdump; + for (std::vector::const_iterator it = args.begin(); it + != args.end(); ++it) + { + argsdump += *it; + } + formatter % argsdump; + putLogDebug(010010, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + //TRUE + check_message_result check_result; + check_result.flag = true; + bool forward_checked = false; + bool sorryuri_checked = false; + const std::string regex_match_str = "([^?#]*)(\\?([^#]*))?(#(.*))?"; + + // + typedef std::vector::const_iterator vec_str_it; + vec_str_it it = args.begin(); + vec_str_it it_end = args.end(); + + //1 + forwarded_for = 1; + + try + { + for (; it != it_end; ++it) + { + // = "-F" + if (*it == "-F" || *it == "--forward-for") + { + //ON + forward_checked = true; + } + // = "-S" + else if (*it == "-S" || *it == "--sorryURI") + { + //sorryURI = OFF + if (!sorryuri_checked) + { + // + if (++it != it_end) + { + // 127 + if (it->size() > 127) + { + std::ostringstream ostr; + ostr << "\"-S/--sorryURI\" option value'" << *it + << "'is too long."; + + //FALSE + check_result.flag = false; + // + check_result.message = ostr.str(); + // + break; + } + // 127 + else + { + //URIhttp + //([^?#]*)(\?([^#]*))?(#(.*))? + boost::regex uri(regex_match_str); + boost::cmatch what; + if (boost::regex_match(it->c_str(), what, uri)) + { + //OK + //sorryURION + sorryuri_checked = true; + } + //NG + else + { + std::ostringstream ostr; + ostr << "\"-S/--sorryURI\" option value '" + << *it << "' is not a valid URI."; + + //FALSE + check_result.flag = false; + // + check_result.message = ostr.str(); + // + break; + } + } + } + // + else + { + //FALSE + check_result.flag = false; + // + check_result.message + = "You have to set option value \"-S/--sorryURI\"."; + // + break; + } + } + //sorryURI = ON + else + { + //FALSE + check_result.flag = false; + // + check_result.message + = "Cannot set multiple option \"-S/--sorryURI\"."; + // + break; + } + } + // = + else + { + //FALSE + check_result.flag = false; + // + check_result.message = "Option error."; + // + break; + } + } + + if (check_result.flag == true) + { + // = OFF + if (!forward_checked) + { + //0 + forwarded_for = 0; + } + } + + } catch (const std::exception& ex) + { + check_result.flag = false; + std::cerr << "set parameter exception: result=false, error=" + << ex.what() << "." << std::endl; + boost::format formatter( + "function protocol_module_sessionless::check_message_result " + "protocol_module_sessionless::set_parameter() exception: " + "result=false, error=%s."); + formatter % ex.what(); + putLogError(0170000, formatter.str(), __FILE__, __LINE__ ); + } catch (...) + { + check_result.flag = false; + std::cerr << "Unkown exception." << std::endl; + putLogError(0170000, + "function protocol_module_sessionless::check_message_result " + "protocol_module_sessionless::set_parameter() :" + "Unkown exception.", __FILE__, __LINE__ ); + } + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format + formatter( + "out_function: protocol_module_sessionless::check_message_result " + "protocol_module_sessionless::set_parameter(" + "const std::vector& args ): return_value=(" + "check_message_result.flag=%d, check_message_result.message=%s"); + formatter % check_result.flag % check_result.message; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + + return check_result; + +} + +/*! + *add_parameter + * + *@param [in] args + *@retval + */ +protocol_module_sessionless::check_message_result protocol_module_sessionless::add_parameter( + const std::vector& args) +{ + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format formatter( + "in_function: protocol_module_sessionless::check_message_result " + "protocol_module_sessionless::add_parameter(" + "const std::vector& args ): args=%s"); + std::string argsdump; + for (std::vector::const_iterator it = args.begin(); it + != args.end(); ++it) + { + argsdump += *it; + } + formatter % argsdump; + putLogDebug(010010, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + check_message_result check_result; + //TRUE + check_result.flag = true; + + // + if (!args.empty()) + { + //FALSE + check_result.flag = false; + // + check_result.message = "Cannot add option."; + } + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format + formatter( + "out_function: protocol_module_sessionless::add_parameter " + "protocol_module_sessionless::set_parameter(" + "const std::vector& args ): return_value=(" + "check_message_result.flag=%d, check_message_result.message=%s"); + formatter % check_result.flag % check_result.message; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + + return check_result; +} + +/*! + *handle_rslist_update + * + */ +void protocol_module_sessionless::handle_rslist_update() +{ +} + +/*! + *register_schedule + * + *@param [in] inschedule + *@retval + */ +void protocol_module_sessionless::register_schedule( + tcp_schedule_func_type inschedule) +{ + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + putLogDebug(010005, + "in_function: void protocol_module_sessionless::register_schedule( " + "tcp_schedule_func_type inschedule )", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + schedule_tcp = inschedule; + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + putLogDebug(010005, + "out_function: void protocol_module_sessionless::register_schedule( " + "tcp_schedule_func_type inschedule )", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ +} + +/*! + *register_schedule + * + *@param [in] inschedule + *@retval + */ +void protocol_module_sessionless::register_schedule( + udp_schedule_func_type inschedule) +{ + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + putLogDebug(010002, + "in/out_function:void protocol_module_sessionless::register_schedule(): " + "return_value=void", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ +} + +/*! + *handle_session_initialize + * + *@param [in] up_thread_id + *@param [in] down_thread_id + *@retval + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_session_initialize( + const boost::thread::id up_thread_id, + const boost::thread::id down_thread_id) +{ + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format + formatter( + "in_function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_session_initialize( const boost::thread::id up_thread_id, " + "const boost::thread::id down_thread_id ): " + "up_thread_id=%d, down_thread_id=%d"); + formatter % up_thread_id % down_thread_id; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + session_thread_data_sessionless* p_up = NULL; + session_thread_data_sessionless* p_down = NULL; + + //ƒZƒbƒVƒ‡ƒ“ƒXƒŒƒbƒh‚ɑΉž‚·‚鏉Šúˆ—‚ðs‚¤ + try + { + p_up = new session_thread_data_sessionless; + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format formatter("new: address=&(%d), size=%lu"); + formatter % &p_up % sizeof(session_thread_data_sessionless); + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + p_up->thread_id = up_thread_id; + p_up->thread_division = THREAD_DIVISION_UP_STREAM; + p_up->pair_thread_id = down_thread_id; + p_up->accept_end_flag = ACCEPT_END_FLAG_OFF; + p_up->end_flag = END_FLAG_OFF; + p_up->sorry_flag = SORRY_FLAG_OFF; + p_up->sorryserver_switch_flag = SORRYSERVER_SWITCH_FLAG_OFF; + p_up->realserver_switch_flag = REALSERVER_SWITCH_FLAG_OFF; + p_up->last_status = INITIALIZE; + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + // data dump + boost::format + formatter( + "function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_session_initialize() : session_thread_data_sslid(upthread) : " + "thread_id=%d, thread_division=%d, " + "pair_thread_id=%d, accept_end_flag=%d, end_flag=%d," + "sorry_flag=%d, sorryserver_switch_flag=%d, realserver_switch_flag=%d, last_status=%d."); + formatter % p_up->thread_id % p_up->thread_division + % p_up->pair_thread_id % p_up->accept_end_flag + % p_up->end_flag % p_up->sorry_flag + % p_up->sorryserver_switch_flag + % p_up->realserver_switch_flag % p_up->last_status; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + p_down = new session_thread_data_sessionless; + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format formatter("new: address=&(%d), size=%lu"); + formatter % &p_down % sizeof(session_thread_data_sessionless); + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + p_down->thread_id = down_thread_id; + p_down->thread_division = THREAD_DIVISION_DOWN_STREAM; + p_down->pair_thread_id = up_thread_id; + p_down->accept_end_flag = ACCEPT_END_FLAG_OFF; + p_down->end_flag = END_FLAG_OFF; + p_down->sorry_flag = SORRY_FLAG_OFF; + p_down->sorryserver_switch_flag = SORRYSERVER_SWITCH_FLAG_OFF; + p_down->realserver_switch_flag = REALSERVER_SWITCH_FLAG_OFF; + p_down->last_status = INITIALIZE; + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + // data dump + boost::format + formatter( + "function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_session_initialize() : session_thread_data_sslid(down_thread_id) : " + "accept_end_flag=%d, end_flag=%d, " + "pair_thread_id=%d, realserver_switch_flag=%d, sorry_flag=%d," + "thread_division=%d, thread_id=%d, last_status=%d."); + formatter % p_down->thread_id % p_down->thread_division + % p_down->pair_thread_id % p_down->accept_end_flag + % p_down->end_flag % p_down->sorry_flag + % p_down->sorryserver_switch_flag + % p_down->realserver_switch_flag % p_down->last_status; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + } catch (const std::bad_alloc& ex) + { + std::cerr + << "handle_session_initialize exception: Could not allocate memory." + << std::endl; + putLogError(017000, "Could not allocate memory.", __FILE__, __LINE__ ); + return FINALIZE; + } + + try + { + boost::mutex::scoped_lock slock(session_thread_data_map_mutex); + session_thread_data_map[up_thread_id] = p_up; + session_thread_data_map[down_thread_id] = p_down; + } catch (const std::exception& ex) + { + std::cerr << "handle_session_initialize exception: error=%s" + << ex.what() << "." << std::endl; + boost::format + formatter( + "function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_session_initialize() exception: result=%d, error=%s."); + formatter % ex.what(); + putLogError(0170000, formatter.str(), __FILE__, __LINE__ ); + return FINALIZE; + } catch (...) + { + std::cerr << "Unkown exception." << std::endl; + putLogError(0170000, + "function protocol_module_sessionless::check_message_result " + "protocol_module_sessionless::handle_session_initialize() : " + "Unkown exception.", __FILE__, __LINE__ ); + + return FINALIZE; + } + + return ACCEPT; +} +/*! + *handle_session_finalize + * + *@param [in] up_thread_id + *@param [in] down_thread_id + *@retval + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_session_finalize( + const boost::thread::id up_thread_id, + const boost::thread::id down_thread_id) +{ + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format + formatter( + "in_function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_session_finalize( const boost::thread::id up_thread_id, " + "const boost::thread::id down_thread_id ): " + "up_thread_id=%d, down_thread_id=%d"); + formatter % up_thread_id % down_thread_id; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + session_thread_data_sessionless* p_up = NULL; + session_thread_data_sessionless* p_down = NULL; + boost::asio::ip::tcp::endpoint endpoint; + //ƒZƒbƒVƒ‡ƒ“ƒXƒŒƒbƒh‚ɑΉž‚·‚éI—¹ˆ—‚ðs‚¤ + try + { + boost::mutex::scoped_lock slock(session_thread_data_map_mutex); + if (session_thread_data_map.find(up_thread_id) + != session_thread_data_map.end()) + { + p_up = session_thread_data_map[up_thread_id]; + if (p_up->recive_data_map.find(endpoint) + != p_up->recive_data_map.end()) + { + char*& recive_buffer = + p_up->recive_data_map[endpoint].recive_buffer; + if (recive_buffer != NULL) + { + if (recive_buffer + == p_up->recive_data_map[endpoint].recive_buffer1) + { + if (p_up->recive_data_map[endpoint].recive_buffer2 + != NULL) + { + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format + formatter("delete: address=&(%d)"); + formatter + % p_up->recive_data_map[endpoint].recive_buffer2; + putLogDebug(010005, formatter.str(), __FILE__, + __LINE__ ); + } + /*------DEBUG LOG END------*/ + delete[] p_up->recive_data_map[endpoint].recive_buffer2; + p_up->recive_data_map[endpoint].recive_buffer2 + = NULL; + } + p_up->recive_data_map[endpoint].recive_buffer1 = NULL; + } + else + { + if (p_up->recive_data_map[endpoint].recive_buffer1 + != NULL) + { + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format + formatter("delete: address=&(%d)"); + formatter + % p_up->recive_data_map[endpoint].recive_buffer1; + putLogDebug(010005, formatter.str(), __FILE__, + __LINE__ ); + } + /*------DEBUG LOG END------*/ + delete[] p_up->recive_data_map[endpoint].recive_buffer1; + p_up->recive_data_map[endpoint].recive_buffer1 + = NULL; + } + p_up->recive_data_map[endpoint].recive_buffer2 = NULL; + } + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format formatter("delete: address=&(%d)"); + formatter % recive_buffer; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + delete[] recive_buffer; + recive_buffer = NULL; + } + } + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format formatter("delete: address=&(%d)"); + formatter % p_up; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + delete p_up; + session_thread_data_map.erase(up_thread_id); + } + + if (session_thread_data_map.find(down_thread_id) + != session_thread_data_map.end()) + { + p_down = session_thread_data_map[down_thread_id]; + if (p_down->recive_data_map.find(p_down->endpoint) + != p_up->recive_data_map.end()) + { + char*& recive_buffer = + p_down->recive_data_map[p_down->endpoint].recive_buffer; + if (recive_buffer != NULL) + { + if (recive_buffer + == p_down->recive_data_map[p_down->endpoint].recive_buffer1) + { + if (p_down->recive_data_map[p_down->endpoint].recive_buffer2 + != NULL) + { + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format + formatter("delete: address=&(%d)"); + formatter + % p_down->recive_data_map[p_down->endpoint].recive_buffer2; + putLogDebug(010005, formatter.str(), __FILE__, + __LINE__ ); + } + /*------DEBUG LOG END------*/ + delete[] p_down->recive_data_map[p_down->endpoint].recive_buffer2; + p_down->recive_data_map[p_down->endpoint].recive_buffer2 + = NULL; + } + p_down->recive_data_map[p_down->endpoint].recive_buffer1 + = NULL; + } + else + { + if (p_down->recive_data_map[p_down->endpoint].recive_buffer1 + != NULL) + { + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format + formatter("delete: address=&(%d)"); + formatter + % p_down->recive_data_map[p_down->endpoint].recive_buffer1; + putLogDebug(010005, formatter.str(), __FILE__, + __LINE__ ); + } + /*------DEBUG LOG END------*/ + delete[] p_down->recive_data_map[p_down->endpoint].recive_buffer1; + p_down->recive_data_map[p_down->endpoint].recive_buffer1 + = NULL; + } + p_down->recive_data_map[p_down->endpoint].recive_buffer2 + = NULL; + } + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format formatter("delete: address=&(%d)"); + formatter % recive_buffer; + putLogDebug(010005, formatter.str(), __FILE__, + __LINE__ ); + } + /*------DEBUG LOG END------*/ + delete[] recive_buffer; + recive_buffer = NULL; + } + } + + p_down = session_thread_data_map[down_thread_id]; + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format formatter("delete: address=&(%d)"); + formatter % p_down; + putLogDebug(010005, formatter.str(), __FILE__, + __LINE__ ); + } + /*------DEBUG LOG END------*/ + delete p_down; + session_thread_data_map.erase(down_thread_id); + } + } catch (const std::exception& ex) + { + std::cerr << "handle_session_finalize exception: error=%s" << ex.what() + << "." << std::endl; + boost::format + formatter( + "function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_session_finalize() exception: result=%d, error=%s."); + formatter % STOP % ex.what(); + putLogError(0170000, formatter.str(), __FILE__, __LINE__ ); + } catch (...) + { + std::cerr << "Unkown exception." << std::endl; + boost::format + formatter( + "function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_session_finalize() exception: result=%d."); + formatter % STOP; + putLogError(0170000, formatter.str(), __FILE__, __LINE__ ); + } + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format + formatter( + "out_function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_session_finalize( const boost::thread::id up_thread_id," + "const boost::thread::id down_thread_id ): return_value=%d"); + formatter % STOP; + putLogDebug(030005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + return STOP; +} + +/*! + *handle_accept + * + *@param [in] thread_id + *@retval + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_accept( + const boost::thread::id thread_id) +{ + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format + formatter( + "in_function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_accept( const boost::thread::id thread_id ): thread_id=%d"); + formatter % thread_id; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + EVENT_TAG status; + session_thread_data_sessionless* session_data = NULL; + + try + { + boost::mutex::scoped_lock slock(session_thread_data_map_mutex); + if (session_thread_data_map.find(thread_id) + == session_thread_data_map.end()) + { + putLogError(0170000, "Invalid thread id.", __FILE__, __LINE__ ); + return FINALIZE; + } + + session_data = session_thread_data_map[thread_id]; + + if (session_data == NULL) + { + putLogError(0170000, "Invalid thread id.", __FILE__, __LINE__ ); + return FINALIZE; + } + + } catch (const std::exception& ex) + { + std::cerr << "handle_accept exception: error=%s" << ex.what() << "." + << std::endl; + boost::format + formatter( + "function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_accept() exception: result=%d, error=%s."); + formatter % FINALIZE % ex.what(); + putLogError(0170000, formatter.str(), __FILE__, __LINE__ ); + + status = FINALIZE; + } catch (...) + { + std::cerr << "Unkown exception." << std::endl; + putLogError(0170000, + "function protocol_module_sessionless::check_message_result " + "protocol_module_sessionless::handle_accept() : " + "Unkown exception.", __FILE__, __LINE__ ); + status = FINALIZE; + } + + //acceptŠ®—¹ƒtƒ‰ƒO‚ðON + session_data->accept_end_flag = ACCEPT_END_FLAG_ON; + + //sorryó‘Ԃ̏ꍇ + if (session_data->sorry_flag == SORRY_FLAG_ON) + { + //‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é + status = SORRYSERVER_SELECT; + } + //sorryó‘ԈȊO‚̏ꍇ + else + { + //‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é + status = REALSERVER_SELECT; + } + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format + formatter( + "out_function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_accept( const boost::thread::id thread_id ): return_value=%d."); + formatter % status; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + return status; +} + +/*! + *handle_client_recv + * + *@param [in] thread_id + *@param [in] recvbuffer + *@param [in] recvlen + *@retval + */ +protocol_module_base::EVENT_TAG protocol_module_sessionless::handle_client_recv( + const boost::thread::id thread_id, const boost::array& recvbuffer, const size_t recvlen) +{ + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format + formatter( + "in_function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_client_recv( const boost::thread::id thread_id," + "const boost::array& recvbuffer," + "const size_t recvlen ): thread_id=%d, recvbuffer=%s, recvlen=%d"); + formatter % thread_id % recvbuffer.data() % recvlen; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + EVENT_TAG status; + typedef std::vector + send_end_it_vec; + send_end_it_vec send_end_vec; + boost::asio::ip::tcp::endpoint endpoint; + int data_remain_start = 0; //–¢‘—Mƒf[ƒ^ŠJŽnˆÊ’u + int data_remain_size = 0; //–¢‘—Mƒf[ƒ^ƒTƒCƒY + int request_data_size = 0; //ƒŠƒNƒGƒXƒgƒf[ƒ^ƒTƒCƒY + int request_data_remain_size = 0; //ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY + bool bret = false; + CHECK_RESULT_TAG check_result; //ƒ`ƒFƒbƒNŒ‹‰Ê + size_t header_offset = 0; + size_t header_offset_len = 0; + size_t count_length_header_value = 0; + size_t value = 0; + std::string str_value; + const std::string http_header = ""; + const std::string content_header = "Content-Length"; + session_thread_data_sessionless* session_data = NULL; + + request_data_size = recvlen; + char* buffer1 = NULL; + char* buffer2 = NULL; + size_t count = 0; + + //ƒpƒ‰ƒ[ƒ^ƒ`ƒFƒbƒN + if (recvlen > recvbuffer.size()) + { + putLogError(0170000, "Data size bigger than buffer size.", __FILE__, + __LINE__ ); + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format + formatter( + "out_function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_client_recv( const boost::thread::id thread_id," + "const boost::array& recvbuffer," + "const size_t recvlen ): return_value=%d"); + formatter % FINALIZE; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + return FINALIZE; + } + + try + { + { + boost::mutex::scoped_lock slock(session_thread_data_map_mutex); + + if (session_thread_data_map.find(thread_id) + == session_thread_data_map.end()) + { + putLogError(0170000, "Invalid thread id.", __FILE__, __LINE__ ); + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format + formatter( + "out_function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_client_recv( const boost::thread::id thread_id," + "const boost::array& recvbuffer," + "const size_t recvlen ): return_value=%d"); + formatter % FINALIZE; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + return FINALIZE; + } + + session_data = session_thread_data_map[thread_id]; + if (session_data == NULL) + { + putLogError(0170000, "Invalid thread id.", __FILE__, __LINE__ ); + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format + formatter( + "out_function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_client_recv( const boost::thread::id thread_id," + "const boost::array& recvbuffer," + "const size_t recvlen ): return_value=%d"); + formatter % FINALIZE; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + return FINALIZE; + } + } + + //I—¹ƒtƒ‰ƒO‚ªON‚̏ꍇ + if (session_data->end_flag == END_FLAG_ON) + { + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format + formatter( + "out_function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_client_recv( const boost::thread::id thread_id," + "const boost::array& recvbuffer," + "const size_t recvlen ): return_value=%d"); + formatter % CLIENT_RECV; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + return CLIENT_RECV; + } + + //I—¹ƒtƒ‰ƒO‚ªOFF‚̏ꍇ + if (session_data->recive_data_map.find(endpoint) + == session_data->recive_data_map.end()) + { + putLogError(0170000, "Invalid endpoint.", __FILE__, __LINE__ ); + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format + formatter( + "out_function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_client_recv( const boost::thread::id thread_id," + "const boost::array& recvbuffer," + "const size_t recvlen ): return_value=%d"); + formatter % FINALIZE; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + return FINALIZE; + } + + recive_data& recv_data = session_data->recive_data_map[endpoint]; + + send_status_it it = recv_data.send_status_list.begin(); + send_status_it it_end = recv_data.send_status_list.end(); + + count = std::count_if(it, it_end, has_send_continue_data()); + if (count >= 2) + { + putLogError(0170000, "send continue data >= 2.", __FILE__, __LINE__ ); + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format + formatter( + "out_function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_client_recv( const boost::thread::id thread_id," + "const boost::array& recvbuffer," + "const size_t recvlen ): return_value=%d"); + formatter % FINALIZE; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + return FINALIZE; + } + + count = std::count_if(it, it_end, has_send_ng_data()); + if (count >= 2) + { + putLogError(0170000, "send ng data >= 2.", __FILE__, __LINE__ ); + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format + formatter( + "out_function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_client_recv( const boost::thread::id thread_id," + "const boost::array& recvbuffer," + "const size_t recvlen ): return_value=%d"); + formatter % FINALIZE; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + return FINALIZE; + } + + //‘—Mó‘ÔƒŠƒXƒg‚Ì—v‘f”•ªŒJ‚è•Ô‚µ + for (; it != it_end; ++it) + { + //‘—Mó‘Ô‚ª‘—MÏ‚̏ꍇ + if (it->status == SEND_END) + { + //‘—Mó‘ÔƒŠƒXƒg‚©‚çíœ‚·‚é + send_end_vec.push_back(it); + } + else if (it->status == SEND_CONTINUE) //‘—Mó‘Ô‚ª‘—MŒp‘±‚̏ꍇ + { + //‘—Mƒf[ƒ^ƒIƒtƒZƒbƒg‚É‘—MÏƒTƒCƒY‚ð‰ÁŽZ‚·‚é + it->send_offset += it->send_end_size; + //–¢‘—Mƒf[ƒ^ŠJŽnˆÊ’u‚É‘—Mƒf[ƒ^ƒIƒtƒZƒbƒg‚ðÝ’è‚·‚é + data_remain_start = it->send_offset; + //ŒJ‚è•Ô‚µˆ—‚ðI—¹‚·‚é + break; + } + else + { //‘—Mó‘Ô‚ª‘—MÏˆÈŠO‚̏ꍇ + //–¢‘—Mƒf[ƒ^ŠJŽnˆÊ’u‚É‘—Mƒf[ƒ^ƒIƒtƒZƒbƒg‚ðÝ’è‚·‚é + data_remain_start = it->send_offset; + //–¢‘—Mƒf[ƒ^ƒTƒCƒY‚É–¢‘—Mƒf[ƒ^ƒTƒCƒY‚ðÝ’è‚·‚é + data_remain_size = it->unsend_size; + //ŒJ‚è•Ô‚µˆ—‚ðI—¹‚·‚é + break; + } + } + + for (send_end_it_vec::iterator it = send_end_vec.begin(); it + != send_end_vec.end(); ++it) + { + //‘—Mó‘ÔƒŠƒXƒg‚©‚çíœ‚·‚é + recv_data.send_status_list.erase(*it); + } + + //ƒf[ƒ^ƒoƒbƒtƒ@ŽcƒTƒCƒY@ƒ@ƒŠƒNƒGƒXƒgƒf[ƒ^ƒTƒCƒY + if (recv_data.recive_buffer_rest_size < request_data_size) + { + //ƒf[ƒ^ƒoƒbƒtƒ@MAXƒTƒCƒY@ƒ@–¢‘—Mƒf[ƒ^ƒTƒCƒY@{@ƒŠƒNƒGƒXƒgƒf[ƒ^ƒTƒCƒY + if (recv_data.recive_buffer_max_size < data_remain_size + + request_data_size) + { + if (recv_data.recive_buffer == NULL) + { + //ƒf[ƒ^ƒoƒbƒtƒ@‚P‚ðMAX_BUFFER_SIZE•ªA + //V‹K‚ÉŠm•Û‚µA‰Šú‰»‚·‚é + recv_data.recive_buffer1 = new char[MAX_BUFFER_SIZE]; + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format formatter("new: address=&(%d), size=%lu"); + formatter % &recv_data.recive_buffer1 + % (MAX_BUFFER_SIZE); + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*-------- DEBUG LOG --------*/ + memset(recv_data.recive_buffer1, 0, MAX_BUFFER_SIZE); + //ƒf[ƒ^ƒoƒbƒtƒ@‚Q‚ðMAX_BUFFER_SIZE•ªA + //V‹K‚ÉŠm•Û‚µA‰Šú‰»‚·‚é + recv_data.recive_buffer2 = new char[MAX_BUFFER_SIZE]; + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format formatter("new: address=&(%d), size=%lu"); + formatter % &recv_data.recive_buffer2 + % (MAX_BUFFER_SIZE); + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*-------- DEBUG LOG --------*/ + memset(recv_data.recive_buffer2, 0, MAX_BUFFER_SIZE); + recv_data.recive_buffer = recv_data.recive_buffer1; + //ƒf[ƒ^ƒoƒbƒtƒ@MAXƒTƒCƒY‚ÉMAX_BUFFER_SIZE‚ðÝ’è‚·‚é + recv_data.recive_buffer_max_size = MAX_BUFFER_SIZE; + } + else + { + //ƒf[ƒ^ƒoƒbƒtƒ@‚P‚ðu–¢‘—Mƒf[ƒ^ƒTƒCƒY@{@ƒŠƒNƒGƒXƒgƒf[ƒ^ƒTƒCƒYv•ªA + //V‹K‚ÉŠm•Û‚µA‰Šú‰»‚·‚é + buffer1 = new char[data_remain_size + request_data_size]; + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format formatter("new: address=&(%d), size=%lu"); + formatter % &buffer1 % (data_remain_size + + request_data_size); + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*-------- DEBUG LOG --------*/ + memset(buffer1, 0, data_remain_size + request_data_size); + //ƒf[ƒ^ƒoƒbƒtƒ@‚Q‚ðu–¢‘—Mƒf[ƒ^ƒTƒCƒY@{@ƒŠƒNƒGƒXƒgƒf[ƒ^ƒTƒCƒYv•ªA + //V‹K‚ÉŠm•Û‚µA‰Šú‰»‚·‚é + buffer2 = new char[data_remain_size + request_data_size]; + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format formatter("new: address=&(%d), size=%lu"); + formatter % &buffer2 % (data_remain_size + + request_data_size); + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*-------- DEBUG LOG --------*/ + memset(buffer2, 0, data_remain_size + request_data_size); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format formatter("%02x"); + for (int i = 0; i < data_remain_size + + request_data_size; ++i) + { + formatter + % static_cast (static_cast (buffer1[i])); + } + + std::string datadump = formatter.str(); + formatter.parse( + "function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_client_recv( ): before memcpy (data dump): " + "data begin(%d), data_size=%d,data=%s."); + formatter % buffer1 % (data_remain_size + + request_data_size) % datadump; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + //ƒf[ƒ^ƒoƒbƒtƒ@‚P‚ÉŽg—p’†ƒf[ƒ^ƒoƒbƒtƒ@‚Ì–¢‘—Mƒf[ƒ^ŠJŽnˆÊ’u‚©‚ç–¢‘—Mƒf[ƒ^ƒTƒCƒY•ªÝ’è‚·‚é + memcpy(buffer1, + recv_data.recive_buffer + data_remain_start, + data_remain_size); + //ƒf[ƒ^ƒoƒbƒtƒ@‚P‚ɃŠƒNƒGƒXƒgƒf[ƒ^‚ðƒTƒCƒY•ª’ljÁÝ’è‚·‚é + memcpy(buffer1 + data_remain_size, recvbuffer.data(), + request_data_size); + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format formatter("%02x"); + for (int i = 0; i < data_remain_size + + request_data_size; ++i) + { + formatter + % static_cast (static_cast (buffer2[i])); + } + + std::string datadump = formatter.str(); + formatter.parse( + "function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_client_recv( ): after memcpy (data dump): " + "data begin(%d), data_size=%d,data=%s."); + formatter % buffer2 % (data_remain_size + + request_data_size) % datadump; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + //‹Œƒf[ƒ^ƒoƒbƒtƒ@‚PA‹Œƒf[ƒ^ƒoƒbƒtƒ@‚Q‚ð‰ð•ú‚·‚é + if (recv_data.recive_buffer1 != NULL) + { + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format formatter("delete: address=&(%d)"); + formatter % recv_data.recive_buffer1; + putLogDebug(010005, formatter.str(), __FILE__, + __LINE__ ); + } + /*------DEBUG LOG END------*/ + delete[] recv_data.recive_buffer1; + recv_data.recive_buffer1 = NULL; + } + + if (recv_data.recive_buffer2 != NULL) + { + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format formatter("delete: address=&(%d)"); + formatter % recv_data.recive_buffer2; + putLogDebug(010005, formatter.str(), __FILE__, + __LINE__ ); + } + /*------DEBUG LOG END------*/ + delete[] recv_data.recive_buffer2; + recv_data.recive_buffer2 = NULL; + } + + //Žg—p’†ƒf[ƒ^ƒoƒbƒtƒ@‚Ƀf[ƒ^ƒoƒbƒtƒ@‚P‚ðÝ’è‚·‚é + recv_data.recive_buffer1 = buffer1; + recv_data.recive_buffer2 = buffer2; + recv_data.recive_buffer = recv_data.recive_buffer1; + //ƒf[ƒ^ƒoƒbƒtƒ@MAXƒTƒCƒY‚Ɂu–¢‘—Mƒf[ƒ^ƒTƒCƒY@{@ƒŠƒNƒGƒXƒgƒf[ƒ^ƒTƒCƒYv‚ðÝ’è‚·‚é + recv_data.recive_buffer_max_size = data_remain_size + + request_data_size; + } + } + //ƒf[ƒ^ƒoƒbƒtƒ@MAXƒTƒCƒY@†@–¢‘—Mƒf[ƒ^ƒTƒCƒY@{@ƒŠƒNƒGƒXƒgƒf[ƒ^ƒTƒCƒY + else + { + if (recv_data.recive_buffer1 == NULL + || recv_data.recive_buffer2 == NULL) + { + putLogError(0170000, "Invalid pointer.", __FILE__, __LINE__ ); + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format + formatter( + "out_function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_client_recv( const boost::thread::id thread_id," + "const boost::array& recvbuffer," + "const size_t recvlen ): return_value=%d"); + formatter % FINALIZE; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + return FINALIZE; + } + //Žg—p’†ƒf[ƒ^ƒoƒbƒtƒ@‚ªƒf[ƒ^ƒoƒbƒtƒ@‚P‚̏ꍇ + if (recv_data.recive_buffer == recv_data.recive_buffer1) + { + //ƒf[ƒ^ƒoƒbƒtƒ@‚Q‚ð‰Šú‰»‚·‚é + memset(recv_data.recive_buffer2, 0, + recv_data.recive_buffer_max_size); + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format formatter("%02x"); + for (int i = 0; i < recv_data.recive_buffer_max_size; ++i) + { + formatter + % static_cast (static_cast (recv_data.recive_buffer2[i])); + } + + std::string datadump = formatter.str(); + formatter.parse( + "function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_client_recv( ): before memcpy (data dump): " + "data begin(%d), data_size=%d,data=%s."); + formatter % recv_data.recive_buffer2 + % recv_data.recive_buffer_max_size % datadump; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + //ƒf[ƒ^ƒoƒbƒtƒ@‚Q‚ÉŽg—p’†ƒf[ƒ^ƒoƒbƒtƒ@‚Ì–¢‘—Mƒf[ƒ^ŠJŽnˆÊ’u‚©‚ç–¢‘—Mƒf[ƒ^ƒTƒCƒY•ªÝ’è‚·‚é + memcpy(recv_data.recive_buffer2, recv_data.recive_buffer + + data_remain_start, data_remain_size); + //ƒf[ƒ^ƒoƒbƒtƒ@‚Q‚ɃŠƒNƒGƒXƒgƒf[ƒ^‚ðƒTƒCƒY•ª’ljÁÝ’è‚·‚é + memcpy(recv_data.recive_buffer2 + data_remain_size, + recvbuffer.data(), request_data_size); + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format formatter("%02x"); + for (int i = 0; i < recv_data.recive_buffer_max_size; ++i) + { + formatter + % static_cast (static_cast (recv_data.recive_buffer2[i])); + } + + std::string datadump = formatter.str(); + formatter.parse( + "function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_client_recv( ): after memcpy (data dump): " + "data begin(%d), data_size=%d,data=%s."); + formatter % recv_data.recive_buffer2 + % recv_data.recive_buffer_max_size % datadump; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + //Žg—p’†ƒf[ƒ^ƒoƒbƒtƒ@‚Ƀf[ƒ^ƒoƒbƒtƒ@‚Q‚ðÝ’è‚·‚é + recv_data.recive_buffer = recv_data.recive_buffer2; + } + //Žg—p’†ƒf[ƒ^ƒoƒbƒtƒ@‚ªƒf[ƒ^ƒoƒbƒtƒ@‚Q‚̏ꍇ + else + { + //ƒf[ƒ^ƒoƒbƒtƒ@‚P‚ð‰Šú‰»‚·‚é + memset(recv_data.recive_buffer1, 0, + recv_data.recive_buffer_max_size); + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format formatter("%02x"); + for (int i = 0; i < recv_data.recive_buffer_max_size; ++i) + { + formatter + % static_cast (static_cast (recv_data.recive_buffer1[i])); + } + + std::string datadump = formatter.str(); + formatter.parse( + "function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_client_recv( ): before memcpy (data dump): " + "data begin(%d), data_size=%d,data=%s."); + formatter % recv_data.recive_buffer1 + % recv_data.recive_buffer_max_size % datadump; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + //ƒf[ƒ^ƒoƒbƒtƒ@‚P‚ÉŽg—p’†ƒf[ƒ^ƒoƒbƒtƒ@‚Ì–¢‘—Mƒf[ƒ^ŠJŽnˆÊ’u‚©‚ç–¢‘—Mƒf[ƒ^ƒTƒCƒY•ªÝ’è‚·‚é + memcpy(recv_data.recive_buffer1, recv_data.recive_buffer + + data_remain_start, data_remain_size); + //ƒf[ƒ^ƒoƒbƒtƒ@‚P‚ɃŠƒNƒGƒXƒgƒf[ƒ^‚ðƒTƒCƒY•ª’ljÁÝ’è‚·‚é + memcpy(recv_data.recive_buffer1 + data_remain_size, + recvbuffer.data(), request_data_size); + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format formatter("%02x"); + for (int i = 0; i < recv_data.recive_buffer_max_size; ++i) + { + formatter + % static_cast (static_cast (recv_data.recive_buffer1[i])); + } + + std::string datadump = formatter.str(); + formatter.parse( + "function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_client_recv( ): after memcpy (data dump): " + "data begin(%d), data_size=%d,data=%s."); + formatter % recv_data.recive_buffer1 + % recv_data.recive_buffer_max_size % datadump; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + //Žg—p’†ƒf[ƒ^ƒoƒbƒtƒ@‚Ƀf[ƒ^ƒoƒbƒtƒ@‚P‚ðÝ’è‚·‚é + recv_data.recive_buffer = recv_data.recive_buffer1; + } + } + + //ƒf[ƒ^ƒoƒbƒtƒ@ŽcƒTƒCƒY‚É + //uƒf[ƒ^ƒoƒbƒtƒ@MAXƒTƒCƒY@|@–¢‘—Mƒf[ƒ^ƒTƒCƒY@|@ƒŠƒNƒGƒXƒgƒf[ƒ^ƒTƒCƒYv‚ðÝ’è‚·‚é + recv_data.recive_buffer_rest_size + = recv_data.recive_buffer_max_size - data_remain_size + - request_data_size; + + //–¢‘—Mƒf[ƒ^ƒTƒCƒY‚Ɂu–¢‘—Mƒf[ƒ^ƒTƒCƒY@{@ƒŠƒNƒGƒXƒgƒf[ƒ^ƒTƒCƒYv‚ðÝ’è‚·‚é + data_remain_size += request_data_size; + + send_status_it it_begin = recv_data.send_status_list.begin(); + send_status_it it_end = recv_data.send_status_list.end(); + + for (; it_begin != it_end; ++it_begin) + { + //‘—Mƒf[ƒ^ƒIƒtƒZƒbƒg‚©‚ç–¢‘—Mƒf[ƒ^ŠJŽnˆÊ’u‚ðŒ¸ŽZ + it->send_offset -= data_remain_start; + } + } + //ƒf[ƒ^ƒoƒbƒtƒ@ŽcƒTƒCƒY@†@ƒŠƒNƒGƒXƒgƒf[ƒ^ƒTƒCƒY + else + { + if (recv_data.recive_buffer == NULL) + { + putLogError(0170000, "Invalid thread id.", __FILE__, __LINE__ ); + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format + formatter( + "out_function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_client_recv( const boost::thread::id thread_id," + "const boost::array& recvbuffer," + "const size_t recvlen ): return_value=%d"); + formatter % FINALIZE; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + return FINALIZE; + } + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format formatter("%02x"); + for (int i = 0; i < recv_data.recive_buffer_max_size; ++i) + { + formatter + % static_cast (static_cast (recv_data.recive_buffer1[i])); + } + + std::string datadump = formatter.str(); + formatter.parse( + "function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_client_recv( ): before memcpy (data dump): " + "data begin(%d), data_size=%d,data=%s."); + formatter % recv_data.recive_buffer1 + % recv_data.recive_buffer_max_size % datadump; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + //Žg—p’†ƒf[ƒ^ƒoƒbƒtƒ@‚ɃŠƒNƒGƒXƒgƒf[ƒ^‚ðƒTƒCƒY•ª’ljÁÝ’è‚·‚é + memcpy(recv_data.recive_buffer + recv_data.recive_buffer_max_size + - recv_data.recive_buffer_rest_size, recvbuffer.data(), + request_data_size); + //ƒf[ƒ^ƒoƒbƒtƒ@ŽcƒTƒCƒY‚©‚烊ƒNƒGƒXƒgƒf[ƒ^ƒTƒCƒY‚ðŒ¸ŽZ‚·‚é + recv_data.recive_buffer_rest_size -= request_data_size; + //–¢‘—Mƒf[ƒ^ƒTƒCƒY‚Ɂu–¢‘—Mƒf[ƒ^ƒTƒCƒY@{@ƒŠƒNƒGƒXƒgƒf[ƒ^ƒTƒCƒYv‚ðÝ’è‚·‚é + data_remain_size += request_data_size; + } + + it = recv_data.send_status_list.begin(); + it_end = recv_data.send_status_list.end(); + + for (; it != it_end; ++it) + { + //ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚ɃŠƒNƒGƒXƒgƒf[ƒ^ƒTƒCƒY‚ðÝ’è‚·‚é + request_data_remain_size = request_data_size; + //‘—Mó‘Ô‚ª‘—MŒp‘±‚̏ꍇ + if (it->status == SEND_CONTINUE) + { + //‘—Mƒf[ƒ^ŽcƒTƒCƒY@„@ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY + if (it->send_rest_size > request_data_remain_size) + { + //‘—M‰Â”\ƒf[ƒ^ƒTƒCƒY‚ɃŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚ðÝ’è‚·‚é + it->send_possible_size = request_data_remain_size; + //‘—Mƒf[ƒ^ŽcƒTƒCƒY‚©‚烊ƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚ðŒ¸ŽZ‚·‚é + it->send_rest_size -= request_data_remain_size; + //‘—MÏƒf[ƒ^ƒTƒCƒY‚É0‚ðÝ’è‚·‚é + it->send_end_size = 0; + //ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚É0‚ðÝ’è‚·‚é + request_data_remain_size = 0; + } + //‘—Mƒf[ƒ^ŽcƒTƒCƒY@…@ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY + else + { + //‘—M‰Â”\ƒf[ƒ^ƒTƒCƒY‚É‘—Mƒf[ƒ^ŽcƒTƒCƒY‚ðÝ’è‚·‚é + it->send_possible_size = it->send_rest_size; + //ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚©‚ç‘—Mƒf[ƒ^ŽcƒTƒCƒY‚ðŒ¸ŽZ‚·‚é + request_data_remain_size -= it->send_rest_size; + //‘—MÏƒf[ƒ^ƒTƒCƒY‚É0‚ðÝ’è‚·‚é + it->send_end_size = 0; + //‘—Mƒf[ƒ^ŽcƒTƒCƒY‚É0‚ðÝ’è‚·‚é + it->send_rest_size = 0; + } + //•ÒW‹æ•ª‚ɕҏW‚È‚µ‚ðÝ’è‚·‚é + it->edit_division = EDIT_DIVISION_NO_EDIT; + //‘—Mó‘Ô‚É‘—M‘Ò‚ðÝ’è‚·‚é + it->status = SEND_OK; + } + //‘—Mó‘Ô‚ª‘—M•s‰Â‚̏ꍇ + else if (it->status == SEND_NG) + { + //HTTPƒƒ\ƒbƒh‚̑Ó–«‚ðƒ`ƒFƒbƒN‚·‚é + check_result = check_http_method(recv_data.recive_buffer + + it->send_offset, data_remain_size); + //ƒ`ƒFƒbƒNŒ‹‰Ê‚ª³í‚̏ꍇ + if (check_result == CHECK_OK) + { + //HTTPƒo[ƒWƒ‡ƒ“‚̑Ó–«‚ðƒ`ƒFƒbƒN‚·‚é + check_result = check_http_version(recv_data.recive_buffer + + it->send_offset, data_remain_size); + } + //ƒ`ƒFƒbƒNŒ‹‰Ê‚ª³í‚̏ꍇ + if (check_result == CHECK_OK) + { + //‘—M‰Â”\ƒf[ƒ^“à‚ÌHTTPƒwƒbƒ_‚ÌŠJŽnˆÊ’uAƒTƒCƒY‚ðŽæ“¾‚·‚é + bret = find_http_header(recv_data.recive_buffer + + it->send_offset, data_remain_size, http_header, + header_offset, header_offset_len); + //ŒŸõŒ‹‰Ê‚ªŠY“–‚ ‚è‚̏ꍇ + if (bret) + { + //HTTPƒwƒbƒ_iContentLengthj‚ðŒŸõ‚·‚é + bret = find_http_header(recv_data.recive_buffer + + it->send_offset, data_remain_size, + content_header, header_offset, + count_length_header_value); + //ŒŸõŒ‹‰Ê‚ªŠY“–‚ ‚è‚̏ꍇ + if (bret) + { + str_value.assign(recv_data.recive_buffer + + it->send_offset + header_offset, + count_length_header_value); + value = boost::lexical_cast( + str_value.c_str()); + //‘—Mƒf[ƒ^ŽcƒTƒCƒY‚É + //uHTTPƒwƒbƒ_ƒTƒCƒY@{@ContentLengthv‚ðÝ’è‚·‚é + it->send_rest_size = header_offset_len + value; + } + //ŒŸõŒ‹‰Ê‚ªŠY“–‚È‚µ‚̏ꍇ + else + { + //‘—Mƒf[ƒ^ŽcƒTƒCƒY‚É–¢‘—Mƒf[ƒ^ƒTƒCƒY + ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚ðÝ’è‚·‚é + it->send_rest_size = it->unsend_size + request_data_remain_size; + } + //•ÒW‹æ•ª‚ɕҏW‚ ‚è‚ðÝ’è‚·‚é + it->edit_division = EDIT_DIVISION_EDIT; + } + //ŒŸõŒ‹‰Ê‚ªŠY“–‚È‚µ‚̏ꍇ + else + { + //–¢‘—Mƒf[ƒ^ƒTƒCƒY‚ɃŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚ð‰ÁŽZ‚·‚é + data_remain_size += request_data_remain_size; + it->unsend_size = data_remain_size; + //ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚É0‚ðÝ’è‚·‚é + request_data_remain_size = 0; + //ŒJ‚è•Ô‚µˆ—‚ðI—¹‚·‚é + break; + } + } + //ƒ`ƒFƒbƒNŒ‹‰Ê‚ªˆÙí‚̏ꍇ + else if (check_result == CHECK_NG) + { + //•ÒW‹æ•ª‚ɕҏW‚È‚µ‚ðÝ’è‚·‚é + it->edit_division = EDIT_DIVISION_NO_EDIT; + //‘—Mƒf[ƒ^ŽcƒTƒCƒY‚ɃŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚ðÝ’è‚·‚é + it->send_rest_size = request_data_remain_size; + } + //ƒ`ƒFƒbƒNŒ‹‰Ê‚ª”»’è•s”\‚̏ꍇ + //check_result == CHECK_INPOSSIBLE + else + { + //–¢‘—Mƒf[ƒ^ƒTƒCƒY‚ɃŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚ð‰ÁŽZ‚·‚é + data_remain_size += request_data_remain_size; + it->unsend_size = data_remain_size; + //ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚É0‚ðÝ’è‚·‚é + request_data_remain_size = 0; + //ŒJ‚è•Ô‚µˆ—‚ðI—¹‚·‚é + break; + } + + //‘—Mƒf[ƒ^ŽcƒTƒCƒY@„@–¢‘—Mƒf[ƒ^ƒTƒCƒY+ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY + if (it->send_rest_size > data_remain_size + + request_data_remain_size) + { + //‘—M‰Â”\ƒf[ƒ^ƒTƒCƒY‚É–¢‘—Mƒf[ƒ^ƒTƒCƒY{ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚ðÝ’è‚·‚é + it->send_possible_size = data_remain_size + + request_data_remain_size; + //‘—Mƒf[ƒ^ŽcƒTƒCƒY‚©‚ç–¢‘—Mƒf[ƒ^ƒTƒCƒY@{@ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚ðŒ¸ŽZ‚·‚é + it->send_rest_size -= (data_remain_size + + request_data_remain_size); + //‘—MÏƒf[ƒ^ƒTƒCƒY‚É0‚ðÝ’è‚·‚é + it->send_end_size = 0; + //–¢‘—Mƒf[ƒ^ƒTƒCƒY‚É0‚ðÝ’è‚·‚é + it->unsend_size = 0; + //ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚É0‚ðÝ’è‚·‚é + request_data_remain_size = 0; + } + //‘—Mƒf[ƒ^ŽcƒTƒCƒY@…@–¢‘—Mƒf[ƒ^ƒTƒCƒY@{@ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY + else + { + //‘—M‰Â”\ƒf[ƒ^ƒTƒCƒY‚É‘—Mƒf[ƒ^ŽcƒTƒCƒY‚ðÝ’è‚·‚é + it->send_possible_size = it->send_rest_size; + //ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚É + //u–¢‘—Mƒf[ƒ^ƒTƒCƒY{ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY|‘—Mƒf[ƒ^ŽcƒTƒCƒYv‚ðÝ’è‚·‚é + request_data_remain_size = data_remain_size + + request_data_remain_size - it->send_rest_size; + //‘—MÏƒf[ƒ^ƒTƒCƒY‚É0‚ðÝ’è‚·‚é + it->send_end_size = 0; + //–¢‘—Mƒf[ƒ^ƒTƒCƒY‚É0‚ðÝ’è‚·‚é + it->unsend_size = 0; + //‘—Mƒf[ƒ^ŽcƒTƒCƒY‚É0‚ðÝ’è‚·‚é + it->send_rest_size = 0; + } + + //‘—Mó‘Ô‚É‘—M‘Ò‚ðÝ’è‚·‚é + it->status = SEND_OK; + } + //ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY@…@0 + if (request_data_remain_size <= 0) + { + break; + } + } + + //ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY@„@0 + while (request_data_remain_size > 0) + { + //‘—Mó‘Ԃ𐶐¬‚·‚é + send_status new_send_state; + //‘—Mó‘Ô‚É‘—M•s‰Â‚ðÝ’è‚·‚é + new_send_state.status = SEND_NG; + //‘—Mƒf[ƒ^ƒIƒtƒZƒbƒg‚ðÝ’è‚·‚é + new_send_state.send_offset = recv_data.recive_buffer_max_size + - recv_data.recive_buffer_rest_size + - request_data_remain_size; + + //HTTPƒƒ\ƒbƒh‚̑Ó–«‚ðƒ`ƒFƒbƒN‚·‚é + check_result = check_http_method(recv_data.recive_buffer + + new_send_state.send_offset, request_data_remain_size); + //ƒ`ƒFƒbƒNŒ‹‰Ê‚ª³í‚̏ꍇ + if (check_result == CHECK_OK) + { + //HTTPƒo[ƒWƒ‡ƒ“‚̑Ó–«‚ðƒ`ƒFƒbƒN‚·‚é + check_result = check_http_version(recv_data.recive_buffer + + new_send_state.send_offset, request_data_remain_size); + } + //ƒ`ƒFƒbƒNŒ‹‰Ê‚ª³í‚̏ꍇ + if (check_result == CHECK_OK) + { + //‘—M‰Â”\ƒf[ƒ^“à‚ÌHTTPƒwƒbƒ_‚ÌŠJŽnˆÊ’uAƒTƒCƒY‚ðŽæ“¾‚·‚é + bret = find_http_header(recvbuffer.data() + request_data_size + - request_data_remain_size, request_data_remain_size, + http_header, header_offset, header_offset_len); + //ŒŸõŒ‹‰Ê‚ªŠY“–‚ ‚è‚̏ꍇ + if (bret) + { + //HTTPƒwƒbƒ_iContentLengthj‚ðŒŸõ‚·‚é + bret = find_http_header(recvbuffer.data() + + request_data_size - request_data_remain_size, + request_data_remain_size, content_header, + header_offset, count_length_header_value); + str_value.assign(recv_data.recive_buffer + it->send_offset + + header_offset, count_length_header_value); + value = boost::lexical_cast(str_value.c_str()); + //ŒŸõŒ‹‰Ê‚ªŠY“–‚ ‚è‚̏ꍇ + if (bret) + { + //‘—Mƒf[ƒ^ŽcƒTƒCƒY‚É + //uHTTPƒwƒbƒ_ƒTƒCƒY@{@ContentLengthv‚ðÝ’è‚·‚é + new_send_state.send_rest_size = header_offset_len + + value; + } + //ŒŸõŒ‹‰Ê‚ªŠY“–‚È‚µ‚̏ꍇ + else + { + //‘—Mƒf[ƒ^ŽcƒTƒCƒY‚ɃŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚ðÝ’è‚·‚é + new_send_state.send_rest_size = request_data_remain_size; + } + //•ÒW‹æ•ª‚ɕҏW‚ ‚è‚ðÝ’è‚·‚é + new_send_state.edit_division = EDIT_DIVISION_EDIT; + } + //ŒŸõŒ‹‰Ê‚ªŠY“–‚È‚µ‚̏ꍇ + else + { + //–¢‘—Mƒf[ƒ^ƒTƒCƒY‚ɃŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚ðÝ’è‚·‚é + new_send_state.unsend_size = request_data_remain_size; + //ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚É0‚ðÝ’è‚·‚é + request_data_remain_size = 0; + //ŒJ‚è•Ô‚µˆ—‚ðI—¹‚·‚é + break; + } + } + //ƒ`ƒFƒbƒNŒ‹‰Ê‚ªˆÙí‚̏ꍇ + else if (check_result == CHECK_NG) + { + //•ÒW‹æ•ª‚ɕҏW‚È‚µ‚ðÝ’è‚·‚é + new_send_state.edit_division = EDIT_DIVISION_NO_EDIT; + //‘—Mƒf[ƒ^ŽcƒTƒCƒY‚ɃŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚ðÝ’è‚·‚é + new_send_state.send_rest_size = request_data_remain_size; + } + //ƒ`ƒFƒbƒNŒ‹‰Ê‚ª”»’è•s”\‚̏ꍇ + //check_result == CHECK_INPOSSIBLE + else + { + //–¢‘—Mƒf[ƒ^ƒTƒCƒY‚ɃŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚ð‰ÁŽZ‚·‚é + new_send_state.unsend_size = request_data_remain_size; + //ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚É0‚ðÝ’è‚·‚é + request_data_remain_size = 0; + //ŒJ‚è•Ô‚µˆ—‚ðI—¹‚·‚é + break; + } + + //‘—Mƒf[ƒ^ŽcƒTƒCƒY@„@ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY + if (new_send_state.send_rest_size > request_data_remain_size) + { + //‘—M‰Â”\ƒf[ƒ^ƒTƒCƒY‚ɃŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚ðÝ’è‚·‚é + new_send_state.send_possible_size = request_data_remain_size; + //‘—Mƒf[ƒ^ŽcƒTƒCƒY‚©‚烊ƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚ðŒ¸ŽZ‚·‚é + new_send_state.send_rest_size -= request_data_remain_size; + //‘—MÏƒf[ƒ^ƒTƒCƒY‚É0‚ðÝ’è‚·‚é + new_send_state.send_end_size = 0; + //ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚É0‚ðÝ’è‚·‚é + request_data_remain_size = 0; + } + //‘—Mƒf[ƒ^ŽcƒTƒCƒY@…@ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY + else + { + //‘—M‰Â”\ƒf[ƒ^ƒTƒCƒY‚É‘—Mƒf[ƒ^ŽcƒTƒCƒY‚ðÝ’è‚·‚é + new_send_state.send_possible_size + = new_send_state.send_rest_size; + //ƒŠƒNƒGƒXƒgƒf[ƒ^ŽcƒTƒCƒY‚©‚ç‘—Mƒf[ƒ^ŽcƒTƒCƒY‚ðŒ¸ŽZ‚·‚é + request_data_remain_size -= new_send_state.send_rest_size; + //‘—MÏƒf[ƒ^ƒTƒCƒY‚É0‚ðÝ’è‚·‚é + new_send_state.send_end_size = 0; + //‘—Mƒf[ƒ^ŽcƒTƒCƒY‚É0‚ðÝ’è‚·‚é + new_send_state.send_rest_size = 0; + } + + //‘—Mó‘Ô‚É‘—M‘Ò‚ðÝ’è‚·‚é + new_send_state.status = SEND_OK; + //‘—Mó‘ÔƒŠƒXƒg‚É‘—Mó‘Ô‚ðÝ’è‚·‚é + recv_data.send_status_list.push_back(new_send_state); + } + + //‘—M‰Â”\ƒf[ƒ^‚ ‚è‚ðƒ`ƒFƒbƒN + send_status_it it_find = find_if(recv_data.send_status_list.begin(), + recv_data.send_status_list.end(), has_send_possible_data()); + //‘—M‰Â”\ƒf[ƒ^‚ ‚è + if (it_find != recv_data.send_status_list.end()) + { + //sorryó‘Ԃ̏ꍇ + if (session_data->sorry_flag == SORRY_FLAG_ON) + { + //‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é + status = SORRYSERVER_CONNECT; + } + //sorryó‘ԈȊO‚̏ꍇ + else + { + //‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é + status = REALSERVER_CONNECT; + } + } + //‘—M‰Â”\ƒf[ƒ^‚È‚µ + else + { + //‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é + status = CLIENT_RECV; + } + } catch (const std::bad_alloc&) + { + std::cerr + << "handle_session_initialize exception: Could not allocate memory." + << std::endl; + putLogError(017000, "Could not allocate memory.", __FILE__, __LINE__ ); + status = FINALIZE; + } catch (const std::exception& ex) + { + std::cerr << "handle_client_recv exception: error=%s" << ex.what() + << "." << std::endl; + boost::format + formatter( + "function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_client_recv() exception: result=%d, error=%s."); + formatter % FINALIZE % ex.what(); + putLogError(0170000, formatter.str(), __FILE__, __LINE__ ); + + status = FINALIZE; + } catch (...) + { + std::cerr << "Unkown exception." << std::endl; + putLogError(0170000, + "function protocol_module_sessionless::check_message_result " + "protocol_module_sessionless::handle_client_recv() : " + "Unkown exception.", __FILE__, __LINE__ ); + status = FINALIZE; + } + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == getloglevel()) + { + boost::format + formatter( + "out_function: protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::" + "handle_client_recv( const boost::thread::id thread_id," + "const boost::array& recvbuffer," + "const size_t recvlen ): return_value=%d"); + formatter % status; + putLogDebug(010005, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + return status; +} + +/*! + *handle_realserver_select + * + *@param [in] thread_id + *@param [out] rs_endpoint + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_realserver_select( + const boost::thread::id thread_id, + boost::asio::ip::tcp::endpoint & rs_endpoint) +{ + EVENT_TAG status; + + return status; +} + +/*! + *handle_realserver_select + * + *@param [in] thread_id + *@param [in] sendbuffer + *@param [out] datalen + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_realserver_select( + const boost::thread::id thread_id, + boost::asio::ip::udp::endpoint& rs_endpoint, boost::array& sendbuffer, size_t& datalen) +{ + return STOP; +} +/*! + *handle_realserver_connect + * + *@param [in] thread_id + *@param [in] sendbuffer + *@param [out] datalen + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_realserver_connect( + const boost::thread::id thread_id, + boost::array& sendbuffer, size_t& datalen) +{ + EVENT_TAG status; + + return status; +} + +/*! + *handle_realserver_connection_fail + * + *@param [in] thread_id + *@param [in] rs_endpoint + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_realserver_connection_fail( + const boost::thread::id thread_id, + const boost::asio::ip::tcp::endpoint & rs_endpoint) +{ + EVENT_TAG status; + + return status; +} +/*! + *handle_realserver_send + * + *@param [in] thread_id + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_realserver_send( + const boost::thread::id thread_id) +{ + EVENT_TAG status; + return status; +} + +/*! + *handle_sorryserver_select + * + *@param [in] thread_id + *@param [in]sorry_endpoint + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_sorryserver_select( + const boost::thread::id thread_id, + boost::asio::ip::tcp::endpoint & sorry_endpoint) +{ + EVENT_TAG status; + return status; +} + +/*! + *handle_sorryserver_connect + * + *@param [in] thread_id + *@param [out]sendbuffer + *@param [out]datalen + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_sorryserver_connect( + const boost::thread::id thread_id, + boost::array& sendbuffer, size_t& datalen) +{ + EVENT_TAG status; + return status; +} + +/*! + *handle_sorryserver_connection_fail + * + *@param [in] thread_id + *@param [out]sendbuffer + *@param [out]datalen + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_sorryserver_connection_fail( + const boost::thread::id thread_id, + const boost::asio::ip::tcp::endpoint & sorry_endpoint) +{ + EVENT_TAG status; + return status; +} + +/*! + *handle_sorryserver_send + * + *@param [in] thread_id + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_sorryserver_send( + const boost::thread::id thread_id) +{ + EVENT_TAG status; + + return status; +} + +/*! + *handle_realserver_recv + * + *@param [in] thread_id + *@param [in] rs_endpoint + *@param [in] recvbuffer + *@param [in] recvlen + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_realserver_recv( + const boost::thread::id thread_id, + const boost::asio::ip::tcp::endpoint& rs_endpoint, const boost::array< + char, MAX_BUFFER_SIZE>& recvbuffer, const size_t recvlen) +{ + EVENT_TAG status; + return status; +} + +/*! + *handle_realserver_recv + * + *@param [in] thread_id + *@param [in] rs_endpoint + *@param [in] recvbuffer + *@param [in] recvlen + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_realserver_recv( + const boost::thread::id thread_id, + const boost::asio::ip::udp::endpoint& rs_endpoint, const boost::array< + char, MAX_BUFFER_SIZE>& recvbuffer, const size_t recvlen) +{ + return STOP; +} + +/*! + *handle_sorryserver_recv + * + *@param [in] thread_id + *@param [in] sorry_endpoint + *@param [in] recvbuffer + *@param [in] recvlen + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_sorryserver_recv( + const boost::thread::id thread_id, + const boost::asio::ip::tcp::endpoint& sorry_endpoint, + const boost::array& recvbuffer, + const size_t recvlen) +{ + EVENT_TAG status; + + return status; +} + +/*! + *handle_response_send_inform + * + *@param [in] thread_id + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_response_send_inform( + const boost::thread::id thread_id) +{ + return STOP; +} + +/*! + *handle_client_connection_check + * + *@param [in] thread_id + *@param [out]sendbuffer + *@param [out]datalen + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_client_connection_check( + const boost::thread::id thread_id, + boost::array& sendbuffer, size_t& datalen) +{ + EVENT_TAG status; + return status; +} + +/*! + *handle_client_send + * + *@param [in] thread_id + *@param [out] sendbuffer + *@param [out] datalen + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_client_select( + const boost::thread::id thread_id, + boost::asio::ip::udp::endpoint& cl_endpoint, boost::array& sendbuffer, size_t& datalen) +{ + return STOP; +} + +/*! + *handle_client_send + * + *@param [in] thread_id + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_client_send( + const boost::thread::id thread_id) +{ + EVENT_TAG status; + + return status; +} + +/*! + *handle_client_disconnect + * + *@param [in] thread_id + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_client_disconnect( + const boost::thread::id thread_id) +{ + return FINALIZE; +} + +/*! + *handle_sorry_enable + * + *@param [in] thread_id + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_sorry_enable( + const boost::thread::id thread_id) +{ + EVENT_TAG status; + + return status; +} + +/*! + *handle_sorry_disable + * + *@param [in] thread_id + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_sorry_disable( + const boost::thread::id thread_id) +{ + EVENT_TAG status; + + return status; +} + +/*! + *handle_sorryserver_disconnect + * + *@param [in] thread_id + *@param [in] rs_endpoint + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_realserver_disconnect( + const boost::thread::id thread_id, + const boost::asio::ip::tcp::endpoint & rs_endpoint) +{ + EVENT_TAG status; + + return status; +} + +/*! + *handle_sorryserver_disconnect + * + *@param [in] thread_id + *@param [in] sorry_endpoint + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_sorryserver_disconnect( + const boost::thread::id thread_id, + const boost::asio::ip::tcp::endpoint & sorry_endpoint) +{ + EVENT_TAG status; + return status; +} + +/*! + *handle_realserver_close + * + *@param [in] thread_id + *@param [in] rs_endpoint + */ +protocol_module_sessionless::EVENT_TAG protocol_module_sessionless::handle_realserver_close( + const boost::thread::id thread_id, + const boost::asio::ip::udp::endpoint & rs_endpoint) +{ + return STOP; +} + +} diff --git a/module/protocol/protocol_module_sessionless.h b/module/protocol/protocol_module_sessionless.h new file mode 100644 index 00000000..6c83c5ed --- /dev/null +++ b/module/protocol/protocol_module_sessionless.h @@ -0,0 +1,196 @@ +#include +#include "http_protocol_module_base.h" + +#ifndef PROTOCOL_MODULE_SESSIONLESS_H +#define PROTOCOL_MODULE_SESSIONLESS_H + +#define MAX_OPTION_SIZE 256 + +namespace l7vs +{ +const std::string MODULE_NAME = "sessionless"; + + + +#define THREAD_DIVISION_UP_STREAM 0 //ã‚èƒXƒŒƒbƒh +#define THREAD_DIVISION_DOWN_STREAM 1 //‰º‚èƒXƒŒƒbƒh + +#define END_FLAG_OFF 0 //I—¹ƒtƒ‰ƒOOFF +#define END_FLAG_ON 1 //I—¹ƒtƒ‰ƒOON + +#define ACCEPT_END_FLAG_OFF 0 //ACCEPTŠ®—¹ƒtƒ‰ƒOOFF +#define ACCEPT_END_FLAG_ON 1 //ACCEPTŠ®—¹ƒtƒ‰ƒOON + +#define SORRY_FLAG_ON 1 //SORRYó‘Ô +#define SORRY_FLAG_OFF 0 //SORRYó‘ԈȊO + +#define SORRYSERVER_SWITCH_FLAG_OFF 0 //sorryserverØ‘Ö’†ˆÈŠO +#define SORRYSERVER_SWITCH_FLAG_ON 1 //sorryserverØ‘Ö’† + +#define REALSERVER_SWITCH_FLAG_OFF 0 //realserverØ‘Ö’†ˆÈŠO +#define REALSERVER_SWITCH_FLAG_ON 1 //realserverØ‘Ö’† + +enum EDIT_DIVISION_TAG +{ + EDIT_DIVISION_NO_EDIT = 0, //•ÒW–³‚µ + EDIT_DIVISION_EDIT = 1 //•ÒW‚ ‚è +}; + +class protocol_module_sessionless : public http_protocol_module_base +{ +public: + enum SEND_STATUS_TAG + { + SEND_OK= 0, + SEND_NG, + SEND_END, + SEND_CONTINUE + }; + typedef struct _edit_data { + std::string data; + int data_size; + int insert_posission; + int replace_size; + } edit_data; + + typedef struct _send_status { + SEND_STATUS_TAG status; + int send_end_size; + int send_rest_size; + int send_possible_size; + int send_offset; + int unsend_size; + int edit_division; + boost::asio::ip::tcp::endpoint send_endpoint; + std::list edit_data_list; + } send_status; + + typedef struct _recive_data { + char* recive_buffer; + char* recive_buffer1; + char* recive_buffer2; + int recive_buffer_max_size; + int recive_buffer_rest_size; + std::list send_status_list; + } recive_data; + + + typedef struct _session_thread_data_sessionless { + boost::thread::id thread_id; + int thread_division; + boost::thread::id pair_thread_id; + std::map recive_data_map; + int end_flag; + int accept_end_flag; + int sorry_flag; + int sorryserver_switch_flag; + int realserver_switch_flag; + boost::asio::ip::tcp::endpoint endpoint; + EVENT_TAG last_status; + } session_thread_data_sessionless; + + typedef std::list::iterator send_status_it; + typedef std::map::iterator session_thread_data_map_it; + typedef std::map::iterator recive_data_map_it; +public://for debug + boost:: array cookie_name; + int cookie_expire; + int forwarded_for; + int reschedule; + boost:: array sorry_uri ; + std::map session_thread_data_map; + boost::mutex session_thread_data_map_mutex; + +public: + protocol_module_sessionless(); + ~protocol_module_sessionless(); + + bool is_tcp(); + bool is_udp(); + std::string& get_name(); + void replication_interrupt(); + void initialize(boost::function::iterator(void)> inrslist_begin, boost::function::iterator(void)> inrslist_end, boost::function::iterator(void)> inrslist_next, boost::function inlist_lock, boost::function inlist_unlock); + void finalize(); + bool is_use_sorry(); + check_message_result check_parameter(const std::vector& args); + check_message_result set_parameter(const std::vector& args); + check_message_result add_parameter(const std::vector& args); + void handle_rslist_update(); + void register_schedule(tcp_schedule_func_type inschedule); + void register_schedule(udp_schedule_func_type inschedule); + EVENT_TAG handle_session_initialize(const boost::thread::id up_thread_id, const boost::thread::id down_thread_id); + EVENT_TAG handle_session_finalize(const boost::thread::id up_thread_id, const boost::thread::id down_thread_id); + EVENT_TAG handle_accept(const boost::thread::id thread_id); + EVENT_TAG handle_client_recv(const boost::thread::id thread_id, const boost::array& recvbuffer, const size_t recvlen); + EVENT_TAG handle_realserver_select(const boost::thread::id thread_id, boost::asio::ip::tcp::endpoint& rs_endpoint); + EVENT_TAG handle_realserver_select(const boost::thread::id thread_id, boost::asio::ip::udp::endpoint& rs_endpoint, boost::array& sendbuffer, size_t& datalen); + EVENT_TAG handle_realserver_connect(const boost::thread::id thread_id, boost::array& sendbuffer, size_t& datalen); + EVENT_TAG handle_realserver_connection_fail(const boost::thread::id thread_id, const boost::asio::ip::tcp::endpoint& rs_endpoint); + EVENT_TAG handle_realserver_send(const boost::thread::id thread_id); + EVENT_TAG handle_sorryserver_select(const boost::thread::id thread_id, boost::asio::ip::tcp::endpoint& sorry_endpoint); + EVENT_TAG handle_sorryserver_connect(const boost::thread::id thread_id, boost::array& sendbuffer, size_t& datalen); + EVENT_TAG handle_sorryserver_connection_fail(const boost::thread::id thread_id, const boost::asio::ip::tcp::endpoint& sorry_endpoint); + EVENT_TAG handle_sorryserver_send(const boost::thread::id thread_id); + EVENT_TAG handle_realserver_recv(const boost::thread::id thread_id, const boost::asio::ip::tcp::endpoint& rs_endpoint, const boost::array& recvbuffer, const size_t recvlen); + EVENT_TAG handle_realserver_recv(const boost::thread::id thread_id, const boost::asio::ip::udp::endpoint& rs_endpoint, const boost::array& recvbuffer, const size_t recvlen); + EVENT_TAG handle_sorryserver_recv(const boost::thread::id thread_id, const boost::asio::ip::tcp::endpoint& sorry_endpoint, const boost::array& recvbuffer, const size_t recvlen); + EVENT_TAG handle_response_send_inform(const boost::thread::id thread_id); + EVENT_TAG handle_client_connection_check(const boost::thread::id thread_id, boost::array& sendbuffer, size_t& datalen); + EVENT_TAG handle_client_select(const boost::thread::id thread_id, boost::asio::ip::udp::endpoint& cl_endpoint, boost::array& sendbuffer, size_t& datalen); + EVENT_TAG handle_client_send(const boost::thread::id thread_id); + EVENT_TAG handle_client_disconnect(const boost::thread::id thread_id); + EVENT_TAG handle_sorry_enable(const boost::thread::id thread_id); + EVENT_TAG handle_sorry_disable(const boost::thread::id thread_id); + EVENT_TAG handle_realserver_disconnect(const boost::thread::id thread_id, const boost::asio::ip::tcp::endpoint& rs_endpoint); + EVENT_TAG handle_sorryserver_disconnect(const boost::thread::id thread_id, const boost::asio::ip::tcp::endpoint& sorry_endpoint); + EVENT_TAG handle_realserver_close(const boost::thread::id thread_id, const boost::asio::ip::udp::endpoint& rs_endpoint); +}; + +inline bool operator < (const protocol_module_sessionless::edit_data& lref, const protocol_module_sessionless::edit_data& rref) +{ + return lref.insert_posission < rref.insert_posission; +} + +class has_send_possible_data +{ +public: + inline bool operator () (const protocol_module_sessionless::send_status& send_status) + { + return send_status.status == protocol_module_sessionless::SEND_OK + && send_status.send_possible_size > 0; + } +}; + +class has_send_disable_data +{ +public: + inline bool operator () (const protocol_module_sessionless::send_status& send_status) + { + return send_status.status == protocol_module_sessionless::SEND_NG + || send_status.send_rest_size > 0 ; + } +}; + +class has_send_continue_data +{ +public: + inline bool operator () (const protocol_module_sessionless::send_status& send_status) + { + return send_status.status == protocol_module_sessionless::SEND_CONTINUE; + } +}; + +class has_send_ng_data +{ +public: + inline bool operator () (const protocol_module_sessionless::send_status& send_status) + { + return send_status.status == protocol_module_sessionless::SEND_NG; + } + +}; + +} + +#endif //PROTOCOL_MODULE_SESSIONLESS_H + diff --git a/module/protocol/protocol_module_sslid.cpp b/module/protocol/protocol_module_sslid.cpp new file mode 100644 index 00000000..8feb193f --- /dev/null +++ b/module/protocol/protocol_module_sslid.cpp @@ -0,0 +1,2339 @@ +#include "protocol_module_sslid.h" +#include + +#define REALSERVER_CONNECT_FAILED_MAX_COUNT (3) +#define THREAD_DIVISION_UP_STREAM (0) // up thread +#define THREAD_DIVISION_DOWN_STREAM (1) // down thread +#define END_FLAG_ON (1) // end flag ON +#define END_FLAG_OFF (0) // end flag OFF + +namespace l7vs +{ + +const std::string protocol_module_sslid::MODULE_NAME = "sslid"; + +protocol_module_sslid::protocol_module_sslid(): + ssl_protocol_module_base( MODULE_NAME ), + realserver_connect_failed_max_count( REALSERVER_CONNECT_FAILED_MAX_COUNT ), + replication_data_processor( NULL ), + session_data_processor( NULL ) +{ + //ctor + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "in_function: Constructor protocol_module_sslid::" + "protocol_module_sslid()", __FILE__, __LINE__ ); + + boost::format formatter( "out_function: protocol_module_sslid::protocol_module_sslid(): " + "modename=%s, realserver_connect_failed_max_count=%d" ); + formatter % MODULE_NAME % realserver_connect_failed_max_count; + putLogDebug( 030001, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ +} + +protocol_module_sslid::~protocol_module_sslid() +{ + //dtor + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030002, "in/out_function: Destructor protocol_module_sslid::" + "~protocol_module_sslid()", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ +} + +bool protocol_module_sslid::is_tcp() +{ + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030002, "in/out_function: bool protocol_module_sslid::is_tcp(): " + "return_value=true", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + return true; +} + +bool protocol_module_sslid::is_udp() +{ + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030002, "in/out_function: bool protocol_module_sslid::is_udp(): " + "return_value=false", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + return false; +} + +void protocol_module_sslid::initialize( + rs_list_itr_func_type inlist_begin, + rs_list_itr_func_type inlist_end, + rs_list_itr_func_type inlist_next, + boost::function< void( void ) > inlist_lock, + boost::function< void( void ) > inlist_unlock ) +{ + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030003, "in_function: void protocol_module_sslid::initialize(" + "rs_list_itr_func_type inlist_begin, rs_list_itr_func_type inlist_end," + "rs_list_itr_func_type inlist_next,boost::function< void( void ) > " + "inlist_lock,boost::function< void( void ) > inlist_unlock )" , + __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + rs_list_begin = inlist_begin; + rs_list_end = inlist_end; + rs_list_next = inlist_next; + rs_list_lock = inlist_lock; + rs_list_unlock = inlist_unlock; + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030004, "out_function: void protocol_module_sslid::initialize(" + "rs_list_itr_func_type inlist_begin,rs_list_itr_func_type inlist_end," + "rs_list_itr_func_type inlist_next,boost::function< void( void ) > " + "inlist_lock,boost::function< void( void ) > inlist_unlock ) ", + __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ +} + +void protocol_module_sslid::finalize() +{ + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "int_function: void protocol_module_sslid::finalize()", + __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + // realserver list function object initialize + rs_list_begin.clear(); + rs_list_end.clear(); + rs_list_next.clear(); + rs_list_lock.clear(); + rs_list_unlock.clear(); + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "function: rs_list_begin.clear(), rs_list_end.clear(), " + "rs_list_next.clear(), rs_list_lock.clear(), rs_list_unlock.clear() END" , + __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + // replication function object initialize + replication_pay_memory.clear(); + replication_area_lock.clear(); + replication_area_unlock.clear(); + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "function: replication_pay_memory.clear(), " + "replication_area_lock.clear(), replication_area_unlock.clear() END" , + __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + // scheduleModule function object initialize + schedule_tcp.clear(); + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "function: schedule_tcp.clear() END", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + // module option initialize + timeout = 0; + maxlist = 0; + reschedule = 0; + + // replication initialize + if ( replication_data_processor ) + { + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter("delete: address=&(%d)" ); + formatter % &replication_data_processor; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + delete replication_data_processor; + replication_data_processor = NULL; + } + + // session initialize + if ( session_data_processor ) + { + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter("delete: address=&(%d)" ); + formatter % &session_data_processor; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + delete session_data_processor; + session_data_processor = NULL; + } + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "out_function: void protocol_module_sslid::finalize()", + __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + // logger function object initialize + getloglevel.clear(); + putLogFatal.clear(); + putLogError.clear(); + putLogWarn.clear(); + putLogInfo.clear(); + putLogDebug.clear(); +} + +bool protocol_module_sslid::is_use_sorry() +{ + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030002, "in/out_function: bool protocol_module_sslid::is_use_sorry(): " + "return_value=false", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + return false; +} + +protocol_module_sslid::check_message_result protocol_module_sslid::check_parameter( + const std::vector& args ) +{ + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "int_function: protocol_module_sslid::check_message_result " + "protocol_module_sslid::check_parameter(" + "const std::vector& args ): args=%s" ); + std::string argsdump; + for ( std::vector::const_iterator it = args.begin(); it != args.end(); ++it ) + { + argsdump += *it; + } + formatter % argsdump; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + check_message_result result; + // set check flag to true + result.flag = true; + bool timeout_flag = false; // timeout set flag + bool maxlist_flag = false; // maxlist set flag + bool reschedule_flag = false; // reschedule set flag + bool no_reschedule_flag = false; // no-reschedule set flag + + try + { + std::vector::const_iterator itparam; + boost::format formatter; + + for ( itparam = args.begin(); itparam != args.end(); ++itparam ) + { + if ( *itparam == "-T" || *itparam == "--timeout" ) + { + // timeout + if ( !timeout_flag ) + { + // not set timeout option + ++itparam; + // next parameter exist check + if ( itparam != args.end() ) + { + // next parameter exist + try + { + unsigned long ultimeout = 0; + ultimeout = boost::lexical_cast( *itparam ); + // int maxvalue check + if ( ultimeout > INT_MAX ) + { + result.flag = false; + formatter.parse( "'-T/--timeout' option value '%s' is too large." ); + formatter % *itparam; + result.message = formatter.str(); + putLogError( 037000, result.message, __FILE__, __LINE__ ); + break; + } + else + { + timeout_flag = true; + continue; + } + } + catch ( boost::bad_lexical_cast& e ) + { + // not numeric character + result.flag = false; + formatter.parse( "'-T/--timeout' option value '%s' is not numeric character." ); + formatter % *itparam; + result.message = formatter.str(); + putLogError( 037000, result.message, __FILE__, __LINE__ ); + break; + } + } + else + { + // next parameter not exist + break; + } + } + else + { + // already set timeout + result.flag = false; + result.message = "Cannot set multiple option '--timeout/-T'."; + putLogError( 037000, result.message, __FILE__, __LINE__ ); + break; + } + } + else if ( *itparam == "-M" || *itparam == "--maxlist" ) + { + // maxlist + if ( !maxlist_flag ) + { + // not set maxlist option + ++itparam; + // next parameter exist check + if ( itparam != args.end() ) + { + // next parameter exist + try + { + unsigned long ulmaxlist = 0; + ulmaxlist = boost::lexical_cast( *itparam ); + // int maxvalue check + if ( ulmaxlist > INT_MAX ) + { + result.flag = false; + formatter.parse( "'-M/--maxlist' option value '%s' is too large." ); + formatter % *itparam; + result.message = formatter.str(); + putLogError( 037000, result.message, __FILE__, __LINE__); + break; + } + else + { + maxlist_flag = true; + continue; + } + } + catch ( boost::bad_lexical_cast& e ) + { + // not numeric character + result.flag = false; + formatter.parse("'-M/--maxlist' option value '%s' is not numeric character."); + formatter % *itparam; + result.message = formatter.str(); + putLogError( 037000, result.message, __FILE__, __LINE__); + break; + } + } + else + { + // next parameter not exist + break; + } + } + else + { + // already set timeout + result.flag = false; + result.message = "Cannot set multiple option '-M/--maxlist'."; + putLogError( 037000, result.message, __FILE__, __LINE__); + break; + } + } + else if ( *itparam == "-R" || *itparam == "--reschedule" ) + { + // reschedule + if ( !no_reschedule_flag ) + { + // not set no-reschedule flag + reschedule_flag = true; + } + else + { + // already set no-reschedule flag + result.flag = false; + result.message = "You have to choose either of reschdule or no-reschedule."; + putLogError( 037000, result.message, __FILE__, __LINE__); + break; + } + } + else if ( *itparam == "-N" || *itparam == "--no-reschedule" ) + { + // no-reschedule + if ( !reschedule_flag ) + { + // not set reschedule flag + no_reschedule_flag = true; + } + else + { + // already set reshcedule flag + result.flag = false; + result.message = "You have to choose either of reschdule or no-reschedule."; + putLogError( 037000, result.message, __FILE__, __LINE__); + break; + } + } + else + { + // check result is false + result.flag = false; + result.message = "Option error."; + putLogError( 037000, result.message, __FILE__, __LINE__); + break; + } + } + } + catch ( const std::exception& e ) + { + result.flag = false; + std::cerr << "check parameter exception: result=false, error=" << e.what() << "." << std::endl; + boost::format formatter( "function protocol_module_sslid::check_message_result " + "protocol_module_sslid::check_parameter() exception: " + "result=false, error=%s." ); + formatter % e.what(); + putLogError( 037000, formatter.str(), __FILE__, __LINE__ ); + } + catch( ... ) + { + result.flag = false; + std::cerr << "Unkown exception." << std::endl; + putLogError( 037000, "function protocol_module_sslid::check_message_result " + "protocol_module_sslid::check_parameter() :" + "Unkown exception.", __FILE__, __LINE__ ); + } + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "out_function: protocol_module_sslid::check_message_result " + "protocol_module_sslid::check_parameter(" + "const std::vector& args ): return_value=(" + "check_message_result.flag=%d, check_message_result.message=%s" ); + formatter % result.flag % result.message; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + return result; +} + +protocol_module_sslid::check_message_result protocol_module_sslid::set_parameter( + const std::vector& args ) +{ + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "int_function: protocol_module_sslid::check_message_result " + "protocol_module_sslid::set_parameter(" + "const std::vector& args ): args=%s" ); + std::string argsdump; + for ( std::vector::const_iterator it = args.begin(); it != args.end(); ++it ) + { + argsdump += *it; + } + formatter % argsdump; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + check_message_result result; + // set check flag to true + result.flag = true; + bool timeout_flag = false; // timeout set flag + bool maxlist_flag = false; // maxlist set flag + bool reschedule_flag = false; // reschedule set flag + bool no_reschedule_flag = false; // no-reschedule set flag + + try + { + std::vector::const_iterator itparam; + boost::format formatter; + + for ( itparam = args.begin(); itparam != args.end(); ++itparam ) + { + if ( *itparam == "-T" || *itparam == "--timeout" ) + { + // timeout + if ( !timeout_flag ) + { + // not set timeout option + ++itparam; + // next parameter exist check + if ( itparam != args.end() ) + { + // next parameter exist + try + { + unsigned long ultimeout = 0; + ultimeout = boost::lexical_cast( *itparam ); + // int maxvalue check + if ( ultimeout > INT_MAX ) + { + result.flag = false; + formatter.parse( "'-T/--timeout' option value '%s' is too large." ); + formatter % *itparam; + result.message = formatter.str(); + putLogError( 037000, result.message, __FILE__, __LINE__ ); + break; + } + else + { + timeout = ultimeout; + timeout_flag = true; + continue; + } + } + catch ( boost::bad_lexical_cast& e ) + { + // not numeric character + result.flag = false; + formatter.parse( "'-T/--timeout' option value '%s' is not numeric character." ); + formatter % *itparam; + result.message = formatter.str(); + putLogError( 037000, result.message, __FILE__, __LINE__ ); + break; + } + } + else + { + // next parameter not exist + break; + } + } + else + { + // already set timeout + result.flag = false; + result.message = "Cannot set multiple option '--timeout/-T'."; + putLogError( 037000, result.message, __FILE__, __LINE__ ); + break; + } + } + else if ( *itparam == "-M" || *itparam == "--maxlist" ) + { + // maxlist + if ( !maxlist_flag ) + { + // not set maxlist option + ++itparam; + // next parameter exist check + if ( itparam != args.end() ) + { + // next parameter exist + try + { + unsigned long ulmaxlist = 0; + ulmaxlist = boost::lexical_cast( *itparam ); + // int maxvalue check + if ( ulmaxlist > INT_MAX ) + { + result.flag = false; + formatter.parse( "'-M/--maxlist' option value '%s' is too large." ); + formatter % *itparam; + result.message = formatter.str(); + putLogError( 037000, result.message, __FILE__, __LINE__ ); + break; + } + else + { + maxlist = ulmaxlist; + maxlist_flag = true; + continue; + } + } + catch ( boost::bad_lexical_cast& e ) + { + // not numeric character + result.flag = false; + formatter.parse("'-M/--maxlist' option value '%s' is not numeric character."); + formatter % *itparam; + result.message = formatter.str(); + putLogError( 037000, result.message, __FILE__, __LINE__ ); + break; + } + } + else + { + // next parameter not exist + break; + } + } + else + { + // already set timeout + result.flag = false; + result.message = "Cannot set multiple option '-M/--maxlist'."; + putLogError( 037000, result.message, __FILE__, __LINE__ ); + break; + } + } + else if ( *itparam == "-R" || *itparam == "--reschedule" ) + { + // reschedule + if ( !no_reschedule_flag ) + { + // not set no-reschedule flag + reschedule_flag = true; + reschedule = 1; + } + else + { + // already set no-reschedule flag + result.flag = false; + result.message = "You have to choose either of reschdule or no-reschedule."; + putLogError( 037000, result.message, __FILE__, __LINE__ ); + break; + } + } + else if ( *itparam == "-N" || *itparam == "--no-reschedule" ) + { + // no-reschedule + if ( !reschedule_flag ) + { + // not set reschedule flag + no_reschedule_flag = true; + reschedule = 0; + } + else + { + // already set reshcedule flag + result.flag = false; + result.message = "You have to choose either of reschdule or no-reschedule."; + putLogError( 037000, result.message, __FILE__, __LINE__ ); + break; + } + } + else + { + // check result is false + result.flag = false; + result.message = "Option error."; + putLogError( 037000, result.message, __FILE__, __LINE__ ); + break; + } + } + + // result check + if ( result.flag ) + { + // timeout default set + if ( !timeout_flag ) + { + timeout = 3600; + } + + // maxlist default set + if ( !maxlist_flag ) + { + maxlist = 1024; + } + + // reschedule default set + if ( !reschedule_flag ) + { + reschedule = 0; + } + } + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "function: protocol_module_sslid::check_message_result " + "protocol_module_sslid::set_parameter(" + "const std::vector& args ): timeout=%d," + "maxlist=%d, reschedule=%d" ); + formatter % timeout % maxlist % reschedule; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + unsigned int data_size = 0; + void* data_addr = NULL; + data_addr = replication_pay_memory( get_name(), &data_size ); + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "function: protocol_module_sslid::check_message_result " + "protocol_module_sslid::set_parameter(): " + "replication_pay_memory() END.", __FILE__, __LINE__ ); + boost::format formatter( "function: protocol_module_sslid::check_message_result " + "protocol_module_sslid::set_parameter(): " + "data_addr=&(%d), data_size=%d." ); + formatter % &data_addr % data_size; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + if ( data_addr == NULL || data_size <= 0 ) + { + // replication area is full + putLogError( 037000, "Replication area is full.", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "out_function: protocol_module_sslid::check_message_result " + "protocol_module_sslid::set_parameter(" + "const std::vector& args ): return_value=" + "check_message_result.flag=%d, check_message_result.message=%s" ); + formatter % result.flag % result.message; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + return result; + } + else + { + // create sslid_replication_data_processor + replication_data_processor = new sslid_replication_data_processor( + maxlist, + static_cast(data_addr), + data_size, + virtual_service_endpoint_tcp, + getloglevel, + putLogFatal, + putLogError, + putLogWarn, + putLogInfo, + putLogDebug ); + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter("new: address=&(%d), size=%lu." ); + formatter % &replication_data_processor % sizeof( sslid_session_data_processor ); + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + replication_data_processor->register_replication_area_lock( replication_area_lock ); + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "protocol_module_sslid::check_message_result " + "protocol_module_sslid::set_parameter(): register_replication_area_lock() END.", + __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + replication_data_processor->register_replication_area_unlock( replication_area_unlock ); + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "protocol_module_sslid::check_message_result " + "protocol_module_sslid::set_parameter(): register_replication_area_unlock() END.", + __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + // create sslid_session_data_processor + session_data_processor = new sslid_session_data_processor( maxlist, + timeout, + replication_data_processor, + getloglevel, + putLogFatal, + putLogError, + putLogWarn, + putLogInfo, + putLogDebug ); + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter("new: address=&(%d), size=%lu." ); + formatter % &session_data_processor % sizeof( sslid_session_data_processor ); + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + // restore data from replication area + sslid_replication_data* redata = replication_data_processor->get_replication_area(); + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "protocol_module_sslid::check_message_result " + "protocol_module_sslid::set_parameter(): get_replication_area() END.", + __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + replication_area_lock(); + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "protocol_module_sslid::check_message_result " + "protocol_module_sslid::set_parameter(): replication_area_lock() END.", + __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + session_data_processor->read_session_data_from_replication_area( redata ); + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "protocol_module_sslid::check_message_result " + "protocol_module_sslid::set_parameter(): " + "read_session_data_from_replication_area() END.", + __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + replication_area_unlock(); + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "protocol_module_sslid::check_message_result " + "protocol_module_sslid::set_parameter(): replication_area_unlock() END.", + __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + } + } + catch ( const std::bad_alloc& ba ) + { + if ( replication_data_processor ) + { + delete replication_data_processor; + replication_data_processor = NULL; + } + + if ( session_data_processor ) + { + delete session_data_processor; + session_data_processor = NULL; + } + + std::cerr << "set parameter exception: Could not allocate memory." << std::endl; + result.flag = false; + result.message = "Could not allocate memory."; + putLogError( 037000, result.message, __FILE__, __LINE__ ); + } + catch ( const std::exception& e ) + { + if ( replication_data_processor ) + { + delete replication_data_processor; + replication_data_processor = NULL; + } + + if ( session_data_processor ) + { + delete session_data_processor; + session_data_processor = NULL; + } + + result.flag = false; + std::cerr << "set parameter exception: result=false, error=" << e.what() << std::endl; + boost::format formatter( "function protocol_module_sslid::check_message_result " + "protocol_module_sslid::set_parameter() exception: " + "result=false, error=%s." ); + formatter % e.what(); + putLogError( 037000, formatter.str(), __FILE__, __LINE__ ); + } + catch( ... ) + { + if ( replication_data_processor ) + { + delete replication_data_processor; + replication_data_processor = NULL; + } + + if ( session_data_processor ) + { + delete session_data_processor; + session_data_processor = NULL; + } + + result.flag = false; + std::cerr << "Unkown exception." << std::endl; + putLogError( 037000, "function protocol_module_sslid::check_message_result " + "protocol_module_sslid::check_parameter() : " + "Unkown exception.", __FILE__, __LINE__ ); + } + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "out_function: protocol_module_sslid::check_message_result " + "protocol_module_sslid::set_parameter(" + "const std::vector& args ): return_value=" + "check_message_result.flag=%d, check_message_result.message=%s" ); + formatter % result.flag % result.message; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + return result; +} + +protocol_module_sslid::check_message_result protocol_module_sslid::add_parameter( + const std::vector& args ) +{ + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "int_function: protocol_module_sslid::check_message_result " + "protocol_module_sslid::add_parameter(" + "const std::vector& args ): args=%s" ); + std::string argsdump; + for ( std::vector::const_iterator it = args.begin(); it != args.end(); ++it ) + { + argsdump += *it; + } + formatter % argsdump; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + check_message_result result; + result.flag = true; + + if ( args.size() > 0 ) + { + // option exist + result.flag = false; + result.message = "Cannot add option."; + putLogError( 037000, result.message, __FILE__, __LINE__ ); + } + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "out_function: protocol_module_sslid::check_message_result " + "protocol_module_sslid::add_parameter(" + "const std::vector& args ): return_value=" + "check_message_result.flag=%d, check_message_result.message=%s" ); + formatter % result.flag % result.message; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + return result; +} + +void protocol_module_sslid::handle_rslist_update() +{ + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030002, "in/out_function:void protocol_module_sslid::handle_rslist_update(): " + "return_value=void", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ +} + +void protocol_module_sslid::register_schedule( tcp_schedule_func_type inschedule ) +{ + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "in_function: void protocol_module_sslid::register_schedule( " + "tcp_schedule_func_type inschedule )", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + schedule_tcp = inschedule; + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "out_function: void protocol_module_sslid::register_schedule( " + "tcp_schedule_func_type inschedule )", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ +} + +void protocol_module_sslid::register_schedule( udp_schedule_func_type inschedule ) +{ + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030002, "in/out_function:void protocol_module_sslid::register_schedule(): " + "return_value=void", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_session_initialize( + const boost::thread::id up_thread_id, + const boost::thread::id down_thread_id ) +{ + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "in_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_session_initialize( const boost::thread::id up_thread_id, " + "const boost::thread::id down_thread_id ): " + "up_thread_id=%d, down_thread_id=%d" ); + formatter % up_thread_id % down_thread_id; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + EVENT_TAG status = ACCEPT; + session_thread_data_sslid* threaddata_up = NULL; + session_thread_data_sslid* threaddata_down = NULL; + + try + { + // initialize the up/down thread data + threaddata_up = new session_thread_data_sslid; + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter("new: address=&(%d), size=%lu" ); + formatter % &threaddata_up % sizeof( session_thread_data_sslid ); + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + threaddata_up->realserver_connect_failed_count = 0; + threaddata_up->data_begain_offset = 0; + threaddata_up->data_size = 0; + threaddata_up->current_record_rest_size = 0; + threaddata_up->hello_message_flag = false; + threaddata_up->end_flag = END_FLAG_OFF; // set end_flag to OFF + threaddata_up->thread_division = THREAD_DIVISION_UP_STREAM; // up thread division + threaddata_up->pair_thread_id = down_thread_id; + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + // data dump + boost::format formatter("function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_session_initialize() : session_thread_data_sslid(upthread) : " + "realserver_connect_failed_count=%d, data_begain_offset=%d, " + "data_size=%d, current_record_rest_size=%d, hello_message_flag=%d," + "end_flag=%d, thread_division=%d, pair_thread_id=%d."); + formatter % threaddata_up->realserver_connect_failed_count + % threaddata_up->data_begain_offset + % threaddata_up->data_size + % threaddata_up->current_record_rest_size + % threaddata_up->hello_message_flag + % threaddata_up->end_flag + % threaddata_up->thread_division + % threaddata_up->pair_thread_id; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + threaddata_down = new session_thread_data_sslid; + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter("new: address=&(%d), size=%lu" ); + formatter % &threaddata_down % sizeof( session_thread_data_sslid ); + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + threaddata_down->realserver_connect_failed_count = 0; + threaddata_down->data_begain_offset = 0; + threaddata_down->data_size = 0; + threaddata_down->current_record_rest_size = 0; + threaddata_down->hello_message_flag = false; + threaddata_down->end_flag = END_FLAG_OFF; // set end_flag to OFF + threaddata_down->thread_division = THREAD_DIVISION_DOWN_STREAM; // down thread division + threaddata_down->pair_thread_id = up_thread_id; + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + // data_dump + boost::format formatter( "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_session_initialize() : session_thread_data_sslid(downthread) : " + "realserver_connect_failed_count=%d, data_begain_offset=%d, " + "data_size=%d, current_record_rest_size=%d, hello_message_flag=%d," + "end_flag=%d, thread_division=%d, pair_thread_id=%d."); + formatter % threaddata_down->realserver_connect_failed_count + % threaddata_down->data_begain_offset + % threaddata_down->data_size + % threaddata_down->current_record_rest_size + % threaddata_down->hello_message_flag + % threaddata_down->end_flag + % threaddata_down->thread_division + % threaddata_down->pair_thread_id; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + { + // insert the up/down thread data into the map + boost::mutex::scoped_lock sclock( session_thread_data_map_mutex ); + session_thread_data_map[up_thread_id] = threaddata_up; + session_thread_data_map[down_thread_id] = threaddata_down; + } + } + catch ( const std::bad_alloc& ba ) + { + if ( threaddata_up ) + { + delete threaddata_up; + threaddata_up = NULL; + } + + if ( threaddata_down ) + { + delete threaddata_down; + threaddata_down = NULL; + } + + std::cerr << "handle_session_initialize exception: Could not allocate memory." << std::endl; + putLogError( 037000, "Could not allocate memory.", __FILE__, __LINE__ ); + + status = FINALIZE; + } + catch ( const std::exception& e ) + { + if ( threaddata_up ) + { + delete threaddata_up; + threaddata_up = NULL; + } + + if ( threaddata_down ) + { + delete threaddata_down; + threaddata_down = NULL; + } + + std::cerr << "handle_session_initialize exception: error=%s" << e.what() << "." << std::endl; + boost::format formatter( "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_session_initialize() exception: result=%d, error=%s." ); + formatter % e.what(); + putLogError( 037000, formatter.str(), __FILE__, __LINE__ ); + + status = FINALIZE; + } + catch( ... ) + { + if ( threaddata_up ) + { + delete threaddata_up; + threaddata_up = NULL; + } + + if ( threaddata_down ) + { + delete threaddata_down; + threaddata_down = NULL; + } + + std::cerr << "Unkown exception." << std::endl; + putLogError( 037000, "function protocol_module_sslid::check_message_result " + "protocol_module_sslid::handle_session_initialize() : " + "Unkown exception.", __FILE__, __LINE__ ); + + status = FINALIZE; + } + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "out_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_session_initialize( const boost::thread::id up_thread_id," + "const boost::thread::id down_thread_id ): return_value=%d" ); + formatter % status; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + return status; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_session_finalize( + const boost::thread::id up_thread_id, + const boost::thread::id down_thread_id ) +{ + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "in_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_session_finalize( const boost::thread::id up_thread_id, " + "const boost::thread::id down_thread_id ): " + "up_thread_id=%d, down_thread_id=%d" ); + formatter % up_thread_id % down_thread_id; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + try + { + // delete the up/down thread data from the map + boost::mutex::scoped_lock sclock( session_thread_data_map_mutex ); + + session_thread_data_map_type::iterator itthread; + itthread = session_thread_data_map.find( up_thread_id ); + if ( itthread != session_thread_data_map.end() ) + { + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter("delete: address=&(%d)" ); + formatter % &itthread->second; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + delete itthread->second; + itthread->second = NULL; + session_thread_data_map.erase( itthread ); + } + + itthread = session_thread_data_map.find( down_thread_id ); + if ( itthread != session_thread_data_map.end() ) + { + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter("delete: address=&(%d)" ); + formatter % &itthread->second; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + delete itthread->second; + itthread->second = NULL; + session_thread_data_map.erase( itthread ); + } + } + catch ( const std::exception& e ) + { + std::cerr << "handle_session_finalize exception: error=%s" << e.what() << "." << std::endl; + boost::format formatter( "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_session_finalize() exception: result=%d, error=%s." ); + formatter % STOP % e.what(); + putLogError( 037000, formatter.str(), __FILE__, __LINE__ ); + } + catch( ... ) + { + std::cerr << "Unkown exception." << std::endl; + putLogError( 037000, "function protocol_module_sslid::check_message_result " + "protocol_module_sslid::handle_session_finalize() : " + "Unkown exception.", __FILE__, __LINE__ ); + } + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "out_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_session_finalize( const boost::thread::id up_thread_id," + "const boost::thread::id down_thread_id ): return_value=%d" ); + formatter % STOP; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + return STOP; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_accept( + const boost::thread::id thread_id ) +{ + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "in_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_accept( const boost::thread::id thread_id ): thread_id=%d" ); + formatter % thread_id; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + EVENT_TAG status = STOP; + // find thread id from map + boost::mutex::scoped_lock sclock( session_thread_data_map_mutex ); + try + { + session_thread_data_map_type::iterator it = session_thread_data_map.find( thread_id ); + if ( it == session_thread_data_map.end() ) + { + // waiting for jp response.....?????????????????? + putLogError(037000, "Invalid thread id.", __FILE__, __LINE__ ); + status = FINALIZE; + } + else + { + status = CLIENT_RECV; + } + } + catch ( const std::exception& e ) + { + std::cerr << "handle_accept exception: error=%s" << e.what() << "." << std::endl; + boost::format formatter( "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_accept() exception: result=%d, error=%s." ); + formatter % FINALIZE % e.what(); + putLogError( 037000, formatter.str(), __FILE__, __LINE__ ); + + status = FINALIZE; + } + catch( ... ) + { + std::cerr << "Unkown exception." << std::endl; + putLogError( 037000, "function protocol_module_sslid::check_message_result " + "protocol_module_sslid::handle_accept() : " + "Unkown exception.", __FILE__, __LINE__ ); + + status = FINALIZE; + } + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter("out_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_accept( const boost::thread::id thread_id ): return_value=%d."); + formatter % status; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + return status; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_client_recv( + const boost::thread::id thread_id, + const boost::array& recvbuffer, + const size_t recvlen ) +{ + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "in_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_client_recv( const boost::thread::id thread_id," + "const boost::array& recvbuffer," + "const size_t recvlen ): thread_id=%d, recvbuffer=%s, recvlen=%d" ); + formatter % thread_id % recvbuffer.data() % recvlen; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + // parameter check + if (recvlen > recvbuffer.size() ) + { + // waiting for jp response...?????????????????? + std::cerr << "handle_client_recv(): Data size bigger than buffer size." << std::endl; + putLogError(037000, "Data size bigger than buffer size.", __FILE__, __LINE__ ); + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "out_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_client_recv( const boost::thread::id thread_id," + "const boost::array& recvbuffer," + "const size_t recvlen ): return_value=%d" ); + formatter % FINALIZE; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + return FINALIZE; + } + + // find session_thread_data_sslid's pointer from map + session_thread_data_sslid* threaddata = NULL; + EVENT_TAG status = STOP; + + try + { + { + boost::mutex::scoped_lock sclock( session_thread_data_map_mutex ); + session_thread_data_map_type::iterator it = session_thread_data_map.find( thread_id ); + if ( it == session_thread_data_map.end() ) + { + // waiting for jp response.....?????????????????? + putLogError(037000, "Invalid thread id.", __FILE__, __LINE__ ); + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "out_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_client_recv( const boost::thread::id thread_id," + "const boost::array& recvbuffer," + "const size_t recvlen ): return_value=%d" ); + formatter % FINALIZE; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + return FINALIZE; + } + + threaddata = it->second; + } + + if ( threaddata->end_flag == END_FLAG_ON ) + { + // end_flag is ON, realserver is disconnect + status = CLIENT_RECV; + } + else + { + // end_flag is OFF + // get the c-style pointer from data buffer + char* databuf = threaddata->data_buffer.c_array(); + + if ( threaddata->data_size > 0 ) + { + // data length check + if ( threaddata->data_size + recvlen > threaddata->data_buffer.size() ) + { + // waiting for jp response...?????????????????? + std::cerr << "handle_client_recv(): Data size bigger than buffer size." << std::endl; + putLogError(037000, "Data size bigger than buffer size.", __FILE__, __LINE__ ); + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "out_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_client_recv( const boost::thread::id thread_id," + "const boost::array& recvbuffer," + "const size_t recvlen ): return_value=%d" ); + formatter % FINALIZE; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + return FINALIZE; + } + + // data dump + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "%02x" ); + for ( int i = 0; i < threaddata->data_size; ++i ) + { + formatter % static_cast( + static_cast( + threaddata->data_buffer[threaddata->data_begain_offset+i])); + } + + std::string datadump = formatter.str(); + formatter.parse( "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_client_recv( ): before memmove (data dump): " + "data begin(%d), data_size=%d,data=%s."); + formatter % threaddata->data_begain_offset % threaddata->data_size % datadump; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + // move the data from data start pos to buffer start pos + memmove( databuf, + &databuf[threaddata->data_begain_offset], + threaddata->data_size ); + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "%02x" ); + for ( int i = 0; i < threaddata->data_size; ++i ) + { + formatter % static_cast( + static_cast(threaddata->data_buffer[i])); + } + + std::string datadump = formatter.str(); + formatter.parse( "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_client_recv( ): after memmove (data dump): " + "data begin(0), data_size=%d,data=%s."); + formatter % threaddata->data_size % datadump; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + } + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "%02x" ); + for ( size_t i = 0; i < threaddata->data_size+recvlen; ++i ) + { + formatter % static_cast( + static_cast(threaddata->data_buffer[i])); + } + + std::string datadump = formatter.str(); + formatter.parse( "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_client_recv( ): before memcpy (data dump): " + "data begin(0), data_size=%d,data=%s."); + formatter % threaddata->data_size % datadump; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + // copy new recv data to data_buffer + memcpy( &databuf[threaddata->data_size], recvbuffer.data(), recvlen ); + + // add data size + threaddata->data_size += recvlen; + threaddata->data_begain_offset = 0; + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "%02x" ); + for ( size_t i = 0; i < threaddata->data_size+recvlen; ++i ) + { + formatter % static_cast( + static_cast(threaddata->data_buffer[i])); + } + + std::string datadump = formatter.str(); + formatter.parse( "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_client_recv( ): after memcpy (data dump): " + "data begin(0), data_size=%d,data=%s."); + formatter % threaddata->data_size % datadump; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + if ( threaddata->current_record_rest_size == 0 ) + { + // new SSL Record start + int alllength = 0; + bool ishellomessage = false; + int ret = check_ssl_record_sendable( true, + threaddata->data_buffer.data(), + threaddata->data_size, + alllength, + ishellomessage ); + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "function:protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_client_recv() : check_ssl_record_sendable() END.", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + if ( ret == -1 ) + { + // anomaly, set the end_flag to ON + threaddata->end_flag = END_FLAG_ON; + status = FINALIZE; + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_client_recv(): END_FLAG_ON.", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + } + else if ( ret == 1 ) + { + // disable send the data, set the status to CLIENT_RECV + status = CLIENT_RECV; + } + else + { + // enable send the data, set the status to REALSERVER_SELECT + // set client helloworld shakehand flag + threaddata->hello_message_flag = ishellomessage; + threaddata->current_record_rest_size = alllength; + status = REALSERVER_SELECT; + } + } + else + { + // other data + status = REALSERVER_SELECT; + } + } + } + catch ( const std::exception& e ) + { + std::cerr << "handle_client_recv exception: error=%s" << e.what() << "." << std::endl; + boost::format formatter( "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_client_recv() exception: result=%d, error=%s." ); + formatter % FINALIZE % e.what(); + putLogError( 037000, formatter.str(), __FILE__, __LINE__ ); + + status = FINALIZE; + } + catch( ... ) + { + std::cerr << "Unkown exception." << std::endl; + putLogError( 037000, "function protocol_module_sslid::check_message_result " + "protocol_module_sslid::handle_client_recv() : " + "Unkown exception.", __FILE__, __LINE__ ); + + status = FINALIZE; + } + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "out_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_client_recv( const boost::thread::id thread_id," + "const boost::array& recvbuffer," + "const size_t recvlen ): return_value=%d,end_flag=%d." ); + formatter % status % threaddata->end_flag; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + return status; +} + + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_realserver_select( + const boost::thread::id thread_id, + boost::asio::ip::tcp::endpoint& rs_endpoint ) +{ + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "in_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_realserver_select( const boost::thread::id thread_id, " + "boost::asio::ip::tcp::endpoint& rs_endpoint ): " + "thread_id=%d,rs_endpoint=[%s]:%d" ); + formatter % thread_id % rs_endpoint.address().to_string() % rs_endpoint.port(); + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + // find session_thread_data_sslid's pointer from map + session_thread_data_sslid* threaddata = NULL; + EVENT_TAG status = STOP; + + try + { + { + boost::mutex::scoped_lock sclock( session_thread_data_map_mutex ); + session_thread_data_map_type::iterator it = session_thread_data_map.find(thread_id); + if ( it == session_thread_data_map.end() ) + { + // waiting for jp response.....?????????????????? + putLogError(037000, "Invalid thread id.", __FILE__, __LINE__ ); + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "out_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_realserver_select( const boost::thread::id thread_id," + "boost::asio::ip::tcp::endpoint& rs_endpoint ): return_value=%d" ); + formatter % FINALIZE; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + // waiting for jp response Could not finalize protomod. (Realserver decision failure)?????? + putLogInfo( 035000, "Realserver decision failure", __FILE__, __LINE__ ); + + return FINALIZE; + } + + threaddata = it->second; + } + + if ( threaddata->realserver_connect_failed_count <= 0 ) + { + // the first connect or connected successful + if ( realserver_selected( threaddata->selected_realserver ) ) + { + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "realserver_selected() END.", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + // realserver already connected + rs_endpoint = threaddata->selected_realserver; + status = REALSERVER_CONNECT; + } + else + { + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "realserver_selected(): END.", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + // first connect + if ( !threaddata->hello_message_flag ) + { + // when the first connect, must be hellomessage + threaddata->end_flag = END_FLAG_ON; + status = FINALIZE; + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_realserver_select(): END_FLAG_ON.", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + } + else + { + // get sessionid from the data buffer + std::string session_id; + if ( get_ssl_session_id( threaddata->data_buffer.data(), threaddata->data_size, + session_id ) == -1 ) + { + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "out_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_realserver_select( const boost::thread::id thread_id," + "boost::asio::ip::tcp::endpoint& rs_endpoint ): return_value=%d" ); + formatter % FINALIZE; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + // waiting for jp response Could not finalize protomod. (Realserver decision failure)?????? + putLogInfo( 035000, "Realserver decision failure", __FILE__, __LINE__ ); + + return FINALIZE; + } + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_realserver_select( ): get_ssl_session_id() END.", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + if ( session_id.size() == 0 ) + { + // no session id in hellomesseage + // schedule the endpoint + boost::asio::ip::tcp::endpoint temp_endpoint; + boost::asio::ip::tcp::endpoint comp_endpoint; // for compare the endpoint + schedule_tcp(thread_id, rs_list_begin, rs_list_end, rs_list_next, temp_endpoint ); + if ( temp_endpoint != comp_endpoint ) + { + // success for get the endpoint by reschedule + threaddata->selected_realserver = temp_endpoint; + rs_endpoint = temp_endpoint; + status = REALSERVER_CONNECT; + } + else + { + // failed to get the endpoint by reschedule + // set end_flag to ON, and turn the status to CLIENT_DISCONNECT + threaddata->end_flag = END_FLAG_ON; + status = CLIENT_DISCONNECT; + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_realserver_select(): END_FLAG_ON.", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + } + } + else + { + // has session id in hellomessage + // try to get the endpoint from session data by session id + int ret = session_data_processor->get_endpoint_from_session_data( + session_id, + threaddata->selected_realserver ); + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_realserver_select(): get_endpoint_from_session_data() END.", + __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + if ( ret == 0 ) + { + // success for get the endpoint + rs_endpoint = threaddata->selected_realserver; + status = REALSERVER_CONNECT; + } + else + { + // failed to get the endpoint + if ( reschedule == 1 ) + { + // reschedule mode + boost::asio::ip::tcp::endpoint temp_endpoint; + boost::asio::ip::tcp::endpoint comp_endpoint; // for compare the endpoint + schedule_tcp(thread_id, rs_list_begin, rs_list_end, rs_list_next, temp_endpoint ); + if ( temp_endpoint != comp_endpoint ) + { + // success for get the endpoint by reschedule + threaddata->selected_realserver = temp_endpoint; + rs_endpoint = temp_endpoint; + status = REALSERVER_CONNECT; + } + else + { + // failed to get the endpoint by reschedule + // set end_flag to ON, and turn the status to CLIENT_DISCONNECT + threaddata->end_flag = END_FLAG_ON; + status = CLIENT_DISCONNECT; + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_realserver_select(): END_FLAG_ON.", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + } + } + else + { + // no reschedule mode + // set end_flag to ON and disconnect the client + threaddata->end_flag = END_FLAG_ON; + status = CLIENT_DISCONNECT; + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_realserver_select(): END_FLAG_ON.", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + } + } + } + } + } + } + else if ( threaddata->realserver_connect_failed_count < realserver_connect_failed_max_count ) + { + // try multi times connect + if ( reschedule == 1 ) + { + // reschedule mode + boost::asio::ip::tcp::endpoint temp_endpoint; + boost::asio::ip::tcp::endpoint comp_endpoint; // for compare the endpoint + schedule_tcp(thread_id, rs_list_begin, rs_list_end, rs_list_next, temp_endpoint ); + if ( temp_endpoint != comp_endpoint ) + { + // success for get the endpoint by reschedule + threaddata->selected_realserver = temp_endpoint; + rs_endpoint = temp_endpoint; + status = REALSERVER_CONNECT; + } + else + { + // failed to get the endpoint by reschedule + // set end_flag to ON, and turn the status to CLIENT_DISCONNECT + threaddata->end_flag = END_FLAG_ON; + status = CLIENT_DISCONNECT; + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_realserver_select(): END_FLAG_ON.", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + } + } + else + { + // no reschedule mode + // set end_flag to ON and disconnect the client + threaddata->end_flag = END_FLAG_ON; + status = CLIENT_DISCONNECT; + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_realserver_select(): END_FLAG_ON.", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + } + } + else + { + // connect failed + // set end_flag to ON and disconnect the client + threaddata->end_flag = END_FLAG_ON; + status = CLIENT_DISCONNECT; + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_realserver_select(): END_FLAG_ON.", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + } + } + catch ( const std::exception& e ) + { + std::cerr << "handle_realserver_select exception: error=%s" << e.what() << "." << std::endl; + boost::format formatter( "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_realserver_select() exception: result=%d, error=%s." ); + formatter % FINALIZE % e.what(); + putLogError( 037000, formatter.str(), __FILE__, __LINE__ ); + + // waiting for jp response Could not finalize protomod. (Realserver decision failure)?????? + putLogInfo( 035000, "Realserver decision failure", __FILE__, __LINE__ ); + + status = FINALIZE; + } + catch( ... ) + { + std::cerr << "Unkown exception." << std::endl; + putLogError( 037000, "function protocol_module_sslid::check_message_result " + "protocol_module_sslid::handle_realserver_select() : " + "Unkown exception.", __FILE__, __LINE__ ); + + // waiting for jp response Could not finalize protomod. (Realserver decision failure)?????? + putLogInfo( 035000, "Realserver decision failure", __FILE__, __LINE__ ); + + status = FINALIZE; + } + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "out_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_realserver_select( const boost::thread::id thread_id," + "boost::asio::ip::tcp::endpoint& rs_endpoint ): return_value=%d," + "end_flag=%d, rs_endpoint=[%s]:%d." ); + formatter % status % threaddata->end_flag % rs_endpoint.address().to_string() % rs_endpoint.port(); + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + return status; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_realserver_select( + const boost::thread::id thread_id, + boost::asio::ip::udp::endpoint& rs_endpoint, + boost::array& sendbuffer, + size_t& datalen ) +{ + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "in/out_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_realserver_select( const boost::thread::id thread_id," + "boost::asio::ip::tcp::endpoint& rs_endpoint, " + "boost::array& sendbuffer, size_t& datalen ): " + "return_value=%d." ); + formatter % STOP; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + return STOP; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_realserver_connect( + const boost::thread::id thread_id, + boost::array& sendbuffer, + size_t& datalen ) +{ + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "in_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_realserver_connect( const boost::thread::id thread_id," + "boost::array& sendbuffer, size_t& datalen ): " + "thread_id=%d, sendbuffer=%s, datalen=%d" ); + formatter % thread_id % sendbuffer.data() % datalen; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + EVENT_TAG status = REALSERVER_SEND; + try + { + if ( put_data_to_sendbuffer( thread_id, sendbuffer, datalen ) == -1 ) + { + // can't find the thread from the thread map + status = FINALIZE; + } + else + { + // find session_thread_data_sslid's pointer from map + boost::mutex::scoped_lock sclock( session_thread_data_map_mutex ); + + session_thread_data_map_type::iterator it = session_thread_data_map.find(thread_id); + if ( it == session_thread_data_map.end() ) + { + // waiting for jp response.....?????????????????? + putLogError(037000, "Invalid thread id.", __FILE__, __LINE__ ); + status = FINALIZE; + } + else + { + session_thread_data_sslid* threaddata = it->second; + threaddata->realserver_connect_failed_count = 0; + } + } + } + catch ( const std::exception& e ) + { + std::cerr << "handle_realserver_connect exception: error=%s" << e.what() << "." << std::endl; + boost::format formatter( "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_realserver_connect() exception: result=%d, error=%s." ); + formatter % FINALIZE % e.what(); + putLogError( 037000, formatter.str(), __FILE__, __LINE__ ); + status = FINALIZE; + } + catch( ... ) + { + std::cerr << "Unkown exception." << std::endl; + putLogError( 037000, "function protocol_module_sslid::check_message_result " + "protocol_module_sslid::handle_realserver_connect() : " + "Unkown exception.", __FILE__, __LINE__ ); + + status = FINALIZE; + } + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "out_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_realserver_connect( const boost::thread::id thread_id," + "boost::array& sendbuffer, size_t& datalen ): " + "return_value=%d" ); + formatter % status; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + return status; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_realserver_connection_fail( + const boost::thread::id thread_id, + const boost::asio::ip::tcp::endpoint& rs_endpoint ) +{ + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "in_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_realserver_connection_fail( const boost::thread::id thread_id," + "const boost::asio::ip::tcp::endpoint& rs_endpoint ): " + "thread_id=%d,rs_endpoint=[%s]:%d" ); + formatter % thread_id % rs_endpoint.address().to_string() % rs_endpoint.port(); + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + // find session_thread_data_sslid's pointer from map + session_thread_data_sslid* threaddata = NULL; + EVENT_TAG status = STOP; + + try + { + { + boost::mutex::scoped_lock sclock( session_thread_data_map_mutex ); + session_thread_data_map_type::iterator it = session_thread_data_map.find(thread_id); + if ( it == session_thread_data_map.end() ) + { + // waiting for jp response.....?????????????????? + putLogError(037000, "Invalid thread id.", __FILE__, __LINE__ ); + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "out_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_realserver_connection_fail( const boost::thread::id thread_id," + "const boost::asio::ip::tcp::endpoint& rs_endpoint ): return_value=%d" ); + formatter % FINALIZE; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + return FINALIZE; + } + + threaddata = it->second; + } + + if ( reschedule == 1 ) + { + // reschedule mode + ++threaddata->realserver_connect_failed_count; + status = REALSERVER_SELECT; + } + else + { + // no reschedule mode + // set end_flag to ON + threaddata->end_flag = END_FLAG_ON; + status = CLIENT_DISCONNECT; + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + putLogDebug( 030000, "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_realserver_connection_fail(): END_FLAG_ON.", __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + } + } + catch ( const std::exception& e ) + { + std::cerr << "handle_realserver_connection_fail exception: error=%s" << e.what() << "." << std::endl; + boost::format formatter( "function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_realserver_connection_fail() exception: result=%d, error=%s." ); + formatter % FINALIZE % e.what(); + putLogError( 037000, formatter.str(), __FILE__, __LINE__ ); + + status = FINALIZE; + } + catch( ... ) + { + std::cerr << "Unkown exception." << std::endl; + putLogError( 037000, "function protocol_module_sslid::check_message_result " + "protocol_module_sslid::handle_realserver_connection_fail() : " + "Unkown exception.", __FILE__, __LINE__ ); + + status = FINALIZE; + } + + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "out_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_realserver_connection_fail( const boost::thread::id thread_id," + "const boost::asio::ip::tcp::endpoint& rs_endpoint ): return_value=%d," + "end_flag=%d" ); + formatter % status % threaddata->end_flag; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + return status; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_realserver_send( + const boost::thread::id thread_id ) +{ + + return STOP; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_sorryserver_select( + const boost::thread::id thread_id, + boost::asio::ip::tcp::endpoint& sorry_endpoint ) +{ + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "in/out_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_sorryserver_select( const boost::thread::id thread_id," + "boost::asio::ip::tcp::endpoint& rs_endpoint ): " + "return_value=%d." ); + formatter % STOP; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + return STOP; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_sorryserver_connect( + const boost::thread::id thread_id, + boost::array& sendbuffer, + size_t& datalen ) +{ + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "in/out_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_sorryserver_connect( const boost::thread::id thread_id," + "boost::asio::ip::tcp::endpoint& rs_endpoint, size_t& datalen ): " + "return_value=%d." ); + formatter % STOP; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + return STOP; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_sorryserver_connection_fail( + const boost::thread::id thread_id, + const boost::asio::ip::tcp::endpoint& sorry_endpoint ) +{ + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "in/out_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_sorryserver_connection_fail( const boost::thread::id thread_id," + "boost::asio::ip::tcp::endpoint& rs_endpoint ): " + "return_value=%d." ); + formatter % STOP; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + return STOP; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_sorryserver_send( + const boost::thread::id thread_id ) +{ + /*-------- DEBUG LOG --------*/ + if ( LOG_LV_DEBUG == getloglevel() ) + { + boost::format formatter( "in/out_function: protocol_module_base::EVENT_TAG protocol_module_sslid::" + "handle_sorryserver_send( const boost::thread::id thread_id) :" + "return_value=%d." ); + formatter % STOP; + putLogDebug( 030000, formatter.str(), __FILE__, __LINE__ ); + } + /*------DEBUG LOG END------*/ + + return STOP; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_realserver_recv( + const boost::thread::id thread_id, + const boost::asio::ip::tcp::endpoint& rs_endpoint, + const boost::array& recvbuffer, + const size_t recvlen ) +{ + return STOP; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_realserver_recv( + const boost::thread::id thread_id, + const boost::asio::ip::udp::endpoint& rs_endpoint, + const boost::array& recvbuffer, + const size_t recvlen ) +{ + return STOP; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_sorryserver_recv( + const boost::thread::id thread_id, + const boost::asio::ip::tcp::endpoint& sorry_endpoint, + const boost::array& recvbuffer, + const size_t recvlen ) +{ + return STOP; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_response_send_inform( + const boost::thread::id thread_id ) +{ + return STOP; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_client_connection_check( + const boost::thread::id thread_id, + boost::array& sendbuffer, + size_t& datalen ) +{ + return STOP; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_client_select( + const boost::thread::id thread_id, + boost::asio::ip::udp::endpoint& cl_endpoint, + boost::array& sendbuffer, + size_t& datalen ) +{ + return STOP; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_client_send( + const boost::thread::id thread_id ) +{ + return STOP; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_client_disconnect( + const boost::thread::id thread_id ) +{ + return FINALIZE; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_sorry_enable( + const boost::thread::id thread_id ) +{ + return STOP; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_sorry_disable( + const boost::thread::id thread_id ) +{ + return STOP; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_realserver_disconnect( + const boost::thread::id thread_id, + const boost::asio::ip::tcp::endpoint& rs_endpoint ) +{ + return STOP; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_sorryserver_disconnect( + const boost::thread::id thread_id, + const boost::asio::ip::tcp::endpoint& sorry_endpoint ) +{ + return STOP; +} + +protocol_module_base::EVENT_TAG protocol_module_sslid::handle_realserver_close( + const boost::thread::id thread_id, + const boost::asio::ip::udp::endpoint& rs_endpoint ) +{ + return STOP; +} + +void protocol_module_sslid::replication_interrupt() +{ + +} + +//! put data into send buffer function +//! @param const boost::thread::id& thread_id +//! @param boost::array& sendbuffer +//! @param size_t& datalen +//! @return 0 : success -1: failed +int protocol_module_sslid::put_data_to_sendbuffer( + const boost::thread::id& thread_id, + boost::array& sendbuffer, + size_t& datalen) +{ + return 0; +} + +bool protocol_module_sslid::realserver_selected(const boost::asio::ip::tcp::endpoint& rs_endpoint) +{ + return true; +} + +} diff --git a/module/protocol/protocol_module_sslid.h b/module/protocol/protocol_module_sslid.h new file mode 100644 index 00000000..b482bc34 --- /dev/null +++ b/module/protocol/protocol_module_sslid.h @@ -0,0 +1,187 @@ +#ifndef PROTOCOL_MODULE_SSLID_H +#define PROTOCOL_MODULE_SSLID_H + +#include "ssl_protocol_module_base.h" +#include "sslid_replication_data_processor.h" +#include "sslid_session_data_processor.h" +#include +#include + +#define MAX_SSLID_BUFFER_SIZE (MAX_BUFFER_SIZE + 76) +namespace l7vs +{ + +struct session_thread_data_sslid +{ + int thread_division; + boost::thread::id pair_thread_id; + int end_flag; + int realserver_connect_failed_count; + boost::asio::ip::tcp::endpoint selected_realserver; + boost::array data_buffer; + int data_begain_offset; + int data_size; + int current_record_rest_size; + bool hello_message_flag; +}; + +class protocol_module_sslid : public ssl_protocol_module_base +{ + public: + protocol_module_sslid(); + + virtual ~protocol_module_sslid(); + + bool is_tcp(); + + bool is_udp(); + + void initialize( rs_list_itr_func_type inlist_begin, + rs_list_itr_func_type inlist_end, + rs_list_itr_func_type inlist_next, + boost::function< void( void ) > inlist_lock, + boost::function< void( void ) > inlist_unlock ); + + void finalize(); + + bool is_use_sorry(); + + check_message_result check_parameter( const std::vector& args ); + + check_message_result set_parameter( const std::vector& args ); + + check_message_result add_parameter( const std::vector& args ); + + void handle_rslist_update(); + + void register_schedule( tcp_schedule_func_type inschedule ); + + void register_schedule( udp_schedule_func_type inschedule ); + + EVENT_TAG handle_session_initialize( + const boost::thread::id up_thread_id, + const boost::thread::id down_thread_id ); + + EVENT_TAG handle_session_finalize( + const boost::thread::id up_thread_id, + const boost::thread::id down_thread_id ); + + EVENT_TAG handle_accept( const boost::thread::id thread_id ); + + EVENT_TAG handle_client_recv( + const boost::thread::id thread_id, + const boost::array& recvbuffer, + const size_t recvlen ); + + EVENT_TAG handle_realserver_select( + const boost::thread::id thread_id, + boost::asio::ip::tcp::endpoint& rs_endpoint ); + + EVENT_TAG handle_realserver_select( + const boost::thread::id thread_id, + boost::asio::ip::udp::endpoint& rs_endpoint, + boost::array& sendbuffer, + size_t& datalen ); + + EVENT_TAG handle_realserver_connect( + const boost::thread::id thread_id, + boost::array& sendbuffer, + size_t& datalen ); + + EVENT_TAG handle_realserver_connection_fail( + const boost::thread::id thread_id, + const boost::asio::ip::tcp::endpoint& rs_endpoint ); + + EVENT_TAG handle_realserver_send( const boost::thread::id thread_id ); + + EVENT_TAG handle_sorryserver_select( + const boost::thread::id thread_id, + boost::asio::ip::tcp::endpoint& sorry_endpoint ); + + EVENT_TAG handle_sorryserver_connect( + const boost::thread::id thread_id, + boost::array& sendbuffer, + size_t& datalen ); + + EVENT_TAG handle_sorryserver_connection_fail( + const boost::thread::id thread_id, + const boost::asio::ip::tcp::endpoint& sorry_endpoint ); + + EVENT_TAG handle_sorryserver_send( const boost::thread::id thread_id ); + + EVENT_TAG handle_realserver_recv( + const boost::thread::id thread_id, + const boost::asio::ip::tcp::endpoint& rs_endpoint, + const boost::array& recvbuffer, + const size_t recvlen ); + + EVENT_TAG handle_realserver_recv( + const boost::thread::id thread_id, + const boost::asio::ip::udp::endpoint& rs_endpoint, + const boost::array& recvbuffer, + const size_t recvlen ); + + EVENT_TAG handle_sorryserver_recv( + const boost::thread::id thread_id, + const boost::asio::ip::tcp::endpoint& sorry_endpoint, + const boost::array& recvbuffer, + const size_t recvlen ); + + EVENT_TAG handle_response_send_inform( const boost::thread::id thread_id ); + + EVENT_TAG handle_client_connection_check( + const boost::thread::id thread_id, + boost::array& sendbuffer, + size_t& datalen ); + + EVENT_TAG handle_client_select( + const boost::thread::id thread_id, + boost::asio::ip::udp::endpoint& cl_endpoint, + boost::array& sendbuffer, + size_t& datalen ); + + EVENT_TAG handle_client_send( const boost::thread::id thread_id ); + + EVENT_TAG handle_client_disconnect( const boost::thread::id thread_id ); + + EVENT_TAG handle_sorry_enable( const boost::thread::id thread_id ); + + EVENT_TAG handle_sorry_disable( const boost::thread::id thread_id ); + + EVENT_TAG handle_realserver_disconnect( + const boost::thread::id thread_id, + const boost::asio::ip::tcp::endpoint& rs_endpoint ); + + EVENT_TAG handle_sorryserver_disconnect( + const boost::thread::id thread_id, + const boost::asio::ip::tcp::endpoint& sorry_endpoint ); + + EVENT_TAG handle_realserver_close( + const boost::thread::id thread_id, + const boost::asio::ip::udp::endpoint& rs_endpoint ); + + void replication_interrupt(); + + bool realserver_selected( const boost::asio::ip::tcp::endpoint& rs_endpoint ); + + protected: + int put_data_to_sendbuffer( + const boost::thread::id& thread_id, + boost::array& sendbuffer, + size_t& datalen); + protected: + int timeout; + int maxlist; + int reschedule; + typedef std::map session_thread_data_map_type; + session_thread_data_map_type session_thread_data_map; + boost::mutex session_thread_data_map_mutex; + int realserver_connect_failed_max_count; + sslid_replication_data_processor* replication_data_processor; + sslid_session_data_processor* session_data_processor; + private: + static const std::string MODULE_NAME; +}; + +} +#endif // PROTOCOL_MODULE_SSLID_H diff --git a/unit_tests/sessionless/Makefile b/unit_tests/sessionless/Makefile new file mode 100644 index 00000000..e02ec9fe --- /dev/null +++ b/unit_tests/sessionless/Makefile @@ -0,0 +1,21 @@ +TARGET = sessionless_ut +CPP = g++ +INCLUDES = +CPPFLAGS = -g -Wall -Werror -pthread -O0 +LD = g++ +LIBS = -lboost_system_gcc41-mt \ + -lboost_thread_gcc41-mt +LDFLAGS = -lrt -ldl -pthread +SRCS = sessionless_ut.cpp +OBJS = $(SRCS:.cpp=.o) + +all: $(TARGET) + +$(TARGET): $(OBJS) + $(LD) $(INCLUDES) $(LDFLAGS) -o -$@ $(OBJS) $(LIBS) + +clean: + rm -f $(TARGET) $(OBJS) + +.cpp.o: + $(CPP) $(CPPFLAGS) $(INCLUDES) -c $< diff --git a/unit_tests/sessionless/sessionless_ut.cpp b/unit_tests/sessionless/sessionless_ut.cpp new file mode 100644 index 00000000..30e4d2f2 --- /dev/null +++ b/unit_tests/sessionless/sessionless_ut.cpp @@ -0,0 +1,1541 @@ +#include +#include "../../module/protocol/protocol_module_sessionless.cpp" + +using namespace std; +using namespace boost; +using namespace boost::unit_test; +using namespace l7vs; + +typedef l7vs::protocol_module_sessionless::check_message_result + check_message_result; + +//protocol_module_sessionless ég‰Æƒ +void protocol_module_sessionless_test(){ + + //unit_test[1] ƒ‚ƒWƒ…[ƒ‹–¼i"sessionless"j + protocol_module_sessionless obj1; + BOOST_CHECK_EQUAL("sessionless",obj1.name); + + //unit_test[2] new + protocol_module_sessionless *p1=new protocol_module_sessionless(); + BOOST_CHECK_EQUAL("sessionless", p1->name); + delete p1; +} + +//~protocol_module_sessionless ég‰Æƒ + +//is_tcp ég‰Æƒ +void is_tcp_test(){ + + //unit_test[4] TRUE‚ð•Ô‹p‚·‚é + protocol_module_sessionless obj; + BOOST_CHECK(obj.is_tcp()); +} + +//is_udp ég‰Æƒ +void is_udp_test(){ + + //unit_test[5] FALSE‚ð•Ô‹p‚·‚é + protocol_module_sessionless obj; + BOOST_CHECK(!obj.is_udp()); +} + +//get_name ég‰Æƒ +void get_name_test(){ + + //unit_test[5] ƒ‚ƒWƒ…[ƒ‹–¼i"sessionless"j‚ð•Ô‹p‚·‚é + protocol_module_sessionless obj; + BOOST_CHECK_EQUAL("sesslonless", obj.get_name()); +} + +//initialize “Ÿì•û +typedef protocol_module_sessionless::realserverlist_type real_server_list; +typedef protocol_module_sessionless::rs_list_itr_func_type rs_list_itr_func_type; +real_server_list real_list; +real_server_list::iterator real_begin() {return real_list.begin();} +real_server_list::iterator real_end() {return real_list.end();} +real_server_list::iterator real_next() {return ++real_list.begin();} +void list_lock_for_test() {} +void list_unlock_for_test() {} +void initialize_test() { + + //unit_test[1] RealServerƒŠƒXƒg‚ÌŠe‘€ìŠÖ”ƒƒ\ƒbƒh‚̃eƒXƒg + //unit_test[1] test data:RealServerƒŠƒXƒgæ“ªŽæ“¾ŠÖ”,RealServerƒŠƒXƒg––’[Žæ“¾ŠÖ”,RealServerƒŠƒXƒgŽŸ—v‘fŽæ“¾ŠÖ” + //unit_test[1] test data:RealServerƒŠƒXƒgƒƒbƒNŠÖ”,RealServerƒŠƒXƒgƒAƒ“ƒƒbƒNŠÖ” + rs_list_itr_func_type inrslist_begin = real_begin; + rs_list_itr_func_type inrslist_end = real_end; + rs_list_itr_func_type inrslist_next = real_next; + function inlist_lock = list_lock_for_test; + function inlist_unlock = list_unlock_for_test; + + protocol_module_sessionless sessionless; + sessionless.initialize(inrslist_begin,inrslist_end,inrslist_next,inlist_lock,inlist_unlock); + + BOOST_CHECK_EQUAL(sessionless.rs_list_begin, real_begin); + BOOST_CHECK_EQUAL(sessionless.rs_list_end, real_end); + BOOST_CHECK_EQUAL(sessionless.rs_list_next, real_next); + BOOST_CHECK_EQUAL(sessionless.rs_list_lock, list_lock_for_test); + BOOST_CHECK_EQUAL(sessionless.rs_list_unlock, list_unlock_for_test); + +}; + +//finalize “Ÿì•û +void finalize_test() { + + //unit_test[2] Še‘€ìŠÖ”‚ð‰Šú‰»‚·‚é + //unit_test[2] test data + protocol_module_sessionless sessionless; + sessionless.finalize(); + + BOOST_CHECK(!sessionless.getloglevel); + BOOST_CHECK(!sessionless.putLogFatal); + BOOST_CHECK(!sessionless.putLogError); + BOOST_CHECK(!sessionless.putLogWarn); + BOOST_CHECK(!sessionless.putLogInfo); + BOOST_CHECK(!sessionless.putLogDebug); + + BOOST_CHECK(!sessionless.rs_list_begin); + BOOST_CHECK(!sessionless.rs_list_end); + BOOST_CHECK(!sessionless.rs_list_next); + BOOST_CHECK(!sessionless.rs_list_lock); + BOOST_CHECK(!sessionless.rs_list_unlock); + + BOOST_CHECK(!sessionless.replication_pay_memory); + BOOST_CHECK(!sessionless.replication_area_lock); + BOOST_CHECK(!sessionless.replication_area_unlock); + + BOOST_CHECK(!sessionless.schedule_tcp); + BOOST_CHECK(!sessionless.schedule_udp); + + BOOST_CHECK_EQUAL(sessionless.forwarded_for, 0); + BOOST_CHECK_EQUAL( '\0', sessionless.sorry_uri[0] ); + +} + +//is_use_sorry ”n‰‰ +void is_use_sorry_test() { + protocol_module_sessionless sessionless; + + // unit_test[1] is_use_sorryƒƒ\ƒbƒh‚̃eƒXƒg + bool is_return = sessionless.is_use_sorry(); + BOOST_CHECK_EQUAL(is_return,true); +} + +//check_parameter ”n‰‰ +void check_parameter_test() { + protocol_module_sessionless sessionless; + check_message_result result; + vector args(5); + + // unit_test[2] ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉTRUE‚ðÝ’è‚·‚é + // unit_test[2] test data:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ‚Ƀf[ƒ^‚È‚µ + result = sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(result.flag,true); + + // unit_test[3] ‘—MŒ³Ý’èŽwŽ¦Ý’èƒtƒ‰ƒO‚ðON,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉTRUE‚ðÝ’è‚·‚é + // unit_test[3] test data:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-F" + args[0] = "l7vsadmin"; + args[1] = "-F"; + result = sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(result.flag,true); + + // unit_test[4] ‘—MŒ³Ý’èŽwŽ¦Ý’èƒtƒ‰ƒO‚ðON, ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉTRUE‚ðÝ’è‚·‚é + // unit_test[4] test data:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-F" + args[0] = "l7vsadmin"; + args[1] = "--forwarded-for"; + sessionless.check_parameter(args); + result = sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(result.flag,true); + + // unit_test[5] ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"'-S/--sorryURI' option value '%s' is too long."i%s‚ÍŽŸ—v‘fj‚ðÝ’è‚·‚é + // unit_test[5] test data:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-S" sorryURIÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ’· > 127 + args[0] = "l7vsadmin"; + args[1] = "-S"; + args[2] = "http://abcde.com/0123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/"; + result = sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(result.flag,false); + BOOST_CHECK_EQUAL(result.message,"'-S/--sorryURI' option value 'http://abcde.com/0123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/' is too long."); + + // unit_test[6] sorryURIÝ’èƒtƒ‰ƒO‚ðON ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"Cannot set multiple option ''-S/--sorryURI'."‚ðÝ’è‚·‚é + // unit_test[6] test data:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-S" sorryURIÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ’· = 127 ƒ`ƒFƒbƒNOK‚̏ꍇ + args[0] = "l7vsadmin"; + args[1] = "-S"; + args[2] = "http://abcde.com/0123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/12345678/"; + args[3] = "----sorryURI"; + args[4] = "http://abcde.com/0123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/12345678/"; + result = sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(result.message,"Cannot set multiple option ''-S/--sorryURI'."); + BOOST_CHECK_EQUAL(result.flag,false); + + // unit_test[7] ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"'-S/--sorryURI' option value '%s' is not a valid URI."i%s‚ÍŽŸ—v‘fj‚ðÝ’è‚·‚é + // unit_test[7] test data:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-S" sorryURIÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ’· = 127 ƒ`ƒFƒbƒNNG‚̏ꍇ + args[0] = "l7vsadmin"; + args[1] = "-S"; + args[2] = "http://abcde.com/0123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/1234567+/"; + result = sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(result.flag,false); + BOOST_CHECK_EQUAL(result.message,"'-S/--sorryURI' option value 'http://abcde.com/0123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/1234567+/' is not a valid URI."); + + // unit_test[8] sorryURIÝ’èƒtƒ‰ƒO‚ðON ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"Cannot set multiple option ''-S/--sorryURI'."‚ðÝ’è‚·‚é + // unit_test[8] test data:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-S" sorryURIÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ’· < 127 ƒ`ƒFƒbƒNOK‚̏ꍇ + args[0] = "l7vsadmin"; + args[1] = "-S"; + args[2] = "http://abcd.com/"; + args[3] = "----sorryURI"; + args[4] = "http://abcd.com/"; + result = sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(result.message,"Cannot set multiple option ''-S/--sorryURI'."); + BOOST_CHECK_EQUAL(result.flag,false); + + // unit_test[9] ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"'-S/--sorryURI' option value '%s' is not a valid URI."i%s‚ÍŽŸ—v‘fj‚ðÝ’è‚·‚é + // unit_test[9] test data:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-S" sorryURIÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ’· < 127 ƒ`ƒFƒbƒNNG‚̏ꍇ + args[0] = "l7vsadmin"; + args[1] = "-S"; + args[2] = "http://abcd.com/aa+"; + result = sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(result.flag,false); + BOOST_CHECK_EQUAL(result.message,"'-S/--sorryURI' option value 'http://abcd.com/aa+' is not a valid URI."); + + // unit_test[10] ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"You have to set option value ''-S/--sorryURI'."‚ðÝ’è‚·‚é + // unit_test[10] test data:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-S" sorryURIÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚ª‘¶Ý‚µ‚È‚¢ê‡ + args[0] = "l7vsadmin"; + args[1] = "-S"; + result = sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(result.flag,false); + BOOST_CHECK_EQUAL(result.message,"You have to set option value ''-S/--sorryURI'."); + + // unit_test[11] ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"Cannot set multiple option ''-S/--sorryURI'."‚ðÝ’è‚·‚é + // unit_test[11] test data:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-S" sorryURIÝ’èƒtƒ‰ƒO = ON + args[0] = "l7vsadmin"; + args[1] = "-S"; + args[2] = "http://abcd.com/"; + args[3] = "-S"; + args[4] = "http://www.xyz.com/"; + result = sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(result.flag,false); + BOOST_CHECK_EQUAL(result.message,"Cannot set multiple option ''-S/--sorryURI"); + + // unit_test[12] ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"Option error."‚ðÝ’è‚·‚é + // unit_test[12] test data:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ"-F","-S" ˆÈŠO‚̏ꍇ + args[0] = "l7vsadmin"; + args[1] = "-D"; + result = sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(result.flag,false); + BOOST_CHECK_EQUAL(result.message,"Option error."); + +} + +//set_parameter ”n‰‰ +void set_parameter_test() { + protocol_module_sessionless sessionless; + check_message_result result; + vector args(5); + + // unit_test[13] ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉTRUE‚ðÝ’è‚·‚é + // unit_test[13] test data:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ‚Ƀf[ƒ^‚È‚µ + result = sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(result.flag,true); + + // unit_test[14] ‘—MŒ³Ý’èŽwŽ¦‚É1‚ðÝ’è‚·‚é + args[0] = "l7vsadmin"; + sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(sessionless.forwarded_for,1); + + // unit_test[15] ‘—MŒ³Ý’èŽwŽ¦Ý’èƒtƒ‰ƒO‚ðON,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉTRUE‚ðÝ’è‚·‚é + // unit_test[15] test data:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-F" + args[0] = "l7vsadmin"; + args[1] = "-F"; + result = sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(sessionless.forwarded_for,1); + BOOST_CHECK_EQUAL(result.flag,true); + + // unit_test[16] ‘—MŒ³Ý’èŽwŽ¦Ý’èƒtƒ‰ƒO‚ðON,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉTRUE‚ðÝ’è‚·‚é + // unit_test[16] test data:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-F" + args[0] = "l7vsadmin"; + args[1] = "--forwarded-for"; + result = sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(sessionless.forwarded_for,1); + BOOST_CHECK_EQUAL(result.flag,true); + + // unit_test[17] ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"'-S/--sorryURI' option value '%s' is too long."i%s‚ÍŽŸ—v‘fj‚ðÝ’è‚·‚é + // unit_test[17] test data:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-S" sorryURIÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ’· > 127 + args[0] = "l7vsadmin"; + args[1] = "-S"; + args[2] = "http://abcde.com/0123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/"; + result = sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(result.flag,false); + BOOST_CHECK_EQUAL(result.message,"'-S/--sorryURI' option value 'http://abcde.com/0123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/' is too long."); + + // unit_test[18] sorryURIÝ’èƒtƒ‰ƒO‚ðON ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"Cannot set multiple option ''-S/--sorryURI'."‚ðÝ’è‚·‚é + // unit_test[18] test data:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-S" sorryURIÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ’· = 127 ƒ`ƒFƒbƒNOK‚̏ꍇ + args[0] = "l7vsadmin"; + args[1] = "-S"; + args[2] = "http://abcde.com/0123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/12345678/"; + args[3] = "--sorryURI"; + args[4] = "http://abcde.com/0123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/12345678/"; + result = sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(result.message,"Cannot set multiple option ''-S/--sorryURI'."); + BOOST_CHECK_EQUAL(result.flag,false); + + // unit_test[19] ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"'-S/--sorryURI' option value '%s' is not a valid URI."i%s‚ÍŽŸ—v‘fj‚ðÝ’è‚·‚é + // unit_test[19] test data:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-S" sorryURIÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ’· = 127 ƒ`ƒFƒbƒNNG‚̏ꍇ + args[0] = "l7vsadmin"; + args[1] = "-S"; + args[2] = "http://abcde.com/0123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/1234567+/"; + result = sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(result.flag,false); + BOOST_CHECK_EQUAL(result.message,"'-S/--sorryURI' option value 'http://abcde.com/0123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/123456789/1234567+/' is not a valid URI."); + + // unit_test[20] sorryURIÝ’èƒtƒ‰ƒO‚ðON ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"Cannot set multiple option ''-S/--sorryURI'."‚ðÝ’è‚·‚é + // unit_test[20] test data:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-S" sorryURIÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ’· < 127 ƒ`ƒFƒbƒNOK‚̏ꍇ + args[0] = "l7vsadmin"; + args[1] = "-S"; + args[2] = "http://abcd.com/"; + args[3] = "--sorryURI"; + args[4] = "http://abcd.com/"; + result = sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(result.message,"Cannot set multiple option ''-S/--sorryURI'."); + BOOST_CHECK_EQUAL(result.flag,false); + + // unit_test[21] ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"'-S/--sorryURI' option value '%s' is not a valid URI."i%s‚ÍŽŸ—v‘fj‚ðÝ’è‚·‚é + // unit_test[21] test data:ŽŸ—v‘f‚Ì•¶Žš—ñ’· < 127 ƒ`ƒFƒbƒNNG‚̏ꍇ + args[0] = "l7vsadmin"; + args[1] = "-S"; + args[2] = "http://abcd.com/aa+"; + result = sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(result.flag,false); + BOOST_CHECK_EQUAL(result.message,"'-S/--sorryURI' option value 'http://abcd.com/aa+' is not a valid URI."); + + // unit_test[22] ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"You have to set option value ''-S/--sorryURI'."‚ðÝ’è‚·‚é + // unit_test[22] test data:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-S" sorryURIÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚ª‘¶Ý‚µ‚È‚¢ê‡ + args[0] = "l7vsadmin"; + args[1] = "-S"; + result = sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(result.flag,false); + BOOST_CHECK_EQUAL(result.message,"You have to set option value ''-S/--sorryURI'."); + + // unit_test[23] ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"Cannot set multiple option ''-S/--sorryURI'."‚ðÝ’è‚·‚é + // unit_test[23] test data:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-S" sorryURIÝ’èƒtƒ‰ƒO = ON + args[0] = "l7vsadmin"; + args[1] = "-S"; + args[2] = "http://abcd.com/"; + args[3] = "-S"; + args[4] = "http://www.xyz.com/"; + result = sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(result.flag,false); + BOOST_CHECK_EQUAL(result.message,"Cannot set multiple option ''-S/--sorryURI"); + + // unit_test[24] ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"Option error."‚ðÝ’è‚·‚é + // unit_test[24] test data:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ"-F","-S" ˆÈŠO‚̏ꍇ + args[0] = "l7vsadmin"; + args[1] = "-D"; + result = sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(result.flag,false); + BOOST_CHECK_EQUAL(result.message,"Option error."); + + // unit_test[25] ‘—MŒ³Ý’èŽwŽ¦‚É0‚ðÝ’è‚·‚é + // unit_test[25] test data:ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO = TRUE‚̏ꍇA‘—MŒ³Ý’èŽwŽ¦Ý’èƒtƒ‰ƒO = OFF + args[0] = "l7vsadmin"; + args[1] = "-S"; + args[2] = "http://abcd.com/"; + sessionless.check_parameter(args); + BOOST_CHECK_EQUAL(sessionless.forwarded_for,0); + +} + +//add_parameter ”n‰‰ +void add_parameter_test() { + protocol_module_sessionless sessionless; + check_message_result result; + vector args(2); + + // unit_test[58] ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉTRUE‚ðÝ’è‚·‚é + // unit_test[58] test data:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ‚ª‘¶Ý‚µ‚È‚¢ê‡ + result = sessionless.add_parameter(args); + BOOST_CHECK_EQUAL(result.flag,true); + + // unit_test[59] ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é, ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"Cannot add option."‚ðÝ’è‚·‚é + // unit_test[59] test data:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ‚ª‘¶Ý‚·‚éê‡ + args[0] = "-F"; + result = sessionless.add_parameter(args); + BOOST_CHECK_EQUAL(result.flag,false); + BOOST_CHECK_EQUAL(result.message,"Cannot add option."); +} + +//handle_rslist_update ”n‰‰ + +//register_schedule(tcp) “Ÿì•û +void schedule_tcp( const boost::thread::id id, + rs_list_itr_func_type func_type1, + rs_list_itr_func_type func_type2, + rs_list_itr_func_type func_type3, + boost::asio::ip::tcp::endpoint& ) {}; +void register_schedule_tcp_test() { + + // unit_test[3] schedule_tcpƒƒ\ƒbƒh‚̃eƒXƒg + // unit_test[3] test data:ClientU‚蕪‚¯ˆ—ŠÖ” + protocol_module_sessionless::tcp_schedule_func_type func = schedule_tcp; + + protocol_module_sessionless sessionless; + sessionless.register_schedule(func); + + BOOST_CHECK_EQUAL(sessionless.schedule_tcp,schedule_tcp); +} + +//register_schedule(udp) “Ÿì•û + + +//handle_session_initialize “Ÿì•û +typedef protocol_module_sessionless::session_thread_data_sessionless session_thread_data; +typedef std::map< thread::id, session_thread_data*> thread_map; +void up_thread_func(){} +void down_thread_func(){} +void handle_session_initialize_test() { + + // unit_test[5] ‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é status = ACCEPT + // unit_test[5] test data:ƒXƒŒƒbƒh + boost::thread up_thread(up_thread_func); + boost::thread down_thread(down_thread_func); + + protocol_module_sessionless sessionless; + protocol_module_base::EVENT_TAG ret = + sessionless.handle_session_initialize(up_thread.get_id(),down_thread.get_id()); + + BOOST_CHECK_EQUAL( protocol_module_base::ACCEPT, ret); + + thread_map::iterator thread_map_iterator; + thread_map::iterator thread_map_iterator_end; + + //unit_test[6] ã‚èƒXƒŒƒbƒhƒ}ƒv‹ó‚̃eƒXƒg + //unit_test[6] test data:ƒ}ƒv + thread_map_iterator = sessionless.session_thread_data_map.find(up_thread.get_id()); + thread_map_iterator_end = sessionless.session_thread_data_map.end(); + BOOST_CHECK(thread_map_iterator != thread_map_iterator_end); + + //unit_test[7] ã‚èƒXƒŒƒbƒhƒ}ƒv‚̃eƒXƒg + thread_map_iterator = sessionless.session_thread_data_map.find(up_thread.get_id()); + session_thread_data* data = thread_map_iterator->second; + + BOOST_CHECK(!data); + BOOST_CHECK_EQUAL(up_thread.get_id(), data->thread_id); + BOOST_CHECK_EQUAL(0, data->thread_division); + BOOST_CHECK_EQUAL(down_thread.get_id(), data->pair_thread_id); + BOOST_CHECK(!(data->recive_data_map.empty())); + + BOOST_CHECK_EQUAL(data->end_flag, 0); + BOOST_CHECK_EQUAL(data->accept_end_flag, 0); + BOOST_CHECK_EQUAL(data->sorry_flag, 0); + BOOST_CHECK_EQUAL(data->sorryserver_switch_flag, 0); + BOOST_CHECK_EQUAL(data->realserver_switch_flag, 0); + + //unit_test[8] ‰º‚èƒXƒŒƒbƒhƒ}ƒv‹ó‚̃eƒXƒg + thread_map_iterator = sessionless.session_thread_data_map.find(down_thread.get_id()); + BOOST_CHECK(thread_map_iterator != thread_map_iterator_end); + + //unit_test[9] ‰º‚èƒXƒŒƒbƒhƒ}ƒv‚̃eƒXƒg + thread_map_iterator = sessionless.session_thread_data_map.find(down_thread.get_id()); + data = thread_map_iterator->second; + + BOOST_CHECK(!data); + BOOST_CHECK_EQUAL(down_thread.get_id(), data->thread_id); + BOOST_CHECK_EQUAL(data->thread_division, 1); + BOOST_CHECK_EQUAL(up_thread.get_id(), data->pair_thread_id); + BOOST_CHECK(!(data->recive_data_map.empty())); + + BOOST_CHECK_EQUAL(data->end_flag, 0); + BOOST_CHECK_EQUAL(data->accept_end_flag, 0); + BOOST_CHECK_EQUAL(data->sorry_flag, 0); + BOOST_CHECK_EQUAL(data->sorryserver_switch_flag, 0); + BOOST_CHECK_EQUAL(data->realserver_switch_flag, 0); +} + +//handle_session_finalize “Ÿì•û +void handle_session_finalize_test() { + + //unit_test[1] ƒZƒbƒVƒ‡ƒ“ƒXƒŒƒbƒh‚ɑΉž‚·‚éI—¹ˆ— + //unit_test[1] test data:ƒZƒbƒVƒ‡ƒ“ƒXƒŒƒbƒh‰Šú‰» + boost::thread up_thread(up_thread_func); + boost::thread down_thread(down_thread_func); + protocol_module_sessionless sessionless; + sessionless.handle_session_initialize(up_thread.get_id(),down_thread.get_id()); + protocol_module_base::EVENT_TAG ret = + sessionless.handle_session_finalize(up_thread.get_id(), down_thread.get_id()); + + thread_map::iterator thread_map_iterator; + thread_map::iterator thread_map_iterator_end; + thread_map_iterator = sessionless.session_thread_data_map.find(up_thread.get_id()); + + thread_map_iterator_end = sessionless.session_thread_data_map.end(); + BOOST_CHECK(thread_map_iterator == thread_map_iterator_end); + + thread_map_iterator = sessionless.session_thread_data_map.find(down_thread.get_id()); + BOOST_CHECK(thread_map_iterator == thread_map_iterator_end); + + BOOST_CHECK_EQUAL( protocol_module_base::STOP, ret); + +} + +//handle_accept “Ÿì•û +void thread_func_for_accept(){} +void handle_accept_test() { + + session_thread_data data; + boost::thread accept_thread(thread_func_for_accept); + + //unit_test[13] sorryó‘Ԃ̏ꍇ + //unit_test[13] test data:accept_end_flag=0,sorry_flag=1 + data.accept_end_flag = 0; + data.sorry_flag = 1; + + protocol_module_sessionless obj1; + obj1.session_thread_data_map.insert( + std::pair(accept_thread.get_id(), &data)); + + protocol_module_base::EVENT_TAG ret = obj1.handle_accept(accept_thread.get_id()); + + BOOST_CHECK_EQUAL(data.accept_end_flag, 1);//acceptŠ®—¹ƒtƒ‰ƒO‚ðON + BOOST_CHECK_EQUAL(ret, protocol_module_base::SORRYSERVER_SELECT);//‘JˆÚæƒXƒe[ƒ^ƒX=SORRYSERVER_SELECT + + //unit_test[13] sorryó‘ԈȊO‚̏ꍇ + data.accept_end_flag = 0; + data.sorry_flag = 0; + + protocol_module_sessionless obj2; + obj2.session_thread_data_map.insert( + std::pair(accept_thread.get_id(), &data)); + + ret = obj2.handle_accept(accept_thread.get_id()); + + BOOST_CHECK_EQUAL(data.accept_end_flag, 1);//acceptŠ®—¹ƒtƒ‰ƒO‚ðON + BOOST_CHECK_EQUAL(ret, protocol_module_base::REALSERVER_SELECT);//‘JˆÚæƒXƒe[ƒ^ƒX=REALSERVER_SELECT +} + +//handle_client_recv + +//handle_realserver_select(tcp) ég‰Æƒ +void upthread_func_for_handle_realserver_select_test(){} +void downthread_func_for_handle_realserver_select_test(){} + +void schedule_tcp_determinate(//endpoint = Œˆ’è + const boost::thread::id thread_id, + protocol_module_base::rs_list_itr_func_type rs_list_begin, + protocol_module_base::rs_list_itr_func_type rs_list_end, + protocol_module_base::rs_list_itr_func_type rs_list_next, + boost::asio::ip::tcp::endpoint &rs_endpoint){ + rs_endpoint.resize(1234); +} + +void schedule_tcp_nodeterminate(//endpoint = –¢Œˆ’è + const boost::thread::id thread_id, + protocol_module_base::rs_list_itr_func_type rs_list_begin, + protocol_module_base::rs_list_itr_func_type rs_list_end, + protocol_module_base::rs_list_itr_func_type rs_list_next, + boost::asio::ip::tcp::endpoint &rs_endpoint){ +} +void handle_realserver_select_test(){ + + //unit_test[6] endpoint = Œˆ’è + protocol_module_sessionless obj1; + + boost::thread upt1(upthread_func_for_handle_realserver_select_test); + boost::thread downt1(downthread_func_for_handle_realserver_select_test); + session_thread_data dataup; + session_thread_data datadown; + obj1.session_thread_data_map[upt1.get_id()] = &dataup; + obj1.session_thread_data_map[downt1.get_id()] = &datadown; + dataup.thread_division = 0; + dataup.pair_thread_id = downt1.get_id(); + datadown.thread_division = 1; + datadown.pair_thread_id = upt1.get_id(); + datadown.recive_data_map.clear(); + protocol_module_sessionless::tcp_schedule_func_type func1 = &schedule_tcp_determinate; + + obj1.register_schedule(func1); + + boost::asio::ip::tcp::endpoint ep1; + protocol_module_base::EVENT_TAG ret=obj1.handle_realserver_select(upt1.get_id(), ep1); + + BOOST_CHECK_EQUAL(ep1.size(), static_cast(1234)); + BOOST_CHECK(datadown.recive_data_map.find(ep1) != datadown.recive_data_map.end()); + BOOST_CHECK_EQUAL(ret, protocol_module_base::CLIENT_RECV); + + //unit_test[7] endpoint = –¢Œˆ’è + protocol_module_sessionless obj2; + + boost::thread upt2(upthread_func_for_handle_realserver_select_test); + session_thread_data dataup2; + obj2.session_thread_data_map[upt2.get_id()] = &dataup2; + dataup2.end_flag = 0; + protocol_module_sessionless::tcp_schedule_func_type func2 = &schedule_tcp_nodeterminate; + + obj2.register_schedule(func2); + + boost::asio::ip::tcp::endpoint ep2; + ret=obj2.handle_realserver_select(upt2.get_id(), ep2); + + BOOST_CHECK_EQUAL(dataup2.end_flag, 1); + BOOST_CHECK_EQUAL(ret, protocol_module_base::CLIENT_DISCONNECT); +} + +//handle_realserver_select(udp) + +//handle_realserver_connect + +//handle_realserver_connection_fail ég‰Æƒ +void handle_realserver_connection_fail_test(){ + //unit_test[8] I—¹ƒtƒ‰ƒO,‘JˆÚæƒXƒe[ƒ^ƒX + protocol_module_sessionless obj; + + boost::thread t; + boost::asio::ip::tcp::endpoint ep; + protocol_module_sessionless::EVENT_TAG ret; + + protocol_module_sessionless::session_thread_data_sessionless data; + data.thread_id = t.get_id(); + obj.session_thread_data_map[t.get_id()] = &data; + + ret = obj.handle_realserver_connection_fail(t.get_id(),ep); + + BOOST_CHECK_EQUAL(data.end_flag, 1); //I—¹ƒtƒ‰ƒO‚ðON + BOOST_CHECK_EQUAL(protocol_module_base::CLIENT_DISCONNECT, ret); //status = CLIENT_DISCONNECT +} + +//handle_realserver_send “Ÿì•û + +//handle_sorryserver_select ég‰Æƒ +void handle_sorryserver_select_test(){ + + //unit_test[9] ŠY“–ƒXƒŒƒbƒh‚Ì‘—M‰Â”\ƒf[ƒ^‚ðŽæ“¾‚·‚é,‰º‚èƒXƒŒƒbƒh‚ÉsorryserverŽóMƒoƒbƒtƒ@‚ðŠm•Û‚·‚é,‘—Mæendpoint,‘JˆÚæƒXƒe[ƒ^ƒX + protocol_module_sessionless obj; + + boost::thread upt,downt; + boost::asio::ip::tcp::endpoint ep; + protocol_module_sessionless::EVENT_TAG ret; + + //up,down thread map + protocol_module_sessionless::session_thread_data_sessionless dataup,datadown; + obj.session_thread_data_map[upt.get_id()] = &dataup; + obj.session_thread_data_map[downt.get_id()] = &datadown; + dataup.thread_id = upt.get_id(); + dataup.thread_division = 0; + dataup.pair_thread_id = downt.get_id(); + datadown.thread_id = downt.get_id(); + datadown.thread_division = 1; + datadown.pair_thread_id = upt.get_id(); + datadown.recive_data_map.clear(); + + //send_status‘—M‰Â”\ƒf[ƒ^ + protocol_module_sessionless::send_status st; + st.status = protocol_module_sessionless::SEND_OK; + st.send_possible_size = 2; + dataup.recive_data_map[ep].send_status_list.push_back(st); + + ret = obj.handle_sorryserver_select(upt.get_id(), ep); + + BOOST_CHECK(!datadown.recive_data_map.empty()); //‰º‚èƒXƒŒƒbƒh‚ÉsorryserverŽóMƒoƒbƒtƒ@‚ðŠm•Û‚·‚é + //BOOST_CHECK_EQUAL(ep, dataup.sorry_endpoint); // ‘—Mæendpoint‚Éendpoint‚ðÝ’è‚·‚é + BOOST_CHECK_EQUAL(protocol_module_base::SORRYSERVER_CONNECT, ret); //status = SORRYSERVER_CONNECT +} + +//handle_sorryserver_connect + +//handle_sorryserver_connection_fail + +//handle_sorryserver_send + +//handle_realserver_recv(tcp) + +//handle_realserver_recv(udp) + +//handle_sorryserver_recv + +//handle_response_send_inform + +//handle_client_connection_check +void handle_client_connection_check_test(){ + //unit_test[10] ‘—Mƒoƒbƒtƒ@ƒTƒCƒY@>@‘—M‰Â”\ƒf[ƒ^ƒTƒCƒY + protocol_module_sessionless obj1; + + boost::thread t1; + boost::array sbf1; + std::size_t d1; + protocol_module_sessionless::EVENT_TAG ret; + boost::asio::ip::tcp::endpoint ep1; + + //session_thread_data_sessionless + protocol_module_sessionless::session_thread_data_sessionless data1; + obj1.session_thread_data_map[t1.get_id()] = &data1; + //send_status + protocol_module_sessionless::send_status sd1; + sd1.status = protocol_module_sessionless::SEND_OK; + sd1.send_possible_size = 2; + sd1.send_offset = 1; + //recive_data + protocol_module_sessionless::recive_data rd1; + rd1.recive_buffer = "abcd"; + //send_status->recive_data + rd1.send_status_list.push_back(sd1); + //recive_data->session_thread_data_sessionless + data1.recive_data_map[ep1] = rd1; + + ret = obj1.handle_client_connection_check(t1.get_id(),sbf1,d1); + //‘—M‰Â”\ƒf[ƒ^‚ðæ“ª‚©‚ç‘—M‰Â”\ƒf[ƒ^ƒTƒCƒY•ªA‘—Mƒoƒbƒtƒ@‚ɃRƒs[‚·‚é + std::string chk1 = "bc"; + BOOST_CHECK_EQUAL(chk1.c_str(),sbf1.data()); + //‘—MÏƒf[ƒ^ƒTƒCƒY‚É‘—M‰Â”\ƒf[ƒ^ƒTƒCƒY‚ðÝ’è‚·‚é + BOOST_CHECK_EQUAL(data1.recive_data_map[ep1].send_status_list.rbegin()->send_end_size, 2); + //‘—M‰Â”\ƒf[ƒ^ƒTƒCƒY‚É0‚ðÝ’è‚·‚é + BOOST_CHECK_EQUAL(data1.recive_data_map[ep1].send_status_list.rbegin()->send_possible_size, 0); + //‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é + BOOST_CHECK_EQUAL(protocol_module_base::CLIENT_SEND, ret); + + + //unit_test[11] ‘—Mƒoƒbƒtƒ@ƒTƒCƒY@<@‘—M‰Â”\ƒf[ƒ^ƒTƒCƒY + protocol_module_sessionless obj2; + + boost::thread t2; + boost::array sbf2; + std::size_t d2; + boost::asio::ip::tcp::endpoint ep2; + + //session_thread_data_sessionless + protocol_module_sessionless::session_thread_data_sessionless data2; + obj2.session_thread_data_map[t2.get_id()] = &data2; + //send_status + protocol_module_sessionless::send_status sd2; + sd2.status = protocol_module_sessionless::SEND_OK; + sd2.send_possible_size = 5000; + sd2.send_offset = 1; + //recive_data + protocol_module_sessionless::recive_data rd2; + rd2.recive_buffer = "abcdefg"; + //send_status->recive_data + rd2.send_status_list.push_back(sd2); + //recive_data->session_thread_data_sessionless + data2.recive_data_map[ep2] = rd2; + + ret = obj2.handle_client_connection_check(t2.get_id(),sbf2,d2); + //‘—M‰Â”\ƒf[ƒ^‚ðæ“ª‚©‚ç‘—Mƒoƒbƒtƒ@ƒTƒCƒY•ªA‘—Mƒoƒbƒtƒ@‚ɃRƒs[‚·‚é + std::string chk2 = "bcdef"; + BOOST_CHECK_EQUAL(chk2.c_str(),sbf2.data()); + //‘—MÏƒf[ƒ^ƒTƒCƒY‚É‘—Mƒoƒbƒtƒ@ƒTƒCƒY‚ðÝ’è‚·‚é + int sbfsize = sbf2.max_size(); + BOOST_CHECK_EQUAL(data2.recive_data_map[ep2].send_status_list.rbegin()->send_end_size, sbfsize); + //‘—M‰Â”\ƒf[ƒ^ƒTƒCƒY‚©‚ç‘—Mƒoƒbƒtƒ@ƒTƒCƒY‚ðŒ¸ŽZ‚·‚é + BOOST_CHECK_EQUAL(5000-sbfsize,data2.recive_data_map[ep2].send_status_list.rbegin()->send_possible_size); + //‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é + BOOST_CHECK_EQUAL(protocol_module_base::CLIENT_SEND,ret); + + //unit_test[10] ‘—Mƒoƒbƒtƒ@ƒTƒCƒY@=@‘—M‰Â”\ƒf[ƒ^ƒTƒCƒY + protocol_module_sessionless obj3; + + boost::thread t3; + boost::array sbf3; + std::size_t d3; + boost::asio::ip::tcp::endpoint ep3; + + //session_thread_data_sessionless + protocol_module_sessionless::session_thread_data_sessionless data3; + obj1.session_thread_data_map[t3.get_id()] = &data3; + //send_status + protocol_module_sessionless::send_status sd3; + sd3.status = protocol_module_sessionless::SEND_OK; + sd3.send_possible_size = 4096; + sd3.send_offset = 1; + //recive_data + protocol_module_sessionless::recive_data rd3; + memset(rd3.recive_buffer,96,4096); + //send_status->recive_data + rd3.send_status_list.push_back(sd3); + //recive_data->session_thread_data_sessionless + data3.recive_data_map[ep3] = rd3; + + ret = obj3.handle_client_connection_check(t3.get_id(),sbf3,d3); + //‘—M‰Â”\ƒf[ƒ^‚ðæ“ª‚©‚ç‘—M‰Â”\ƒf[ƒ^ƒTƒCƒY•ªA‘—Mƒoƒbƒtƒ@‚ɃRƒs[‚·‚é + char *chk3; + memset(chk3,96,4095); + BOOST_CHECK_EQUAL(chk3, sbf3.data()); + //‘—MÏƒf[ƒ^ƒTƒCƒY‚É‘—M‰Â”\ƒf[ƒ^ƒTƒCƒY‚ðÝ’è‚·‚é + BOOST_CHECK_EQUAL(data3.recive_data_map[ep3].send_status_list.rbegin()->send_end_size, 4096); + //‘—M‰Â”\ƒf[ƒ^ƒTƒCƒY‚É0‚ðÝ’è‚·‚é + BOOST_CHECK_EQUAL(data3.recive_data_map[ep3].send_status_list.rbegin()->send_possible_size, 0); + //‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é + BOOST_CHECK_EQUAL(protocol_module_base::CLIENT_SEND, ret); + +} + +//handle_client_select +void handle_client_select_test(){ + //unit_test[1] STOP + protocol_module_sessionless obj; + + boost::thread t; + boost::asio::ip::udp::endpoint ep; + boost::array sbf; + std::size_t d; + protocol_module_sessionless::EVENT_TAG ret; + ret = obj.handle_client_select(t.get_id(),ep,sbf,d); + + BOOST_CHECK_EQUAL(protocol_module_base::STOP, ret); +} + +//handle_client_send + +//handle_client_disconnect ég‰Æƒ +void handle_client_disconnect_test(){ + //unit_test[12] ‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é + protocol_module_sessionless obj; + + protocol_module_sessionless::EVENT_TAG ret; + boost::thread t; + + ret=obj.handle_client_disconnect(t.get_id()); + BOOST_CHECK_EQUAL(protocol_module_base::FINALIZE,ret); +} + +//handle_sorry_enable ”n‰‰ +void thread_t(){} +void handle_sorry_enable_test() { + protocol_module_sessionless sessionless; + protocol_module_sessionless::EVENT_TAG status; + protocol_module_sessionless::send_status sendstatus; + protocol_module_sessionless::recive_data receivedata; + session_thread_data *thread_data = new session_thread_data(); + boost::thread thread_up(&thread_t); + boost::thread thread_down(&thread_t); + boost::thread::id thread_id_up = thread_up.get_id(); + boost::thread::id thread_id_down = thread_down.get_id(); + boost::asio::ip::tcp::endpoint endpoint; + boost::asio::ip::tcp::endpoint endpoint_down; + + // ã‚èƒXƒŒƒbƒh‚̏ꍇ + thread_data->thread_division = 0; + thread_data->thread_id = thread_id_up; + sessionless.session_thread_data_map.insert(std::pair(thread_id_up,thread_data)); + + // unit_test[26] sorryó‘Ô‚ðON,status = protocol_module_sessionless::ACCEPT + // unit_test[26] test data:acceptŠ®—¹ƒtƒ‰ƒOOFF‚̏ꍇ + sessionless.session_thread_data_map[thread_id_up]->accept_end_flag = 0; + status = sessionless.handle_sorry_enable(thread_id_up); + BOOST_CHECK_EQUAL(sessionless.session_thread_data_map[thread_id_up]->sorry_flag,1); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::ACCEPT); + + // unit_test[27] status =SORRYSERVER_SELECT + // unit_test[27] test data:acceptŠ®—¹ƒtƒ‰ƒOON‚̏ꍇ,sorryó‘Ԃ̏ꍇ,‘—M‰Â”\ƒf[ƒ^‚ ‚è‚̏ꍇ list 1Œ + sessionless.session_thread_data_map[thread_id_up]->accept_end_flag = 1; + sessionless.session_thread_data_map[thread_id_up]->sorry_flag = 1; + sendstatus.status = protocol_module_sessionless::SEND_OK; + sendstatus.send_possible_size = 10; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.insert(std::pair(endpoint,receivedata)); + status = sessionless.handle_sorry_enable(thread_id_up); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::SORRYSERVER_SELECT); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.clear(); + + // unit_test[28] status =SORRYSERVER_SELECT + // unit_test[28] test data:‘—M‰Â”\ƒf[ƒ^‚ ‚è‚̏ꍇ list 2Œ 1Œ‚ ‚è + sendstatus.status = protocol_module_sessionless::SEND_OK; + sendstatus.send_possible_size = 10; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_END; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.insert(std::pair(endpoint,receivedata)); + status = sessionless.handle_sorry_enable(thread_id_up); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::SORRYSERVER_SELECT); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.clear(); + + // unit_test[29] status =CLIENT_RECV + // unit_test[29] test data:‘—M‰Â”\ƒf[ƒ^‚È‚µ list 3Œ + sendstatus.status = protocol_module_sessionless::SEND_END; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_CONTINUE; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_NG; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.insert(std::pair(endpoint,receivedata)); + status = sessionless.handle_sorry_enable(thread_id_up); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::CLIENT_RECV); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.clear(); + + // unit_test[30] I—¹ƒtƒ‰ƒO‚ðON,status = REALSERVER_DISCONNECT + // unit_test[30] test data:sorryó‘ԈȊO‚̏ꍇ,‘—MŒp‘±ƒf[ƒ^‚ ‚è list 1Œ + sessionless.session_thread_data_map[thread_id_up]->sorry_flag = 0; + sendstatus.status = protocol_module_sessionless::SEND_CONTINUE; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.insert(std::pair(endpoint,receivedata)); + status = sessionless.handle_sorry_enable(thread_id_up); + BOOST_CHECK_EQUAL(sessionless.session_thread_data_map[thread_id_up]->end_flag,1); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::REALSERVER_DISCONNECT); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.clear(); + + // unit_test[31] I—¹ƒtƒ‰ƒO‚ðON,status = REALSERVER_DISCONNECT + // unit_test[31] test data:‘—MŒp‘±ƒf[ƒ^‚ ‚è list 2Œ 1Œ‚ ‚è + sendstatus.status = protocol_module_sessionless::SEND_CONTINUE; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_NG; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.insert(std::pair(endpoint,receivedata)); + status = sessionless.handle_sorry_enable(thread_id_up); + BOOST_CHECK_EQUAL(sessionless.session_thread_data_map[thread_id_up]->end_flag,1); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::REALSERVER_DISCONNECT); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.clear(); + + // unit_test[32] sorryserverØ‘Ö’†ƒtƒ‰ƒOON,sorryó‘Ô‚ðON,status = REALSERVER_DISCONNECT + // unit_test[32] test data:‘—MŒp‘±ƒf[ƒ^‚È‚µ list 3Œ + sendstatus.status = protocol_module_sessionless::SEND_END; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_NG; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_OK; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.insert(std::pair(endpoint,receivedata)); + status = sessionless.handle_sorry_enable(thread_id_up); + BOOST_CHECK_EQUAL(sessionless.session_thread_data_map[thread_id_up]->sorryserver_switch_flag,1); + BOOST_CHECK_EQUAL(sessionless.session_thread_data_map[thread_id_up]->sorry_flag,1); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::REALSERVER_DISCONNECT); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.clear(); + + // ‰º‚èƒXƒŒƒbƒh‚̏ꍇ + sessionless.session_thread_data_map.clear(); + thread_data->thread_division = 1; + thread_data->thread_id = thread_id_down; + sessionless.session_thread_data_map.insert(std::pair(thread_id_down,thread_data)); + + // unit_test[33] status =CLIENT_CONNECTION_CHECK + // unit_test[33] test data:sorryó‘Ԃ̏ꍇ,‘—M‰Â”\ƒf[ƒ^‚ ‚è list 1Œ + sessionless.session_thread_data_map[thread_id_down]->sorry_flag = 1; + sendstatus.status = protocol_module_sessionless::SEND_OK; + sendstatus.send_possible_size = 10; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.insert(std::pair(endpoint_down,receivedata)); + status = sessionless.handle_sorry_enable(thread_id_down); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::CLIENT_CONNECTION_CHECK); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.clear(); + + // unit_test[34] status =CLIENT_CONNECTION_CHECK + // unit_test[34] test data:‘—M‰Â”\ƒf[ƒ^‚ ‚è list 2Œ 1Œ‚ ‚è + sendstatus.status = protocol_module_sessionless::SEND_END; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_OK; + sendstatus.send_possible_size = 10; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.insert(std::pair(endpoint_down,receivedata)); + status = sessionless.handle_sorry_enable(thread_id_down); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::CLIENT_CONNECTION_CHECK); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.clear(); + + // unit_test[35] status =SORRYSERVER_RECV + // unit_test[35] test data:‘—M‰Â”\ƒf[ƒ^‚È‚µ list 3Œ + sendstatus.status = protocol_module_sessionless::SEND_END; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_CONTINUE; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_NG; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.insert(std::pair(endpoint_down,receivedata)); + status = sessionless.handle_sorry_enable(thread_id_down); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::SORRYSERVER_RECV); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.clear(); + + // unit_test[36] I—¹ƒtƒ‰ƒO‚ðON,status = REALSERVER_DISCONNECT + // unit_test[36] test data:sorryó‘ԈȊO‚̏ꍇ,‘—M•s‰Âƒf[ƒ^‚ ‚è list 1Œ + sessionless.session_thread_data_map[thread_id_down]->sorry_flag = 0; + sendstatus.status = protocol_module_sessionless::SEND_NG; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.insert(std::pair(endpoint_down,receivedata)); + status = sessionless.handle_sorry_enable(thread_id_down); + BOOST_CHECK_EQUAL(sessionless.session_thread_data_map[thread_id_down]->end_flag , 1); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::REALSERVER_DISCONNECT); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.clear(); + + // unit_test[37] I—¹ƒtƒ‰ƒO‚ðON,status = REALSERVER_DISCONNECT + // unit_test[37] test data:‘—Mƒf[ƒ^ŽcƒTƒCƒY „ ‚O@‚ª‘¶Ý‚·‚éê‡ list 2Œ + sendstatus.status = protocol_module_sessionless::SEND_END; + sendstatus.send_rest_size = 10; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_END; + sendstatus.send_rest_size = 20; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.insert(std::pair(endpoint_down,receivedata)); + status = sessionless.handle_sorry_enable(thread_id_down); + BOOST_CHECK_EQUAL(sessionless.session_thread_data_map[thread_id_down]->end_flag , 1); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::REALSERVER_DISCONNECT); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.clear(); + + // unit_test[38] sorryó‘Ô‚ðON + // unit_test[38] test data:‘—M•s‰Âƒf[ƒ^‚È‚µ@‚©‚@‘—Mƒf[ƒ^ŽcƒTƒCƒY „ ‚O@‚ª‘¶Ý‚µ‚È‚¢ê‡ list 1Œ + sendstatus.status = protocol_module_sessionless::SEND_END; + sendstatus.send_rest_size = 0; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.insert(std::pair(endpoint_down,receivedata)); + status = sessionless.handle_sorry_enable(thread_id_down); + BOOST_CHECK_EQUAL(sessionless.session_thread_data_map[thread_id_down]->sorry_flag,1); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.clear(); + + // unit_test[39] status = SORRYSERVER_RECV + // unit_test[39] test data:‘—M•s‰Âƒf[ƒ^‚È‚µ@‚©‚@‘—Mƒf[ƒ^ŽcƒTƒCƒY „ ‚O@‚ª‘¶Ý‚µ‚È‚¢ê‡,‘—M‰Â”\ƒf[ƒ^‚È‚µ list 1Œ + sendstatus.status = protocol_module_sessionless::SEND_END; + sendstatus.send_rest_size = 0; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.insert(std::pair(endpoint_down,receivedata)); + status = sessionless.handle_sorry_enable(thread_id_down); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::SORRYSERVER_RECV); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.clear(); + + // unit_test[40] ‘—M‰Â”\ƒf[ƒ^‚ ‚è status = CLIENT_CONNECTION_CHECK + // unit_test[40] test data:‘—M•s‰Âƒf[ƒ^‚È‚µ@‚©‚@‘—Mƒf[ƒ^ŽcƒTƒCƒY „ ‚O@‚ª‘¶Ý‚µ‚È‚¢ê‡,‘—M‰Â”\ƒf[ƒ^‚ ‚è list 3Œ + sendstatus.status = protocol_module_sessionless::SEND_OK; + sendstatus.send_rest_size = 0; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_CONTINUE; + sendstatus.send_rest_size = 0; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_END; + sendstatus.send_rest_size = 0; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.insert(std::pair(endpoint_down,receivedata)); + status = sessionless.handle_sorry_enable(thread_id_down); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::CLIENT_CONNECTION_CHECK); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.clear(); + + // unit_test[41] status =FINALIZE + // unit_test[41] test data:thread_id‘Ήž‚Ìsession_thread_data‚È‚µ + sendstatus.status = protocol_module_sessionless::SEND_OK; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.insert(std::pair(endpoint_down,receivedata)); + status = sessionless.handle_sorry_enable(thread_id_up); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::FINALIZE); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.clear(); + +} + +//handle_sorry_disable ”n‰‰ +void handle_sorry_disable_test(){ + protocol_module_sessionless sessionless; + protocol_module_sessionless::EVENT_TAG status; + protocol_module_sessionless::send_status sendstatus; + protocol_module_sessionless::recive_data receivedata; + session_thread_data *thread_data = new session_thread_data(); + boost::thread thread_up(&thread_t); + boost::thread thread_down(&thread_t); + boost::thread::id thread_id_up = thread_up.get_id(); + boost::thread::id thread_id_down = thread_down.get_id(); + boost::asio::ip::tcp::endpoint endpoint; + boost::asio::ip::tcp::endpoint endpoint_down; + + // ã‚èƒXƒŒƒbƒh‚̏ꍇ + thread_data->thread_division = 0; + thread_data->thread_id = thread_id_up; + sessionless.session_thread_data_map.insert(std::pair(thread_id_up,thread_data)); + + // unit_test[42] sorryó‘Ô‚ðOFF,status =ACCEPT + // unit_test[42] test data:acceptŠ®—¹ƒtƒ‰ƒOOFF‚̏ꍇ + sessionless.session_thread_data_map[thread_id_up]->accept_end_flag = 0; + status = sessionless.handle_sorry_disable(thread_id_up); + BOOST_CHECK_EQUAL(sessionless.session_thread_data_map[thread_id_up]->sorry_flag,0); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::ACCEPT); + + // unit_test[43] I—¹ƒtƒ‰ƒO‚ðON,status = SORRYSERVER_DISCONNECT + // unit_test[43] test data:acceptŠ®—¹ƒtƒ‰ƒOON‚̏ꍇ,sorryó‘Ԃ̏ꍇ,‘—MŒp‘±ƒf[ƒ^‚ ‚è list 1Œ + sessionless.session_thread_data_map[thread_id_up]->accept_end_flag = 1; + sessionless.session_thread_data_map[thread_id_up]->sorry_flag = 1; + sendstatus.status = protocol_module_sessionless::SEND_CONTINUE; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.insert(std::pair(endpoint,receivedata)); + status = sessionless.handle_sorry_disable(thread_id_up); + BOOST_CHECK_EQUAL(sessionless.session_thread_data_map[thread_id_up]->end_flag,1); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::SORRYSERVER_DISCONNECT); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.clear(); + + // unit_test[44] I—¹ƒtƒ‰ƒO‚ðON,status = SORRYSERVER_DISCONNECT + // unit_test[44] test data:‘—MŒp‘±ƒf[ƒ^‚ ‚è list 2Œ 1Œ‚ ‚è + sendstatus.status = protocol_module_sessionless::SEND_CONTINUE; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_NG; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.insert(std::pair(endpoint,receivedata)); + status = sessionless.handle_sorry_disable(thread_id_up); + BOOST_CHECK_EQUAL(sessionless.session_thread_data_map[thread_id_up]->end_flag,1); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::SORRYSERVER_DISCONNECT); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.clear(); + + // unit_test[45] realserverØ‘Ö’†,sorryó‘Ô‚ðOFF,status = SORRYSERVER_DISCONNECT + // unit_test[45] test data:‘—MŒp‘±ƒf[ƒ^‚È‚µ list 3Œ + sendstatus.status = protocol_module_sessionless::SEND_END; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_NG; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_OK; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.insert(std::pair(endpoint,receivedata)); + status = sessionless.handle_sorry_disable(thread_id_up); + BOOST_CHECK_EQUAL(sessionless.session_thread_data_map[thread_id_up]->realserver_switch_flag,1); + BOOST_CHECK_EQUAL(sessionless.session_thread_data_map[thread_id_up]->sorry_flag,0); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::SORRYSERVER_DISCONNECT); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.clear(); + + // unit_test[46] status =REALSERVER_SELECT + // unit_test[46] test data:sorryó‘ԈȊO‚̏ꍇ,‘—M‰Â”\ƒf[ƒ^‚ ‚è‚̏ꍇ list 1Œ + sessionless.session_thread_data_map[thread_id_up]->sorry_flag = 0; + sendstatus.status = protocol_module_sessionless::SEND_OK; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.insert(std::pair(endpoint,receivedata)); + status = sessionless.handle_sorry_disable(thread_id_up); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::REALSERVER_SELECT); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.clear(); + + // unit_test[47] status =REALSERVER_SELECT + // unit_test[47] test data:‘—M‰Â”\ƒf[ƒ^‚ ‚è‚̏ꍇ list 2Œ 1Œ‚ ‚è + sendstatus.status = protocol_module_sessionless::SEND_OK; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_END; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.insert(std::pair(endpoint,receivedata)); + status = sessionless.handle_sorry_disable(thread_id_up); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::REALSERVER_SELECT); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.clear(); + + // unit_test[48] status =CLIENT_RECV + // unit_test[48] test data:‘—M‰Â”\ƒf[ƒ^‚È‚µ list 3Œ + sendstatus.status = protocol_module_sessionless::SEND_END; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_CONTINUE; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_NG; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.insert(std::pair(endpoint,receivedata)); + status = sessionless.handle_sorry_disable(thread_id_up); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::CLIENT_RECV); + sessionless.session_thread_data_map[thread_id_up]->recive_data_map.clear(); + + // ‰º‚èƒXƒŒƒbƒh‚̏ꍇ + sessionless.session_thread_data_map.clear(); + thread_data->thread_division = 1; + thread_data->thread_id = thread_id_down; + sessionless.session_thread_data_map.insert(std::pair(thread_id_down,thread_data)); + + // unit_test[49] I—¹ƒtƒ‰ƒO‚ðON,status = SORRYSERVER_DISCONNECT + // unit_test[49] test data:sorryó‘Ԃ̏ꍇ,‘—M•s‰Âƒf[ƒ^‚ ‚è list 1Œ + sessionless.session_thread_data_map[thread_id_down]->sorry_flag = 1; + sendstatus.status = protocol_module_sessionless::SEND_NG; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.insert(std::pair(endpoint_down,receivedata)); + status = sessionless.handle_sorry_disable(thread_id_down); + BOOST_CHECK_EQUAL(sessionless.session_thread_data_map[thread_id_down]->end_flag , 1); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::SORRYSERVER_DISCONNECT); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.clear(); + + // unit_test[50] I—¹ƒtƒ‰ƒO‚ðON,status = SORRYSERVER_DISCONNECT + // unit_test[50] test data:‘—Mƒf[ƒ^ŽcƒTƒCƒY „ ‚O@‚ª‘¶Ý‚·‚éê‡ list 2Œ + sendstatus.status = protocol_module_sessionless::SEND_END; + sendstatus.send_rest_size = 10; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_END; + sendstatus.send_rest_size = 20; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.insert(std::pair(endpoint_down,receivedata)); + status = sessionless.handle_sorry_disable(thread_id_down); + BOOST_CHECK_EQUAL(sessionless.session_thread_data_map[thread_id_down]->end_flag , 1); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::SORRYSERVER_DISCONNECT); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.clear(); + + // unit_test[51] sorryó‘Ô‚ðOFF + // unit_test[51] test data:‘—M•s‰Âƒf[ƒ^‚È‚µ@‚©‚@‘—Mƒf[ƒ^ŽcƒTƒCƒY „ ‚O@‚ª‘¶Ý‚µ‚È‚¢ê‡ list 1Œ + sendstatus.status = protocol_module_sessionless::SEND_END; + sendstatus.send_rest_size = 0; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.insert(std::pair(endpoint_down,receivedata)); + status = sessionless.handle_sorry_disable(thread_id_down); + BOOST_CHECK_EQUAL(sessionless.session_thread_data_map[thread_id_down]->sorry_flag,0); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.clear(); + + // unit_test[52] sorryó‘Ô‚ðOFF,‘—M‰Â”\ƒf[ƒ^‚È‚µ status = REALSERVER_RECV + // unit_test[52] test data:‘—M•s‰Âƒf[ƒ^‚È‚µ@‚©‚@‘—Mƒf[ƒ^ŽcƒTƒCƒY „ ‚O@‚ª‘¶Ý‚µ‚È‚¢ê‡,‘—M‰Â”\ƒf[ƒ^‚È‚µ list 1Œ + sendstatus.status = protocol_module_sessionless::SEND_END; + sendstatus.send_rest_size = 0; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.insert(std::pair(endpoint_down,receivedata)); + status = sessionless.handle_sorry_disable(thread_id_down); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::REALSERVER_RECV); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.clear(); + + // unit_test[53] status = CLIENT_CONNECTION_CHECK + // unit_test[53] test data:‘—M•s‰Âƒf[ƒ^‚È‚µ@‚©‚@‘—Mƒf[ƒ^ŽcƒTƒCƒY „ ‚O@‚ª‘¶Ý‚µ‚È‚¢ê‡,‘—M‰Â”\ƒf[ƒ^‚ ‚è list 3Œ + sendstatus.status = protocol_module_sessionless::SEND_OK; + sendstatus.send_rest_size = 0; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_CONTINUE; + sendstatus.send_rest_size = 0; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_END; + sendstatus.send_rest_size = 0; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.insert(std::pair(endpoint_down,receivedata)); + status = sessionless.handle_sorry_disable(thread_id_down); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::CLIENT_CONNECTION_CHECK); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.clear(); + + // unit_test[54] status =CLIENT_CONNECTION_CHECK + // unit_test[54] test data:sorryó‘ԈȊO‚̏ꍇ,‘—M‰Â”\ƒf[ƒ^‚ ‚è list 1Œ + sessionless.session_thread_data_map[thread_id_down]->sorry_flag = 0; + sendstatus.status = protocol_module_sessionless::SEND_OK; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.insert(std::pair(endpoint_down,receivedata)); + status = sessionless.handle_sorry_disable(thread_id_down); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::CLIENT_CONNECTION_CHECK); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.clear(); + + // unit_test[55] status =CLIENT_CONNECTION_CHECK + // unit_test[55] test data:‘—M‰Â”\ƒf[ƒ^‚ ‚è list 2Œ 1Œ‚ ‚è + sendstatus.status = protocol_module_sessionless::SEND_END; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_OK; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.insert(std::pair(endpoint_down,receivedata)); + status = sessionless.handle_sorry_disable(thread_id_down); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::CLIENT_CONNECTION_CHECK); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.clear(); + + // unit_test[56] status =REALSERVER_RECV + // unit_test[56] test data:‘—M‰Â”\ƒf[ƒ^‚È‚µ list 3Œ + sendstatus.status = protocol_module_sessionless::SEND_END; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_CONTINUE; + receivedata.send_status_list.push_back(sendstatus); + sendstatus.status = protocol_module_sessionless::SEND_NG; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.insert(std::pair(endpoint_down,receivedata)); + status = sessionless.handle_sorry_disable(thread_id_down); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::REALSERVER_RECV); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.clear(); + + // unit_test[57] status =FINALIZE + // unit_test[57] test data:thread_id‘Ήž‚Ìsession_thread_data‚È‚µ + sendstatus.status = protocol_module_sessionless::SEND_OK; + receivedata.send_status_list.push_back(sendstatus); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.insert(std::pair(endpoint_down,receivedata)); + status = sessionless.handle_sorry_disable(thread_id_up); + BOOST_CHECK_EQUAL(status,protocol_module_sessionless::FINALIZE); + sessionless.session_thread_data_map[thread_id_down]->recive_data_map.clear(); +} + +//handle_realserver_disconnect(tcp) +void handle_realserver_disconnect_test(){ + + //unit_test[13] ã‚èƒXƒŒƒbƒh‚̏ꍇ->I—¹ƒtƒ‰ƒO‚ªON‚̏ꍇ + protocol_module_sessionless obj1; + + boost::thread t1; + boost::asio::ip::tcp::endpoint ep1; + protocol_module_sessionless::EVENT_TAG ret; + + protocol_module_sessionless::session_thread_data_sessionless data1; + obj1.session_thread_data_map[t1.get_id()] = &data1; + //make ã‚èƒXƒŒƒbƒh‚̏ꍇ 0->ã‚èƒXƒŒƒbƒh + data1.thread_division = 0; + //make I—¹ƒtƒ‰ƒO‚ªON‚̏ꍇ 1->on + data1.end_flag = 1; + + ret = obj1.handle_realserver_disconnect(t1.get_id(), ep1); + //‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é status = CLIENT_RECV + BOOST_CHECK_EQUAL(protocol_module_base::CLIENT_RECV, ret); + + + //unit_test[14] ã‚èƒXƒŒƒbƒh‚̏ꍇ->I—¹ƒtƒ‰ƒO‚ªOFF‚̏ꍇ->sorryserverØ‘Ö’†‚̏ꍇ->‘—M‰Â”\ƒf[ƒ^‚ ‚è + protocol_module_sessionless obj2; + + boost::thread t2; + boost::asio::ip::tcp::endpoint ep2; + + protocol_module_sessionless::session_thread_data_sessionless data2; + obj2.session_thread_data_map[t2.get_id()] = &data2; + //make ã‚èƒXƒŒƒbƒh‚̏ꍇ 0->ã‚èƒXƒŒƒbƒh + data2.thread_division = 0; + //make I—¹ƒtƒ‰ƒO‚ªOFF‚̏ꍇ 0->off + data2.end_flag = 0; + //make sorryserverØ‘Ö’†‚̏ꍇ 1->Ø‘Ö’† + data2.sorryserver_switch_flag = 1; + //make ‘—M‰Â”\ƒf[ƒ^‚ ‚è + protocol_module_sessionless::send_status st2; + st2.status = protocol_module_sessionless::SEND_OK; + st2.send_possible_size = 100; + data2.recive_data_map[ep2].send_status_list.push_back(st2); + + + ret = obj2.handle_realserver_disconnect(t2.get_id(),ep2); + //‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é status = SORRYSERVER_SELECT + BOOST_CHECK_EQUAL(protocol_module_base::SORRYSERVER_SELECT, ret); + + + //unit_test[15] ã‚èƒXƒŒƒbƒh‚̏ꍇ->I—¹ƒtƒ‰ƒO‚ªOFF‚̏ꍇ->sorryserverØ‘Ö’†‚̏ꍇ->‘—M‰Â”\ƒf[ƒ^‚È‚µ + protocol_module_sessionless obj3; + + boost::thread t3; + boost::asio::ip::tcp::endpoint ep3; + + protocol_module_sessionless::session_thread_data_sessionless data3; + obj3.session_thread_data_map[t3.get_id()] = &data3; + //make ã‚èƒXƒŒƒbƒh‚̏ꍇ 0->ã‚èƒXƒŒƒbƒh + data3.thread_division = 0; + //make I—¹ƒtƒ‰ƒO‚ªOFF‚̏ꍇ 0->off + data3.end_flag = 0; + //make sorryserverØ‘Ö’†‚̏ꍇ 1->Ø‘Ö’† + data3.sorryserver_switch_flag = 1; + //make ‘—M‰Â”\ƒf[ƒ^‚È‚µ + protocol_module_sessionless::send_status st3; + //send_possible=0 + st3.send_possible_size = 0; + data3.recive_data_map[ep3].send_status_list.push_back(st3); + + ret = obj3.handle_realserver_disconnect(t3.get_id(), ep3); + //‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é status = CLIENT_RECV + BOOST_CHECK_EQUAL(protocol_module_base::CLIENT_RECV, ret); + + + //unit_test[16] ã‚èƒXƒŒƒbƒh‚̏ꍇ->I—¹ƒtƒ‰ƒO‚ªOFF‚̏ꍇ->sorryserverØ‘Ö’†‚Å‚È‚¢ê‡ + protocol_module_sessionless obj4; + + boost::thread t4; + boost::asio::ip::tcp::endpoint ep4; + + protocol_module_sessionless::session_thread_data_sessionless data4; + obj4.session_thread_data_map[t4.get_id()] = &data4; + //make ã‚èƒXƒŒƒbƒh‚̏ꍇ 0->ã‚èƒXƒŒƒbƒh + data4.thread_division = 0; + //make I—¹ƒtƒ‰ƒO‚ªOFF‚̏ꍇ 0->off + data4.end_flag = 0; + //make sorryserverØ‘Ö’†‚Å‚È‚¢ê‡ 0->Ø‘Ö’†‚Å‚È‚¢ + data4.sorryserver_switch_flag = 0; + + ret = obj4.handle_realserver_disconnect(t4.get_id(),ep4); + //I—¹ƒtƒ‰ƒO‚ðON + BOOST_CHECK_EQUAL(data4.end_flag, 1); + //‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é status = CLIENT_RECV + BOOST_CHECK_EQUAL(protocol_module_base::CLIENT_RECV, ret); + + + //unit_test[17] ‰º‚èƒXƒŒƒbƒh‚̏ꍇ->‘—M‰Â”\ƒf[ƒ^‚ ‚è + protocol_module_sessionless obj5; + + boost::thread t5; + boost::asio::ip::tcp::endpoint ep5; + + protocol_module_sessionless::session_thread_data_sessionless data5; + obj5.session_thread_data_map[t5.get_id()] = &data5; + //make ‰º‚èƒXƒŒƒbƒh‚̏ꍇ 1->‰º‚èƒXƒŒƒbƒh + data5.thread_division = 1; + //make ‘—M‰Â”\ƒf[ƒ^‚ ‚è + protocol_module_sessionless::send_status st5; + st5.status = protocol_module_sessionless::SEND_OK; + //send_possible>0 + st5.send_possible_size = 100; + data5.recive_data_map[ep5].send_status_list.push_back(st5); + + ret = obj5.handle_realserver_disconnect(t5.get_id(), ep5); + //I—¹ƒtƒ‰ƒO‚ðON + BOOST_CHECK_EQUAL(data5.end_flag, 1); + //‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é status = CLIENT_CONNECTION_CHECK + BOOST_CHECK_EQUAL(protocol_module_base::CLIENT_CONNECTION_CHECK, ret); + + + //unit_test[18] ‰º‚èƒXƒŒƒbƒh‚̏ꍇ->‘—M‰Â”\ƒf[ƒ^‚È‚µ + protocol_module_sessionless obj6; + + boost::thread t6; + boost::asio::ip::tcp::endpoint ep6; + + protocol_module_sessionless::session_thread_data_sessionless data6; + obj6.session_thread_data_map[t6.get_id()] = &data6; + //make ‰º‚èƒXƒŒƒbƒh‚̏ꍇ 1->‰º‚èƒXƒŒƒbƒh + data6.thread_division = 1; + //make ‘—M‰Â”\ƒf[ƒ^‚È‚µ + protocol_module_sessionless::send_status st6; + //send_possible>0 + st5.send_possible_size = 0; + data6.recive_data_map[ep6].send_status_list.push_back(st6); + + ret = obj6.handle_realserver_disconnect(t6.get_id(), ep6); + //I—¹ƒtƒ‰ƒO‚ðON + BOOST_CHECK_EQUAL(data6.end_flag, 1); + //‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é status = CLIENT_DISCONNECT + BOOST_CHECK_EQUAL(protocol_module_base::CLIENT_DISCONNECT, ret); +} + +//handle_realserver_disconnect(udp) + +//handle_sorryserver_disconnect ég‰Æƒ +void handle_sorryserver_disconnect_test(){ + + //unit_test[19] ã‚èƒXƒŒƒbƒh‚̏ꍇ->I—¹ƒtƒ‰ƒO‚ªON‚̏ꍇ + protocol_module_sessionless obj1; + + boost::thread t1; + boost::asio::ip::tcp::endpoint ep1; + protocol_module_sessionless::EVENT_TAG ret; + + protocol_module_sessionless::session_thread_data_sessionless data1; + obj1.session_thread_data_map[t1.get_id()] = &data1; + //make ã‚èƒXƒŒƒbƒh‚̏ꍇ 0->ã‚èƒXƒŒƒbƒh + data1.thread_division = 0; + //make I—¹ƒtƒ‰ƒO‚ªON‚̏ꍇ 1->on + data1.end_flag = 1; + + ret = obj1.handle_realserver_disconnect(t1.get_id(), ep1); + //‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é status = CLIENT_RECV + BOOST_CHECK_EQUAL(protocol_module_base::CLIENT_RECV, ret); + + + //unit_test[20] ã‚èƒXƒŒƒbƒh‚̏ꍇ->I—¹ƒtƒ‰ƒO‚ªOFF‚̏ꍇ->realserverØ‘Ö’†‚̏ꍇ->‘—M‰Â”\ƒf[ƒ^‚ ‚è + protocol_module_sessionless obj2; + + boost::thread t2; + boost::asio::ip::tcp::endpoint ep2; + + protocol_module_sessionless::session_thread_data_sessionless data2; + obj2.session_thread_data_map[t2.get_id()] = &data2; + //make ã‚èƒXƒŒƒbƒh‚̏ꍇ 0->ã‚èƒXƒŒƒbƒh + data2.thread_division = 0; + //make I—¹ƒtƒ‰ƒO‚ªOFF‚̏ꍇ 0->off + data2.end_flag = 0; + //make realserverØ‘Ö’†‚̏ꍇ 1->Ø‘Ö’† + data2.realserver_switch_flag = 1; + //make ‘—M‰Â”\ƒf[ƒ^‚ ‚è + protocol_module_sessionless::send_status st2; + st2.status = protocol_module_sessionless::SEND_OK; + //send_possible>0 + st2.send_possible_size = 100; + data2.recive_data_map[ep2].send_status_list.push_back(st2); + + ret = obj2.handle_realserver_disconnect(t2.get_id(), ep2); + //‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é status = REALSERVER_SELECT + BOOST_CHECK_EQUAL(protocol_module_base::REALSERVER_SELECT, ret); + + + //unit_test[21] ã‚èƒXƒŒƒbƒh‚̏ꍇ->I—¹ƒtƒ‰ƒO‚ªOFF‚̏ꍇ->realserverØ‘Ö’†‚̏ꍇ->‘—M‰Â”\ƒf[ƒ^‚È‚µ + protocol_module_sessionless obj3; + + boost::thread t3; + boost::asio::ip::tcp::endpoint ep3; + + protocol_module_sessionless::session_thread_data_sessionless data3; + obj3.session_thread_data_map[t3.get_id()] = &data3; + //make ã‚èƒXƒŒƒbƒh‚̏ꍇ 0->ã‚èƒXƒŒƒbƒh + data3.thread_division = 0; + //make I—¹ƒtƒ‰ƒO‚ªOFF‚̏ꍇ 0->off + data3.end_flag = 0; + //make realserverØ‘Ö’†‚̏ꍇ 1->Ø‘Ö’† + data3.realserver_switch_flag = 1; + //make ‘—M‰Â”\ƒf[ƒ^‚È‚µ + protocol_module_sessionless::send_status st3; + //send_possible=0 + st3.send_possible_size = 0; + data3.recive_data_map[ep3].send_status_list.push_back(st3); + + ret = obj3.handle_realserver_disconnect(t3.get_id(), ep3); + //‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é status = CLIENT_RECV + BOOST_CHECK_EQUAL(protocol_module_base::CLIENT_RECV, ret); + + + //unit_test[22] ã‚èƒXƒŒƒbƒh‚̏ꍇ->I—¹ƒtƒ‰ƒO‚ªOFF‚̏ꍇ->realserverØ‘Ö’†‚Å‚È‚¢ê‡ + protocol_module_sessionless obj4; + + boost::thread t4; + boost::asio::ip::tcp::endpoint ep4; + + protocol_module_sessionless::session_thread_data_sessionless data4; + obj4.session_thread_data_map[t4.get_id()] = &data4; + //make ã‚èƒXƒŒƒbƒh‚̏ꍇ 0->ã‚èƒXƒŒƒbƒh + data4.thread_division = 0; + //make I—¹ƒtƒ‰ƒO‚ªOFF‚̏ꍇ 0->off + data4.end_flag = 0; + //make realserverØ‘Ö’†‚Å‚È‚¢ê‡ 0->Ø‘Ö’†‚Å‚È‚¢ + data4.realserver_switch_flag = 0; + + ret = obj4.handle_realserver_disconnect(t4.get_id(),ep4); + //I—¹ƒtƒ‰ƒO‚ðON + BOOST_CHECK_EQUAL(data4.end_flag,1); + //‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é status = CLIENT_RECV + BOOST_CHECK_EQUAL(protocol_module_base::CLIENT_RECV, ret); + + + //unit_test[23] ‰º‚èƒXƒŒƒbƒh‚̏ꍇ->‘—M‰Â”\ƒf[ƒ^‚ ‚è + protocol_module_sessionless obj5; + + boost::thread t5; + boost::asio::ip::tcp::endpoint ep5; + + protocol_module_sessionless::session_thread_data_sessionless data5; + obj5.session_thread_data_map[t5.get_id()] = &data5; + //make ‰º‚èƒXƒŒƒbƒh‚̏ꍇ 1->‰º‚èƒXƒŒƒbƒh + data5.thread_division = 1; + //make ‘—M‰Â”\ƒf[ƒ^‚ ‚è + protocol_module_sessionless::send_status st5; + st5.status = protocol_module_sessionless::SEND_OK; + //send_possible>0 + st5.send_possible_size = 100; + data5.recive_data_map[ep5].send_status_list.push_back(st5); + + ret = obj5.handle_realserver_disconnect(t5.get_id(),ep5); + //I—¹ƒtƒ‰ƒO‚ðON + BOOST_CHECK_EQUAL(data5.end_flag, 1); + //‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é status = CLIENT_CONNECTION_CHECK + BOOST_CHECK_EQUAL(protocol_module_base::CLIENT_CONNECTION_CHECK, ret); + + + //unit_test[24] ‰º‚èƒXƒŒƒbƒh‚̏ꍇ->‘—M‰Â”\ƒf[ƒ^‚È‚µ + protocol_module_sessionless obj6; + + boost::thread t6; + boost::asio::ip::tcp::endpoint ep6; + + protocol_module_sessionless::session_thread_data_sessionless data6; + obj6.session_thread_data_map[t6.get_id()] = &data6; + //make ‰º‚èƒXƒŒƒbƒh‚̏ꍇ 1->‰º‚èƒXƒŒƒbƒh + data6.thread_division = 1; + //make ‘—M‰Â”\ƒf[ƒ^‚È‚µ + protocol_module_sessionless::send_status st6; + //send_possible=0 + st6.send_possible_size = 0; + data6.recive_data_map[ep6].send_status_list.push_back(st6); + + ret = obj6.handle_realserver_disconnect(t6.get_id(),ep6); + //I—¹ƒtƒ‰ƒO‚ðON + BOOST_CHECK_EQUAL(data6.end_flag,1); + //‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é status = CLIENT_DISCONNECT + BOOST_CHECK_EQUAL(protocol_module_base::CLIENT_DISCONNECT,ret); +} + + +test_suite* init_unit_test_suite( int argc, char* argv[] ){ + + test_suite* ts = BOOST_TEST_SUITE( "sessionless test" ); + + ts->add(BOOST_TEST_CASE(&protocol_module_sessionless_test)); + ts->add(BOOST_TEST_CASE(&is_tcp_test)); + ts->add(BOOST_TEST_CASE(&is_udp_test)); + ts->add(BOOST_TEST_CASE(&get_name_test)); + ts->add(BOOST_TEST_CASE(&initialize_test)); + ts->add(BOOST_TEST_CASE(&finalize_test)); + ts->add(BOOST_TEST_CASE(&is_use_sorry_test)); + ts->add(BOOST_TEST_CASE(&check_parameter_test)); + ts->add(BOOST_TEST_CASE(&set_parameter_test)); + ts->add(BOOST_TEST_CASE(&add_parameter_test)); + ts->add(BOOST_TEST_CASE(®ister_schedule_tcp_test)); + ts->add(BOOST_TEST_CASE(&handle_session_initialize_test)); + ts->add(BOOST_TEST_CASE(&handle_session_finalize_test)); + ts->add(BOOST_TEST_CASE(&handle_accept_test)); + ts->add(BOOST_TEST_CASE(&handle_realserver_select_test)); + ts->add(BOOST_TEST_CASE(&handle_realserver_connection_fail_test)); + ts->add(BOOST_TEST_CASE(&handle_sorryserver_select_test)); + ts->add(BOOST_TEST_CASE(&handle_client_connection_check_test)); + ts->add(BOOST_TEST_CASE(&handle_client_select_test)); + ts->add(BOOST_TEST_CASE(&handle_client_disconnect_test)); + ts->add(BOOST_TEST_CASE(&handle_sorry_enable_test)); + ts->add(BOOST_TEST_CASE(&handle_sorry_disable_test)); + ts->add(BOOST_TEST_CASE(&handle_realserver_disconnect_test)); + ts->add(BOOST_TEST_CASE(&handle_sorryserver_disconnect_test)); + + framework::master_test_suite().add(ts); + return 0; +} + diff --git a/unit_tests/sslid/protocol_module_sslid_test.cpp b/unit_tests/sslid/protocol_module_sslid_test.cpp new file mode 100644 index 00000000..7cd9d18a --- /dev/null +++ b/unit_tests/sslid/protocol_module_sslid_test.cpp @@ -0,0 +1,1051 @@ +#include "sslid_to_be_test_file.h" +#include + +using namespace boost::unit_test; +using namespace l7vs; + +// declaration +std::list rs_list; +bool function_check_flag = false; +void rs_list_init(void); +void rs_list_fini(void); +std::list::iterator rs_list_itr_begin(void); +std::list::iterator rs_list_itr_end(void); +std::list::iterator rs_list_itr_next(void); +void list_lock(void); +void list_unlock(void); +void thread_callback(void); +void rs_list_init(void) +{ + for(int i=0; i<5; i++) + { + realserver rs; + rs_list.push_back(rs); + } +} + +void rs_list_fini(void) +{ + rs_list.clear(); +} + +std::list::iterator rs_list_itr_begin(void) +{ + function_check_flag = true; + return rs_list.begin(); +} + +std::list::iterator rs_list_itr_end(void) +{ + function_check_flag = true; + return rs_list.end(); +} + +std::list::iterator rs_list_itr_next(void) +{ + function_check_flag = true; + return ++rs_list.begin(); +} + +void list_lock(void) +{ + function_check_flag = true; +} + +void list_unlock(void) +{ + function_check_flag = true; +} + +void thread_callback(void){} + +void thread_func(){} + +void thread_func2(){} + +bool check=false; + + +//protocol_module_sslid 鸎u”ò +void protocol_module_sslid_test(){ + + protocol_module_sslid sslid; + + // unit_test[1] check the module name + BOOST_CHECK_EQUAL("sslid", sslid.name); +} + +//is_tcp ‹–H•² +void is_tcp_test(){ + protocol_module_sslid sslid; + //unit_test[1] is_tcp()ƒƒ\ƒbƒh‚̃eƒXƒg@ normal + //unit_test[1] test data:NULL + BOOST_CHECK(sslid.is_tcp()); +} + +//is_udp ‹–H•² +void is_udp_test(){ + protocol_module_sslid sslid; + //unit_test[2] is_udp()ƒƒ\ƒbƒh‚̃eƒXƒg@ normal + //unit_test[2] test data:NULL + BOOST_CHECK(!sslid.is_udp()); +} + +//get_name ‹–H•² +void get_name_test() +{ + protocol_module_sslid sslid; + std::string name=sslid.get_name(); + std::string sslidname="sslid"; + //unit_test[3]@get_name()ƒƒ\ƒbƒh‚̃eƒXƒg@ normal + //unit_test[3] test data:NULL + BOOST_CHECK_EQUAL(sslidname,name); +} + +//initialize 鸎u”ò +void initialize_test(){ + + std::list rs_list; + rs_list_init(); + boost::function::iterator(void)> inrslist_begin = rs_list_itr_begin; + boost::function::iterator(void)> inrslist_end = rs_list_itr_end; + boost::function::iterator(void)> inrslist_next = rs_list_itr_next; + boost::function inlist_lock = list_lock; + boost::function inlist_unlock = list_unlock; + l7vs::protocol_module_sslid sslid; + + // unit_test[3] check the initial data + sslid.initialize(inrslist_begin, inrslist_end, inrslist_next, inlist_lock, inlist_unlock); + BOOST_CHECK_EQUAL(sslid.rs_list_begin, rs_list_itr_begin); + function_check_flag = false; + sslid.rs_list_begin(); + BOOST_CHECK(function_check_flag); + BOOST_CHECK_EQUAL(sslid.rs_list_end, rs_list_itr_end); + function_check_flag = false; + sslid.rs_list_end(); + BOOST_CHECK(function_check_flag); + BOOST_CHECK_EQUAL(sslid.rs_list_next, rs_list_itr_next); + function_check_flag = false; + sslid.rs_list_next(); + BOOST_CHECK(function_check_flag); + BOOST_CHECK_EQUAL(sslid.rs_list_lock, list_lock); + function_check_flag = false; + sslid.rs_list_lock(); + BOOST_CHECK(function_check_flag); + BOOST_CHECK_EQUAL(sslid.rs_list_unlock, list_unlock); + function_check_flag = false; + sslid.rs_list_unlock(); + BOOST_CHECK(function_check_flag); + + // unit_test[4] pass NULL to initialize(), check function object + sslid.initialize(NULL, NULL, NULL, NULL, NULL); + BOOST_CHECK(!sslid.rs_list_begin); + BOOST_CHECK(!sslid.rs_list_end); + BOOST_CHECK(!sslid.rs_list_next); + BOOST_CHECK(!sslid.rs_list_lock); + BOOST_CHECK(!sslid.rs_list_unlock); + + rs_list_fini(); +} + +//finalize 鸎u”ò +void finalize_test(){ + l7vs::protocol_module_sslid sslid; + + // unit_test[5] check finalize + sslid.finalize(); + BOOST_CHECK(!sslid.getloglevel); + BOOST_CHECK(!sslid.putLogFatal); + BOOST_CHECK(!sslid.putLogError); + BOOST_CHECK(!sslid.putLogWarn); + BOOST_CHECK(!sslid.putLogInfo); + BOOST_CHECK(!sslid.putLogDebug); + BOOST_CHECK(!sslid.rs_list_begin); + BOOST_CHECK(!sslid.rs_list_end); + BOOST_CHECK(!sslid.rs_list_next); + BOOST_CHECK(!sslid.rs_list_lock); + BOOST_CHECK(!sslid.rs_list_unlock); + BOOST_CHECK(!sslid.replication_pay_memory); + BOOST_CHECK(!sslid.replication_area_lock); + BOOST_CHECK(!sslid.replication_area_unlock); + BOOST_CHECK(!sslid.schedule_tcp); + BOOST_CHECK(!sslid.schedule_udp); + BOOST_CHECK_EQUAL(sslid.timeout, 0); + BOOST_CHECK_EQUAL(sslid.maxlist, 0); + BOOST_CHECK_EQUAL(sslid.reschedule, 0); + BOOST_CHECK(sslid.session_data_processor == NULL); + BOOST_CHECK(sslid.replication_data_processor == NULL); +} + +//is_use_sorry ‹–H•² +void is_use_sorry_test() +{ + protocol_module_sslid sslid; + //unit_test[4] is_use_sorry()ƒƒ\ƒbƒh‚̃eƒXƒg@ normal + //unit_test[4] test data:NULL + BOOST_CHECK(!sslid.is_use_sorry()); +} + +//check_parameter ‹–H•² +void check_parameter_test() +{ + + l7vs::protocol_module_sslid sslid; + std::vector args; + + //unit_test[13] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ‚ª‘¶Ý‚µ‚È‚¢ê‡, ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉTRUE‚ðÝ’è‚·‚é + //unit_test[13] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ‚ª‘¶Ý‚µ‚È‚¢ê‡ + args.push_back("l7vsdadm"); + protocol_module_base::check_message_result check_message; + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(true,check_message.flag); + + //unit_test[14] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-T", timeoutÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚ª‘¶Ý‚µ‚È‚¢ê‡,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉTRUE‚ðÝ’è‚·‚é + //unit_test[14] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-T", timeoutÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚ª‘¶Ý‚µ‚È‚¢ê‡ + args.push_back("-T"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(true,check_message.flag); + + + //unit_test[15] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-T" timeoutÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ɐ”ŽšˆÈŠO‚ªŠÜ‚Ü‚ê‚Ä‚¢‚éê‡,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"'-T/--timeout' option value 2ewqt is not numeric character."‚ðÝ’è‚·‚é + //unit_test[15] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-T" timeoutÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ɐ”ŽšˆÈŠO‚ªŠÜ‚Ü‚ê‚Ä‚¢‚éê‡ + args.push_back("2ewqt"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(false,check_message.flag); + BOOST_CHECK_EQUAL(check_message.message,"'-T/--timeout option' value 2ewqt is not numeric character."); + + //unit_test[16] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-T" timeoutÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš‚̏ꍇ ”’l „ INT_MAX,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"'-T/--timeout' option value 2148583647 is not numeric character."‚ðÝ’è‚·‚é + //unit_test[16] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-T" timeoutÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš‚̏ꍇ ”’l „ INT_MAX + args.pop_back(); + args.push_back("2148583647"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(false,check_message.flag); + BOOST_CHECK_EQUAL(check_message.message,"'-T/--timeout option' value 2148583647 is too large."); + + //unit_test[17] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-T" timeoutÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš‚̏ꍇ ”’l < INT_MAX,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉTRUE‚ðÝ’è‚·‚é + //unit_test[17] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-T" timeoutÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš‚̏ꍇ ”’l < INT_MAX + args.pop_back(); + args.push_back("2000"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(true,check_message.flag); + + //unit_test[18] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-T" timeoutÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš‚̏ꍇ ”’l = INT_MAX,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉTRUE‚ðÝ’è‚·‚é + //unit_test[18] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-T" timeoutÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš‚̏ꍇ ”’l = INT_MAX + args.pop_back(); + args.push_back("2147483674"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(true,check_message.flag); + + //unit_test[19] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-T" timeoutÝ’èƒtƒ‰ƒO = ON ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš‚̏ꍇ ”’l <= INT_MAX,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"Cannot set multiple option '-T/timeout'"‚ðÝ’è‚·‚é + //unit_test[19] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-T" timeoutÝ’èƒtƒ‰ƒO = ON ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš‚̏ꍇ ”’l = INT_MAX + args.pop_back(); + args.push_back("2000"); + args.push_back("-T"); + args.push_back("3000"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(false,check_message.flag); + BOOST_CHECK_EQUAL("Cannot set multiple option '-T/timeout'",check_message.message); + + //unit_test[20] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--timeout" timeoutÝ’èƒtƒ‰ƒO = ON ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš‚̏ꍇ ”’l <= INT_MAX,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"Cannot set multiple option '-T/timeout'"‚ðÝ’è‚·‚é + //unit_test[20] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-T" timeoutÝ’èƒtƒ‰ƒO = ON ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš‚̏ꍇ ”’l = INT_MAX + args.pop_back(); + args.pop_back(); + args.push_back("--timeout"); + args.push_back("100"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(false,check_message.flag); + BOOST_CHECK_EQUAL("Cannot set multiple option'-T/--timeout'",check_message.message); + + //unit_test[21] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--timeout" timeoutÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚ª‘¶Ý‚µ‚È‚¢ê‡,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉTRUE‚ðÝ’è‚·‚é + //unit_test[21] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--timeout" timeoutÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚ª‘¶Ý‚µ‚È‚¢ê‡ + args.pop_back(); + args.pop_back(); + args.pop_back(); + args.pop_back(); + args.push_back("--timeout"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(true,check_message.flag); + + + //unit_test[22] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--timeout" timeoutÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ɐ”ŽšˆÈŠO‚ªŠÜ‚Ü‚ê‚Ä‚¢‚éê‡,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"'-T/--timeout' option value 2ewqt is not numeric character."‚ðÝ’è‚·‚é + //unit_test[22] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--timeout" timeoutÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ɐ”ŽšˆÈŠO‚ªŠÜ‚Ü‚ê‚Ä‚¢‚éê‡ + args.push_back("2ewqt"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(false,check_message.flag); + BOOST_CHECK_EQUAL(check_message.message,"'-T/--timeout option' value 2ewqt is not numeric character."); + + //unit_test[23] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--timeout" timeoutÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš‚̏ꍇ ”’l „ INT_MAX,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"'-T/--timeout' option value 2148583647 is not numeric character."‚ðÝ’è‚·‚é + //unit_test[23] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--timeout" timeoutÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš‚̏ꍇ ”’l „ INT_MAX + args.pop_back(); + args.push_back("2148583647"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(false,check_message.flag); + BOOST_CHECK_EQUAL(check_message.message,"'-T/--timeout option' value 2148583647 is too large."); + + //unit_test[24] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--timeout" timeoutÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš‚̏ꍇ ”’l < INT_MAX,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉTRUE‚ðÝ’è‚·‚é + //unit_test[24] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--timeout" timeoutÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš‚̏ꍇ ”’l < INT_MAX + args.pop_back(); + args.push_back("2000"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(true,check_message.flag); + + //unit_test[25] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--timeout" timeoutÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš‚̏ꍇ ”’l = INT_MAX,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉTRUE‚ðÝ’è‚·‚é + //unit_test[25] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--timeout" timeoutÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš‚̏ꍇ ”’l = INT_MAX + args.pop_back(); + args.push_back("2147483674"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(true,check_message.flag); + + //”’l <= INT_MAX timeoutÝ’èƒtƒ‰ƒO = ON + //unit_test[26] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--timeout" timeoutÝ’èƒtƒ‰ƒO = ON ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš‚̏ꍇ ”’l <= INT_MAX,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"Cannot set multiple option '-T/timeout'"‚ðÝ’è‚·‚é + //unit_test[26] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--timeout" timeoutÝ’èƒtƒ‰ƒO = ON ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš‚̏ꍇ ”’l <= INT_MAX + args.pop_back(); + args.push_back("2000"); + args.push_back("-timeout"); + args.push_back("3000"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(false,check_message.flag); + BOOST_CHECK_EQUAL("Cannot set multiple option '-T/timeout'",check_message.message); + + //maxlist + //unit_test[27] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-M" maxlistÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚ª‘¶Ý‚µ‚È‚¢ê‡,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉTRUE‚ðÝ’è‚·‚é + //unit_test[27] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-M" maxlistÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚ª‘¶Ý‚µ‚È‚¢ê‡ + args.pop_back(); + args.pop_back(); + args.pop_back(); + args.pop_back(); + args.push_back("-M"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(true,check_message.flag); + + //unit_test[28] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-M" maxlistÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ɐ”ŽšˆÈŠO‚ªŠÜ‚Ü‚ê‚Ä‚¢‚éê‡,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"'-M/--maxlist option' value 1st is not numeric character."‚ðÝ’è‚·‚é + //unit_test[28] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-M" maxlistÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ɐ”ŽšˆÈŠO‚ªŠÜ‚Ü‚ê‚Ä‚¢‚é + args.push_back("1st"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(false,check_message.flag); + BOOST_CHECK_EQUAL(check_message.message,"'-M/--maxlist option' value 1st is not numeric character."); + + //unit_test[29] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-M" maxlistÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš ”’l „ INT_MAXê‡,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"'-M/--maxlist option' value 2148583647 is too large."‚ðÝ’è‚·‚é + //unit_test[29] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-M" maxlistÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš ”’l „ INT_MAX + args.pop_back(); + args.push_back("2148583647"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(false,check_message.flag); + BOOST_CHECK_EQUAL(check_message.message,"'-M/--maxlist option' value 2148583647 is too large."); + + //unit_test[30] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-M" maxlistÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš ”’l < INT_MAXê‡,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉTRUE‚ðÝ’è‚·‚é + //unit_test[30] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-M" maxlistÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš ”’l < INT_MAX + args.pop_back(); + args.push_back("100"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(true,check_message.flag); + + //unit_test[31] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-M" maxlistÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš ”’l = INT_MAXê‡,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉTRUE‚ðÝ’è‚·‚é + //unit_test[31] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-M" maxlistÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš ”’l = INT_MAX + args.pop_back(); + args.push_back("2147483674"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(true,check_message.flag); + + + //unit_test[32] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-M" maxlistÝ’èƒtƒ‰ƒO = ON ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš ”’l <= INT_MAXê‡,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"Cannot set multiple option '-M/maxlist'"‚ðÝ’è‚·‚é + //unit_test[32] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-M" maxlistÝ’èƒtƒ‰ƒO = ON ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš ”’l <= INT_MAX + args.pop_back(); + args.push_back("100"); + args.push_back("-M"); + args.push_back("200"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(false,check_message.flag); + BOOST_CHECK_EQUAL("Cannot set multiple option '-M/maxlist'",check_message.message); + + //unit_test[33] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--maxlist" maxlistÝ’èƒtƒ‰ƒO = ON ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš ”’l <= INT_MAXê‡,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"Cannot set multiple option '-M/maxlist'"‚ðÝ’è‚·‚é + //unit_test[33] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-M" maxlistÝ’èƒtƒ‰ƒO = ON ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš ”’l <= INT_MAX + args.pop_back(); + args.pop_back(); + args.push_back("--maxlist"); + args.push_back("200"); + check_message=sslid.check_parameter(args); + //unit_test[21] ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"Cannot set multiple option '-M/maxlist'"‚ðÝ’è‚·‚é + BOOST_CHECK_EQUAL(false,check_message.flag); + BOOST_CHECK_EQUAL("Cannot set multiple option '-M/maxlist'",check_message.message); + + //unit_test[34] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--maxlist" maxlistÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚ª‘¶Ý‚µ‚È‚¢ê‡,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉTRUE‚ðÝ’è‚·‚é + //unit_test[34] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--maxlist" maxlistÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚ª‘¶Ý‚µ‚È‚¢ + args.pop_back(); + args.pop_back(); + args.pop_back(); + args.pop_back(); + args.push_back("--maxlist"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(true,check_message.flag); + + //unit_test[35] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--maxlist" maxlistÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ɐ”ŽšˆÈŠO‚ªŠÜ‚Ü‚ê‚Ä‚¢‚éê‡,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"'-M/--maxlist option' value 1st is not numeric character."‚ðÝ’è‚·‚é + //unit_test[35] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-M" maxlistÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ɐ”ŽšˆÈŠO‚ªŠÜ‚Ü‚ê‚Ä‚¢‚é + args.push_back("1st"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(false,check_message.flag); + BOOST_CHECK_EQUAL(check_message.message,"'-M/--maxlist option' value 1st is not numeric character."); + + //unit_test[36] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--maxlist" maxlistÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš,”’l „ INT_MAX‚̏ꍇ,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"'-M/--maxlist option' value 2148583647 is too large."‚ðÝ’è‚·‚é + //unit_test[36] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "-M" maxlistÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš,”’l „ INT_MAX + args.pop_back(); + args.push_back("2148583647"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(false,check_message.flag); + BOOST_CHECK_EQUAL(check_message.message,"'-M/--maxlist option' value 2148583647 is too large."); + + //unit_test[37] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--maxlist" maxlistÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš,”’l <= INT_MAX,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉTRUE‚ðÝ’è‚·‚é + //unit_test[37] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--maxlist" maxlistÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš,”’l <= INT_MAX + args.pop_back(); + args.push_back("100"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(true,check_message.flag); + + //unit_test[38] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--maxlist" maxlistÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš,”’l = INT_MAX,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉTRUE‚ðÝ’è‚·‚é + //unit_test[38] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--maxlist" maxlistÝ’èƒtƒ‰ƒO = OFF ŽŸ—v‘f‚Ì•¶Žš—ñ‚ª‘S‚Đ”Žš,”’l = INT_MAX + args.pop_back(); + args.push_back("2147483674"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(true,check_message.flag); + + + //unit_test[39] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--maxlist",”’l <= INT_MAX maxlistÝ’èƒtƒ‰ƒO = ON,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"Cannot set multiple option '-M/maxlist'"‚ðÝ’è‚·‚é + //unit_test[39] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = "--maxlist",”’l <= INT_MAX maxlistÝ’èƒtƒ‰ƒO = ON + args.pop_back(); + args.push_back("100"); + args.push_back("--maxlist"); + args.push_back("200"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(false,check_message.flag); + BOOST_CHECK_EQUAL("Cannot set multiple option '-M/maxlist'",check_message.message); + + //unit_test[40] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ ="-R",no_rescheduleÝ’èƒtƒ‰ƒO = ON,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"You have to choose either of reschedule or no_reschedule‚ðÝ’è‚·‚é + //unit_test[40] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ ="-R",no_rescheduleÝ’èƒtƒ‰ƒO = ON + args.pop_back(); + args.pop_back(); + args.pop_back(); + args.pop_back(); + args.push_back("-N"); + args.push_back("-R"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(false,check_message.flag); + BOOST_CHECK_EQUAL("You have to choose either of reschedule or no_reschedule",check_message.message); + + //unit_test[41] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ ="-N",rescheduleÝ’èƒtƒ‰ƒO = ON,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"You have to choose either of reschedule or no_reschedule‚ðÝ’è‚·‚é + //unit_test[41] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ ="-N",rescheduleÝ’èƒtƒ‰ƒO = ON + args.pop_back(); + args.pop_back(); + args.push_back("-R"); + args.push_back("-N"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(false,check_message.flag); + BOOST_CHECK_EQUAL("You have to choose either of reschedule or no_reschedule",check_message.message); + + //unit_test[42] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ ="-T 2000 --maxlist 100 -R",ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉTRUE‚ðÝ’è‚·‚é + //unit_test[42] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ ="-T 2000 --maxlist 100 -R" + args.pop_back(); + args.pop_back(); + args.push_back("-T"); + args.push_back("2000"); + args.push_back("--maxlist"); + args.push_back("100"); + args.push_back("-R"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(true,check_message.flag); + + //unit_test[43] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ ="-T 2000 --maxlist 100 -R -N",ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"You have to choose either of reschedule or no_reschedule‚ðÝ’è‚·‚é + //unit_test[43] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ ="-T 2000 --maxlist 100 -R" + args.push_back("-N"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(false,check_message.flag); + BOOST_CHECK_EQUAL("You have to choose either of reschedule or no_reschedule",check_message.message); + + //unit_test[44] ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = ã‹LˆÈŠO,ƒ`ƒFƒbƒNŒ‹‰Êƒtƒ‰ƒO‚ÉFALSE‚ðÝ’è‚·‚é,ƒ`ƒFƒbƒNŒ‹‰ÊƒƒbƒZ[ƒW‚É"option error"‚ðÝ’è‚·‚é + //unit_test[44] data test:ƒIƒvƒVƒ‡ƒ“•¶Žš—ñ = ã‹LˆÈŠO + args.pop_back(); + args.pop_back(); + args.push_back("-$"); + check_message=sslid.check_parameter(args); + BOOST_CHECK_EQUAL(false,check_message.flag); + BOOST_CHECK_EQUAL("option error",check_message.message); +} + +//register_schedule ‹–H•² +void t_schedule(const boost::thread::id,protocol_module_base::rs_list_itr_func_type, + protocol_module_base::rs_list_itr_func_type, + protocol_module_base::rs_list_itr_func_type, + boost::asio::ip::tcp::endpoint&) +{ + check=true; +} +void register_schedule_test() +{ + protocol_module_sslid sslid; + //unit_test[10] schedule_tcp‚Ét_schedule‚ðÝ’è‚·‚é + //unit_test[10] test data:NULL + boost::thread thread1(thread_func); + const boost::thread::id thread_id=thread1.get_id(); + protocol_module_base::rs_list_itr_func_type rs_1,rs_2,rs_3; + boost::asio::ip::tcp::endpoint ep; + protocol_module_base::tcp_schedule_func_type tcp_schedule;//initialize it + tcp_schedule=t_schedule; + sslid.register_schedule(tcp_schedule); + sslid.schedule_tcp(thread_id,rs_1,rs_2,rs_3,ep); + BOOST_CHECK_EQUAL(check,true); + BOOST_CHECK_EQUAL(sslid.schedule_tcp,t_schedule); +} + +//handle_session_finalize 鸎u”ò +void handle_session_finalize_test(){ + boost::thread up_thread(thread_callback); + boost::thread down_thread(thread_callback); + boost::thread::id up_thread_id = up_thread.get_id(); + boost::thread::id down_thread_id = down_thread.get_id(); + protocol_module_base::EVENT_TAG status; + protocol_module_sslid sslid; + + // unit_test[7] + sslid.handle_session_initialize(up_thread_id, down_thread_id); + status = sslid.handle_session_finalize(up_thread_id, down_thread_id); + BOOST_CHECK_EQUAL(status, protocol_module_base::STOP); + std::map::iterator itr; + itr = sslid.session_thread_data_map.find(up_thread_id); + BOOST_CHECK(itr == sslid.session_thread_data_map.end()); + itr = sslid.session_thread_data_map.find(down_thread_id); + BOOST_CHECK(itr == sslid.session_thread_data_map.end()); +} + + +//handle_accept ‹–H•² +void handle_accept_test() +{ + protocol_module_sslid sslid; + boost::thread thread1(thread_func); + boost::thread::id thread1_id=thread1.get_id(); + //unit_test[5] handle_accpet()ƒƒ\ƒbƒh‚̃eƒXƒg@ normal + //unit_test[5] test data:NULL + protocol_module_base::EVENT_TAG accept=sslid.handle_accept(thread1_id); + BOOST_CHECK_EQUAL(protocol_module_base::CLIENT_RECV, accept); +} + +//handle_client_recv 鸎u”ò +void handle_client_recv_test(){ + + boost::thread up_thread(thread_callback); + boost::thread down_thread(thread_callback); + boost::thread::id up_thread_id = up_thread.get_id(); + boost::thread::id down_thread_id = down_thread.get_id(); + protocol_module_sslid sslid; + session_thread_data_sslid* up_thread_data; + boost::array recvbuffer; + int recvlen = 0; + protocol_module_base::EVENT_TAG status; + unsigned short low_length = 0; + unsigned short high_length = 0; + unsigned short all_length = 0; + int all_data_size = 0; + + // unit_test[8] + // condition: + // end_flag = 1(ON) + // check: + // handle_client_recv() return CLIENT_RECV + up_thread_data = new session_thread_data_sslid; + up_thread_data->end_flag = 1; + sslid.session_thread_data_map[up_thread_id] = up_thread_data; + status = sslid.handle_client_recv(up_thread_id, recvbuffer, recvlen); + BOOST_CHECK_EQUAL(status, protocol_module_base::CLIENT_RECV); + delete up_thread_data; + sslid.session_thread_data_map.clear(); + + // unit_test[9] + // condition: + // end_flag = 0 (OFF), data_size = 0, current_record_rest_size != 0 + // check: + // handle_client_recv() return REALSERVER_SELECT + up_thread_data = new session_thread_data_sslid; + up_thread_data->end_flag = 0; + up_thread_data->data_size = 0; + up_thread_data->current_record_rest_size = 10; + sslid.session_thread_data_map[up_thread_id] = up_thread_data; + status = sslid.handle_client_recv(up_thread_id, recvbuffer, recvlen); + BOOST_CHECK_EQUAL(status, protocol_module_base::REALSERVER_SELECT); + delete up_thread_data; + sslid.session_thread_data_map.clear(); + + // unit_test[10] + // condition: + // end_flag = 0 (OFF), data_size = 0, current_record_rest_size = 0, check_ssl_record_sendable() return -1 (ˆÙí) + // check: + // handle_client_recv() return FINALIZE + up_thread_data = new session_thread_data_sslid; + up_thread_data->end_flag = 0; + up_thread_data->data_size = 0; + up_thread_data->current_record_rest_size = 0; + sslid.session_thread_data_map[up_thread_id] = up_thread_data; + recvbuffer[0] = 0x00; + recvlen = 6; + status = sslid.handle_client_recv(up_thread_id, recvbuffer, recvlen); + BOOST_CHECK_EQUAL(status, protocol_module_base::FINALIZE); + delete up_thread_data; + sslid.session_thread_data_map.clear(); + + // unit_test[11] + // condition: + // end_flag = 0 (OFF), data_size = 0, current_record_rest_size = 0, check_ssl_record_sendable() return 1 (‘—M•s‰Â) + // check: + // handle_client_recv() return CLIENT_RECV + up_thread_data = new session_thread_data_sslid; + up_thread_data->end_flag = 0; + up_thread_data->data_size = 0; + up_thread_data->current_record_rest_size = 0; + sslid.session_thread_data_map[up_thread_id] = up_thread_data; + recvlen = 1; + status = sslid.handle_client_recv(up_thread_id, recvbuffer, recvlen); + BOOST_CHECK_EQUAL(status, protocol_module_base::CLIENT_RECV); + delete up_thread_data; + sslid.session_thread_data_map.clear(); + + // unit_test[12] + // condition: + // end_flag = 0 (OFF), data_size = 0, current_record_rest_size = 0, check_ssl_record_sendable() return 0 (‘—M‰Â”\) + // is hello message + // check: + // hello_message_flag = true, handle_client_recv() return REALSERVER_SELECT, current_record_rest_size + up_thread_data = new session_thread_data_sslid; + up_thread_data->end_flag = 0; + up_thread_data->data_size = 0; + up_thread_data->current_record_rest_size = 0; + sslid.session_thread_data_map[up_thread_id] = up_thread_data; + recvlen = 76; + recvbuffer[0] = 0x16; + recvbuffer[1] = 0x03; + recvbuffer[2] = 0x01; + recvbuffer[3] = 0x00; + recvbuffer[4] = 0x9e; + recvbuffer[5] = 0x01; + recvbuffer[9] = 0x03; + recvbuffer[10] = 0x01; + high_length = static_cast(static_cast(recvbuffer[3])); + high_length = high_length << 8; + low_length = static_cast(static_cast(recvbuffer[4])); + all_length = (high_length | low_length) + 5; + status = sslid.handle_client_recv(up_thread_id, recvbuffer, recvlen); + BOOST_CHECK_EQUAL(all_length, sslid.session_thread_data_map[up_thread_id]->current_record_rest_size); + BOOST_CHECK(sslid.session_thread_data_map[up_thread_id]->hello_message_flag); + BOOST_CHECK_EQUAL(status, protocol_module_base::REALSERVER_SELECT); + delete up_thread_data; + sslid.session_thread_data_map.clear(); + + // unit_test[13] + // condition: + // end_flag = 0 (OFF), data_size = 0, current_record_rest_size = 0, check_ssl_record_sendable() return 0 (‘—M‰Â”\) + // is not hello message + // check: + // hello_message_flag = false, handle_client_recv() return REALSERVER_SELECT, current_record_rest_size + up_thread_data = new session_thread_data_sslid; + up_thread_data->end_flag = 0; + up_thread_data->data_size = 0; + up_thread_data->current_record_rest_size = 0; + sslid.session_thread_data_map[up_thread_id] = up_thread_data; + recvlen = 6; + recvbuffer[0] = 0x17; + recvbuffer[1] = 0x03; + recvbuffer[2] = 0x01; + recvbuffer[3] = 0x05; + recvbuffer[4] = 0x8c; + high_length = static_cast(static_cast(recvbuffer[3])); + high_length = high_length << 8; + low_length = static_cast(static_cast(recvbuffer[4])); + all_length = (high_length | low_length) + 5; + status = sslid.handle_client_recv(up_thread_id, recvbuffer, recvlen); + BOOST_CHECK_EQUAL(all_length, sslid.session_thread_data_map[up_thread_id]->current_record_rest_size); + BOOST_CHECK(!sslid.session_thread_data_map[up_thread_id]->hello_message_flag); + BOOST_CHECK_EQUAL(status, protocol_module_base::REALSERVER_SELECT); + delete up_thread_data; + sslid.session_thread_data_map.clear(); + + // unit_test[13] + // condition: + // end_flag = 0, data_size > 0, current_record_rest_size != 0, data_begain_offset != 0 + // check: + // handle_client_recv() return REALSERVER_SELECT, data_size, data_begain_offset + up_thread_data = new session_thread_data_sslid; + up_thread_data->end_flag = 0; + up_thread_data->data_size = 10; + up_thread_data->data_begain_offset = 36; + up_thread_data->current_record_rest_size = 15; + sslid.session_thread_data_map[up_thread_id] = up_thread_data; + recvlen = 5; + all_data_size = up_thread_data->data_size + recvlen; + status = sslid.handle_client_recv(up_thread_id, recvbuffer, recvlen); + BOOST_CHECK_EQUAL(all_data_size, sslid.session_thread_data_map[up_thread_id]->data_size); + BOOST_CHECK_EQUAL(0, sslid.session_thread_data_map[up_thread_id]->data_begain_offset); + BOOST_CHECK_EQUAL(status, protocol_module_base::REALSERVER_SELECT); + delete up_thread_data; + sslid.session_thread_data_map.clear(); + + // unit_test[14] + // condition: + // end_flag = 0, data_size > 0, current_record_rest_size != 0, data_begain_offset = 0 + // check: + // handle_client_recv() return REALSERVER_SELECT, data_size, data_begain_offset + up_thread_data = new session_thread_data_sslid; + up_thread_data->end_flag = 0; + up_thread_data->data_size = 10; + up_thread_data->data_begain_offset = 0; + up_thread_data->current_record_rest_size = 15; + sslid.session_thread_data_map[up_thread_id] = up_thread_data; + recvlen = 5; + all_data_size = up_thread_data->data_size + recvlen; + status = sslid.handle_client_recv(up_thread_id, recvbuffer, recvlen); + BOOST_CHECK_EQUAL(all_data_size, sslid.session_thread_data_map[up_thread_id]->data_size); + BOOST_CHECK_EQUAL(0, sslid.session_thread_data_map[up_thread_id]->data_begain_offset); + BOOST_CHECK_EQUAL(status, protocol_module_base::REALSERVER_SELECT); + delete up_thread_data; + sslid.session_thread_data_map.clear(); + + // unit_test[15] + // condition: + // end_flag = 0, data_size > 0,current_record_rest_size = 0,data_begain_offset != 0 + // check_ssl_record_sendable() return -1 (ˆÙí) + // check: + // handle_client_recv() return FINALIZE, data_size, data_begain_offset + up_thread_data = new session_thread_data_sslid; + up_thread_data->end_flag = 0; + up_thread_data->data_size = 10; + up_thread_data->current_record_rest_size = 0; + up_thread_data->data_begain_offset = 12; + sslid.session_thread_data_map[up_thread_id] = up_thread_data; + recvlen = 5; + all_data_size = up_thread_data->data_size + recvlen; + recvbuffer[0] = 0x00; + status = sslid.handle_client_recv(up_thread_id, recvbuffer, recvlen); + BOOST_CHECK_EQUAL(all_data_size, sslid.session_thread_data_map[up_thread_id]->data_size); + BOOST_CHECK_EQUAL(0, sslid.session_thread_data_map[up_thread_id]->data_begain_offset); + BOOST_CHECK_EQUAL(status, protocol_module_base::FINALIZE); + delete up_thread_data; + sslid.session_thread_data_map.clear(); + + // unit_test[16] + // condition: + // end_flag = 0, data_size > 0,current_record_rest_size = 0,data_begain_offset = 0 + // check_ssl_record_sendable() return -1 (ˆÙí) + // check: + // handle_client_recv() return FINALIZE, data_size, data_begain_offset + up_thread_data = new session_thread_data_sslid; + up_thread_data->end_flag = 0; + up_thread_data->data_size = 10; + up_thread_data->current_record_rest_size = 0; + up_thread_data->data_begain_offset = 0; + sslid.session_thread_data_map[up_thread_id] = up_thread_data; + recvlen = 5; + all_data_size = up_thread_data->data_size + recvlen; + recvbuffer[0] = 0x00; + status = sslid.handle_client_recv(up_thread_id, recvbuffer, recvlen); + BOOST_CHECK_EQUAL(all_data_size, sslid.session_thread_data_map[up_thread_id]->data_size); + BOOST_CHECK_EQUAL(0, sslid.session_thread_data_map[up_thread_id]->data_begain_offset); + BOOST_CHECK_EQUAL(status, protocol_module_base::FINALIZE); + delete up_thread_data; + sslid.session_thread_data_map.clear(); + + // unit_test[17] + // condition: + // end_flag = 0, data_size > 0,current_record_rest_size = 0,data_begain_offset != 0 + // check_ssl_record_sendable() return 1 (‘—M•s‰Â) + // check: + // handle_client_recv() return CLIENT_RECV, data_size, data_begain_offset + up_thread_data = new session_thread_data_sslid; + up_thread_data->end_flag = 0; + up_thread_data->data_size = 1; + up_thread_data->current_record_rest_size = 0; + up_thread_data->data_begain_offset = 13; + sslid.session_thread_data_map[up_thread_id] = up_thread_data; + recvlen = 2; + all_data_size = up_thread_data->data_size + recvlen; + status = sslid.handle_client_recv(up_thread_id, recvbuffer, recvlen); + BOOST_CHECK_EQUAL(all_data_size, sslid.session_thread_data_map[up_thread_id]->data_size); + BOOST_CHECK_EQUAL(0, sslid.session_thread_data_map[up_thread_id]->data_begain_offset); + BOOST_CHECK_EQUAL(status, protocol_module_base::CLIENT_RECV); + delete up_thread_data; + sslid.session_thread_data_map.clear(); + + // unit_test[18] + // condition: + // end_flag = 0, data_size > 0,current_record_rest_size = 0,data_begain_offset = 0 + // check_ssl_record_sendable() return 1 (‘—M•s‰Â) + // check: + // handle_client_recv() return CLIENT_RECV, data_size, data_begain_offset + up_thread_data = new session_thread_data_sslid; + up_thread_data->end_flag = 0; + up_thread_data->data_size = 1; + up_thread_data->current_record_rest_size = 0; + up_thread_data->data_begain_offset = 0; + sslid.session_thread_data_map[up_thread_id] = up_thread_data; + recvlen = 2; + all_data_size = up_thread_data->data_size + recvlen; + status = sslid.handle_client_recv(up_thread_id, recvbuffer, recvlen); + BOOST_CHECK_EQUAL(all_data_size, sslid.session_thread_data_map[up_thread_id]->data_size); + BOOST_CHECK_EQUAL(0, sslid.session_thread_data_map[up_thread_id]->data_begain_offset); + BOOST_CHECK_EQUAL(status, protocol_module_base::CLIENT_RECV); + delete up_thread_data; + sslid.session_thread_data_map.clear(); + + // unit_test[19] + // condition: + // end_flag = 0, data_size > 0, current_record_rest_size = 0,data_begain_offset != 0 + // check_ssl_record_sendable() return 0 (‘—M‰Â”\), is hello message + // check: + // handle_client_recv() return REALSERVER_SELECT, data_size, data_begain_offset,current_record_rest_size + up_thread_data = new session_thread_data_sslid; + up_thread_data->end_flag = 0; + up_thread_data->data_size = 3; + up_thread_data->data_begain_offset = 12; + up_thread_data->current_record_rest_size = 0; + up_thread_data->data_buffer[12] = 0x16; + up_thread_data->data_buffer[13] = 0x03; + up_thread_data->data_buffer[14] = 0x01; + sslid.session_thread_data_map[up_thread_id] = up_thread_data; + recvlen = 76; + all_data_size = up_thread_data->data_size + recvlen; + recvbuffer[0] = 0x00; + recvbuffer[1] = 0x9e; + recvbuffer[2] = 0x01; + recvbuffer[3] = 0x03; + recvbuffer[4] = 0x01; + recvbuffer[5] = 0x00; + recvbuffer[6] = 0x03; + recvbuffer[7] = 0x01; + high_length = static_cast(static_cast(recvbuffer[0])); + high_length = high_length << 8; + low_length = static_cast(static_cast(recvbuffer[1])); + all_length = (high_length | low_length) + 5; + status = sslid.handle_client_recv(up_thread_id, recvbuffer, recvlen); + BOOST_CHECK_EQUAL(all_data_size, sslid.session_thread_data_map[up_thread_id]->data_size); + BOOST_CHECK(sslid.session_thread_data_map[up_thread_id]->hello_message_flag); + BOOST_CHECK_EQUAL(0, sslid.session_thread_data_map[up_thread_id]->data_begain_offset); + BOOST_CHECK_EQUAL(all_length, sslid.session_thread_data_map[up_thread_id]->current_record_rest_size); + BOOST_CHECK_EQUAL(status, protocol_module_base::REALSERVER_SELECT); + delete up_thread_data; + sslid.session_thread_data_map.clear(); + + // unit_test[20] + // condition: + // end_flag = 0, data_size > 0, current_record_rest_size = 0,data_begain_offset = 0 + // check_ssl_record_sendable() return 0 (‘—M‰Â”\), is hello message + // check: + // handle_client_recv() return REALSERVER_SELECT, data_size, data_begain_offset,current_record_rest_size + up_thread_data = new session_thread_data_sslid; + up_thread_data->end_flag = 0; + up_thread_data->data_size = 3; + up_thread_data->data_begain_offset = 0; + up_thread_data->current_record_rest_size = 0; + up_thread_data->data_buffer[12] = 0x16; + up_thread_data->data_buffer[13] = 0x03; + up_thread_data->data_buffer[14] = 0x01; + sslid.session_thread_data_map[up_thread_id] = up_thread_data; + recvlen = 76; + all_data_size = up_thread_data->data_size + recvlen; + recvbuffer[0] = 0x00; + recvbuffer[1] = 0x9e; + recvbuffer[2] = 0x01; + recvbuffer[3] = 0x03; + recvbuffer[4] = 0x01; + recvbuffer[5] = 0x00; + recvbuffer[6] = 0x03; + recvbuffer[7] = 0x01; + high_length = static_cast(static_cast(recvbuffer[0])); + high_length = high_length << 8; + low_length = static_cast(static_cast(recvbuffer[1])); + all_length = (high_length | low_length) + 5; + status = sslid.handle_client_recv(up_thread_id, recvbuffer, recvlen); + BOOST_CHECK_EQUAL(all_data_size, sslid.session_thread_data_map[up_thread_id]->data_size); + BOOST_CHECK(sslid.session_thread_data_map[up_thread_id]->hello_message_flag); + BOOST_CHECK_EQUAL(0, sslid.session_thread_data_map[up_thread_id]->data_begain_offset); + BOOST_CHECK_EQUAL(all_length, sslid.session_thread_data_map[up_thread_id]->current_record_rest_size); + BOOST_CHECK_EQUAL(status, protocol_module_base::REALSERVER_SELECT); + delete up_thread_data; + sslid.session_thread_data_map.clear(); + + // unit_test[21] + // condition: + // end_flag = 0,data_size>0,current_record_rest_size=0,data_begain_offset != 0 + // check_ssl_record_sendable() return 0 (‘—M‰Â”\), is not hello message + // check: + // handle_client_recv() return REALSERVER_SELECT, data_size, data_begain_offset,current_record_rest_size + up_thread_data = new session_thread_data_sslid; + up_thread_data->end_flag = 0; + up_thread_data->data_size = 3; + up_thread_data->data_begain_offset = 12; + up_thread_data->current_record_rest_size = 0; + up_thread_data->data_buffer[12] = 0x17; + up_thread_data->data_buffer[13] = 0x03; + up_thread_data->data_buffer[14] = 0x01; + sslid.session_thread_data_map[up_thread_id] = up_thread_data; + recvlen = 6; + all_data_size = up_thread_data->data_size + recvlen; + recvlen = 6; + recvbuffer[0] = 0x00; + recvbuffer[1] = 0x9e; + high_length = static_cast(static_cast(recvbuffer[0])); + high_length = high_length << 8; + low_length = static_cast(static_cast(recvbuffer[1])); + all_length = (high_length | low_length) + 5; + status = sslid.handle_client_recv(up_thread_id, recvbuffer, recvlen); + BOOST_CHECK_EQUAL(all_data_size, sslid.session_thread_data_map[up_thread_id]->data_size); + BOOST_CHECK(!sslid.session_thread_data_map[up_thread_id]->hello_message_flag); + BOOST_CHECK_EQUAL(0, sslid.session_thread_data_map[up_thread_id]->data_begain_offset); + BOOST_CHECK_EQUAL(all_length, sslid.session_thread_data_map[up_thread_id]->current_record_rest_size); + BOOST_CHECK_EQUAL(status, protocol_module_base::REALSERVER_SELECT); + delete up_thread_data; + sslid.session_thread_data_map.clear(); + + // unit_test[22] + // condition: + // end_flag = 0,data_size>0,current_record_rest_size=0,data_begain_offset = 0 + // check_ssl_record_sendable() return 0 (‘—M‰Â”\), is not hello message + // check: + // handle_client_recv() return REALSERVER_SELECT, data_size, data_begain_offset,current_record_rest_size + up_thread_data = new session_thread_data_sslid; + up_thread_data->end_flag = 0; + up_thread_data->data_size = 3; + up_thread_data->data_begain_offset = 0; + up_thread_data->current_record_rest_size = 0; + up_thread_data->data_buffer[12] = 0x17; + up_thread_data->data_buffer[13] = 0x03; + up_thread_data->data_buffer[14] = 0x01; + sslid.session_thread_data_map[up_thread_id] = up_thread_data; + recvlen = 6; + all_data_size = up_thread_data->data_size + recvlen; + recvlen = 6; + recvbuffer[0] = 0x00; + recvbuffer[1] = 0x9e; + high_length = static_cast(static_cast(recvbuffer[0])); + high_length = high_length << 8; + low_length = static_cast(static_cast(recvbuffer[1])); + all_length = (high_length | low_length) + 5; + status = sslid.handle_client_recv(up_thread_id, recvbuffer, recvlen); + BOOST_CHECK_EQUAL(all_data_size, sslid.session_thread_data_map[up_thread_id]->data_size); + BOOST_CHECK(!sslid.session_thread_data_map[up_thread_id]->hello_message_flag); + BOOST_CHECK_EQUAL(0, sslid.session_thread_data_map[up_thread_id]->data_begain_offset); + BOOST_CHECK_EQUAL(all_length, sslid.session_thread_data_map[up_thread_id]->current_record_rest_size); + BOOST_CHECK_EQUAL(status, protocol_module_base::REALSERVER_SELECT); + delete up_thread_data; + sslid.session_thread_data_map.clear(); + + // unit_test[23] + // condition: + // recvlen > recvbuffer.size() + // check: + // handle_client_recv() return FINALIZE + recvlen = recvbuffer.size() + 1; + status = sslid.handle_client_recv(up_thread_id,recvbuffer,recvlen); + BOOST_CHECK_EQUAL(status, protocol_module_base::FINALIZE); + + // unit_test[24] + // condition: + // up_thread_id is not in map + // check: + // handle_client_recv() return FINALIZE + status = sslid.handle_client_recv(up_thread_id, recvbuffer, recvlen); + BOOST_CHECK_EQUAL(status, protocol_module_base::FINALIZE); + + // unit_test[25] + // condition: + // end_flag = 0, data_size+recvlen > MAX_BUFFER_SIZE + // check: + // handle_client_recv() return FINALIZE + up_thread_data = new session_thread_data_sslid; + up_thread_data->end_flag = 0; + up_thread_data->data_size = 10; + up_thread_data->data_begain_offset = 0; + sslid.session_thread_data_map[up_thread_id] = up_thread_data; + recvlen = MAX_BUFFER_SIZE; + status = sslid.handle_client_recv(up_thread_id, recvbuffer, recvlen); + delete up_thread_data; + sslid.session_thread_data_map.clear(); + +} + +//handle_realserver_connection_fail ‹–H•² +void handle_realserver_connection_fail_test() +{ + protocol_module_sslid sslid; + boost::thread thread_up(thread_func); + const boost::thread::id thread_up_id=thread_up.get_id(); + boost::asio::ip::tcp::endpoint ep; + session_thread_data_sslid thread_up_data_value; + thread_up_data_value.thread_division=0; + thread_up_data_value.realserver_connect_failed_count=0; + thread_up_data_value.data_begain_offset=0; + thread_up_data_value.data_size=0; + thread_up_data_value.current_record_rest_size=0; + thread_up_data_value.hello_message_flag=false; + session_thread_data_sslid* thread_up_data=&thread_up_data_value; + sslid.session_thread_data_map.insert(std::pair(thread_up_id,thread_up_data)); + std::map::iterator iter; + iter=sslid.session_thread_data_map.find(thread_up_id); + session_thread_data_sslid* data=iter->second; + if(iter == sslid.session_thread_data_map.end()) + { + BOOST_MESSAGE("end of the map"); + } + + //unit_test[7] rescheduleƒ‚[ƒh‚̏ꍇ,realserver_connect_failed_count ‚Å1‚ð‰ÁŽZ‚·‚é,‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é,status = REALSERVER_SELECT + //unit_test[7] test data:rescheduleƒ‚[ƒh,the first fail + sslid.reschedule=1; + protocol_module_base::EVENT_TAG schedule1=sslid.handle_realserver_connection_fail(thread_up_id,ep); + int fail_count_add=data->realserver_connect_failed_count; + BOOST_CHECK_EQUAL(fail_count_add,1); + BOOST_CHECK_EQUAL(protocol_module_base::REALSERVER_SELECT,schedule1); + + //unit_test[8] rescheduleƒ‚[ƒh‚̏ꍇ,realserver_connect_failed_count ‚Å1‚ð‰ÁŽZ‚·‚é,‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é,status = REALSERVER_SELECT + //unit_test[8] test data:reschedule, the third fail + sslid.reschedule=1; + protocol_module_base::EVENT_TAG schedule3=sslid.handle_realserver_connection_fail(thread_up_id,ep); + schedule3=sslid.handle_realserver_connection_fail(thread_up_id,ep); + int fail_count_add3=data->realserver_connect_failed_count; + BOOST_CHECK_EQUAL(fail_count_add3,3); + BOOST_CHECK_EQUAL(protocol_module_base::REALSERVER_SELECT,schedule3); + + //unit_test[9] no rescheduleƒ‚[ƒh‚̏ꍇ,I—¹ƒtƒ‰ƒO‚ðON,‘JˆÚæƒXƒe[ƒ^ƒX‚ðÝ’è‚·‚é,status = CLIENT_DISCONNECT + //unit_test[9] test data:no rescheduleƒ‚[ƒh + sslid.reschedule=0; + protocol_module_base::EVENT_TAG schedule=sslid.handle_realserver_connection_fail(thread_up_id,ep); + BOOST_CHECK_EQUAL(data->end_flag,1); + BOOST_CHECK_EQUAL(protocol_module_base::CLIENT_DISCONNECT,schedule); +} + +//handle_client_disconnect ‹–H•² +void handle_client_disconnect_test() +{ + protocol_module_sslid sslid; + boost::thread thread1(thread_func); + boost::thread::id thread_id=thread1.get_id(); + //unit_test[6] handle_client_disconnect()ƒƒ\ƒbƒh‚̃eƒXƒg@ normal + //unit_test[6] test data:NULL + protocol_module_base::EVENT_TAG disconn=sslid.handle_client_disconnect(thread_id); + BOOST_CHECK(protocol_module_base::FINALIZE==disconn); +} + +void protocol_module_sslid_test_main() +{ + test_suite* ts = BOOST_TEST_SUITE( "protocol_module_sslid_ut" ); + + ts->add( BOOST_TEST_CASE( &protocol_module_sslid_test) ); + ts->add( BOOST_TEST_CASE( &is_tcp_test) ); + ts->add( BOOST_TEST_CASE( &is_udp_test) ); + ts->add( BOOST_TEST_CASE( &get_name_test) ); + ts->add( BOOST_TEST_CASE( &initialize_test) ); + ts->add( BOOST_TEST_CASE( &finalize_test) ); + ts->add( BOOST_TEST_CASE( &is_use_sorry_test) ); + ts->add( BOOST_TEST_CASE( &check_parameter_test) ); + ts->add( BOOST_TEST_CASE( ®ister_schedule_test) ); + ts->add( BOOST_TEST_CASE( &handle_session_finalize_test) ); + ts->add( BOOST_TEST_CASE( &handle_accept_test) ); + ts->add( BOOST_TEST_CASE( &handle_client_recv_test) ); + ts->add( BOOST_TEST_CASE( &handle_realserver_connection_fail_test) ); + ts->add( BOOST_TEST_CASE( &handle_client_disconnect_test) ); + framework::master_test_suite().add( ts ); +} + diff --git a/unit_tests/sslid/ssl_protocol_module_base_test.cpp b/unit_tests/sslid/ssl_protocol_module_base_test.cpp new file mode 100644 index 00000000..4307b6cc --- /dev/null +++ b/unit_tests/sslid/ssl_protocol_module_base_test.cpp @@ -0,0 +1,1229 @@ +/* + * ssl_protocol_module_base_test.cpp + * + * Created on: Jan 20, 2009 + * Author: root + */ +#include "sslid_to_be_test_file.h" + +using namespace boost::unit_test; +using namespace l7vs; + +//get_ssl_session_id +void get_ssl_session_id_test(){ + protocol_module_sslid ssl_base; + std::string session_id; + int ret = 0; + char *record_data; + + // unit_test[1] + ret = ssl_base.get_ssl_session_id(NULL, 0, session_id); + BOOST_CHECK_EQUAL(ret, -1); + + // unit_test[2] + record_data = new char[76]; + record_data[43] = 0x20; + ret = ssl_base.get_ssl_session_id(record_data, 76, session_id); + BOOST_CHECK_EQUAL(ret, 0); + delete record_data; + + // unit_test[3] + record_data = new char[76]; + record_data[43] = 0x00; + ret = ssl_base.get_ssl_session_id(record_data, 76, session_id); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; + + // unit_test[4] + record_data = new char[100]; + record_data[43] = 0x20; + ret = ssl_base.get_ssl_session_id(record_data, 100, session_id); + BOOST_CHECK_EQUAL(ret, 0); + delete record_data; + + // unit_test[5] + record_data = new char[100]; + record_data[43] = 0x00; + ret = ssl_base.get_ssl_session_id(record_data, 100, session_id); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; +} + +//check_ssl_record_sendable +void check_ssl_record_sendable(){ + protocol_module_sslid ssl_base; + bool is_message_from_client; + char* record_data; + int recv_length; + int all_length; + int check_all_length; + bool is_hello_message; + int ret; + unsigned short high_length; + unsigned short low_length; + + // unit_test[6] + // condition: + // recv_length < 6 + // check: + // check_ssl_record_sendable() return 1 (‘—M•s‰Â) + recv_length = 5; + record_data = new char[recv_length]; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, 1); + delete record_data; + + // unit_test[7] + // condition: + // recv_length = 6, record_data is not a ssl record + // check: + // check_ssl_record_sendable() return -1 (ˆÙí) + recv_length = 6; + record_data = new char[recv_length]; + record_data[0] = 0x00; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; + + // unit_test[8] + // condition: + // recv_length = 6, record_data is a ssl record(minimal size), but is not a hello message. + // check: + // check_ssl_record_sendable() return 0 (‘—M‰Â”\) + recv_length = 6; + record_data = new char[recv_length]; + record_data[0] = 0x17; + record_data[1] = 0x03; + record_data[2] = 0x01; + record_data[3] = 0x00; + record_data[4] = 0x01; + record_data[5] = 0x00; + all_length = 0; + is_hello_message = true; + high_length = static_cast(static_cast(record_data[3])); + high_length = high_length << 8; + low_length = static_cast(static_cast(record_data[4])); + check_all_length = (high_length | low_length) + 5; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK_EQUAL(all_length, check_all_length); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, 0); + delete record_data; + + // unit_test[9] + // condition: + // recv_length = 6, record_data is a ssl record(minimal size), but is not a hello message. + // check: + // check_ssl_record_sendable() return 0 (‘—M‰Â”\) + recv_length = 6; + record_data = new char[recv_length]; + record_data[0] = 0x17; + record_data[1] = 0x03; + record_data[2] = 0x00; + record_data[3] = 0x00; + record_data[4] = 0x01; + record_data[5] = 0x00; + all_length = 0; + is_hello_message = true; + high_length = static_cast(static_cast(record_data[3])); + high_length = high_length << 8; + low_length = static_cast(static_cast(record_data[4])); + check_all_length = (high_length | low_length) + 5; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK_EQUAL(all_length, check_all_length); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, 0); + delete record_data; + + // unit_test[10] + // condition: + // recv_length = 6, record_data is a ssl record(minimal size), and is a hello message. + // check: + // check_ssl_record_sendable() return 1 (‘—M•s‰Â) + recv_length = 6; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x01; + record_data[3] = 0x00; + record_data[4] = 0x01; + record_data[5] = 0x01; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, 1); + delete record_data; + + // unit_test[11] + // condition: + // recv_length = 6, record_data is a ssl record(minimal size), and is a hello message. + // check: + // check_ssl_record_sendable() return 1 (‘—M•s‰Â) + recv_length = 6; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x00; + record_data[3] = 0x00; + record_data[4] = 0x01; + record_data[5] = 0x01; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, 1); + delete record_data; + + // unit_test[12] + // condition: + // recv_length > 6, record_data is not ssl record data + // check: + // check_ssl_record_sendable() return -1 (ˆÙí) + recv_length = 10; + record_data = new char[recv_length]; + record_data[0] = 0x00; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; + + // unit_test[13] + // condition: + // recv_length > 6, record_data is ssl record data, but is not a hello message + // check: + // check_ssl_record_sendable() return 0 (‘—M‰Â”\) + recv_length = 10; + record_data = new char[recv_length]; + record_data[0] = 0x17; + record_data[1] = 0x03; + record_data[2] = 0x01; + record_data[3] = 0x00; + record_data[4] = 0x05; + record_data[5] = 0x00; + is_hello_message = true; + all_length = 0; + high_length = static_cast(static_cast(record_data[3])); + high_length = high_length << 8; + low_length = static_cast(static_cast(record_data[4])); + check_all_length = (high_length | low_length) + 5; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, 0); + delete record_data; + + // unit_test[14] + // condition: + // recv_length > 6, record_data is ssl record data, but is not a hello message + // check: + // check_ssl_record_sendable() return 0 (‘—M‰Â”\) + recv_length = 10; + record_data = new char[recv_length]; + record_data[0] = 0x17; + record_data[1] = 0x03; + record_data[2] = 0x00; + record_data[3] = 0x00; + record_data[4] = 0x05; + record_data[5] = 0x00; + is_hello_message = true; + all_length = 0; + high_length = static_cast(static_cast(record_data[3])); + high_length = high_length << 8; + low_length = static_cast(static_cast(record_data[4])); + check_all_length = (high_length | low_length) + 5; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, 0); + delete record_data; + + // unit_test[15] + // condition: + // recv_length > 6, recv_length < 76, record_data is ssl record data, is a hello message + // check: + // check_ssl_record_sendable() return 1 (‘—M•s‰Â) + recv_length = 10; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x01; + record_data[3] = 0x00; + record_data[4] = 0x05; + record_data[5] = 0x01; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, 1); + delete record_data; + + // unit_test[16] + // condition: + // recv_length > 6, recv_length < 76, record_data is ssl record data, is a hello message + // check: + // check_ssl_record_sendable() return 1 (‘—M•s‰Â) + recv_length = 10; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x00; + record_data[3] = 0x00; + record_data[4] = 0x05; + record_data[5] = 0x01; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, 1); + delete record_data; + + // unit_test[17] + // condition: + // recv_length = 76, record_data is ssl record data, but is a error hello message, + // check: + // check_ssl_record_sendable() return -1 (ˆÙí) + recv_length = 76; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x01; + record_data[3] = 0x00; + record_data[4] = 0x47; + record_data[5] = 0x01; + record_data[9] = 0x00; + record_data[10] = 0x00; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; + + // unit_test[18] + // condition: + // recv_length = 76, record_data is ssl record data, but is a error hello message, + // check: + // check_ssl_record_sendable() return -1 (ˆÙí) + recv_length = 76; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x00; + record_data[3] = 0x00; + record_data[4] = 0x47; + record_data[5] = 0x01; + record_data[9] = 0x00; + record_data[10] = 0x00; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; + + // unit_test[19] + // condition: + // recv_length = 76, record_data is ssl record data, but is a error hello message + // check: + // check_ssl_record_sendable() return -1 (ˆÙí) + recv_length = 76; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x01; + record_data[3] = 0x00; + record_data[4] = 0x47; + record_data[5] = 0x01; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x01; + is_message_from_client = false; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; + + // unit_test[20] + // condition: + // recv_length = 76, record_data is ssl record data, but is a error hello message + // check: + // check_ssl_record_sendable() return -1 (ˆÙí) + recv_length = 76; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x00; + record_data[3] = 0x00; + record_data[4] = 0x47; + record_data[5] = 0x01; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x01; + is_message_from_client = false; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; + + // unit_test[21] + // condition: + // recv_length = 76, record_data is ssl record data, but is a error hello message + // check: + // check_ssl_record_sendable() return -1 (ˆÙí) + recv_length = 76; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x01; + record_data[3] = 0x00; + record_data[4] = 0x47; + record_data[5] = 0x01; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x00; + is_message_from_client = false; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; + + // unit_test[22] + // condition: + // recv_length = 76, record_data is ssl record data, but is a error hello message + // check: + // check_ssl_record_sendable() return -1 (ˆÙí) + recv_length = 76; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x00; + record_data[3] = 0x00; + record_data[4] = 0x47; + record_data[5] = 0x01; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x00; + is_message_from_client = false; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; + + // unit_test[23] + // condition: + // recv_length = 76, record_data is ssl record data, but is a error hello message + // check: + // check_ssl_record_sendable() return -1 (ˆÙí) + recv_length = 76; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x01; + record_data[3] = 0x00; + record_data[4] = 0x47; + record_data[5] = 0x02; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x01; + is_message_from_client = true; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; + + // unit_test[24] + // condition: + // recv_length = 76, record_data is ssl record data, but is a error hello message + // check: + // check_ssl_record_sendable() return -1 (ˆÙí) + recv_length = 76; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x00; + record_data[3] = 0x00; + record_data[4] = 0x47; + record_data[5] = 0x02; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x01; + is_message_from_client = true; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; + + // unit_test[25] + // condition: + // recv_length = 76, record_data is ssl record data, but is a error hello message + // check: + // check_ssl_record_sendable() return -1 (ˆÙí) + recv_length = 76; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x01; + record_data[3] = 0x00; + record_data[4] = 0x47; + record_data[5] = 0x02; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x00; + is_message_from_client = true; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; + + // unit_test[26] + // condition: + // recv_length = 76, record_data is ssl record data, but is a error hello message + // check: + // check_ssl_record_sendable() return -1 (ˆÙí) + recv_length = 76; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x00; + record_data[3] = 0x00; + record_data[4] = 0x47; + record_data[5] = 0x02; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x00; + is_message_from_client = true; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; + + // unit_test[27] + // condition: + // recv_length = 76, record_data is ssl record data, and is client hello message + // check: + // check_ssl_record_sendable() return 0 (‘—M‰Â”\) + recv_length = 76; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x01; + record_data[3] = 0x00; + record_data[4] = 0x47; + record_data[5] = 0x01; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x01; + is_message_from_client = true; + is_hello_message = false; + all_length = 0; + high_length = static_cast(static_cast(record_data[3])); + high_length = high_length << 8; + low_length = static_cast(static_cast(record_data[4])); + check_all_length = (high_length | low_length) + 5; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(is_hello_message); + BOOST_CHECK_EQUAL(all_length, check_all_length); + BOOST_CHECK_EQUAL(ret, 0); + delete record_data; + + // unit_test[28] + // condition: + // recv_length = 76, record_data is ssl record data, and is client hello message + // check: + // check_ssl_record_sendable() return 0 (‘—M‰Â”\) + recv_length = 76; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x00; + record_data[3] = 0x00; + record_data[4] = 0x47; + record_data[5] = 0x01; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x01; + is_message_from_client = true; + is_hello_message = false; + all_length = 0; + high_length = static_cast(static_cast(record_data[3])); + high_length = high_length << 8; + low_length = static_cast(static_cast(record_data[4])); + check_all_length = (high_length | low_length) + 5; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(is_hello_message); + BOOST_CHECK_EQUAL(all_length, check_all_length); + BOOST_CHECK_EQUAL(ret, 0); + delete record_data; + + // unit_test[29] + // condition: + // recv_length = 76, record_data is ssl record data, and is client hello message + // check: + // check_ssl_record_sendable() return 0 (‘—M‰Â”\) + recv_length = 76; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x01; + record_data[3] = 0x00; + record_data[4] = 0x47; + record_data[5] = 0x01; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x00; + is_message_from_client = true; + is_hello_message = false; + all_length = 0; + high_length = static_cast(static_cast(record_data[3])); + high_length = high_length << 8; + low_length = static_cast(static_cast(record_data[4])); + check_all_length = (high_length | low_length) + 5; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(is_hello_message); + BOOST_CHECK_EQUAL(all_length, check_all_length); + BOOST_CHECK_EQUAL(ret, 0); + delete record_data; + + // unit_test[30] + // condition: + // recv_length = 76, record_data is ssl record data, and is client hello message + // check: + // check_ssl_record_sendable() return 0 (‘—M‰Â”\) + recv_length = 76; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x00; + record_data[3] = 0x00; + record_data[4] = 0x47; + record_data[5] = 0x01; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x00; + is_message_from_client = true; + is_hello_message = false; + all_length = 0; + high_length = static_cast(static_cast(record_data[3])); + high_length = high_length << 8; + low_length = static_cast(static_cast(record_data[4])); + check_all_length = (high_length | low_length) + 5; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(is_hello_message); + BOOST_CHECK_EQUAL(all_length, check_all_length); + BOOST_CHECK_EQUAL(ret, 0); + delete record_data; + + // unit_test[31] + // condition: + // recv_length = 76, record_data is ssl record data, and is server hello message + // check: + // check_ssl_record_sendable() return 0 (‘—M‰Â”\) + recv_length = 76; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x01; + record_data[3] = 0x00; + record_data[4] = 0x47; + record_data[5] = 0x02; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x01; + is_message_from_client = false; + is_hello_message = false; + all_length = 0; + high_length = static_cast(static_cast(record_data[3])); + high_length = high_length << 8; + low_length = static_cast(static_cast(record_data[4])); + check_all_length = (high_length | low_length) + 5; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(is_hello_message); + BOOST_CHECK_EQUAL(all_length, check_all_length); + BOOST_CHECK_EQUAL(ret, 0); + delete record_data; + + // unit_test[32] + // condition: + // recv_length = 76, record_data is ssl record data, and is server hello message + // check: + // check_ssl_record_sendable() return 0 (‘—M‰Â”\) + recv_length = 76; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x00; + record_data[3] = 0x00; + record_data[4] = 0x47; + record_data[5] = 0x02; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x01; + is_message_from_client = false; + is_hello_message = false; + all_length = 0; + high_length = static_cast(static_cast(record_data[3])); + high_length = high_length << 8; + low_length = static_cast(static_cast(record_data[4])); + check_all_length = (high_length | low_length) + 5; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(is_hello_message); + BOOST_CHECK_EQUAL(all_length, check_all_length); + BOOST_CHECK_EQUAL(ret, 0); + delete record_data; + + // unit_test[33] + // condition: + // recv_length = 76, record_data is ssl record data, and is server hello message + // check: + // check_ssl_record_sendable() return 0 (‘—M‰Â”\) + recv_length = 76; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x01; + record_data[3] = 0x00; + record_data[4] = 0x47; + record_data[5] = 0x02; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x00; + is_message_from_client = false; + is_hello_message = false; + all_length = 0; + high_length = static_cast(static_cast(record_data[3])); + high_length = high_length << 8; + low_length = static_cast(static_cast(record_data[4])); + check_all_length = (high_length | low_length) + 5; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(is_hello_message); + BOOST_CHECK_EQUAL(all_length, check_all_length); + BOOST_CHECK_EQUAL(ret, 0); + delete record_data; + + // unit_test[34] + // condition: + // recv_length = 76, record_data is ssl record data, and is server hello message + // check: + // check_ssl_record_sendable() return 0 (‘—M‰Â”\) + recv_length = 76; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x00; + record_data[3] = 0x00; + record_data[4] = 0x47; + record_data[5] = 0x02; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x00; + is_message_from_client = false; + is_hello_message = false; + all_length = 0; + high_length = static_cast(static_cast(record_data[3])); + high_length = high_length << 8; + low_length = static_cast(static_cast(record_data[4])); + check_all_length = (high_length | low_length) + 5; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(is_hello_message); + BOOST_CHECK_EQUAL(all_length, check_all_length); + BOOST_CHECK_EQUAL(ret, 0); + delete record_data; + + // unit_test[35] + // condition: + // recv_length > 76, record_data is ssl record data, but is a error hello message, + // check: + // check_ssl_record_sendable() return -1 (ˆÙí) + recv_length = 100; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x01; + record_data[3] = 0x00; + record_data[4] = 0x64; + record_data[5] = 0x01; + record_data[9] = 0x00; + record_data[10] = 0x00; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; + + // unit_test[36] + // condition: + // recv_length > 76, record_data is ssl record data, but is a error hello message, + // check: + // check_ssl_record_sendable() return -1 (ˆÙí) + recv_length = 100; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x00; + record_data[3] = 0x00; + record_data[4] = 0x64; + record_data[5] = 0x01; + record_data[9] = 0x00; + record_data[10] = 0x00; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; + + // unit_test[37] + // condition: + // recv_length > 76, record_data is ssl record data, but is a error hello message + // check: + // check_ssl_record_sendable() return -1 (ˆÙí) + recv_length = 100; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x01; + record_data[3] = 0x00; + record_data[4] = 0x64; + record_data[5] = 0x01; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x01; + is_message_from_client = false; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; + + // unit_test[38] + // condition: + // recv_length > 76, record_data is ssl record data, but is a error hello message + // check: + // check_ssl_record_sendable() return -1 (ˆÙí) + recv_length = 100; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x00; + record_data[3] = 0x00; + record_data[4] = 0x64; + record_data[5] = 0x01; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x01; + is_message_from_client = false; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; + + // unit_test[39] + // condition: + // recv_length > 76, record_data is ssl record data, but is a error hello message + // check: + // check_ssl_record_sendable() return -1 (ˆÙí) + recv_length = 100; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x01; + record_data[3] = 0x00; + record_data[4] = 0x64; + record_data[5] = 0x01; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x00; + is_message_from_client = false; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; + + // unit_test[40] + // condition: + // recv_length > 76, record_data is ssl record data, but is a error hello message + // check: + // check_ssl_record_sendable() return -1 (ˆÙí) + recv_length = 100; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x00; + record_data[3] = 0x00; + record_data[4] = 0x64; + record_data[5] = 0x01; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x00; + is_message_from_client = false; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; + + // unit_test[41] + // condition: + // recv_length > 76, record_data is ssl record data, but is a error hello message + // check: + // check_ssl_record_sendable() return -1 (ˆÙí) + recv_length = 100; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x01; + record_data[3] = 0x00; + record_data[4] = 0x64; + record_data[5] = 0x02; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x01; + is_message_from_client = true; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; + + // unit_test[42] + // condition: + // recv_length > 76, record_data is ssl record data, but is a error hello message + // check: + // check_ssl_record_sendable() return -1 (ˆÙí) + recv_length = 100; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x00; + record_data[3] = 0x00; + record_data[4] = 0x64; + record_data[5] = 0x02; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x01; + is_message_from_client = true; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; + + // unit_test[43] + // condition: + // recv_length > 76, record_data is ssl record data, but is a error hello message + // check: + // check_ssl_record_sendable() return -1 (ˆÙí) + recv_length = 100; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x01; + record_data[3] = 0x00; + record_data[4] = 0x64; + record_data[5] = 0x02; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x00; + is_message_from_client = true; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; + + // unit_test[44] + // condition: + // recv_length > 76, record_data is ssl record data, but is a error hello message + // check: + // check_ssl_record_sendable() return -1 (ˆÙí) + recv_length = 100; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x00; + record_data[3] = 0x00; + record_data[4] = 0x64; + record_data[5] = 0x02; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x00; + is_message_from_client = true; + is_hello_message = true; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(!is_hello_message); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; + + // unit_test[45] + // condition: + // recv_length > 76, record_data is ssl record data, and is client hello message + // check: + // check_ssl_record_sendable() return 0 (‘—M‰Â”\) + recv_length = 100; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x01; + record_data[3] = 0x00; + record_data[4] = 0x64; + record_data[5] = 0x01; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x01; + is_message_from_client = true; + is_hello_message = false; + all_length = 0; + high_length = static_cast(static_cast(record_data[3])); + high_length = high_length << 8; + low_length = static_cast(static_cast(record_data[4])); + check_all_length = (high_length | low_length) + 5; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(is_hello_message); + BOOST_CHECK_EQUAL(all_length, check_all_length); + BOOST_CHECK_EQUAL(ret, 0); + delete record_data; + + // unit_test[46] + // condition: + // recv_length > 76, record_data is ssl record data, and is client hello message + // check: + // check_ssl_record_sendable() return 0 (‘—M‰Â”\) + recv_length = 100; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x00; + record_data[3] = 0x00; + record_data[4] = 0x64; + record_data[5] = 0x01; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x01; + is_message_from_client = true; + is_hello_message = false; + all_length = 0; + high_length = static_cast(static_cast(record_data[3])); + high_length = high_length << 8; + low_length = static_cast(static_cast(record_data[4])); + check_all_length = (high_length | low_length) + 5; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(is_hello_message); + BOOST_CHECK_EQUAL(all_length, check_all_length); + BOOST_CHECK_EQUAL(ret, 0); + delete record_data; + + // unit_test[47] + // condition: + // recv_length > 76, record_data is ssl record data, and is client hello message + // check: + // check_ssl_record_sendable() return 0 (‘—M‰Â”\) + recv_length = 100; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x01; + record_data[3] = 0x00; + record_data[4] = 0x64; + record_data[5] = 0x01; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x00; + is_message_from_client = true; + is_hello_message = false; + all_length = 0; + high_length = static_cast(static_cast(record_data[3])); + high_length = high_length << 8; + low_length = static_cast(static_cast(record_data[4])); + check_all_length = (high_length | low_length) + 5; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(is_hello_message); + BOOST_CHECK_EQUAL(all_length, check_all_length); + BOOST_CHECK_EQUAL(ret, 0); + delete record_data; + + // unit_test[48] + // condition: + // recv_length > 76, record_data is ssl record data, and is client hello message + // check: + // check_ssl_record_sendable() return 0 (‘—M‰Â”\) + recv_length = 100; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x00; + record_data[3] = 0x00; + record_data[4] = 0x64; + record_data[5] = 0x01; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x00; + is_message_from_client = true; + is_hello_message = false; + all_length = 0; + high_length = static_cast(static_cast(record_data[3])); + high_length = high_length << 8; + low_length = static_cast(static_cast(record_data[4])); + check_all_length = (high_length | low_length) + 5; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(is_hello_message); + BOOST_CHECK_EQUAL(all_length, check_all_length); + BOOST_CHECK_EQUAL(ret, 0); + delete record_data; + + // unit_test[49] + // condition: + // recv_length = 76, record_data is ssl record data, and is server hello message + // check: + // check_ssl_record_sendable() return 0 (‘—M‰Â”\) + recv_length = 100; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x01; + record_data[3] = 0x00; + record_data[4] = 0x64; + record_data[5] = 0x02; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x01; + is_message_from_client = false; + is_hello_message = false; + all_length = 0; + high_length = static_cast(static_cast(record_data[3])); + high_length = high_length << 8; + low_length = static_cast(static_cast(record_data[4])); + check_all_length = (high_length | low_length) + 5; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(is_hello_message); + BOOST_CHECK_EQUAL(all_length, check_all_length); + BOOST_CHECK_EQUAL(ret, 0); + delete record_data; + + // unit_test[50] + // condition: + // recv_length = 76, record_data is ssl record data, and is server hello message + // check: + // check_ssl_record_sendable() return 0 (‘—M‰Â”\) + recv_length = 100; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x00; + record_data[3] = 0x00; + record_data[4] = 0x64; + record_data[5] = 0x02; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x01; + is_message_from_client = false; + is_hello_message = false; + all_length = 0; + high_length = static_cast(static_cast(record_data[3])); + high_length = high_length << 8; + low_length = static_cast(static_cast(record_data[4])); + check_all_length = (high_length | low_length) + 5; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(is_hello_message); + BOOST_CHECK_EQUAL(all_length, check_all_length); + BOOST_CHECK_EQUAL(ret, 0); + delete record_data; + + // unit_test[51] + // condition: + // recv_length = 76, record_data is ssl record data, and is server hello message + // check: + // check_ssl_record_sendable() return 0 (‘—M‰Â”\) + recv_length = 100; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x01; + record_data[3] = 0x00; + record_data[4] = 0x64; + record_data[5] = 0x02; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x00; + is_message_from_client = false; + is_hello_message = false; + all_length = 0; + high_length = static_cast(static_cast(record_data[3])); + high_length = high_length << 8; + low_length = static_cast(static_cast(record_data[4])); + check_all_length = (high_length | low_length) + 5; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(is_hello_message); + BOOST_CHECK_EQUAL(all_length, check_all_length); + BOOST_CHECK_EQUAL(ret, 0); + delete record_data; + + // unit_test[52] + // condition: + // recv_length = 76, record_data is ssl record data, and is server hello message + // check: + // check_ssl_record_sendable() return 0 (‘—M‰Â”\) + recv_length = 100; + record_data = new char[recv_length]; + record_data[0] = 0x16; + record_data[1] = 0x03; + record_data[2] = 0x00; + record_data[3] = 0x00; + record_data[4] = 0x64; + record_data[5] = 0x02; // client hello = 0x01, server hello = 0x02 + record_data[9] = 0x03; + record_data[10] = 0x00; + is_message_from_client = false; + is_hello_message = false; + all_length = 0; + high_length = static_cast(static_cast(record_data[3])); + high_length = high_length << 8; + low_length = static_cast(static_cast(record_data[4])); + check_all_length = (high_length | low_length) + 5; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, + recv_length, all_length, is_hello_message); + BOOST_CHECK(is_hello_message); + BOOST_CHECK_EQUAL(all_length, check_all_length); + BOOST_CHECK_EQUAL(ret, 0); + delete record_data; + + // unit_test[53] + // condition: + // record_data = NULL + // check: + // check_ssl_record_sendable() return -1 (ˆÙí) + record_data = NULL; + ret = ssl_base.check_ssl_record_sendable(is_message_from_client, record_data, 0, + all_length, is_hello_message); + BOOST_CHECK_EQUAL(ret, -1); + delete record_data; +} + +void ssl_protocol_module_base_test_main() +{ + test_suite* ts = BOOST_TEST_SUITE( "ssl_protocol_module_base_ut" ); + ts->add( BOOST_TEST_CASE( &get_ssl_session_id_test ) ); + ts->add( BOOST_TEST_CASE( &check_ssl_record_sendable ) ); + framework::master_test_suite().add( ts ); +}