l7vsd/src/l7vsadm.cpp

   1 /*!
   2  *      @file   l7vsadm.cpp
   3  *      @brief  l7vsadm command is l7vsd control application
   4  *
   5  * L7VSD: Linux Virtual Server for Layer7 Load Balancing
   6  * Copyright (C) 2009  NTT COMWARE Corporation.
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  21  * 02110-1301 USA
  22  *
  23  **********************************************************************/
  24
  25 #include <iostream>
  26 #include <sstream>
  27 #include <exception>
  28 #include <boost/bind.hpp>
  29 #include <boost/archive/text_oarchive.hpp>
  30 #include <boost/archive/text_iarchive.hpp>
  31 #include <boost/format.hpp>
  32 #include <boost/algorithm/string.hpp>
  33 #include <sys/file.h>
  34 #include "l7vsadm.h"
  35 #include "logger.h"
  36 #include "parameter.h"
  37 #include "protocol_module_control.h"
  38 #include "schedule_module_control.h"
  39
  40 // global function prototype
  41 static void     sig_exit_handler(int sig);
  42 static int      set_sighandler(int sig, void (*handler)(int));
  43 static int      set_sighandlers();
  44
  45 // global variables
  46 static bool     signal_flag = false;
  47 static int      received_sig = 0;
  48
  49 //
  50 // command functions.
  51 //
  52 //! list command parsing.
  53 //! @param[in]  request command
  54 //! @param[in]  argument count
  55 //! @param[in]  argument value
  56 bool    l7vs::l7vsadm::parse_list_func( l7vs::l7vsadm_request::COMMAND_CODE_TAG cmd, int argc, char* argv[] ){
  57         Logger  logger( LOG_CAT_L7VSADM_COMMON, 1, "l7vsadm::parse_list_func", __FILE__, __LINE__ );
  58
  59         request.command = cmd;  // set command
  60         if( argc < 3 ) return true;     // option is none. this pattern is true
  61         for( int pos = 2; pos < argc; ++pos ){  //search option function from argv strings
  62                 parse_opt_map_type::iterator itr = list_option_dic.find( argv[pos] );
  63                 if( itr != list_option_dic.end() ){     // option string function find.
  64                         if( ! itr->second( pos, argc, argv ) ) return false;    // option string function error.
  65                 }
  66                 else{   //option string function don't find.
  67                         // print option not found message.
  68                         std::stringstream buf;
  69                         buf << "list option not found:" << argv[pos];
  70                         l7vsadm_err.setter( true, buf.str() );
  71                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 1, buf.str(), __FILE__, __LINE__ );
  72                         return false;
  73                 }
  74         }
  75         return true;
  76 }
  77 //
  78 // option list functions.
  79 //
  80 //! list numeric flag check.
  81 //! @param[in]  argument position
  82 //! @param[in]  argument count
  83 //! @param[in]  argument value
  84 bool    l7vs::l7vsadm::parse_opt_list_numeric_func( int& pos, int argc, char* argv[] ){
  85         Logger  logger( LOG_CAT_L7VSADM_COMMON, 2, "l7vsadm::parse_opt_list_numeric_func", __FILE__, __LINE__ );
  86
  87         numeric_flag = true;    //numeric flag on.
  88         return true;
  89 }
  90
  91 //! virtualservice command parsing.
  92 //! @param[in]  request command
  93 //! @param[in]  argument count
  94 //! @param[in]  argument value
  95 bool    l7vs::l7vsadm::parse_vs_func( l7vs::l7vsadm_request::COMMAND_CODE_TAG cmd, int argc, char* argv[] ){
  96         Logger  logger( LOG_CAT_L7VSADM_COMMON, 3, "l7vsadm::parse_vs_func", __FILE__, __LINE__ );
  97
  98         request.command = cmd;  // set command
  99         for( int pos = 2; pos < argc; ++pos ){  // check options.
 100                 parse_opt_map_type::iterator itr = vs_option_dic.find( argv[pos] );
 101                 if( itr != vs_option_dic.end() ){       // find option
 102                         if( ! itr->second( pos, argc, argv ) ) return false;    // option function execute.
 103                 }
 104                 else{   // don't find option function.
 105                         std::stringstream buf;
 106                         buf << "virtualservice option not found:" << argv[pos];
 107                         l7vsadm_err.setter( true, buf.str() );
 108                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 2, buf.str(), __FILE__, __LINE__ );
 109                         return false;
 110                 }
 111         }
 112         // check virtualservice on response
 113         //
 114         if( l7vsadm_request::CMD_FLUSH_VS == cmd ){
 115                 // flushvs required no option
 116                 return true;
 117         }
 118         if( ( l7vsadm_request::CMD_ADD_VS == cmd ) && ( request.vs_element.schedule_module_name.length() == 0 ) ){
 119                 //scheduler module not specified
 120                 //scheduler module check.
 121                 std::string     scheduler_name = L7VSADM_DEFAULT_SCHEDULER;             //default scheduler
 122                 schedule_module_control&        ctrl = schedule_module_control::getInstance();
 123                 ctrl.initialize( L7VS_MODULE_PATH );
 124                 schedule_module_base* module;
 125                 try{
 126                         module = ctrl.load_module( scheduler_name );
 127                 }
 128                 catch( ... ){
 129                         std::stringstream buf;
 130                         buf << "scheduler module load error:" << scheduler_name;
 131                         l7vsadm_err.setter( true, buf.str() );
 132                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 3, buf.str(), __FILE__, __LINE__ );
 133                         return false;
 134                 }
 135                 if( !module ){
 136                         // don't find schedule module
 137                         std::stringstream buf;
 138                         buf << "scheduler module not found:" << scheduler_name;
 139                         l7vsadm_err.setter( true, buf.str() );
 140                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 4, buf.str(), __FILE__, __LINE__ );
 141                         return false;
 142                 }
 143                 ctrl.unload_module( module );
 144                 request.vs_element.schedule_module_name = scheduler_name;
 145         }
 146         if( request.vs_element.protocol_module_name.length() == 0 ){
 147                 //protocol module name error
 148                 std::string     buf("protocol module not specified.");
 149                 l7vsadm_err.setter( true, buf );
 150                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 5, buf, __FILE__, __LINE__ );
 151                 return false;
 152         }
 153         if( request.vs_element.udpmode ){
 154                 if( request.vs_element.udp_recv_endpoint == boost::asio::ip::udp::endpoint() ){
 155                         // udp mode,but not acceptor endpoint
 156                         std::string buf("udp recv endpoint not specified.");
 157                         l7vsadm_err.setter( true, buf );
 158                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 6, buf, __FILE__, __LINE__ );
 159                         return false;
 160                 }
 161         }
 162         else{
 163                 if( request.vs_element.tcp_accept_endpoint == boost::asio::ip::tcp::endpoint() ){
 164                         // tcp mode, but not acceptor endpoint
 165                         std::string buf("tcp accpeptor endpoint not specified.");
 166                         l7vsadm_err.setter( true, buf );
 167                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 7, buf, __FILE__, __LINE__ );
 168                         return false;
 169                 }
 170         }
 171         if( 0 > request.vs_element.sorry_maxconnection ){
 172                 std::string     buf("invalid sorry_maxconnection value.");
 173                 l7vsadm_err.setter( true, buf );
 174                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 8, buf, __FILE__, __LINE__ );
 175                 return false;
 176         }
 177         return true;
 178 }
 179 //
 180 // option virtualservice functions.
 181 //
 182 //! target option check
 183 //! @param[in]  argument position
 184 //! @param[in]  argument count
 185 //! @param[in]  argument value
 186 bool    l7vs::l7vsadm::parse_opt_vs_target_func( int& pos, int argc, char* argv[] ){
 187         Logger  logger( LOG_CAT_L7VSADM_COMMON, 4, "l7vsadm::parse_opt_vs_target_func", __FILE__, __LINE__ );
 188
 189         if( ++pos >= argc ){
 190                 //don't target recvaddress:port
 191                 std::string     buf("target endpoint is not specified.");
 192                 l7vsadm_err.setter( true, buf );
 193                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 9, buf, __FILE__, __LINE__ );
 194                 return false;
 195         }
 196         // get host endpoint from string
 197         std::string     src_str = argv[pos];
 198         if( request.vs_element.udpmode ){
 199                 error_code      err;
 200                 request.vs_element.udp_recv_endpoint = string_to_endpoint<boost::asio::ip::udp>( src_str, err );
 201                 if( err ){
 202                         std::stringstream buf;
 203                         buf << "target endpoint parse error:" << err.get_message() << src_str;
 204                         l7vsadm_err.setter( true, buf.str() );
 205                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 10, buf.str(), __FILE__, __LINE__ );
 206                         return false;
 207                 }
 208                 check_endpoint<boost::asio::ip::udp>( request.vs_element.udp_recv_endpoint, err );
 209                 if ( err ){
 210                         std::stringstream buf;
 211                         buf << "target endpoint parse error:" << err.get_message() << src_str;
 212                         l7vsadm_err.setter( true, buf.str() );
 213                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 11, buf.str(), __FILE__, __LINE__ );
 214                         return false;
 215                 }
 216         }
 217         else{
 218                 error_code      err;
 219                 request.vs_element.tcp_accept_endpoint = string_to_endpoint<boost::asio::ip::tcp>( src_str, err );
 220                 if( err ){
 221                         std::stringstream buf;
 222                         buf << "target endpoint parse error:" << err.get_message() << src_str;
 223                         l7vsadm_err.setter( true, buf.str() );
 224                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 12, buf.str(), __FILE__, __LINE__ );
 225                         return false;
 226                 }
 227                 check_endpoint<boost::asio::ip::tcp>( request.vs_element.tcp_accept_endpoint, err );
 228                 if ( err ){
 229                         std::stringstream buf;
 230                         buf << "target endpoint parse error:" << err.get_message() << src_str;
 231                         l7vsadm_err.setter( true, buf.str() );
 232                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 13, buf.str(), __FILE__, __LINE__ );
 233                         return false;
 234                 }
 235         }
 236         return true;
 237 }
 238 //! module option check
 239 //! @param[in]  argument position
 240 //! @param[in]  argument count
 241 //! @param[in]  argument value
 242 bool    l7vs::l7vsadm::parse_opt_vs_module_func( int& pos, int argc, char* argv[] ){
 243         Logger  logger( LOG_CAT_L7VSADM_COMMON, 5, "l7vsadm::parse_opt_vs_module_func", __FILE__, __LINE__ );
 244
 245         if( ++pos >= argc ){
 246                 //don't target protomod name.
 247                 std::string     buf("protomod name is not specified.");
 248                 l7vsadm_err.setter( true, buf );
 249                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 14, buf, __FILE__, __LINE__ );
 250                 return false;
 251         }
 252         std::string     module_name = argv[pos];
 253         if( L7VS_MODNAME_LEN < module_name.length() ){
 254                 std::string     buf("protomod name is too long.");
 255                 l7vsadm_err.setter( true, buf );
 256                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 15, buf, __FILE__, __LINE__ );
 257                 return false;
 258         }
 259         protocol_module_control&        ctrl = protocol_module_control::getInstance();
 260         ctrl.initialize( L7VS_MODULE_PATH );
 261         protocol_module_base* module;
 262         try{
 263                 module = ctrl.load_module( module_name );
 264         }
 265         catch( ... ){
 266                 std::stringstream buf;
 267                 buf << "protocol module load error:" << module_name;
 268                 l7vsadm_err.setter( true, buf.str() );
 269                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 16, buf.str(), __FILE__, __LINE__ );
 270                 return false;
 271         }
 272         if( !module ){
 273                 //don't find protocol module.
 274                 std::stringstream buf;
 275                 buf << "protocol module not found:" << module_name;
 276                 l7vsadm_err.setter( true, buf.str() );
 277                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 17, buf.str(), __FILE__, __LINE__ );
 278                 return false;
 279         }
 280         module->init_logger_functions(
 281                                         boost::bind( &l7vs::Logger::getLogLevel, l7vs::LOG_CAT_PROTOCOL ),
 282                                         boost::bind( &l7vs::Logger::putLogFatal, l7vs::LOG_CAT_PROTOCOL, _1, _2, _3, _4 ),
 283                                         boost::bind( &l7vs::Logger::putLogError, l7vs::LOG_CAT_PROTOCOL, _1, _2, _3, _4 ),
 284                                         boost::bind( &l7vs::Logger::putLogWarn, l7vs::LOG_CAT_PROTOCOL, _1, _2, _3, _4 ),
 285                                         boost::bind( &l7vs::Logger::putLogInfo, l7vs::LOG_CAT_PROTOCOL, _1, _2, _3, _4 ),
 286                                         boost::bind( &l7vs::Logger::putLogDebug, l7vs::LOG_CAT_PROTOCOL, _1, _2, _3, _4 ) );
 287         // create module args.
 288         std::vector< std::string > module_args;
 289         while( true ){
 290                 if( ++pos == argc ) break; //module option end.
 291                 parse_opt_map_type::iterator vsitr = vs_option_dic.find( argv[pos] );
 292                 if( vsitr != vs_option_dic.end() ){
 293                         --pos;  // back for next option
 294                         break;  // module option end.
 295                 }
 296                 parse_opt_map_type::iterator rsitr = rs_option_dic.find( argv[pos] );
 297                 if( rsitr != rs_option_dic.end() ){
 298                         --pos;  // back for next option
 299                         break;  // module option end.
 300                 }
 301                 module_args.push_back( argv[pos] );
 302         }
 303         //>> socket option
 304         std::vector< std::string > chk_module_args;
 305
 306         BOOST_FOREACH( std::string str, module_args ){
 307                 chk_module_args.push_back( str );
 308         }
 309
 310         protocol_module_base::check_message_result socket_option_message;
 311         socket_option_message.flag = true;
 312         std::vector<std::string>::iterator args_itr = chk_module_args.begin();
 313         bool is_fond = false;
 314
 315         while( args_itr != chk_module_args.end()){
 316
 317                 if(  *args_itr == "-C" || *args_itr == "--cookie-name" ){
 318                         args_itr++;
 319                         // next value
 320                         if(args_itr != chk_module_args.end()){
 321                                 args_itr++;
 322                         }
 323                 }else if( *args_itr == "-E" || *args_itr == "--cookie-expire" ){
 324                         args_itr++;
 325                         // next value
 326                         if(args_itr != chk_module_args.end()){
 327                                 args_itr++;
 328                         }
 329 //              }else if( *args_itr == "-F" || *args_itr == "--forwarded-for" ){
 330 //              }else if( *args_itr == "-R" || *args_itr == "--reschedule" ){
 331 //              }else if( *args_itr == "-N" || *args_itr == "--no-reschedule" ){
 332                 }else if( *args_itr == "-S" || *args_itr == "--sorry-uri" ){
 333                         args_itr++;
 334                         // next value
 335                         if(args_itr != chk_module_args.end()){
 336                                 args_itr++;
 337                         }
 338                 }else if( *args_itr == "-T" || *args_itr == "--timeout" ){
 339                         args_itr++;
 340                         // next value
 341                         if(args_itr != chk_module_args.end()){
 342                                 args_itr++;
 343                         }
 344                 }else if( *args_itr == "-M" || *args_itr == "--maxlist" ){
 345                         args_itr++;
 346                         // next value
 347                         if(args_itr != chk_module_args.end()){
 348                                 args_itr++;
 349                         }
 350                 }else if( *args_itr == "-O" || *args_itr == "--sockopt" ){
 351                         if(is_fond){
 352                                 // duplication
 353                                 socket_option_message.flag = false;
 354                                 socket_option_message.message = "'-O/--sock-opt' option value '";
 355                                 socket_option_message.message +=        *args_itr;
 356                                 socket_option_message.message +=        "' is not numeric character.";
 357                                 break;
 358                         }
 359                         is_fond = true;
 360                         args_itr = chk_module_args.erase(args_itr);
 361                         if(args_itr == chk_module_args.end()){
 362                                 // not socket opution value
 363                                 socket_option_message.flag = false;
 364                                 socket_option_message.message = "'-O/--sock-opt' option value not socket opution value error.";
 365                                 break;
 366                         }
 367
 368                         std::string sock_option_val = *args_itr;
 369                         args_itr = chk_module_args.erase(args_itr);
 370
 371                         unsigned int hed_pos = 0;
 372                         bool is_fond_da = false;
 373                         bool is_fond_nd = false;
 374                         bool is_fond_ck = false;
 375                         bool is_fond_qa = false;
 376
 377                         while((hed_pos + 2) < sock_option_val.length()){
 378
 379                                 if(sock_option_val.substr(hed_pos,2) == "da"){
 380                                         if(is_fond_da){
 381                                                 // da(defer_accept option) duplication error
 382                                                 socket_option_message.flag = false;
 383                                                 socket_option_message.message = "'-O/--sock-opt' option value da(defer_accept option) duplication error.";
 384                                                 break;
 385                                         }
 386                                         hed_pos += 2;
 387                                         if(sock_option_val.substr(hed_pos,3) == ":on"){
 388                                                 is_fond_da = true;
 389                                                 hed_pos += 3;
 390                                                 if((hed_pos + 1) < sock_option_val.length()){
 391                                                         if( sock_option_val.substr(hed_pos,1) == ",") {
 392                                                                 hed_pos += 1;
 393                                                         }else{
 394                                                                 socket_option_message.flag = false;
 395                                                                 socket_option_message.message = "'-O/--sock-opt' option value '";
 396                                                                 socket_option_message.message +=        *args_itr;
 397                                                                 socket_option_message.message +=        "' wrong value ex. da:on,nd:on,ck:on,qa:on";
 398                                                                 break;
 399                                                         }
 400                                                 }
 401                                         }else{
 402                                                 socket_option_message.flag = false;
 403                                                 socket_option_message.message = "'-O/--sock-opt' option value '";
 404                                                 socket_option_message.message +=        *args_itr;
 405                                                 socket_option_message.message +=        "' wrong value ex. da:on,nd:on,ck:on,qa:on";
 406                                                 break;
 407                                         }
 408                                 }else if(sock_option_val.substr(hed_pos,2) == "nd"){
 409                                         if(is_fond_nd){
 410                                                 // nd(nodelay option) duplication error
 411                                                 socket_option_message.flag = false;
 412                                                 socket_option_message.message = "'-O/--sock-opt' option value nd(nodelay option) duplication error.";
 413                                                 break;
 414                                         }
 415                                         hed_pos += 2;
 416                                         if(sock_option_val.substr(hed_pos,3) == ":on"){
 417                                                 is_fond_nd = true;
 418                                                 hed_pos += 3;
 419                                                 if((hed_pos + 1) < sock_option_val.length()){
 420                                                         if( sock_option_val.substr(hed_pos,1) == ",") {
 421                                                                 hed_pos += 1;
 422                                                         }else{
 423                                                                 socket_option_message.flag = false;
 424                                                                 socket_option_message.message = "'-O/--sock-opt' option value '";
 425                                                                 socket_option_message.message +=        *args_itr;
 426                                                                 socket_option_message.message +=        "' wrong value ex. da:on,nd:on,ck:on,qa:on";
 427                                                                 break;
 428                                                         }
 429                                                 }
 430                                         }else{
 431                                                 socket_option_message.flag = false;
 432                                                 socket_option_message.message = "'-O/--sock-opt' option value '";
 433                                                 socket_option_message.message +=        *args_itr;
 434                                                 socket_option_message.message +=        "' wrong value ex. da:on,nd:on,ck:on,qa:on";
 435                                                 break;
 436                                         }
 437                                 }else if(sock_option_val.substr(hed_pos,2) == "ck"){
 438                                         if(is_fond_ck){
 439                                                 // ck(cork option) duplication error
 440                                                 socket_option_message.flag = false;
 441                                                 socket_option_message.message = "'-O/--sock-opt' option value ck(cork option) duplication error.";
 442                                         }
 443                                         hed_pos += 2;
 444                                         if(sock_option_val.substr(hed_pos,3) == ":on"){
 445                                                 is_fond_ck = true;
 446                                                 hed_pos += 3;
 447                                                 if((hed_pos + 1) < sock_option_val.length()){
 448                                                         if( sock_option_val.substr(hed_pos,1) == ",") {
 449                                                                 hed_pos += 1;
 450                                                         }else{
 451                                                                 socket_option_message.flag = false;
 452                                                                 socket_option_message.message = "'-O/--sock-opt' option value '";
 453                                                                 socket_option_message.message +=        *args_itr;
 454                                                                 socket_option_message.message +=        "' wrong value ex. da:on,nd:on,ck:on,qa:on";
 455                                                                 break;
 456                                                         }
 457                                                 }
 458                                         }else{
 459                                                 socket_option_message.flag = false;
 460                                                 socket_option_message.message = "'-O/--sock-opt' option value '";
 461                                                 socket_option_message.message +=        *args_itr;
 462                                                 socket_option_message.message +=        "' wrong value ex. da:on,nd:on,ck:on,qa:on";
 463                                                 break;
 464                                         }
 465
 466                                 }else if(sock_option_val.substr(hed_pos,2) == "qa"){
 467                                         if(is_fond_qa){
 468                                                 // qa(quickack option) duplication error
 469                                                 socket_option_message.flag = false;
 470                                                 socket_option_message.message = "'-O/--sock-opt' option value qa(quickack option) duplication error.";
 471                                         }
 472                                         hed_pos += 2;
 473                                         if(sock_option_val.substr(hed_pos,3) == ":on"){
 474                                                 is_fond_qa = true;
 475                                                 hed_pos += 3;
 476                                                 if((hed_pos + 1) < sock_option_val.length()){
 477                                                         if( sock_option_val.substr(hed_pos,1) == ",") {
 478                                                                 hed_pos += 1;
 479                                                         }else{
 480                                                                 socket_option_message.flag = false;
 481                                                                 socket_option_message.message = "'-O/--sock-opt' option value '";
 482                                                                 socket_option_message.message +=        *args_itr;
 483                                                                 socket_option_message.message +=        "' wrong value ex. da:on,nd:on,ck:on,qa:on";
 484                                                                 break;
 485                                                         }
 486                                                 }
 487                                         }else if(sock_option_val.substr(hed_pos,4) == ":off"){
 488                                                 is_fond_qa = true;
 489                                                 hed_pos += 3;
 490                                                 if((hed_pos + 1) < sock_option_val.length()){
 491                                                         if( sock_option_val.substr(hed_pos,1) == ",") {
 492                                                                 hed_pos += 1;
 493                                                         }else{
 494                                                                 socket_option_message.flag = false;
 495                                                                 socket_option_message.message = "'-O/--sock-opt' option value '";
 496                                                                 socket_option_message.message +=        *args_itr;
 497                                                                 socket_option_message.message +=        "' wrong value ex. da:on,nd:on,ck:on,qa:on";
 498                                                                 break;
 499                                                         }
 500                                                 }
 501                                         }else{
 502                                                 socket_option_message.flag = false;
 503                                                 socket_option_message.message = "'-O/--sock-opt' option value '";
 504                                                 socket_option_message.message +=        *args_itr;
 505                                                 socket_option_message.message +=        "' wrong value ex. da:on,nd:on,ck:on,qa:on";
 506                                                 break;
 507                                         }
 508                                 }else{
 509                                         socket_option_message.flag = false;
 510                                         socket_option_message.message = "'-O/--sock-opt' option value '";
 511                                         socket_option_message.message +=        *args_itr;
 512                                         socket_option_message.message +=        "' wrong value ex. da:on,nd:on,ck:on,qa:on";
 513                                         break;
 514                                 }
 515                         }
 516                         if(!socket_option_message.flag){
 517                                 break;
 518                         }
 519                 }else{
 520                         args_itr++;
 521                 }
 522         }
 523
 524         if( !socket_option_message.flag ){
 525                 // args is not supported.
 526                 std::stringstream       buf;
 527                 buf << "protocol module argument error: " << socket_option_message.message;
 528                 l7vsadm_err.setter( true, buf.str() );
 529                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 100, buf.str(), __FILE__, __LINE__ );
 530                 return false;
 531         }
 532 //      protocol_module_base::check_message_result module_message = module->check_parameter( module_args );
 533         protocol_module_base::check_message_result module_message = module->check_parameter( chk_module_args );
 534         //<< socket option
 535         if( !module_message.flag ){
 536                 // args is not supported.
 537                 std::stringstream       buf;
 538                 buf << "protocol module argument error: " << module_message.message;
 539                 l7vsadm_err.setter( true, buf.str() );
 540                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 18, buf.str(), __FILE__, __LINE__ );
 541                 return false;
 542         }
 543         request.vs_element.protocol_module_name = module_name;
 544         BOOST_FOREACH( std::string str, module_args ){
 545                 request.vs_element.protocol_args.push_back( str );
 546         }
 547         ctrl.unload_module( module );
 548
 549         return true;
 550 }
 551
 552 //! scheduler option check.
 553 //! @param[in]  argument position
 554 //! @param[in]  argument count
 555 //! @param[in]  argument value
 556 bool    l7vs::l7vsadm::parse_opt_vs_scheduler_func( int& pos, int argc, char* argv[] ){
 557         Logger  logger( LOG_CAT_L7VSADM_COMMON, 6, "l7vsadm::parse_opt_vs_scheduler_func", __FILE__, __LINE__ );
 558
 559         if( ++pos >= argc ){
 560                 // don't target scheduler name.
 561                 std::string     buf("scheduler name is not specified.");
 562                 l7vsadm_err.setter( true, buf );
 563                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 19, buf, __FILE__, __LINE__ );
 564                 return false;
 565         }
 566         //schedule module check.
 567         std::string     scheduler_name = argv[pos];
 568         if( L7VS_MODNAME_LEN < scheduler_name.length() ){
 569                 std::string     buf("scheduler name is too long.");
 570                 l7vsadm_err.setter( true, buf );
 571                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 20, buf, __FILE__, __LINE__ );
 572                 return false;
 573         }
 574         schedule_module_control&        ctrl = schedule_module_control::getInstance();
 575         ctrl.initialize( L7VS_MODULE_PATH );
 576         schedule_module_base* module;
 577         try{
 578                 module = ctrl.load_module( scheduler_name );
 579         }
 580         catch( ... ){
 581                 std::stringstream buf;
 582                 buf << "scheduler module load error:" << scheduler_name;
 583                 l7vsadm_err.setter( true, buf.str() );
 584                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 21, buf.str(), __FILE__, __LINE__ );
 585                 return false;
 586         }
 587         if( !module ){
 588                 // don't find schedule module
 589                 std::stringstream buf;
 590                 buf << "scheduler module not found:" << scheduler_name;
 591                 l7vsadm_err.setter( true, buf.str() );
 592                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 22, buf.str(), __FILE__, __LINE__ );
 593                 return false;
 594         }
 595         ctrl.unload_module( module );
 596         request.vs_element.schedule_module_name = scheduler_name;
 597         return true;
 598 }
 599 //! upper flag check
 600 //! @param[in]  argument position
 601 //! @param[in]  argument count
 602 //! @param[in]  argument value
 603 bool    l7vs::l7vsadm::parse_opt_vs_upper_func( int& pos, int argc, char* argv[] ){
 604         Logger  logger( LOG_CAT_L7VSADM_COMMON, 7, "l7vsadm::parse_opt_vs_upper_func", __FILE__, __LINE__ );
 605
 606         if( ++pos >= argc ){
 607                 // don't target maxconnection_num
 608                 std::string     buf("maxconnection value is not specified.");
 609                 l7vsadm_err.setter( true, buf );
 610                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 23, buf, __FILE__, __LINE__ );
 611                 return false;
 612         }
 613         try{
 614                 request.vs_element.sorry_maxconnection = boost::lexical_cast< long long >( argv[pos] );
 615                 if( ( 0LL > request.vs_element.sorry_maxconnection ) ||
 616                         ( 100000LL < request.vs_element.sorry_maxconnection ) ){
 617                         std::string     buf("invalid sorry_maxconnection value.");
 618                         l7vsadm_err.setter( true, buf );
 619                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 24, buf, __FILE__, __LINE__ );
 620                         return false;
 621                 }
 622                 if( 0LL == request.vs_element.sorry_maxconnection )
 623                         request.vs_element.sorry_maxconnection = LLONG_MAX;             // clear value
 624         }
 625         catch( boost::bad_lexical_cast& e ){
 626                 // don't convert argv[pos] is
 627                 std::string     buf("invalid sorry_maxconnection value.");
 628                 l7vsadm_err.setter( true, buf );
 629                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 25, buf, __FILE__, __LINE__ );
 630                 return false;
 631         }
 632         //check connection limit and zero
 633         return true;
 634 }
 635 //! bypass(SorryServer) option check
 636 //! @param[in]  argument position
 637 //! @param[in]  argument count
 638 //! @param[in]  argument value
 639 bool    l7vs::l7vsadm::parse_opt_vs_bypass_func( int& pos, int argc, char* argv[] ){
 640         Logger  logger( LOG_CAT_L7VSADM_COMMON, 8, "l7vsadm::parse_opt_vs_bypass_func", __FILE__, __LINE__ );
 641
 642         if( ++pos >= argc ){
 643                 //don't target sorryserver:port
 644                 std::string     buf("sorryserver endpoint is not specified.");
 645                 l7vsadm_err.setter( true, buf );
 646                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 26, buf, __FILE__, __LINE__ );
 647                 return false;
 648         }
 649         std::string sorry_endpoint = argv[pos];
 650         error_code err;
 651         request.vs_element.sorry_endpoint = string_to_endpoint< boost::asio::ip::tcp > ( sorry_endpoint, err );
 652         if( err ){
 653                 std::stringstream buf;
 654                 buf << "sorryserver endpoint parse error:" << err.get_message() << sorry_endpoint;
 655                 l7vsadm_err.setter( true, buf.str() );
 656                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 27, buf.str(), __FILE__, __LINE__ );
 657                 return false;
 658         }
 659         // clear endpoint check
 660         if( request.vs_element.sorry_endpoint == boost::asio::ip::tcp::endpoint() ){
 661                 std::string     clear_endpoint = "255.255.255.255:0";           // clear value
 662                 request.vs_element.sorry_endpoint = string_to_endpoint< boost::asio::ip::tcp > ( clear_endpoint, err );
 663                 if( err ){
 664                         std::stringstream buf;
 665                         buf << "sorryserver endpoint parse error:" << err.get_message() << clear_endpoint;
 666                         l7vsadm_err.setter( true, buf.str() );
 667                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 28, buf.str(), __FILE__, __LINE__ );
 668                         return false;
 669                 }
 670         }
 671         else{
 672                 check_endpoint<boost::asio::ip::tcp>( request.vs_element.sorry_endpoint, err );
 673                 if ( err ){
 674                         std::stringstream buf;
 675                         buf << "sorryserver endpoint parse error:" << err.get_message() << sorry_endpoint;
 676                         l7vsadm_err.setter( true, buf.str() );
 677                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 29, buf.str(), __FILE__, __LINE__ );
 678                         return false;
 679                 }
 680         }
 681         return true;    //
 682 }
 683 //! virtualservice option flag function
 684 //! @param[in]  argument position
 685 //! @param[in]  argument count
 686 //! @param[in]  argument value
 687 bool    l7vs::l7vsadm::parse_opt_vs_flag_func( int& pos, int argc, char* argv[] ){
 688         Logger  logger( LOG_CAT_L7VSADM_COMMON, 9, "l7vsadm::parse_opt_vs_flag_func", __FILE__, __LINE__ );
 689
 690         if( ++pos >= argc ){
 691                 //don't target sorry flag
 692                 std::string     buf("sorryflag value is not specified.");
 693                 l7vsadm_err.setter( true, buf );
 694                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 30, buf, __FILE__, __LINE__ );
 695                 return false;
 696         }
 697         try{
 698                 int     tmp = boost::lexical_cast< int >( argv[pos] );
 699                 if( ( 0 != tmp ) && ( 1 != tmp ) ){
 700                         std::string     buf("invalid sorryflag value.");
 701                         l7vsadm_err.setter( true, buf );
 702                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 31, buf, __FILE__, __LINE__ );
 703                         return false;
 704                 }
 705                 if( 0 == tmp )
 706                         request.vs_element.sorry_flag = INT_MAX;        // clear value
 707                 else
 708                         request.vs_element.sorry_flag = 1;
 709         }
 710         catch( boost::bad_lexical_cast& e ){
 711                 // don't convert argv[pos] is
 712                 std::string     buf("invalid sorryflag value.");
 713                 l7vsadm_err.setter( true, buf );
 714                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 32, buf, __FILE__, __LINE__ );
 715                 return false;
 716         }
 717         return true;    //
 718 }
 719 //! virtualservice option qosupstream function
 720 //! @param[in]  argument position
 721 //! @param[in]  argument count
 722 //! @param[in]  argument value
 723 bool    l7vs::l7vsadm::parse_opt_vs_qosup_func( int& pos, int argc, char* argv[] ){
 724         Logger  logger( LOG_CAT_L7VSADM_COMMON, 10, "l7vsadm::parse_opt_vs_qosup_func", __FILE__, __LINE__ );
 725
 726         if( ++pos >= argc ){
 727                 //don't rarget QoS upstream value.
 728                 std::string     buf("qos_upstream value is not specified.");
 729                 l7vsadm_err.setter( true, buf );
 730                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 33, buf, __FILE__, __LINE__ );
 731                 return false;
 732         }
 733         try{
 734                 virtualservice_element& elem = request.vs_element;      // request virtualservice element refalence get.
 735                 std::string     tmp     = argv[pos];
 736                 std::string::reverse_iterator ritr = tmp.rbegin();
 737                 if( *ritr == 'G' || *ritr == 'g' ){
 738                         std::string     strval = tmp.substr(0, tmp.length() - 1);
 739                         unsigned long long      ullval  = boost::lexical_cast< unsigned long long > ( strval );
 740                         if( ( ULLONG_MAX / 1024 / 1024 / 1024 ) < ullval ){
 741                                 std::string     buf("qos_upstream value is too big.");
 742                                 l7vsadm_err.setter( true, buf );
 743                                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 34, buf, __FILE__, __LINE__ );
 744                                 return false;
 745                         }
 746                         elem.qos_upstream = ullval * 1024 * 1024 * 1024;                // set qos_upstream
 747                 }
 748                 else if( *ritr == 'M' || *ritr == 'm' ){
 749                         std::string     strval = tmp.substr(0, tmp.length() - 1);
 750                         unsigned long long      ullval  = boost::lexical_cast< unsigned long long > ( strval );
 751                         if( ( ULLONG_MAX / 1024 / 1024 ) < ullval ){
 752                                 std::string     buf("qos_upstream value is too big.");
 753                                 l7vsadm_err.setter( true, buf );
 754                                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 35, buf, __FILE__, __LINE__ );
 755                                 return false;
 756                         }
 757                         elem.qos_upstream = ullval * 1024 * 1024;               // set qos_upstream
 758                 }
 759                 else if( *ritr == 'K' || *ritr == 'k' ){
 760                         std::string     strval = tmp.substr(0, tmp.length() - 1);
 761                         unsigned long long      ullval  = boost::lexical_cast< unsigned long long > ( strval );
 762                         if( ( ULLONG_MAX / 1024 ) < ullval ){
 763                                 std::string     buf("qos_upstream value is too big.");
 764                                 l7vsadm_err.setter( true, buf );
 765                                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 36, buf, __FILE__, __LINE__ );
 766                                 return false;
 767                         }
 768                         elem.qos_upstream = ullval * 1024;              // set qos_upstream
 769                 }
 770                 else{
 771                         elem.qos_upstream = boost::lexical_cast< unsigned long long > ( argv[pos] );    // set qos_upstream
 772                 }
 773                 if( 0ULL == elem.qos_upstream )
 774                         elem.qos_upstream = ULLONG_MAX;         // clear value
 775                 else
 776                         elem.qos_upstream /= 8;         //qos convert to bytes per sec to bit per sec
 777         }
 778         catch( boost::bad_lexical_cast& ex ){   // don't convert string to qos_upsatream
 779                 // don't conv qos upstream
 780                 std::string     buf("invalid qos_upstream value.");
 781                 l7vsadm_err.setter( true, buf );
 782                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 37, buf, __FILE__, __LINE__ );
 783                 return false;
 784         }
 785         return true;
 786 }
 787 //! virtualservice option qosdownstream functipn
 788 //! @param[in]  argument position
 789 //! @param[in]  argument count
 790 //! @param[in]  argument value
 791 bool    l7vs::l7vsadm::parse_opt_vs_qosdown_func( int& pos, int argc, char* argv[] ){
 792         Logger  logger( LOG_CAT_L7VSADM_COMMON, 11, "l7vsadm::parse_opt_vs_qosdown_func", __FILE__, __LINE__ );
 793
 794         if( ++pos >= argc ){
 795                 // don't target QoS downstream value
 796                 std::string     buf("qos_downstream value is not specified.");
 797                 l7vsadm_err.setter( true, buf );
 798                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 38, buf, __FILE__, __LINE__ );
 799                 return false;
 800         }
 801         try{
 802                 virtualservice_element& elem = request.vs_element;      // request virtualservice element refalence get.
 803                 std::string     tmp     = argv[pos];
 804                 std::string::reverse_iterator ritr = tmp.rbegin();
 805                 if( *ritr == 'G' || *ritr == 'g' ){
 806                         std::string     strval = tmp.substr(0, tmp.length() - 1);
 807                         unsigned long long      ullval  = boost::lexical_cast< unsigned long long > ( strval );
 808                         if( ( ULLONG_MAX / 1024 / 1024 / 1024 ) < ullval ){
 809                                 std::string     buf("qos_downstream value is too big.");
 810                                 l7vsadm_err.setter( true, buf );
 811                                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 39, buf, __FILE__, __LINE__ );
 812                                 return false;
 813                         }
 814                         elem.qos_downstream = ullval * 1024 * 1024 * 1024;              // set qos_upstream
 815                 }
 816                 else if( *ritr == 'M' || *ritr == 'm' ){
 817                         std::string     strval = tmp.substr(0, tmp.length() - 1);
 818                         unsigned long long      ullval  = boost::lexical_cast< unsigned long long > ( strval );
 819                         if( ( ULLONG_MAX / 1024 / 1024 ) < ullval ){
 820                                 std::string     buf("qos_downstream value is too big.");
 821                                 l7vsadm_err.setter( true, buf );
 822                                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 40, buf, __FILE__, __LINE__ );
 823                                 return false;
 824                         }
 825                         elem.qos_downstream = ullval * 1024 * 1024;             // set qos_upstream
 826                 }
 827                 else if( *ritr == 'K' || *ritr == 'k' ){
 828                         std::string     strval = tmp.substr(0, tmp.length() - 1);
 829                         unsigned long long      ullval  = boost::lexical_cast< unsigned long long > ( strval );
 830                         if( ( ULLONG_MAX / 1024 ) < ullval ){
 831                                 std::string     buf("qos_downstream value is too big.");
 832                                 l7vsadm_err.setter( true, buf );
 833                                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 41, buf, __FILE__, __LINE__ );
 834                                 return false;
 835                         }
 836                         elem.qos_downstream = ullval * 1024;            // set qos_upstream
 837                 }
 838                 else{
 839                         elem.qos_downstream = boost::lexical_cast< unsigned long long > ( argv[pos] );  // set qos_downstream
 840                 }
 841                 if( 0ULL == elem.qos_downstream )
 842                         elem.qos_downstream = ULLONG_MAX;               // clear value
 843                 else
 844                         elem.qos_downstream /= 8;               //qos convert to bytes per sec to bit per sec
 845         }
 846         catch( boost::bad_lexical_cast& ex ){
 847                 // don' conv qos downstream
 848                 std::string     buf("invalid qos_downstream value.");
 849                 l7vsadm_err.setter( true, buf );
 850                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 42, buf, __FILE__, __LINE__ );
 851                 return false;
 852         }
 853         return true;
 854 }
 855 //! virtualservice option udp func.
 856 //! @param[in]  argument position
 857 //! @param[in]  argument count
 858 //! @param[in]  argument value
 859 bool    l7vs::l7vsadm::parse_opt_vs_udp_func( int& pos, int argc, char* argv[] ){
 860         Logger  logger( LOG_CAT_L7VSADM_COMMON, 12, "l7vsadm::parse_opt_vs_udp_func", __FILE__, __LINE__ );
 861
 862         virtualservice_element& elem = request.vs_element;      // request virtualservie element reference get.
 863         elem.udpmode = true;    // udpmode on.
 864         boost::asio::ip::tcp::endpoint  zeropoint;
 865         if( zeropoint != elem.tcp_accept_endpoint ){ // adddress tcp_acceptor endpoint
 866                 std::stringstream       sstream;
 867                 sstream << elem.tcp_accept_endpoint;
 868                 std::string     endpoint        = sstream.str();
 869                 error_code err;
 870                 elem.udp_recv_endpoint = string_to_endpoint<boost::asio::ip::udp>( endpoint, err );
 871                 if( err ){
 872                         std::stringstream buf;
 873                         buf << "target endpoint parse error:" << err.get_message() << endpoint;
 874                         l7vsadm_err.setter( true, buf.str() );
 875                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 43, buf.str(), __FILE__, __LINE__ );
 876                         return false;
 877                 }
 878                 elem.tcp_accept_endpoint = zeropoint;
 879         }
 880         if( elem.realserver_vector.size() != 0 && elem.realserver_vector.front().tcp_endpoint != zeropoint ){
 881                 std::stringstream       sstream;
 882                 sstream << elem.realserver_vector.front().tcp_endpoint;
 883                 std::string     endpoint = sstream.str();
 884                 error_code err;
 885                 elem.realserver_vector.front().udp_endpoint = string_to_endpoint< boost::asio::ip::udp > ( endpoint, err );
 886                 if( err ){
 887                         std::stringstream buf;
 888                         buf << "realserver endpoint parse error:" << err.get_message() << endpoint;
 889                         l7vsadm_err.setter( true, buf.str() );
 890                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 44, buf.str(), __FILE__, __LINE__ );
 891                         return false;
 892                 }
 893                 elem.realserver_vector.front().tcp_endpoint = zeropoint;
 894         }
 895         return true;
 896 }
 897 //! virtualservice option ssl function
 898 //! @param[in]  argument position
 899 //! @param[in]  argument count
 900 //! @param[in]  argument value
 901 bool    l7vs::l7vsadm::parse_opt_vs_ssl_func( int& pos, int argc, char* argv[] ){
 902         Logger  logger( LOG_CAT_L7VSADM_COMMON, 999, "l7vsadm::parse_opt_vs_ssl_func", __FILE__, __LINE__ );
 903
 904         if( ++pos >= argc ){
 905                 std::string     buf("ssl config filename is not specified.");
 906                 l7vsadm_err.setter( true, buf );
 907                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 999, buf, __FILE__, __LINE__ );
 908                 return false;
 909         }
 910         // ssl config file check.
 911         std::string conf_filename = argv[pos];
 912         if( L7VS_FILENAME_LEN < conf_filename.length() ){
 913                 std::string buf("ssl config filename is too long.");
 914                 l7vsadm_err.setter( true, buf );
 915                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 999, buf, __FILE__, __LINE__ );
 916                 return false;
 917         }
 918         FILE  *fp;
 919         if ((fp = fopen(conf_filename.c_str(), "r")) == NULL) {
 920                 std::string buf("ssl config file cannot open.");
 921                 l7vsadm_err.setter( true, buf );
 922                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 999, buf, __FILE__, __LINE__ );
 923                 return false;
 924         }
 925         fclose(fp);
 926         request.vs_element.ssl_conf_filename = conf_filename;
 927         request.vs_element.ssl_flag = 1;
 928         return true;
 929 }
 930 //! realserver command parsing.
 931 //! @param[in]  request command
 932 //! @param[in]  argument count
 933 //! @param[in]  argument value
 934 bool    l7vs::l7vsadm::parse_rs_func( l7vs::l7vsadm_request::COMMAND_CODE_TAG cmd, int argc, char* argv[] ){
 935         Logger  logger( LOG_CAT_L7VSADM_COMMON, 13, "l7vsadm::parse_rs_func", __FILE__, __LINE__ );
 936
 937         request.command = cmd;
 938         request.vs_element.realserver_vector.push_back( realserver_element() );
 939         for( int pos = 2; pos < argc; ++pos ){
 940                 parse_opt_map_type::iterator itr = rs_option_dic.find( argv[pos] );
 941                 if( itr != rs_option_dic.end() ){
 942                         if( ! itr->second( pos, argc, argv ) ) return false;
 943                 }
 944                 else{
 945                         std::stringstream buf;
 946                         buf << "realserver option not found:" << argv[pos];
 947                         l7vsadm_err.setter( true, buf.str() );
 948                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 45, buf.str(), __FILE__, __LINE__ );
 949                         return false;
 950                 }
 951         }
 952
 953         if( request.vs_element.protocol_module_name.length() == 0 ){
 954                 //protocol module name error
 955                 std::string     buf("protocol module not specified.");
 956                 l7vsadm_err.setter( true, buf );
 957                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 46, buf, __FILE__, __LINE__ );
 958                 return false;
 959         }
 960         if( request.vs_element.udpmode ){
 961                 if( request.vs_element.udp_recv_endpoint == boost::asio::ip::udp::endpoint() ){
 962                         // udp mode,but not acceptor endpoint
 963                         std::string     buf("udp recv endpoint not specified.");
 964                         l7vsadm_err.setter( true, buf );
 965                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 47, buf, __FILE__, __LINE__ );
 966                         return false;
 967                 }
 968                 if( request.vs_element.realserver_vector.front().udp_endpoint == boost::asio::ip::udp::endpoint() ){
 969                         // udp mode,but not realserver endpoint
 970                         std::string     buf("realserver udp endpoint not specified.");
 971                         l7vsadm_err.setter( true, buf );
 972                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 48, buf, __FILE__, __LINE__ );
 973                         return false;
 974                 }
 975         }
 976         else{
 977                 if( request.vs_element.tcp_accept_endpoint == boost::asio::ip::tcp::endpoint() ){
 978                         // tcp mode, but not acceptor endpoint
 979                         std::string     buf("tcp accpeptor endpoint not specified.");
 980                         l7vsadm_err.setter( true, buf );
 981                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 49, buf, __FILE__, __LINE__ );
 982                         return false;
 983                 }
 984                 if( request.vs_element.realserver_vector.front().tcp_endpoint == boost::asio::ip::tcp::endpoint() ){
 985                         // tcp mode,but not realserver endpoint
 986                         std::string     buf("realserver tcp endpoint not specified.");
 987                         l7vsadm_err.setter( true, buf );
 988                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 50, buf, __FILE__, __LINE__ );
 989                         return false;
 990                 }
 991         }
 992         // realserver weight default value = 1
 993         if( -1 == request.vs_element.realserver_vector.front().weight ){
 994                 request.vs_element.realserver_vector.front().weight = 1;
 995         }
 996
 997         return true;
 998 }
 999 //
1000 // realserver option functions.
1001 //
1002 //! realserver weight set
1003 //! @param[in]  argument position
1004 //! @param[in]  argument count
1005 //! @param[in]  argument value
1006 bool    l7vs::l7vsadm::parse_opt_rs_weight_func( int& pos, int argc, char* argv[] ){
1007         Logger  logger( LOG_CAT_L7VSADM_COMMON, 14, "l7vsadm::parse_opt_rs_weight_func", __FILE__, __LINE__ );
1008
1009         if( ++pos >= argc ){
1010                 //don't target weight value
1011                 std::string     buf("weight value is not specified.");
1012                 l7vsadm_err.setter( true, buf );
1013                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 51, buf, __FILE__, __LINE__ );
1014                 return false;
1015         }
1016         try{
1017                 request.vs_element.realserver_vector.front().weight = boost::lexical_cast<int>( argv[pos] );
1018                 if( ( 0 > request.vs_element.realserver_vector.front().weight ) ||
1019                         ( 100 < request.vs_element.realserver_vector.front().weight ) ){
1020                         std::string     buf("invalid weight value.");
1021                         l7vsadm_err.setter( true, buf );
1022                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 52, buf, __FILE__, __LINE__ );
1023                         return false;
1024                 }
1025         }
1026         catch( boost::bad_lexical_cast& ex ){
1027                 // lexical cast error
1028                 std::string     buf("invalid weight value.");
1029                 l7vsadm_err.setter( true, buf );
1030                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 53, buf, __FILE__, __LINE__ );
1031                 return false;
1032         }
1033         return true;
1034 }
1035 //! realserver target set
1036 //! @param[in]  argument position
1037 //! @param[in]  argument count
1038 //! @param[in]  argument value
1039 bool    l7vs::l7vsadm::parse_opt_rs_realserver_func( int& pos, int argc, char* argv[] ){
1040         Logger  logger( LOG_CAT_L7VSADM_COMMON, 15, "l7vsadm::parse_opt_rs_realserver_func", __FILE__, __LINE__ );
1041
1042         if( ++pos >= argc ){
1043                 // don't target realserver address
1044                 std::string     buf("realserver address is not specified.");
1045                 l7vsadm_err.setter( true, buf );
1046                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 54, buf, __FILE__, __LINE__ );
1047                 return false;
1048         }
1049         std::string     src_str = argv[pos];
1050         if( request.vs_element.udpmode ){
1051                 error_code err;
1052                 request.vs_element.realserver_vector.front().udp_endpoint = string_to_endpoint< boost::asio::ip::udp >( src_str, err );
1053                 if ( err ){
1054                         // address string error.
1055                         std::stringstream buf;
1056                         buf << "realserver endpoint parse error:" << err.get_message() << src_str;
1057                         l7vsadm_err.setter( true, buf.str() );
1058                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 55, buf.str(), __FILE__, __LINE__ );
1059                         return false;
1060                 }
1061                 check_endpoint<boost::asio::ip::udp>( request.vs_element.realserver_vector.front().udp_endpoint, err );
1062                 if ( err ){
1063                         std::stringstream buf;
1064                         buf << "realserver endpoint parse error:" << err.get_message() << src_str;
1065                         l7vsadm_err.setter( true, buf.str() );
1066                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 56, buf.str(), __FILE__, __LINE__ );
1067                         return false;
1068                 }
1069         }
1070         else{
1071                 error_code err;
1072                 request.vs_element.realserver_vector.front().tcp_endpoint = string_to_endpoint< boost::asio::ip::tcp >( src_str, err );
1073                 if ( err ){
1074                         // address string error.
1075                         std::stringstream buf;
1076                         buf << "realserver endpoint parse error:" << err.get_message() << src_str;
1077                         l7vsadm_err.setter( true, buf.str() );
1078                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 57, buf.str(), __FILE__, __LINE__ );
1079                         return false;
1080                 }
1081                 check_endpoint<boost::asio::ip::tcp>( request.vs_element.realserver_vector.front().tcp_endpoint, err );
1082                 if ( err ){
1083                         std::stringstream buf;
1084                         buf << "realserver endpoint parse error:" << err.get_message() << src_str;
1085                         l7vsadm_err.setter( true, buf.str() );
1086                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 58, buf.str(), __FILE__, __LINE__ );
1087                         return false;
1088                 }
1089         }
1090         return true;
1091 }
1092
1093 //! replication command parsing.
1094 //! @param[in]  request command
1095 //! @param[in]  argument count
1096 //! @param[in]  argument value
1097 bool    l7vs::l7vsadm::parse_replication_func( l7vs::l7vsadm_request::COMMAND_CODE_TAG cmd, int argc, char* argv[] ){
1098         Logger  logger( LOG_CAT_L7VSADM_COMMON, 16, "l7vsadm::parse_replication_func", __FILE__, __LINE__ );
1099
1100         request.command = cmd;
1101         for( int pos = 2; pos < argc; ++pos ){
1102                 parse_opt_map_type::iterator itr = replication_option_dic.find( argv[pos] );
1103                 if( itr != replication_option_dic.end() ){
1104                         if( ! itr->second( pos, argc, argv ) ) return false;
1105                 }
1106                 else{
1107                         std::stringstream buf;
1108                         buf << "replication option not found:" << argv[pos];
1109                         l7vsadm_err.setter( true, buf.str() );
1110                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 59, buf.str(), __FILE__, __LINE__ );
1111                         return false;
1112                 }
1113         }
1114         if( l7vsadm_request::REP_NONE == request.replication_command ){
1115                 // not specified replication command
1116                 std::string     buf("replication command not specified.");
1117                 l7vsadm_err.setter( true, buf );
1118                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 60, buf, __FILE__, __LINE__ );
1119                 return false;
1120         }
1121         return true;
1122 }
1123
1124 //
1125 //      replication option functions.
1126 //
1127 //! replication switch function
1128 //! @param[in]  argument position
1129 //! @param[in]  argument count
1130 //! @param[in]  argument value
1131 bool    l7vs::l7vsadm::parse_opt_replication_switch_func( int& pos, int argc, char* argv[] ){
1132         Logger  logger( LOG_CAT_L7VSADM_COMMON, 17, "l7vsadm::parse_opt_replication_switch_func", __FILE__, __LINE__ );
1133
1134         if( request.replication_command != l7vsadm_request::REP_NONE ){
1135                 // double command target.
1136                 std::string     buf("replication option is double specified.");
1137                 l7vsadm_err.setter( true, buf );
1138                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 61, buf, __FILE__, __LINE__ );
1139                 return false;
1140         }
1141         if( ++pos >= argc ){
1142                 // don't target replication switch value
1143                 std::string     buf("replication switch option is not specified.");
1144                 l7vsadm_err.setter( true, buf );
1145                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 62, buf, __FILE__, __LINE__ );
1146                 return false;
1147         }
1148         parse_opt_map_type::iterator itr = replication_switch_option_dic.find( argv[pos] );
1149         if( itr != replication_switch_option_dic.end() ){       // option string function find.
1150                 if( ! itr->second( pos, argc, argv ) ) return false;    // option string function error.
1151         }
1152         else{   //option string function don't find.
1153                 // print option not found message.
1154                 std::stringstream buf;
1155                 buf << "replication switch option not found:" << argv[pos];
1156                 l7vsadm_err.setter( true, buf.str() );
1157                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 63, buf.str(), __FILE__, __LINE__ );
1158                 return false;
1159         }
1160         return true;
1161 }
1162 //! replication start function
1163 //! @param[in]  argument position
1164 //! @param[in]  argument count
1165 //! @param[in]  argument value
1166 bool    l7vs::l7vsadm::parse_opt_replication_start_func( int& pos, int argc, char* argv[] ){
1167         Logger  logger( LOG_CAT_L7VSADM_COMMON, 18, "l7vsadm::parse_opt_replication_start_func", __FILE__, __LINE__ );
1168
1169         request.replication_command = l7vsadm_request::REP_START;
1170         return true;
1171 }
1172 //! replication stop function
1173 //! @param[in]  argument position
1174 //! @param[in]  argument count
1175 //! @param[in]  argument value
1176 bool    l7vs::l7vsadm::parse_opt_replication_stop_func( int& pos, int argc, char* argv[] ){
1177         Logger  logger( LOG_CAT_L7VSADM_COMMON, 19, "l7vsadm::parse_opt_replication_stop_func", __FILE__, __LINE__ );
1178
1179         request.replication_command = l7vsadm_request::REP_STOP;
1180         return true;
1181 }
1182 //! replication force function
1183 //! @param[in]  argument position
1184 //! @param[in]  argument count
1185 //! @param[in]  argument value
1186 bool    l7vs::l7vsadm::parse_opt_replication_force_func( int& pos, int argc, char* argv[] ){
1187         Logger  logger( LOG_CAT_L7VSADM_COMMON, 20, "l7vsadm::parse_opt_replication_force_func", __FILE__, __LINE__ );
1188
1189         if( request.replication_command != l7vsadm_request::REP_NONE ){
1190                 // double command target.
1191                 std::string     buf("replication option is double specified.");
1192                 l7vsadm_err.setter( true, buf );
1193                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 64, buf, __FILE__, __LINE__ );
1194                 return false;
1195         }
1196         request.replication_command = l7vsadm_request::REP_FORCE;
1197         return true;
1198 }
1199 //! replication dump function
1200 //! @param[in]  argument position
1201 //! @param[in]  argument count
1202 //! @param[in]  argument value
1203 bool    l7vs::l7vsadm::parse_opt_replication_dump_func( int& pos, int argc, char* argv[] ){
1204         Logger  logger( LOG_CAT_L7VSADM_COMMON, 21, "l7vsadm::parse_opt_replication_dump_func", __FILE__, __LINE__ );
1205
1206         if( request.replication_command != l7vsadm_request::REP_NONE ){
1207                 // double command target.
1208                 std::string     buf("replication option is double specified.");
1209                 l7vsadm_err.setter( true, buf );
1210                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 65, buf, __FILE__, __LINE__ );
1211                 return false;
1212         }
1213         request.replication_command = l7vsadm_request::REP_DUMP;
1214         return true;
1215 }
1216
1217 //! log command parsing.
1218 //! @param[in]  request command
1219 //! @param[in]  argument count
1220 //! @param[in]  argument value
1221 bool    l7vs::l7vsadm::parse_log_func( l7vs::l7vsadm_request::COMMAND_CODE_TAG cmd, int argc, char* argv[] ){
1222         Logger  logger( LOG_CAT_L7VSADM_COMMON, 22, "l7vsadm::parse_log_func", __FILE__, __LINE__ );
1223
1224         request.command = cmd;
1225         for( int pos = 2; pos < argc; ++pos ){
1226                 parse_opt_map_type::iterator itr = log_option_dic.find( argv[pos] );
1227                 if( itr != log_option_dic.end() ){      // option string function find.
1228                         if( ! itr->second( pos, argc, argv ) ) return false;    // option string function error.
1229                 }
1230                 else{   //option string function don't find.
1231                         // print option not found message.
1232                         std::stringstream buf;
1233                         buf << "log option not found:" << argv[pos];
1234                         l7vsadm_err.setter( true, buf.str() );
1235                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 66, buf.str(), __FILE__, __LINE__ );
1236                         return false;
1237                 }
1238         }
1239         if( LOG_CAT_NONE == request.log_category ){
1240                 // not specified logcategory
1241                 std::string     buf("logcategory not specified.");
1242                 l7vsadm_err.setter( true, buf );
1243                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 67, buf, __FILE__, __LINE__ );
1244                 return false;
1245         }
1246         if( LOG_LV_NONE == request.log_level ){
1247                 // not specified loglevel
1248                 std::string     buf("loglevel not specified.");
1249                 l7vsadm_err.setter( true, buf );
1250                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 68, buf, __FILE__, __LINE__ );
1251                 return false;
1252         }
1253         return true;
1254 }
1255 //
1256 //      log option function
1257 //
1258 //! log category set function
1259 //! @param[in]  argument position
1260 //! @param[in]  argument count
1261 //! @param[in]  argument value
1262 bool    l7vs::l7vsadm::parse_opt_log_category_func( int& pos, int argc, char* argv[] ){
1263         Logger  logger( LOG_CAT_L7VSADM_COMMON, 23, "l7vsadm::parse_opt_log_category_func", __FILE__, __LINE__ );
1264
1265         if( request.log_category != LOG_CAT_NONE ){
1266                 // double target commands.
1267                 std::string     buf("logcategory is double specified.");
1268                 l7vsadm_err.setter( true, buf );
1269                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 69, buf, __FILE__, __LINE__ );
1270                 return false;
1271         }
1272         if( ++pos >= argc ){
1273                 // don't target logcategory
1274                 std::string     buf("logcategory is not specified.");
1275                 l7vsadm_err.setter( true, buf );
1276                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 70, buf, __FILE__, __LINE__ );
1277                 return false;
1278         }
1279         string_logcategory_map_type::iterator itr = string_logcategory_dic.find( argv[pos] );
1280         if( itr != string_logcategory_dic.end() ){
1281                 request.log_category = itr->second;
1282                 return true;
1283         }
1284         std::stringstream buf;
1285         buf << "logcategory not found:" << argv[pos];
1286         l7vsadm_err.setter( true, buf.str() );
1287         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 71, buf.str(), __FILE__, __LINE__ );
1288         return false;
1289 }
1290 //! log level set function
1291 //! @param[in]  argument position
1292 //! @param[in]  argument count
1293 //! @param[in]  argument value
1294 bool    l7vs::l7vsadm::parse_opt_log_level_func( int& pos, int argc, char* argv[] ){
1295         Logger  logger( LOG_CAT_L7VSADM_COMMON, 24, "l7vsadm::parse_opt_log_level_func", __FILE__, __LINE__ );
1296
1297         if( request.log_level != LOG_LV_NONE ){
1298                 // double target commands.
1299                 std::string     buf("loglevel is double specified.");
1300                 l7vsadm_err.setter( true, buf );
1301                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 72, buf, __FILE__, __LINE__ );
1302                 return false;
1303         }
1304         if( ++pos >= argc ){
1305                 // don't target loglevel
1306                 std::string     buf("loglevel is not specified.");
1307                 l7vsadm_err.setter( true, buf );
1308                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 73, buf, __FILE__, __LINE__ );
1309                 return false;
1310         }
1311         string_loglevel_map_type::iterator itr = string_loglevel_dic.find( argv[pos] );
1312         if( itr != string_loglevel_dic.end() ){
1313                 request.log_level = itr->second;
1314                 return true;
1315         }
1316         std::stringstream buf;
1317         buf << "loglevel not found:" << argv[pos];
1318         l7vsadm_err.setter( true, buf.str() );
1319         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 74, buf.str(), __FILE__, __LINE__ );
1320         return false;
1321 }
1322
1323 //! snmp command parsing
1324 //! @param[in]  request command
1325 //! @param[in]  argument count
1326 //! @param[in]  argument value
1327 bool    l7vs::l7vsadm::parse_snmp_func( l7vs::l7vsadm_request::COMMAND_CODE_TAG cmd, int argc, char* argv[] ){
1328         Logger  logger( LOG_CAT_L7VSADM_COMMON, 25, "l7vsadm::parse_snmp_func", __FILE__, __LINE__ );
1329
1330         request.command = cmd;
1331         for( int pos = 2; pos < argc; ++pos ){
1332                 parse_opt_map_type::iterator itr = snmp_option_dic.find( argv[pos] );
1333                 if( itr != snmp_option_dic.end() ){     // option string function find.
1334                         if( ! itr->second( pos, argc, argv ) ) return false;    // option string function error.
1335                 }
1336                 else{   //option string function don't find.
1337                         // print option not found message.
1338                         std::stringstream buf;
1339                         buf << "snmp log option not found:" << argv[pos];
1340                         l7vsadm_err.setter( true, buf.str() );
1341                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 75, buf.str(), __FILE__, __LINE__ );
1342                         return false;
1343                 }
1344         }
1345         if( LOG_CAT_NONE == request.snmp_log_category ){
1346                 // not specified logcategory
1347                 std::string     buf("snmp logcategory not specified.");
1348                 l7vsadm_err.setter( true, buf );
1349                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 76, buf, __FILE__, __LINE__ );
1350                 return false;
1351         }
1352         if( LOG_LV_NONE == request.snmp_log_level ){
1353                 // not specified loglevel
1354                 std::string     buf("snmp loglevel not specified.");
1355                 l7vsadm_err.setter( true, buf );
1356                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 77, buf, __FILE__, __LINE__ );
1357                 return false;
1358         }
1359         return true;
1360 }
1361 //! snmp log category set function
1362 //! @param[in]  argument position
1363 //! @param[in]  argument count
1364 //! @param[in]  argument value
1365 bool    l7vs::l7vsadm::parse_opt_snmp_log_category_func( int& pos, int argc, char* argv[] ){
1366         Logger  logger( LOG_CAT_L7VSADM_COMMON, 26, "l7vsadm::parse_opt_snmp_log_category_func", __FILE__, __LINE__ );
1367
1368         if( request.snmp_log_category != LOG_CAT_NONE ){
1369                 // double target commands.
1370                 std::string     buf("snmp logcategory is double specified.");
1371                 l7vsadm_err.setter( true, buf );
1372                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 78, buf, __FILE__, __LINE__ );
1373                 return false;
1374         }
1375         if( ++pos >= argc ){
1376                 // don't target logcategory
1377                 std::string     buf("snmp logcategory is not specified.");
1378                 l7vsadm_err.setter( true, buf );
1379                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 79, buf, __FILE__, __LINE__ );
1380                 return false;
1381         }
1382         string_logcategory_map_type::iterator itr = string_snmp_logcategory_dic.find( argv[pos] );
1383         if( itr != string_snmp_logcategory_dic.end() ){
1384                 request.snmp_log_category = itr->second;
1385                 return true;
1386         }
1387         std::stringstream buf;
1388         buf << "snmp logcategory not found:" << argv[pos];
1389         l7vsadm_err.setter( true, buf.str() );
1390         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 80, buf.str(), __FILE__, __LINE__ );
1391         return false;
1392 }
1393 //! snmp log level set function
1394 //! @param[in]  argument position
1395 //! @param[in]  argument count
1396 //! @param[in]  argument value
1397 bool    l7vs::l7vsadm::parse_opt_snmp_log_level_func( int& pos, int argc, char* argv[] ){
1398         Logger  logger( LOG_CAT_L7VSADM_COMMON, 27, "l7vsadm::parse_opt_snmp_log_level_func", __FILE__, __LINE__ );
1399
1400         if( request.snmp_log_level != LOG_LV_NONE ){
1401                 // double target commands.
1402                 std::string     buf("snmp loglevel is double specified.");
1403                 l7vsadm_err.setter( true, buf );
1404                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 81, buf, __FILE__, __LINE__ );
1405                 return false;
1406         }
1407         if( ++pos >= argc ){
1408                 // don't rarget logcategory
1409                 std::string     buf("snmp loglevel is not specified.");
1410                 l7vsadm_err.setter( true, buf );
1411                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 82, buf, __FILE__, __LINE__ );
1412                 return false;
1413         }
1414         string_loglevel_map_type::iterator itr = string_loglevel_dic.find( argv[pos] );
1415         if( itr != string_loglevel_dic.end() ){
1416                 request.snmp_log_level = itr->second;
1417                 return true;
1418         }
1419         std::stringstream buf;
1420         buf << "snmp loglevel not found:" << argv[pos];
1421         l7vsadm_err.setter( true, buf.str() );
1422         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 83, buf.str(), __FILE__, __LINE__ );
1423         return false;
1424 }
1425
1426 //! parameter command parsing
1427 //! @param[in]  request command
1428 //! @param[in]  argument count
1429 //! @param[in]  argument value
1430 bool    l7vs::l7vsadm::parse_parameter_func( l7vs::l7vsadm_request::COMMAND_CODE_TAG cmd, int argc, char* argv[] ){
1431         Logger  logger( LOG_CAT_L7VSADM_COMMON, 28, "l7vsadm::parse_parameter_func", __FILE__, __LINE__ );
1432
1433         request.command = cmd;
1434         for( int pos = 2; pos < argc; ++pos ){
1435                 parse_opt_map_type::iterator itr = parameter_option_dic.find( argv[pos] );
1436                 if( itr != parameter_option_dic.end() ){        // option string function find.
1437                         if( ! itr->second( pos, argc, argv ) ) return false;    // option string function error.
1438                 }
1439                 else{   //option string function don't find.
1440                         // print option not found message.
1441                         std::stringstream buf;
1442                         buf << "parameter option not found:" << argv[pos];
1443                         l7vsadm_err.setter( true, buf.str() );
1444                         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 84, buf.str(), __FILE__, __LINE__ );
1445                         return false;
1446                 }
1447         }
1448         if( PARAM_COMP_NOCAT == request.reload_param ){
1449                 // not specified reload_param
1450                 std::string     buf("reload component not specified.");
1451                 l7vsadm_err.setter( true, buf );
1452                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 85, buf, __FILE__, __LINE__ );
1453                 return false;
1454         }
1455         return true;
1456 }
1457 //
1458 //      parameter command
1459 //
1460 //! parameter reload component parsing
1461 //! @param[in]  argument position
1462 //! @param[in]  argument count
1463 //! @param[in]  argument value
1464 bool    l7vs::l7vsadm::parse_opt_parameter_reload_func( int& pos, int argc, char* argv[] ){
1465         Logger  logger( LOG_CAT_L7VSADM_COMMON, 29, "l7vsadm::parse_opt_parameter_reload_func", __FILE__, __LINE__ );
1466
1467         if( ++pos >= argc ){
1468                 // don't target reload component
1469                 std::string     buf("reload component is not specified.");
1470                 l7vsadm_err.setter( true, buf );
1471                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 86, buf, __FILE__, __LINE__ );
1472                 return false;
1473         }
1474         string_parameter_map_type::iterator itr = string_parameter_dic.find( argv[pos] );
1475         if( itr != string_parameter_dic.end() ){
1476                 request.reload_param = itr->second;
1477                 return true;
1478         }
1479         std::stringstream buf;
1480         buf << "reload component not found:" << argv[pos];
1481         l7vsadm_err.setter( true, buf.str() );
1482         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 87, buf.str(), __FILE__, __LINE__ );
1483         return false;
1484 }
1485
1486 //! help command parsing
1487 //! @param[in]  request command
1488 //! @param[in]  argument count
1489 //! @param[in]  argument value
1490 bool    l7vs::l7vsadm::parse_help_func( l7vs::l7vsadm_request::COMMAND_CODE_TAG cmd, int argc, char* argv[] ){
1491         Logger  logger( LOG_CAT_L7VSADM_COMMON, 30, "l7vsadm::parse_help_func", __FILE__, __LINE__ );
1492
1493         request.command = cmd;
1494
1495         std::cout << usage() << std::endl;
1496
1497         std::cout <<
1498         "Commands:\n"
1499         "  --add-service     -A        add virtual service with options\n"
1500         "  --edit-service    -E        edit virtual service with options\n"
1501         "  --delete-service  -D        delete virtual service with options\n"
1502         "  --flush           -C        flush virtual service\n"
1503         "  --add-server      -a        add real server with options\n"
1504         "  --edit-server     -e        edit real server with options\n"
1505         "  --delete-server   -d        delete real server with options\n"
1506         "  --replication     -R        control replication-function\n"
1507         "  --log             -L        control logger-function\n"
1508         "  --snmp            -S        control SNMP Agent-function\n"
1509         "  --parameter       -P        control parameter-function\n"
1510         "  --list            -l        list the table\n"
1511         "  --verbose         -V        list the table in verbose format\n"
1512         "  --key             -K        list the table in key setting format\n"
1513         "  --help            -h        show usage\n"
1514         << std::endl;
1515
1516         std::cout <<
1517         "Options:\n"
1518         "  --tcp-service   -t service-address     service-address is host:port\n"
1519         "  --proto-module  -m proto-module        protocol module name and module argment\n"
1520         "                     [module-args]\n"
1521         "  --scheduler     -s scheduler           one of rr,lc,wrr\n"
1522         "  --upper         -u connection-count    maximum number of connections\n"
1523         "  --bypass        -b sorry-server        sorry server address is host:port\n"
1524         "  --flag          -f sorry-flag          sorry status set to virtual service\n"
1525         "  --qos-up        -Q QoSval-up           QoS Threshold(bps) set to real server direction\n"
1526         "  --qos-down      -q QoSval-down         QoS Threshold(bps) set to client direction\n"
1527         "  --udp           -p                     VirtualService UDP mode on\n"
1528         "  --ssl           -S ssl-config-file     SSL configuration file(Use SSL)\n"
1529         "  --real-server   -r server-address      server-address is host:port\n"
1530         "  --weight        -w weight              scheduling weight set to real server\n"
1531         "  --switch        -s replication-switch  start or stop replication\n"
1532         "  --force         -f                     force replication start\n"
1533         "  --dump          -d                     dump replication memory\n"
1534         "  --category      -c log-category        set log category for l7vsd or SNMP Agent\n"
1535         "  --level         -l log-level           set log level for l7vsd or SNMP Agent\n"
1536         "  --reload        -r reload-parameter    reload specified config parameter\n"
1537         "  --numeric       -n                     list the table in numeric\n"
1538         << std::endl;
1539
1540         return true;
1541 }
1542
1543 //! usage function.
1544 std::string     l7vs::l7vsadm::usage(){
1545         Logger  logger( LOG_CAT_L7VSADM_COMMON, 31, "l7vsadm::usage", __FILE__, __LINE__ );
1546
1547         std::stringstream       stream;
1548         stream <<
1549         "Usage: \n"
1550         "  l7vsadm -A|E -t service-address -m proto-module [module-args]\n"
1551         "          [-s scheduler] [-u connection-count] [-b sorry-server]\n"
1552         "          [-f sorry-flag] [-Q QoSval-up] [-q QoSval-down]\n"
1553         "          [-p ] [-S ssl-config-file]\n"
1554         "  l7vsadm -D -t service-address -m proto-module [module-args]\n"
1555         "  l7vsadm -C\n"
1556         "  l7vsadm -a|e -t service-address -m proto-module [module-args] [-u]\n"
1557         "          -r server-address [-w weight]\n"
1558         "  l7vsadm -d -t service-address -m proto-module [module-args]\n"
1559         "          -r server-address\n"
1560         "  l7vsadm -R -s replication-switch\n"
1561         "  l7vsadm -R -f\n"
1562         "  l7vsadm -R -d\n"
1563         "  l7vsadm -L -c log-category -l log-level\n"
1564         "  l7vsadm -S -c log-category -l log-level\n"
1565         "  l7vsadm -P -r reload-parameter\n"
1566         "  l7vsadm -l [-n]\n"
1567         "  l7vsadm -V [-n]\n"
1568         "  l7vsadm -K [-n]\n"
1569         "  l7vsadm -h\n"
1570         << std::endl;
1571         return stream.str();
1572 }
1573
1574 //!     disp_list function
1575 void    l7vs::l7vsadm::disp_list(){
1576         Logger  logger( LOG_CAT_L7VSADM_COMMON, 32, "l7vsadm::disp_list", __FILE__, __LINE__ );
1577
1578         std::stringstream buf;
1579         buf << boost::format( "Layer-7 Virtual Server version %s\n" ) % VERSION;
1580         buf << "Prot LocalAddress:Port ProtoMod Scheduler\n";
1581         buf << "  -> RemoteAddress:Port           Forward Weight ActiveConn InactConn\n";
1582         BOOST_FOREACH( virtualservice_element vse, response.virtualservice_status_list ){
1583                 std::string     vsepstr;
1584                 if(vse.udpmode)
1585                         vsepstr = endpoint_to_string<boost::asio::ip::udp>( vse.udp_recv_endpoint, numeric_flag );
1586                 else
1587                         vsepstr = endpoint_to_string<boost::asio::ip::tcp>( vse.tcp_accept_endpoint, numeric_flag );
1588                 buf << boost::format( "%s %s %s %s\n" )
1589                         % ( vse.udpmode ? "UDP" : "TCP" )
1590                         % vsepstr
1591                         % vse.protocol_module_name
1592                         % vse.schedule_module_name;
1593                 BOOST_FOREACH( realserver_element rse, vse.realserver_vector ){
1594                         std::string     rsepstr;
1595                         if(vse.udpmode)
1596                                 rsepstr = endpoint_to_string<boost::asio::ip::udp>( rse.udp_endpoint, numeric_flag );
1597                         else
1598                                 rsepstr = endpoint_to_string<boost::asio::ip::tcp>( rse.tcp_endpoint, numeric_flag );
1599                         buf << boost::format( "  -> %-28s %-7s %-6d %-10d %-10d\n" )
1600                                 % rsepstr
1601                                 % "Masq"
1602                                 % rse.weight
1603                                 % rse.get_active()
1604                                 % rse.get_inact();
1605                 }
1606         }
1607         std::cout << buf.str();
1608 }
1609
1610 //!     disp_list_key function
1611 void    l7vs::l7vsadm::disp_list_key(){
1612         Logger  logger( LOG_CAT_L7VSADM_COMMON, 33, "l7vsadm::disp_list_key", __FILE__, __LINE__ );
1613
1614         std::stringstream buf;
1615         buf << boost::format( "Layer-7 Virtual Server version %s\n" ) % VERSION;
1616         buf << "Prot LocalAddress:Port ProtoMod Scheduler\n";
1617         buf << "  -> RemoteAddress:Port           Forward Weight ActiveConn InactConn\n";
1618         BOOST_FOREACH( virtualservice_element vse, response.virtualservice_status_list ){
1619                 std::string     vsepstr;
1620                 if(vse.udpmode)
1621                         vsepstr = endpoint_to_string<boost::asio::ip::udp>( vse.udp_recv_endpoint, numeric_flag );
1622                 else
1623                         vsepstr = endpoint_to_string<boost::asio::ip::tcp>( vse.tcp_accept_endpoint, numeric_flag );
1624                 buf << boost::format( "%s %s %s %s\n" )
1625                         % ( vse.udpmode ? "UDP" : "TCP" )
1626                         % vsepstr
1627                         % vse.protocol_module_name
1628                         % vse.schedule_module_name;
1629                 BOOST_FOREACH( realserver_element rse, vse.realserver_vector ){
1630                         std::string     rsepstr;
1631                         if(vse.udpmode)
1632                                 rsepstr = endpoint_to_string<boost::asio::ip::udp>( rse.udp_endpoint, numeric_flag );
1633                         else
1634                                 rsepstr = endpoint_to_string<boost::asio::ip::tcp>( rse.tcp_endpoint, numeric_flag );
1635                         buf << boost::format( "  -> %-28s %-7s %-6d %-10d %-10d\n" )
1636                                 % rsepstr
1637                                 % "Masq"
1638                                 % rse.weight
1639                                 % rse.get_active()
1640                                 % rse.get_inact();
1641                 }
1642         }
1643         std::cout << buf.str();
1644 }
1645
1646 //!     disp_list_verbose function
1647 void    l7vs::l7vsadm::disp_list_verbose(){
1648         Logger  logger( LOG_CAT_L7VSADM_COMMON, 34, "l7vsadm::disp_list_verbose", __FILE__, __LINE__ );
1649
1650         std::stringstream       buf;
1651         buf << boost::format( "Layer-7 Virtual Server version %s\n" ) % VERSION;
1652
1653         //disp loglevel
1654         buf << "L7vsd Log Level:\n";
1655         buf << "Category                       Level\n";
1656         typedef std::pair< LOG_CATEGORY_TAG, LOG_LEVEL_TAG > logstatus_type;
1657         BOOST_FOREACH( logstatus_type logstatus, response.log_status_list ){
1658                 buf << boost::format( "%-30s %s\n" )
1659                         % logcategory_string_dic[logstatus.first]
1660                         % loglevel_string_dic[logstatus.second];
1661         }
1662         buf << "\n";
1663
1664         //disp replication
1665         buf << "Replication Mode:\n";
1666         buf << boost::format( "%s\n" ) % replication_mode_string_dic[response.replication_mode_status];
1667         buf << "\n";
1668
1669         //disp snmp connection status
1670         buf << "SNMPAgent Connection Status:\n";
1671         if( response.snmp_connection_status )
1672                 buf << "connecting\n";
1673         else
1674                 buf << "non-connecting\n";
1675         buf << "\n";
1676
1677         //disp snmp loglevel
1678         buf << "SNMPAgent Log Level:\n";
1679         buf << "Category                       Level\n";
1680         BOOST_FOREACH( logstatus_type snmplogstatus, response.snmp_log_status_list ){
1681                 buf << boost::format( "%-30s %s\n" )
1682                         % snmp_logcategory_string_dic[snmplogstatus.first]
1683                         % loglevel_string_dic[snmplogstatus.second];
1684         }
1685         buf << "\n";
1686
1687         // disp vs
1688         buf << "Prot LocalAddress:Port ProtoMod Scheduler Protomod_opt_string\n";
1689         buf << "     SorryAddress:Port Sorry_cc Sorry_flag\n";
1690         buf << "     QoS-up   Throughput-up\n";
1691         buf << "     QoS-down Throughput-down\n";
1692         buf << "     SSL_flag SSL_config_file\n";
1693         buf << "  -> RemoteAddress:Port           Forward Weight ActiveConn InactConn\n";
1694         BOOST_FOREACH( virtualservice_element vse, response.virtualservice_status_list ){
1695                 std::string     vsepstr;
1696                 if( vse.udpmode )
1697                         vsepstr = endpoint_to_string<boost::asio::ip::udp>( vse.udp_recv_endpoint, numeric_flag );
1698                 else
1699                         vsepstr = endpoint_to_string<boost::asio::ip::tcp>( vse.tcp_accept_endpoint, numeric_flag );
1700                 std::string     args = boost::algorithm::join( vse.protocol_args, " " );
1701                 buf << boost::format( "%s %s %s %s %s\n" )
1702                         % ( vse.udpmode ? "UDP" : "TCP" )
1703                         % vsepstr
1704                         % vse.protocol_module_name
1705                         % vse.schedule_module_name
1706                         % args;
1707                 if( !vse.udpmode ){
1708                         std::string     sorryepstr;
1709                         boost::asio::ip::tcp::endpoint  zeropoint;
1710                         if( zeropoint == vse.sorry_endpoint ){
1711                                 sorryepstr = "none";
1712                         }
1713                         else{
1714                                 sorryepstr = endpoint_to_string<boost::asio::ip::tcp>( vse.sorry_endpoint, numeric_flag );
1715                         }
1716                         buf << boost::format( "    %s %d %d\n" )
1717                                 % sorryepstr
1718                                 % vse.sorry_maxconnection
1719                                 % vse.sorry_flag;
1720                 }
1721                 // QoS value and throughput convert from byte/s to bps.
1722                 buf << boost::format( "    %lld %lld\n" )
1723                         % (vse.qos_upstream * 8)
1724                         % (vse.throughput_upstream * 8);
1725                 buf << boost::format( "    %lld %lld\n" )
1726                         % (vse.qos_downstream * 8)
1727                         % (vse.throughput_downstream * 8);
1728                 buf << boost::format( "    %d %s\n" )
1729                         % vse.ssl_flag
1730                         % vse.ssl_conf_filename;
1731                 BOOST_FOREACH( realserver_element rse, vse.realserver_vector ){
1732                         std::string     rsepstr;
1733                         if( vse.udpmode )
1734                                 rsepstr = endpoint_to_string<boost::asio::ip::udp>( rse.udp_endpoint, numeric_flag );
1735                         else
1736                                 rsepstr = endpoint_to_string<boost::asio::ip::tcp>( rse.tcp_endpoint, numeric_flag );
1737                         buf << boost::format( "  -> %-28s %-7s %-6d %-10d %-10d\n" )
1738                                 % rsepstr
1739                                 % "Masq"
1740                                 % rse.weight
1741                                 % rse.get_active()
1742                                 % rse.get_inact();
1743                 }
1744         }
1745         std::cout << buf.str();
1746 }
1747 //! l7vsadm constractor.
1748 //! create including all dictionary.
1749 l7vs::l7vsadm::l7vsadm()
1750                                 :       numeric_flag(false),
1751                                         command_wait_interval( L7VSADM_DEFAULT_WAIT_INTERVAL ),
1752                                         command_wait_count( L7VSADM_DEFAULT_WAIT_COUNT ),
1753                                         connect_wait_interval( L7VSADM_DEFAULT_WAIT_INTERVAL ),
1754                                         connect_wait_count( L7VSADM_DEFAULT_WAIT_COUNT ){
1755         Logger  logger( LOG_CAT_L7VSADM_COMMON, 35, "l7vsadm::l7vsadm(constructor)", __FILE__, __LINE__ );
1756
1757         // create command dictionary.
1758         command_dic["-l"]                               = boost::bind( &l7vsadm::parse_list_func, this, l7vsadm_request::CMD_LIST, _1, _2 );
1759         command_dic["--list"]                   = boost::bind( &l7vsadm::parse_list_func, this, l7vsadm_request::CMD_LIST, _1, _2 );
1760         command_dic["-V"]                               = boost::bind( &l7vsadm::parse_list_func, this, l7vsadm_request::CMD_LIST_VERBOSE, _1, _2 );
1761         command_dic["--verbose"]                = boost::bind( &l7vsadm::parse_list_func, this, l7vsadm_request::CMD_LIST_VERBOSE, _1, _2 );
1762         command_dic["-K"]                               = boost::bind( &l7vsadm::parse_list_func, this, l7vsadm_request::CMD_LIST_KEY, _1, _2 );
1763         command_dic["--key"]                    = boost::bind( &l7vsadm::parse_list_func, this, l7vsadm_request::CMD_LIST_KEY, _1, _2 );
1764         command_dic["-A"]                               = boost::bind( &l7vsadm::parse_vs_func, this, l7vsadm_request::CMD_ADD_VS, _1, _2 );
1765         command_dic["--add-service"]    = boost::bind( &l7vsadm::parse_vs_func, this, l7vsadm_request::CMD_ADD_VS, _1, _2 );
1766         command_dic["-D"]                               = boost::bind( &l7vsadm::parse_vs_func, this, l7vsadm_request::CMD_DEL_VS, _1, _2 );
1767         command_dic["--delete-service"] = boost::bind( &l7vsadm::parse_vs_func, this, l7vsadm_request::CMD_DEL_VS, _1, _2 );
1768         command_dic["-E"]                               = boost::bind( &l7vsadm::parse_vs_func, this, l7vsadm_request::CMD_EDIT_VS, _1, _2 );
1769         command_dic["--edit-service"]   = boost::bind( &l7vsadm::parse_vs_func, this, l7vsadm_request::CMD_EDIT_VS, _1, _2 );
1770         command_dic["-C"]                               = boost::bind( &l7vsadm::parse_vs_func, this, l7vsadm_request::CMD_FLUSH_VS, _1, _2 );
1771         command_dic["--flush"]                  = boost::bind( &l7vsadm::parse_vs_func, this, l7vsadm_request::CMD_FLUSH_VS, _1, _2 );
1772         command_dic["-a"]                               = boost::bind( &l7vsadm::parse_rs_func, this, l7vsadm_request::CMD_ADD_RS, _1, _2 );
1773         command_dic["--add-server"]             = boost::bind( &l7vsadm::parse_rs_func, this, l7vsadm_request::CMD_ADD_RS, _1, _2 );
1774         command_dic["-d"]                               = boost::bind( &l7vsadm::parse_rs_func, this, l7vsadm_request::CMD_DEL_RS, _1, _2 );
1775         command_dic["--delete-server"]  = boost::bind( &l7vsadm::parse_rs_func, this, l7vsadm_request::CMD_DEL_RS, _1, _2 );
1776         command_dic["-e"]                               = boost::bind( &l7vsadm::parse_rs_func, this, l7vsadm_request::CMD_EDIT_RS, _1, _2 );
1777         command_dic["--edit-server"]    = boost::bind( &l7vsadm::parse_rs_func, this, l7vsadm_request::CMD_EDIT_RS, _1, _2 );
1778         command_dic["-R"]                               = boost::bind( &l7vsadm::parse_replication_func, this, l7vsadm_request::CMD_REPLICATION, _1, _2 );
1779         command_dic["--replication"]    = boost::bind( &l7vsadm::parse_replication_func, this, l7vsadm_request::CMD_REPLICATION, _1, _2 );
1780         command_dic["-L"]                               = boost::bind( &l7vsadm::parse_log_func, this, l7vsadm_request::CMD_LOG, _1, _2 );
1781         command_dic["--log"]                    = boost::bind( &l7vsadm::parse_log_func, this, l7vsadm_request::CMD_LOG, _1, _2 );
1782         command_dic["-S"]                               = boost::bind( &l7vsadm::parse_snmp_func, this, l7vsadm_request::CMD_SNMP, _1, _2 );
1783         command_dic["--snmp"]                   = boost::bind( &l7vsadm::parse_snmp_func, this, l7vsadm_request::CMD_SNMP, _1, _2 );
1784         command_dic["-P"]                               = boost::bind( &l7vsadm::parse_parameter_func, this, l7vsadm_request::CMD_PARAMETER, _1, _2 );
1785         command_dic["--parameter"]              = boost::bind( &l7vsadm::parse_parameter_func, this, l7vsadm_request::CMD_PARAMETER, _1, _2 );
1786         command_dic["-h"]                               = boost::bind( &l7vsadm::parse_help_func, this, l7vsadm_request::CMD_HELP, _1, _2 );
1787         command_dic["--help"]                   = boost::bind( &l7vsadm::parse_help_func, this, l7vsadm_request::CMD_HELP, _1, _2 );
1788
1789         // create list option dictionary.
1790         list_option_dic["-n"]                   = boost::bind( &l7vsadm::parse_opt_list_numeric_func, this, _1, _2, _3 );
1791         list_option_dic["--numeric"]    = boost::bind( &l7vsadm::parse_opt_list_numeric_func, this, _1, _2, _3 );
1792         // create virtualservice option dictionary
1793         vs_option_dic["-t"]                             = boost::bind( &l7vsadm::parse_opt_vs_target_func, this, _1, _2, _3 );
1794         vs_option_dic["--target"]               = boost::bind( &l7vsadm::parse_opt_vs_target_func, this, _1, _2, _3 );
1795         vs_option_dic["-m"]                             = boost::bind( &l7vsadm::parse_opt_vs_module_func, this, _1, _2, _3 );
1796         vs_option_dic["--module"]               = boost::bind( &l7vsadm::parse_opt_vs_module_func, this, _1, _2, _3 );
1797         vs_option_dic["-s"]                             = boost::bind( &l7vsadm::parse_opt_vs_scheduler_func, this, _1, _2, _3 );
1798         vs_option_dic["--scheduler"]    = boost::bind( &l7vsadm::parse_opt_vs_scheduler_func, this, _1, _2, _3 );
1799         vs_option_dic["-u"]                             = boost::bind( &l7vsadm::parse_opt_vs_upper_func, this, _1, _2, _3 );
1800         vs_option_dic["--upper"]                = boost::bind( &l7vsadm::parse_opt_vs_upper_func, this, _1, _2, _3 );
1801         vs_option_dic["-b"]                             = boost::bind( &l7vsadm::parse_opt_vs_bypass_func, this, _1, _2, _3 );
1802         vs_option_dic["--bypass"]               = boost::bind( &l7vsadm::parse_opt_vs_bypass_func, this, _1, _2, _3 );
1803         vs_option_dic["-f"]                             = boost::bind( &l7vsadm::parse_opt_vs_flag_func, this, _1, _2, _3 );
1804         vs_option_dic["--flag"]                 = boost::bind( &l7vsadm::parse_opt_vs_flag_func, this, _1, _2, _3 );
1805         vs_option_dic["-Q"]                             = boost::bind( &l7vsadm::parse_opt_vs_qosup_func, this, _1, _2, _3 );
1806         vs_option_dic["--qos-up"]               = boost::bind( &l7vsadm::parse_opt_vs_qosup_func, this, _1, _2, _3 );
1807         vs_option_dic["-q"]                             = boost::bind( &l7vsadm::parse_opt_vs_qosdown_func, this, _1, _2, _3 );
1808         vs_option_dic["--qos-down"]             = boost::bind( &l7vsadm::parse_opt_vs_qosdown_func, this, _1, _2, _3 );
1809         vs_option_dic["-p"]                             = boost::bind( &l7vsadm::parse_opt_vs_udp_func, this, _1, _2, _3 );
1810         vs_option_dic["--udp"]                  = boost::bind( &l7vsadm::parse_opt_vs_udp_func, this, _1, _2, _3 );
1811         vs_option_dic["-S"]                             = boost::bind( &l7vsadm::parse_opt_vs_ssl_func, this, _1, _2, _3 );
1812         vs_option_dic["--ssl"]                  = boost::bind( &l7vsadm::parse_opt_vs_ssl_func, this, _1, _2, _3 );
1813         // create realserver option dictionary
1814         rs_option_dic["-t"]                             = boost::bind( &l7vsadm::parse_opt_vs_target_func, this, _1, _2, _3 );
1815         rs_option_dic["--target"]               = boost::bind( &l7vsadm::parse_opt_vs_target_func, this, _1, _2, _3 );
1816         rs_option_dic["-w"]                             = boost::bind( &l7vsadm::parse_opt_rs_weight_func, this, _1, _2, _3 );
1817         rs_option_dic["--weight"]               = boost::bind( &l7vsadm::parse_opt_rs_weight_func, this, _1, _2, _3 );
1818         rs_option_dic["-m"]                             = boost::bind( &l7vsadm::parse_opt_vs_module_func, this, _1, _2, _3 );
1819         rs_option_dic["--module"]               = boost::bind( &l7vsadm::parse_opt_vs_module_func, this, _1, _2, _3 );
1820         rs_option_dic["-p"]                             = boost::bind( &l7vsadm::parse_opt_vs_udp_func, this, _1, _2, _3 );
1821         rs_option_dic["--udp"]                  = boost::bind( &l7vsadm::parse_opt_vs_udp_func, this, _1, _2, _3 );
1822         rs_option_dic["-r"]                             = boost::bind( &l7vsadm::parse_opt_rs_realserver_func, this, _1, _2, _3 );
1823         rs_option_dic["--real-server"]  = boost::bind( &l7vsadm::parse_opt_rs_realserver_func, this, _1, _2, _3 );
1824         // create replication option dictionary
1825         replication_option_dic["-s"]    = boost::bind( &l7vsadm::parse_opt_replication_switch_func, this, _1, _2, _3 );
1826         replication_option_dic["--switch"]
1827                                                                         = boost::bind( &l7vsadm::parse_opt_replication_switch_func, this, _1, _2, _3 );
1828         replication_switch_option_dic["start"]
1829                                                                         = boost::bind( &l7vsadm::parse_opt_replication_start_func, this, _1, _2, _3 );
1830         replication_switch_option_dic["stop"]
1831                                                                         = boost::bind( &l7vsadm::parse_opt_replication_stop_func, this, _1, _2, _3 );
1832         replication_option_dic["-f"]    = boost::bind( &l7vsadm::parse_opt_replication_force_func, this, _1, _2, _3 );
1833         replication_option_dic["--force"]
1834                                                                         = boost::bind( &l7vsadm::parse_opt_replication_force_func, this, _1, _2, _3 );
1835         replication_option_dic["-d"]    = boost::bind( &l7vsadm::parse_opt_replication_dump_func, this, _1, _2, _3 );
1836         replication_option_dic["--dump"]
1837                                                                         = boost::bind( &l7vsadm::parse_opt_replication_dump_func, this, _1, _2, _3 );
1838         // create log option function dictionary create
1839         log_option_dic["-c"]                    = boost::bind( &l7vsadm::parse_opt_log_category_func, this, _1, _2, _3 );
1840         log_option_dic["--category"]    = boost::bind( &l7vsadm::parse_opt_log_category_func, this, _1, _2, _3 );
1841         log_option_dic["-l"]                    = boost::bind( &l7vsadm::parse_opt_log_level_func, this, _1, _2, _3 );
1842         log_option_dic["--level"]               = boost::bind( &l7vsadm::parse_opt_log_level_func, this, _1, _2, _3 );
1843         // snmp agent option function dictionary create
1844         snmp_option_dic["-c"]                   = boost::bind( &l7vsadm::parse_opt_snmp_log_category_func, this, _1, _2, _3 );
1845         snmp_option_dic["--category"]   = boost::bind( &l7vsadm::parse_opt_snmp_log_category_func, this, _1, _2, _3 );
1846         snmp_option_dic["-l"]                   = boost::bind( &l7vsadm::parse_opt_snmp_log_level_func, this, _1, _2, _3 );
1847         snmp_option_dic["--level"]              = boost::bind( &l7vsadm::parse_opt_snmp_log_level_func, this, _1, _2, _3 );
1848         // parameter option function dictionary create
1849         parameter_option_dic["-r"]              = boost::bind( &l7vsadm::parse_opt_parameter_reload_func, this, _1, _2, _3 );
1850         parameter_option_dic["--reload"]
1851                                                                         = boost::bind( &l7vsadm::parse_opt_parameter_reload_func, this, _1, _2, _3 );
1852
1853         // string logcategory dictionary create
1854         string_logcategory_dic["l7vsd_network"]                                 = LOG_CAT_L7VSD_NETWORK;
1855         string_logcategory_dic["nw"]                                                    = LOG_CAT_L7VSD_NETWORK;
1856         logcategory_string_dic[LOG_CAT_L7VSD_NETWORK]                   = "l7vsd_network";
1857         string_logcategory_dic["l7vsd_network_qos"]                             = LOG_CAT_L7VSD_NETWORK_QOS;
1858         string_logcategory_dic["nw_qos"]                                                = LOG_CAT_L7VSD_NETWORK_QOS;
1859         logcategory_string_dic[LOG_CAT_L7VSD_NETWORK_QOS]               = "l7vsd_network_qos";
1860         string_logcategory_dic["l7vsd_network_bandwidth"]               = LOG_CAT_L7VSD_NETWORK_BANDWIDTH;
1861         string_logcategory_dic["nw_bw"]                                                 = LOG_CAT_L7VSD_NETWORK_BANDWIDTH;
1862         logcategory_string_dic[LOG_CAT_L7VSD_NETWORK_BANDWIDTH] = "l7vsd_network_bandwidth";
1863         string_logcategory_dic["l7vsd_network_num_connection"]  = LOG_CAT_L7VSD_NETWORK_NUM_CONNECTION;
1864         string_logcategory_dic["nw_conn"]                                               = LOG_CAT_L7VSD_NETWORK_NUM_CONNECTION;
1865         logcategory_string_dic[LOG_CAT_L7VSD_NETWORK_NUM_CONNECTION]
1866                                                                                                                         = "l7vsd_network_num_connection";
1867         string_logcategory_dic["l7vsd_network_access"]                  = LOG_CAT_L7VSD_NETWORK_ACCESS;
1868         string_logcategory_dic["nw_acc"]                                                = LOG_CAT_L7VSD_NETWORK_ACCESS;
1869         logcategory_string_dic[LOG_CAT_L7VSD_NETWORK_ACCESS]            = "l7vsd_network_access";
1870         string_logcategory_dic["l7vsd_mainthread"]                              = LOG_CAT_L7VSD_MAINTHREAD;
1871         string_logcategory_dic["mth"]                                                   = LOG_CAT_L7VSD_MAINTHREAD;
1872         logcategory_string_dic[LOG_CAT_L7VSD_MAINTHREAD]                = "l7vsd_mainthread";
1873         string_logcategory_dic["l7vsd_virtualservice"]                  = LOG_CAT_L7VSD_VIRTUALSERVICE;
1874         string_logcategory_dic["vs"]                                                    = LOG_CAT_L7VSD_VIRTUALSERVICE;
1875         logcategory_string_dic[LOG_CAT_L7VSD_VIRTUALSERVICE]    = "l7vsd_virtualservice";
1876         string_logcategory_dic["l7vsd_virtualservice_thread"]   = LOG_CAT_L7VSD_VIRTUALSERVICE_THREAD;
1877         string_logcategory_dic["vs_th"]                                                 = LOG_CAT_L7VSD_VIRTUALSERVICE_THREAD;
1878         logcategory_string_dic[LOG_CAT_L7VSD_VIRTUALSERVICE_THREAD]
1879                                                                                                                         = "l7vsd_virtualservice_thread";
1880         string_logcategory_dic["l7vsd_session"]                                 = LOG_CAT_L7VSD_SESSION;
1881         string_logcategory_dic["ss"]                                                    = LOG_CAT_L7VSD_SESSION;
1882         logcategory_string_dic[LOG_CAT_L7VSD_SESSION]                   = "l7vsd_session";
1883         string_logcategory_dic["l7vsd_session_thread"]                  = LOG_CAT_L7VSD_SESSION_THREAD;
1884         string_logcategory_dic["ss_th"]                                                 = LOG_CAT_L7VSD_SESSION_THREAD;
1885         logcategory_string_dic[LOG_CAT_L7VSD_SESSION_THREAD]    = "l7vsd_session_thread";
1886         string_logcategory_dic["l7vsd_realserver"]                              = LOG_CAT_L7VSD_REALSERVER;
1887         string_logcategory_dic["rs"]                                                    = LOG_CAT_L7VSD_REALSERVER;
1888         logcategory_string_dic[LOG_CAT_L7VSD_REALSERVER]                = "l7vsd_realserver";
1889         string_logcategory_dic["l7vsd_sorryserver"]                             = LOG_CAT_L7VSD_SORRYSERVER;
1890         string_logcategory_dic["sorry"]                                                 = LOG_CAT_L7VSD_SORRYSERVER;
1891         logcategory_string_dic[LOG_CAT_L7VSD_SORRYSERVER]               = "l7vsd_sorryserver";
1892         string_logcategory_dic["l7vsd_module"]                                  = LOG_CAT_L7VSD_MODULE;
1893         string_logcategory_dic["mod"]                                                   = LOG_CAT_L7VSD_MODULE;
1894         logcategory_string_dic[LOG_CAT_L7VSD_MODULE]                    = "l7vsd_module";
1895         string_logcategory_dic["l7vsd_replication"]                             = LOG_CAT_L7VSD_REPLICATION;
1896         string_logcategory_dic["rep"]                                                   = LOG_CAT_L7VSD_REPLICATION;
1897         logcategory_string_dic[LOG_CAT_L7VSD_REPLICATION]               = "l7vsd_replication";
1898         string_logcategory_dic["l7vsd_replication_sendthread"]  = LOG_CAT_L7VSD_REPLICATION_SENDTHREAD;
1899         string_logcategory_dic["rep_sth"]                                               = LOG_CAT_L7VSD_REPLICATION_SENDTHREAD;
1900         logcategory_string_dic[LOG_CAT_L7VSD_REPLICATION_SENDTHREAD]
1901                                                                                                                         = "l7vsd_replication_sendthread";
1902         string_logcategory_dic["l7vsd_parameter"]                               = LOG_CAT_L7VSD_PARAMETER;
1903         string_logcategory_dic["para"]                                                  = LOG_CAT_L7VSD_PARAMETER;
1904         logcategory_string_dic[LOG_CAT_L7VSD_PARAMETER]                 = "l7vsd_parameter";
1905         string_logcategory_dic["l7vsd_logger"]                                  = LOG_CAT_L7VSD_LOGGER;
1906         string_logcategory_dic["logger"]                                                = LOG_CAT_L7VSD_LOGGER;
1907         logcategory_string_dic[LOG_CAT_L7VSD_LOGGER]                    = "l7vsd_logger";
1908         string_logcategory_dic["l7vsd_command"]                                 = LOG_CAT_L7VSD_COMMAND;
1909         string_logcategory_dic["cmd"]                                                   = LOG_CAT_L7VSD_COMMAND;
1910         logcategory_string_dic[LOG_CAT_L7VSD_COMMAND]                   = "l7vsd_command";
1911         string_logcategory_dic["l7vsd_start_stop"]                              = LOG_CAT_L7VSD_START_STOP;
1912         string_logcategory_dic["stastp"]                                                = LOG_CAT_L7VSD_START_STOP;
1913         logcategory_string_dic[LOG_CAT_L7VSD_START_STOP]                = "l7vsd_start_stop";
1914         string_logcategory_dic["l7vsd_system"]                                  = LOG_CAT_L7VSD_SYSTEM;
1915         string_logcategory_dic["sys"]                                                   = LOG_CAT_L7VSD_SYSTEM;
1916         logcategory_string_dic[LOG_CAT_L7VSD_SYSTEM]                    = "l7vsd_system";
1917         string_logcategory_dic["l7vsd_system_memory"]                   = LOG_CAT_L7VSD_SYSTEM_MEMORY;
1918         string_logcategory_dic["sys_mem"]                                               = LOG_CAT_L7VSD_SYSTEM_MEMORY;
1919         logcategory_string_dic[LOG_CAT_L7VSD_SYSTEM_MEMORY]             = "l7vsd_system_memory";
1920         string_logcategory_dic["l7vsd_system_endpoint"]                 = LOG_CAT_L7VSD_SYSTEM_ENDPOINT;
1921         string_logcategory_dic["sys_ep"]                                                = LOG_CAT_L7VSD_SYSTEM_ENDPOINT;
1922         logcategory_string_dic[LOG_CAT_L7VSD_SYSTEM_ENDPOINT]   = "l7vsd_system_endpoint";
1923         string_logcategory_dic["l7vsd_system_signal"]                   = LOG_CAT_L7VSD_SYSTEM_SIGNAL;
1924         string_logcategory_dic["sys_sig"]                                               = LOG_CAT_L7VSD_SYSTEM_SIGNAL;
1925         logcategory_string_dic[LOG_CAT_L7VSD_SYSTEM_SIGNAL]             = "l7vsd_system_signal";
1926         string_logcategory_dic["l7vsd_system_environment"]              = LOG_CAT_L7VSD_SYSTEM_ENVIRONMENT;
1927         string_logcategory_dic["sys_env"]                                               = LOG_CAT_L7VSD_SYSTEM_ENVIRONMENT;
1928         logcategory_string_dic[LOG_CAT_L7VSD_SYSTEM_ENVIRONMENT]
1929                                                                                                                         = "l7vsd_system_environment";
1930         string_logcategory_dic["l7vsd_snmpbridge"]                              = LOG_CAT_L7VSD_SNMPBRIDGE;
1931         string_logcategory_dic["bridge"]                                                = LOG_CAT_L7VSD_SNMPBRIDGE;
1932         logcategory_string_dic[LOG_CAT_L7VSD_SNMPBRIDGE]
1933                                                                                                                         = "l7vsd_snmpbridge";
1934         string_logcategory_dic["l7vsd_protocol"]                                = LOG_CAT_PROTOCOL;
1935         string_logcategory_dic["prot"]                                                  = LOG_CAT_PROTOCOL;
1936         logcategory_string_dic[LOG_CAT_PROTOCOL]                                = "l7vsd_protocol";
1937         string_logcategory_dic["l7vsd_schedule"]                                = LOG_CAT_SCHEDULE;
1938         string_logcategory_dic["sched"]                                                 = LOG_CAT_SCHEDULE;
1939         logcategory_string_dic[LOG_CAT_SCHEDULE]                                = "l7vsd_schedule";
1940         string_logcategory_dic["all"]                                                   = LOG_CAT_END;
1941
1942         // string snmp logcategory dictionary create
1943         string_snmp_logcategory_dic["snmpagent_start_stop"]                     = LOG_CAT_SNMPAGENT_START_STOP;
1944         string_snmp_logcategory_dic["snmp_stastp"]                                      = LOG_CAT_SNMPAGENT_START_STOP;
1945         snmp_logcategory_string_dic[LOG_CAT_SNMPAGENT_START_STOP]       = "snmpagent_start_stop";
1946         string_snmp_logcategory_dic["snmpagent_manager_receive"]        = LOG_CAT_SNMPAGENT_MANAGER_RECEIVE;
1947         string_snmp_logcategory_dic["snmp_mngrcv"]                                      = LOG_CAT_SNMPAGENT_MANAGER_RECEIVE;
1948         snmp_logcategory_string_dic[LOG_CAT_SNMPAGENT_MANAGER_RECEIVE]
1949                                                                                                                                 = "snmpagent_manager_receive";
1950         string_snmp_logcategory_dic["snmpagent_manager_send"]           = LOG_CAT_SNMPAGENT_MANAGER_SEND;
1951         string_snmp_logcategory_dic["snmp_mngsnd"]                                      = LOG_CAT_SNMPAGENT_MANAGER_SEND;
1952         snmp_logcategory_string_dic[LOG_CAT_SNMPAGENT_MANAGER_SEND]     = "snmpagent_manager_send";
1953         string_snmp_logcategory_dic["snmpagent_l7vsd_receive"]          = LOG_CAT_SNMPAGENT_L7VSD_RECEIVE;
1954         string_snmp_logcategory_dic["snmp_vsdrcv"]                                      = LOG_CAT_SNMPAGENT_L7VSD_RECEIVE;
1955         snmp_logcategory_string_dic[LOG_CAT_SNMPAGENT_L7VSD_RECEIVE]
1956                                                                                                                                 = "snmpagent_l7vsd_receive";
1957         string_snmp_logcategory_dic["snmpagent_l7vsd_send"]                     = LOG_CAT_SNMPAGENT_L7VSD_SEND;
1958         string_snmp_logcategory_dic["snmp_vsdsnd"]                                      = LOG_CAT_SNMPAGENT_L7VSD_SEND;
1959         snmp_logcategory_string_dic[LOG_CAT_SNMPAGENT_L7VSD_SEND]       = "snmpagent_l7vsd_send";
1960         string_snmp_logcategory_dic["snmpagent_logger"]                         = LOG_CAT_SNMPAGENT_LOGGER;
1961         string_snmp_logcategory_dic["snmp_logger"]                                      = LOG_CAT_SNMPAGENT_LOGGER;
1962         snmp_logcategory_string_dic[LOG_CAT_SNMPAGENT_LOGGER]           = "snmpagent_logger";
1963         string_snmp_logcategory_dic["snmpagent_parameter"]                      = LOG_CAT_SNMPAGENT_PARAMETER;
1964         string_snmp_logcategory_dic["snmp_para"]                                        = LOG_CAT_SNMPAGENT_PARAMETER;
1965         snmp_logcategory_string_dic[LOG_CAT_SNMPAGENT_PARAMETER]        = "snmpagent_parameter";
1966         string_snmp_logcategory_dic["snmpagent_system"]                         = LOG_CAT_SNMPAGENT_SYSTEM;
1967         string_snmp_logcategory_dic["snmp_sys"]                                         = LOG_CAT_SNMPAGENT_SYSTEM;
1968         snmp_logcategory_string_dic[LOG_CAT_SNMPAGENT_SYSTEM]           = "snmpagent_system";
1969         string_snmp_logcategory_dic["snmpagent_system_memory"]          = LOG_CAT_SNMPAGENT_SYSTEM_MEMORY;
1970         string_snmp_logcategory_dic["snmp_sys_mem"]                                     = LOG_CAT_SNMPAGENT_SYSTEM_MEMORY;
1971         snmp_logcategory_string_dic[LOG_CAT_SNMPAGENT_SYSTEM_MEMORY]
1972                                                                                                                                 = "snmpagent_system_memory";
1973         string_snmp_logcategory_dic["snmpagent_system_endpoint"]        = LOG_CAT_SNMPAGENT_SYSTEM_ENDPOINT;
1974         string_snmp_logcategory_dic["snmp_sys_ep"]                                      = LOG_CAT_SNMPAGENT_SYSTEM_ENDPOINT;
1975         snmp_logcategory_string_dic[LOG_CAT_SNMPAGENT_SYSTEM_ENDPOINT]
1976                                                                                                                                 = "snmpagent_system_endpoint";
1977         string_snmp_logcategory_dic["snmpagent_system_signal"]          = LOG_CAT_SNMPAGENT_SYSTEM_SIGNAL;
1978         string_snmp_logcategory_dic["snmp_sys_sig"]                                     = LOG_CAT_SNMPAGENT_SYSTEM_SIGNAL;
1979         snmp_logcategory_string_dic[LOG_CAT_SNMPAGENT_SYSTEM_SIGNAL]
1980                                                                                                                                 = "snmpagent_system_signal";
1981         string_snmp_logcategory_dic["snmpagent_system_environment"]     = LOG_CAT_SNMPAGENT_SYSTEM_ENVIRONMENT;
1982         string_snmp_logcategory_dic["snmp_sys_env"]                                     = LOG_CAT_SNMPAGENT_SYSTEM_ENVIRONMENT;
1983         snmp_logcategory_string_dic[LOG_CAT_SNMPAGENT_SYSTEM_ENVIRONMENT]
1984                                                                                                                                 = "snmpagent_system_environment";
1985         string_snmp_logcategory_dic["all"]                                                      = LOG_CAT_END;
1986
1987         // string log level dictionary create.
1988         string_loglevel_dic["debug"]            = LOG_LV_DEBUG;
1989         loglevel_string_dic[LOG_LV_DEBUG]       = "debug";
1990         string_loglevel_dic["info"]                     = LOG_LV_INFO;
1991         loglevel_string_dic[LOG_LV_INFO]        = "info";
1992         string_loglevel_dic["warn"]                     = LOG_LV_WARN;
1993         loglevel_string_dic[LOG_LV_WARN]        = "warn";
1994         string_loglevel_dic["error"]            = LOG_LV_ERROR;
1995         loglevel_string_dic[LOG_LV_ERROR]       = "error";
1996         string_loglevel_dic["fatal"]            = LOG_LV_FATAL;
1997         loglevel_string_dic[LOG_LV_FATAL]       = "fatal";
1998
1999         // parameter category dictionary create
2000         string_parameter_dic["all"]                             = PARAM_COMP_ALL;
2001         string_parameter_dic["l7vsd"]                   = PARAM_COMP_L7VSD;
2002         string_parameter_dic["command"]                 = PARAM_COMP_COMMAND;
2003         string_parameter_dic["session"]                 = PARAM_COMP_SESSION;
2004         string_parameter_dic["virtualservice"]  = PARAM_COMP_VIRTUALSERVICE;
2005         string_parameter_dic["module"]                  = PARAM_COMP_MODULE;
2006         string_parameter_dic["replication"]             = PARAM_COMP_REPLICATION;
2007         string_parameter_dic["logger"]                  = PARAM_COMP_LOGGER;
2008         string_parameter_dic["l7vsadm"]                 = PARAM_COMP_L7VSADM;
2009         string_parameter_dic["snmpagent"]               = PARAM_COMP_SNMPAGENT;
2010         string_parameter_dic["sslproxy"]                = PARAM_COMP_SSLPROXY;
2011         string_parameter_dic["ssl"]                     = PARAM_COMP_SSL;
2012
2013         // create disp_result dictionary.
2014         disp_result_dic[l7vsadm_request::CMD_LIST]                      = boost::bind( &l7vsadm::disp_list, this );
2015         disp_result_dic[l7vsadm_request::CMD_LIST_KEY]          = boost::bind( &l7vsadm::disp_list_key, this );
2016         disp_result_dic[l7vsadm_request::CMD_LIST_VERBOSE]      = boost::bind( &l7vsadm::disp_list_verbose, this );
2017
2018         // response_message_dic create
2019         response_error_message_dic[l7vsd_response::RESPONSE_ERROR]                              = "command error : ";
2020         response_error_message_dic[l7vsd_response::RESPONSE_LIST_ERROR]                 = "list command error : ";
2021         response_error_message_dic[l7vsd_response::RESPONSE_LIST_VERBOSE_ERROR] = "list verbose error : ";
2022         response_error_message_dic[l7vsd_response::RESPONSE_LIST_KEY_ERROR]             = "list key error : ";
2023         response_error_message_dic[l7vsd_response::RESPONSE_ADD_VS_ERROR]               = "add vs error : ";
2024         response_error_message_dic[l7vsd_response::RESPONSE_DEL_VS_ERROR]               = "del vs error : ";
2025         response_error_message_dic[l7vsd_response::RESPONSE_EDIT_VS_ERROR]              = "edit vs error : ";
2026         response_error_message_dic[l7vsd_response::RESPONSE_FLUSH_VS_ERROR]             = "flush vs error : ";
2027         response_error_message_dic[l7vsd_response::RESPONSE_ADD_RS_ERROR]               = "add rs error : ";
2028         response_error_message_dic[l7vsd_response::RESPONSE_DEL_RS_ERROR]               = "del rs error : ";
2029         response_error_message_dic[l7vsd_response::RESPONSE_EDIT_RS_ERROR]              = "edit rs error : ";
2030         response_error_message_dic[l7vsd_response::RESPONSE_REPLICATION_ERROR]  = "replication command error : ";
2031         response_error_message_dic[l7vsd_response::RESPONSE_LOG_ERROR]                  = "log command error : ";
2032         response_error_message_dic[l7vsd_response::RESPONSE_SNMP_ERROR]                 = "snmp command error : ";
2033         response_error_message_dic[l7vsd_response::RESPONSE_PARAMETER_ERROR]    = "parameter error : ";
2034
2035         replication_mode_string_dic[replication::REPLICATION_OUT]                       = "OUT";
2036         replication_mode_string_dic[replication::REPLICATION_SINGLE]            = "SINGLE";
2037         replication_mode_string_dic[replication::REPLICATION_MASTER]            = "MASTER";
2038         replication_mode_string_dic[replication::REPLICATION_SLAVE]                     = "SLAVE";
2039         replication_mode_string_dic[replication::REPLICATION_MASTER_STOP]       = "MASTER_STOP";
2040         replication_mode_string_dic[replication::REPLICATION_SLAVE_STOP]        = "SLAVE_STOP";
2041
2042 }
2043
2044 //! Get l7vsadm parameter data
2045 void    l7vs::l7vsadm::set_parameter(){
2046         Logger  logger( LOG_CAT_L7VSADM_COMMON, 36, "l7vsadm::set_parameter", __FILE__, __LINE__ );
2047
2048         // Get and Set l7vsadm all parameter value.
2049         Parameter       param;
2050         error_code      err;
2051
2052         // command_wait_interval
2053         command_wait_interval = param.get_int(PARAM_COMP_L7VSADM, "cmd_interval", err);
2054         if( !err ){
2055                 if(     command_wait_interval < 0 ||
2056                         command_wait_interval > L7VSADM_MAX_WAIT ){
2057                         // When illegal parameter value, use default parameter value.
2058                         command_wait_interval = L7VSADM_DEFAULT_WAIT_INTERVAL;
2059                         std::string     msg("Illegal cmd_interval parameter value. Use default value.");
2060                         Logger::putLogWarn(LOG_CAT_L7VSADM_COMMON, 1, msg, __FILE__, __LINE__);
2061                 }
2062         }
2063         else{
2064                 std::string     msg("Get cmd_interval parameter error. Use default value.");
2065                 Logger::putLogWarn(LOG_CAT_L7VSADM_COMMON, 2, msg, __FILE__, __LINE__);
2066         }
2067
2068         //command_wait_count
2069         command_wait_count = param.get_int(PARAM_COMP_L7VSADM, "cmd_count", err);
2070         if( !err ){
2071                 if(     command_wait_count < 0 ||
2072                         command_wait_count > L7VSADM_MAX_WAIT ){
2073                         // When illegal parameter value, use default parameter value.
2074                         command_wait_count = L7VSADM_DEFAULT_WAIT_COUNT;
2075                         std::string     msg("Illegal cmd_count parameter value. Use default value.");
2076                         Logger::putLogWarn(LOG_CAT_L7VSADM_COMMON, 3, msg, __FILE__, __LINE__);
2077                 }
2078         }
2079         else{
2080                 std::string     msg("Get cmd_count parameter error. Use default value.");
2081                 Logger::putLogWarn(LOG_CAT_L7VSADM_COMMON, 4, msg, __FILE__, __LINE__);
2082         }
2083
2084         // connect_wait_interval
2085         connect_wait_interval = param.get_int(PARAM_COMP_L7VSADM, "con_interval", err);
2086         if( !err ){
2087                 if(     connect_wait_interval < 0 ||
2088                         connect_wait_interval > L7VSADM_MAX_WAIT ){
2089                         // When illegal parameter value, use default parameter value.
2090                         connect_wait_interval = L7VSADM_DEFAULT_WAIT_INTERVAL;
2091                         std::string     msg("Illegal con_interval parameter value. Use default value.");
2092                         Logger::putLogWarn(LOG_CAT_L7VSADM_COMMON, 5, msg, __FILE__, __LINE__);
2093                 }
2094         }
2095         else{
2096                 std::string     msg("Get con_interval parameter error. Use default value.");
2097                 Logger::putLogWarn(LOG_CAT_L7VSADM_COMMON, 6, msg, __FILE__, __LINE__);
2098         }
2099
2100         //connect_wait_count
2101         connect_wait_count = param.get_int(PARAM_COMP_L7VSADM, "con_count", err);
2102         if( !err ){
2103                 if(     connect_wait_count < 0 ||
2104                         connect_wait_count > L7VSADM_MAX_WAIT ){
2105                         // When illegal parameter value, use default parameter value.
2106                         connect_wait_count = L7VSADM_DEFAULT_WAIT_COUNT;
2107                         std::string     msg("Illegal con_count parameter value. Use default value.");
2108                         Logger::putLogWarn(LOG_CAT_L7VSADM_COMMON, 7, msg, __FILE__, __LINE__);
2109                 }
2110         }
2111         else{
2112                 std::string     msg("Get con_count parameter error. Use default value.");
2113                 Logger::putLogWarn(LOG_CAT_L7VSADM_COMMON, 8, msg, __FILE__, __LINE__);
2114         }
2115
2116         if ((command_wait_interval * command_wait_count) > L7VSADM_MAX_WAIT) {
2117                 // When wait value too long, use default parameter value.
2118                 command_wait_interval = L7VSADM_DEFAULT_WAIT_INTERVAL;
2119                 command_wait_count = L7VSADM_DEFAULT_WAIT_COUNT;
2120                 std::string     msg("Command wait value too long. Use default value.");
2121                 Logger::putLogWarn(LOG_CAT_L7VSADM_COMMON, 9, msg, __FILE__, __LINE__);
2122
2123         }
2124         if ((connect_wait_interval * connect_wait_count) > L7VSADM_MAX_WAIT) {
2125                 // When wait value too long, use default parameter value.
2126                 connect_wait_interval = L7VSADM_DEFAULT_WAIT_INTERVAL;
2127                 connect_wait_count = L7VSADM_DEFAULT_WAIT_COUNT;
2128                 std::string     msg("Connect wait value too long. Use default value.");
2129                 Logger::putLogWarn(LOG_CAT_L7VSADM_COMMON, 10, msg, __FILE__, __LINE__);
2130         }
2131 }
2132
2133 //! l7vsadm command execute
2134 bool    l7vs::l7vsadm::execute( int argc, char* argv[] ){
2135         Logger  logger( LOG_CAT_L7VSADM_COMMON, 37, "l7vsadm::execute", __FILE__, __LINE__ );
2136
2137         /*-------- DEBUG LOG --------*/
2138         if( LOG_LV_DEBUG == Logger::getLogLevel( LOG_CAT_L7VSADM_COMMON ) ){
2139                 std::stringstream       debugstr;
2140                 debugstr << boost::format( "l7vsadm::execute arguments:%s" ) % argument_debug_dump( argc, argv );
2141                 Logger::putLogDebug( LOG_CAT_L7VSADM_COMMON, 38, debugstr.str(), __FILE__, __LINE__ );
2142         }
2143         /*------ DEBUG LOG END ------*/
2144
2145         // set sighanlder
2146         if ( 0 > set_sighandlers() ) {
2147                 std::string     buf("set_sighandlers failed.");
2148                 std::cerr << "COMMON ERROR : " << buf << std::endl;
2149                 Logger::putLogError( LOG_CAT_L7VSADM_COMMON, 1, buf, __FILE__, __LINE__ );
2150                 return false;
2151         }
2152
2153         // readparam
2154         set_parameter();
2155
2156         // Get l7vsadm execute file path from /proc/(pid)/exe (symbolic link)
2157         char l7vsadm_file_path[256];
2158         memset(l7vsadm_file_path, 0, sizeof(l7vsadm_file_path));
2159         readlink("/proc/self/exe", l7vsadm_file_path, sizeof(l7vsadm_file_path));
2160
2161         // L7vsadm command conflict check. (Try l7vsadm execute file lock)
2162         file_lock       lock( l7vsadm_file_path, l7vsadm_err );
2163         if( l7vsadm_err ){
2164                 std::cerr << "COMMON ERROR : " << l7vsadm_err.get_message() << std::endl;
2165                 Logger::putLogError( LOG_CAT_L7VSADM_COMMON, 2, l7vsadm_err.get_message(), __FILE__, __LINE__ );
2166                 return false;
2167         }
2168
2169         try{
2170                 // l7vsadm file lock wait
2171                 int command_retry_count = 0;
2172                 while( true ){
2173                         // Check signal.
2174                         if( signal_flag ){
2175                                 std::stringstream buf;
2176                                 buf << boost::format( "Signal (%d) Received." ) % received_sig;
2177                                 l7vsadm_err.setter( true, buf.str() );
2178                                 Logger::putLogError( LOG_CAT_L7VSADM_COMMON, 3, buf.str(), __FILE__, __LINE__ );
2179                                 break;
2180                         }
2181
2182                         // Try lock l7vsadm file.
2183                         if( lock.try_lock() ){
2184                                 break;
2185                         }
2186
2187                         ++command_retry_count;
2188                         if (command_retry_count > command_wait_count) {
2189                                 // L7vsadm file lock error. (l7vsadm is executing)
2190                                 std::string     buf( "L7vsadm file lock timeout. (l7vsadm is already executing)" );
2191                                 l7vsadm_err.setter( true, buf );
2192                                 Logger::putLogError( LOG_CAT_L7VSADM_COMMON, 4, buf, __FILE__, __LINE__ );
2193                                 break;
2194                         }
2195                         // Lock retrying.
2196                         boost::xtime xt;
2197                         xtime_get(&xt, boost::TIME_UTC);
2198                         xt.sec += command_wait_interval;
2199                         boost::thread::sleep(xt);
2200                 }
2201
2202                 // display err
2203                 if( l7vsadm_err ){
2204                         std::cerr << "COMMON ERROR : " << l7vsadm_err.get_message() << std::endl;
2205                         return false;
2206                 }
2207
2208                 // no argument, assume list command
2209                 if( 1 == argc ){
2210                         request.command = l7vsadm_request::CMD_LIST;
2211                 }
2212                 else {
2213                         // parse command line
2214                         int pos = 1;
2215                         parse_cmd_map_type::iterator itr = command_dic.find( argv[pos] );
2216                         if( itr != command_dic.end() ){
2217                                 itr->second( argc, argv );
2218                         }
2219                         else{
2220                                 std::string     buf("command not found.");
2221                                 l7vsadm_err.setter( true, buf );
2222                                 Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 88, buf, __FILE__, __LINE__ );
2223                         }
2224                 }
2225
2226                 // display command parse result
2227                 if( l7vsadm_err ){
2228                         std::cerr << "PARSE ERROR : " << l7vsadm_err.get_message() << std::endl;
2229                         std::cerr << usage() << std::endl;
2230                         return false;
2231                 }
2232
2233                 if( l7vsadm_request::CMD_HELP != request.command ){
2234                         // communicate to l7vsd
2235                         using boost::asio::local::stream_protocol;
2236                         boost::array< char, COMMAND_BUFFER_SIZE >       response_buffer;
2237                         response_buffer.assign( 0x00 );
2238
2239                         // connect
2240                         boost::asio::io_service io;
2241                         stream_protocol::socket s( io );
2242
2243                         int     connect_retry_count = 0;
2244                         while( true ){
2245                                 // Check signal.
2246                                 if( signal_flag ){
2247                                         std::stringstream buf;
2248                                         buf << boost::format( "Signal (%d) Received." ) % received_sig;
2249                                         l7vsadm_err.setter( true, buf.str() );
2250                                         Logger::putLogError( LOG_CAT_L7VSADM_COMMON, 5, buf.str(), __FILE__, __LINE__ );
2251                                         break;
2252                                 }
2253
2254                                 // Try connect to config socket.
2255                                 boost::system::error_code err;
2256                                 s.connect(stream_protocol::endpoint( L7VS_CONFIG_SOCKNAME ), err );
2257                                 if( !err ){
2258                                         break;
2259                                 }
2260                                 connect_retry_count++;
2261                                 if (connect_retry_count > connect_wait_count) {
2262                                         std::stringstream       buf;
2263                                         buf << boost::format( "connect() to daemon timeout: %s." ) % err.message();
2264                                         l7vsadm_err.setter( true, buf.str() );
2265                                         Logger::putLogError( LOG_CAT_L7VSADM_COMMON, 6, buf.str(), __FILE__, __LINE__ );
2266                                         break;
2267                                 }
2268                                 // Connect retrying.
2269                                 boost::xtime xt;
2270                                 xtime_get(&xt, boost::TIME_UTC);
2271                                 xt.sec += connect_wait_interval;
2272                                 boost::thread::sleep(xt);
2273                         }
2274
2275                         // display err
2276                         if( l7vsadm_err ){
2277                                 std::cerr << "COMMON ERROR : " << l7vsadm_err.get_message() << std::endl;
2278                                 return false;
2279                         }
2280
2281                         /*-------- DEBUG LOG --------*/
2282                         if( LOG_LV_DEBUG == Logger::getLogLevel( LOG_CAT_L7VSADM_COMMON ) ){
2283                                 std::stringstream       debugstr;
2284                                 debugstr << boost::format( "l7vsadm_send_request:%s" ) % request;
2285                                 Logger::putLogDebug( LOG_CAT_L7VSADM_COMMON, 39, debugstr.str(), __FILE__, __LINE__ );
2286                         }
2287                         /*------ DEBUG LOG END ------*/
2288
2289                         // write sockfile
2290                         std::stringstream       send_stream;
2291                         boost::archive::text_oarchive   oa( send_stream );
2292                         oa << (const l7vs::l7vsadm_request&) request;
2293                         boost::asio::write( s, boost::asio::buffer( send_stream.str() ) );
2294
2295                         // read sockfile
2296                         s.read_some( boost::asio::buffer( response_buffer ) );
2297
2298                         std::stringstream       recv_stream;
2299                         recv_stream << &(response_buffer[0]);
2300                         boost::archive::text_iarchive   ia( recv_stream );
2301                         ia >> response;
2302
2303                         /*-------- DEBUG LOG --------*/
2304                         if( LOG_LV_DEBUG == Logger::getLogLevel( LOG_CAT_L7VSADM_COMMON ) ){
2305                                 std::stringstream       debugstr;
2306                                 debugstr << boost::format( "l7vsadm_recv_response:%s" ) % response;
2307                                 Logger::putLogDebug( LOG_CAT_L7VSADM_COMMON, 40, debugstr.str(), __FILE__, __LINE__ );
2308                         }
2309                         /*------ DEBUG LOG END ------*/
2310
2311                         // close socket
2312                         s.close();
2313
2314                         // display result
2315                         if( l7vsd_response::RESPONSE_OK == response.status ){
2316                                 disp_result_map_type::iterator  itr = disp_result_dic.find( request.command );
2317                                 if( itr != disp_result_dic.end() )
2318                                         itr->second();
2319                         }
2320                         else{
2321                                 std::stringstream       buf;
2322                                 response_error_message_map_type::iterator       itr = response_error_message_dic.find( response.status );
2323                                 if( itr != response_error_message_dic.end() )
2324                                         buf << itr->second << response.message;
2325                                 else
2326                                         buf << "COMMAND ERROR : " << response.message;
2327                                 std::cerr << buf.str() << std::endl;
2328                                 Logger::putLogError( LOG_CAT_L7VSADM_COMMON, 7, buf.str(), __FILE__, __LINE__ );
2329                                 return false;
2330                         }
2331                 }       //if help_mode
2332         }       //try
2333         catch( std::exception& e ){
2334                 std::stringstream       buf;
2335                 buf << "COMMON ERROR : " << e.what();
2336                 std::cerr << buf.str() << std::endl;
2337                 Logger::putLogError( LOG_CAT_L7VSADM_COMMON, 8, buf.str(), __FILE__, __LINE__ );
2338                 return false;
2339         }
2340         return true;
2341 }
2342
2343 //! argument dump for debug
2344 //! @param[in]  argument count
2345 //! @param[in]  argument value
2346 std::string     l7vs::l7vsadm::argument_debug_dump( int argc, char* argv[] ){
2347         std::stringstream buf;
2348         if( !argv ){
2349                 buf << "argument=(null)";
2350         }
2351         else{
2352                 buf << boost::format( "argument={argc=%d: " ) % argc;
2353                 for( int i = 0; i < argc; ++i){
2354                         buf << boost::format( "argv[%d]=%s: " ) % i % argv[i];
2355                 }
2356                 buf << "}";
2357         }
2358         return buf.str();
2359 }
2360
2361 //! signal handler function
2362 //! @param[in]  signal
2363 static void sig_exit_handler( int sig ){
2364         received_sig = sig;
2365         signal_flag = true;
2366 }
2367
2368 //! set singal handler function
2369 //! @param[in]  signal
2370 //! @param[in]  handler function pointer
2371 //! @return             0/success, -1/fail
2372 static int set_sighandler( int sig, void ( *handler )( int ) ){
2373         struct  sigaction act;
2374         int             ret;
2375
2376         ret = sigaction( sig, NULL, &act );
2377         if( 0 > ret )   return ret;
2378
2379         act.sa_flags &= ~SA_RESETHAND;
2380         act.sa_handler = handler;
2381
2382         ret = sigaction( sig, &act, NULL );
2383         if( 0 > ret )   return ret;
2384
2385         return 0;
2386 }
2387
2388 //! set all singal handler function
2389 //! @return             0/success, -1/fail
2390 static int set_sighandlers() {
2391         int ret;
2392
2393 #define SET_SIGHANDLER(sig, handler)                            \
2394         do {                                                                                    \
2395                 ret = set_sighandler((sig), (handler));         \
2396                 if (ret < 0) {                                                          \
2397                         return ret;                                                             \
2398                 }                                                                                       \
2399         } while (0)
2400
2401         SET_SIGHANDLER( SIGHUP,         sig_exit_handler );
2402         SET_SIGHANDLER( SIGINT,         sig_exit_handler );
2403         SET_SIGHANDLER( SIGQUIT,        sig_exit_handler );
2404         SET_SIGHANDLER( SIGPIPE,        sig_exit_handler );
2405         SET_SIGHANDLER( SIGTERM,        sig_exit_handler );
2406         SET_SIGHANDLER( SIGUSR1,        sig_exit_handler );
2407         SET_SIGHANDLER( SIGUSR2,        sig_exit_handler );
2408
2409 #undef SET_SIGHANDLER
2410
2411     return 0;
2412 }
2413
2414 #ifndef UNIT_TEST
2415 int main( int argc, char* argv[] ){
2416         l7vs::Logger            logger;
2417         l7vs::Parameter         param;
2418         logger.loadConf();
2419
2420         l7vs::l7vsadm   adm;
2421         if( !adm.execute( argc, argv ) ){
2422                 return -1;
2423         }
2424         return 0;
2425 }
2426 #endif  //UNIT_TEST
2427