src/l7vsadm_main.c

   1 /*
   2  * @file  l7vsadm_main.c
   3  * @brief the main module of l7vsadm
   4  * @brief it interrupts command line option
   5  * @brief and communucate with l7vsd
   6  *
   7  * L7VSADM: Virtual Server Administration Program for L7vsd
   8  * Copyright (C) 2005  NTT COMWARE Corporation.
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  23  * 02110-1301 USA
  24  *
  25  **********************************************************************/
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <ctype.h>
  31 #include <signal.h>
  32 #include <sys/un.h>
  33 #include <sys/types.h>
  34 #include <sys/stat.h>
  35 #include <fcntl.h>
  36 #include <sys/file.h>
  37 #include <errno.h>
  38
  39 #include "l7vs.h"
  40 #include "l7vs_config.h"
  41 #include "l7vs_replication.h"
  42 #include "l7vs_module.h"
  43 #include "l7vs_service.h"
  44 #include "l7vs_dest.h"
  45 #include "l7vs_conn.h"
  46
  47 #include "l7vsadm.h"
  48
  49 //! Prototype of functions.
  50 static int parse_command(int argc, char *argv[]);
  51
  52 static int parse_option_list(int argc, char *argv[]);
  53 static int parse_option_vs(int argc, char *argv[]);
  54 static int parse_option_rs(int argc, char *argv[]);
  55 static int parse_option_replication(int argc, char *argv[]);
  56 static int parse_option_log(int argc, char *argv[]);
  57 static int parse_option_snmp(int argc, char *argv[]);
  58 static int parse_option_parameter(int argc, char *argv[]);
  59 static int parse_option_help(int argc, char *argv[]);
  60
  61 static int parse_endpoint(struct sockaddr_in *addr, const char *endpoint_str, int allow_inaddr_any);
  62 static int parse_digit(const char *digit_str);
  63 static long long parse_qos(const char *qos_str);
  64 static int parse_option_protomod(int argc, char *argv[], int m_idx_begin, int m_idx_end);
  65
  66 static int operate_list(void);
  67 static int operate_add_vs(void);
  68 static int operate_edit_vs(void);
  69 static int operate_del_vs(void);
  70 static int operate_flush_vs(void);
  71 static int operate_add_rs(void);
  72 static int operate_edit_rs(void);
  73 static int operate_del_rs(void);
  74 static int operate_replication(void);
  75 static int operate_log(void);
  76 static int operate_snmp(void);
  77 static int operate_parameter(void);
  78 static int operate_help(void);
  79
  80 static int list_replication_info(void);
  81 static int list_log_info(void);
  82 static int list_snmp_info(void);
  83
  84 static int get_vs(void *vs_buffer, int vs_bufsize);
  85 static int get_rs(struct l7vs_dest_arg *darg_buffer, int rs_num, struct l7vs_service_arg *sarg);
  86 static int list_vs(struct l7vs_service_arg *sarg);
  87 static int list_rs(struct l7vs_dest_arg *darg);
  88
  89 static char *get_endpoint_name(struct sockaddr_storage *addr);
  90
  91 static int create_socket(void);
  92 static void destroy_socket(void);
  93 static int communicate_to_l7vsd(struct l7vsadm_iov_data *iov_data);
  94 static int send_request(struct iovec *req_iov, int req_cnt);
  95 static int recv_response(struct iovec *rsp_iov, int rsp_cnt);
  96
  97 static void usage(FILE *fp);
  98
  99 static void set_parameter(void);
 100 static char *config_strerror(int rsp_code);
 101 static void sig_exit_handler(int sig);
 102 static int set_signal(void);
 103
 104 //! L7vsadm option data that has been parsed.
 105 static struct l7vsadm_option_data l7vsadm_option_data;
 106 static char tmp_endpoint_name[NI_MAXHOST + NI_MAXSERV + 2];
 107
 108 //! Table for command argument check.
 109 static struct l7vsadm_command_list l7vsadm_command_table[] = {
 110         {CMD_LIST,         "-l", "--list",           parse_option_list,        operate_list},
 111         {CMD_LIST_VERBOSE, "-V", "--verbose",        parse_option_list,        operate_list},
 112         {CMD_LIST_KEY,     "-K", "--key",            parse_option_list,        operate_list},
 113         {CMD_ADD_VS,       "-A", "--add-service",    parse_option_vs,          operate_add_vs},
 114         {CMD_DEL_VS,       "-D", "--delete-service", parse_option_vs,          operate_del_vs},
 115         {CMD_EDIT_VS,      "-E", "--edit-service",   parse_option_vs,          operate_edit_vs},
 116         {CMD_FLUSH_VS,     "-C", "--flush",          parse_option_vs,          operate_flush_vs},
 117         {CMD_ADD_RS,       "-a", "--add-server",     parse_option_rs,          operate_add_rs},
 118         {CMD_DEL_RS,       "-d", "--delete-server",  parse_option_rs,          operate_del_rs},
 119         {CMD_EDIT_RS,      "-e", "--edit-server",    parse_option_rs,          operate_edit_rs},
 120         {CMD_REPLICATION,  "-R", "--replication",    parse_option_replication, operate_replication},
 121         {CMD_LOG,          "-L", "--log",            parse_option_log,         operate_log},
 122         {CMD_SNMP,         "-S", "--snmp",           parse_option_snmp,        operate_snmp},
 123         {CMD_PARAMETER,    "-P", "--parameter",      parse_option_parameter,   operate_parameter},
 124         {CMD_HELP,         "-h", "--help",           parse_option_help,        operate_help},
 125         {CMD_NONE,         NULL, NULL,               NULL,                     NULL}
 126 };
 127
 128 //! Table for List command argument check.(optional argument)
 129 static struct l7vsadm_option_list l7vsadm_option_table_list[] = {
 130         {OPT_NUMERIC,           "-n",   "--numeric",            0},
 131         {OPT_NONE,              NULL,   NULL,                   0}
 132 };
 133
 134 //! Table for VirtualService command argument check.(optional argument)
 135 static struct l7vsadm_option_list l7vsadm_option_table_vs[] = {
 136         {OPT_SCHEDULER,         "-s",   "--scheduler",          0},
 137         {OPT_UPPER,             "-u",   "--upper",              0},
 138         {OPT_BYPASS,            "-b",   "--bypass",             0},
 139         {OPT_FLAG,              "-f",   "--flag",               0},
 140         {OPT_QOS_UP,    "-Q",   "--qos-up",     0},
 141         {OPT_QOS_DOWN,  "-q",   "--qos-down",   0},
 142         {OPT_NONE,              NULL,   NULL,                   0}
 143 };
 144
 145 //! Table for RealServer command argument check.(optional argument)
 146 static struct l7vsadm_option_list l7vsadm_option_table_rs[] = {
 147         {OPT_WEIGHT,            "-w",   "--weight",             0},
 148         {OPT_NONE,              NULL,   NULL,                   0}
 149 };
 150
 151 //! Table for Replication command argument check.
 152 static struct l7vsadm_option_list l7vsadm_option_table_replication[] = {
 153         {OPT_SWITCH,            "-s",   "--switch",             0},
 154         {OPT_FORCE,             "-f",   "--force",              0},
 155         {OPT_DUMP,              "-d",   "--dump",               0},
 156         {OPT_NONE,              NULL,   NULL,                   0}
 157 };
 158
 159 //! Table for Logger command argument check.
 160 static struct l7vsadm_option_list l7vsadm_option_table_log[] = {
 161         {OPT_CATEGORY,          "-c",   "--category",           0},
 162         {OPT_LEVEL,             "-l",   "--level",              0},
 163         {OPT_NONE,              NULL,   NULL,                   0}
 164 };
 165
 166 //! Table for SNMPAgent command argument check.
 167 static struct l7vsadm_option_list l7vsadm_option_table_snmp[] = {
 168         {OPT_CATEGORY,          "-c",   "--category",           0},
 169         {OPT_LEVEL,             "-l",   "--level",              0},
 170         {OPT_NONE,              NULL,   NULL,                   0}
 171 };
 172
 173 //! Table for Parameter command argument check.
 174 static struct l7vsadm_option_list l7vsadm_option_table_parameter[] = {
 175         {OPT_RELOAD,            "-r",   "--reload",             0},
 176         {OPT_NONE,              NULL,   NULL,                   0}
 177 };
 178
 179 //! Table for L7vsd Log-Category string check.
 180 static struct l7vsadm_category_name_list l7vsd_category_name_table[] = {
 181         {LOG_CAT_L7VSD_NETWORK,                 "l7vsd_network",                "nw"},
 182         {LOG_CAT_L7VSD_NETWORK_BANDWIDTH,       "l7vsd_network.bandwidth",      "nw.bw"},
 183         {LOG_CAT_L7VSD_NETWORK_NUM_CONNECTION,  "l7vsd_network.num_connection", "nw.conn"},
 184         {LOG_CAT_L7VSD_NETWORK_QOS,             "l7vsd_network.qos",            "nw.qos"},
 185         {LOG_CAT_L7VSD_VIRTUAL_SERVICE,         "l7vsd_virtual_service",        "vs"},
 186         {LOG_CAT_L7VSD_REAL_SERVER,             "l7vsd_real_server",            "rs"},
 187         {LOG_CAT_L7VSD_SORRY_SERVER,            "l7vsd_sorry_server",           "sorry"},
 188         {LOG_CAT_L7VSD_REAL_SERVER_BALANCING,   "l7vsd_real_server.balancing",  "rs.bal"},
 189         {LOG_CAT_L7VSD_REPLICATION,             "l7vsd_replication",            "rep"},
 190         {LOG_CAT_L7VSD_START_STOP,              "l7vsd_start_stop",             "stastp"},
 191         {LOG_CAT_L7VSD_SYSTEM,                  "l7vsd_system",                 "sys"},
 192         {LOG_CAT_L7VSD_SYSTEM_MEMORY,           "l7vsd_system.memory",          "sys.mem"},
 193         {LOG_CAT_L7VSD_SYSTEM_SOCKET,           "l7vsd_system.socket",          "sys.sock"},
 194         {LOG_CAT_L7VSD_SYSTEM_SIGNAL,           "l7vsd_system.signal",          "sys.sig"},
 195         {LOG_CAT_L7VSD_ENVIRONMENT,             "l7vsd_environment",            "env"},
 196         {LOG_CAT_L7VSD_ENVIRONMENT_PARAMETER,   "l7vsd_environment.parameter",  "env.para"},
 197         {LOG_CAT_L7VSD_LOGGER,                  "l7vsd_logger",                 "logger"},
 198         {LOG_CAT_L7VSD_PARAMETER,               "l7vsd_parameter",              "para"},
 199         {LOG_CAT_L7VSD_EVENT,                   "l7vsd_event",                  "event"},
 200         {LOG_CAT_L7VSD_SCHEDULE,                "l7vsd_schedule",               "sched"},
 201         {LOG_CAT_L7VSD_PROGRAM,                 "l7vsd_program",                "prog"},
 202         {LOG_CAT_L7VSD_PROTOCOL,                "l7vsd_protocol",               "prot"},
 203         {LOG_CAT_L7VSD_MODULE,                  "l7vsd_module",                 "mod"},
 204         {(enum LOG_CATEGORY_TAG)0,              NULL,                           NULL}
 205 };
 206
 207 //! Table for SNMPAgent Log-Category string check.
 208 static struct l7vsadm_category_name_list snmp_category_name_table[] = {
 209         {LOG_CAT_SNMPAGENT_START_STOP,          "snmpagent_start_stop",         "snmp_stastp"},
 210         {LOG_CAT_SNMPAGENT_MANAGER_RECEIVE,     "snmpagent_manager_receive",    "snmp_mngrcv"},
 211         {LOG_CAT_SNMPAGENT_MANAGER_SEND,        "snmpagent_manager_send",       "snmp_mngsnd"},
 212         {LOG_CAT_SNMPAGENT_L7VSD_RECEIVE,       "snmpagent_l7vsd_receive",      "snmp_vsdrcv"},
 213         {LOG_CAT_SNMPAGENT_L7VSD_SEND,          "snmpagent_l7vsd_send",         "snmp_vsdsnd"},
 214         {LOG_CAT_SNMPAGENT_LOGGER,              "snmpagent_logger",             "snmp_logger"},
 215         {LOG_CAT_SNMPAGENT_PARAMETER,           "snmpagent_parameter",          "snmp_para"},
 216         {(enum LOG_CATEGORY_TAG)0,              NULL,                           NULL}
 217 };
 218
 219 //! Table for Log-Level string check.
 220 static struct l7vsadm_level_name_list level_name_table[] = {
 221         {LOG_LV_DEBUG,  "debug"},
 222         {LOG_LV_INFO,   "info"},
 223         {LOG_LV_WARN,   "warn"},
 224         {LOG_LV_ERROR,  "error"},
 225         {LOG_LV_FATAL,  "fatal"},
 226         {LOG_LV_NONE,   NULL}
 227 };
 228
 229 //! Interval of l7vsadm command conflict check.
 230 static int command_wait_interval = L7VSADM_DEFAULT_WAIT_INTERVAL;
 231 //! Number of times of l7vsadm command conflict check.
 232 static int command_wait_count = L7VSADM_DEFAULT_WAIT_COUNT;
 233
 234 //! Interval of connected check to l7vsd.
 235 static int connect_wait_interval = L7VSADM_DEFAULT_WAIT_INTERVAL;
 236 //! Number of times of connected check to l7vsd.
 237 static int connect_wait_count = L7VSADM_DEFAULT_WAIT_COUNT;
 238
 239 //! Log-Level of Parse-Category.
 240 static int log_level_parse;
 241 //! Log-Level of Operate-Category.
 242 static int log_level_operate;
 243 //! Log-Level of Communicate-Category.
 244 static int log_level_communicate;
 245 //! Log-Level of Config_Result-Category.
 246 static int log_level_config_result;
 247 //! Log-Level of Common-Category.
 248 static int log_level_common;
 249
 250 //! Received signal count.
 251 static int signal_flg = 0;
 252 //! Received signal number.
 253 static int received_sig = 0;
 254
 255 //! Local socket name.
 256 static char local_sockname[sizeof(L7VS_CONFIG_SOCK_PATH) + sizeof(L7VSADM_NAME) + 10];
 257 //! Local socket file discripter.
 258 static int local_sock_fd = -1;
 259
 260 /*!
 261  * Parse command option.
 262  * Check 1st argment
 263  * @param[in]   argc    number of argument
 264  * @param[in]   *argv[] array of argument string
 265  * @retval      0       parse result OK
 266  * @retval      -1      parse result NG
 267  */
 268 static int
 269 parse_command(int argc, char *argv[])
 270 {
 271         struct l7vsadm_command_list *list;
 272
 273         /*-------- DEBUG LOG --------*/
 274         if (log_level_parse == LOG_LV_DEBUG) {
 275                 char arg_str[DEBUG_STR_LEN] = {0};
 276                 argc_argv_c_str(arg_str, argc, argv);
 277                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,1,
 278                         "in_function : static int parse_command(int argc, char *argv[]) : "
 279                         "argc = %d, %s",
 280                         argc,
 281                         arg_str);
 282         }
 283         /*------ DEBUG LOG END ------*/
 284
 285         // Argument check.
 286         if (argc < 2) {
 287                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,1, "Argument argc is illegal.");
 288                 fprintf(stderr, "PARSE ERROR : Argument argc is illegal.\n");
 289
 290         /*-------- DEBUG LOG --------*/
 291         if (log_level_parse == LOG_LV_DEBUG) {
 292                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,2,
 293                         "out_function : static int parse_command(int argc, char *argv[]) : "
 294                         "return = -1");
 295         }
 296         /*------ DEBUG LOG END ------*/
 297
 298                 return -1;
 299         }
 300
 301         // Search command option on l7vsadm_command_table.
 302         l7vsadm_option_data.command_code = CMD_NONE;
 303         for (list = l7vsadm_command_table; list->command_name != NULL; list++) {
 304                 if (strcmp(argv[1], list->command_name) == 0 ||
 305                     strcmp(argv[1], list->command_name_long) == 0) {
 306                         l7vsadm_option_data.command_code = list->command_code;
 307                         l7vsadm_option_data.parse_func = list->parse_func;
 308                         l7vsadm_option_data.operate_func = list->operate_func;
 309                         break;
 310                 }
 311         }
 312         if (l7vsadm_option_data.command_code == CMD_NONE) {
 313                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,2,
 314                         "No such command option %s.", argv[1]);
 315                 fprintf(stderr, "PARSE ERROR : "
 316                         "No such command option %s.\n", argv[1]);
 317
 318         /*-------- DEBUG LOG --------*/
 319         if (log_level_parse == LOG_LV_DEBUG) {
 320                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,3,
 321                         "out_function : static int parse_command(int argc, char *argv[]) : "
 322                         "return = -1");
 323         }
 324         /*------ DEBUG LOG END ------*/
 325
 326                 return -1;
 327         }
 328
 329         /*-------- DEBUG LOG --------*/
 330         if (log_level_parse == LOG_LV_DEBUG) {
 331                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,4,
 332                         "out_function : static int parse_command(int argc, char *argv[]) : "
 333                         "return = 0 : result l7vsadm_option_data.command_code = %d",
 334                         l7vsadm_option_data.command_code);
 335         }
 336         /*------ DEBUG LOG END ------*/
 337
 338         return 0;
 339 }
 340
 341 /*!
 342  * Parse list command option.
 343  * Check 2nd argument and later of list command
 344  * @param[in]   argc    number of argument
 345  * @param[in]   *argv[] array of argument string
 346  * @return      int     parse result OK=0, NG=-1
 347  */
 348 static int
 349 parse_option_list(int argc, char *argv[])
 350 {
 351         struct l7vsadm_option_list *list;
 352         int idx;
 353         int match_option_f;
 354
 355         /*-------- DEBUG LOG --------*/
 356         if (log_level_parse == LOG_LV_DEBUG) {
 357                 char arg_str[DEBUG_STR_LEN] = {0};
 358                 argc_argv_c_str(arg_str, argc, argv);
 359                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,5,
 360                         "in_function : static int parse_option_list(int argc, char *argv[]) : "
 361                         "argc = %d, %s",
 362                         argc,
 363                         arg_str);
 364         }
 365         /*------ DEBUG LOG END ------*/
 366
 367         // Argument check.
 368         if (argc > 3) {
 369                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,3,
 370                         "Argument argc is illegal for %s command.", argv[1]);
 371                 fprintf(stderr, "PARSE ERROR : "
 372                         "Argument argc is illegal for %s command.\n", argv[1]);
 373
 374         /*-------- DEBUG LOG --------*/
 375         if (log_level_parse == LOG_LV_DEBUG) {
 376                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,6,
 377                         "out_function : static int "
 378                         "parse_option_list(int argc, char *argv[]) : "
 379                         "return = -1");
 380         }
 381         /*------ DEBUG LOG END ------*/
 382
 383                 return -1;
 384         }
 385         idx = 2;
 386         while (idx < argc) {
 387                 match_option_f = 0;
 388                 // Search optional option on l7vsadm_option_table_list.
 389                 for (list = l7vsadm_option_table_list; list->option_name != NULL; list++) {
 390                         if (strcmp(argv[idx], list->option_name) == 0 ||
 391                             strcmp(argv[idx], list->option_name_long) == 0) {
 392                                 match_option_f = 1;
 393                                 // Set each option value.
 394                                 switch (list->option_code) {
 395                                 case OPT_NUMERIC:
 396                                         l7vsadm_option_data.isnumeric = 1;
 397                                         break;
 398                                 default:
 399                                         break;
 400                                 }
 401                         }
 402                 }
 403                 if (!match_option_f) {
 404                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,4,
 405                                 "Invalid option for %s command.", argv[1]);
 406                         fprintf(stderr, "PARSE ERROR : "
 407                                 "Invalid option for %s command.\n", argv[1]);
 408
 409                 /*-------- DEBUG LOG --------*/
 410                 if (log_level_parse == LOG_LV_DEBUG) {
 411                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,7,
 412                                 "out_function : static int "
 413                                 "parse_option_list(int argc, char *argv[]) : "
 414                                 "return = -1");
 415                 }
 416                 /*------ DEBUG LOG END ------*/
 417
 418                         return -1;
 419                 }
 420                 idx++;
 421         }
 422
 423         /*-------- DEBUG LOG --------*/
 424         if (log_level_parse == LOG_LV_DEBUG) {
 425                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,8,
 426                         "out_function : static int parse_option_list(int argc, char *argv[]) : "
 427                         "return = 0 : result l7vsadm_option_data.isnumeric = %d",
 428                         l7vsadm_option_data.isnumeric);
 429         }
 430         /*------ DEBUG LOG END ------*/
 431
 432         return 0;
 433 }
 434
 435 /*!
 436  * Parse virtual service command option.
 437  * Check 2nd argument and later of vs command
 438  * @param[in]   argc    number of argument
 439  * @param[in]   *argv[] array of argument string
 440  * @return      int     parse result OK=0, NG=-1
 441  */
 442 static int
 443 parse_option_vs(int argc, char *argv[])
 444 {
 445         struct l7vsadm_option_list *list;
 446         int idx;
 447         int ret;
 448         long long ret_ll;
 449         int m_idx_begin,m_idx_end;
 450         int break_f;
 451         int match_option_f;
 452
 453         /*-------- DEBUG LOG --------*/
 454         if (log_level_parse == LOG_LV_DEBUG) {
 455                 char arg_str[DEBUG_STR_LEN] = {0};
 456                 argc_argv_c_str(arg_str, argc, argv);
 457                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,9,
 458                         "in_function : static int parse_option_vs(int argc, char *argv[]) : "
 459                         "argc = %d, %s",
 460                         argc,
 461                         arg_str);
 462         }
 463         /*------ DEBUG LOG END ------*/
 464
 465         // Argument check for flush_vs command.
 466         if (l7vsadm_option_data.command_code == CMD_FLUSH_VS) {
 467                 if (argc != 2) {
 468                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,5,
 469                                 "Argument argc is illegal for -C command.");
 470                         fprintf(stderr, "PARSE ERROR : "
 471                                 "Argument argc is illegal for -C command.\n");
 472
 473                         /*-------- DEBUG LOG --------*/
 474                         if (log_level_parse == LOG_LV_DEBUG) {
 475                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,10,
 476                                         "out_function : static int "
 477                                         "parse_option_vs(int argc, char *argv[]) : "
 478                                         "return = -1");
 479                         }
 480                         /*------ DEBUG LOG END ------*/
 481
 482                         return -1;
 483                 }
 484
 485                 /*-------- DEBUG LOG --------*/
 486                 if (log_level_parse == LOG_LV_DEBUG) {
 487                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,11,
 488                                 "out_function : static int "
 489                                 "parse_option_vs(int argc, char *argv[]) : "
 490                                 "return = 0 : result -C");
 491                 }
 492                 /*------ DEBUG LOG END ------*/
 493
 494                 return 0;
 495         }
 496
 497         // Argument check for add_vs/edit_vs/delete_vs command.
 498         if (argc < 6) {
 499                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,6,
 500                         "Argument argc is illegal for (%s) command.", argv[1]);
 501                 fprintf(stderr, "PARSE ERROR : "
 502                         "Argument argc is illegal for (%s) command.\n", argv[1]);
 503
 504                 /*-------- DEBUG LOG --------*/
 505                 if (log_level_parse == LOG_LV_DEBUG) {
 506                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,12,
 507                                 "out_function : static int "
 508                                 "parse_option_vs(int argc, char *argv[]) : "
 509                                 "return = -1");
 510                 }
 511                 /*------ DEBUG LOG END ------*/
 512
 513                 return -1;
 514         }
 515         idx = 2;
 516         if (strcmp(argv[idx], "-t") == 0 || strcmp(argv[idx], "--tcp-service") == 0) {
 517                 idx++;
 518                 ret = parse_endpoint(&l7vsadm_option_data.vs_addr,
 519                                      argv[idx], TRUE);
 520                 if (ret < 0) {
 521                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,7,
 522                                 "Parse VirtualService endpoint error.");
 523
 524                 /*-------- DEBUG LOG --------*/
 525                 if (log_level_parse == LOG_LV_DEBUG) {
 526                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,13,
 527                                 "out_function : static int "
 528                                 "parse_option_vs(int argc, char *argv[]) : "
 529                                 "return = -1");
 530                 }
 531                 /*------ DEBUG LOG END ------*/
 532
 533                         return -1;
 534                 }
 535                 idx++;
 536         } else {
 537                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,8,
 538                         "Invalid option %s. Need -t option for %s command.",
 539                         argv[idx],
 540                         argv[1]);
 541                 fprintf(stderr, "PARSE ERROR : "
 542                         "Invalid option %s. Need -t option for %s command.\n",
 543                         argv[idx],
 544                         argv[1]);
 545
 546                 /*-------- DEBUG LOG --------*/
 547                 if (log_level_parse == LOG_LV_DEBUG) {
 548                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,14,
 549                                 "out_function : static int "
 550                                 "parse_option_vs(int argc, char *argv[]) : "
 551                                 "return = -1");
 552                 }
 553                 /*------ DEBUG LOG END ------*/
 554
 555                 return -1;
 556         }
 557
 558         if (strcmp(argv[idx], "-m") == 0 || strcmp(argv[idx], "--proto-module") == 0) {
 559                 idx++;
 560                 if (strlen(argv[idx]) >= L7VS_MODNAME_LEN - 1) {
 561                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,9,
 562                                 "ProtocolModule name too long. (max %d)", L7VS_MODNAME_LEN);
 563                         fprintf(stderr, "PARSE ERROR : "
 564                                 "ProtocolModule name too long. (max %d)\n", L7VS_MODNAME_LEN);
 565
 566                         /*-------- DEBUG LOG --------*/
 567                         if (log_level_parse == LOG_LV_DEBUG) {
 568                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,15,
 569                                         "out_function : static int "
 570                                         "parse_option_vs(int argc, char *argv[]) : "
 571                                         "return = -1");
 572                         }
 573                         /*------ DEBUG LOG END ------*/
 574
 575                         return -1;
 576                 }
 577                 strncpy(l7vsadm_option_data.protomod_name, argv[idx], strlen(argv[idx]));
 578                 idx++;
 579         } else {
 580                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,10,
 581                         "Invalid option %s. Need -m option for %s command.",
 582                         argv[idx],
 583                         argv[1]);
 584                 fprintf(stderr, "PARSE ERROR : "
 585                         "Invalid option %s. Need -m option for %s command.\n",
 586                         argv[idx],
 587                         argv[1]);
 588
 589                 /*-------- DEBUG LOG --------*/
 590                 if (log_level_parse == LOG_LV_DEBUG) {
 591                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,16,
 592                                 "out_function : static int "
 593                                 "parse_option_vs(int argc, char *argv[]) : "
 594                                 "return = -1");
 595                 }
 596                 /*------ DEBUG LOG END ------*/
 597
 598                 return -1;
 599         }
 600
 601         // Search begin and end of ProtocolModule option.
 602         m_idx_begin = idx;
 603         break_f = 0;
 604         while (idx < argc) {
 605                 // End of ProtocolModule option is next valid option or end of argument.
 606                 for (list = l7vsadm_option_table_vs; list->option_name != NULL; list++) {
 607                         if (strcmp(argv[idx], list->option_name) == 0 ||
 608                             strcmp(argv[idx], list->option_name_long) == 0) {
 609                                 break_f = 1;
 610                                 break;
 611                         }
 612                 }
 613                 if (break_f) {
 614                         break;
 615                 }
 616                 idx++;
 617         }
 618         m_idx_end = idx;
 619         ret = parse_option_protomod(argc, argv, m_idx_begin, m_idx_end);
 620         if (ret < 0) {
 621                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,11,
 622                         "Parse ProtocolModule option error.");
 623
 624                 /*-------- DEBUG LOG --------*/
 625                 if (log_level_parse == LOG_LV_DEBUG) {
 626                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,17,
 627                                 "out_function : static int "
 628                                 "parse_option_vs(int argc, char *argv[]) : "
 629                                 "return = -1");
 630                 }
 631                 /*------ DEBUG LOG END ------*/
 632
 633                 return -1;
 634         }
 635
 636         // Argument check for delete_vs command.
 637         if (l7vsadm_option_data.command_code == CMD_DEL_VS) {
 638                 if (idx < argc) {
 639                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,12,
 640                                 "Argument argc is illegal for -D command.");
 641                         fprintf(stderr, "PARSE ERROR : "
 642                                 "Argument argc is illegal for -D command.\n");
 643
 644                         /*-------- DEBUG LOG --------*/
 645                         if (log_level_parse == LOG_LV_DEBUG) {
 646                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,18,
 647                                         "out_function : static int "
 648                                         "parse_option_vs(int argc, char *argv[]) : "
 649                                         "return = -1");
 650                         }
 651                         /*------ DEBUG LOG END ------*/
 652
 653                         return -1;
 654                 }
 655
 656                 /*-------- DEBUG LOG --------*/
 657                 if (log_level_parse == LOG_LV_DEBUG) {
 658                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,19,
 659                                 "out_function : static int "
 660                                 "parse_option_vs(int argc, char *argv[]) : "
 661                                 "return = 0 : result -D");
 662                 }
 663                 /*------ DEBUG LOG END ------*/
 664
 665                 return 0;
 666         }
 667
 668         // Set default ScheduleModule "rr".
 669         strncpy(l7vsadm_option_data.schedmod_name,
 670                 L7VSADM_DEFAULT_SCHEDULER,
 671                 strlen(L7VSADM_DEFAULT_SCHEDULER));
 672
 673         while (idx < argc) {
 674                 match_option_f = 0;
 675                 // Search optional option on l7vsadm_option_table_vs.
 676                 for (list = l7vsadm_option_table_vs; list->option_name != NULL; list++) {
 677                         if (strcmp(argv[idx], list->option_name) == 0 ||
 678                             strcmp(argv[idx], list->option_name_long) == 0) {
 679                                 match_option_f = 1;
 680                                 if (list->check_flag) {
 681                                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,13,
 682                                                 "Option %s is conflict.",
 683                                                 argv[idx]);
 684                                         fprintf(stderr, "PARSE ERROR : "
 685                                                 "Option %s is conflict.\n",
 686                                                 argv[idx]);
 687
 688                                         /*-------- DEBUG LOG --------*/
 689                                         if (log_level_parse == LOG_LV_DEBUG) {
 690                                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,20,
 691                                                         "out_function : static int "
 692                                                         "parse_option_vs(int argc, char *argv[]) : "
 693                                                         "return = -1");
 694                                         }
 695                                         /*------ DEBUG LOG END ------*/
 696
 697                                         return -1;
 698                                 }
 699                                 list->check_flag = 1;
 700                                 // Check and Set each option value.
 701                                 switch (list->option_code) {
 702                                 case OPT_SCHEDULER:
 703                                         idx++;
 704                                         if (idx >= argc) {
 705                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,14,
 706                                                         "Need option value for -s option.");
 707                                                 fprintf(stderr, "PARSE ERROR : "
 708                                                         "Need option value for -s option.\n");
 709
 710                                                 /*-------- DEBUG LOG --------*/
 711                                                 if (log_level_parse == LOG_LV_DEBUG) {
 712                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,21,
 713                                                                 "out_function : static int "
 714                                                                 "parse_option_vs(int argc, char *argv[]) : "
 715                                                                 "return = -1");
 716                                                 }
 717                                                 /*------ DEBUG LOG END ------*/
 718
 719                                                 return -1;
 720                                         }
 721                                         if (strlen(argv[idx]) >= L7VS_MODNAME_LEN - 1) {
 722                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,15,
 723                                                         "ScheduleModule name too long. (max %d)",
 724                                                         L7VS_MODNAME_LEN);
 725                                                 fprintf(stderr, "PARSE ERROR : "
 726                                                         "ScheduleModule name too long. (max %d)\n",
 727                                                         L7VS_MODNAME_LEN);
 728
 729                                                 /*-------- DEBUG LOG --------*/
 730                                                 if (log_level_parse == LOG_LV_DEBUG) {
 731                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,22,
 732                                                                 "out_function : static int "
 733                                                                 "parse_option_vs(int argc, char *argv[]) : "
 734                                                                 "return = -1");
 735                                                 }
 736                                                 /*------ DEBUG LOG END ------*/
 737
 738                                                 return -1;
 739                                         }
 740                                         strncpy(l7vsadm_option_data.schedmod_name,
 741                                                 argv[idx],
 742                                                 strlen(argv[idx]));
 743                                         break;
 744                                 case OPT_UPPER:
 745                                         idx++;
 746                                         if (idx >= argc) {
 747                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,16,
 748                                                         "Need option value for -u option.");
 749                                                 fprintf(stderr, "PARSE ERROR : "
 750                                                         "Need option value for -u option.\n");
 751
 752                                                 /*-------- DEBUG LOG --------*/
 753                                                 if (log_level_parse == LOG_LV_DEBUG) {
 754                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,23,
 755                                                                 "out_function : static int "
 756                                                                 "parse_option_vs(int argc, char *argv[]) : "
 757                                                                 "return = -1");
 758                                                 }
 759                                                 /*------ DEBUG LOG END ------*/
 760
 761                                                 return -1;
 762                                         }
 763                                         ret = parse_digit(argv[idx]);
 764                                         if (ret < 0) {
 765                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,17,
 766                                                         "-u option value is only digit.");
 767                                                 return -1;
 768                                         }
 769                                         sscanf(argv[idx], "%d", &l7vsadm_option_data.max_connection);
 770                                         if (l7vsadm_option_data.max_connection < 0 ||
 771                                             l7vsadm_option_data.max_connection > 100000) {
 772                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,18,
 773                                                         "Invalid option value for -u option.");
 774                                                 fprintf(stderr, "PARSE ERROR : "
 775                                                         "Invalid option value for -u option.\n");
 776
 777                                                 /*-------- DEBUG LOG --------*/
 778                                                 if (log_level_parse == LOG_LV_DEBUG) {
 779                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,24,
 780                                                                 "out_function : static int "
 781                                                                 "parse_option_vs(int argc, char *argv[]) : "
 782                                                                 "return = -1");
 783                                                 }
 784                                                 /*------ DEBUG LOG END ------*/
 785
 786                                                 return -1;
 787                                         }
 788                                         break;
 789                                 case OPT_BYPASS:
 790                                         idx++;
 791                                         if (idx >= argc) {
 792                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,19,
 793                                                         "Need option value for -b option.");
 794                                                 fprintf(stderr, "PARSE ERROR : "
 795                                                         "Need option value for -b option.\n");
 796
 797                                                 /*-------- DEBUG LOG --------*/
 798                                                 if (log_level_parse == LOG_LV_DEBUG) {
 799                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,25,
 800                                                                 "out_function : static int "
 801                                                                 "parse_option_vs(int argc, char *argv[]) : "
 802                                                                 "return = -1");
 803                                                 }
 804                                                 /*------ DEBUG LOG END ------*/
 805
 806                                                 return -1;
 807                                         }
 808                                         // When specify the initialization of the sorry endpoint.
 809                                         if (strncmp(L7VSADM_INIT_ENDPOINT_STR, argv[idx],
 810                                             strlen(L7VSADM_INIT_ENDPOINT_STR)) == 0) {
 811                                                 // Sorry endpoint is 0 clear data.
 812                                                 break;
 813                                         }
 814                                         ret = parse_endpoint(
 815                                                 (struct sockaddr_in *)(&l7vsadm_option_data.sorry_addr),
 816                                                 argv[idx], FALSE);
 817                                         if (ret < 0) {
 818                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,20,
 819                                                         "Parse SorryServer endpoint error.");
 820
 821                                                 /*-------- DEBUG LOG --------*/
 822                                                 if (log_level_parse == LOG_LV_DEBUG) {
 823                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,26,
 824                                                                 "out_function : static int "
 825                                                                 "parse_option_vs(int argc, char *argv[]) : "
 826                                                                 "return = -1");
 827                                                 }
 828                                                 /*------ DEBUG LOG END ------*/
 829
 830                                                 return -1;
 831                                         }
 832                                         break;
 833                                 case OPT_FLAG:
 834                                         idx++;
 835                                         if (idx >= argc) {
 836                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,21,
 837                                                         "Need option value for -f option.");
 838                                                 fprintf(stderr, "PARSE ERROR : "
 839                                                         "Need option value for -f option.\n");
 840
 841                                                 /*-------- DEBUG LOG --------*/
 842                                                 if (log_level_parse == LOG_LV_DEBUG) {
 843                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,27,
 844                                                                 "out_function : static int "
 845                                                                 "parse_option_vs(int argc, char *argv[]) : "
 846                                                                 "return = -1");
 847                                                 }
 848                                                 /*------ DEBUG LOG END ------*/
 849
 850                                                 return -1;
 851                                         }
 852                                         ret = parse_digit(argv[idx]);
 853                                         if (ret < 0) {
 854                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,22,
 855                                                         "-f option value is only digit.");
 856
 857                                                 /*-------- DEBUG LOG --------*/
 858                                                 if (log_level_parse == LOG_LV_DEBUG) {
 859                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,28,
 860                                                                 "out_function : static int "
 861                                                                 "parse_option_vs(int argc, char *argv[]) : "
 862                                                                 "return = -1");
 863                                                 }
 864                                                 /*------ DEBUG LOG END ------*/
 865
 866                                                 return -1;
 867                                         }
 868                                         sscanf(argv[idx], "%d", &l7vsadm_option_data.sorry_flag);
 869                                         if (l7vsadm_option_data.sorry_flag < 0 ||
 870                                             l7vsadm_option_data.sorry_flag > 1) {
 871                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,23,
 872                                                         "Invalid option value for -f option.");
 873                                                 fprintf(stderr, "PARSE ERROR : "
 874                                                         "Invalid option value for -f option.\n");
 875
 876                                                 /*-------- DEBUG LOG --------*/
 877                                                 if (log_level_parse == LOG_LV_DEBUG) {
 878                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,29,
 879                                                                 "out_function : static int "
 880                                                                 "parse_option_vs(int argc, char *argv[]) : "
 881                                                                 "return = -1");
 882                                                 }
 883                                                 /*------ DEBUG LOG END ------*/
 884
 885                                                 return -1;
 886                                         }
 887                                         break;
 888                                 case OPT_QOS_UP:
 889                                         idx++;
 890                                         if (idx >= argc) {
 891                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,24,
 892                                                         "Need option value for -Q option.");
 893                                                 fprintf(stderr, "PARSE ERROR : "
 894                                                         "Need option value for -Q option.\n");
 895
 896                                                 /*-------- DEBUG LOG --------*/
 897                                                 if (log_level_parse == LOG_LV_DEBUG) {
 898                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,30,
 899                                                                 "out_function : static int "
 900                                                                 "parse_option_vs(int argc, char *argv[]) : "
 901                                                                 "return = -1");
 902                                                 }
 903                                                 /*------ DEBUG LOG END ------*/
 904
 905                                                 return -1;
 906                                         }
 907                                         ret_ll = parse_qos(argv[idx]);
 908                                         if (ret_ll < 0) {
 909                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,25,
 910                                                         "Parse QoS-up value error.");
 911
 912                                                 /*-------- DEBUG LOG --------*/
 913                                                 if (log_level_parse == LOG_LV_DEBUG) {
 914                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,31,
 915                                                                 "out_function : static int "
 916                                                                 "parse_option_vs(int argc, char *argv[]) : "
 917                                                                 "return = -1");
 918                                                 }
 919                                                 /*------ DEBUG LOG END ------*/
 920
 921                                                 return -1;
 922                                         }
 923                                         l7vsadm_option_data.qos_threshold_up = (unsigned long long)ret_ll;
 924                                         break;
 925                                 case OPT_QOS_DOWN:
 926                                         idx++;
 927                                         if (idx >= argc) {
 928                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,26,
 929                                                         "Need option value for -q option.");
 930                                                 fprintf(stderr, "PARSE ERROR : "
 931                                                         "Need option value for -q option.\n");
 932
 933                                                 /*-------- DEBUG LOG --------*/
 934                                                 if (log_level_parse == LOG_LV_DEBUG) {
 935                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,32,
 936                                                                 "out_function : static int "
 937                                                                 "parse_option_vs(int argc, char *argv[]) : "
 938                                                                 "return = -1");
 939                                                 }
 940                                                 /*------ DEBUG LOG END ------*/
 941
 942                                                 return -1;
 943                                         }
 944                                         ret_ll = parse_qos(argv[idx]);
 945                                         if (ret_ll < 0) {
 946                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,27,
 947                                                         "Parse QoS-down value error.");
 948
 949                                                 /*-------- DEBUG LOG --------*/
 950                                                 if (log_level_parse == LOG_LV_DEBUG) {
 951                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,33,
 952                                                                 "out_function : static int "
 953                                                                 "parse_option_vs(int argc, char *argv[]) : "
 954                                                                 "return = -1");
 955                                                 }
 956                                                 /*------ DEBUG LOG END ------*/
 957
 958                                                 return -1;
 959                                         }
 960                                         l7vsadm_option_data.qos_threshold_down = (unsigned long long)ret_ll;
 961                                         break;
 962                                 default:
 963                                         break;
 964                                 }
 965                                 break;
 966                         }
 967                 }
 968                 if (!match_option_f) {
 969                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,28,
 970                                 "Invalid option for %s command.", argv[1]);
 971                         fprintf(stderr, "PARSE ERROR : "
 972                                 "Invalid option for %s command.\n", argv[1]);
 973
 974                         /*-------- DEBUG LOG --------*/
 975                         if (log_level_parse == LOG_LV_DEBUG) {
 976                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,34,
 977                                         "out_function : static int "
 978                                         "parse_option_vs(int argc, char *argv[]) : "
 979                                         "return = -1");
 980                         }
 981                         /*------ DEBUG LOG END ------*/
 982
 983                         return -1;
 984                 }
 985                 idx++;
 986         }
 987
 988         /*-------- DEBUG LOG --------*/
 989         if (log_level_parse == LOG_LV_DEBUG) {
 990                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,35,
 991                         "out_function : static int "
 992                         "parse_option_vs(int argc, char *argv[]) : "
 993                         "return = 0 : result -A or -E");
 994         }
 995         /*------ DEBUG LOG END ------*/
 996
 997         return 0;
 998 }
 999
1000 /*!
1001  * Parse real server command option.
1002  * Check 2nd argument and later of rs command
1003  * @param[in]   argc    number of argument
1004  * @param[in]   *argv[] array of argument string
1005  * @return      int     parse result OK=0, NG=-1
1006  */
1007 static int
1008 parse_option_rs(int argc, char *argv[])
1009 {
1010         struct l7vsadm_option_list *list;
1011         int idx;
1012         int ret;
1013         int m_idx_begin,m_idx_end;
1014         int break_f;
1015         int match_option_f;
1016
1017         /*-------- DEBUG LOG --------*/
1018         if (log_level_parse == LOG_LV_DEBUG) {
1019                 char arg_str[DEBUG_STR_LEN] = {0};
1020                 argc_argv_c_str(arg_str, argc, argv);
1021                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,36,
1022                         "in_function : static int parse_option_rs(int argc, char *argv[]) : "
1023                         "argc = %d, %s",
1024                         argc,
1025                         arg_str);
1026         }
1027         /*------ DEBUG LOG END ------*/
1028
1029         // Argument check for add_rs/edit_rs/delete_rs command.
1030         if (argc < 8) {
1031                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,29,
1032                         "Argument argc is illegal for %s command.", argv[1]);
1033                 fprintf(stderr, "PARSE ERROR : "
1034                         "Argument argc is illegal for %s command.\n", argv[1]);
1035
1036                 /*-------- DEBUG LOG --------*/
1037                 if (log_level_parse == LOG_LV_DEBUG) {
1038                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,37,
1039                                 "out_function : static int "
1040                                 "parse_option_rs(int argc, char *argv[]) : "
1041                                 "return = -1");
1042                 }
1043                 /*------ DEBUG LOG END ------*/
1044
1045                 return -1;
1046         }
1047         idx = 2;
1048         if (strcmp(argv[idx], "-t") == 0 || strcmp(argv[idx], "--tcp-service") == 0) {
1049                 idx++;
1050                 ret = parse_endpoint(&l7vsadm_option_data.vs_addr,
1051                                      argv[idx], TRUE);
1052                 if (ret < 0) {
1053                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,30,
1054                                 "Parse VirtualService endpoint error.");
1055
1056                         /*-------- DEBUG LOG --------*/
1057                         if (log_level_parse == LOG_LV_DEBUG) {
1058                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,38,
1059                                         "out_function : static int "
1060                                         "parse_option_rs(int argc, char *argv[]) : "
1061                                         "return = -1");
1062                         }
1063                         /*------ DEBUG LOG END ------*/
1064
1065                         return -1;
1066                 }
1067                 idx++;
1068         } else {
1069                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,31,
1070                         "Invalid option %s. Need -t option for %s command.",
1071                         argv[idx],
1072                         argv[1]);
1073                 fprintf(stderr, "PARSE ERROR : "
1074                         "Invalid option %s. Need -t option for %s command.\n",
1075                         argv[idx],
1076                         argv[1]);
1077
1078                 /*-------- DEBUG LOG --------*/
1079                 if (log_level_parse == LOG_LV_DEBUG) {
1080                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,39,
1081                                 "out_function : static int "
1082                                 "parse_option_rs(int argc, char *argv[]) : "
1083                                 "return = -1");
1084                 }
1085                 /*------ DEBUG LOG END ------*/
1086
1087                 return -1;
1088         }
1089
1090         if (strcmp(argv[idx], "-m") == 0 || strcmp(argv[idx], "--proto-module") == 0) {
1091                 idx++;
1092                 if (strlen(argv[idx]) >= L7VS_MODNAME_LEN - 1) {
1093                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,32,
1094                                 "ProtocolModule name too long. (max %d)", L7VS_MODNAME_LEN);
1095                         fprintf(stderr, "PARSE ERROR : "
1096                                 "ProtocolModule name too long. (max %d)\n", L7VS_MODNAME_LEN);
1097
1098                         /*-------- DEBUG LOG --------*/
1099                         if (log_level_parse == LOG_LV_DEBUG) {
1100                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,40,
1101                                         "out_function : static int "
1102                                         "parse_option_rs(int argc, char *argv[]) : "
1103                                         "return = -1");
1104                         }
1105                         /*------ DEBUG LOG END ------*/
1106
1107                         return -1;
1108                 }
1109                 strncpy(l7vsadm_option_data.protomod_name, argv[idx], strlen(argv[idx]));
1110                 idx++;
1111         } else {
1112                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,33,
1113                         "Invalid option %s. Need -m option for %s command.",
1114                         argv[idx],
1115                         argv[1]);
1116                 fprintf(stderr, "PARSE ERROR : "
1117                         "Invalid option %s. Need -m option for %s command.\n",
1118                         argv[idx],
1119                         argv[1]);
1120
1121                 /*-------- DEBUG LOG --------*/
1122                 if (log_level_parse == LOG_LV_DEBUG) {
1123                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,41,
1124                                 "out_function : static int "
1125                                 "parse_option_rs(int argc, char *argv[]) : "
1126                                 "return = -1");
1127                 }
1128                 /*------ DEBUG LOG END ------*/
1129
1130                 return -1;
1131         }
1132
1133         // Search begin and end of ProtocolModule option.
1134         m_idx_begin = idx;
1135         break_f = 0;
1136         while (idx < argc) {
1137                 // End of ProtocolModule option is -r option.
1138                 if (strcmp(argv[idx], "-r") == 0 || strcmp(argv[idx], "--real-server") == 0) {
1139                         break_f = 1;
1140                         break;
1141                 }
1142                 idx++;
1143         }
1144         if (!break_f) {
1145                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,34,
1146                         "Invalid option %s. Need -r option for %s command.",
1147                         argv[idx],
1148                         argv[1]);
1149                 fprintf(stderr, "PARSE ERROR : "
1150                         "Invalid option %s. Need -r option for %s command.\n",
1151                         argv[idx],
1152                         argv[1]);
1153
1154                 /*-------- DEBUG LOG --------*/
1155                 if (log_level_parse == LOG_LV_DEBUG) {
1156                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,42,
1157                                 "out_function : static int "
1158                                 "parse_option_rs(int argc, char *argv[]) : "
1159                                 "return = -1");
1160                 }
1161                 /*------ DEBUG LOG END ------*/
1162
1163                 return -1;
1164         }
1165         m_idx_end = idx;
1166         ret = parse_option_protomod(argc, argv, m_idx_begin, m_idx_end);
1167         if (ret < 0) {
1168                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,35,
1169                         "Parse ProtocolModule option error.");
1170
1171                 /*-------- DEBUG LOG --------*/
1172                 if (log_level_parse == LOG_LV_DEBUG) {
1173                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,43,
1174                                 "out_function : static int "
1175                                 "parse_option_rs(int argc, char *argv[]) : "
1176                                 "return = -1");
1177                 }
1178                 /*------ DEBUG LOG END ------*/
1179
1180                 return -1;
1181         }
1182
1183         idx++;
1184         ret = parse_endpoint(&l7vsadm_option_data.rs_addr, argv[idx], FALSE);
1185         if (ret < 0) {
1186                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,36,
1187                         "Parse RealServer endpoint error.");
1188
1189                 /*-------- DEBUG LOG --------*/
1190                 if (log_level_parse == LOG_LV_DEBUG) {
1191                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,44,
1192                                 "out_function : static int "
1193                                 "parse_option_rs(int argc, char *argv[]) : "
1194                                 "return = -1");
1195                 }
1196                 /*------ DEBUG LOG END ------*/
1197
1198                 return -1;
1199         }
1200         idx++;
1201
1202         // Argument check for delete_rs command.
1203         if (l7vsadm_option_data.command_code == CMD_DEL_RS) {
1204                 if (idx < argc) {
1205                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,37,
1206                                 "Argument argc is illegal for -d command.");
1207                         fprintf(stderr, "PARSE ERROR : "
1208                                 "Argument argc is illegal for -d command.\n");
1209
1210                         /*-------- DEBUG LOG --------*/
1211                         if (log_level_parse == LOG_LV_DEBUG) {
1212                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,45,
1213                                         "out_function : static int "
1214                                         "parse_option_rs(int argc, char *argv[]) : "
1215                                         "return = -1");
1216                         }
1217                         /*------ DEBUG LOG END ------*/
1218
1219                         return -1;
1220                 }
1221
1222                 /*-------- DEBUG LOG --------*/
1223                 if (log_level_parse == LOG_LV_DEBUG) {
1224                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,46,
1225                                 "out_function : static int "
1226                                 "parse_option_rs(int argc, char *argv[]) : "
1227                                 "return = 0 : result -d");
1228                 }
1229                 /*------ DEBUG LOG END ------*/
1230
1231                 return 0;
1232         }
1233
1234         // Set default RealServer weight = 1.
1235         l7vsadm_option_data.weight = 1;
1236
1237         while (idx < argc) {
1238                 match_option_f = 0;
1239                 // Search optional option on l7vsadm_option_table_rs.
1240                 for (list = l7vsadm_option_table_rs; list->option_name != NULL; list++) {
1241                         if (strcmp(argv[idx], list->option_name) == 0 ||
1242                             strcmp(argv[idx], list->option_name_long) == 0) {
1243                                 match_option_f = 1;
1244                                 if (list->check_flag) {
1245                                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,38,
1246                                                 "Option %s is conflict.",
1247                                                 argv[idx]);
1248                                         fprintf(stderr, "PARSE ERROR : "
1249                                                 "Option %s is conflict.\n",
1250                                                 argv[idx]);
1251
1252                                         /*-------- DEBUG LOG --------*/
1253                                         if (log_level_parse == LOG_LV_DEBUG) {
1254                                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,47,
1255                                                         "out_function : static int "
1256                                                         "parse_option_rs(int argc, char *argv[]) : "
1257                                                         "return = -1");
1258                                         }
1259                                         /*------ DEBUG LOG END ------*/
1260
1261                                         return -1;
1262                                 }
1263                                 list->check_flag = 1;
1264                                 // Check and Set each option value.
1265                                 switch (list->option_code) {
1266                                 case OPT_WEIGHT:
1267                                         idx++;
1268                                         if (idx >= argc) {
1269                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,39,
1270                                                         "Need option value for -w option.");
1271                                                 fprintf(stderr, "PARSE ERROR : "
1272                                                         "Need option value for -w option.\n");
1273
1274                                                 /*-------- DEBUG LOG --------*/
1275                                                 if (log_level_parse == LOG_LV_DEBUG) {
1276                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,48,
1277                                                                 "out_function : static int "
1278                                                                 "parse_option_rs(int argc, char *argv[]) : "
1279                                                                 "return = -1");
1280                                                 }
1281                                                 /*------ DEBUG LOG END ------*/
1282
1283                                                 return -1;
1284                                         }
1285                                         ret = parse_digit(argv[idx]);
1286                                         if (ret < 0) {
1287                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,40,
1288                                                         "-w option value is only digit.");
1289
1290                                                 /*-------- DEBUG LOG --------*/
1291                                                 if (log_level_parse == LOG_LV_DEBUG) {
1292                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,49,
1293                                                                 "out_function : static int "
1294                                                                 "parse_option_rs(int argc, char *argv[]) : "
1295                                                                 "return = -1");
1296                                                 }
1297                                                 /*------ DEBUG LOG END ------*/
1298
1299                                                 return -1;
1300                                         }
1301                                         sscanf(argv[idx], "%d", &l7vsadm_option_data.weight);
1302                                         if (l7vsadm_option_data.weight < 0 ||
1303                                             l7vsadm_option_data.weight > 100) {
1304                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,41,
1305                                                         "Invalid option value for -w option.");
1306                                                 fprintf(stderr, "PARSE ERROR : "
1307                                                         "Invalid option value for -w option.\n");
1308
1309                                                 /*-------- DEBUG LOG --------*/
1310                                                 if (log_level_parse == LOG_LV_DEBUG) {
1311                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,50,
1312                                                                 "out_function : static int "
1313                                                                 "parse_option_rs(int argc, char *argv[]) : "
1314                                                                 "return = -1");
1315                                                 }
1316                                                 /*------ DEBUG LOG END ------*/
1317
1318                                                 return -1;
1319                                         }
1320                                         break;
1321                                 default:
1322                                         break;
1323                                 }
1324                                 break;
1325                         }
1326                 }
1327                 if (!match_option_f) {
1328                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,42,
1329                                 "Invalid option for %s command.", argv[1]);
1330                         fprintf(stderr, "PARSE ERROR : "
1331                                 "Invalid option for %s command.\n", argv[1]);
1332
1333                         /*-------- DEBUG LOG --------*/
1334                         if (log_level_parse == LOG_LV_DEBUG) {
1335                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,51,
1336                                         "out_function : static int "
1337                                         "parse_option_rs(int argc, char *argv[]) : "
1338                                         "return = -1");
1339                         }
1340                         /*------ DEBUG LOG END ------*/
1341
1342                         return -1;
1343                 }
1344                 idx++;
1345         }
1346
1347         /*-------- DEBUG LOG --------*/
1348         if (log_level_parse == LOG_LV_DEBUG) {
1349                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,52,
1350                         "out_function : static int "
1351                         "parse_option_rs(int argc, char *argv[]) : "
1352                         "return = 0 : result -a or -e");
1353         }
1354         /*------ DEBUG LOG END ------*/
1355
1356         return 0;
1357 }
1358
1359 /*!
1360  * Parse replication command option.
1361  * Check 2nd argument and later of replication command
1362  * @param[in]   argc    number of argument
1363  * @param[in]   *argv[] array of argument string
1364  * @return      int     parse result OK=0, NG=-1
1365  */
1366 static int
1367 parse_option_replication(int argc, char *argv[])
1368 {
1369         struct l7vsadm_option_list *list;
1370         int idx;
1371         int match_option_f;
1372
1373         /*-------- DEBUG LOG --------*/
1374         if (log_level_parse == LOG_LV_DEBUG) {
1375                 char arg_str[DEBUG_STR_LEN] = {0};
1376                 argc_argv_c_str(arg_str, argc, argv);
1377                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,53,
1378                         "in_function : static int parse_option_replication(int argc, char *argv[]) : "
1379                         "argc = %d, %s",
1380                         argc,
1381                         arg_str);
1382         }
1383         /*------ DEBUG LOG END ------*/
1384
1385         // Argument check for replication command.
1386         if (argc < 3 || argc > 4) {
1387                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,43,
1388                         "Argument argc is illegal for -R command.");
1389                 fprintf(stderr, "PARSE ERROR : "
1390                         "Argument argc is illegal for -R command.\n");
1391
1392                 /*-------- DEBUG LOG --------*/
1393                 if (log_level_parse == LOG_LV_DEBUG) {
1394                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,54,
1395                                 "out_function : static int "
1396                                 "parse_option_replication(int argc, char *argv[]) : "
1397                                 "return = -1");
1398                 }
1399                 /*------ DEBUG LOG END ------*/
1400
1401                 return -1;
1402         }
1403         idx = 2;
1404         match_option_f = 0;
1405         // Search option on l7vsadm_option_table_replication.
1406         for (list = l7vsadm_option_table_replication; list->option_name != NULL; list++) {
1407                 if (strcmp(argv[idx], list->option_name) == 0 ||
1408                     strcmp(argv[idx], list->option_name_long) == 0) {
1409                         match_option_f = 1;
1410                         if (list->check_flag) {
1411                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,44,
1412                                         "Option %s is conflict.",
1413                                         argv[idx]);
1414                                 fprintf(stderr, "PARSE ERROR : "
1415                                         "Option %s is conflict.\n",
1416                                         argv[idx]);
1417
1418                         /*-------- DEBUG LOG --------*/
1419                         if (log_level_parse == LOG_LV_DEBUG) {
1420                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,55,
1421                                         "out_function : static int "
1422                                         "parse_option_replication(int argc, char *argv[]) : "
1423                                         "return = -1");
1424                         }
1425                         /*------ DEBUG LOG END ------*/
1426
1427                                 return -1;
1428                         }
1429                         list->check_flag = 1;
1430                         // Check and Set each option value.
1431                         switch (list->option_code) {
1432                         case OPT_SWITCH:
1433                                 idx++;
1434                                 if (idx >= argc) {
1435                                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,45,
1436                                                 "Need option value for -s option.");
1437                                         fprintf(stderr, "PARSE ERROR : "
1438                                                 "Need option value for -s option.\n");
1439
1440                                         /*-------- DEBUG LOG --------*/
1441                                         if (log_level_parse == LOG_LV_DEBUG) {
1442                                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,56,
1443                                                         "out_function : static int "
1444                                                         "parse_option_replication(int argc, char *argv[]) : "
1445                                                         "return = -1");
1446                                         }
1447                                         /*------ DEBUG LOG END ------*/
1448
1449                                         return -1;
1450                                 }
1451                                 l7vsadm_option_data.control_code = list->option_code;
1452                                 if (strcmp(argv[idx], "start") == 0) {
1453                                         l7vsadm_option_data.replication_start_flag = 1;
1454                                 } else if (strcmp(argv[idx], "stop") == 0) {
1455                                         l7vsadm_option_data.replication_start_flag = 0;
1456                                 } else {
1457                                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,46,
1458                                                 "Invalid option value for -s option.");
1459                                         fprintf(stderr, "PARSE ERROR : "
1460                                                 "Invalid option value for -s option.\n");
1461
1462                                         /*-------- DEBUG LOG --------*/
1463                                         if (log_level_parse == LOG_LV_DEBUG) {
1464                                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,57,
1465                                                         "out_function : static int "
1466                                                         "parse_option_replication(int argc, char *argv[]) : "
1467                                                         "return = -1");
1468                                         }
1469                                         /*------ DEBUG LOG END ------*/
1470
1471                                         return -1;
1472                                 }
1473                                 break;
1474                         case OPT_FORCE:
1475                                 if (idx + 1 < argc) {
1476                                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,47,
1477                                                 "-f option is no argument option.");
1478                                         fprintf(stderr, "PARSE ERROR : "
1479                                                 "-f option is no argument option.\n");
1480
1481                                         /*-------- DEBUG LOG --------*/
1482                                         if (log_level_parse == LOG_LV_DEBUG) {
1483                                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,58,
1484                                                         "out_function : static int "
1485                                                         "parse_option_replication(int argc, char *argv[]) : "
1486                                                         "return = -1");
1487                                         }
1488                                         /*------ DEBUG LOG END ------*/
1489
1490                                         return -1;
1491                                 }
1492                                 l7vsadm_option_data.control_code = list->option_code;
1493                                 break;
1494                         case OPT_DUMP:
1495                                 if (idx + 1 < argc) {
1496                                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,48,
1497                                                 "-d option is no argument option.");
1498                                         fprintf(stderr, "PARSE ERROR : "
1499                                                 "-d option is no argument option.\n");
1500
1501                                         /*-------- DEBUG LOG --------*/
1502                                         if (log_level_parse == LOG_LV_DEBUG) {
1503                                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,59,
1504                                                         "out_function : static int "
1505                                                         "parse_option_replication(int argc, char *argv[]) : "
1506                                                         "return = -1");
1507                                         }
1508                                         /*------ DEBUG LOG END ------*/
1509
1510                                         return -1;
1511                                 }
1512                                 l7vsadm_option_data.control_code = list->option_code;
1513                                 break;
1514                         default:
1515                                 break;
1516                         }
1517                         break;
1518                 }
1519         }
1520         if (!match_option_f) {
1521                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,49,
1522                         "Invalid option for -R command.");
1523                 fprintf(stderr, "PARSE ERROR : "
1524                         "Invalid option for -R command.\n");
1525
1526                 /*-------- DEBUG LOG --------*/
1527                 if (log_level_parse == LOG_LV_DEBUG) {
1528                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,60,
1529                                 "out_function : static int "
1530                                 "parse_option_replication(int argc, char *argv[]) : "
1531                                 "return = -1");
1532                 }
1533                 /*------ DEBUG LOG END ------*/
1534
1535                 return -1;
1536         }
1537
1538         /*-------- DEBUG LOG --------*/
1539         if (log_level_parse == LOG_LV_DEBUG) {
1540                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,61,
1541                         "out_function : static int "
1542                         "parse_option_replication(int argc, char *argv[]) : "
1543                         "return = 0 : result "
1544                         "l7vsadm_option_data.control_code = %d "
1545                         "l7vsadm_option_data.replication_start_flag = %d",
1546                         l7vsadm_option_data.control_code,
1547                         l7vsadm_option_data.replication_start_flag);
1548         }
1549         /*------ DEBUG LOG END ------*/
1550
1551         return 0;
1552 }
1553
1554 /*!
1555  * Parse logger command option.
1556  * Check 2nd argument and later of logger command
1557  * @param[in]   argc    number of argument
1558  * @param[in]   *argv[] array of argument string
1559  * @return      int     parse result OK=0, NG=-1
1560  */
1561 static int
1562 parse_option_log(int argc, char *argv[])
1563 {
1564         struct l7vsadm_option_list *op_list;
1565         struct l7vsadm_category_name_list *cat_list;
1566         struct l7vsadm_level_name_list *lv_list;
1567         int idx;
1568         int match_option_f;
1569         int match_value_f;
1570
1571         /*-------- DEBUG LOG --------*/
1572         if (log_level_parse == LOG_LV_DEBUG) {
1573                 char arg_str[DEBUG_STR_LEN] = {0};
1574                 argc_argv_c_str(arg_str, argc, argv);
1575                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,62,
1576                         "in_function : static int parse_option_log(int argc, char *argv[]) : "
1577                         "argc = %d, %s",
1578                         argc,
1579                         arg_str);
1580         }
1581         /*------ DEBUG LOG END ------*/
1582
1583         // Argument check for logger command.
1584         if (argc != 6) {
1585                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,50,
1586                         "Argument argc is illegal for -L command.");
1587                 fprintf(stderr, "PARSE ERROR : "
1588                         "Argument argc is illegal for -L command.\n");
1589
1590                 /*-------- DEBUG LOG --------*/
1591                 if (log_level_parse == LOG_LV_DEBUG) {
1592                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,63,
1593                                 "out_function : static int "
1594                                 "parse_option_log(int argc, char *argv[]) : "
1595                                 "return = -1");
1596                 }
1597                 /*------ DEBUG LOG END ------*/
1598
1599                 return -1;
1600         }
1601         idx = 2;
1602         while (idx < argc) {
1603                 match_option_f = 0;
1604                 // Search option on l7vsadm_option_table_log.
1605                 for (op_list = l7vsadm_option_table_log; op_list->option_name != NULL; op_list++) {
1606                         if (strcmp(argv[idx], op_list->option_name) == 0 ||
1607                             strcmp(argv[idx], op_list->option_name_long) == 0) {
1608                                 match_option_f = 1;
1609                                 if (op_list->check_flag) {
1610                                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,51,
1611                                                 "Option %s is conflict.",
1612                                                 argv[idx]);
1613                                         fprintf(stderr, "PARSE ERROR : "
1614                                                 "Option %s is conflict.\n",
1615                                                 argv[idx]);
1616
1617                                         /*-------- DEBUG LOG --------*/
1618                                         if (log_level_parse == LOG_LV_DEBUG) {
1619                                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,64,
1620                                                         "out_function : static int "
1621                                                         "parse_option_log(int argc, char *argv[]) : "
1622                                                         "return = -1");
1623                                         }
1624                                         /*------ DEBUG LOG END ------*/
1625
1626                                         return -1;
1627                                 }
1628                                 op_list->check_flag = 1;
1629                                 // Check and Set each option value.
1630                                 switch (op_list->option_code) {
1631                                 case OPT_CATEGORY:
1632                                         idx++;
1633                                         if (idx >= argc) {
1634                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,52,
1635                                                         "Need option value for -c option.");
1636                                                 fprintf(stderr, "PARSE ERROR : "
1637                                                         "Need option value for -c option.\n");
1638
1639                                                 /*-------- DEBUG LOG --------*/
1640                                                 if (log_level_parse == LOG_LV_DEBUG) {
1641                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,65,
1642                                                                 "out_function : static int "
1643                                                                 "parse_option_log(int argc, char *argv[]) : "
1644                                                                 "return = -1");
1645                                                 }
1646                                                 /*------ DEBUG LOG END ------*/
1647
1648                                                 return -1;
1649                                         }
1650                                         // Check option value "all".
1651                                         if (strcmp(argv[idx], "all") == 0) {
1652                                                 l7vsadm_option_data.category_all_flag = 1;
1653                                                 break;
1654                                         }
1655                                         match_value_f = 0;
1656                                         // Search category name on l7vsd_category_name_table
1657                                         // and Convert category name to category code.
1658                                         for (cat_list = l7vsd_category_name_table;
1659                                              cat_list->category_name != NULL;
1660                                              cat_list++) {
1661                                                 if (strcmp(argv[idx],
1662                                                            cat_list->category_name) == 0 ||
1663                                                     strcmp(argv[idx],
1664                                                            cat_list->category_name_short) == 0) {
1665                                                         l7vsadm_option_data.log_category =
1666                                                                 cat_list->category_code;
1667                                                         match_value_f = 1;
1668                                                         break;
1669                                                 }
1670                                         }
1671                                         if (!match_value_f) {
1672                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,53,
1673                                                         "No such Log-Category %s.", argv[idx]);
1674                                                 fprintf(stderr, "PARSE ERROR : "
1675                                                         "No such Log-Category %s.\n", argv[idx]);
1676
1677                                                 /*-------- DEBUG LOG --------*/
1678                                                 if (log_level_parse == LOG_LV_DEBUG) {
1679                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,66,
1680                                                                 "out_function : static int "
1681                                                                 "parse_option_log(int argc, char *argv[]) : "
1682                                                                 "return = -1");
1683                                                 }
1684                                                 /*------ DEBUG LOG END ------*/
1685
1686                                                 return -1;
1687                                         }
1688                                         break;
1689                                 case OPT_LEVEL:
1690                                         idx++;
1691                                         if (idx >= argc) {
1692                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,54,
1693                                                         "Need option value for -l option.");
1694                                                 fprintf(stderr, "PARSE ERROR : "
1695                                                         "Need option value for -l option.\n");
1696
1697                                                 /*-------- DEBUG LOG --------*/
1698                                                 if (log_level_parse == LOG_LV_DEBUG) {
1699                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,67,
1700                                                                 "out_function : static int "
1701                                                                 "parse_option_log(int argc, char *argv[]) : "
1702                                                                 "return = -1");
1703                                                 }
1704                                                 /*------ DEBUG LOG END ------*/
1705
1706                                                 return -1;
1707                                         }
1708                                         match_value_f = 0;
1709                                         // Search level name on level_name_table
1710                                         // and Convert level name to level code.
1711                                         for (lv_list = level_name_table;
1712                                              lv_list->level_name != NULL;
1713                                              lv_list++) {
1714                                                 if (strcmp(argv[idx], lv_list->level_name) == 0) {
1715                                                         l7vsadm_option_data.log_level =
1716                                                                 lv_list->level_code;
1717                                                         match_value_f = 1;
1718                                                         break;
1719                                                 }
1720                                         }
1721                                         if (!match_value_f) {
1722                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,55,
1723                                                         "No such Log-Level %s.", argv[idx]);
1724                                                 fprintf(stderr, "PARSE ERROR : "
1725                                                         "No such Log-Level %s.\n", argv[idx]);
1726
1727                                                 /*-------- DEBUG LOG --------*/
1728                                                 if (log_level_parse == LOG_LV_DEBUG) {
1729                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,68,
1730                                                                 "out_function : static int "
1731                                                                 "parse_option_log(int argc, char *argv[]) : "
1732                                                                 "return = -1");
1733                                                 }
1734                                                 /*------ DEBUG LOG END ------*/
1735
1736                                                 return -1;
1737                                         }
1738                                         break;
1739                                 default:
1740                                         break;
1741                                 }
1742                                 break;
1743                         }
1744                 }
1745                 if (!match_option_f) {
1746                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,56,
1747                                 "Invalid option for -L command.");
1748                         fprintf(stderr, "PARSE ERROR : "
1749                                 "Invalid option for -L command.\n");
1750
1751                         /*-------- DEBUG LOG --------*/
1752                         if (log_level_parse == LOG_LV_DEBUG) {
1753                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,69,
1754                                         "out_function : static int "
1755                                         "parse_option_log(int argc, char *argv[]) : "
1756                                         "return = -1");
1757                         }
1758                         /*------ DEBUG LOG END ------*/
1759
1760                         return -1;
1761                 }
1762                 idx++;
1763         }
1764
1765         /*-------- DEBUG LOG --------*/
1766         if (log_level_parse == LOG_LV_DEBUG) {
1767                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,70,
1768                         "out_function : static int "
1769                         "parse_option_log(int argc, char *argv[]) : "
1770                         "return = 0 : result "
1771                         "l7vsadm_option_data.category_all_flag = %d "
1772                         "l7vsadm_option_data.log_category = %d "
1773                         "l7vsadm_option_data.log_level = %d",
1774                         l7vsadm_option_data.category_all_flag,
1775                         l7vsadm_option_data.log_category,
1776                         l7vsadm_option_data.log_level);
1777         }
1778         /*------ DEBUG LOG END ------*/
1779
1780         return 0;
1781 }
1782
1783 /*!
1784  * Parse SNMPAgent command option.
1785  * Check 2nd argument and later of SNMPAgent command
1786  * @param[in]   argc    number of argument
1787  * @param[in]   *argv[] array of argument string
1788  * @return      int     parse result OK=0, NG=-1
1789  */
1790 static int
1791 parse_option_snmp(int argc, char *argv[])
1792 {
1793         struct l7vsadm_option_list *op_list;
1794         struct l7vsadm_category_name_list *cat_list;
1795         struct l7vsadm_level_name_list *lv_list;
1796         int idx;
1797         int match_option_f;
1798         int match_value_f;
1799
1800         /*-------- DEBUG LOG --------*/
1801         if (log_level_parse == LOG_LV_DEBUG) {
1802                 char arg_str[DEBUG_STR_LEN] = {0};
1803                 argc_argv_c_str(arg_str, argc, argv);
1804                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,71,
1805                         "in_function : static int parse_option_snmp(int argc, char *argv[]) : "
1806                         "argc = %d, %s",
1807                         argc,
1808                         arg_str);
1809         }
1810         /*------ DEBUG LOG END ------*/
1811
1812         // Argument check for SNMPAgent command.
1813         if (argc != 6) {
1814                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,57,
1815                         "Argument argc is illegal for -S command.");
1816                 fprintf(stderr, "PARSE ERROR : "
1817                         "Argument argc is illegal for -S command.\n");
1818
1819                 /*-------- DEBUG LOG --------*/
1820                 if (log_level_parse == LOG_LV_DEBUG) {
1821                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,72,
1822                                 "out_function : static int "
1823                                 "parse_option_snmp(int argc, char *argv[]) : "
1824                                 "return = -1");
1825                 }
1826                 /*------ DEBUG LOG END ------*/
1827
1828                 return -1;
1829         }
1830         idx = 2;
1831         while (idx < argc) {
1832                 match_option_f = 0;
1833                 // Search option on l7vsadm_option_table_snmp.
1834                 for (op_list = l7vsadm_option_table_snmp;
1835                      op_list->option_name != NULL;
1836                      op_list++) {
1837                         if (strcmp(argv[idx], op_list->option_name) == 0 ||
1838                             strcmp(argv[idx], op_list->option_name_long) == 0) {
1839                                 match_option_f = 1;
1840                                 if (op_list->check_flag) {
1841                                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,58,
1842                                                 "Option %s is conflict.",
1843                                                 argv[idx]);
1844                                         fprintf(stderr, "PARSE ERROR : "
1845                                                 "Option %s is conflict.\n",
1846                                                 argv[idx]);
1847
1848                                         /*-------- DEBUG LOG --------*/
1849                                         if (log_level_parse == LOG_LV_DEBUG) {
1850                                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,73,
1851                                                         "out_function : static int "
1852                                                         "parse_option_snmp(int argc, char *argv[]) : "
1853                                                         "return = -1");
1854                                         }
1855                                         /*------ DEBUG LOG END ------*/
1856
1857                                         return -1;
1858                                 }
1859                                 op_list->check_flag = 1;
1860                                 // Check and Set each option value.
1861                                 switch (op_list->option_code) {
1862                                 case OPT_CATEGORY:
1863                                         idx++;
1864                                         if (idx >= argc) {
1865                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,59,
1866                                                         "Need option value for -c option.");
1867                                                 fprintf(stderr, "PARSE ERROR : "
1868                                                         "Need option value for -c option.\n");
1869
1870                                                 /*-------- DEBUG LOG --------*/
1871                                                 if (log_level_parse == LOG_LV_DEBUG) {
1872                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,74,
1873                                                                 "out_function : static int "
1874                                                                 "parse_option_snmp(int argc, char *argv[]) : "
1875                                                                 "return = -1");
1876                                                 }
1877                                                 /*------ DEBUG LOG END ------*/
1878
1879                                                 return -1;
1880                                         }
1881                                         // Check option value "all".
1882                                         if (strcmp(argv[idx], "all") == 0) {
1883                                                 l7vsadm_option_data.category_all_flag = 1;
1884                                                 break;
1885                                         }
1886                                         match_value_f = 0;
1887                                         // Search category name on snmp_category_name_table
1888                                         // and Convert category name to category code.
1889                                         for (cat_list = snmp_category_name_table;
1890                                              cat_list->category_name != NULL;
1891                                              cat_list++) {
1892                                                 if (strcmp(argv[idx],
1893                                                            cat_list->category_name) == 0 ||
1894                                                     strcmp(argv[idx],
1895                                                            cat_list->category_name_short) == 0) {
1896                                                         l7vsadm_option_data.log_category =
1897                                                                 cat_list->category_code;
1898                                                         match_value_f = 1;
1899                                                         break;
1900                                                 }
1901                                         }
1902                                         if (!match_value_f) {
1903                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,60,
1904                                                         "No such Log-Category %s.", argv[idx]);
1905                                                 fprintf(stderr, "PARSE ERROR : "
1906                                                         "No such Log-Category %s.\n", argv[idx]);
1907
1908                                                 /*-------- DEBUG LOG --------*/
1909                                                 if (log_level_parse == LOG_LV_DEBUG) {
1910                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,75,
1911                                                                 "out_function : static int "
1912                                                                 "parse_option_snmp(int argc, char *argv[]) : "
1913                                                                 "return = -1");
1914                                                 }
1915                                                 /*------ DEBUG LOG END ------*/
1916
1917                                                 return -1;
1918                                         }
1919                                         break;
1920                                 case OPT_LEVEL:
1921                                         idx++;
1922                                         if (idx >= argc) {
1923                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,61,
1924                                                         "Need option value for -l option.");
1925                                                 fprintf(stderr, "PARSE ERROR : "
1926                                                         "Need option value for -l option.\n");
1927
1928                                                 /*-------- DEBUG LOG --------*/
1929                                                 if (log_level_parse == LOG_LV_DEBUG) {
1930                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,76,
1931                                                                 "out_function : static int "
1932                                                                 "parse_option_snmp(int argc, char *argv[]) : "
1933                                                                 "return = -1");
1934                                                 }
1935                                                 /*------ DEBUG LOG END ------*/
1936
1937                                                 return -1;
1938                                         }
1939                                         match_value_f = 0;
1940                                         // Search level name on level_name_table
1941                                         // and Convert level name to level code.
1942                                         for (lv_list = level_name_table;
1943                                              lv_list->level_name != NULL;
1944                                              lv_list++) {
1945                                                 if (strcmp(argv[idx],
1946                                                            lv_list->level_name) == 0) {
1947                                                         l7vsadm_option_data.log_level =
1948                                                                 lv_list->level_code;
1949                                                         match_value_f = 1;
1950                                                         break;
1951                                                 }
1952                                         }
1953                                         if (!match_value_f) {
1954                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,62,
1955                                                         "No such Log-Level %s.", argv[idx]);
1956                                                 fprintf(stderr, "PARSE ERROR : "
1957                                                         "No such Log-Level %s.\n", argv[idx]);
1958
1959                                                 /*-------- DEBUG LOG --------*/
1960                                                 if (log_level_parse == LOG_LV_DEBUG) {
1961                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,77,
1962                                                                 "out_function : static int "
1963                                                                 "parse_option_snmp(int argc, char *argv[]) : "
1964                                                                 "return = -1");
1965                                                 }
1966                                                 /*------ DEBUG LOG END ------*/
1967
1968                                                 return -1;
1969                                         }
1970                                         break;
1971                                 default:
1972                                         break;
1973                                 }
1974                                 break;
1975                         }
1976                 }
1977                 if (!match_option_f) {
1978                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,63,
1979                                 "Invalid option for -S command.");
1980                         fprintf(stderr, "PARSE ERROR : "
1981                                 "Invalid option for -S command.\n");
1982
1983                         /*-------- DEBUG LOG --------*/
1984                         if (log_level_parse == LOG_LV_DEBUG) {
1985                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,78,
1986                                         "out_function : static int "
1987                                         "parse_option_snmp(int argc, char *argv[]) : "
1988                                         "return = -1");
1989                         }
1990                         /*------ DEBUG LOG END ------*/
1991
1992                         return -1;
1993                 }
1994                 idx++;
1995         }
1996
1997         /*-------- DEBUG LOG --------*/
1998         if (log_level_parse == LOG_LV_DEBUG) {
1999                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,79,
2000                         "out_function : static int "
2001                         "parse_option_snmp(int argc, char *argv[]) : "
2002                         "return = 0 : result "
2003                         "l7vsadm_option_data.category_all_flag = %d "
2004                         "l7vsadm_option_data.log_category = %d "
2005                         "l7vsadm_option_data.log_level = %d",
2006                         l7vsadm_option_data.category_all_flag,
2007                         l7vsadm_option_data.log_category,
2008                         l7vsadm_option_data.log_level);
2009         }
2010         /*------ DEBUG LOG END ------*/
2011
2012         return 0;
2013 }
2014
2015 /*!
2016  * Parse parameter command option.
2017  * Check 2nd argument and later of parameter command
2018  * @param[in]   argc    number of argument
2019  * @param[in]   *argv[] array of argument string
2020  * @return      int     parse result OK=0, NG=-1
2021  */
2022 static int
2023 parse_option_parameter(int argc, char *argv[])
2024 {
2025         struct l7vsadm_option_list *op_list;
2026         static struct l7vsadm_component_name_list component_name_table[] = {
2027                 {PARAM_COMP_ALL,                        "all"},
2028                 {PARAM_COMP_L7VSD,                      "l7vsd"},
2029                 {PARAM_COMP_IOMUX,                      "iomux"},
2030                 {PARAM_COMP_LSOCK,                      "lsock"},
2031                 {PARAM_COMP_CONN,                       "conn"},
2032                 {PARAM_COMP_DEST,                       "dest"},
2033                 {PARAM_COMP_SERVICE,                    "service"},
2034                 {PARAM_COMP_MODULE,                     "module"},
2035                 {PARAM_COMP_REPLICATION,                "replication"},
2036                 {PARAM_COMP_LOGGER,                     "logger"},
2037                 {PARAM_COMP_L7VSADM,                    "l7vsadm"},
2038                 {PARAM_COMP_SNMPAGENT,                  "snmpagent"},
2039                 {(enum PARAMETER_COMPONENT_TAG)0,       NULL}
2040         };
2041         struct l7vsadm_component_name_list *cmp_list;
2042         int idx;
2043         int match_option_f;
2044         int match_value_f;
2045
2046         /*-------- DEBUG LOG --------*/
2047         if (log_level_parse == LOG_LV_DEBUG) {
2048                 char arg_str[DEBUG_STR_LEN] = {0};
2049                 argc_argv_c_str(arg_str, argc, argv);
2050                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,80,
2051                         "in_function : static int parse_option_parameter(int argc, char *argv[]) : "
2052                         "argc = %d, %s",
2053                         argc,
2054                         arg_str);
2055         }
2056         /*------ DEBUG LOG END ------*/
2057
2058         // Argument check for parameter command.
2059         if (argc != 4) {
2060                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,64,
2061                         "Argument argc is illegal for -P command.");
2062                 fprintf(stderr, "PARSE ERROR : "
2063                         "Argument argc is illegal for -P command.\n");
2064
2065                 /*-------- DEBUG LOG --------*/
2066                 if (log_level_parse == LOG_LV_DEBUG) {
2067                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,81,
2068                                 "out_function : static int "
2069                                 "parse_option_parameter(int argc, char *argv[]) : "
2070                                 "return = -1");
2071                 }
2072                 /*------ DEBUG LOG END ------*/
2073
2074                 return -1;
2075         }
2076         idx = 2;
2077         while (idx < argc) {
2078                 match_option_f = 0;
2079                 // Search option on l7vsadm_option_table_snmp.
2080                 for (op_list = l7vsadm_option_table_parameter;
2081                      op_list->option_name != NULL;
2082                      op_list++) {
2083                         if (strcmp(argv[idx], op_list->option_name) == 0 ||
2084                             strcmp(argv[idx], op_list->option_name_long) == 0) {
2085                                 match_option_f = 1;
2086                                 if (op_list->check_flag) {
2087                                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,65,
2088                                                 "Option %s is conflict.",
2089                                                 argv[idx]);
2090                                         fprintf(stderr, "PARSE ERROR : "
2091                                                 "Option %s is conflict.\n",
2092                                                 argv[idx]);
2093
2094                                         /*-------- DEBUG LOG --------*/
2095                                         if (log_level_parse == LOG_LV_DEBUG) {
2096                                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,82,
2097                                                         "out_function : static int "
2098                                                         "parse_option_parameter(int argc, char *argv[]) : "
2099                                                         "return = -1");
2100                                         }
2101                                         /*------ DEBUG LOG END ------*/
2102
2103                                         return -1;
2104                                 }
2105                                 op_list->check_flag = 1;
2106                                 // Check and Set each option value.
2107                                 switch (op_list->option_code) {
2108                                 case OPT_RELOAD:
2109                                         idx++;
2110                                         if (idx >= argc) {
2111                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,66,
2112                                                         "Need option value for -r option.");
2113                                                 fprintf(stderr, "PARSE ERROR : "
2114                                                         "Need option value for -r option.\n");
2115
2116                                                 /*-------- DEBUG LOG --------*/
2117                                                 if (log_level_parse == LOG_LV_DEBUG) {
2118                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,83,
2119                                                                 "out_function : static int "
2120                                                                 "parse_option_parameter("
2121                                                                 "int argc, char *argv[]) : "
2122                                                                 "return = -1");
2123                                                 }
2124                                                 /*------ DEBUG LOG END ------*/
2125
2126                                                 return -1;
2127                                         }
2128                                         match_value_f = 0;
2129                                         // Search component name on component_name_table
2130                                         // and Convert component name to component code.
2131                                         for (cmp_list = component_name_table;
2132                                              cmp_list->component_name != NULL;
2133                                              cmp_list++) {
2134                                                 if (strcmp(argv[idx],
2135                                                            cmp_list->component_name) == 0) {
2136                                                         l7vsadm_option_data.reload_param =
2137                                                                 cmp_list->component_code;
2138                                                         match_value_f = 1;
2139                                                         break;
2140                                                 }
2141                                         }
2142                                         if (!match_value_f) {
2143                                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,67,
2144                                                         "No such Component %s.", argv[idx]);
2145                                                 fprintf(stderr, "PARSE ERROR : "
2146                                                         "No such Component %s.\n", argv[idx]);
2147
2148                                                 /*-------- DEBUG LOG --------*/
2149                                                 if (log_level_parse == LOG_LV_DEBUG) {
2150                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,84,
2151                                                                 "out_function : static int "
2152                                                                 "parse_option_parameter("
2153                                                                 "int argc, char *argv[]) : "
2154                                                                 "return = -1");
2155                                                 }
2156                                                 /*------ DEBUG LOG END ------*/
2157
2158                                                 return -1;
2159                                         }
2160
2161                                         break;
2162                                 default:
2163                                         break;
2164                                 }
2165                                 break;
2166                         }
2167                 }
2168                 if (!match_option_f) {
2169                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,68,
2170                                 "Invalid option for -P command.");
2171                         fprintf(stderr, "PARSE ERROR : "
2172                                 "Invalid option for -P command.\n");
2173
2174                         /*-------- DEBUG LOG --------*/
2175                         if (log_level_parse == LOG_LV_DEBUG) {
2176                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,85,
2177                                         "out_function : static int "
2178                                         "parse_option_parameter(int argc, char *argv[]) : "
2179                                         "return = -1");
2180                         }
2181                         /*------ DEBUG LOG END ------*/
2182
2183                         return -1;
2184                 }
2185                 idx++;
2186         }
2187
2188         /*-------- DEBUG LOG --------*/
2189         if (log_level_parse == LOG_LV_DEBUG) {
2190                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,86,
2191                         "out_function : static int "
2192                         "parse_option_parameter(int argc, char *argv[]) : "
2193                         "return = 0 : result "
2194                         "l7vsadm_option_data.reload_param = %d",
2195                         l7vsadm_option_data.reload_param);
2196         }
2197         /*------ DEBUG LOG END ------*/
2198
2199         return 0;
2200 }
2201
2202 /*!
2203  * Parse help command option.
2204  * Check 2nd argument and later of help command
2205  * @param[in]   argc    number of argument
2206  * @param[in]   *argv[] array of argument string
2207  * @return      int     parse result OK=0, NG=-1
2208  */
2209 static int
2210 parse_option_help(int argc, char *argv[])
2211 {
2212         /*-------- DEBUG LOG --------*/
2213         if (log_level_parse == LOG_LV_DEBUG) {
2214                 char arg_str[DEBUG_STR_LEN] = {0};
2215                 argc_argv_c_str(arg_str, argc, argv);
2216                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,87,
2217                         "in_function : static int parse_option_help(int argc, char *argv[]) : "
2218                         "argc = %d, %s",
2219                         argc,
2220                         arg_str);
2221         }
2222         /*------ DEBUG LOG END ------*/
2223
2224         // Argument check for help command.
2225         if (argc != 2) {
2226                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,69,
2227                         "Argument argc is illegal for -h command.");
2228                 fprintf(stderr, "PARSE ERROR : "
2229                         "Argument argc is illegal for -h command.\n");
2230
2231                 /*-------- DEBUG LOG --------*/
2232                 if (log_level_parse == LOG_LV_DEBUG) {
2233                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,88,
2234                                 "out_function : static int "
2235                                 "parse_option_help(int argc, char *argv[]) : "
2236                                 "return = -1");
2237                 }
2238                 /*------ DEBUG LOG END ------*/
2239
2240                 return -1;
2241         }
2242
2243         /*-------- DEBUG LOG --------*/
2244         if (log_level_parse == LOG_LV_DEBUG) {
2245                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,89,
2246                         "out_function : static int "
2247                         "parse_option_help(int argc, char *argv[]) : "
2248                         "return = 0");
2249         }
2250         /*------ DEBUG LOG END ------*/
2251
2252         return 0;
2253 }
2254
2255 /*!
2256  * Parse endpoint option.
2257  * Check endpoint(IP-Address:port) data
2258  * @param[out]  *addr   socket address struct
2259  * @param[in]   *endpoint_str   endpoint data string
2260  * @return      int     parse result OK=0, NG=-1
2261  */
2262 static int
2263 parse_endpoint(struct sockaddr_in *addr, const char *endpoint_str, int allow_inaddr_any)
2264 {
2265         struct addrinfo *res, hints;
2266         struct sockaddr_in *sin;
2267         char s[NI_MAXHOST + NI_MAXSERV], *t;
2268         int ret;
2269
2270         // Argment check.
2271         if (endpoint_str == NULL) {
2272                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,70,
2273                         "Argument endpoint_str is NULL.");
2274                 fprintf(stderr, "PARSE ERROR : "
2275                         "Argument endpoint_str is NULL.\n");
2276
2277                 /*-------- DEBUG LOG --------*/
2278                 if (log_level_parse == LOG_LV_DEBUG) {
2279                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,90,
2280                                 "out_function : static int parse_endpoint"
2281                                 "(struct sockaddr_in *addr, const char *endpoint_str) : "
2282                                 "return = -1");
2283                 }
2284                 /*------ DEBUG LOG END ------*/
2285
2286                 return -1;
2287         }
2288
2289         /*-------- DEBUG LOG --------*/
2290         if (log_level_parse == LOG_LV_DEBUG) {
2291                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,91,
2292                         "in_function : static int parse_endpoint"
2293                         "(struct sockaddr_in *addr, const char *endpoint_str) : "
2294                         "addr = \"\" endpoint_str = %s",
2295                         endpoint_str);
2296         }
2297         /*------ DEBUG LOG END ------*/
2298
2299         // Separate host and port string.
2300         strncpy(s, endpoint_str, strlen(endpoint_str));
2301         s[strlen(endpoint_str)] = '\0';
2302         t = strrchr(s, ':');
2303         if (t == NULL) {
2304                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,71,
2305                         "Endpoint string is illegal. (':' not found)");
2306                 fprintf(stderr, "PARSE ERROR : "
2307                         "Endpoint string is illegal. (':' not found)\n");
2308
2309                 /*-------- DEBUG LOG --------*/
2310                 if (log_level_parse == LOG_LV_DEBUG) {
2311                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,92,
2312                                 "out_function : static int parse_endpoint"
2313                                 "(struct sockaddr_in *addr, const char *endpoint_str) : "
2314                                 "return = -1");
2315                 }
2316                 /*------ DEBUG LOG END ------*/
2317
2318                 return -1;
2319         }
2320         *t++ = '\0';
2321
2322         memset(&hints, 0, sizeof(hints));
2323         hints.ai_family = PF_INET; /* inet only. no support for inet6 (yet) */
2324         hints.ai_socktype = SOCK_STREAM;
2325         ret = getaddrinfo(s, t, &hints, &res);
2326         if (ret != 0) {
2327                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,72,
2328                         "getaddrinfo() error. %s:%s: %s", s, t, gai_strerror(ret));
2329                 fprintf(stderr, "PARSE ERROR : "
2330                         "getaddrinfo() error. %s:%s: %s\n", s, t, gai_strerror(ret));
2331
2332                 /*-------- DEBUG LOG --------*/
2333                 if (log_level_parse == LOG_LV_DEBUG) {
2334                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,93,
2335                                 "out_function : static int parse_endpoint"
2336                                 "(struct sockaddr_in *addr, const char *endpoint_str) : "
2337                                 "return = -1");
2338                 }
2339                 /*------ DEBUG LOG END ------*/
2340
2341                 return -1;
2342         }
2343
2344         /*
2345          * We always use the first entry, because we can't distinguish
2346          * which entry you want to specify if we have multiple entries.
2347          */
2348         sin = (struct sockaddr_in *)res->ai_addr;
2349         if (!allow_inaddr_any && sin->sin_addr.s_addr == htonl(INADDR_ANY)) {
2350                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,73,
2351                         "You can't specify INADDR_ANY for endpoint.");
2352                 fprintf(stderr, "PARSE ERROR : "
2353                         "You can't specify INADDR_ANY for endpoint.\n");
2354                 freeaddrinfo(res);
2355
2356                 /*-------- DEBUG LOG --------*/
2357                 if (log_level_parse == LOG_LV_DEBUG) {
2358                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,94,
2359                                 "out_function : static int parse_endpoint"
2360                                 "(struct sockaddr_in *addr, const char *endpoint_str) : "
2361                                 "return = -1");
2362                 }
2363                 /*------ DEBUG LOG END ------*/
2364
2365                 return -1;
2366         }
2367
2368         if (sin->sin_port == htons(0)) {
2369                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,74,
2370                         "You can't specify port number 0.");
2371                 fprintf(stderr, "PARSE ERROR : "
2372                         "You can't specify port number 0.\n");
2373                 freeaddrinfo(res);
2374
2375                 /*-------- DEBUG LOG --------*/
2376                 if (log_level_parse == LOG_LV_DEBUG) {
2377                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,95,
2378                                 "out_function : static int parse_endpoint"
2379                                 "(struct sockaddr_in *addr, const char *endpoint_str) : "
2380                                 "return = -1");
2381                 }
2382                 /*------ DEBUG LOG END ------*/
2383
2384                 return -1;
2385         }
2386
2387         *addr = *sin;
2388         freeaddrinfo(res);
2389
2390         /*-------- DEBUG LOG --------*/
2391         if (log_level_parse == LOG_LV_DEBUG) {
2392                 char ep_str[DEBUG_STR_LEN] = {0};
2393                 endpoint_c_str(ep_str, (void *)addr);
2394                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,96,
2395                         "out_function : static int parse_endpoint"
2396                         "(struct sockaddr_in *addr, const char *endpoint_str) : "
2397                         "return = 0 : result "
2398                         "addr = (%s)",
2399                         ep_str);
2400         }
2401         /*------ DEBUG LOG END ------*/
2402
2403         return 0;
2404 }
2405
2406 /*!
2407  * Parse digit option.
2408  * Check digit data
2409  * @param[in]   *digit_str      digit data string
2410  * @return      int     parse result OK=0, NG=-1
2411  */
2412 static int
2413 parse_digit(const char *digit_str)
2414 {
2415         int i;
2416
2417         // Argment check.
2418         if (digit_str == NULL) {
2419                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,75,
2420                         "Argument digit_str is NULL.");
2421                 fprintf(stderr, "PARSE ERROR : "
2422                         "Argument digit_str is NULL.\n");
2423
2424                 /*-------- DEBUG LOG --------*/
2425                 if (log_level_parse == LOG_LV_DEBUG) {
2426                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,97,
2427                                 "out_function : static int parse_digit"
2428                                 "(const char *digit_str) : "
2429                                 "return = -1");
2430                 }
2431                 /*------ DEBUG LOG END ------*/
2432
2433                 return -1;
2434         }
2435
2436         /*-------- DEBUG LOG --------*/
2437         if (log_level_parse == LOG_LV_DEBUG) {
2438                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,98,
2439                         "in_function : static int parse_digit(const char *digit_str) : "
2440                         "digit_str = %s",
2441                         digit_str);
2442         }
2443         /*------ DEBUG LOG END ------*/
2444
2445         for (i = 0; i < (int)strlen(digit_str); i++) {
2446                 // Digit check.
2447                 if (isdigit(digit_str[i]) == 0) {
2448                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,76,
2449                                 "Non digit character is included.");
2450                         fprintf(stderr, "PARSE ERROR : "
2451                                 "Non digit character is included.\n");
2452
2453                         /*-------- DEBUG LOG --------*/
2454                         if (log_level_parse == LOG_LV_DEBUG) {
2455                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,99,
2456                                         "out_function : static int parse_digit"
2457                                         "(const char *digit_str) : "
2458                                         "return = -1");
2459                         }
2460                         /*------ DEBUG LOG END ------*/
2461
2462                         return -1;
2463                 }
2464         }
2465
2466         /*-------- DEBUG LOG --------*/
2467         if (log_level_parse == LOG_LV_DEBUG) {
2468                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,100,
2469                         "out_function : static int parse_digit"
2470                         "(const char *digit_str) : "
2471                         "return = 0");
2472         }
2473         /*------ DEBUG LOG END ------*/
2474
2475         return 0;
2476 }
2477
2478 /*!
2479  * Parse qos option.
2480  * Check qos data (xxx,xxxK,xxxM,xxxG)
2481  * @param[in]   *qos_str        qos data string
2482  * @return      long long       qos value, parse result NG=-1
2483  */
2484 static long long
2485 parse_qos(const char *qos_str)
2486 {
2487         int i;
2488         int unit_f = 0;
2489         char numstr[4];
2490         long long qos_value = 0;
2491         long long multiply_value = 0;
2492
2493         // Argment check.
2494         if (qos_str == NULL) {
2495                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,77,
2496                         "Argument qos_str is NULL.");
2497                 fprintf(stderr, "PARSE ERROR : "
2498                         "Argument qos_str is NULL.\n");
2499
2500                 /*-------- DEBUG LOG --------*/
2501                 if (log_level_parse == LOG_LV_DEBUG) {
2502                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,101,
2503                                 "out_function : static long long parse_qos"
2504                                 "(const char *qos_str) : "
2505                                 "return = -1");
2506                 }
2507                 /*------ DEBUG LOG END ------*/
2508
2509                 return -1;
2510         }
2511         if ((int)strlen(qos_str) > 4) {
2512                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,78,
2513                         "Argument qos_str is too long.");
2514                 fprintf(stderr, "PARSE ERROR : "
2515                         "Argument qos_str is too long.\n");
2516
2517                 /*-------- DEBUG LOG --------*/
2518                 if (log_level_parse == LOG_LV_DEBUG) {
2519                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,102,
2520                                 "out_function : static long long parse_qos"
2521                                 "(const char *qos_str) : "
2522                                 "return = -1");
2523                 }
2524                 /*------ DEBUG LOG END ------*/
2525
2526                 return -1;
2527         }
2528
2529         /*-------- DEBUG LOG --------*/
2530         if (log_level_parse == LOG_LV_DEBUG) {
2531                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,103,
2532                         "in_function : static long long parse_qos"
2533                         "(const char *qos_str) : "
2534                         "qos_str = %s",
2535                         qos_str);
2536         }
2537         /*------ DEBUG LOG END ------*/
2538
2539
2540         for (i = 0; i < (int)strlen(qos_str); i++) {
2541                 // Check QoS data format. (xxx or xxx + one alphabet)
2542                 if (isdigit(qos_str[i]) == 0) {
2543                         if ((int)strlen(qos_str) > 1 &&
2544                             i == (int)strlen(qos_str) -1 &&
2545                             isalpha(qos_str[i]) != 0) {
2546                                 // xxx + one alphabet (len > 1)
2547                                 unit_f = 1;
2548                         } else {
2549                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,79,
2550                                         "Wrong QoS value format.");
2551                                 fprintf(stderr, "PARSE ERROR : "
2552                                         "Wrong QoS value format.\n");
2553
2554                                 /*-------- DEBUG LOG --------*/
2555                                 if (log_level_parse == LOG_LV_DEBUG) {
2556                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,104,
2557                                                 "out_function : static long long parse_qos"
2558                                                 "(const char *qos_str) : "
2559                                                 "return = -1");
2560                                 }
2561                                 /*------ DEBUG LOG END ------*/
2562
2563                                 return -1;
2564                         }
2565                 }
2566         }
2567         if (unit_f) {
2568                 // Format xxxK,xxxM,xxxG,xxxk,xxxm,xxxg
2569                 strncpy(numstr, qos_str, strlen(qos_str) - 1);
2570                 numstr[strlen(qos_str) - 1] = '\0';
2571                 sscanf(numstr, "%lld", &qos_value);
2572                 if (qos_value < 0LL || qos_value > 999LL) {
2573                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,80,
2574                                 "Invalid QoS value.");
2575                         fprintf(stderr, "PARSE ERROR : "
2576                                 "Invalid QoS value.\n");
2577
2578                         /*-------- DEBUG LOG --------*/
2579                         if (log_level_parse == LOG_LV_DEBUG) {
2580                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,105,
2581                                         "out_function : static long long parse_qos"
2582                                         "(const char *qos_str) : "
2583                                         "return = -1");
2584                         }
2585                         /*------ DEBUG LOG END ------*/
2586
2587                         return -1;
2588                 }
2589                 if (qos_str[strlen(qos_str) - 1] == 'K' ||
2590                     qos_str[strlen(qos_str) - 1] == 'k') {
2591                         multiply_value = 1000LL;
2592                 } else if (qos_str[strlen(qos_str) - 1] == 'M' ||
2593                            qos_str[strlen(qos_str) - 1] == 'm') {
2594                         multiply_value = 1000LL * 1000LL;
2595                 } else if (qos_str[strlen(qos_str) - 1] == 'G' ||
2596                            qos_str[strlen(qos_str) - 1] == 'g') {
2597                         multiply_value = 1000LL * 1000LL * 1000LL;
2598                 } else {
2599                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,81,
2600                                 "Invalid QoS value unit character.");
2601                         fprintf(stderr, "PARSE ERROR : "
2602                                 "Invalid QoS value character.\n");
2603
2604                         /*-------- DEBUG LOG --------*/
2605                         if (log_level_parse == LOG_LV_DEBUG) {
2606                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,106,
2607                                         "out_function : static long long parse_qos"
2608                                         "(const char *qos_str) : "
2609                                         "return = -1");
2610                         }
2611                         /*------ DEBUG LOG END ------*/
2612
2613                         return -1;
2614                 }
2615                 // Convert from bps to byte/s.
2616                 //qos_value = qos_value * multiply_value / 8LL;
2617                 qos_value = qos_value * multiply_value;
2618         } else {
2619                 // Format xxx only.
2620                 sscanf(qos_str, "%lld", &qos_value);
2621                 if (qos_value < 0LL || qos_value > 999LL) {
2622                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,82,
2623                                 "Invalid QoS value.");
2624                         fprintf(stderr, "PARSE ERROR : "
2625                                 "Invalid QoS value.\n");
2626
2627                         /*-------- DEBUG LOG --------*/
2628                         if (log_level_parse == LOG_LV_DEBUG) {
2629                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,107,
2630                                         "out_function : static long long parse_qos"
2631                                         "(const char *qos_str) : "
2632                                         "return = -1");
2633                         }
2634                         /*------ DEBUG LOG END ------*/
2635
2636                         return -1;
2637                 }
2638                 // Convert from bps to byte/s.
2639 //              qos_value = qos_value / 8LL;
2640         }
2641
2642         // compare l7vs_conn_read_bufsize <= qos_value by bps
2643         if (qos_value != 0) {
2644                 int l7vs_conn_read_bufsize_bps = 20480 * 8;                     //! conn read buffer size
2645             int ret = parameter_is_int_exist( PARAM_COMP_CONN, "read_bufsize" );
2646             if (ret) {
2647                 int bufsize = parameter_get_int_value( PARAM_COMP_CONN, "read_bufsize" );
2648                 if (bufsize >= L7VS_CONN_READ_BUFSIZE_MIN && bufsize <= L7VS_CONN_READ_BUFSIZE_MAX)
2649                     l7vs_conn_read_bufsize_bps = bufsize * 8;
2650                 else if (bufsize > L7VS_CONN_READ_BUFSIZE_MAX) {
2651                         l7vs_conn_read_bufsize_bps = L7VS_CONN_READ_BUFSIZE_MAX * 8;
2652                 }
2653                 else {
2654                         l7vs_conn_read_bufsize_bps = L7VS_CONN_READ_BUFSIZE_MIN * 8;
2655                 }
2656             }
2657             if (l7vs_conn_read_bufsize_bps > qos_value) {
2658                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,86,
2659                                 "Invalid QoS value. qos >= read_bufsize is must");
2660                         fprintf(stderr, "PARSE ERROR : "
2661                                 "Invalid QoS value. qos >= read_bufsize is must\n");
2662
2663                         return -1;
2664             }
2665         }
2666
2667         // Convert from bps to byte/s.
2668         qos_value = qos_value / 8LL;
2669
2670         /*-------- DEBUG LOG --------*/
2671         if (log_level_parse == LOG_LV_DEBUG) {
2672                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,108,
2673                         "out_function : static long long parse_qos"
2674                         "(const char *qos_str) : "
2675                         "return = %lld",
2676                         qos_value);
2677         }
2678         /*------ DEBUG LOG END ------*/
2679
2680         return qos_value;
2681 }
2682
2683 /*!
2684  * Parse protocol module option.
2685  * Check protocol module option data
2686  * @param[in]   argc    number of argument
2687  * @param[in]   *argv[] array of argument string
2688  * @param[in]   m_idx_begin     start of module option
2689  * @param[in]   m_idx_end       end of module option
2690  * @return      int     parse result OK=0, NG=-1
2691  */
2692 static int
2693 parse_option_protomod(int argc, char *argv[], int m_idx_begin, int m_idx_end)
2694 {
2695         struct l7vs_service_arg_multi sarg;
2696         void *protomod_service_arg;
2697         int ret;
2698         int i;
2699
2700         /*-------- DEBUG LOG --------*/
2701         if (log_level_parse == LOG_LV_DEBUG) {
2702                 char arg_str[DEBUG_STR_LEN] = {0};
2703                 argc_argv_c_str(arg_str, argc, argv);
2704                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,109,
2705                         "in_function : static int parse_option_protomod"
2706                         "(int argc, char *argv[], int m_idx_begin, int m_idx_end) : "
2707                         "argc = %d, %s, m_idx_begin = %d, m_idx_end = %d",
2708                         argc,
2709                         arg_str,
2710                         m_idx_begin,
2711                         m_idx_end);
2712         }
2713         /*------ DEBUG LOG END ------*/
2714
2715         // Check signal.
2716         if (signal_flg > 0) {
2717                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMON,1,
2718                         "Signal (%d) Received.", received_sig);
2719                 fprintf(stderr, "COMMON ERROR : "
2720                         "Signal (%d) Received.\n", received_sig);
2721
2722                 /*-------- DEBUG LOG --------*/
2723                 if (log_level_parse == LOG_LV_DEBUG) {
2724                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,110,
2725                                 "out_function : static int parse_option_protomod"
2726                                 "(int argc, char *argv[], int m_idx_begin, int m_idx_end) : "
2727                                 "return = -1");
2728                 }
2729                 /*------ DEBUG LOG END ------*/
2730
2731                 return -1;
2732         }
2733
2734         // Clear sarg.
2735         memset(&sarg, 0, sizeof(l7vs_service_arg_multi));
2736
2737         // Create GArray.
2738         l7vsadm_option_data.protomod_options = g_array_new(FALSE, TRUE, sizeof(char*));
2739         if (l7vsadm_option_data.protomod_options == NULL) {
2740                 LOGGER_PUT_LOG_FATAL(LOG_CAT_L7VSADM_COMMON,1,
2741                         " GArray create error. (Could not allocate memory)");
2742                 fprintf(stderr, "COMMON ERROR : "
2743                         " GArray create error. (Could not allocate memory)\n");
2744                 ret = -1;
2745                 goto END;
2746         }
2747
2748         /* Add argv[0] first because getopt_long() skip argv[0]... */
2749         if (g_array_append_val(l7vsadm_option_data.protomod_options, argv[0]) == NULL) {
2750                 LOGGER_PUT_LOG_FATAL(LOG_CAT_L7VSADM_COMMON,2,
2751                         "Add to GArray error. (Could not allocate memory)");
2752                 fprintf(stderr, "COMMON ERROR : "
2753                         "Add to GArray error. (Could not allocate memory)\n");
2754                 ret = -1;
2755                 goto END;
2756         }
2757         // Add Protocol Module option to GArray. (from m_idx_begin to m_idx_end)
2758         for (i = m_idx_begin; i < m_idx_end; i++) {
2759                 if (g_array_append_val(l7vsadm_option_data.protomod_options, argv[i]) == NULL) {
2760                         LOGGER_PUT_LOG_FATAL(LOG_CAT_L7VSADM_COMMON,3,
2761                                 "Add to GArray error. (Could not allocate memory)");
2762                         fprintf(stderr, "COMMON ERROR : "
2763                                 "Add to GArray error. (Could not allocate memory)\n");
2764                         ret = -1;
2765                         goto END;
2766                 }
2767         }
2768
2769         // Protocol Module Initialize.
2770         ret = l7vs_module_init(NULL);
2771         if (ret < 0) {
2772                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_PARSE,1,
2773                         "Protocol Module Initialize error.");
2774                 fprintf(stderr, "PARSE ERROR : "
2775                         "Protocol Module Initialize error.\n");
2776                 goto END;
2777         }
2778
2779         // Protocol Module Load.
2780         l7vsadm_option_data.protomod =
2781                 (struct l7vs_protomod *)l7vs_protomod_get(l7vsadm_option_data.protomod_name);
2782         if (l7vsadm_option_data.protomod == NULL) {
2783                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_PARSE,2,
2784                         "Protocol Module Load error.");
2785                 fprintf(stderr, "PARSE ERROR : "
2786                         "Protocol Module Load error.\n");
2787                 ret = -1;
2788                 goto END;
2789         }
2790
2791         //  Check Protocol Module function pointer
2792         if (l7vsadm_option_data.protomod->create_sa  == NULL) {
2793                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_PARSE,3,
2794                         "create_sa() function pointer is NULL.");
2795                 fprintf(stderr, "PARSE ERROR : "
2796                         "create_sa() function pointer is NULL.\n");
2797                 ret = -1;
2798                 goto END;
2799         }
2800         if (l7vsadm_option_data.protomod->destroy_sa == NULL) {
2801                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_PARSE,4,
2802                         "destroy_sa() function pointer is NULL.");
2803                 fprintf(stderr, "PARSE ERROR : "
2804                         "destroy_sa() function pointer is NULL.\n");
2805                 ret = -1;
2806                 goto END;
2807         }
2808         if (l7vsadm_option_data.protomod->parse == NULL) {
2809                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_PARSE,5,
2810                         "parse() function pointer is NULL.");
2811                 fprintf(stderr, "PARSE ERROR : "
2812                         "parse() function pointer is NULL.\n");
2813                 ret = -1;
2814                 goto END;
2815         }
2816
2817         // Create Protocol Module service_arg
2818         protomod_service_arg = l7vsadm_option_data.protomod->create_sa(&sarg.srv_arg);
2819         if (protomod_service_arg == NULL) {
2820                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_PARSE,6,
2821                         "Create Protocol Module service_arg error.");
2822                 fprintf(stderr, "PARSE ERROR : "
2823                         "Create Protocol Module service_arg error.\n");
2824                 ret = -1;
2825                 goto END;
2826         }
2827         // Copy protomod_service_arg to sarg.protomod_arg
2828         memcpy(&sarg.protomod_arg, protomod_service_arg, sizeof(sarg.protomod_arg));
2829
2830         // Destroy protomod_service_arg. (because copy end)
2831         l7vsadm_option_data.protomod->destroy_sa(&protomod_service_arg);
2832
2833         // Parse Protocol Module option. (parse result saved sarg.protomod_arg)
2834         ret = l7vsadm_option_data.protomod->parse(sarg.protomod_arg,
2835                                 l7vsadm_option_data.protomod_options->len,
2836                                 (char **)l7vsadm_option_data.protomod_options->data);
2837         if (ret < 0) {
2838                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,83,
2839                         "Parse %s Protocol Module option error.",
2840                         l7vsadm_option_data.protomod_name);
2841                 fprintf(stderr, "PARSE ERROR : "
2842                         "Parse %s Protocol Module option error.\n",
2843                         l7vsadm_option_data.protomod_name);
2844                 goto END;
2845         }
2846
2847         // Copy sarg.protomod_arg to l7vsadm_option_data. (for operate)
2848         memcpy(&l7vsadm_option_data.protomod_sarg,
2849                &sarg,
2850                sizeof(struct l7vs_service_arg_multi));
2851
2852         ret = 0;
2853
2854 END:
2855         if (l7vsadm_option_data.protomod_options != NULL) {
2856                 g_array_free(l7vsadm_option_data.protomod_options, TRUE);
2857         }
2858
2859         if (l7vsadm_option_data.protomod != NULL) {
2860                 l7vs_protomod_put(l7vsadm_option_data.protomod);
2861         }
2862
2863         l7vs_module_fini();
2864
2865         /*-------- DEBUG LOG --------*/
2866         if (log_level_parse == LOG_LV_DEBUG) {
2867                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,111,
2868                         "out_function : static int parse_option_protomod"
2869                         "(int argc, char *argv[], int m_idx_begin, int m_idx_end) : "
2870                         "return = %d",
2871                         ret);
2872         }
2873         /*------ DEBUG LOG END ------*/
2874
2875         return ret;
2876 }
2877
2878 /*!
2879  * Operate List command.
2880  * @return      int     result OK=0, NG=<0
2881  */
2882 static int
2883 operate_list(void)
2884 {
2885         struct l7vs_service_arg *sarg;
2886         void *vs_buffer = NULL;
2887         int vs_bufsize = L7VSADM_DEFAULT_LIST_VS_BUFSIZE;
2888         int vs_num;
2889         int ret_num;
2890         int vs_offset;
2891         int i;
2892         int ret;
2893
2894         /*-------- DEBUG LOG --------*/
2895         if (log_level_operate == LOG_LV_DEBUG) {
2896                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,1,
2897                         "in_function : static int operate_list(void) : ");
2898         }
2899         /*------ DEBUG LOG END ------*/
2900
2901         ret = create_socket();
2902         if (ret < 0) {
2903                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,1,
2904                         "Create socket error.");
2905
2906                 /*-------- DEBUG LOG --------*/
2907                 if (log_level_operate == LOG_LV_DEBUG) {
2908                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,2,
2909                                 "out_function : static int operate_list"
2910                                 "(void) : "
2911                                 "return = -1");
2912                 }
2913                 /*------ DEBUG LOG END ------*/
2914
2915                 return -1;
2916         }
2917
2918         // Print Version.
2919         printf("Layer-7 Virtual Server version %s\n", L7VS_VERSION_STRING);
2920
2921         if (l7vsadm_option_data.command_code == CMD_LIST_VERBOSE) {
2922                 // Logger info.
2923                 ret = list_log_info();
2924                 if (ret < 0) {
2925                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,2,
2926                                 "List logger info error.");
2927                         goto END;
2928                 }
2929
2930                 // Replication info.
2931                 ret = list_replication_info();
2932                 if (ret < 0) {
2933                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,3,
2934                                 "List replication info error.");
2935                         goto END;
2936                 }
2937
2938                 // SNMPAgent info.
2939                 ret = list_snmp_info();
2940                 if (ret < 0) {
2941                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,4,
2942                                 "List SNMPAgent info error.");
2943                         goto END;
2944                 }
2945         }
2946
2947         // Display VS header.
2948         if (l7vsadm_option_data.command_code == CMD_LIST_VERBOSE) {
2949                 printf("Prot LocalAddress:Port ProtoMod Scheduler Reschedule "
2950                        "Protomod_opt_string\n");
2951                 printf("     SorryAddress:Port Sorry_cc Sorry_flag\n");
2952                 printf("     QoS-up   Throughput-up\n");
2953                 printf("     QoS-down Throughput-down\n");
2954         } else if (l7vsadm_option_data.command_code == CMD_LIST_KEY) {
2955                 printf("Prot LocalAddress:Port ProtoMod Scheduler Reschedule "
2956                        "Protomod_key_string\n");
2957         } else {
2958                 printf("Prot LocalAddress:Port ProtoMod Scheduler\n");
2959         }
2960         printf("  -> RemoteAddress:Port           Forward Weight ActiveConn InactConn\n");
2961
2962 RETRY:
2963         // Alloc VirtualService list memory.
2964         vs_buffer = malloc(vs_bufsize);
2965
2966         /*-------- DEBUG LOG --------*/
2967         if (log_level_common == LOG_LV_DEBUG) {
2968                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,1,
2969                         "malloc vs_buffer : "
2970                         "allocate address = %p "
2971                         "allocate size = %d",
2972                         vs_buffer,
2973                         vs_bufsize);
2974         }
2975         /*------ DEBUG LOG END ------*/
2976
2977         if (vs_buffer == NULL) {
2978                 LOGGER_PUT_LOG_FATAL(LOG_CAT_L7VSADM_COMMON,4,
2979                         "Could not allocate vs_buffer memory.");
2980                 fprintf(stderr, "COMMON ERROR : "
2981                         "Could not allocate vs_buffer memory.\n");
2982                 ret = -1;
2983                 goto END;
2984         }
2985         // Get all VirtualService list.
2986         ret_num = get_vs(vs_buffer, vs_bufsize);
2987         // If return L7VSADM_RECV_TOO_LARGE (-2) when extend vs_buffer size and retry.
2988         if (ret_num < 0) {
2989                 free(vs_buffer);
2990
2991                 /*-------- DEBUG LOG --------*/
2992                 if (log_level_common == LOG_LV_DEBUG) {
2993                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,2,
2994                                 "free vs_buffer : "
2995                                 "free address = %p",
2996                                 vs_buffer);
2997                 }
2998                 /*------ DEBUG LOG END ------*/
2999
3000                 vs_buffer = NULL;
3001                 if (ret_num == L7VSADM_RECV_TOO_LARGE) {
3002                         vs_bufsize += L7VSADM_DEFAULT_LIST_VS_BUFSIZE;
3003                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_OPERATE,1,
3004                                 "Receive VirtualService data too large. retrying.");
3005                         goto RETRY;
3006                 }
3007                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,5,
3008                         "Get VirtualService data error.");
3009                 fprintf(stderr, "OPERATE ERROR : "
3010                         "Get VirtualService data error.\n");
3011                 ret = -1;
3012                 goto END;
3013         }
3014         vs_num = ret_num;
3015         // List all VirtualService.
3016         sarg = (struct l7vs_service_arg *)vs_buffer;
3017         vs_offset = 0;
3018         for (i = 0; i < vs_num; i++) {
3019                 ret = list_vs(sarg);
3020                 if (ret < 0) {
3021                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,6,
3022                                 "List VirtualService data error.");
3023                         fprintf(stderr, "OPERATE ERROR : "
3024                                 "List VirtualService data error.\n");
3025                         goto END;
3026                 }
3027                 vs_offset += sarg->len;
3028                 if (vs_offset >= vs_bufsize) {
3029                         // Message size did not match.
3030                         // Version mismatch between l7vsd and l7vsadm?
3031                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,7,
3032                                 "VirtualService message size did not match.");
3033                         fprintf(stderr, "OPERATE ERROR : "
3034                                 "VirtualService message size did not match.\n");
3035                         ret = -1;
3036                         goto END;
3037                 }
3038                 sarg = (struct l7vs_service_arg *)((char *)vs_buffer + vs_offset);
3039         }
3040         ret = 0;
3041
3042 END:
3043         if (vs_buffer != NULL) {
3044                 free(vs_buffer);
3045
3046                 /*-------- DEBUG LOG --------*/
3047                 if (log_level_common == LOG_LV_DEBUG) {
3048                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,3,
3049                                 "free vs_buffer : "
3050                                 "free address = %p",
3051                                 vs_buffer);
3052                 }
3053                 /*------ DEBUG LOG END ------*/
3054
3055         }
3056
3057         destroy_socket();
3058
3059         /*-------- DEBUG LOG --------*/
3060         if (log_level_operate == LOG_LV_DEBUG) {
3061                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,3,
3062                         "out_function : static int operate_list"
3063                         "(void) : "
3064                         "return = %d",
3065                         ret);
3066         }
3067         /*------ DEBUG LOG END ------*/
3068
3069         return ret;
3070 }
3071
3072 /*!
3073  * Operate Add-VirtualService command.
3074  * @return      int     result OK=0, NG=<0
3075  */
3076 static int
3077 operate_add_vs(void)
3078 {
3079         struct l7vs_config_req_operate_vs req;
3080         struct l7vs_config_rsp_operate_vs rsp;
3081         struct l7vsadm_iov_data iov_data;
3082         int ret;
3083
3084         /*-------- DEBUG LOG --------*/
3085         if (log_level_operate == LOG_LV_DEBUG) {
3086                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,4,
3087                         "in_function : static int operate_add_vs(void) : ");
3088         }
3089         /*------ DEBUG LOG END ------*/
3090
3091         ret = create_socket();
3092         if (ret < 0) {
3093                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,8,
3094                         "Create socket error.");
3095
3096                 /*-------- DEBUG LOG --------*/
3097                 if (log_level_operate == LOG_LV_DEBUG) {
3098                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,5,
3099                                 "out_function : static int operate_add_vs"
3100                                 "(void) : "
3101                                 "return = -1");
3102                 }
3103                 /*------ DEBUG LOG END ------*/
3104
3105                 return -1;
3106         }
3107
3108         memset(&req, 0, sizeof(struct l7vs_config_req_operate_vs));
3109         memset(&rsp, 0, sizeof(struct l7vs_config_rsp_operate_vs));
3110         memset(&iov_data, 0, sizeof(struct l7vsadm_iov_data));
3111
3112         req.cmd = L7VS_CONFIG_ADD_VS;
3113
3114         l7vsadm_option_data.protomod_sarg.srv_arg.addr = l7vsadm_option_data.vs_addr;
3115         l7vsadm_option_data.protomod_sarg.srv_arg.proto = IPPROTO_TCP;
3116         l7vsadm_option_data.protomod_sarg.srv_arg.backlog = L7VSADM_DEFAULT_BACKLOG;
3117
3118         strncpy(l7vsadm_option_data.protomod_sarg.srv_arg.schedmod,
3119                 l7vsadm_option_data.schedmod_name,
3120                 strlen(l7vsadm_option_data.schedmod_name));
3121
3122         // set sorry data
3123         l7vsadm_option_data.protomod_sarg.srv_arg.sorry_cc = l7vsadm_option_data.max_connection;
3124         l7vsadm_option_data.protomod_sarg.srv_arg.sorry_addr = l7vsadm_option_data.sorry_addr;
3125         l7vsadm_option_data.protomod_sarg.srv_arg.sorry_flag = l7vsadm_option_data.sorry_flag;
3126
3127         // QoS Threshold data
3128         l7vsadm_option_data.protomod_sarg.srv_arg.qos_threshold_up = l7vsadm_option_data.qos_threshold_up;
3129         l7vsadm_option_data.protomod_sarg.srv_arg.qos_threshold_down = l7vsadm_option_data.qos_threshold_down;
3130
3131         // Set data for request
3132         iov_data.req_iov[0].iov_base = &req;
3133         iov_data.req_iov[0].iov_len = sizeof(req);
3134         iov_data.req_iov[1].iov_base = &l7vsadm_option_data.protomod_sarg;
3135         iov_data.req_iov[1].iov_len = sizeof(struct l7vs_service_arg_multi);
3136         iov_data.req_cnt = 2;
3137
3138         // Set data for response
3139         iov_data.rsp_iov[0].iov_base = &rsp;
3140         iov_data.rsp_iov[0].iov_len = sizeof(rsp);
3141         iov_data.rsp_cnt = 1;
3142
3143         ret = communicate_to_l7vsd(&iov_data);
3144         if (ret < 0) {
3145                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,9,
3146                         "Communicate to l7vsd error.");
3147                 goto END;
3148         }
3149
3150         if (rsp.code != 0) {
3151                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_CONFIG_RESULT,1,
3152                         "%s.", config_strerror(rsp.code));
3153                 fprintf(stderr, "CONFIG ERROR : "
3154                         "%s.\n", config_strerror(rsp.code));
3155                 ret = -1;
3156                 goto END;
3157         }
3158         ret = 0;
3159
3160 END:
3161         destroy_socket();
3162
3163         /*-------- DEBUG LOG --------*/
3164         if (log_level_operate == LOG_LV_DEBUG) {
3165                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,6,
3166                         "out_function : static int operate_add_vs"
3167                         "(void) : "
3168                         "return = %d",
3169                         ret);
3170         }
3171         /*------ DEBUG LOG END ------*/
3172
3173         return ret;
3174 }
3175
3176 /*!
3177  * Operate Edit-VirtualService command.
3178  * @return      int     result OK=0, NG=<0
3179  */
3180 static int
3181 operate_edit_vs(void)
3182 {
3183         struct l7vs_config_req_operate_vs req;
3184         struct l7vs_config_rsp_operate_vs rsp;
3185         struct l7vsadm_iov_data iov_data;
3186         int ret;
3187         struct l7vsadm_option_list *list;
3188         int specified_f = 0;
3189
3190         /*-------- DEBUG LOG --------*/
3191         if (log_level_operate == LOG_LV_DEBUG) {
3192                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,7,
3193                         "in_function : static int operate_edit_vs(void) : ");
3194         }
3195         /*------ DEBUG LOG END ------*/
3196
3197         ret = create_socket();
3198         if (ret < 0) {
3199                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,10,
3200                         "Create socket error.");
3201
3202                 /*-------- DEBUG LOG --------*/
3203                 if (log_level_operate == LOG_LV_DEBUG) {
3204                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,8,
3205                                 "out_function : static int operate_edit_vs"
3206                                 "(void) : "
3207                                 "return = -1");
3208                 }
3209                 /*------ DEBUG LOG END ------*/
3210
3211                 return -1;
3212         }
3213
3214         memset(&req, 0, sizeof(struct l7vs_config_req_operate_vs));
3215         memset(&rsp, 0, sizeof(struct l7vs_config_rsp_operate_vs));
3216         memset(&iov_data, 0, sizeof(struct l7vsadm_iov_data));
3217
3218         req.cmd = L7VS_CONFIG_EDIT_VS;
3219
3220         l7vsadm_option_data.protomod_sarg.srv_arg.addr = l7vsadm_option_data.vs_addr;
3221         l7vsadm_option_data.protomod_sarg.srv_arg.proto = IPPROTO_TCP;
3222         l7vsadm_option_data.protomod_sarg.srv_arg.backlog = L7VSADM_DEFAULT_BACKLOG;
3223
3224         // Check Specified option for edit. Set -1 or NULL or etc. to omitted option.
3225         for (list = l7vsadm_option_table_vs; list->option_name != NULL; list++) {
3226                 switch (list->option_code) {
3227                 case OPT_SCHEDULER:
3228                         if (list->check_flag) {
3229                                 // Option specified.
3230                                 strncpy(l7vsadm_option_data.protomod_sarg.srv_arg.schedmod,
3231                                         l7vsadm_option_data.schedmod_name,
3232                                         strlen(l7vsadm_option_data.schedmod_name));
3233                         } else {
3234                                 // Option omitted. Set all "0x00".
3235                                 memset(&l7vsadm_option_data.protomod_sarg.srv_arg.schedmod, 0,
3236                                        sizeof(l7vsadm_option_data.protomod_sarg.srv_arg.schedmod));
3237                         }
3238                         break;
3239                 case OPT_UPPER:
3240                         if (list->check_flag) {
3241                                 // Option specified.
3242                                 l7vsadm_option_data.protomod_sarg.srv_arg.sorry_cc =
3243                                 l7vsadm_option_data.max_connection;
3244                         } else {
3245                                 // Option omitted.
3246                                 l7vsadm_option_data.protomod_sarg.srv_arg.sorry_cc = -1;
3247                         }
3248                         break;
3249                 case OPT_BYPASS:
3250                         if (list->check_flag) {
3251                                 // Option specified.
3252                                 l7vsadm_option_data.protomod_sarg.srv_arg.sorry_addr =
3253                                 l7vsadm_option_data.sorry_addr;
3254                         } else {
3255                                 // Option omitted. Set all "0xff".
3256                                 memset(&l7vsadm_option_data.protomod_sarg.srv_arg.sorry_addr, 0xff,
3257                                        sizeof(struct sockaddr_storage));
3258                         }
3259                         break;
3260                 case OPT_FLAG:
3261                         if (list->check_flag) {
3262                                 // Option specified.
3263                                 l7vsadm_option_data.protomod_sarg.srv_arg.sorry_flag =
3264                                 l7vsadm_option_data.sorry_flag;
3265                         } else {
3266                                 // Option omitted. Set -1.
3267                                 l7vsadm_option_data.protomod_sarg.srv_arg.sorry_flag = -1;
3268                         }
3269                         break;
3270                 case OPT_QOS_UP:
3271                         if (list->check_flag) {
3272                                 // Option specified.
3273                                 l7vsadm_option_data.protomod_sarg.srv_arg.qos_threshold_up =
3274                                 l7vsadm_option_data.qos_threshold_up;
3275                         } else {
3276                                 // Option omitted. Set ULLONG_MAX.
3277                                 l7vsadm_option_data.protomod_sarg.srv_arg.qos_threshold_up = ULLONG_MAX;
3278                         }
3279                         break;
3280                 case OPT_QOS_DOWN:
3281                         if (list->check_flag) {
3282                                 // Option specified.
3283                                 l7vsadm_option_data.protomod_sarg.srv_arg.qos_threshold_down =
3284                                 l7vsadm_option_data.qos_threshold_down;
3285                         } else {
3286                                 // Option omitted. Set ULLONG_MAX.
3287                                 l7vsadm_option_data.protomod_sarg.srv_arg.qos_threshold_down = ULLONG_MAX;
3288                         }
3289                         break;
3290                 default:
3291                         break;
3292                 }
3293                 specified_f += list->check_flag;
3294         }
3295
3296         // All option omitted.
3297         if (specified_f == 0) {
3298                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,11,
3299                         "All option omitted for edit vs command.");
3300                 fprintf(stderr, "OPERATE ERROR : "
3301                         "All option omitted for edit vs command.\n");
3302                 ret = -1;
3303                 goto END;
3304         }
3305
3306         // Set data for request
3307         iov_data.req_iov[0].iov_base = &req;
3308         iov_data.req_iov[0].iov_len = sizeof(req);
3309         iov_data.req_iov[1].iov_base = &l7vsadm_option_data.protomod_sarg;
3310         iov_data.req_iov[1].iov_len = sizeof(struct l7vs_service_arg_multi);
3311         iov_data.req_cnt = 2;
3312
3313         // Set data for response
3314         iov_data.rsp_iov[0].iov_base = &rsp;
3315         iov_data.rsp_iov[0].iov_len = sizeof(rsp);
3316         iov_data.rsp_cnt = 1;
3317
3318         ret = communicate_to_l7vsd(&iov_data);
3319         if (ret < 0) {
3320                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,12,
3321                         "Communicate to l7vsd error.");
3322                 goto END;
3323         }
3324
3325         if (rsp.code != 0) {
3326                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_CONFIG_RESULT,2,
3327                         "%s.", config_strerror(rsp.code));
3328                 fprintf(stderr, "CONFIG ERROR : "
3329                         "%s.\n", config_strerror(rsp.code));
3330                 ret = -1;
3331                 goto END;
3332         }
3333         ret = 0;
3334
3335 END:
3336         destroy_socket();
3337
3338         /*-------- DEBUG LOG --------*/
3339         if (log_level_operate == LOG_LV_DEBUG) {
3340                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,9,
3341                         "out_function : static int operate_edit_vs"
3342                         "(void) : "
3343                         "return = %d",
3344                         ret);
3345         }
3346         /*------ DEBUG LOG END ------*/
3347
3348         return ret;
3349 }
3350
3351 /*!
3352  * Operate Delete-VirtualService command.
3353  * @return      int     result OK=0, NG=<0
3354  */
3355 static int
3356 operate_del_vs(void)
3357 {
3358         struct l7vs_config_req_operate_vs req;
3359         struct l7vs_config_rsp_operate_vs rsp;
3360         struct l7vsadm_iov_data iov_data;
3361         int ret;
3362
3363         /*-------- DEBUG LOG --------*/
3364         if (log_level_operate == LOG_LV_DEBUG) {
3365                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,10,
3366                         "in_function : static int operate_del_vs(void) : ");
3367         }
3368         /*------ DEBUG LOG END ------*/
3369
3370         ret = create_socket();
3371         if (ret < 0) {
3372                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,13,
3373                         "Create socket error.");
3374
3375                 /*-------- DEBUG LOG --------*/
3376                 if (log_level_operate == LOG_LV_DEBUG) {
3377                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,11,
3378                                 "out_function : static int operate_del_vs"
3379                                 "(void) : "
3380                                 "return = -1");
3381                 }
3382                 /*------ DEBUG LOG END ------*/
3383
3384                 return -1;
3385         }
3386
3387         memset(&req, 0, sizeof(struct l7vs_config_req_operate_vs));
3388         memset(&rsp, 0, sizeof(struct l7vs_config_rsp_operate_vs));
3389         memset(&iov_data, 0, sizeof(struct l7vsadm_iov_data));
3390
3391         req.cmd = L7VS_CONFIG_DEL_VS;
3392
3393         l7vsadm_option_data.protomod_sarg.srv_arg.addr = l7vsadm_option_data.vs_addr;
3394         l7vsadm_option_data.protomod_sarg.srv_arg.proto = IPPROTO_TCP;
3395         l7vsadm_option_data.protomod_sarg.srv_arg.backlog = L7VSADM_DEFAULT_BACKLOG;
3396
3397         // Set data for request
3398         iov_data.req_iov[0].iov_base = &req;
3399         iov_data.req_iov[0].iov_len = sizeof(req);
3400         iov_data.req_iov[1].iov_base = &l7vsadm_option_data.protomod_sarg;
3401         iov_data.req_iov[1].iov_len = sizeof(struct l7vs_service_arg_multi);
3402         iov_data.req_cnt = 2;
3403
3404         // Set data for response
3405         iov_data.rsp_iov[0].iov_base = &rsp;
3406         iov_data.rsp_iov[0].iov_len = sizeof(rsp);
3407         iov_data.rsp_cnt = 1;
3408
3409         ret = communicate_to_l7vsd(&iov_data);
3410         if (ret < 0) {
3411                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,14,
3412                         "Communicate to l7vsd error.");
3413                 goto END;
3414         }
3415
3416         if (rsp.code != 0) {
3417                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_CONFIG_RESULT,3,
3418                         "%s.", config_strerror(rsp.code));
3419                 fprintf(stderr, "CONFIG ERROR : "
3420                         "%s.\n", config_strerror(rsp.code));
3421                 ret = -1;
3422                 goto END;
3423         }
3424         ret = 0;
3425
3426 END:
3427         destroy_socket();
3428
3429         /*-------- DEBUG LOG --------*/
3430         if (log_level_operate == LOG_LV_DEBUG) {
3431                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,12,
3432                         "out_function : static int operate_del_vs"
3433                         "(void) : "
3434                         "return = %d",
3435                         ret);
3436         }
3437         /*------ DEBUG LOG END ------*/
3438
3439         return ret;
3440 }
3441
3442 /*!
3443  * Operate Flush-VirtualService command.
3444  * @return      int     result OK=0, NG=<0
3445  */
3446 static int
3447 operate_flush_vs(void)
3448 {
3449         struct l7vs_config_req_flush_vs req;
3450         struct l7vs_config_rsp_flush_vs rsp;
3451         struct l7vsadm_iov_data iov_data;
3452         int ret;
3453
3454         /*-------- DEBUG LOG --------*/
3455         if (log_level_operate == LOG_LV_DEBUG) {
3456                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,13,
3457                         "in_function : static int operate_flush_vs(void) : ");
3458         }
3459         /*------ DEBUG LOG END ------*/
3460
3461         ret = create_socket();
3462         if (ret < 0) {
3463                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,15,
3464                         "Create socket error.");
3465
3466                 /*-------- DEBUG LOG --------*/
3467                 if (log_level_operate == LOG_LV_DEBUG) {
3468                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,14,
3469                                 "out_function : static int operate_flush_vs"
3470                                 "(void) : "
3471                                 "return = -1");
3472                 }
3473                 /*------ DEBUG LOG END ------*/
3474
3475                 return -1;
3476         }
3477
3478         memset(&req, 0, sizeof(struct l7vs_config_req_flush_vs));
3479         memset(&rsp, 0, sizeof(struct l7vs_config_rsp_flush_vs));
3480         memset(&iov_data, 0, sizeof(struct l7vsadm_iov_data));
3481
3482         req.cmd = L7VS_CONFIG_FLUSH_VS;
3483
3484         // Set data for request
3485         iov_data.req_iov[0].iov_base = &req;
3486         iov_data.req_iov[0].iov_len = sizeof(req);
3487         iov_data.req_cnt = 1;
3488
3489         // Set data for response
3490         iov_data.rsp_iov[0].iov_base = &rsp;
3491         iov_data.rsp_iov[0].iov_len = sizeof(rsp);
3492         iov_data.rsp_cnt = 1;
3493
3494         ret = communicate_to_l7vsd(&iov_data);
3495         if (ret < 0) {
3496                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,16,
3497                         "Communicate to l7vsd error.");
3498                 goto END;
3499         }
3500
3501         if (rsp.code != 0) {
3502                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_CONFIG_RESULT,4,
3503                         "%s.", config_strerror(rsp.code));
3504                 fprintf(stderr, "CONFIG ERROR : "
3505                         "%s.\n", config_strerror(rsp.code));
3506                 ret = -1;
3507                 goto END;
3508         }
3509         ret = 0;
3510
3511 END:
3512         destroy_socket();
3513
3514         /*-------- DEBUG LOG --------*/
3515         if (log_level_operate == LOG_LV_DEBUG) {
3516                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,15,
3517                         "out_function : static int operate_flush_vs"
3518                         "(void) : "
3519                         "return = %d",
3520                         ret);
3521         }
3522         /*------ DEBUG LOG END ------*/
3523
3524         return ret;
3525 }
3526
3527 /*!
3528  * Operate Add-RealServer command.
3529  * @return      int     result OK=0, NG=<0
3530  */
3531 static int
3532 operate_add_rs(void)
3533 {
3534         struct l7vs_config_req_operate_rs req;
3535         struct l7vs_config_rsp_operate_rs rsp;
3536         struct l7vsadm_iov_data iov_data;
3537         int ret;
3538
3539         /*-------- DEBUG LOG --------*/
3540         if (log_level_operate == LOG_LV_DEBUG) {
3541                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,16,
3542                         "in_function : static int operate_add_rs(void) : ");
3543         }
3544         /*------ DEBUG LOG END ------*/
3545
3546         ret = create_socket();
3547         if (ret < 0) {
3548                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,17,
3549                         "Create socket error.");
3550
3551                 /*-------- DEBUG LOG --------*/
3552                 if (log_level_operate == LOG_LV_DEBUG) {
3553                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,17,
3554                                 "out_function : static int operate_add_rs"
3555                                 "(void) : "
3556                                 "return = -1");
3557                 }
3558                 /*------ DEBUG LOG END ------*/
3559
3560                 return -1;
3561         }
3562
3563         memset(&req, 0, sizeof(struct l7vs_config_req_operate_rs));
3564         memset(&rsp, 0, sizeof(struct l7vs_config_rsp_operate_rs));
3565         memset(&iov_data, 0, sizeof(struct l7vsadm_iov_data));
3566
3567         req.cmd = L7VS_CONFIG_ADD_RS;
3568
3569         l7vsadm_option_data.protomod_sarg.srv_arg.addr = l7vsadm_option_data.vs_addr;
3570         l7vsadm_option_data.protomod_sarg.srv_arg.proto = IPPROTO_TCP;
3571
3572         req.darg.addr = l7vsadm_option_data.rs_addr;
3573         req.darg.weight = l7vsadm_option_data.weight;
3574
3575         // Set data for request
3576         iov_data.req_iov[0].iov_base = &req;
3577         iov_data.req_iov[0].iov_len = sizeof(req);
3578         iov_data.req_iov[1].iov_base = &l7vsadm_option_data.protomod_sarg;
3579         iov_data.req_iov[1].iov_len = sizeof(struct l7vs_service_arg_multi);
3580         iov_data.req_cnt = 2;
3581
3582         // Set data for response
3583         iov_data.rsp_iov[0].iov_base = &rsp;
3584         iov_data.rsp_iov[0].iov_len = sizeof(rsp);
3585         iov_data.rsp_cnt = 1;
3586
3587         ret = communicate_to_l7vsd(&iov_data);
3588         if (ret < 0) {
3589                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,18,
3590                         "Communicate to l7vsd error.");
3591                 goto END;
3592         }
3593
3594         if (rsp.code != 0) {
3595                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_CONFIG_RESULT,5,
3596                         "%s.", config_strerror(rsp.code));
3597                 fprintf(stderr, "CONFIG ERROR : "
3598                         "%s.\n", config_strerror(rsp.code));
3599                 ret = -1;
3600                 goto END;
3601         }
3602         ret = 0;
3603
3604 END:
3605         destroy_socket();
3606
3607         /*-------- DEBUG LOG --------*/
3608         if (log_level_operate == LOG_LV_DEBUG) {
3609                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,18,
3610                         "out_function : static int operate_add_rs"
3611                         "(void) : "
3612                         "return = %d",
3613                         ret);
3614         }
3615         /*------ DEBUG LOG END ------*/
3616
3617         return ret;
3618 }
3619
3620 /*!
3621  * Operate Edit-RealServer command.
3622  * @return      int     result OK=0, NG=<0
3623  */
3624 static int
3625 operate_edit_rs(void)
3626 {
3627         struct l7vs_config_req_operate_rs req;
3628         struct l7vs_config_rsp_operate_rs rsp;
3629         struct l7vsadm_iov_data iov_data;
3630         int ret;
3631         struct l7vsadm_option_list *list;
3632         int specified_f = 0;
3633
3634         /*-------- DEBUG LOG --------*/
3635         if (log_level_operate == LOG_LV_DEBUG) {
3636                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,19,
3637                         "in_function : static int operate_edit_rs(void) : ");
3638         }
3639         /*------ DEBUG LOG END ------*/
3640
3641         ret = create_socket();
3642         if (ret < 0) {
3643                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,19,
3644                         "Create socket error.");
3645
3646                 /*-------- DEBUG LOG --------*/
3647                 if (log_level_operate == LOG_LV_DEBUG) {
3648                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,20,
3649                                 "out_function : static int operate_edit_rs"
3650                                 "(void) : "
3651                                 "return = -1");
3652                 }
3653                 /*------ DEBUG LOG END ------*/
3654
3655                 return -1;
3656         }
3657
3658         memset(&req, 0, sizeof(struct l7vs_config_req_operate_rs));
3659         memset(&rsp, 0, sizeof(struct l7vs_config_rsp_operate_rs));
3660         memset(&iov_data, 0, sizeof(struct l7vsadm_iov_data));
3661
3662         req.cmd = L7VS_CONFIG_EDIT_RS;
3663
3664         l7vsadm_option_data.protomod_sarg.srv_arg.addr = l7vsadm_option_data.vs_addr;
3665         l7vsadm_option_data.protomod_sarg.srv_arg.proto = IPPROTO_TCP;
3666
3667         req.darg.addr = l7vsadm_option_data.rs_addr;
3668
3669         // Check Specified option for edit. Set -1 or NULL or etc. to omitted option.
3670         for (list = l7vsadm_option_table_rs; list->option_name != NULL; list++) {
3671                 switch (list->option_code) {
3672                 case OPT_WEIGHT:
3673                         if (list->check_flag) {
3674                                 // Option specified.
3675                                 req.darg.weight = l7vsadm_option_data.weight;
3676                         } else {
3677                                 // Option omitted. Set -1.
3678                                 req.darg.weight = -1;
3679                         }
3680                         break;
3681                 default:
3682                         break;
3683                 }
3684                 specified_f += list->check_flag;
3685         }
3686
3687         // All option omitted.
3688         if (specified_f == 0) {
3689                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,20,
3690                         "All option omitted for edit rs command.");
3691                 fprintf(stderr, "OPERATE ERROR : "
3692                         "All option omitted for edit rs command.\n");
3693                 ret = -1;
3694                 goto END;
3695         }
3696
3697         // Set data for request
3698         iov_data.req_iov[0].iov_base = &req;
3699         iov_data.req_iov[0].iov_len = sizeof(req);
3700         iov_data.req_iov[1].iov_base = &l7vsadm_option_data.protomod_sarg;
3701         iov_data.req_iov[1].iov_len = sizeof(struct l7vs_service_arg_multi);
3702         iov_data.req_cnt = 2;
3703
3704         // Set data for response
3705         iov_data.rsp_iov[0].iov_base = &rsp;
3706         iov_data.rsp_iov[0].iov_len = sizeof(rsp);
3707         iov_data.rsp_cnt = 1;
3708
3709         ret = communicate_to_l7vsd(&iov_data);
3710         if (ret < 0) {
3711                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,21,
3712                         "Communicate to l7vsd error.");
3713                 goto END;
3714         }
3715
3716         if (rsp.code != 0) {
3717                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_CONFIG_RESULT,6,
3718                         "%s.", config_strerror(rsp.code));
3719                 fprintf(stderr, "CONFIG ERROR : "
3720                         "%s.\n", config_strerror(rsp.code));
3721                 ret = -1;
3722                 goto END;
3723         }
3724         ret = 0;
3725
3726 END:
3727         destroy_socket();
3728
3729         /*-------- DEBUG LOG --------*/
3730         if (log_level_operate == LOG_LV_DEBUG) {
3731                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,21,
3732                         "out_function : static int operate_edit_rs"
3733                         "(void) : "
3734                         "return = %d",
3735                         ret);
3736         }
3737         /*------ DEBUG LOG END ------*/
3738
3739         return ret;
3740 }
3741
3742 /*!
3743  * Operate Delete-RealServer command.
3744  * @return      int     result OK=0, NG=<0
3745  */
3746 static int
3747 operate_del_rs(void)
3748 {
3749         struct l7vs_config_req_operate_rs req;
3750         struct l7vs_config_rsp_operate_rs rsp;
3751         struct l7vsadm_iov_data iov_data;
3752         int ret;
3753
3754         /*-------- DEBUG LOG --------*/
3755         if (log_level_operate == LOG_LV_DEBUG) {
3756                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,22,
3757                         "in_function : static int operate_del_rs(void) : ");
3758         }
3759         /*------ DEBUG LOG END ------*/
3760
3761         ret = create_socket();
3762         if (ret < 0) {
3763                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,22,
3764                         "Create socket error.");
3765
3766                 /*-------- DEBUG LOG --------*/
3767                 if (log_level_operate == LOG_LV_DEBUG) {
3768                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,23,
3769                                 "out_function : static int operate_del_rs"
3770                                 "(void) : "
3771                                 "return = -1");
3772                 }
3773                 /*------ DEBUG LOG END ------*/
3774
3775                 return -1;
3776         }
3777
3778         memset(&req, 0, sizeof(struct l7vs_config_req_operate_rs));
3779         memset(&rsp, 0, sizeof(struct l7vs_config_rsp_operate_rs));
3780         memset(&iov_data, 0, sizeof(struct l7vsadm_iov_data));
3781
3782         req.cmd = L7VS_CONFIG_DEL_RS;
3783
3784         l7vsadm_option_data.protomod_sarg.srv_arg.addr = l7vsadm_option_data.vs_addr;
3785         l7vsadm_option_data.protomod_sarg.srv_arg.proto = IPPROTO_TCP;
3786
3787         req.darg.addr = l7vsadm_option_data.rs_addr;
3788
3789         // Set data for request
3790         iov_data.req_iov[0].iov_base = &req;
3791         iov_data.req_iov[0].iov_len = sizeof(req);
3792         iov_data.req_iov[1].iov_base = &l7vsadm_option_data.protomod_sarg;
3793         iov_data.req_iov[1].iov_len = sizeof(struct l7vs_service_arg_multi);
3794         iov_data.req_cnt = 2;
3795
3796         // Set data for response
3797         iov_data.rsp_iov[0].iov_base = &rsp;
3798         iov_data.rsp_iov[0].iov_len = sizeof(rsp);
3799         iov_data.rsp_cnt = 1;
3800
3801         ret = communicate_to_l7vsd(&iov_data);
3802         if (ret < 0) {
3803                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,23,
3804                         "Communicate to l7vsd error.");
3805                 goto END;
3806         }
3807
3808         if (rsp.code != 0) {
3809                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_CONFIG_RESULT,7,
3810                         "%s.", config_strerror(rsp.code));
3811                 fprintf(stderr, "CONFIG ERROR : "
3812                         "%s.\n", config_strerror(rsp.code));
3813                 ret = -1;
3814                 goto END;
3815         }
3816         ret = 0;
3817
3818 END:
3819         destroy_socket();
3820
3821         /*-------- DEBUG LOG --------*/
3822         if (log_level_operate == LOG_LV_DEBUG) {
3823                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,24,
3824                         "out_function : static int operate_del_rs"
3825                         "(void) : "
3826                         "return = %d",
3827                         ret);
3828         }
3829         /*------ DEBUG LOG END ------*/
3830
3831         return ret;
3832 }
3833
3834 /*!
3835  * Operate Replication command.
3836  * @return      int     result OK=0, NG=<0
3837  */
3838 static int
3839 operate_replication(void)
3840 {
3841         struct l7vs_config_msg_replication req;
3842         struct l7vs_config_msg_replication rsp;
3843         struct l7vsadm_iov_data iov_data;
3844         int ret;
3845
3846         /*-------- DEBUG LOG --------*/
3847         if (log_level_operate == LOG_LV_DEBUG) {
3848                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,25,
3849                         "in_function : static int operate_replication(void) : ");
3850         }
3851         /*------ DEBUG LOG END ------*/
3852
3853         ret = create_socket();
3854         if (ret < 0) {
3855                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,24,
3856                         "Create socket error.");
3857
3858                 /*-------- DEBUG LOG --------*/
3859                 if (log_level_operate == LOG_LV_DEBUG) {
3860                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,26,
3861                                 "out_function : static int operate_replication"
3862                                 "(void) : "
3863                                 "return = -1");
3864                 }
3865                 /*------ DEBUG LOG END ------*/
3866
3867                 return -1;
3868         }
3869
3870         memset(&req, 0, sizeof(struct l7vs_config_msg_replication));
3871         memset(&rsp, 0, sizeof(struct l7vs_config_msg_replication));
3872         memset(&iov_data, 0, sizeof(struct l7vsadm_iov_data));
3873
3874         req.cmd = L7VS_CONFIG_REPLICATION;
3875
3876         switch (l7vsadm_option_data.control_code) {
3877         case OPT_SWITCH:
3878                 if (l7vsadm_option_data.replication_start_flag == 1) {
3879                         req.kind = L7VS_CONFIG_REPLICATION_START;
3880                 } else {
3881                         req.kind = L7VS_CONFIG_REPLICATION_STOP;
3882                 }
3883                 break;
3884         case OPT_FORCE:
3885                 req.kind = L7VS_CONFIG_REPLICATION_COMPULSORILY;
3886                 break;
3887         case OPT_DUMP:
3888                 req.kind = L7VS_CONFIG_REPLICATION_DUMP;
3889                 break;
3890         default:
3891                 break;
3892         }
3893
3894         // Set data for request
3895         iov_data.req_iov[0].iov_base = &req;
3896         iov_data.req_iov[0].iov_len = sizeof(req);
3897         iov_data.req_cnt = 1;
3898
3899         // Set data for response
3900         iov_data.rsp_iov[0].iov_base = &rsp;
3901         iov_data.rsp_iov[0].iov_len = sizeof(rsp);
3902         iov_data.rsp_cnt = 1;
3903
3904         ret = communicate_to_l7vsd(&iov_data);
3905         if (ret < 0) {
3906                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,25,
3907                         "Communicate to l7vsd error.");
3908                 goto END;
3909         }
3910
3911         if (rsp.code != 0) {
3912                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_CONFIG_RESULT,8,
3913                         "%s.", config_strerror(rsp.code));
3914                 fprintf(stderr, "CONFIG ERROR : "
3915                         "%s.\n", config_strerror(rsp.code));
3916                 ret = -1;
3917                 goto END;
3918         }
3919         ret = 0;
3920
3921 END:
3922         destroy_socket();
3923
3924         /*-------- DEBUG LOG --------*/
3925         if (log_level_operate == LOG_LV_DEBUG) {
3926                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,27,
3927                         "out_function : static int operate_replication"
3928                         "(void) : "
3929                         "return = %d",
3930                         ret);
3931         }
3932         /*------ DEBUG LOG END ------*/
3933
3934         return ret;
3935 }
3936
3937 /*!
3938  * Operate Logger command.
3939  * @return      int     result OK=0, NG=<0
3940  */
3941 static int
3942 operate_log(void)
3943 {
3944         struct l7vs_config_msg_log req;
3945         struct l7vs_config_msg_log rsp;
3946         struct l7vsadm_iov_data iov_data;
3947         int ret;
3948
3949         /*-------- DEBUG LOG --------*/
3950         if (log_level_operate == LOG_LV_DEBUG) {
3951                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,28,
3952                         "in_function : static int operate_log(void) : ");
3953         }
3954         /*------ DEBUG LOG END ------*/
3955
3956         ret = create_socket();
3957         if (ret < 0) {
3958                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,26,
3959                         "Create socket error.");
3960
3961                 /*-------- DEBUG LOG --------*/
3962                 if (log_level_operate == LOG_LV_DEBUG) {
3963                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,29,
3964                                 "out_function : static int operate_log"
3965                                 "(void) : "
3966                                 "return = -1");
3967                 }
3968                 /*------ DEBUG LOG END ------*/
3969
3970                 return -1;
3971         }
3972
3973         memset(&req, 0, sizeof(struct l7vs_config_msg_log));
3974         memset(&rsp, 0, sizeof(struct l7vs_config_msg_log));
3975         memset(&iov_data, 0, sizeof(struct l7vsadm_iov_data));
3976
3977         if (l7vsadm_option_data.category_all_flag == 1) {
3978                 req.cmd = L7VS_CONFIG_SET_LOG_LEVEL_ALL;
3979         } else {
3980                 req.cmd = L7VS_CONFIG_SET_LOG_LEVEL;
3981         }
3982         req.kind = l7vsadm_option_data.log_category;
3983         req.vsd_log_level = l7vsadm_option_data.log_level;
3984
3985         // Set data for request
3986         iov_data.req_iov[0].iov_base = &req;
3987         iov_data.req_iov[0].iov_len = sizeof(req);
3988         iov_data.req_cnt = 1;
3989
3990         // Set data for response
3991         iov_data.rsp_iov[0].iov_base = &rsp;
3992         iov_data.rsp_iov[0].iov_len = sizeof(rsp);
3993         iov_data.rsp_cnt = 1;
3994
3995         ret = communicate_to_l7vsd(&iov_data);
3996         if (ret < 0) {
3997                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,27,
3998                         "Communicate to l7vsd error.");
3999                 goto END;
4000         }
4001
4002         if (rsp.code != 0) {
4003                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_CONFIG_RESULT,9,
4004                         "%s.", config_strerror(rsp.code));
4005                 fprintf(stderr, "CONFIG ERROR : "
4006                         "%s.\n", config_strerror(rsp.code));
4007                 ret = -1;
4008                 goto END;
4009         }
4010         ret = 0;
4011
4012 END:
4013         destroy_socket();
4014
4015         /*-------- DEBUG LOG --------*/
4016         if (log_level_operate == LOG_LV_DEBUG) {
4017                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,30,
4018                         "out_function : static int operate_log"
4019                         "(void) : "
4020                         "return = %d",
4021                         ret);
4022         }
4023         /*------ DEBUG LOG END ------*/
4024
4025         return ret;
4026 }
4027
4028 /*!
4029  * Operate SNMPAgent command.
4030  * @return      int     result OK=0, NG=<0
4031  */
4032 static int
4033 operate_snmp(void)
4034 {
4035         struct l7vs_config_msg_snmp req;
4036         struct l7vs_config_msg_snmp rsp;
4037         struct l7vsadm_iov_data iov_data;
4038         int ret;
4039
4040         /*-------- DEBUG LOG --------*/
4041         if (log_level_operate == LOG_LV_DEBUG) {
4042                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,31,
4043                         "in_function : static int operate_snmp(void) : ");
4044         }
4045         /*------ DEBUG LOG END ------*/
4046
4047         ret = create_socket();
4048         if (ret < 0) {
4049                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,28,
4050                         "Create socket error.");
4051
4052                 /*-------- DEBUG LOG --------*/
4053                 if (log_level_operate == LOG_LV_DEBUG) {
4054                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,32,
4055                                 "out_function : static int operate_snmp"
4056                                 "(void) : "
4057                                 "return = -1");
4058                 }
4059                 /*------ DEBUG LOG END ------*/
4060
4061                 return -1;
4062         }
4063
4064         memset(&req, 0, sizeof(struct l7vs_config_msg_snmp));
4065         memset(&rsp, 0, sizeof(struct l7vs_config_msg_snmp));
4066         memset(&iov_data, 0, sizeof(struct l7vsadm_iov_data));
4067
4068         if (l7vsadm_option_data.category_all_flag == 1) {
4069                 req.cmd = L7VS_CONFIG_SET_SNMP_LOG_LEVEL_ALL;
4070         } else {
4071                 req.cmd = L7VS_CONFIG_SET_SNMP_LOG_LEVEL;
4072         }
4073         req.kind = l7vsadm_option_data.log_category;
4074         req.snmp_log_level = l7vsadm_option_data.log_level;
4075
4076         // Set data for request
4077         iov_data.req_iov[0].iov_base = &req;
4078         iov_data.req_iov[0].iov_len = sizeof(req);
4079         iov_data.req_cnt = 1;
4080
4081         // Set data for response
4082         iov_data.rsp_iov[0].iov_base = &rsp;
4083         iov_data.rsp_iov[0].iov_len = sizeof(rsp);
4084         iov_data.rsp_cnt = 1;
4085
4086         ret = communicate_to_l7vsd(&iov_data);
4087         if (ret < 0) {
4088                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,29,
4089                         "Communicate to l7vsd error.");
4090                 goto END;
4091         }
4092
4093         if (rsp.code != 0) {
4094                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_CONFIG_RESULT,10,
4095                         "%s.", config_strerror(rsp.code));
4096                 fprintf(stderr, "CONFIG ERROR : "
4097                         "%s.\n", config_strerror(rsp.code));
4098                 ret = -1;
4099                 goto END;
4100         }
4101         ret = 0;
4102
4103 END:
4104         destroy_socket();
4105
4106         /*-------- DEBUG LOG --------*/
4107         if (log_level_operate == LOG_LV_DEBUG) {
4108                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,33,
4109                         "out_function : static int operate_snmp"
4110                         "(void) : "
4111                         "return = %d",
4112                         ret);
4113         }
4114         /*------ DEBUG LOG END ------*/
4115
4116         return ret;
4117 }
4118
4119 /*!
4120  * Operate Parameter command.
4121  * @return      int     result OK=0, NG=<0
4122  */
4123 static int
4124 operate_parameter(void)
4125 {
4126         struct l7vs_config_msg_parameter req;
4127         struct l7vs_config_msg_parameter rsp;
4128         struct l7vsadm_iov_data iov_data;
4129         int ret;
4130
4131         /*-------- DEBUG LOG --------*/
4132         if (log_level_operate == LOG_LV_DEBUG) {
4133                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,34,
4134                         "in_function : static int operate_parameter(void) : ");
4135         }
4136         /*------ DEBUG LOG END ------*/
4137
4138         ret = create_socket();
4139         if (ret < 0) {
4140                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,30,
4141                         "Create socket error.");
4142
4143                 /*-------- DEBUG LOG --------*/
4144                 if (log_level_operate == LOG_LV_DEBUG) {
4145                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,35,
4146                                 "out_function : static int operate_parameter"
4147                                 "(void) : "
4148                                 "return = -1");
4149                 }
4150                 /*------ DEBUG LOG END ------*/
4151
4152                 return -1;
4153         }
4154
4155         memset(&req, 0, sizeof(struct l7vs_config_msg_parameter));
4156         memset(&rsp, 0, sizeof(struct l7vs_config_msg_parameter));
4157         memset(&iov_data, 0, sizeof(struct l7vsadm_iov_data));
4158
4159         req.cmd = L7VS_CONFIG_PARAMETER;
4160         req.category = l7vsadm_option_data.reload_param;
4161
4162         // Set data for request
4163         iov_data.req_iov[0].iov_base = &req;
4164         iov_data.req_iov[0].iov_len = sizeof(req);
4165         iov_data.req_cnt = 1;
4166
4167         // Set data for response
4168         iov_data.rsp_iov[0].iov_base = &rsp;
4169         iov_data.rsp_iov[0].iov_len = sizeof(rsp);
4170         iov_data.rsp_cnt = 1;
4171
4172         ret = communicate_to_l7vsd(&iov_data);
4173         if (ret < 0) {
4174                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,31,
4175                         "Communicate to l7vsd error.");
4176                 goto END;
4177         }
4178
4179         if (rsp.code != 0) {
4180                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_CONFIG_RESULT,11,
4181                         "%s.", config_strerror(rsp.code));
4182                 fprintf(stderr, "CONFIG ERROR : "
4183                         "%s.\n", config_strerror(rsp.code));
4184                 ret = -1;
4185                 goto END;
4186         }
4187         ret = 0;
4188
4189 END:
4190         destroy_socket();
4191
4192         /*-------- DEBUG LOG --------*/
4193         if (log_level_operate == LOG_LV_DEBUG) {
4194                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,36,
4195                         "out_function : static int operate_parameter"
4196                         "(void) : "
4197                         "return = %d",
4198                         ret);
4199         }
4200         /*------ DEBUG LOG END ------*/
4201
4202         return ret;
4203 }
4204
4205 /*!
4206  * Operate help command.
4207  * @return      int     result OK=0
4208  */
4209 static int
4210 operate_help(void)
4211 {
4212         /*-------- DEBUG LOG --------*/
4213         if (log_level_operate == LOG_LV_DEBUG) {
4214                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,37,
4215                         "in_function : static int operate_help(void) : ");
4216         }
4217         /*------ DEBUG LOG END ------*/
4218
4219         usage(stdout);
4220
4221         fprintf(stdout,
4222         "Commands:\n"
4223         "  --add-service     -A        add virtual service with options\n"
4224         "  --edit-service    -E        edit virtual service with options\n"
4225         "  --delete-service  -D        delete virtual service with options\n"
4226         "  --flush           -C        flush virtual service\n"
4227         "  --add-server      -a        add real server with options\n"
4228         "  --edit-server     -e        edit real server with options\n"
4229         "  --delete-server   -d        delete real server with options\n"
4230         "  --replication     -R        control replication-function\n"
4231         "  --log             -L        control logger-function\n"
4232         "  --snmp            -S        control SNMP Agent-function\n"
4233         "  --parameter       -P        control parameter-function\n"
4234         "  --list            -l        list the table\n"
4235         "  --verbose         -V        list the table in verbose format\n"
4236         "  --key             -K        list the table in key setting format\n"
4237         "  --help            -h        show usage\n"
4238         "\n");
4239
4240         fprintf(stdout,
4241         "Options:\n"
4242         "  --tcp-service   -t service-address     service-address is host:port\n"
4243         "  --proto-module  -m proto-module        protocol module name and module argment\n"
4244         "                     [module-args]\n"
4245         "  --scheduler     -s scheduler           one of rr,lc,wrr\n"
4246         "  --upper         -u connection-count    maximum number of connections\n"
4247         "  --bypass        -b sorry-server        sorry server address is host:port\n"
4248         "  --flag          -f sorry-flag          sorry status set to virtual service\n"
4249         "  --qos-up        -Q QoSval-up           QoS Threshold(bps) set to real server direction\n"
4250         "  --qos-down      -q QoSval-down         QoS Threshold(bps) set to client direction\n"
4251         "  --real-server   -r server-address      server-address is host:port\n"
4252         "  --weight        -w weight              scheduling weight set to real server\n"
4253         "  --switch        -s replication-switch  start or stop replication\n"
4254         "  --force         -f                     force replication start\n"
4255         "  --dump          -d                     dump replication memory\n"
4256         "  --category      -c log-category        set log category for l7vsd or SNMP Agent\n"
4257         "  --level         -l log-level           set log level for l7vsd or SNMP Agent\n"
4258         "  --reload        -r reload-parameter    reload specified config parameter\n"
4259         "  --numeric       -n                     list the table in numeric\n"
4260         "\n");
4261
4262         /*-------- DEBUG LOG --------*/
4263         if (log_level_operate == LOG_LV_DEBUG) {
4264                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,38,
4265                         "out_function : static int operate_help"
4266                         "(void) : "
4267                         "return = 0");
4268         }
4269         /*------ DEBUG LOG END ------*/
4270
4271         return 0;
4272 }
4273
4274 /*!
4275  * List Replication information.
4276  * @return      int     list result OK=0, NG=-1
4277  */
4278 static int
4279 list_replication_info(void)
4280 {
4281         struct l7vs_config_msg_replication req;
4282         struct l7vs_config_msg_replication rsp;
4283         struct l7vsadm_iov_data iov_data;
4284         int ret;
4285         char *mode = NULL;
4286
4287         /*-------- DEBUG LOG --------*/
4288         if (log_level_operate == LOG_LV_DEBUG) {
4289                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,39,
4290                         "in_function : static int list_replication_info(void) : ");
4291         }
4292         /*------ DEBUG LOG END ------*/
4293
4294         memset(&req, 0, sizeof(struct l7vs_config_msg_replication));
4295         memset(&rsp, 0, sizeof(struct l7vs_config_msg_replication));
4296         memset(&iov_data, 0, sizeof(struct l7vsadm_iov_data));
4297
4298         req.cmd = L7VS_CONFIG_GET_REPLICATION_INFO;
4299
4300         // Set data for request
4301         iov_data.req_iov[0].iov_base = &req;
4302         iov_data.req_iov[0].iov_len = sizeof(req);
4303         iov_data.req_cnt = 1;
4304
4305         // Set data for response
4306         iov_data.rsp_iov[0].iov_base = &rsp;
4307         iov_data.rsp_iov[0].iov_len = sizeof(rsp);
4308         iov_data.rsp_cnt = 1;
4309
4310         ret = communicate_to_l7vsd(&iov_data);
4311         if (ret < 0) {
4312                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,32,
4313                         "Communicate to l7vsd error.");
4314                 goto END;
4315         }
4316
4317         if (rsp.code != 0) {
4318                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_CONFIG_RESULT,12,
4319                         "%s.", config_strerror(rsp.code));
4320                 fprintf(stderr, "CONFIG ERROR : "
4321                         "%s.\n", config_strerror(rsp.code));
4322                 ret = -1;
4323                 goto END;
4324         }
4325
4326         // Convert Replication mode to string.
4327         switch (rsp.replication_mode) {
4328         case REPLICATION_OUT:
4329                 mode = "OUT";
4330                 break;
4331         case REPLICATION_SINGLE:
4332                 mode = "SINGLE";
4333                 break;
4334         case REPLICATION_MASTER:
4335                 mode = "MASTER";
4336                 break;
4337         case REPLICATION_SLAVE:
4338                 mode = "SLAVE";
4339                 break;
4340         case REPLICATION_MASTER_STOP:
4341                 mode = "MASTER_STOP";
4342                 break;
4343         case REPLICATION_SLAVE_STOP:
4344                 mode = "SLAVE_STOP";
4345                 break;
4346         default:
4347                 break;
4348         }
4349
4350         // Print Replication info.
4351         printf("Replication Mode:\n");
4352         if (mode != NULL) {
4353                 printf("%s\n", mode);
4354         } else {
4355                 // Mode is NULL.
4356                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_OPERATE,2,
4357                         "Invalid Replication Mode.");
4358         }
4359         printf("\n");
4360
4361         ret = 0;
4362
4363 END:
4364         /*-------- DEBUG LOG --------*/
4365         if (log_level_operate == LOG_LV_DEBUG) {
4366                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,40,
4367                         "out_function : static int list_replication_info"
4368                         "(void) : "
4369                         "return = %d",
4370                         ret);
4371         }
4372         /*------ DEBUG LOG END ------*/
4373
4374         return ret;
4375 }
4376
4377 /*!
4378  * List Logger information.
4379  * @return      int     list result OK=0, NG=-1
4380  */
4381 static int
4382 list_log_info(void)
4383 {
4384         struct l7vs_config_msg_log req;
4385         struct l7vs_config_msg_log rsp;
4386         struct l7vsadm_iov_data iov_data;
4387         int ret;
4388         struct l7vsadm_category_name_list *cat_list;
4389         struct l7vsadm_level_name_list *lv_list;
4390
4391         /*-------- DEBUG LOG --------*/
4392         if (log_level_operate == LOG_LV_DEBUG) {
4393                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,41,
4394                         "in_function : static int list_log_info(void) : ");
4395         }
4396         /*------ DEBUG LOG END ------*/
4397
4398         // Print Logger info header.
4399         printf("L7vsd Log Level:\n");
4400         printf("Category                       Level\n");
4401
4402         // Get and List all category log level.
4403         for (cat_list = l7vsd_category_name_table;
4404              cat_list->category_name != NULL;
4405              cat_list++) {
4406                 memset(&req, 0, sizeof(struct l7vs_config_msg_log));
4407                 memset(&rsp, 0, sizeof(struct l7vs_config_msg_log));
4408                 memset(&iov_data, 0, sizeof(struct l7vsadm_iov_data));
4409
4410                 req.cmd = L7VS_CONFIG_GET_LOG_INFO;
4411                 req.kind = cat_list->category_code;
4412
4413                 // Set data for request
4414                 iov_data.req_iov[0].iov_base = &req;
4415                 iov_data.req_iov[0].iov_len = sizeof(req);
4416                 iov_data.req_cnt = 1;
4417
4418                 // Set data for response
4419                 iov_data.rsp_iov[0].iov_base = &rsp;
4420                 iov_data.rsp_iov[0].iov_len = sizeof(rsp);
4421                 iov_data.rsp_cnt = 1;
4422
4423                 ret = communicate_to_l7vsd(&iov_data);
4424                 if (ret < 0) {
4425                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,33,
4426                                 "Communicate to l7vsd error.");
4427                         goto END;
4428                 }
4429
4430                 if (rsp.code != 0) {
4431                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_CONFIG_RESULT,13,
4432                                 "%s.", config_strerror(rsp.code));
4433                         fprintf(stderr, "CONFIG ERROR : "
4434                                 "%s.\n", config_strerror(rsp.code));
4435                         ret = -1;
4436                         goto END;
4437                 }
4438
4439                 // Convert log level to string.
4440                 for (lv_list = level_name_table;
4441                      lv_list->level_name != NULL;
4442                      lv_list++) {
4443                         if (rsp.vsd_log_level == lv_list->level_code) {
4444                                 printf("%-30s %s\n",
4445                                         cat_list->category_name,
4446                                         lv_list->level_name);
4447                                 break;
4448                         }
4449                 }
4450         }
4451         printf("\n");
4452
4453         ret = 0;
4454
4455 END:
4456         /*-------- DEBUG LOG --------*/
4457         if (log_level_operate == LOG_LV_DEBUG) {
4458                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,42,
4459                         "out_function : static int list_log_info"
4460                         "(void) : "
4461                         "return = %d",
4462                         ret);
4463         }
4464         /*------ DEBUG LOG END ------*/
4465
4466         return ret;
4467 }
4468
4469 /*!
4470  * List SNMPAgent information.
4471  * @return      int     list result OK=0, NG=-1
4472  */
4473 static int
4474 list_snmp_info(void)
4475 {
4476         struct l7vs_config_msg_snmp req;
4477         struct l7vs_config_msg_snmp rsp;
4478         struct l7vsadm_iov_data iov_data;
4479         int ret;
4480         struct l7vsadm_category_name_list *cat_list;
4481         struct l7vsadm_level_name_list *lv_list;
4482
4483         /*-------- DEBUG LOG --------*/
4484         if (log_level_operate == LOG_LV_DEBUG) {
4485                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,43,
4486                         "in_function : static int list_snmp_info(void) : ");
4487         }
4488         /*------ DEBUG LOG END ------*/
4489
4490         memset(&req, 0, sizeof(struct l7vs_config_msg_snmp));
4491         memset(&rsp, 0, sizeof(struct l7vs_config_msg_snmp));
4492         memset(&iov_data, 0, sizeof(struct l7vsadm_iov_data));
4493
4494         req.cmd = L7VS_CONFIG_GET_SNMP_CONNECT_STATUS;
4495
4496         // Set data for request
4497         iov_data.req_iov[0].iov_base = &req;
4498         iov_data.req_iov[0].iov_len = sizeof(req);
4499         iov_data.req_cnt = 1;
4500
4501         // Set data for response
4502         iov_data.rsp_iov[0].iov_base = &rsp;
4503         iov_data.rsp_iov[0].iov_len = sizeof(rsp);
4504         iov_data.rsp_cnt = 1;
4505
4506         ret = communicate_to_l7vsd(&iov_data);
4507         if (ret < 0) {
4508                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,34,
4509                         "Communicate to l7vsd error.");
4510                 goto END;
4511         }
4512
4513         if (rsp.code != 0) {
4514                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_CONFIG_RESULT,14,
4515                         "%s.", config_strerror(rsp.code));
4516                 fprintf(stderr, "CONFIG ERROR : "
4517                         "%s.\n", config_strerror(rsp.code));
4518                 ret = -1;
4519                 goto END;
4520         }
4521
4522         // Print SNMP connection status header.
4523         printf("SNMPAgent Connection Status:\n");
4524         // Print SNMP connection status.
4525         if (rsp.connection_status == 1) {
4526                 printf("connecting\n");
4527         } else {
4528                 printf("non-connecting\n");
4529         }
4530         printf("\n");
4531
4532         // Print SNMPAgent Log header.
4533         printf("SNMPAgent Log Level:\n");
4534         printf("Category                       Level\n");
4535
4536         // Get and List all category SNMPAgent log level.
4537         for (cat_list = snmp_category_name_table;
4538              cat_list->category_name != NULL;
4539              cat_list++) {
4540                 memset(&req, 0, sizeof(struct l7vs_config_msg_snmp));
4541                 memset(&rsp, 0, sizeof(struct l7vs_config_msg_snmp));
4542                 memset(&iov_data, 0, sizeof(struct l7vsadm_iov_data));
4543
4544                 req.cmd = L7VS_CONFIG_GET_SNMP_LOG_INFO;
4545                 req.kind = cat_list->category_code;
4546
4547                 // Set data for request
4548                 iov_data.req_iov[0].iov_base = &req;
4549                 iov_data.req_iov[0].iov_len = sizeof(req);
4550                 iov_data.req_cnt = 1;
4551
4552                 // Set data for response
4553                 iov_data.rsp_iov[0].iov_base = &rsp;
4554                 iov_data.rsp_iov[0].iov_len = sizeof(rsp);
4555                 iov_data.rsp_cnt = 1;
4556
4557                 ret = communicate_to_l7vsd(&iov_data);
4558                 if (ret < 0) {
4559                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,35,
4560                                 "Communicate to l7vsd error.");
4561                         goto END;
4562                 }
4563
4564                 if (rsp.code != 0) {
4565                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_CONFIG_RESULT,15,
4566                                 "%s.", config_strerror(rsp.code));
4567                         fprintf(stderr, "CONFIG ERROR : "
4568                                 "%s.\n", config_strerror(rsp.code));
4569                         ret = -1;
4570                         goto END;
4571                 }
4572
4573                 // Convert log level to string.
4574                 for (lv_list = level_name_table;
4575                      lv_list->level_name != NULL;
4576                      lv_list++) {
4577                         if (rsp.snmp_log_level == lv_list->level_code) {
4578                                 printf("%-30s %s\n",
4579                                         cat_list->category_name,
4580                                         lv_list->level_name);
4581                                 break;
4582                         }
4583                 }
4584         }
4585         printf("\n");
4586
4587         ret = 0;
4588
4589 END:
4590         /*-------- DEBUG LOG --------*/
4591         if (log_level_operate == LOG_LV_DEBUG) {
4592                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,44,
4593                         "out_function : static int list_snmp_info"
4594                         "(void) : "
4595                         "return = %d",
4596                         ret);
4597         }
4598         /*------ DEBUG LOG END ------*/
4599
4600         return ret;
4601 }
4602
4603 /*!
4604  * Get list of VirtualService information.
4605  * @param[in,out]       *vs_buffer      VirtualService list buffer pointer
4606  * @param[in]           vs_bufsize      size of vs_buffer
4607  * @return              int             number of VirtualService, NG<0
4608  */
4609 static int
4610 get_vs(void *vs_buffer, int vs_bufsize)
4611 {
4612         struct l7vs_config_req_list_vs req;
4613         struct l7vs_config_rsp_list_vs rsp;
4614         struct l7vsadm_iov_data iov_data;
4615         int ret;
4616
4617         // Argment check.
4618         if (vs_buffer == NULL) {
4619                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,36,
4620                         "Argument vs_buffer is NULL.");
4621                 fprintf(stderr, "OPERATE ERROR : "
4622                         "Argument vs_buffer is NULL.\n");
4623
4624                 /*-------- DEBUG LOG --------*/
4625                 if (log_level_operate == LOG_LV_DEBUG) {
4626                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,45,
4627                                 "out_function : static int get_vs"
4628                                 "(void *vs_buffer, int vs_bufsize) : "
4629                                 "return = -1");
4630                 }
4631                 /*------ DEBUG LOG END ------*/
4632
4633                 return -1;
4634         }
4635
4636         /*-------- DEBUG LOG --------*/
4637         if (log_level_operate == LOG_LV_DEBUG) {
4638                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,46,
4639                         "in_function : static int get_vs"
4640                         "(void *vs_buffer, int vs_bufsize) : "
4641                         "vs_buffer = %p, vs_bufsize = %d",
4642                         vs_buffer,
4643                         vs_bufsize);
4644         }
4645         /*------ DEBUG LOG END ------*/
4646
4647         memset(&req, 0, sizeof(struct l7vs_config_req_list_vs));
4648         memset(&rsp, 0, sizeof(struct l7vs_config_rsp_list_vs));
4649         memset(&iov_data, 0, sizeof(struct l7vsadm_iov_data));
4650
4651         req.cmd = L7VS_CONFIG_LIST_VS;
4652
4653         // Set data for request
4654         iov_data.req_iov[0].iov_base = &req;
4655         iov_data.req_iov[0].iov_len = sizeof(req);
4656         iov_data.req_cnt = 1;
4657
4658         // Set data for response
4659         iov_data.rsp_iov[0].iov_base = &rsp;
4660         iov_data.rsp_iov[0].iov_len = sizeof(rsp);
4661         iov_data.rsp_iov[1].iov_base = vs_buffer;
4662         iov_data.rsp_iov[1].iov_len = vs_bufsize;
4663         iov_data.rsp_cnt = 2;
4664
4665         ret = communicate_to_l7vsd(&iov_data);
4666         if (ret < 0) {
4667                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,37,
4668                         "Communicate to l7vsd error.");
4669                 goto END;
4670         }
4671
4672         if (rsp.code != 0) {
4673                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_CONFIG_RESULT,16,
4674                         "%s.", config_strerror(rsp.code));
4675                 fprintf(stderr, "CONFIG ERROR : "
4676                         "%s.\n", config_strerror(rsp.code));
4677                 ret = -1;
4678                 goto END;
4679         }
4680         ret = rsp.num;
4681
4682 END:
4683         /*-------- DEBUG LOG --------*/
4684         if (log_level_operate == LOG_LV_DEBUG) {
4685                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,47,
4686                         "out_function : static int get_vs"
4687                         "(void *vs_buffer, int vs_bufsize) : "
4688                         "return = %d",
4689                         ret);
4690         }
4691         /*------ DEBUG LOG END ------*/
4692
4693         return ret;
4694 }
4695
4696 /*!
4697  * Get list of RealServer information in the VirtualService.
4698  * @param[in,out]       *darg_buffer    l7vs_dest_arg list pointer
4699  * @param[in]           rs_num          number of l7vs_dest_arg
4700  * @param[in]           *sarg           l7vs_service_arg pointer
4701  * @return              int             number of RealServer, NG<0
4702  */
4703 static int
4704 get_rs(struct l7vs_dest_arg *darg_buffer, int rs_num, struct l7vs_service_arg *sarg)
4705 {
4706         struct l7vs_config_req_list_rs req;
4707         struct l7vs_config_rsp_list_rs rsp;
4708         struct l7vsadm_iov_data iov_data;
4709         int ret;
4710
4711         // Argment check.
4712         if (darg_buffer == NULL) {
4713                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,38,
4714                         "Argument darg_buffer is NULL.");
4715                 fprintf(stderr, "OPERATE ERROR : "
4716                         "Argument darg_buffer is NULL.\n");
4717
4718                 /*-------- DEBUG LOG --------*/
4719                 if (log_level_operate == LOG_LV_DEBUG) {
4720                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,48,
4721                                 "out_function : static int get_rs"
4722                                 "(struct l7vs_dest_arg *darg_buffer, "
4723                                 "int rs_num, struct l7vs_service_arg *sarg) : "
4724                                 "return = -1");
4725                 }
4726                 /*------ DEBUG LOG END ------*/
4727
4728                 return -1;
4729         }
4730         if (sarg == NULL) {
4731                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,39,
4732                         "Argument sarg is NULL.");
4733                 fprintf(stderr, "OPERATE ERROR : "
4734                         "Argument sarg is NULL.\n");
4735
4736                 /*-------- DEBUG LOG --------*/
4737                 if (log_level_operate == LOG_LV_DEBUG) {
4738                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,49,
4739                                 "out_function : static int get_rs"
4740                                 "(struct l7vs_dest_arg *darg_buffer, "
4741                                 "int rs_num, struct l7vs_service_arg *sarg) : "
4742                                 "return = -1");
4743                 }
4744                 /*------ DEBUG LOG END ------*/
4745
4746                 return -1;
4747         }
4748
4749         /*-------- DEBUG LOG --------*/
4750         if (log_level_operate == LOG_LV_DEBUG) {
4751                 char sarg_str[DEBUG_STR_LEN] = {0};
4752                 l7vs_service_arg_c_str(sarg_str, sarg);
4753                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,50,
4754                         "in_function : static int get_rs"
4755                         "(struct l7vs_dest_arg *darg_buffer, "
4756                         "int rs_num, "
4757                         "struct l7vs_service_arg *sarg) : "
4758                         "darg_buffer = %p, "
4759                         "rs_num = %d, "
4760                         "sarg = (%s)",
4761                         darg_buffer,
4762                         rs_num,
4763                         sarg_str);
4764         }
4765         /*------ DEBUG LOG END ------*/
4766
4767         memset(&req, 0, sizeof(struct l7vs_config_req_list_rs));
4768         memset(&rsp, 0, sizeof(struct l7vs_config_rsp_list_rs));
4769         memset(&iov_data, 0, sizeof(struct l7vsadm_iov_data));
4770
4771         req.cmd = L7VS_CONFIG_LIST_RS;
4772
4773         // Set data for request
4774         iov_data.req_iov[0].iov_base = &req;
4775         iov_data.req_iov[0].iov_len = sizeof(req);
4776         iov_data.req_iov[1].iov_base = sarg;
4777         iov_data.req_iov[1].iov_len = sizeof(struct l7vs_service_arg_multi);
4778         iov_data.req_cnt = 2;
4779
4780         // Set data for response
4781         iov_data.rsp_iov[0].iov_base = &rsp;
4782         iov_data.rsp_iov[0].iov_len = sizeof(rsp);
4783         iov_data.rsp_iov[1].iov_base = darg_buffer;
4784         iov_data.rsp_iov[1].iov_len = rs_num * sizeof(struct l7vs_dest_arg);
4785         iov_data.rsp_cnt = 2;
4786
4787         ret = communicate_to_l7vsd(&iov_data);
4788         if (ret < 0) {
4789                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,40,
4790                         "Communicate to l7vsd error.");
4791                 goto END;
4792         }
4793
4794         if (rsp.code != 0) {
4795                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_CONFIG_RESULT,17,
4796                         "%s.", config_strerror(rsp.code));
4797                 fprintf(stderr, "CONFIG ERROR : "
4798                         "%s.\n", config_strerror(rsp.code));
4799                 ret = -1;
4800                 goto END;
4801         }
4802         ret = rsp.num;
4803
4804 END:
4805         /*-------- DEBUG LOG --------*/
4806         if (log_level_operate == LOG_LV_DEBUG) {
4807                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,51,
4808                         "out_function : static int get_rs"
4809                         "(struct l7vs_dest_arg *darg_buffer, "
4810                         "int rs_num, struct l7vs_service_arg *sarg) : "
4811                         "return = %d",
4812                         ret);
4813         }
4814         /*------ DEBUG LOG END ------*/
4815
4816         return ret;
4817 }
4818
4819 /*!
4820  * List one of VirtualService information.
4821  * @param[in]   *sarg   l7vs_service_arg pointer
4822  * @return      int     list result OK=0, NG=-1
4823  */
4824 static int
4825 list_vs(struct l7vs_service_arg *sarg)
4826 {
4827         struct sockaddr_in vs_addr_0;
4828         struct sockaddr_in sorry_addr_in_0;
4829         struct l7vs_dest_arg *darg_buffer;
4830         char *endpoint_name;
4831         int rs_num = L7VSADM_DEFAULT_LIST_RS_RSNUM;
4832         int ret_num;
4833         int ret;
4834         int i;
4835
4836         // Argment check.
4837         if (sarg == NULL) {
4838                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,41,
4839                         "Argument sarg is NULL.");
4840                 fprintf(stderr, "OPERATE ERROR : "
4841                         "Argument sarg is NULL.\n");
4842
4843                 /*-------- DEBUG LOG --------*/
4844                 if (log_level_operate == LOG_LV_DEBUG) {
4845                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,52,
4846                                 "out_function : static int list_vs"
4847                                 "(struct l7vs_service_arg *sarg) : "
4848                                 "return = -1");
4849                 }
4850                 /*------ DEBUG LOG END ------*/
4851
4852                 return -1;
4853         }
4854
4855         /*-------- DEBUG LOG --------*/
4856         if (log_level_operate == LOG_LV_DEBUG) {
4857                 char sarg_str[DEBUG_STR_LEN] = {0};
4858                 l7vs_service_arg_c_str(sarg_str, sarg);
4859                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,53,
4860                         "in_function : static int list_vs"
4861                         "(struct l7vs_service_arg *sarg) : "
4862                         "sarg = (%s)",
4863                         sarg_str);
4864         }
4865         /*------ DEBUG LOG END ------*/
4866
4867         // Check VirtualService address.(Compare vs_addr_0)
4868         memset(&vs_addr_0, 0, sizeof(struct sockaddr_in));
4869         if (memcmp(&sarg->addr, &vs_addr_0, sizeof(struct sockaddr_in)) == 0) {
4870                 // sarg->addr not set.
4871                 endpoint_name = NULL;
4872         } else {
4873                 endpoint_name =
4874                         get_endpoint_name((struct sockaddr_storage *)(&sarg->addr));
4875         }
4876         if (endpoint_name == NULL) {
4877                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_OPERATE,3,
4878                         "Invalid VirtualService address for list_vs.");
4879
4880                 /*-------- DEBUG LOG --------*/
4881                 if (log_level_operate == LOG_LV_DEBUG) {
4882                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,54,
4883                                 "out_function : static int list_vs"
4884                                 "(struct l7vs_service_arg *sarg) : "
4885                                 "return = 0");
4886                 }
4887                 /*------ DEBUG LOG END ------*/
4888
4889                 return 0;
4890         }
4891
4892         // If it ie verbose, display more details else simple details.
4893         if (l7vsadm_option_data.command_code == CMD_LIST_VERBOSE) {
4894                 printf("TCP %s %s %s %d %s\n",
4895                         endpoint_name,
4896                         sarg->protomod,
4897                         sarg->schedmod,
4898                         sarg->reschedule,
4899                         sarg->protomod_opt_string);
4900         } else if (l7vsadm_option_data.command_code == CMD_LIST_KEY) {
4901                 printf("TCP %s %s %s %d %s\n",
4902                         endpoint_name,
4903                         sarg->protomod,
4904                         sarg->schedmod,
4905                         sarg->reschedule,
4906                         sarg->protomod_key_string);
4907         } else {
4908                 printf("TCP %s %s %s\n",
4909                         endpoint_name,
4910                         sarg->protomod,
4911                         sarg->schedmod);
4912         }
4913
4914         // Print sorry and QoS information when L7VSADM_OP_VERBOSE.
4915         if (l7vsadm_option_data.command_code == CMD_LIST_VERBOSE) {
4916                 // Check sorry address.(Compare sorry_addr_0)
4917                 memset(&sorry_addr_in_0, 0, sizeof(struct sockaddr_in));
4918                 if (memcmp(&sarg->sorry_addr,
4919                            &sorry_addr_in_0,
4920                            sizeof(struct sockaddr_in)) == 0) {
4921                         // sarg->sorry_addr not set.
4922                         endpoint_name = NULL;
4923                 } else {
4924                         endpoint_name =
4925                                 get_endpoint_name((struct sockaddr_storage *)(&sarg->sorry_addr));
4926                 }
4927                 // If endpoint_name is NULL then string is "none".
4928                 if (endpoint_name == NULL) {
4929                         endpoint_name = "none";
4930                 }
4931                 printf("    %s %d %d\n",
4932                         endpoint_name,
4933                         sarg->sorry_cc,
4934                         sarg->sorry_flag);
4935                 // QoS value and throughput convert from byte/s to bps.
4936                 printf("    %lld %lld\n",
4937                         sarg->qos_threshold_up * 8,
4938                         sarg->throughput_to_server * 8);
4939                 printf("    %lld %lld\n",
4940                         sarg->qos_threshold_down * 8,
4941                         sarg->throughput_to_client * 8);
4942         }
4943
4944 RETRY:
4945         // Alloc RealServer list memory.
4946         darg_buffer = (struct l7vs_dest_arg *)malloc(rs_num * sizeof(struct l7vs_dest_arg));
4947
4948         /*-------- DEBUG LOG --------*/
4949         if (log_level_common == LOG_LV_DEBUG) {
4950                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,4,
4951                         "malloc darg_buffer : "
4952                         "allocate address = %p "
4953                         "allocate size = %d",
4954                         darg_buffer,
4955                         int(rs_num * sizeof(struct l7vs_dest_arg)));
4956         }
4957         /*------ DEBUG LOG END ------*/
4958
4959         if (darg_buffer == NULL) {
4960                 LOGGER_PUT_LOG_FATAL(LOG_CAT_L7VSADM_COMMON,5,
4961                         "Could not allocate darg_buffer memory.");
4962                 fprintf(stderr, "COMMON ERROR : "
4963                         "Could not allocate darg_buffer memory.\n");
4964
4965                 /*-------- DEBUG LOG --------*/
4966                 if (log_level_operate == LOG_LV_DEBUG) {
4967                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,55,
4968                                 "out_function : static int list_vs"
4969                                 "(struct l7vs_service_arg *sarg) : "
4970                                 "return = -1");
4971                 }
4972                 /*------ DEBUG LOG END ------*/
4973
4974                 return -1;
4975         }
4976         // Get all RealServer list on VirtualService.
4977         ret_num = get_rs(darg_buffer, rs_num, sarg);
4978         // If return L7VSADM_RECV_TOO_LARGE (-2) when extend darg_buffer size and retry.
4979         if (ret_num < 0) {
4980                 free(darg_buffer);
4981
4982                 /*-------- DEBUG LOG --------*/
4983                 if (log_level_common == LOG_LV_DEBUG) {
4984                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,5,
4985                                 "free darg_buffer : "
4986                                 "free address = %p",
4987                                 darg_buffer);
4988                 }
4989                 /*------ DEBUG LOG END ------*/
4990
4991                 if (ret_num == L7VSADM_RECV_TOO_LARGE) {
4992                         rs_num += L7VSADM_DEFAULT_LIST_RS_RSNUM;
4993                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_OPERATE,4,
4994                                 "Receive RealServer data too large. retrying.");
4995                         goto RETRY;
4996                 }
4997                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,42,
4998                         "Get RealServer data error.");
4999                 fprintf(stderr, "OPERATE ERROR : "
5000                         "Get RealServer data error.\n");
5001
5002                 /*-------- DEBUG LOG --------*/
5003                 if (log_level_operate == LOG_LV_DEBUG) {
5004                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,56,
5005                                 "out_function : static int list_vs"
5006                                 "(struct l7vs_service_arg *sarg) : "
5007                                 "return = -1");
5008                 }
5009                 /*------ DEBUG LOG END ------*/
5010
5011                 return -1;
5012         }
5013         // List all RealServer.
5014         for (i = 0; i < ret_num; i++) {
5015                 ret = list_rs(&darg_buffer[i]);
5016                 if (ret < 0) {
5017                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,43,
5018                                 "List RealServer data error.");
5019                         fprintf(stderr, "OPERATE ERROR : "
5020                                 "List RealServer data error.\n");
5021                         free(darg_buffer);
5022
5023                         /*-------- DEBUG LOG --------*/
5024                         if (log_level_common == LOG_LV_DEBUG) {
5025                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,6,
5026                                         "free darg_buffer : "
5027                                         "free address = %p",
5028                                         darg_buffer);
5029                         }
5030                         /*------ DEBUG LOG END ------*/
5031
5032                         /*-------- DEBUG LOG --------*/
5033                         if (log_level_operate == LOG_LV_DEBUG) {
5034                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,57,
5035                                         "out_function : static int list_vs"
5036                                         "(struct l7vs_service_arg *sarg) : "
5037                                         "return = -1");
5038                         }
5039                         /*------ DEBUG LOG END ------*/
5040
5041                         return -1;
5042                 }
5043         }
5044
5045         free(darg_buffer);
5046
5047         /*-------- DEBUG LOG --------*/
5048         if (log_level_common == LOG_LV_DEBUG) {
5049                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,7,
5050                         "free darg_buffer : "
5051                         "free address = %p",
5052                         darg_buffer);
5053         }
5054         /*------ DEBUG LOG END ------*/
5055
5056         /*-------- DEBUG LOG --------*/
5057         if (log_level_operate == LOG_LV_DEBUG) {
5058                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,58,
5059                         "out_function : static int list_vs"
5060                         "(struct l7vs_service_arg *sarg) : "
5061                         "return = 0");
5062         }
5063         /*------ DEBUG LOG END ------*/
5064
5065         return 0;
5066 }
5067
5068 /*!
5069  * List one of RealServer information.
5070  * @param[in]   *darg   l7vs_dest_arg pointer
5071  * @return      int     list result OK=0, NG=-1
5072  */
5073 static int
5074 list_rs(struct l7vs_dest_arg *darg)
5075 {
5076         struct sockaddr_in rs_addr_0;
5077         char *endpoint_name;
5078
5079         // Argment check.
5080         if (darg == NULL) {
5081                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,44,
5082                         "Argument darg is NULL.");
5083                 fprintf(stderr, "OPERATE ERROR : "
5084                         "Argument darg is NULL.\n");
5085
5086                 /*-------- DEBUG LOG --------*/
5087                 if (log_level_operate == LOG_LV_DEBUG) {
5088                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,59,
5089                                 "out_function : static int list_rs"
5090                                 "(struct l7vs_dest_arg *darg) : "
5091                                 "return = -1");
5092                 }
5093                 /*------ DEBUG LOG END ------*/
5094
5095                 return -1;
5096         }
5097
5098         /*-------- DEBUG LOG --------*/
5099         if (log_level_operate == LOG_LV_DEBUG) {
5100                 char darg_str[DEBUG_STR_LEN] = {0};
5101                 l7vs_darg_c_str(darg_str, darg);
5102                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,60,
5103                         "in_function : static int list_rs"
5104                         "(struct l7vs_dest_arg *darg) : "
5105                         "darg = (%s)",
5106                         darg_str);
5107         }
5108         /*------ DEBUG LOG END ------*/
5109
5110         // Check RealServer address.(Compare rs_addr_0)
5111         memset(&rs_addr_0, 0, sizeof(struct sockaddr_in));
5112         if (memcmp(&darg->addr, &rs_addr_0, sizeof(struct sockaddr_in)) == 0) {
5113                 // darg.addr not set.
5114                 endpoint_name = NULL;
5115         } else {
5116                 endpoint_name =
5117                         get_endpoint_name((struct sockaddr_storage *)(&darg->addr));
5118         }
5119         if (endpoint_name == NULL) {
5120                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_OPERATE,5,
5121                         "Invalid RealServer address for list_rs.");
5122
5123                 /*-------- DEBUG LOG --------*/
5124                 if (log_level_operate == LOG_LV_DEBUG) {
5125                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,61,
5126                                 "out_function : static int list_rs"
5127                                 "(struct l7vs_dest_arg *darg) : "
5128                                 "return = 0");
5129                 }
5130                 /*------ DEBUG LOG END ------*/
5131
5132                 return 0;
5133         }
5134
5135         // Display RealServer.
5136         printf("  -> %-28s %-7s %-6d %-10d %-10d\n",
5137                 endpoint_name, "Masq", darg->weight, darg->nactive, darg->ninact);
5138
5139         /*-------- DEBUG LOG --------*/
5140         if (log_level_operate == LOG_LV_DEBUG) {
5141                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,62,
5142                         "out_function : static int list_rs"
5143                         "(struct l7vs_dest_arg *darg) : "
5144                         "return = 0");
5145         }
5146         /*------ DEBUG LOG END ------*/
5147
5148         return 0;
5149 }
5150
5151 /*!
5152  * Get endpoint name string.
5153  * Translate form address to endpoint string(hostname:portname)
5154  * @param[in]   *addr   endpoint data
5155  * @return      char *  endpoint string, NG=NULL
5156  */
5157 static char *
5158 get_endpoint_name(struct sockaddr_storage *addr)
5159 {
5160         char hostname[NI_MAXHOST], portname[NI_MAXSERV];
5161         int flags;
5162         int ret;
5163
5164         // Argment check.
5165         if (addr == NULL) {
5166                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,45,
5167                         "Argument addr is NULL.");
5168                 fprintf(stderr, "OPERATE ERROR : "
5169                         "Argument addr is NULL.\n");
5170
5171                 /*-------- DEBUG LOG --------*/
5172                 if (log_level_operate == LOG_LV_DEBUG) {
5173                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,63,
5174                                 "out_function : static char *get_endpoint_name"
5175                                 "(struct sockaddr_storage *addr) : "
5176                                 "return = NULL");
5177                 }
5178                 /*------ DEBUG LOG END ------*/
5179
5180                 return NULL;
5181         }
5182
5183         /*-------- DEBUG LOG --------*/
5184         if (log_level_operate == LOG_LV_DEBUG) {
5185                 char ep_str[DEBUG_STR_LEN] = {0};
5186                 endpoint_c_str(ep_str, (void *)addr);
5187                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,64,
5188                         "in_function : static char *get_endpoint_name"
5189                         "(struct sockaddr_storage *addr) : "
5190                         "addr = (%s)",
5191                         ep_str);
5192         }
5193         /*------ DEBUG LOG END ------*/
5194
5195
5196         if (l7vsadm_option_data.isnumeric != 0 &&
5197             l7vsadm_option_data.isnumeric != 1) {
5198                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,46,
5199                         "Invalid isnumeric value.");
5200                 fprintf(stderr, "OPERATE ERROR : "
5201                         "Invalid isnumeric value.\n");
5202
5203                 /*-------- DEBUG LOG --------*/
5204                 if (log_level_operate == LOG_LV_DEBUG) {
5205                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,65,
5206                                 "out_function : static char *get_endpoint_name"
5207                                 "(struct sockaddr_storage *addr) : "
5208                                 "return = NULL");
5209                 }
5210                 /*------ DEBUG LOG END ------*/
5211
5212                 return NULL;
5213         }
5214
5215         flags = 0;
5216         if (l7vsadm_option_data.isnumeric) {
5217                 flags = NI_NUMERICHOST | NI_NUMERICSERV;
5218         }
5219
5220         ret = getnameinfo((struct sockaddr *)addr, sizeof(*addr),
5221                           hostname, sizeof(hostname),
5222                           portname, sizeof(portname), flags);
5223         if (ret == EAI_AGAIN) {
5224                 flags = flags | NI_NUMERICHOST;
5225                 ret = getnameinfo((struct sockaddr *)addr, sizeof(*addr),
5226                                 hostname, sizeof(hostname),
5227                                 portname, sizeof(portname), flags);
5228                 if (ret != 0) {
5229                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMON,2,
5230                                 "getnameinfo() error: %s.", gai_strerror(ret));
5231                         fprintf(stderr, "COMMON ERROR : "
5232                                 "getnameinfo() error: %s.\n", gai_strerror(ret));
5233
5234                         /*-------- DEBUG LOG --------*/
5235                         if (log_level_operate == LOG_LV_DEBUG) {
5236                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,66,
5237                                         "out_function : static char *get_endpoint_name"
5238                                         "(struct sockaddr_storage *addr) : "
5239                                         "return = NULL");
5240                         }
5241                         /*------ DEBUG LOG END ------*/
5242
5243                         return NULL;
5244                 }
5245         } else if (ret != 0) {
5246                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMON,3,
5247                         "getnameinfo() error: %s.", gai_strerror(ret));
5248                 fprintf(stderr, "COMMON ERROR : "
5249                         "getnameinfo() error: %s.\n", gai_strerror(ret));
5250
5251                 /*-------- DEBUG LOG --------*/
5252                 if (log_level_operate == LOG_LV_DEBUG) {
5253                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,67,
5254                                 "out_function : static char *get_endpoint_name"
5255                                 "(struct sockaddr_storage *addr) : "
5256                                 "return = NULL");
5257                 }
5258                 /*------ DEBUG LOG END ------*/
5259
5260                 return NULL;
5261         }
5262         memset(tmp_endpoint_name,0x00,sizeof(tmp_endpoint_name));
5263         sprintf(tmp_endpoint_name, "%s:%s", hostname, portname);
5264
5265         /*-------- DEBUG LOG --------*/
5266         if (log_level_operate == LOG_LV_DEBUG) {
5267                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,68,
5268                         "out_function : static char *get_endpoint_name"
5269                         "(struct sockaddr_storage *addr) : "
5270                         "return = %s",
5271                         tmp_endpoint_name);
5272         }
5273         /*------ DEBUG LOG END ------*/
5274
5275         return tmp_endpoint_name;
5276 }
5277
5278 /*!
5279  * Create socket file for communicate.
5280  * @return      int     create result OK=0, NG=-1
5281  */
5282 static int
5283 create_socket(void)
5284 {
5285         struct sockaddr_un addr;
5286         char sockname[sizeof(L7VS_CONFIG_SOCK_PATH) + sizeof(L7VSADM_NAME) + 10];
5287         int opt;
5288         int ret;
5289         int sock_fd;
5290         int retry_count = 0;
5291
5292         /*-------- DEBUG LOG --------*/
5293         if (log_level_operate == LOG_LV_DEBUG) {
5294                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,69,
5295                         "in_function : static int create_socket(void) : ");
5296         }
5297         /*------ DEBUG LOG END ------*/
5298
5299         sprintf(sockname, "%s/%s-%d", L7VS_CONFIG_SOCK_PATH, L7VSADM_NAME, getpid());
5300
5301         unlink(sockname);
5302         if (sizeof(sockname) > sizeof(addr.sun_path)) {
5303                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,47,
5304                         "Internal error. socket name too long.");
5305                 fprintf(stderr, "OPERATE ERROR : "
5306                         "Internal error. socket name too long.\n");
5307                 ret = -1;
5308                 goto END;
5309         }
5310
5311         memset(&addr, 0, sizeof(addr));
5312         memcpy(addr.sun_path, sockname, sizeof(sockname));
5313         addr.sun_family = AF_LOCAL;
5314
5315         sock_fd = socket(PF_LOCAL, SOCK_DGRAM, 0);
5316         if (sock_fd < 0) {
5317                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMON,4,
5318                         "socket() error: %s.", strerror(errno));
5319                 fprintf(stderr, "COMMON ERROR : "
5320                         "socket() error: %s.\n", strerror(errno));
5321                 ret = sock_fd;
5322                 goto END;
5323         }
5324
5325         opt = 1;
5326         ret = setsockopt(sock_fd, SOL_SOCKET, SO_PASSCRED, &opt, sizeof(opt));
5327         if (ret < 0) {
5328                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMON,5,
5329                         "setsockopt() SO_PASSCRED error: %s.", strerror(errno));
5330                 fprintf(stderr, "COMMON ERROR : "
5331                         "setsockopt() SO_PASSCRED error: %s.\n", strerror(errno));
5332                 goto END;
5333         }
5334
5335         ret = bind(sock_fd, (struct sockaddr *)&addr, SUN_LEN(&addr));
5336         if (ret < 0) {
5337                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMON,6,
5338                         "bind() on %s error: %s.", sockname, strerror(errno));
5339                 fprintf(stderr, "COMMON ERROR : "
5340                         "bind() on %s error: %s.\n", sockname, strerror(errno));
5341                 goto END;
5342         }
5343
5344         strcpy(local_sockname, sockname);
5345
5346         memset(&addr, 0, sizeof(addr));
5347         addr.sun_family = AF_LOCAL;
5348         strcpy(addr.sun_path, L7VS_CONFIG_SOCKNAME);
5349
5350         while (1) {
5351                 // Check signal.
5352                 if (signal_flg > 0) {
5353                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMON,7,
5354                                 "Signal (%d) Received.", received_sig);
5355                         fprintf(stderr, "COMMON ERROR : "
5356                                 "Signal (%d) Received.\n", received_sig);
5357                         ret = -1;
5358                         goto END;
5359                 }
5360
5361                 // Try connect to config socket.
5362                 ret = connect(sock_fd, (struct sockaddr *)&addr, SUN_LEN(&addr));
5363                 if (ret == 0) {
5364                         // Connect OK.
5365                         break;
5366                 }
5367                 retry_count++;
5368                 if (retry_count > connect_wait_count) {
5369                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMON,8,
5370                                 "connect() to daemon timeout: %s.", strerror(errno));
5371                         fprintf(stderr, "COMMON ERROR : "
5372                                 "connect() to daemon timeout: %s.\n", strerror(errno));
5373                         goto END;
5374                 }
5375                 // Connect retrying.
5376                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_COMMON,1,
5377                         "connect() to daemon error (retry %d): %s.",
5378                         retry_count, strerror(errno));
5379                 sleep(connect_wait_interval);
5380         }
5381
5382         // Save socket file discripter.
5383         local_sock_fd = sock_fd;
5384         ret = 0;
5385
5386 END:
5387         if (ret < 0) {
5388                 if (sock_fd != -1) {
5389                         close(sock_fd);
5390                 }
5391         }
5392
5393         /*-------- DEBUG LOG --------*/
5394         if (log_level_operate == LOG_LV_DEBUG) {
5395                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,70,
5396                         "out_function : static int create_socket"
5397                         "(void) : "
5398                         "return = %d",
5399                         ret);
5400         }
5401         /*------ DEBUG LOG END ------*/
5402
5403         return ret;
5404 }
5405
5406 /*!
5407  * Destroy socket file for communicate.
5408  */
5409 static void
5410 destroy_socket(void)
5411 {
5412         /*-------- DEBUG LOG --------*/
5413         if (log_level_operate == LOG_LV_DEBUG) {
5414                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,71,
5415                         "in_function : static void destroy_socket(void) : ");
5416         }
5417         /*------ DEBUG LOG END ------*/
5418
5419         unlink(local_sockname);
5420
5421         /*-------- DEBUG LOG --------*/
5422         if (log_level_operate == LOG_LV_DEBUG) {
5423                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,72,
5424                         "out_function : static void destroy_socket(void) : ");
5425         }
5426         /*------ DEBUG LOG END ------*/
5427 }
5428
5429 /*!
5430  * Communicate to l7vsd daemon.
5431  * Send request and receive response between l7vsd daemon
5432  * @param[in,out]       *iov_data       io-vector data pointer
5433  * @return              int             communicate result OK=byte, NG=-1
5434  */
5435 static int
5436 communicate_to_l7vsd(struct l7vsadm_iov_data *iov_data)
5437 {
5438         int ret;
5439
5440         // Argment check.
5441         if (iov_data == NULL) {
5442                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMUNICATE,1,
5443                         "Argument iov_data is NULL.");
5444                 fprintf(stderr, "COMMUNICATE ERROR : "
5445                         "Argument iov_data is NULL.\n");
5446
5447                 /*-------- DEBUG LOG --------*/
5448                 if (log_level_communicate == LOG_LV_DEBUG) {
5449                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMUNICATE,1,
5450                                 "out_function : static int communicate_to_l7vsd"
5451                                 "(struct l7vsadm_iov_data *iov_data) : "
5452                                 "return = -1");
5453                 }
5454                 /*------ DEBUG LOG END ------*/
5455
5456                 return -1;
5457         }
5458
5459         /*-------- DEBUG LOG --------*/
5460         if (log_level_communicate == LOG_LV_DEBUG) {
5461                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMUNICATE,2,
5462                         "in_function : static int communicate_to_l7vsd"
5463                         "(struct l7vsadm_iov_data *iov_data) : "
5464                         "iov_data = %p",
5465                         iov_data);
5466         }
5467         /*------ DEBUG LOG END ------*/
5468
5469         // Check signal.
5470         if (signal_flg > 0) {
5471                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMON,9,
5472                         "Signal (%d) Received.", received_sig);
5473                 fprintf(stderr, "COMMON ERROR : "
5474                         "Signal (%d) Received.\n", received_sig);
5475
5476                 /*-------- DEBUG LOG --------*/
5477                 if (log_level_communicate == LOG_LV_DEBUG) {
5478                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMUNICATE,3,
5479                                 "out_function : static int communicate_to_l7vsd"
5480                                 "(struct l7vsadm_iov_data *iov_data) : "
5481                                 "return = -1");
5482                 }
5483                 /*------ DEBUG LOG END ------*/
5484
5485                 return -1;
5486         }
5487
5488         ret = send_request(iov_data->req_iov, iov_data->req_cnt);
5489         if (ret < 0) {
5490                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMUNICATE,2,
5491                         "Send Request error.");
5492
5493                 /*-------- DEBUG LOG --------*/
5494                 if (log_level_communicate == LOG_LV_DEBUG) {
5495                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMUNICATE,4,
5496                                 "out_function : static int communicate_to_l7vsd"
5497                                 "(struct l7vsadm_iov_data *iov_data) : "
5498                                 "return = %d",
5499                                 ret);
5500                 }
5501                 /*------ DEBUG LOG END ------*/
5502
5503                 return ret;
5504         }
5505
5506         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSADM_COMMUNICATE,1,
5507                 "Send Request success.");
5508
5509         // Check signal.
5510         if (signal_flg > 0) {
5511                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMON,10,
5512                         "Signal (%d) Received.", received_sig);
5513                 fprintf(stderr, "COMMON ERROR : "
5514                         "Signal (%d) Received.\n", received_sig);
5515
5516                 /*-------- DEBUG LOG --------*/
5517                 if (log_level_communicate == LOG_LV_DEBUG) {
5518                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMUNICATE,5,
5519                                 "out_function : static int communicate_to_l7vsd"
5520                                 "(struct l7vsadm_iov_data *iov_data) : "
5521                                 "return = -1");
5522                 }
5523                 /*------ DEBUG LOG END ------*/
5524
5525                 return -1;
5526         }
5527
5528         ret = recv_response(iov_data->rsp_iov, iov_data->rsp_cnt);
5529         if (ret < 0) {
5530                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMUNICATE,3,
5531                         "Receive Response error.");
5532
5533                 /*-------- DEBUG LOG --------*/
5534                 if (log_level_communicate == LOG_LV_DEBUG) {
5535                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMUNICATE,6,
5536                                 "out_function : static int communicate_to_l7vsd"
5537                                 "(struct l7vsadm_iov_data *iov_data) : "
5538                                 "return = %d",
5539                                 ret);
5540                 }
5541                 /*------ DEBUG LOG END ------*/
5542
5543                 return ret;
5544         }
5545
5546         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSADM_COMMUNICATE,2,
5547                 "Receive Response success.");
5548
5549         /*-------- DEBUG LOG --------*/
5550         if (log_level_communicate == LOG_LV_DEBUG) {
5551                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMUNICATE,7,
5552                         "out_function : static int communicate_to_l7vsd"
5553                         "(struct l7vsadm_iov_data *iov_data) : "
5554                         "return = %d",
5555                         ret);
5556         }
5557         /*------ DEBUG LOG END ------*/
5558
5559         return ret;
5560 }
5561
5562 /*!
5563  * Send config request message.
5564  * @param[in]   *req_iov        request io-vector pointer
5565  * @param[in]   req_cnt         request io-vector count
5566  * @return      int             send result OK=byte, NG<0
5567  */
5568 static int
5569 send_request(struct iovec *req_iov, int req_cnt)
5570 {
5571         int ret;
5572
5573         // Argment check.
5574         if (req_iov == NULL) {
5575                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMUNICATE,4,
5576                         "Argument req_iov is NULL.");
5577                 fprintf(stderr, "COMMUNICATE ERROR : "
5578                         "Argument req_iov is NULL.\n");
5579
5580                 /*-------- DEBUG LOG --------*/
5581                 if (log_level_communicate == LOG_LV_DEBUG) {
5582                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMUNICATE,8,
5583                                 "out_function : static int send_request"
5584                                 "(struct iovec *req_iov, int req_cnt) : "
5585                                 "return = -1");
5586                 }
5587                 /*------ DEBUG LOG END ------*/
5588
5589                 return -1;
5590         }
5591         if (req_cnt < 1) {
5592                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMUNICATE,5,
5593                         "Invalid req_cnt argument.");
5594                 fprintf(stderr, "COMMUNICATE ERROR : "
5595                         "Invalid req_cnt argument.\n");
5596
5597                 /*-------- DEBUG LOG --------*/
5598                 if (log_level_communicate == LOG_LV_DEBUG) {
5599                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMUNICATE,9,
5600                                 "out_function : static int send_request"
5601                                 "(struct iovec *req_iov, int req_cnt) : "
5602                                 "return = -1");
5603                 }
5604                 /*------ DEBUG LOG END ------*/
5605
5606                 return -1;
5607         }
5608
5609         /*-------- DEBUG LOG --------*/
5610         if (log_level_communicate == LOG_LV_DEBUG) {
5611                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMUNICATE,10,
5612                         "in_function : static int send_request"
5613                         "(struct iovec *req_iov, int req_cnt) : "
5614                         "req_iov = %p "
5615                         "req_cnt = %d",
5616                         req_iov,
5617                         req_cnt);
5618         }
5619         /*------ DEBUG LOG END ------*/
5620
5621         if (req_cnt == 1) {
5622                 if (req_iov->iov_base == NULL) {
5623                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMUNICATE,6,
5624                                 "iov_base is NULL.");
5625
5626                         /*-------- DEBUG LOG --------*/
5627                         if (log_level_communicate == LOG_LV_DEBUG) {
5628                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMUNICATE,11,
5629                                         "out_function : static int send_request"
5630                                         "(struct iovec *req_iov, int req_cnt) : "
5631                                         "return = -1");
5632                         }
5633                         /*------ DEBUG LOG END ------*/
5634
5635                         return -1;
5636                 }
5637                 ret = send(local_sock_fd,
5638                            req_iov->iov_base,
5639                            req_iov->iov_len,
5640                            0);
5641                 if (ret < 0) {
5642                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMUNICATE,7,
5643                                 "send() to daemon error: %s.", strerror(errno));
5644                         fprintf(stderr, "COMMUNICATE ERROR : "
5645                                 "send() to daemon error: %s.\n", strerror(errno));
5646                 }
5647         } else {
5648                 ret = writev(local_sock_fd, req_iov, req_cnt);
5649                 if (ret < 0) {
5650                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMUNICATE,8,
5651                                 "writev() to daemon error: %s.", strerror(errno));
5652                         fprintf(stderr, "COMMUNICATE ERROR : "
5653                                 "writev() to daemon error: %s.\n", strerror(errno));
5654                 }
5655         }
5656
5657         /*-------- DEBUG LOG --------*/
5658         if (log_level_communicate == LOG_LV_DEBUG) {
5659                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMUNICATE,12,
5660                         "out_function : static int send_request"
5661                         "(struct iovec *req_iov, int req_cnt) : "
5662                         "return = %d",
5663                         ret);
5664         }
5665         /*------ DEBUG LOG END ------*/
5666
5667         return ret;
5668 }
5669
5670 /*!
5671  * Receive config response message.
5672  * @param[in,out]       *rsp_iov        response io-vector pointer
5673  * @param[in]           rsp_cnt         response io-vector count
5674  * @return              int             receive result OK=byte, NG<0
5675  */
5676 static int
5677 recv_response(struct iovec *rsp_iov, int rsp_cnt)
5678 {
5679         struct msghdr msg;
5680         struct ucred *cred;
5681         struct cmsghdr *cmsg;
5682         unsigned char cbuf[CMSG_LEN(sizeof(struct ucred))];
5683         int ret;
5684
5685         // Argment check.
5686         if (rsp_iov == NULL) {
5687                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMUNICATE,9,
5688                         "Argument rsp_iov is NULL.");
5689                 fprintf(stderr, "COMMUNICATE ERROR : "
5690                         "Argument rsp_iov is NULL.\n");
5691
5692                 /*-------- DEBUG LOG --------*/
5693                 if (log_level_communicate == LOG_LV_DEBUG) {
5694                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMUNICATE,13,
5695                                 "out_function : static int recv_response"
5696                                 "(struct iovec *rsp_iov, int rsp_cnt) : "
5697                                 "return = -1");
5698                 }
5699                 /*------ DEBUG LOG END ------*/
5700
5701                 return -1;
5702         }
5703         if (rsp_cnt < 1) {
5704                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMUNICATE,10,
5705                         "Invalid rsp_cnt argument.");
5706                 fprintf(stderr, "COMMUNICATE ERROR : "
5707                         "Invalid rsp_cnt argument.\n");
5708
5709                 /*-------- DEBUG LOG --------*/
5710                 if (log_level_communicate == LOG_LV_DEBUG) {
5711                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMUNICATE,14,
5712                                 "out_function : static int recv_response"
5713                                 "(struct iovec *rsp_iov, int rsp_cnt) : "
5714                                 "return = -1");
5715                 }
5716                 /*------ DEBUG LOG END ------*/
5717
5718                 return -1;
5719         }
5720
5721         /*-------- DEBUG LOG --------*/
5722         if (log_level_communicate == LOG_LV_DEBUG) {
5723                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMUNICATE,15,
5724                         "in_function : static int recv_response"
5725                         "(struct iovec *rsp_iov, int rsp_cnt) : "
5726                         "rsp_iov = %p "
5727                         "rsp_cnt = %d",
5728                         rsp_iov,
5729                         rsp_cnt);
5730         }
5731         /*------ DEBUG LOG END ------*/
5732
5733         memset(&msg, 0, sizeof(msg));
5734         msg.msg_control = cbuf;
5735         msg.msg_controllen = sizeof(cbuf);
5736         msg.msg_iov = rsp_iov;
5737         msg.msg_iovlen = (size_t)rsp_cnt;
5738         cmsg = (struct cmsghdr *)cbuf;
5739
5740         ret = recvmsg(local_sock_fd, &msg, 0);
5741         if (ret < 0) {
5742                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMUNICATE,11,
5743                         "recvmsg() to daemon error: %s.", strerror(errno));
5744                 fprintf(stderr, "COMMUNICATE ERROR : "
5745                         "recvmsg() to daemon error: %s.\n", strerror(errno));
5746
5747                 /*-------- DEBUG LOG --------*/
5748                 if (log_level_communicate == LOG_LV_DEBUG) {
5749                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMUNICATE,16,
5750                                 "out_function : static int recv_response"
5751                                 "(struct iovec *rsp_iov, int rsp_cnt) : "
5752                                 "return = L7VSADM_RECV_FAILED(-1)");
5753                 }
5754                 /*------ DEBUG LOG END ------*/
5755
5756                 return L7VSADM_RECV_FAILED;
5757         }
5758
5759         if (msg.msg_flags & MSG_CTRUNC) {
5760                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMUNICATE,12,
5761                         "Invalid response from l7vsd.");
5762                 fprintf(stderr, "COMMUNICATE ERROR : "
5763                         "Invalid response from l7vsd.\n");
5764
5765                 /*-------- DEBUG LOG --------*/
5766                 if (log_level_communicate == LOG_LV_DEBUG) {
5767                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMUNICATE,17,
5768                                 "out_function : static int recv_response"
5769                                 "(struct iovec *rsp_iov, int rsp_cnt) : "
5770                                 "return = L7VSADM_RECV_FAILED(-1)");
5771                 }
5772                 /*------ DEBUG LOG END ------*/
5773
5774                 return L7VSADM_RECV_FAILED;
5775         }
5776
5777         if (msg.msg_flags & MSG_TRUNC) {
5778                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_COMMUNICATE,1,
5779                         "Too large response from l7vsd.");
5780
5781                 /*-------- DEBUG LOG --------*/
5782                 if (log_level_communicate == LOG_LV_DEBUG) {
5783                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMUNICATE,18,
5784                                 "out_function : static int recv_response"
5785                                 "(struct iovec *rsp_iov, int rsp_cnt) : "
5786                                 "return = L7VSADM_RECV_TOO_LARGE(-2)");
5787                 }
5788                 /*------ DEBUG LOG END ------*/
5789
5790                 return L7VSADM_RECV_TOO_LARGE;
5791         }
5792
5793         if (! (cmsg->cmsg_level == SOL_SOCKET &&
5794                 cmsg->cmsg_type == SCM_CREDENTIALS)) {
5795                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMUNICATE,13,
5796                         "Could not receive a remote credential.");
5797                 fprintf(stderr, "COMMUNICATE ERROR : "
5798                         "Could not receive a remote credential.\n");
5799
5800                 /*-------- DEBUG LOG --------*/
5801                 if (log_level_communicate == LOG_LV_DEBUG) {
5802                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMUNICATE,19,
5803                                 "out_function : static int recv_response"
5804                                 "(struct iovec *rsp_iov, int rsp_cnt) : "
5805                                 "return = L7VSADM_RECV_FAILED(-1)");
5806                 }
5807                 /*------ DEBUG LOG END ------*/
5808
5809                 return L7VSADM_RECV_FAILED;
5810         }
5811
5812         cred = (struct ucred *)CMSG_DATA(cmsg);
5813         if (cred->uid != 0) {
5814                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMUNICATE,14,
5815                         "Response from unprivileged user.");
5816                 fprintf(stderr, "COMMUNICATE ERROR : "
5817                         "Response from unprivileged user.\n");
5818                 return L7VSADM_RECV_FAILED;
5819
5820                 /*-------- DEBUG LOG --------*/
5821                 if (log_level_communicate == LOG_LV_DEBUG) {
5822                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMUNICATE,20,
5823                                 "out_function : static int recv_response"
5824                                 "(struct iovec *rsp_iov, int rsp_cnt) : "
5825                                 "return = L7VSADM_RECV_FAILED(-1)");
5826                 }
5827                 /*------ DEBUG LOG END ------*/
5828
5829         }
5830
5831         /*-------- DEBUG LOG --------*/
5832         if (log_level_communicate == LOG_LV_DEBUG) {
5833                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMUNICATE,21,
5834                         "out_function : static int recv_response"
5835                         "(struct iovec *rsp_iov, int rsp_cnt) : "
5836                         "return = %d",
5837                         ret);
5838         }
5839         /*------ DEBUG LOG END ------*/
5840
5841         return ret;
5842 }
5843
5844 /*!
5845  * Print l7vsadm command usage.
5846  * @param[in]   *fp     outoput file pointer
5847  */
5848 static void
5849 usage(FILE *fp)
5850 {
5851         // Argment check.
5852         if (!fp) {
5853                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,48,
5854                         "Argument fp is NULL.");
5855                 fprintf(stderr, "OPERATE ERROR : "
5856                         "Argument fp is NULL.\n");
5857
5858                 /*-------- DEBUG LOG --------*/
5859                 if (log_level_operate == LOG_LV_DEBUG) {
5860                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,73,
5861                                 "out_function : static void usage(FILE *fp) : ");
5862                 }
5863                 /*------ DEBUG LOG END ------*/
5864
5865                 return;
5866         }
5867
5868         /*-------- DEBUG LOG --------*/
5869         if (log_level_operate == LOG_LV_DEBUG) {
5870                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,74,
5871                         "in_function : static void usage(FILE *fp) : "
5872                         "fp = %p",
5873                         fp);
5874         }
5875         /*------ DEBUG LOG END ------*/
5876
5877         fprintf(fp,
5878         "Usage: \n"
5879         "  l7vsadm -A|E -t service-address -m proto-module [module-args]\n"
5880         "          [-s scheduler] [-u connection-count] [-b sorry-server]\n"
5881         "          [-f sorry-flag] [-Q QoSval-up] [-q QoSval-down]\n"
5882         "  l7vsadm -D -t service-address -m proto-module [module-args]\n"
5883         "  l7vsadm -C\n"
5884         "  l7vsadm -a|e -t service-address -m proto-module [module-args]\n"
5885         "          -r server-address [-w weight]\n"
5886         "  l7vsadm -d -t service-address -m proto-module [module-args]\n"
5887         "          -r server-address\n"
5888         "  l7vsadm -R -s replication-switch\n"
5889         "  l7vsadm -R -f\n"
5890         "  l7vsadm -R -d\n"
5891         "  l7vsadm -L -c log-category -l log-level\n"
5892         "  l7vsadm -S -c log-category -l log-level\n"
5893         "  l7vsadm -P -r reload-parameter\n"
5894         "  l7vsadm -l [-n]\n"
5895         "  l7vsadm -V [-n]\n"
5896         "  l7vsadm -K [-n]\n"
5897         "  l7vsadm -h\n"
5898         "\n");
5899
5900         /*-------- DEBUG LOG --------*/
5901         if (log_level_operate == LOG_LV_DEBUG) {
5902                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_OPERATE,75,
5903                         "out_function : static void usage(FILE *fp) : ");
5904         }
5905         /*------ DEBUG LOG END ------*/
5906
5907 }
5908
5909 /*!
5910  * Set l7vsadm parameter data.
5911  * Get l7vsadm parameter data and set to global data
5912  */
5913 static void
5914 set_parameter(void)
5915 {
5916         static struct l7vsadm_parameter_list l7vsadm_parameter_table[] = {
5917                 {PARA_CMD_INTERVAL,             "cmd_interval"},
5918                 {PARA_CMD_COUNT,                "cmd_count"},
5919                 {PARA_CON_INTERVAL,             "con_interval"},
5920                 {PARA_CON_COUNT,                "con_count"},
5921                 {PARA_NONE,                     NULL}
5922         };
5923         struct l7vsadm_parameter_list *list;
5924         int parameter_value = 0;
5925
5926         /*-------- DEBUG LOG --------*/
5927         if (log_level_common == LOG_LV_DEBUG) {
5928                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,8,
5929                         "in_function : static void set_parameter(void) : ");
5930         }
5931         /*------ DEBUG LOG END ------*/
5932
5933         // Get and Set l7vsadm all parameter value.
5934         for (list = l7vsadm_parameter_table; list->parameter_name != NULL; list++) {
5935                 parameter_value = 0;
5936                 if (parameter_is_int_exist(L7VSADM_COMPONENT, list->parameter_name)) {
5937                         parameter_value =
5938                                 parameter_get_int_value(L7VSADM_COMPONENT, list->parameter_name);
5939                 } else {
5940                         // When parameter not exist, use default parameter value.
5941                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_COMMON,2,
5942                                 "Get %s parameter error. Use default value.",
5943                                 list->parameter_name);
5944                         continue;
5945                 }
5946                 switch (list->parameter_code) {
5947                 case PARA_CMD_INTERVAL:
5948                         command_wait_interval = parameter_value;
5949                         if (command_wait_interval < 0 ||
5950                             command_wait_interval > L7VSADM_MAX_WAIT) {
5951                                 // When illegal parameter value, use default parameter value.
5952                                 command_wait_interval = L7VSADM_DEFAULT_WAIT_INTERVAL;
5953                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_COMMON,3,
5954                                         "Illegal %s parameter value. Use default value.",
5955                                         list->parameter_name);
5956                         }
5957                         break;
5958                 case PARA_CMD_COUNT:
5959                         command_wait_count = parameter_value;
5960                         if (command_wait_count < 0 ||
5961                             command_wait_count > L7VSADM_MAX_WAIT) {
5962                                 // When illegal parameter value, use default parameter value.
5963                                 command_wait_count = L7VSADM_DEFAULT_WAIT_COUNT;
5964                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_COMMON,4,
5965                                         "Illegal %s parameter value. Use default value.",
5966                                         list->parameter_name);
5967                         }
5968                         break;
5969                 case PARA_CON_INTERVAL:
5970                         connect_wait_interval = parameter_value;
5971                         if (connect_wait_interval < 0 ||
5972                             connect_wait_interval > L7VSADM_MAX_WAIT) {
5973                                 // When illegal parameter value, use default parameter value.
5974                                 connect_wait_interval = L7VSADM_DEFAULT_WAIT_INTERVAL;
5975                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_COMMON,5,
5976                                         "Illegal %s parameter value. Use default value.",
5977                                         list->parameter_name);
5978                         }
5979                         break;
5980                 case PARA_CON_COUNT:
5981                         connect_wait_count = parameter_value;
5982                         if (connect_wait_count < 0 ||
5983                             connect_wait_count > L7VSADM_MAX_WAIT) {
5984                                 // When illegal parameter value, use default parameter value.
5985                                 connect_wait_count = L7VSADM_DEFAULT_WAIT_COUNT;
5986                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_COMMON,6,
5987                                         "Illegal %s parameter value. Use default value.",
5988                                         list->parameter_name);
5989                         }
5990                         break;
5991                 case PARA_NONE:
5992                 default:
5993                         break;
5994                 }
5995         }
5996
5997         if ((command_wait_interval * command_wait_count) > L7VSADM_MAX_WAIT) {
5998                 // When wait value too long, use default parameter value.
5999                 command_wait_interval = L7VSADM_DEFAULT_WAIT_INTERVAL;
6000                 command_wait_count = L7VSADM_DEFAULT_WAIT_COUNT;
6001                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_COMMON,7,
6002                         "Command wait value too long. Use default value.");
6003         }
6004         if ((connect_wait_interval * connect_wait_count) > L7VSADM_MAX_WAIT) {
6005                 // When wait value too long, use default parameter value.
6006                 connect_wait_interval = L7VSADM_DEFAULT_WAIT_INTERVAL;
6007                 connect_wait_count = L7VSADM_DEFAULT_WAIT_COUNT;
6008                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_COMMON,8,
6009                         "Connect wait value too long. Use default value.");
6010         }
6011
6012         /*-------- DEBUG LOG --------*/
6013         if (log_level_common == LOG_LV_DEBUG) {
6014                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,9,
6015                         "out_function : static void set_parameter(void) : "
6016                         "result "
6017                         "command_wait_interval = %d "
6018                         "command_wait_count = %d "
6019                         "connect_wait_interval = %d "
6020                         "connect_wait_count = %d",
6021                         command_wait_interval,
6022                         command_wait_count,
6023                         connect_wait_interval,
6024                         connect_wait_count);
6025         }
6026         /*------ DEBUG LOG END ------*/
6027 }
6028
6029 /*!
6030  * Create config error string.
6031  * Translate from esponse code to error string
6032  * @param[in]   rsp_code        response code
6033  * @param[in]   *argv[]         array of argument string
6034  * @return      char *          error string
6035  */
6036 static char *
6037 config_strerror(int rsp_code)
6038 {
6039         /*-------- DEBUG LOG --------*/
6040         if (log_level_common == LOG_LV_DEBUG) {
6041                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,10,
6042                         "in_function : static char *config_strerror(int rsp_code) : "
6043                         "rsp_code = %d",
6044                         rsp_code);
6045         }
6046         /*------ DEBUG LOG END ------*/
6047
6048         switch (rsp_code) {
6049         case L7VS_CONFIG_NOERR:
6050                 /*-------- DEBUG LOG --------*/
6051                 if (log_level_common == LOG_LV_DEBUG) {
6052                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,11,
6053                                 "out_function : static char *config_strerror(int rsp_code) : "
6054                                 "return = No error");
6055                 }
6056                 /*------ DEBUG LOG END ------*/
6057
6058                 return "No error";
6059         case L7VS_CONFIG_ERR_INVALID_COMMAND:
6060                 /*-------- DEBUG LOG --------*/
6061                 if (log_level_common == LOG_LV_DEBUG) {
6062                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,12,
6063                                 "out_function : static char *config_strerror(int rsp_code) : "
6064                                 "return = Invalid command");
6065                 }
6066                 /*------ DEBUG LOG END ------*/
6067
6068                 return "Invalid command";
6069         case L7VS_CONFIG_ERR_NOMEM:
6070                 /*-------- DEBUG LOG --------*/
6071                 if (log_level_common == LOG_LV_DEBUG) {
6072                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,13,
6073                                 "out_function : static char *config_strerror(int rsp_code) : "
6074                                 "return = Could not allocate memory");
6075                 }
6076                 /*------ DEBUG LOG END ------*/
6077
6078                 return "Could not allocate memory";
6079         case L7VS_CONFIG_ERR_VS_EXISTS:
6080                 /*-------- DEBUG LOG --------*/
6081                 if (log_level_common == LOG_LV_DEBUG) {
6082                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,14,
6083                                 "out_function : static char *config_strerror(int rsp_code) : "
6084                                 "return = Virtual service already exists");
6085                 }
6086                 /*------ DEBUG LOG END ------*/
6087
6088                 return "Virtual service already exists";
6089         case L7VS_CONFIG_ERR_RS_EXISTS:
6090                 /*-------- DEBUG LOG --------*/
6091                 if (log_level_common == LOG_LV_DEBUG) {
6092                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,15,
6093                                 "out_function : static char *config_strerror(int rsp_code) : "
6094                                 "return = Real server already exists");
6095                 }
6096                 /*------ DEBUG LOG END ------*/
6097
6098                 return "Real server already exists";
6099         case L7VS_CONFIG_ERR_NOVS:
6100                 /*-------- DEBUG LOG --------*/
6101                 if (log_level_common == LOG_LV_DEBUG) {
6102                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,16,
6103                                 "out_function : static char *config_strerror(int rsp_code) : "
6104                                 "return = No such virtual service");
6105                 }
6106                 /*------ DEBUG LOG END ------*/
6107
6108                 return "No such virtual service";
6109         case L7VS_CONFIG_ERR_NORS:
6110                 /*-------- DEBUG LOG --------*/
6111                 if (log_level_common == LOG_LV_DEBUG) {
6112                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,17,
6113                                 "out_function : static char *config_strerror(int rsp_code) : "
6114                                 "return = No such real server");
6115                 }
6116                 /*------ DEBUG LOG END ------*/
6117
6118                 return "No such real server";
6119         case L7VS_CONFIG_ERR_NOSCHED:
6120                 /*-------- DEBUG LOG --------*/
6121                 if (log_level_common == LOG_LV_DEBUG) {
6122                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,18,
6123                                 "out_function : static char *config_strerror(int rsp_code) : "
6124                                 "return = No such scheduler");
6125                 }
6126                 /*------ DEBUG LOG END ------*/
6127
6128                 return "No such scheduler";
6129         case L7VS_CONFIG_ERR_NOSOCK:
6130                 /*-------- DEBUG LOG --------*/
6131                 if (log_level_common == LOG_LV_DEBUG) {
6132                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,19,
6133                                 "out_function : static char *config_strerror(int rsp_code) : "
6134                                 "return = Could not create a service socket");
6135                 }
6136                 /*------ DEBUG LOG END ------*/
6137
6138                 return "Could not create a service socket";
6139         case L7VS_CONFIG_ERR_QOSSET:
6140                 /*-------- DEBUG LOG --------*/
6141                 if (log_level_common == LOG_LV_DEBUG) {
6142                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,20,
6143                                 "out_function : static char *config_strerror(int rsp_code) : "
6144                                 "return = QoS threshold setting failure");
6145                 }
6146                 /*------ DEBUG LOG END ------*/
6147
6148                 return "QoS threshold setting failure";
6149         case L7VS_CONFIG_ERR_SORRYSET:
6150                 /*-------- DEBUG LOG --------*/
6151                 if (log_level_common == LOG_LV_DEBUG) {
6152                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,21,
6153                                 "out_function : static char *config_strerror(int rsp_code) : "
6154                                 "return = Sorry-Server modification failure");
6155                 }
6156                 /*------ DEBUG LOG END ------*/
6157
6158                 return "Sorry-Server modification failure";
6159         case L7VS_CONFIG_ERR_SENDMSG:
6160                 /*-------- DEBUG LOG --------*/
6161                 if (log_level_common == LOG_LV_DEBUG) {
6162                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,22,
6163                                 "out_function : static char *config_strerror(int rsp_code) : "
6164                                 "return = Could not send response to l7vsadm");
6165                 }
6166                 /*------ DEBUG LOG END ------*/
6167
6168                 return "Could not send response to l7vsadm";
6169         case L7VS_CONFIG_ERR_MAXVS_EXISTS:
6170                 /*------ DEBUG LOG -------*/
6171                 if (log_level_common == LOG_LV_DEBUG) {
6172                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,23,
6173                                 "out_function : static char *config_strerror(int rep_code) : "
6174                                 "return = l7vsd is created max virtual service" );
6175                 }
6176                  /*------ DEBUG LOG END ------*/
6177
6178                 return "Could not create virtual service to l7vsd because max limit it.";
6179         default:
6180                 /*-------- DEBUG LOG --------*/
6181                 if (log_level_common == LOG_LV_DEBUG) {
6182                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,24,
6183                                 "out_function : static char *config_strerror(int rsp_code) : "
6184                                 "return = Unknown error");
6185                 }
6186                 /*------ DEBUG LOG END ------*/
6187
6188                 return "Unknown error";
6189                 break;
6190         }
6191 }
6192
6193 /*!
6194  * Signal handling function.
6195  * @param[in]   sig     signal number
6196  */
6197 static void
6198 sig_exit_handler(int sig)
6199 {
6200         received_sig = sig;
6201         ++signal_flg;
6202 }
6203
6204 /*!
6205  * Set signal handler.
6206  * @param[in]   argc    number of argument
6207  * @param[in]   *argv[] array of argument string
6208  * @return      int     set result OK=0, NG=-1
6209  */
6210 static int
6211 set_signal(void)
6212 {
6213         static struct l7vsadm_sig_list sigs[] = {
6214                 {SIGHUP,        sig_exit_handler},
6215                 {SIGINT,        sig_exit_handler},
6216                 {SIGQUIT,       sig_exit_handler},
6217                 {SIGPIPE,       sig_exit_handler},
6218                 {SIGTERM,       sig_exit_handler},
6219                 {SIGUSR1,       sig_exit_handler},
6220                 {SIGUSR2,       sig_exit_handler},
6221                 {0,             NULL}
6222         };
6223         struct l7vsadm_sig_list *s;
6224         struct sigaction act, oact;
6225         int ret;
6226
6227         /*-------- DEBUG LOG --------*/
6228         if (log_level_common == LOG_LV_DEBUG) {
6229                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,25,
6230                         "in_function : static int set_signal(void) : ");
6231         }
6232         /*------ DEBUG LOG END ------*/
6233
6234         memset(&act, 0x00, sizeof(struct sigaction));
6235         memset(&oact, 0x00, sizeof(struct sigaction));
6236
6237         for (s = sigs; s->sig != 0; s++) {
6238                 ret = sigaction(s->sig, NULL, &oact);
6239                 if (ret < 0) {
6240                         LOGGER_PUT_LOG_FATAL(LOG_CAT_L7VSADM_COMMON,6,
6241                                 "sigaction() error: %s.", strerror(errno));
6242                         fprintf(stderr, "COMMON ERROR : "
6243                                 "sigaction() error: %s.\n", strerror(errno));
6244
6245                         /*-------- DEBUG LOG --------*/
6246                         if (log_level_common == LOG_LV_DEBUG) {
6247                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,26,
6248                                         "out_function : static int set_signal(void) : "
6249                                         "return = %d",
6250                                         ret);
6251                         }
6252                         /*------ DEBUG LOG END ------*/
6253
6254                         return ret;
6255                 }
6256
6257                 act = oact;
6258                 act.sa_handler = s->sig_func;
6259                 ret = sigaction(s->sig, &act, NULL);
6260                 if (ret < 0) {
6261                         LOGGER_PUT_LOG_FATAL(LOG_CAT_L7VSADM_COMMON,7,
6262                                 "sigaction() error: %s.", strerror(errno));
6263                         fprintf(stderr, "COMMON ERROR : "
6264                                 "sigaction() error: %s.\n", strerror(errno));
6265
6266                         /*-------- DEBUG LOG --------*/
6267                         if (log_level_common == LOG_LV_DEBUG) {
6268                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,27,
6269                                         "out_function : static int set_signal(void) : "
6270                                         "return = %d",
6271                                         ret);
6272                         }
6273                         /*------ DEBUG LOG END ------*/
6274
6275                         return ret;
6276                 }
6277         }
6278
6279         /*-------- DEBUG LOG --------*/
6280         if (log_level_common == LOG_LV_DEBUG) {
6281                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,28,
6282                         "out_function : static int set_signal(void) : "
6283                         "return = 0");
6284         }
6285         /*------ DEBUG LOG END ------*/
6286
6287         return 0;
6288 }
6289
6290 /*!
6291  * L7vsadm command main function.
6292  * Parse argument and execute command
6293  * @param[in]   argc    number of argument
6294  * @param[in]   *argv[] array of argument string
6295  */
6296 void
6297 l7vsadm_main(int argc, char *argv[])
6298 {
6299         char l7vsadm_file_path[256];
6300         int l7vsadm_fd = -1;
6301         int l7vsadm_lock = -1;
6302         int retry_count = 0;
6303         int ret;
6304         int error_f = 0;
6305
6306         // Get and Set l7vsadm all log level value.
6307         log_level_parse = logger_get_log_level(LOG_CAT_L7VSADM_PARSE);
6308         log_level_operate = logger_get_log_level(LOG_CAT_L7VSADM_OPERATE);
6309         log_level_communicate = logger_get_log_level(LOG_CAT_L7VSADM_COMMUNICATE);
6310         log_level_config_result = logger_get_log_level(LOG_CAT_L7VSADM_CONFIG_RESULT);
6311         log_level_common = logger_get_log_level(LOG_CAT_L7VSADM_COMMON);
6312
6313         // L7vsadm command start.
6314         char arg_str[DEBUG_STR_LEN] = {0};
6315         argc_argv_c_str(arg_str, argc, argv);
6316         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSADM_COMMON,1,
6317                 "l7vsadm command start. : "
6318                 "argc = %d, %s",
6319                 argc,
6320                 arg_str);
6321
6322         // Set signal handler.
6323         ret = set_signal();
6324         if (ret < 0) {
6325                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMON,11,
6326                         "Set signal handler error.");
6327                 error_f = 1;
6328                 goto END;
6329         }
6330
6331         // l7vsadm_option_data initialize.
6332         memset(&l7vsadm_option_data, 0, sizeof(struct l7vsadm_option_data));
6333
6334         // Check signal.
6335         if (signal_flg > 0) {
6336                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMON,12,
6337                         "Signal (%d) Received.", received_sig);
6338                 fprintf(stderr, "COMMON ERROR : "
6339                         "Signal (%d) Received.\n", received_sig);
6340                 error_f = 1;
6341                 goto END;
6342         }
6343
6344         // Set l7vsadm parameter.
6345         set_parameter();
6346
6347         // Get l7vsadm execute file path from /proc/(pid)/exe (symbolic link)
6348         memset(l7vsadm_file_path, 0, sizeof(l7vsadm_file_path));
6349         readlink("/proc/self/exe", l7vsadm_file_path, sizeof(l7vsadm_file_path));
6350
6351         // L7vsadm command conflict check. (Try l7vsadm execute file lock)
6352         l7vsadm_fd = open(l7vsadm_file_path, O_RDONLY);
6353         if (l7vsadm_fd == -1) {
6354                 LOGGER_PUT_LOG_FATAL(LOG_CAT_L7VSADM_COMMON,8,
6355                         "L7vsadm execute file open error. file:%s", l7vsadm_file_path);
6356                 fprintf(stderr, "COMMON ERROR : "
6357                         "L7vsadm execute file open error. file:%s\n", l7vsadm_file_path);
6358                 error_f = 1;
6359                 goto END;
6360         }
6361         while (1) {
6362                 // Check signal.
6363                 if (signal_flg > 0) {
6364                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMON,13,
6365                                 "Signal (%d) Received.", received_sig);
6366                         fprintf(stderr, "COMMON ERROR : "
6367                                 "Signal (%d) Received.\n", received_sig);
6368                         error_f = 1;
6369                         goto END;
6370                 }
6371
6372                 // Try lock l7vsadm file.
6373                 l7vsadm_lock = flock(l7vsadm_fd, LOCK_EX | LOCK_NB);
6374                 if (l7vsadm_lock == 0) {
6375                         // l7vsadm file lock OK.
6376                         break;
6377                 }
6378                 retry_count++;
6379                 if (retry_count > command_wait_count) {
6380                         // L7vsadm file lock error. (l7vsadm is executing)
6381                         LOGGER_PUT_LOG_FATAL(LOG_CAT_L7VSADM_COMMON,9,
6382                                 "L7vsadm file lock timeout. (l7vsadm is already executing)");
6383                         fprintf(stderr, "COMMON ERROR : "
6384                                 "L7vsadm file lock timeout. (l7vsadm is already executing)\n");
6385                         error_f = 1;
6386                         goto END;
6387                 }
6388                 // Lock retrying.
6389                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_COMMON,9,
6390                         "L7vsadm file lock error. (l7vsadm is already executing) (retry %d)",
6391                         retry_count);
6392                 sleep(command_wait_interval);
6393         }
6394
6395         if (argc > 1) {
6396                 // Check signal.
6397                 if (signal_flg > 0) {
6398                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMON,14,
6399                                 "Signal (%d) Received.", received_sig);
6400                         fprintf(stderr, "COMMON ERROR : "
6401                                 "Signal (%d) Received.\n", received_sig);
6402                         error_f = 1;
6403                         goto END;
6404                 }
6405
6406                 // Parse command option. (1st argument)
6407                 ret = parse_command(argc, argv);
6408                 if (ret < 0) {
6409                         // Command option parse NG.
6410                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,84,
6411                                 "Command option parse error.");
6412                         usage(stderr);
6413                         error_f = 1;
6414                         goto END;
6415                 }
6416
6417                 /*-------- DEBUG LOG --------*/
6418                 if (log_level_parse == LOG_LV_DEBUG) {
6419                         char parse_str[DEBUG_STR_LEN] = {0};
6420                         l7vsadm_option_data_c_str(parse_str);
6421                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,112,
6422                                 "function : void l7vsadm_main(int argc, char *argv[]) : "
6423                                 "parse_command result (%s)",
6424                                 parse_str);
6425                 }
6426                 /*------ DEBUG LOG END ------*/
6427
6428                 // Check signal.
6429                 if (signal_flg > 0) {
6430                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMON,15,
6431                                 "Signal (%d) Received.", received_sig);
6432                         fprintf(stderr, "COMMON ERROR : "
6433                                 "Signal (%d) Received.\n", received_sig);
6434                         error_f = 1;
6435                         goto END;
6436                 }
6437
6438                 // Check parse function pointer.
6439                 if (l7vsadm_option_data.parse_func == NULL) {
6440                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_PARSE,7,
6441                                 "Parse function pointer is NULL.");
6442                         error_f = 1;
6443                         goto END;
6444                 }
6445
6446                 // Parse xxx command option. (2nd argument and later)
6447                 ret = l7vsadm_option_data.parse_func(argc, argv);
6448                 if (ret < 0) {
6449                         // xxx command option parse NG.
6450                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSADM_PARSE,85,
6451                                 "(%s) command option parse error.", argv[1]);
6452                         usage(stderr);
6453                         error_f = 1;
6454                         goto END;
6455                 }
6456
6457                 /*-------- DEBUG LOG --------*/
6458                 if (log_level_parse == LOG_LV_DEBUG) {
6459                         char parse_str[DEBUG_STR_LEN] = {0};
6460                         l7vsadm_option_data_c_str(parse_str);
6461                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,113,
6462                                 "function : void l7vsadm_main(int argc, char *argv[]) : "
6463                                 "parse_option result (%s)",
6464                                 parse_str);
6465                 }
6466                 /*------ DEBUG LOG END ------*/
6467
6468         } else {
6469                 // No argument. Set default command (-l).
6470                 l7vsadm_option_data.command_code = CMD_LIST;
6471                 l7vsadm_option_data.operate_func = operate_list;
6472
6473                 /*-------- DEBUG LOG --------*/
6474                 if (log_level_parse == LOG_LV_DEBUG) {
6475                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_PARSE,114,
6476                                 "function : void l7vsadm_main(int argc, char *argv[]) : "
6477                                 "no option");
6478                 }
6479                 /*------ DEBUG LOG END ------*/
6480
6481         }
6482
6483         // Check signal.
6484         if (signal_flg > 0) {
6485                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_COMMON,16,
6486                         "Signal (%d) Received.", received_sig);
6487                 fprintf(stderr, "COMMON ERROR : "
6488                         "Signal (%d) Received.\n", received_sig);
6489                 error_f = 1;
6490                 goto END;
6491         }
6492
6493
6494         // Check operate function pointer.
6495         if (l7vsadm_option_data.operate_func == NULL) {
6496                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,49,
6497                         "Operate function pointer is NULL.");
6498                 error_f = 1;
6499                 goto END;
6500         }
6501
6502         // Operate l7vsadm command.
6503         ret = l7vsadm_option_data.operate_func();
6504         if (ret < 0) {
6505                 // xxx command operate NG.
6506                 if (argc > 1) {
6507                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,50,
6508                                 "(%s) command operate error.", argv[1]);
6509                 } else {
6510                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSADM_OPERATE,51,
6511                                 "(-l) command operate error.");
6512                 }
6513                 error_f = 1;
6514                 goto END;
6515         }
6516
6517 END:
6518         if (l7vsadm_lock != -1) {
6519                 // L7vsadm fd unlock.
6520                 flock(l7vsadm_fd, LOCK_UN);
6521         }
6522
6523         if (l7vsadm_fd != -1) {
6524                 // L7vsadm fd close.
6525                 close(l7vsadm_fd);
6526         }
6527
6528         // Error check.
6529         if (error_f == 1) {
6530                 // Abnormal end.
6531                 if (argc > 1) {
6532                         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSADM_COMMON,2,
6533                                 "L7vsadm command (%s) is failure.", argv[1]);
6534                 } else {
6535                         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSADM_COMMON,3,
6536                                 "L7vsadm command (-l) is failure.");
6537                 }
6538
6539                 /*-------- DEBUG LOG --------*/
6540                 if (log_level_common == LOG_LV_DEBUG) {
6541                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,29,
6542                                 "out_function : void l7vsadm_main(int argc, char *argv[]) : "
6543                                 "exit = %d",
6544                                 EXIT_FAILURE);
6545                 }
6546                 /*------ DEBUG LOG END ------*/
6547
6548                 fflush(stdout);
6549                 fsync(1);
6550                 _exit(EXIT_FAILURE);
6551         } else {
6552                 // Normal end.
6553                 if (argc > 1) {
6554                         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSADM_COMMON,4,
6555                                 "L7vsadm command (%s) is successful.", argv[1]);
6556                 } else {
6557                         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSADM_COMMON,5,
6558                                 "L7vsadm command (-l) is successful.");
6559                 }
6560
6561                 /*-------- DEBUG LOG --------*/
6562                 if (log_level_common == LOG_LV_DEBUG) {
6563                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSADM_COMMON,30,
6564                                 "out_function : void l7vsadm_main(int argc, char *argv[]) : "
6565                                 "exit = %d",
6566                                 EXIT_SUCCESS);
6567                 }
6568                 /*------ DEBUG LOG END ------*/
6569
6570                 fflush(stdout);
6571                 fsync(1);
6572                 _exit(EXIT_SUCCESS);
6573         }
6574 }
6575
6576 /*!
6577  * Serialize endpoint for debug log.
6578  * @param[out]  *ep_str endpoint string
6579  * @param[in]   *addr   endpoint structure
6580  */
6581 void
6582 endpoint_c_str(char* ep_str, void *addr)
6583 {
6584         struct sockaddr_in *p;
6585
6586         p = (struct sockaddr_in *)addr;
6587         if (p == NULL) {
6588                 sprintf(ep_str, "NULL");
6589         } else {
6590                 sprintf(ep_str, "sin_family = %d", p->sin_family);
6591                 sprintf(ep_str, "%s sin_port = %d", ep_str, p->sin_port);
6592                 if (memcmp(&p->sin_addr, "", 1) == 0) {
6593                         sprintf(ep_str, "%s sin_addr = (NULL)", ep_str);
6594                 } else {
6595                         sprintf(ep_str, "%s sin_addr = (s_addr = %d)", ep_str, p->sin_addr.s_addr);
6596                 }
6597                 if (p->sin_zero == NULL) {
6598                         sprintf(ep_str, "%s sin_zero = NULL", ep_str);
6599                 } else {
6600                         sprintf(ep_str, "%s sin_zero = %s", ep_str, p->sin_zero);
6601                 }
6602         }
6603 }
6604
6605 /*!
6606  * Serialize argc *argv[] for debug log.
6607  * @param[out]  *arg_str        serialized string
6608  * @param[in]   argc            argument count
6609  * @param[in]   *argv[]         argument string array
6610  */
6611 void
6612 argc_argv_c_str(char* arg_str, int argc, char *argv[])
6613 {
6614         int i;
6615
6616         for (i = 0; i < argc; i++) {
6617                 if (argv == NULL) {
6618                         if (strlen(arg_str) + 20 > DEBUG_STR_LEN) {
6619                                 break;
6620                         }
6621                         sprintf(arg_str, "%s argv[%d] = NULL", arg_str, i);
6622                 } else {
6623                         if (strlen(arg_str) + strlen(argv[i]) + 16 > DEBUG_STR_LEN) {
6624                                 break;
6625                         }
6626                         sprintf(arg_str, "%s argv[%d] = %s", arg_str, i, argv[i]);
6627                 }
6628         }
6629 }
6630
6631 /*!
6632  * Serialize l7vsadm_option_data (global data) for debug log.
6633  * @param[out]  *parse_str      serialized string
6634  */
6635 void
6636 l7vsadm_option_data_c_str(char* parse_str)
6637 {
6638         sprintf(parse_str, "command_code = %d",
6639                 l7vsadm_option_data.command_code);
6640         sprintf(parse_str, "%s parse_func = %p", parse_str,
6641                 l7vsadm_option_data.parse_func);
6642         sprintf(parse_str, "%s operate_func = %p", parse_str,
6643                 l7vsadm_option_data.operate_func);
6644         if (memcmp(&l7vsadm_option_data.vs_addr, "", 1) == 0) {
6645                 sprintf(parse_str, "%s vs_addr = NULL", parse_str);
6646         } else {
6647                 sprintf(parse_str, "%s vs_addr = %s", parse_str,
6648                         get_endpoint_name((struct sockaddr_storage *)(&l7vsadm_option_data.vs_addr)));
6649         }
6650         if (memcmp(&l7vsadm_option_data.rs_addr, "", 1) == 0) {
6651                 sprintf(parse_str, "%s rs_addr = NULL", parse_str);
6652         } else {
6653                 sprintf(parse_str, "%s rs_addr = %s", parse_str,
6654                         get_endpoint_name((struct sockaddr_storage *)(&l7vsadm_option_data.rs_addr)));
6655         }
6656         if (memcmp(&l7vsadm_option_data.protomod_name, "", 1) == 0) {
6657                 sprintf(parse_str, "%s protomod_name = NULL", parse_str);
6658         } else {
6659                 sprintf(parse_str, "%s protomod_name = %s", parse_str,
6660                         l7vsadm_option_data.protomod_name);
6661         }
6662         if (memcmp(&l7vsadm_option_data.schedmod_name, "", 1) == 0) {
6663                 sprintf(parse_str, "%s schedmod_name = NULL", parse_str);
6664         } else {
6665                 sprintf(parse_str, "%s schedmod_name = %s", parse_str,
6666                         l7vsadm_option_data.schedmod_name);
6667         }
6668         sprintf(parse_str, "%s protomod = %p", parse_str,
6669                 l7vsadm_option_data.protomod);
6670         sprintf(parse_str, "%s persist = %d", parse_str,
6671                 l7vsadm_option_data.persist);
6672         sprintf(parse_str, "%s backlog = %d", parse_str,
6673                 l7vsadm_option_data.backlog);
6674         sprintf(parse_str, "%s weight = %d", parse_str,
6675                 l7vsadm_option_data.weight);
6676         sprintf(parse_str, "%s isnumeric = %d", parse_str,
6677                 l7vsadm_option_data.isnumeric);
6678         if (l7vsadm_option_data.protomod_options == NULL) {
6679                 sprintf(parse_str, "%s protomod_options = %p", parse_str,
6680                         l7vsadm_option_data.protomod_options);
6681         } else {
6682                 char arg_str[DEBUG_STR_LEN] = {0};
6683                 argc_argv_c_str(arg_str,
6684                                 l7vsadm_option_data.protomod_options->len,
6685                                 (char **)l7vsadm_option_data.protomod_options->data);
6686                 sprintf(parse_str, "%s protomod_options = %s", parse_str,
6687                         arg_str);
6688         }
6689         sprintf(parse_str, "%s protomod_sarg = %p", parse_str,
6690                 &l7vsadm_option_data.protomod_sarg);
6691         sprintf(parse_str, "%s max_connection = %d", parse_str,
6692                 l7vsadm_option_data.max_connection);
6693         if (memcmp(&l7vsadm_option_data.sorry_addr, "", 1) == 0) {
6694                 sprintf(parse_str, "%s sorry_addr = NULL", parse_str);
6695         } else {
6696                 sprintf(parse_str, "%s sorry_addr = %s", parse_str,
6697                         get_endpoint_name(&l7vsadm_option_data.sorry_addr));
6698         }
6699         sprintf(parse_str, "%s sorry_flag = %d", parse_str,
6700                 l7vsadm_option_data.sorry_flag);
6701         sprintf(parse_str, "%s QoS_to_server = %lld", parse_str,
6702                 l7vsadm_option_data.qos_threshold_up);
6703         sprintf(parse_str, "%s QoS_to_client = %lld", parse_str,
6704                 l7vsadm_option_data.qos_threshold_down);
6705         sprintf(parse_str, "%s control_code = %d", parse_str,
6706                 l7vsadm_option_data.control_code);
6707         sprintf(parse_str, "%s log_category = %d", parse_str,
6708                 l7vsadm_option_data.log_category);
6709         sprintf(parse_str, "%s log_level = %d", parse_str,
6710                 l7vsadm_option_data.log_level);
6711         sprintf(parse_str, "%s category_all_flag = %d", parse_str,
6712                 l7vsadm_option_data.category_all_flag);
6713         sprintf(parse_str, "%s replication_start_flag = %d", parse_str,
6714                 l7vsadm_option_data.replication_start_flag);
6715         sprintf(parse_str, "%s reload_param = %d", parse_str,
6716                 l7vsadm_option_data.reload_param);
6717         return;
6718 }