src/config.c

   1 /*
   2  * @file  config.c
   3  * @brief the configulation interface component
   4  * @brief it receives configulation command from l7vsadm,
   5  * @brief execute coresponding action and return result
   6  *
   7  * L7VSD: Linux Virtual Server for Layer7 Load Balancing
   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 <sys/types.h>
  28 #include <sys/stat.h>
  29 #include <sys/socket.h>
  30 #include <sys/un.h>
  31 #include <unistd.h>
  32 #include <stdlib.h>
  33 #include <glib.h>
  34
  35 /* Added headers for sending messages to l7vsagent */
  36 #include <stdio.h>
  37 #include <errno.h>
  38 #include <sys/msg.h>
  39 #include <string.h>
  40 #include <netdb.h>
  41
  42 #include "l7vs_config.h"
  43 #include "l7vs_iomuxlist.h"
  44 #include "l7vs_service.h"
  45 #include "l7vs_sched.h"
  46
  47
  48
  49 static int      l7vs_config_callback( struct l7vs_iomux* );
  50 static void     l7vs_config_dispatch( union l7vs_config_req*, struct sockaddr_un* );
  51 static void     l7vs_config_list_vs( union l7vs_config_req*, struct sockaddr_un* );
  52 static void     l7vs_config_list_rs( union l7vs_config_req*, struct sockaddr_un* );
  53 static void     l7vs_config_add_vs( union l7vs_config_req*, struct sockaddr_un* );
  54 static void     l7vs_config_del_vs( union l7vs_config_req*, struct sockaddr_un* );
  55 static void     l7vs_config_edit_vs( union l7vs_config_req*, struct sockaddr_un* );
  56 static void     l7vs_config_add_rs( union l7vs_config_req*, struct sockaddr_un* );
  57 static void     l7vs_config_del_rs( union l7vs_config_req*, struct sockaddr_un* );
  58 static void     l7vs_config_edit_rs( union l7vs_config_req*, struct sockaddr_un* );
  59 static void     l7vs_config_flush_vs( union l7vs_config_req*, struct sockaddr_un* );
  60 static void     l7vs_config_get_replication_info( union l7vs_config_req*, struct sockaddr_un* );
  61 static void     l7vs_config_get_log_info( union l7vs_config_req*, struct sockaddr_un* );
  62 static void     l7vs_config_get_snmp_log_info( union l7vs_config_req*, struct sockaddr_un* );
  63 static void     l7vs_config_get_snmp_connect_status( union l7vs_config_req*, struct sockaddr_un* );
  64 static void     l7vs_config_replication( union l7vs_config_req*, struct sockaddr_un* );
  65 static void     l7vs_config_log( union l7vs_config_req*, struct sockaddr_un* );
  66 static void     l7vs_config_snmp( union l7vs_config_req*, struct sockaddr_un* );
  67 static void     l7vs_config_snmp_all( union l7vs_config_req*, struct sockaddr_un* );
  68 static void     l7vs_config_parameter( union l7vs_config_req*, struct sockaddr_un* );
  69 static int      l7vs_config_send_response( struct sockaddr_un*, struct iovec*, int );
  70
  71 char    servicebuf[NI_MAXHOST + NI_MAXSERV + 2];
  72 const char l7vs_config_sockname[] = L7VS_CONFIG_SOCKNAME;
  73
  74 static struct l7vs_iomux *l7vs_config_iomux;
  75
  76 /*!
  77  * Operate config init
  78  * @return      int     result OK=0, NG=<0
  79  */
  80
  81 int
  82 l7vs_config_init(void)
  83 {
  84         int s;
  85         int ret;
  86         int opt;
  87         mode_t mode;
  88         struct sockaddr_un addr;
  89         struct sockaddr_in *in_addr;
  90         socklen_t len;
  91
  92         if(logger_get_log_level(LOG_CAT_L7VSD_ENVIRONMENT) == LOG_LV_DEBUG){
  93                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_ENVIRONMENT,1,
  94                 "in_fuction:  int l7vs_config_init return int");
  95         }
  96
  97         if (l7vs_config_iomux) {
  98                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_ENVIRONMENT,1,"config is already initialized.");
  99                 if(logger_get_log_level(LOG_CAT_L7VSD_ENVIRONMENT) == LOG_LV_DEBUG){
 100                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_ENVIRONMENT,2,
 101                         "out_fuction:  int l7vs_config_init return -1");
 102                 }
 103                 return -1;
 104         }
 105
 106         if (sizeof(addr.sun_path) < sizeof(l7vs_config_sockname)) {
 107                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_NETWORK,1,"Internal error The config socket name is too large.");
 108                 if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
 109                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,1,
 110                         "out_fuction:  int l7vs_config_init return -1");
 111                 }
 112                 return -1;
 113         }
 114
 115         s = socket(PF_LOCAL, SOCK_DGRAM, 0);
 116         if (s < 0) {
 117                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_SOCKET,1,"socket: %s (Socket Type is SOCK_DGRAM)", strerror(errno));
 118                 if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
 119                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,2,
 120                         "out_fuction:  int l7vs_config_init return < 0");
 121                 }
 122                 return s;
 123         }
 124
 125         opt = 1;
 126         ret = setsockopt(s, SOL_SOCKET, SO_PASSCRED, &opt, sizeof(opt));
 127         if (ret < 0) {
 128                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_SOCKET,2,"setsockopt SO_PASSCRED: %s", strerror(errno));
 129                 close(s);
 130                 if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
 131                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,3,
 132                         "out_fuction:  int l7vs_config_init return < 0");
 133                 }
 134                 return ret;
 135         }
 136
 137         memset(&addr, 0, sizeof(addr));
 138         addr.sun_family = AF_LOCAL;
 139         strcpy(addr.sun_path, l7vs_config_sockname);
 140         len = SUN_LEN(&addr);
 141
 142         mode = umask(0077);
 143         if (mode < 0) {
 144                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM,1,"umask: %s", strerror(errno));
 145                 close(s);
 146                 if(logger_get_log_level(LOG_CAT_L7VSD_SYSTEM) == LOG_LV_DEBUG){
 147                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM,1,
 148                         "out_fuction:  int l7vs_config_init return -1");
 149                 }
 150                 return -1;
 151         }
 152
 153         ret = bind(s, (struct sockaddr *)&addr, len);
 154         if (ret < 0) {
 155                 in_addr = (struct sockaddr_in*)&addr;
 156                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_SOCKET,3,"cannot create socket file \"%s\": %s",
 157                                 addr.sun_path, strerror(errno));
 158                 if (errno == EADDRINUSE) {
 159                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_SOCKET,4, "Config socket already exists. "
 160                                            "You could remove it if" " the l7vs daemon is not running");
 161                 }
 162                 close(s);
 163                 umask(mode);
 164                 if(logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_SOCKET) == LOG_LV_DEBUG){
 165                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_SOCKET,1,
 166                         "out_fuction:  int l7vs_config_init return < 0");
 167                 }
 168                 return ret;
 169         }
 170         umask(mode);
 171
 172         l7vs_config_iomux = l7vs_iomux_get_from_avail_list();
 173         if (!l7vs_config_iomux) {
 174                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_NETWORK,2,"can not get config_iomux");
 175                 if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
 176                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,4,
 177                         "out_fuction:  int l7vs_config_init return < 0");
 178                 }
 179                 return -1;
 180         }
 181
 182         l7vs_config_iomux->fd = s;
 183         l7vs_config_iomux->data = NULL;
 184         l7vs_config_iomux->callback = l7vs_config_callback;
 185         l7vs_config_iomux->status = iomux_config_command_waiting;
 186         l7vs_iomux_add( l7vs_config_iomux, iom_read );
 187
 188         if(logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_SOCKET) == LOG_LV_DEBUG){
 189                 char iomux_str[DEBUG_STR_LEN] = {0};
 190                 l7vs_iomux_c_str(iomux_str,l7vs_config_iomux);
 191                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_PROGRAM,23,
 192                                       "creat: l7vs_config_iomux=%s",
 193                                        iomux_str);
 194         }
 195
 196         return 0;
 197 }
 198
 199 /*!
 200  * Operate config finish
 201  * @return      void
 202  */
 203 void
 204 l7vs_config_fini(void)
 205 {
 206         if(logger_get_log_level(LOG_CAT_L7VSD_ENVIRONMENT) == LOG_LV_DEBUG){
 207                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_ENVIRONMENT,3,
 208                 "in_fuction:  void l7vs_config_fini return void");
 209         }
 210         if (l7vs_config_iomux) {
 211                 l7vs_config_iomux->status = iomux_config_destroyed;
 212                 l7vs_iomux_remove(l7vs_config_iomux);
 213                 if (-1 != l7vs_config_iomux->fd) {
 214                         close(l7vs_config_iomux->fd);
 215                 }
 216                 l7vs_iomux_put_to_avail_list(l7vs_config_iomux);
 217                 l7vs_config_iomux = NULL;
 218         }
 219         unlink(l7vs_config_sockname);
 220         if(logger_get_log_level(LOG_CAT_L7VSD_ENVIRONMENT) == LOG_LV_DEBUG){
 221                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_ENVIRONMENT,4,
 222                 "out_fuction:  void l7vs_config_fini return void");
 223         }
 224 }
 225
 226 /*!
 227  * config call back
 228  * @param[in]           struct l7vs_iomux      l7vs_iomux pointer
 229  * @return              int             number of VirtualService, NG<0
 230  */
 231 static int
 232 l7vs_config_callback(struct l7vs_iomux *iom )
 233 {
 234         struct msghdr msg;
 235         struct sockaddr_un addr;
 236         struct iovec iov;
 237         struct ucred *cred;
 238         struct cmsghdr *cmsg;
 239         unsigned char cbuf[CMSG_LEN(sizeof(struct ucred))];
 240         union l7vs_config_req req;
 241         int ret;
 242
 243         if (!iom) {
 244                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_ENVIRONMENT,2,"error / iom is null");
 245                 if(logger_get_log_level(LOG_CAT_L7VSD_ENVIRONMENT) == LOG_LV_DEBUG){
 246                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_ENVIRONMENT,5,
 247                         "out_fuction:  int l7vs_config_callback (struct l7vs_iomux *iom) return -1");
 248                 }
 249                 return -1;
 250         }
 251         if (iomux_config_command_waiting != iom->status) {
 252                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_EVENT,2,"error / invalid status(%d)", iom->status);
 253                 if(logger_get_log_level(LOG_CAT_L7VSD_ENVIRONMENT) == LOG_LV_DEBUG){
 254                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_ENVIRONMENT,6,
 255                         "out_fuction:  int l7vs_config_callback (struct l7vs_iomux *iom) return -1");
 256                 }
 257                 return -1;
 258         }
 259
 260         if(logger_get_log_level(LOG_CAT_L7VSD_ENVIRONMENT) == LOG_LV_DEBUG){
 261                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_ENVIRONMENT,7,
 262                 "in_fuction:  int l7vs_config_callback (struct l7vs_iomux *iom) iom = %p",iom);
 263         }
 264
 265         cmsg = (struct cmsghdr *)cbuf;
 266         cmsg->cmsg_len = sizeof(cbuf);
 267
 268         memset(&addr, 0, sizeof(addr));
 269         memset(&msg, 0, sizeof(msg));
 270         msg.msg_name = &addr;
 271         msg.msg_namelen = sizeof(addr);
 272         msg.msg_iov = &iov;
 273         msg.msg_iovlen = 1;
 274         msg.msg_control = cmsg;
 275         msg.msg_controllen = sizeof(cbuf);
 276
 277         iov.iov_base = &req;
 278         iov.iov_len = sizeof(req);
 279
 280         ret = recvmsg(iom->fd, &msg, 0);
 281         if (ret < 0) {
 282                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_NETWORK,3,"recvmsg on config socket: %s", strerror(errno));
 283                 if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
 284                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,5,
 285                         "out_fuction:  int l7vs_config_callback (struct l7vs_iomux *iom) return -1");
 286                 }
 287                 return -1;
 288         }
 289
 290         if (msg.msg_flags & (MSG_TRUNC|MSG_CTRUNC)) {
 291                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_NETWORK,4,"msg_flags=%x", msg.msg_flags);
 292                 if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
 293                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,6,
 294                         "out_fuction:  int l7vs_config_callback (struct l7vs_iomux *iom) return -1");
 295                 }
 296                 return -1;
 297         }
 298
 299         if (! (cmsg->cmsg_level == SOL_SOCKET &&
 300                cmsg->cmsg_type == SCM_CREDENTIALS)) {
 301                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_NETWORK,5,"Could not receive a remote credential");
 302                 if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
 303                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,7,
 304                         "out_fuction:  int l7vs_config_callback (struct l7vs_iomux *iom) return -1");
 305                 }
 306                 return -1;
 307         }
 308
 309         /*
 310          * actually credential check is unnecessary,
 311          * at least for Linux 2.4.20.
 312          */
 313         cred = (struct ucred *)CMSG_DATA(cmsg);
 314         if (cred->uid != 0) {
 315                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_NETWORK,6,"Request from unprivileged user");
 316                 if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
 317                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,8,
 318                         "out_fuction:  int l7vs_config_callback (struct l7vs_iomux *iom) return -1");
 319                 }
 320                 return -1;
 321         }
 322
 323         l7vs_config_dispatch(&req, &addr);
 324
 325         l7vs_config_iomux->status = iomux_config_command_waiting;
 326         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
 327                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,9,
 328                 "out_fuction:  int l7vs_config_callback (struct l7vs_iomux *iom) return 0");
 329         }
 330
 331         return 0;
 332 }
 333
 334 struct l7vs_config_table {
 335         enum l7vs_config_command cmd;
 336         void (*func)(union l7vs_config_req *req, struct sockaddr_un *addr);
 337 };
 338
 339 struct l7vs_config_table l7vs_config_table[] = {
 340         {L7VS_CONFIG_LIST_VS,   l7vs_config_list_vs},
 341         {L7VS_CONFIG_LIST_RS,   l7vs_config_list_rs},
 342         {L7VS_CONFIG_ADD_VS,    l7vs_config_add_vs},
 343         {L7VS_CONFIG_DEL_VS,    l7vs_config_del_vs},
 344         {L7VS_CONFIG_EDIT_VS,   l7vs_config_edit_vs},
 345         {L7VS_CONFIG_ADD_RS,    l7vs_config_add_rs},
 346         {L7VS_CONFIG_DEL_RS,    l7vs_config_del_rs},
 347         {L7VS_CONFIG_EDIT_RS,   l7vs_config_edit_rs},
 348         {L7VS_CONFIG_FLUSH_VS,  l7vs_config_flush_vs},
 349         {L7VS_CONFIG_GET_REPLICATION_INFO,l7vs_config_get_replication_info},
 350         {L7VS_CONFIG_REPLICATION,         l7vs_config_replication},
 351         {L7VS_CONFIG_GET_LOG_INFO,        l7vs_config_get_log_info},
 352         {L7VS_CONFIG_SET_LOG_LEVEL,       l7vs_config_log},
 353         {L7VS_CONFIG_SET_LOG_LEVEL_ALL,   l7vs_config_log},
 354         {L7VS_CONFIG_GET_SNMP_LOG_INFO,   l7vs_config_get_snmp_log_info},
 355         {L7VS_CONFIG_GET_SNMP_CONNECT_STATUS, l7vs_config_get_snmp_connect_status},
 356         {L7VS_CONFIG_SET_SNMP_LOG_LEVEL,  l7vs_config_snmp},
 357         {L7VS_CONFIG_SET_SNMP_LOG_LEVEL_ALL,l7vs_config_snmp_all},
 358         {L7VS_CONFIG_PARAMETER,           l7vs_config_parameter},
 359         {L7VS_CONFIG_NONE, NULL}
 360 };
 361
 362 /*!
 363  * config event dispatch
 364  * @param[in]           union l7vs_config_req request messege from l7vsadm
 365  * @param[in]           struct sockaddr_un l7vsd socket pointer
 366  * @return              void
 367  */
 368 static void
 369 l7vs_config_dispatch(union l7vs_config_req *req, struct sockaddr_un *addr)
 370 {
 371         struct l7vs_config_table *t;
 372         struct iovec iov;
 373         struct l7vs_config_rsp_unknown_cmd rsp;
 374
 375         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
 376                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,10,
 377                 "in_fuction:  void l7vs_config_dispatch (union l7vs_config_req *req, struct sockaddr_un *addr)"
 378                 "req= %p: addr= %p",req,addr);
 379         }
 380         for (t = l7vs_config_table; t->cmd != L7VS_CONFIG_NONE; t++) {
 381                 if (t->cmd == req->cmd) {
 382                         break;
 383                 }
 384         }
 385
 386         if (t->cmd == L7VS_CONFIG_NONE) {
 387                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_EVENT,3,"Unknown command from config socket");
 388                 rsp.cmd = req->cmd;
 389                 rsp.code = L7VS_CONFIG_ERR_INVALID_COMMAND;
 390                 iov.iov_base = &rsp;
 391                 iov.iov_len = sizeof(rsp);
 392                 l7vs_config_send_response(addr, &iov, 1);
 393                 return;
 394         }
 395
 396         t->func(req, addr);
 397         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
 398                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,11,
 399                 "out_fuction:  void l7vs_config_dispatch return void");
 400         }
 401 }
 402
 403 /*!
 404  * config event list virtual service
 405  * @param[in]           union l7vs_config_req request messege from l7vsadm
 406  * @param[in]           struct sockaddr_un l7vsd socket pointer
 407  * @return              void
 408  */
 409 static void
 410 l7vs_config_list_vs(union l7vs_config_req *arg,
 411                     struct sockaddr_un *addr)
 412 {
 413         struct l7vs_config_req_list_vs *req = &arg->list_vs;
 414         struct l7vs_config_rsp_list_vs rsp;
 415         struct l7vs_service_arg_multi *sas;
 416         struct iovec iov[2];
 417         int iovlen;
 418         int len;
 419
 420
 421         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
 422                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,12,
 423                 "in_fuction:  void l7vs_config_list_vs (union l7vs_config_req *arg, struct sockaddr_un *addr)"
 424                 "arg= %p: addr= %p",arg,addr);
 425         }
 426         if (!l7vs_config_iomux) {
 427                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_ENVIRONMENT,3,"error / iom is null");
 428                 return;
 429         }
 430         l7vs_config_iomux->status = iomux_config_command_list_vs_received;
 431
 432         sas = NULL;
 433         rsp.cmd = req->cmd;
 434         rsp.code = 0;
 435         rsp.num = 0;
 436         iov[0].iov_base = &rsp;
 437         iov[0].iov_len = sizeof(rsp);
 438
 439         len = l7vs_service_list_service_arg(&sas, &rsp.num);
 440         if (len < 0) {
 441                 l7vs_config_iomux->status = iomux_config_command_nomem_error;
 442                 rsp.code = L7VS_CONFIG_ERR_NOMEM;
 443                 l7vs_config_send_response(addr, iov, 1);
 444                 return;
 445         }
 446
 447         if (rsp.num == 0) {
 448                 iovlen = 1;
 449         } else {
 450                 iov[1].iov_base = sas;
 451                 iov[1].iov_len = len;
 452                 iovlen = 2;
 453         }
 454
 455         l7vs_config_iomux->status = iomux_config_command_list_vs_succeeded;
 456
 457         if(logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_SOCKET) == LOG_LV_DEBUG){
 458                 char config_str[DEBUG_STR_LEN] = {0};
 459
 460                 snprintf(config_str,DEBUG_STR_LEN,
 461                         "cmd=%d: "
 462                         "code=%d: "
 463                         "num=%d: ",
 464                         rsp.cmd,rsp.code,rsp.num);
 465
 466                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_PROGRAM,24,
 467                                       "list VirtualService: send data=%s",
 468                                        config_str);
 469         }
 470
 471         l7vs_config_send_response(addr, iov, iovlen);
 472         if (sas != NULL) {
 473                 free(sas);
 474         }
 475         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
 476                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,13,
 477                 "out_fuction:  void l7vs_config_list_vs return void");
 478         }
 479         return;
 480 }
 481
 482 /*!
 483  * config event list real server
 484  * @param[in]           union l7vs_config_req request messege from l7vsadm
 485  * @param[in]           struct sockaddr_un l7vsd socket pointer
 486  * @return              void
 487  */
 488 static void
 489 l7vs_config_list_rs(union l7vs_config_req *arg,
 490                     struct sockaddr_un *addr)
 491 {
 492         struct l7vs_config_req_list_rs *req = &arg->list_rs;
 493         struct l7vs_config_rsp_list_rs rsp;
 494         struct l7vs_service_arg_multi *sarg;
 495         struct l7vs_service  *srv=NULL;
 496         struct l7vs_dest_arg *das=NULL;
 497         struct iovec iov[2];
 498         int iovlen;
 499         int ret;
 500
 501         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
 502                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,14,
 503                 "in_fuction:  void l7vs_config_list_rs (union l7vs_config_req *arg, struct sockaddr_un *addr)"
 504                 "arg= %p: addr= %p",arg,addr);
 505         }
 506         if (!l7vs_config_iomux) {
 507                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_ENVIRONMENT,4,"error / iom is null");
 508                 return;
 509         }
 510         l7vs_config_iomux->status = iomux_config_command_list_rs_received;
 511
 512         rsp.cmd = req->cmd;
 513         rsp.code = 0;
 514         iov[0].iov_base = &rsp;
 515         iov[0].iov_len = sizeof(rsp);
 516
 517         sarg = (struct l7vs_service_arg_multi *)(req + 1);
 518
 519         srv = l7vs_service_lookup(sarg);
 520         if (srv == NULL) {
 521                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_ENVIRONMENT,5,"error / service not found");
 522
 523                 l7vs_config_iomux->status = iomux_config_command_novs_error;
 524                 rsp.code = L7VS_CONFIG_ERR_NOVS;
 525
 526                 if(logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_SOCKET) == LOG_LV_DEBUG){
 527                         char config_str[DEBUG_STR_LEN] = {0};
 528                         snprintf(config_str,DEBUG_STR_LEN,
 529                                 "cmd=%d: "
 530                                 "code=%d: ",
 531                                 rsp.cmd,rsp.code);
 532                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_SOCKET,2,
 533                                       "list RealServer: send data=%s",
 534                                        config_str);
 535                 }
 536                 l7vs_config_send_response(addr, iov, 1);
 537                 return;
 538         }
 539
 540         l7vs_config_iomux->status = iomux_config_command_list_rs_vs_found;
 541
 542         ret = l7vs_service_list_dest_arg(srv, &das);
 543         if (ret < 0) {
 544                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_ENVIRONMENT,6,"error / dest not found");
 545                 l7vs_config_iomux->status = iomux_config_command_nomem_error;
 546                 rsp.code = L7VS_CONFIG_ERR_NOMEM;
 547                 if(logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_SOCKET) == LOG_LV_DEBUG){
 548                         char config_str[DEBUG_STR_LEN] = {0};
 549                         snprintf(config_str,DEBUG_STR_LEN,
 550                                 "cmd=%d: "
 551                                 "code=%d: ",
 552                                 rsp.cmd,rsp.code);
 553                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_SOCKET,3,
 554                                       "list RealServer: send data=%s",
 555                                        config_str);
 556                 }
 557                 l7vs_config_send_response(addr, iov, 1);
 558                 return;
 559         }
 560
 561         rsp.num = ret;
 562         if (ret == 0) {
 563                 iovlen = 1;
 564         } else {
 565                 iov[1].iov_base = das;
 566                 iov[1].iov_len = ret * sizeof(*das);
 567                 iovlen = 2;
 568         }
 569
 570         l7vs_config_iomux->status = iomux_config_command_list_rs_succeeded;
 571         if(logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_SOCKET) == LOG_LV_DEBUG){
 572                 char config_str[DEBUG_STR_LEN] = {0};
 573                 snprintf(config_str,DEBUG_STR_LEN,
 574                         "cmd=%d: "
 575                         "code=%d: ",
 576                         rsp.cmd,rsp.code);
 577                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_SOCKET,4,
 578                                       "list RealServer: send data=%s",
 579                                      config_str);
 580         }
 581
 582         l7vs_config_send_response(addr, iov, iovlen);
 583         if (das != NULL) {
 584                 free(das);
 585                 das = NULL;
 586         }
 587
 588         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
 589                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,15,
 590                 "out_fuction:  void l7vs_config_list_rs return void");
 591         }
 592 }
 593
 594 /*!
 595  * config event add virtual service
 596  * @param[in]           union l7vs_config_req request messege from l7vsadm
 597  * @param[in]           struct sockaddr_un l7vsd socket pointer
 598  * @return              void
 599  */
 600 static void
 601 l7vs_config_add_vs(union l7vs_config_req *arg,
 602                    struct sockaddr_un *addr)
 603 {
 604         struct l7vs_config_req_operate_vs *req = &arg->operate_vs;
 605         struct l7vs_config_rsp_operate_vs rsp;
 606         struct l7vs_service_arg_multi *sarg;
 607         struct l7vs_service *srv;
 608         struct iovec iov;
 609
 610         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
 611                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,16,
 612                 "in_fuction:  void l7vs_config_add_vs (union l7vs_config_req *arg, struct sockaddr_un *addr)"
 613                 "arg= %p: addr= %p",arg,addr);
 614         }
 615         if (!l7vs_config_iomux) {
 616                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_ENVIRONMENT,7,"error / iom is null");
 617                 return;
 618         }
 619         l7vs_config_iomux->status = iomux_config_command_add_vs_received;
 620
 621         rsp.cmd = req->cmd;
 622         rsp.code = 0;
 623
 624         iov.iov_base = &rsp;
 625         iov.iov_len = sizeof(rsp);
 626
 627         sarg = (struct l7vs_service_arg_multi *)(req + 1);
 628         srv = l7vs_service_lookup(sarg);
 629         if (srv != NULL) {
 630                 if(logger_get_log_level(LOG_CAT_L7VSD_VIRTUAL_SERVICE) == LOG_LV_DEBUG){
 631                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_VIRTUAL_SERVICE,1,"ADD_VS: service already exists");
 632                 }
 633                 l7vs_config_iomux->status = iomux_config_command_vs_exist_error;
 634                 rsp.code = L7VS_CONFIG_ERR_VS_EXISTS;
 635                 goto out;
 636         }
 637
 638         l7vs_config_iomux->status = iomux_config_command_add_vs_vs_not_found;
 639
 640         srv = l7vs_service_create(sarg, &rsp.code);
 641         if (srv == NULL) {
 642                 if(logger_get_log_level(LOG_CAT_L7VSD_VIRTUAL_SERVICE) == LOG_LV_DEBUG){
 643                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_VIRTUAL_SERVICE,2,"ADD_VS: service already exists");
 644                 }
 645                 l7vs_config_iomux->status = iomux_config_command_vs_create_error;
 646                 goto out;
 647         } else {
 648                 l7vs_config_iomux->status = iomux_config_command_add_vs_vs_created;
 649                 LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_VIRTUAL_SERVICE,1,"ADD_VS: IFRM001: created a service ");
 650         }
 651
 652         l7vs_config_iomux->status = iomux_config_command_add_vs_succeeded;
 653
 654 out:
 655         if(logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_SOCKET) == LOG_LV_DEBUG){
 656                 char config_str[DEBUG_STR_LEN] = {0};
 657                 snprintf(config_str,DEBUG_STR_LEN,
 658                         "cmd=%d: "
 659                         "code=%d: ",
 660                         rsp.cmd,rsp.code);
 661                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_SOCKET,5,
 662                                      "add VertualService: send data=%s",
 663                                      config_str);
 664         }
 665         l7vs_config_send_response(addr, &iov, 1);
 666         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
 667                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,17,
 668                 "out_fuction:  void l7vs_config_add_vs return void");
 669         }
 670 }
 671
 672 /*!
 673  * config event delete virtual service
 674  * @param[in]           union l7vs_config_req request messege from l7vsadm
 675  * @param[in]           struct sockaddr_un l7vsd socket pointer
 676  * @return              void
 677  */
 678 static void
 679 l7vs_config_del_vs(union l7vs_config_req *arg,
 680                    struct sockaddr_un *addr)
 681 {
 682         struct l7vs_config_req_operate_vs *req = &arg->operate_vs;
 683         struct l7vs_config_rsp_operate_vs rsp;
 684         struct l7vs_service_arg_multi *sarg;
 685         struct l7vs_service *srv;
 686         struct l7vs_dest *dest;
 687         struct iovec iov;
 688
 689         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
 690                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,18,
 691                 "in_fuction:  void l7vs_config_del_vs (union l7vs_config_req *arg, struct sockaddr_un *addr)"
 692                 "arg= %p: addr= %p",arg,addr);
 693         }
 694         if (!l7vs_config_iomux) {
 695                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_ENVIRONMENT,8,"error / iom is null");
 696                 return;
 697         }
 698         l7vs_config_iomux->status = iomux_config_command_del_vs_received;
 699
 700         rsp.cmd = req->cmd;
 701         rsp.code = 0;
 702
 703         iov.iov_base = &rsp;
 704         iov.iov_len = sizeof(rsp);
 705
 706         sarg = (struct l7vs_service_arg_multi *)(req + 1);
 707         srv = l7vs_service_lookup(sarg);
 708         if (srv == NULL) {
 709                 if(logger_get_log_level(LOG_CAT_L7VSD_VIRTUAL_SERVICE) == LOG_LV_DEBUG){
 710                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_VIRTUAL_SERVICE,3,"DEL_VS: service nonexistent");
 711                 }
 712                 l7vs_config_iomux->status = iomux_config_command_novs_error;
 713                 rsp.code = L7VS_CONFIG_ERR_NOVS;
 714                 goto out;
 715         }
 716
 717         l7vs_config_iomux->status = iomux_config_command_del_vs_vs_found;
 718
 719         while (g_list_length(srv->dest_list) > 0) {
 720                 dest = (struct l7vs_dest *)((g_list_first(srv->dest_list))->data);
 721                 srv->dest_list = g_list_remove(srv->dest_list, dest);
 722                 l7vs_dest_destroy(dest);
 723         }
 724
 725         l7vs_config_iomux->status = iomux_config_command_del_vs_dest_destroyed;
 726
 727         l7vs_service_destroy(srv);
 728
 729         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_VIRTUAL_SERVICE,3,"DEL_VS: IFRM003: released virtual service");
 730         l7vs_config_iomux->status = iomux_config_command_del_vs_succeeded;
 731
 732 out:
 733         if(logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_SOCKET) == LOG_LV_DEBUG){
 734                 char config_str[DEBUG_STR_LEN] = {0};
 735                 snprintf(config_str,DEBUG_STR_LEN,
 736                         "cmd=%d: "
 737                         "code=%d: ",
 738                         rsp.cmd,rsp.code);
 739                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_SOCKET,6,
 740                                     "delete VertualService: send data=%s",
 741                                     config_str);
 742         }
 743         l7vs_config_send_response(addr, &iov, 1);
 744         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
 745                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,19,
 746                 "out_fuction:  void l7vs_config_del_vs retrurn void");
 747         }
 748 }
 749
 750 /*!
 751  * config event edit virtual service
 752  * @param[in]           union l7vs_config_req request messege from l7vsadm
 753  * @param[in]           struct sockaddr_un l7vsd socket pointer
 754  * @return              void
 755  */
 756 static void
 757 l7vs_config_edit_vs(union l7vs_config_req *arg,
 758                     struct sockaddr_un *addr)
 759 {
 760         struct l7vs_config_req_operate_vs *req = &arg->operate_vs;
 761         struct l7vs_config_rsp_operate_vs rsp;
 762         struct l7vs_service_arg_multi *sarg;
 763         struct l7vs_service *srv;
 764         struct l7vs_scheduler *sched, *sched_old;
 765         struct iovec iov;
 766         int     retval;
 767
 768         struct l7vs_service_arg_multi tmp_sarg;
 769
 770         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
 771                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,20,
 772                 "in_fuction:  void l7vs_config_edit_vs (union l7vs_config_req *arg, struct sockaddr_un *addr)"
 773                 "arg= %p: addr= %p",arg,addr);
 774         }
 775
 776         memset(&tmp_sarg,0x00,sizeof(struct l7vs_service_arg_multi));
 777
 778         if (!l7vs_config_iomux) {
 779                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_ENVIRONMENT,9,"error / iom is null");
 780                 return;
 781         }
 782         l7vs_config_iomux->status = iomux_config_command_edit_vs_received;
 783
 784         rsp.cmd = req->cmd;
 785         rsp.code = 0;
 786
 787         iov.iov_base = &rsp;
 788         iov.iov_len = sizeof(rsp);
 789
 790         sarg = (struct l7vs_service_arg_multi *)(req + 1);
 791         srv = l7vs_service_lookup(sarg);
 792         if (srv == NULL) {
 793                 if(logger_get_log_level(LOG_CAT_L7VSD_VIRTUAL_SERVICE) == LOG_LV_DEBUG){
 794                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_VIRTUAL_SERVICE,4,"EDIT_VS: service nonexistent");
 795                 }
 796                 l7vs_config_iomux->status = iomux_config_command_novs_error;
 797                 rsp.code = L7VS_CONFIG_ERR_NOVS;
 798                 goto out;
 799         }
 800
 801         l7vs_config_iomux->status = iomux_config_command_edit_vs_vs_found;
 802
 803
 804         if(sarg->srv_arg.sorry_cc != -1) {
 805                 tmp_sarg.srv_arg.sorry_cc = sarg->srv_arg.sorry_cc;
 806         } else{
 807                 tmp_sarg.srv_arg.sorry_cc = srv->sorry_cc;
 808         }
 809
 810         memset(&(tmp_sarg.srv_arg.sorry_addr),0xff,sizeof(struct sockaddr_storage));
 811         if(memcmp(&(tmp_sarg.srv_arg.sorry_addr),&(sarg->srv_arg.sorry_addr),
 812         sizeof(struct sockaddr_storage))) {
 813                 memcpy(&(tmp_sarg.srv_arg.sorry_addr),
 814                         &(sarg->srv_arg.sorry_addr),
 815                         sizeof(struct sockaddr_storage));
 816         } else{
 817                 memcpy(&(tmp_sarg.srv_arg.sorry_addr),
 818                         &(srv->sorry_dest->addr),
 819                         sizeof(struct sockaddr_in));
 820         }
 821
 822         if(sarg->srv_arg.sorry_flag != -1) {
 823                 tmp_sarg.srv_arg.sorry_flag = sarg->srv_arg.sorry_flag;
 824         } else{
 825                 tmp_sarg.srv_arg.sorry_flag = srv->sorry_flag;
 826         }
 827
 828         if(sarg->srv_arg.qos_threshold_up != ULLONG_MAX) {
 829                 tmp_sarg.srv_arg.qos_threshold_up = sarg->srv_arg.qos_threshold_up;
 830         } else{
 831                 tmp_sarg.srv_arg.qos_threshold_up = srv->qos_threshold_up;
 832         }
 833
 834         if(sarg->srv_arg.qos_threshold_down != ULLONG_MAX) {
 835                 tmp_sarg.srv_arg.qos_threshold_down = sarg->srv_arg.qos_threshold_down;
 836         } else{
 837                 tmp_sarg.srv_arg.qos_threshold_down = srv->qos_threshold_down;
 838         }
 839
 840         retval = l7vs_service_set_QoS_Threshold( srv, &tmp_sarg );
 841         if( 0 > retval ){
 842                 if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK_QOS) == LOG_LV_DEBUG){
 843                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK_QOS,1,"EDIT_VS: QoS set failure");
 844                 }
 845                 l7vs_config_iomux->status = iomux_config_command_set_qos_error;
 846                 rsp.code = L7VS_CONFIG_ERR_QOSSET;
 847                 goto out;
 848         }
 849         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK_QOS) == LOG_LV_DEBUG){
 850                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK_QOS,2,"EDIT_VS: QoS set success");
 851         }
 852
 853         retval = l7vs_service_set_SorryServer_Values( srv, &tmp_sarg );
 854         if( 0 > retval ){
 855                 if(logger_get_log_level(LOG_CAT_L7VSD_SORRY_SERVER) == LOG_LV_DEBUG){
 856                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SORRY_SERVER,1,"EDIT_VS: SorryServer set failure");
 857                 }
 858                 l7vs_config_iomux->status = iomux_config_command_set_sorry_server_error;
 859                 rsp.code = L7VS_CONFIG_ERR_SORRYSET;
 860                 goto out;
 861         }
 862         if(logger_get_log_level(LOG_CAT_L7VSD_SORRY_SERVER) == LOG_LV_DEBUG){
 863                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SORRY_SERVER,2,"EDIT_VS: SorryServer set success");
 864         }
 865
 866         memset(&(tmp_sarg.srv_arg.schedmod),0x00,sizeof(tmp_sarg.srv_arg.schedmod));
 867         if(memcmp(&(tmp_sarg.srv_arg.schedmod),&(sarg->srv_arg.schedmod),
 868         sizeof(tmp_sarg.srv_arg.schedmod))) {
 869
 870                 sched = (struct l7vs_scheduler* )l7vs_sched_get(sarg->srv_arg.schedmod);
 871                 if (sched == NULL) {
 872                         if(logger_get_log_level(LOG_CAT_L7VSD_SCHEDULE) == LOG_LV_DEBUG){
 873                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SCHEDULE,1,"EDIT_VS: unknown scheduler");
 874                         }
 875                         l7vs_config_iomux->status = iomux_config_command_nosched_error;
 876                         rsp.code = L7VS_CONFIG_ERR_NOSCHED;
 877                         goto out;
 878                 } else {
 879                         if(logger_get_log_level(LOG_CAT_L7VSD_SCHEDULE) == LOG_LV_DEBUG){
 880                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SCHEDULE,2,"EDIT_VS: scheduler set success");
 881                         }
 882                 }
 883
 884                 l7vs_config_iomux->status = iomux_config_command_edit_vs_sched_got;
 885
 886                 sched_old = srv->scheduler;
 887                 if (sched != sched_old) {
 888                         l7vs_sched_unbind(sched_old, srv);
 889                         l7vs_sched_put(sched_old);
 890                         l7vs_sched_bind(sched, srv);
 891                 }
 892         }
 893
 894         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_VIRTUAL_SERVICE,2,"EDIT_VS: IFRM002: changed virtual service");
 895         l7vs_config_iomux->status = iomux_config_command_edit_vs_succeeded;
 896
 897 out:
 898         if(logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_SOCKET) == LOG_LV_DEBUG){
 899                 char config_str[DEBUG_STR_LEN] = {0};
 900                 snprintf(config_str,DEBUG_STR_LEN,
 901                         "cmd=%d: "
 902                         "code=%d: ",
 903                         rsp.cmd,rsp.code);
 904                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_SOCKET,7,
 905                                     "edit VertualService: send data=%s",
 906                                     config_str);
 907         }
 908         l7vs_config_send_response(addr, &iov, 1);
 909         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
 910                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,21,
 911                 "out_fuction:  void l7vs_config_edit_vs return void");
 912         }
 913 }
 914
 915 /*!
 916  * config event add real server
 917  * @param[in]           union l7vs_config_req request messege from l7vsadm
 918  * @param[in]           struct sockaddr_un l7vsd socket pointer
 919  * @return              void
 920  */
 921 static void
 922 l7vs_config_add_rs(union l7vs_config_req *arg,
 923                    struct sockaddr_un *addr)
 924 {
 925         struct l7vs_config_req_operate_rs *req = &arg->operate_rs;
 926         struct l7vs_config_rsp_operate_rs rsp;
 927         struct l7vs_service_arg_multi *sarg;
 928         struct l7vs_service *srv;
 929         struct iovec iov;
 930         int ret;
 931
 932         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
 933                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,22,
 934                 "in_fuction:  void l7vs_config_add_rs (union l7vs_config_req *arg, struct sockaddr_un *addr)"
 935                 "arg= %p: addr= %p",arg,addr);
 936         }
 937         if (!l7vs_config_iomux) {
 938                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_ENVIRONMENT,10,"error / iom is null");
 939                 return;
 940         }
 941         l7vs_config_iomux->status = iomux_config_command_add_rs_received;
 942
 943         rsp.cmd = req->cmd;
 944         rsp.code = 0;
 945
 946         iov.iov_base = &rsp;
 947         iov.iov_len = sizeof(rsp);
 948
 949         sarg = (struct l7vs_service_arg_multi *)(req + 1);
 950         srv = l7vs_service_lookup(sarg);
 951         if (srv == NULL) {
 952                 if(logger_get_log_level(LOG_CAT_L7VSD_REAL_SERVER) == LOG_LV_DEBUG){
 953                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REAL_SERVER,1,"ADD_RS: service nonexistent");
 954                 }
 955                 l7vs_config_iomux->status = iomux_config_command_novs_error;
 956                 rsp.code = L7VS_CONFIG_ERR_NOVS;
 957                 goto out;
 958         }
 959
 960         l7vs_config_iomux->status = iomux_config_command_add_rs_vs_found;
 961
 962         if (l7vs_service_lookup_dest(srv, &req->darg.addr) != NULL) {
 963                 if(logger_get_log_level(LOG_CAT_L7VSD_REAL_SERVER) == LOG_LV_DEBUG){
 964                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REAL_SERVER,2,"ADD_RS: real server already exists");
 965                 }
 966                 l7vs_config_iomux->status = iomux_config_command_rs_exist_error;
 967                 rsp.code = L7VS_CONFIG_ERR_RS_EXISTS;
 968                 goto out;
 969         }
 970
 971         l7vs_config_iomux->status = iomux_config_command_add_rs_rs_not_found;
 972
 973         ret = l7vs_service_add_dest(srv, &req->darg);
 974         if (ret < 0) {
 975                 if(logger_get_log_level(LOG_CAT_L7VSD_REAL_SERVER) == LOG_LV_DEBUG){
 976                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REAL_SERVER,3,"ADD_RS: failed to add real server");
 977                 }
 978                 l7vs_config_iomux->status = iomux_config_command_nomem_error;
 979                 rsp.code = L7VS_CONFIG_ERR_NOMEM;
 980                 goto out;
 981         }
 982
 983         l7vs_config_iomux->status = iomux_config_command_add_rs_succeeded;
 984
 985 out:
 986         if(logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_SOCKET) == LOG_LV_DEBUG){
 987                 char config_str[DEBUG_STR_LEN] = {0};
 988                 snprintf(config_str,DEBUG_STR_LEN,
 989                         "cmd=%d: "
 990                         "code=%d: ",
 991                         rsp.cmd,rsp.code);
 992                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_SOCKET,8,
 993                                     "add RealServer: send data=%s",
 994                                     config_str);
 995         }
 996         l7vs_config_send_response(addr, &iov, 1);
 997         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
 998                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,23,
 999                 "out_fuction:  void l7vs_config_add_rs return void");
1000         }
1001 }
1002
1003 /*!
1004  * config event delete real server
1005  * @param[in]           union l7vs_config_req request messege from l7vsadm
1006  * @param[in]           struct sockaddr_un l7vsd socket pointer
1007  * @return              void
1008  */
1009 static void
1010 l7vs_config_del_rs(union l7vs_config_req *arg,
1011                    struct sockaddr_un *addr)
1012 {
1013         struct l7vs_config_req_operate_rs *req = &arg->operate_rs;
1014         struct l7vs_config_rsp_operate_rs rsp;
1015         struct l7vs_service_arg_multi *sarg;
1016         struct l7vs_service *srv;
1017         struct l7vs_dest *dest;
1018         struct iovec iov;
1019         int ret;
1020
1021         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1022                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,24,
1023                 "in_fuction:  void l7vs_config_del_rs (union l7vs_config_req *arg, struct sockaddr_un *addr)"
1024                 "arg= %p: addr= %p",arg,addr);
1025         }
1026         if (!l7vs_config_iomux) {
1027                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_ENVIRONMENT,11,"error / iom is null");
1028                 return;
1029         }
1030         l7vs_config_iomux->status = iomux_config_command_del_rs_received;
1031
1032         rsp.cmd = req->cmd;
1033         rsp.code = 0;
1034
1035         iov.iov_base = &rsp;
1036         iov.iov_len = sizeof(rsp);
1037
1038         sarg = (struct l7vs_service_arg_multi *)(req + 1);
1039         srv = l7vs_service_lookup(sarg);
1040         if (srv == NULL) {
1041                 if(logger_get_log_level(LOG_CAT_L7VSD_REAL_SERVER) == LOG_LV_DEBUG){
1042                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REAL_SERVER,4,"DEL_RS: service nonexistent");
1043                 }
1044                 l7vs_config_iomux->status = iomux_config_command_novs_error;
1045                 rsp.code = L7VS_CONFIG_ERR_NOVS;
1046                 goto out;
1047         }
1048
1049         l7vs_config_iomux->status = iomux_config_command_del_rs_vs_found;
1050
1051         dest = l7vs_service_lookup_dest(srv, &req->darg.addr);
1052         if (dest == NULL) {
1053                 if(logger_get_log_level(LOG_CAT_L7VSD_REAL_SERVER) == LOG_LV_DEBUG){
1054                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REAL_SERVER,5,"DEL_RS: destination nonexistent");
1055                 }
1056                 l7vs_config_iomux->status = iomux_config_command_nors_error;
1057                 rsp.code = L7VS_CONFIG_ERR_NORS;
1058                 goto out;
1059         }
1060
1061         l7vs_config_iomux->status = iomux_config_command_del_rs_rs_found;
1062
1063         ret = l7vs_service_remove_dest(srv, &req->darg);
1064         if (ret < 0) {
1065                 if(logger_get_log_level(LOG_CAT_L7VSD_REAL_SERVER) == LOG_LV_DEBUG){
1066                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REAL_SERVER,6,"DEL_RS: failed to remove real server");
1067                 }
1068                 /* XXX actually impossible */
1069                 rsp.code = L7VS_CONFIG_ERR_NORS;
1070                 goto out;
1071         }
1072
1073         l7vs_config_iomux->status = iomux_config_command_del_rs_succeeded;
1074
1075 out:
1076         if(logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_SOCKET) == LOG_LV_DEBUG){
1077                 char config_str[DEBUG_STR_LEN] = {0};
1078                 snprintf(config_str,DEBUG_STR_LEN,
1079                         "cmd=%d: "
1080                         "code=%d: ",
1081                         rsp.cmd,rsp.code);
1082                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_SOCKET,9,
1083                                     "delete RealServer: send data=%s",
1084                                     config_str);
1085         }
1086         l7vs_config_send_response(addr, &iov, 1);
1087         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1088                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,25,
1089                 "out_fuction:  void l7vs_config_del_rs return void");
1090         }
1091 }
1092
1093 /*!
1094  * config event edit real server
1095  * @param[in]           union l7vs_config_req request messege from l7vsadm
1096  * @param[in]           struct sockaddr_un l7vsd socket pointer
1097  * @return              void
1098  */
1099 static void
1100 l7vs_config_edit_rs(union l7vs_config_req *arg,
1101                     struct sockaddr_un *addr)
1102 {
1103         struct l7vs_config_req_operate_rs *req = &arg->operate_rs;
1104         struct l7vs_config_rsp_operate_rs rsp;
1105         struct l7vs_service_arg_multi *sarg;
1106         struct l7vs_service *srv;
1107         struct l7vs_dest *dest;
1108         struct iovec iov;
1109
1110         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1111                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,26,
1112                 "in_fuction:  void l7vs_config_edit_rs (union l7vs_config_req *arg, struct sockaddr_un *addr)"
1113                 "arg= %p: addr= %p",arg,addr);
1114         }
1115         if (!l7vs_config_iomux) {
1116                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_ENVIRONMENT,12,"error / iom is null");
1117                 return;
1118         }
1119         l7vs_config_iomux->status = iomux_config_command_edit_rs_received;
1120
1121         rsp.cmd = req->cmd;
1122         rsp.code = 0;
1123
1124         iov.iov_base = &rsp;
1125         iov.iov_len = sizeof(rsp);
1126
1127         sarg = (struct l7vs_service_arg_multi *)(req + 1);
1128         srv = l7vs_service_lookup(sarg);
1129         if (srv == NULL) {
1130                 if(logger_get_log_level(LOG_CAT_L7VSD_REAL_SERVER) == LOG_LV_DEBUG){
1131                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REAL_SERVER,7,"EDIT_RS: service nonexistent");
1132                 }
1133                 rsp.code = L7VS_CONFIG_ERR_NOVS;
1134                 goto out;
1135         }
1136
1137         l7vs_config_iomux->status = iomux_config_command_edit_rs_vs_found;
1138
1139         dest = l7vs_service_lookup_dest(srv, &req->darg.addr);
1140         if (dest == NULL) {
1141                 if(logger_get_log_level(LOG_CAT_L7VSD_REAL_SERVER) == LOG_LV_DEBUG){
1142                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REAL_SERVER,8,"EDIT_RS: destination nonexistent");
1143                 }
1144                 rsp.code = L7VS_CONFIG_ERR_NORS;
1145                 goto out;
1146         }
1147
1148         l7vs_config_iomux->status = iomux_config_command_edit_rs_rs_found;
1149
1150         if(req->darg.weight != -1){
1151                 dest->weight = req->darg.weight;
1152         }
1153
1154         l7vs_config_iomux->status = iomux_config_command_edit_rs_succeeded;
1155
1156 out:
1157         if(logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_SOCKET) == LOG_LV_DEBUG){
1158                 char config_str[DEBUG_STR_LEN] = {0};
1159                 snprintf(config_str,DEBUG_STR_LEN,
1160                         "cmd=%d: "
1161                         "code=%d: ",
1162                         rsp.cmd,rsp.code);
1163                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_SOCKET,10,
1164                                     "edit RealServer: send data=%s",
1165                                     config_str);
1166         }
1167         l7vs_config_send_response(addr, &iov, 1);
1168         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1169                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,27,
1170                 "out_fuction:  void l7vs_config_edit_rs return void");
1171         }
1172 }
1173
1174 /*!
1175  * config event delete all viertual service
1176  * @param[in]           union l7vs_config_req request messege from l7vsadm
1177  * @param[in]           struct sockaddr_un l7vsd socket pointer
1178  * @return              void
1179  */
1180 static void
1181 l7vs_config_flush_vs(union l7vs_config_req *arg, struct sockaddr_un *addr)
1182 {
1183         struct l7vs_config_req_flush_vs *req = &arg->flush_vs;
1184         struct l7vs_config_rsp_flush_vs rsp;
1185         struct iovec iov;
1186
1187         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1188                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,28,
1189                 "in_fuction:  void l7vs_config_flush_vs (union l7vs_config_req *arg, struct sockaddr_un *addr)"
1190                 "arg= %p: addr= %p",arg,addr);
1191         }
1192         if (!l7vs_config_iomux) {
1193                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_ENVIRONMENT,13,"error / iom is null");
1194                 return;
1195         }
1196         l7vs_config_iomux->status = iomux_config_command_flush_vs_received;
1197
1198         rsp.cmd = req->cmd;
1199         rsp.code = 0;
1200
1201         iov.iov_base = &rsp;
1202         iov.iov_len = sizeof(rsp);
1203
1204         l7vs_service_flush_all();
1205
1206         l7vs_config_iomux->status = iomux_config_command_flush_vs_succeeded;
1207
1208         if(logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_SOCKET) == LOG_LV_DEBUG){
1209                 char config_str[DEBUG_STR_LEN] = {0};
1210                 snprintf(config_str,DEBUG_STR_LEN,
1211                         "cmd=%d: "
1212                         "code=%d: ",
1213                         rsp.cmd,rsp.code);
1214                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_SOCKET,11,
1215                                     "flush VertualService: send data=%s",
1216                                     config_str);
1217         }
1218         l7vs_config_send_response(addr, &iov, 1);
1219         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1220                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,29,
1221                 "in_fuction:  void l7vs_config_flush_vs return void");
1222         }
1223 }
1224
1225 /*!
1226  * config send response
1227  * @param[in]           struct sockaddr_un l7vsd socket pointer
1228  * @param[in]           struct iovec sending messege
1229  * @param[in]           int sending messege size
1230  * @return              int   sendmsg NG<0 OK >=0
1231  */
1232 static int
1233 l7vs_config_send_response(struct sockaddr_un *addr,
1234                           struct iovec *iov,
1235                           int iovlen)
1236 {
1237         struct  msghdr msg;
1238         int ret;
1239         struct l7vs_config_rsp_unknown_cmd rsp;
1240         struct iovec err_iov;
1241
1242         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1243                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,30,
1244                 "in_fuction:  int l7vs_config_send_response (struct sockaddr_un *addr,struct iovec *iov,int iovlen)"
1245                 "addr= %p : iov= %p : iovlen= %d",addr,iov,iovlen);
1246         }
1247
1248         if (!l7vs_config_iomux) {
1249                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_ENVIRONMENT,14,"error / iom is null");
1250                 return -1;
1251         }
1252
1253         memset(&msg, 0, sizeof(msg));
1254         msg.msg_name = addr;
1255         msg.msg_namelen = sizeof(*addr);
1256         msg.msg_iov = iov;
1257         msg.msg_iovlen = iovlen;
1258
1259         ret = sendmsg(l7vs_config_iomux->fd, &msg, 0);
1260         if (ret < 0) {
1261                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_SOCKET,5,"sendmsg on config socket: %s", strerror(errno));
1262                 // Try sending error response to l7vsadm.
1263                 rsp.cmd = ((struct l7vs_config_rsp_unknown_cmd *)(&iov->iov_base))->cmd;
1264                 rsp.code = L7VS_CONFIG_ERR_SENDMSG;
1265                 err_iov.iov_base = &rsp;
1266                 err_iov.iov_len = sizeof(rsp);
1267                 memset(&msg, 0, sizeof(msg));
1268                 msg.msg_name = addr;
1269                 msg.msg_namelen = sizeof(*addr);
1270                 msg.msg_iov = &err_iov;
1271                 msg.msg_iovlen = 1;
1272                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_SOCKET,6,"Try sending error response to l7vsadm.");
1273                 if (sendmsg(l7vs_config_iomux->fd, &msg, 0) < 0) {
1274                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_SOCKET,7,"retry error sendmsg on config socket: %s", strerror(errno));
1275                 }
1276         }
1277         l7vs_config_iomux->status = iomux_config_command_response_sent;
1278
1279         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1280                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,31,
1281                 "out_fuction:  int l7vs_config_send_response return ret = %d",ret);
1282         }
1283         return ret;
1284 }
1285
1286 /*!
1287  * config event get replication information
1288  * @param[in]           union l7vs_config_req messege pointer
1289  * @param[in]           struct sockaddr_un l7vsd socket pointer
1290  * @return              void
1291  */
1292 static void
1293 l7vs_config_get_replication_info (union l7vs_config_req *arg, struct sockaddr_un *addr)
1294 {
1295         struct l7vs_config_msg_replication *req = &arg->msg_replication;
1296         struct l7vs_config_msg_replication rsp;
1297         struct iovec iov;
1298
1299         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1300                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,32,
1301                 "in_fuction:  void l7vs_config_get_replication_info (union l7vs_config_req *arg, struct sockaddr_un *addr)"
1302                 "arg= %p: addr= %p",arg,addr);
1303         }
1304
1305         if (!l7vs_config_iomux) {
1306                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_ENVIRONMENT,15,"error / iom is null");
1307                 return;
1308         }
1309
1310         memset(&rsp,0x00,sizeof(struct l7vs_config_msg_replication));
1311         rsp.cmd = req->cmd;
1312         rsp.code = 0;
1313         iov.iov_base = &rsp;
1314         iov.iov_len = sizeof(struct l7vs_config_msg_replication);
1315         rsp.replication_mode = l7vs_replication_get_status();
1316         if(logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_SOCKET) == LOG_LV_DEBUG){
1317                 char config_str[DEBUG_STR_LEN] = {0};
1318                 snprintf(config_str,DEBUG_STR_LEN,
1319                         "cmd=%d: "
1320                         "code=%d: ",
1321                         rsp.cmd,rsp.code);
1322                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_SOCKET,12,
1323                                     "get replication info: send data=%s",
1324                                     config_str);
1325         }
1326         l7vs_config_send_response(addr, &iov, 1);
1327         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1328                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,33,
1329                 "out_fuction:  void l7vs_config_get_replication_info return void");
1330         }
1331 }
1332
1333 /*!
1334  * config event get snmp information
1335  * @param[in]           union l7vs_config_req messege pointer
1336  * @param[in]           struct sockaddr_un l7vsd socket pointer
1337  * @return              void
1338  */
1339 static void
1340 l7vs_config_get_snmp_log_info (union l7vs_config_req *arg, struct sockaddr_un *addr)
1341 {
1342         struct l7vs_config_msg_snmp *req = &arg->msg_snmp;
1343         struct l7vs_config_msg_snmp rsp;
1344         struct iovec iov;
1345
1346         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1347                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,34,
1348                 "in_fuction:  void l7vs_config_get_snmp_log_info (union l7vs_config_req *arg, struct sockaddr_un *addr)"
1349                 "arg= %p: addr= %p",arg,addr);
1350         }
1351
1352         if (!l7vs_config_iomux) {
1353                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_ENVIRONMENT,16,"error / iom is null");
1354                 return;
1355         }
1356
1357         memset(&rsp,0x00,sizeof(struct l7vs_config_msg_snmp));
1358         memcpy(&rsp,req,sizeof(struct l7vs_config_msg_snmp));
1359         rsp.code = 0;
1360         iov.iov_base = &rsp;
1361         iov.iov_len = sizeof(rsp);
1362         rsp.snmp_log_level = l7vs_snmpbridge_get_loglevel(rsp.kind);
1363         if(logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_SOCKET) == LOG_LV_DEBUG){
1364                 char config_str[DEBUG_STR_LEN] = {0};
1365                 snprintf(config_str,DEBUG_STR_LEN,
1366                         "cmd=%d: "
1367                         "code=%d: ",
1368                         rsp.cmd,rsp.code);
1369                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_SOCKET,13,
1370                                     "get snmp log level: send data=%s",
1371                                     config_str);
1372         }
1373         l7vs_config_send_response(addr, &iov, 1);
1374         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1375                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,35,
1376                 "out_fuction:  void l7vs_config_get_snmp_log_info return void");
1377         }
1378 }
1379
1380 /*!
1381  * config event get snmp connect status
1382  * @param[in]           union l7vs_config_req messege pointer
1383  * @param[in]           struct sockaddr_un l7vsd socket pointer
1384  * @return              void
1385  */
1386 static void
1387 l7vs_config_get_snmp_connect_status (union l7vs_config_req *arg, struct sockaddr_un *addr)
1388 {
1389         struct l7vs_config_msg_snmp *req = &arg->msg_snmp;
1390         struct l7vs_config_msg_snmp rsp;
1391         struct iovec iov;
1392
1393         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1394                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,36,
1395                 "in_fuction:  void l7vs_config_get_snmp_connect_status (union l7vs_config_req *arg, struct sockaddr_un *addr)"
1396                 "arg= %p: addr= %p",arg,addr);
1397         }
1398
1399         if (!l7vs_config_iomux) {
1400                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_ENVIRONMENT,17,"error / iom is null");
1401                 return;
1402         }
1403
1404         memset(&rsp,0x00,sizeof(struct l7vs_config_msg_snmp));
1405         memcpy(&rsp,req,sizeof(struct l7vs_config_msg_snmp));
1406         rsp.code = 0;
1407         iov.iov_base = &rsp;
1408         iov.iov_len = sizeof(rsp);
1409         rsp.connection_status = l7vs_snmpbridge_get_connectionstate();
1410         if(logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_SOCKET) == LOG_LV_DEBUG){
1411                 char config_str[DEBUG_STR_LEN] = {0};
1412                 snprintf(config_str,DEBUG_STR_LEN,
1413                         "cmd=%d: "
1414                         "code=%d: ",
1415                         rsp.cmd,rsp.code);
1416                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_PROGRAM,25,
1417                                     "get snmp connect status: send data=%s",
1418                                     config_str);
1419         }
1420         l7vs_config_send_response(addr, &iov, 1);
1421         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1422                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,37,
1423                 "out_fuction:  void l7vs_config_get_snmp_connect_status return void");
1424         }
1425 }
1426
1427 /*!
1428  * config event get log level information
1429  * @param[in]           union l7vs_config_req messege pointer
1430  * @param[in]           struct sockaddr_un l7vsd socket pointer
1431  * @return              void
1432  */
1433 static void
1434 l7vs_config_get_log_info (union l7vs_config_req *arg, struct sockaddr_un *addr)
1435 {
1436         struct l7vs_config_msg_log *req = &arg->msg_log;
1437         struct l7vs_config_msg_log rsp;
1438         struct iovec iov;
1439
1440         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1441                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,38,
1442                 "in_fuction:  void l7vs_config_get_log_info (union l7vs_config_req *arg, struct sockaddr_un *addr)"
1443                 "arg= %p: addr= %p",arg,addr);
1444         }
1445         if (!l7vs_config_iomux) {
1446                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_ENVIRONMENT,18,"error / iom is null");
1447                 return;
1448         }
1449
1450         memset(&rsp,0x00,sizeof(struct l7vs_config_msg_log));
1451         memcpy(&rsp,req,sizeof(struct l7vs_config_msg_log));
1452         iov.iov_base = &rsp;
1453         iov.iov_len = sizeof(rsp);
1454         rsp.vsd_log_level = logger_get_log_level(req->kind);
1455         if(logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_SOCKET) == LOG_LV_DEBUG){
1456                 char config_str[DEBUG_STR_LEN] = {0};
1457                 snprintf(config_str,DEBUG_STR_LEN,
1458                         "cmd=%d: "
1459                         "code=%d: ",
1460                         rsp.cmd,rsp.code);
1461                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_SOCKET,14,
1462                                     "get snmp connect status: send data=%s",
1463                                     config_str);
1464         }
1465         l7vs_config_send_response(addr, &iov, 1);
1466         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1467                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,39,
1468                 "out_fuction:  void l7vs_config_get_log_info return void");
1469         }
1470 }
1471
1472 /*!
1473  * config event action replication
1474  * @param[in]           union l7vs_config_req messege pointer
1475  * @param[in]           struct sockaddr_un l7vsd socket pointer
1476  * @return              void
1477  */
1478 static void
1479 l7vs_config_replication (union l7vs_config_req *arg, struct sockaddr_un *addr)
1480 {
1481         struct l7vs_config_msg_replication *req = &arg->msg_replication;
1482         struct l7vs_config_msg_replication rsp;
1483         struct iovec iov;
1484
1485         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1486                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,40,
1487                 "in_fuction:  void l7vs_config_replication (union l7vs_config_req *arg, struct sockaddr_un *addr)"
1488                 "arg= %p: addr= %p",arg,addr);
1489         }
1490         if (!l7vs_config_iomux) {
1491                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_ENVIRONMENT,19,"error / iom is null");
1492                 return;
1493         }
1494         memset(&rsp,0x00,sizeof(struct l7vs_config_msg_replication));
1495         memcpy(&rsp,req,sizeof(struct l7vs_config_msg_replication));
1496         rsp.code = 0;
1497         iov.iov_base = &rsp;
1498         iov.iov_len = sizeof(rsp);
1499         switch(rsp.kind){
1500                 case L7VS_CONFIG_REPLICATION_DUMP:
1501                         l7vs_replication_dump_memory();
1502                         break;
1503                 case L7VS_CONFIG_REPLICATION_START:
1504                         l7vs_replication_start();
1505                         break;
1506                 case L7VS_CONFIG_REPLICATION_STOP:
1507                         l7vs_replication_stop();
1508                         break;
1509                 case L7VS_CONFIG_REPLICATION_COMPULSORILY:
1510                         l7vs_replication_compulsorily();
1511                         break;
1512         }
1513         if(logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_SOCKET) == LOG_LV_DEBUG){
1514                 char config_str[DEBUG_STR_LEN] = {0};
1515                 snprintf(config_str,DEBUG_STR_LEN,
1516                         "cmd=%d: "
1517                         "code=%d: ",
1518                         rsp.cmd,rsp.code);
1519                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_SOCKET,15,
1520                                     "config replication: send data=%s",
1521                                     config_str);
1522         }
1523         l7vs_config_send_response(addr, &iov, 1);
1524         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1525                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,41,
1526                 "out_fuction:  void l7vs_config_replication return void");
1527         }
1528 }
1529
1530 /*!
1531  * config event change snmp bridge apointed category log level
1532  * @param[in]           union l7vs_config_req messege pointer
1533  * @param[in]           struct sockaddr_un l7vsd socket pointer
1534  * @return              void
1535  */
1536 static void
1537 l7vs_config_snmp (union l7vs_config_req *arg, struct sockaddr_un *addr)
1538 {
1539         struct l7vs_config_msg_snmp *req = &arg->msg_snmp;
1540         struct l7vs_config_msg_snmp rsp;
1541         struct iovec iov;
1542
1543         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1544                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,42,
1545                 "in_fuction:  void l7vs_config_snmp (union l7vs_config_req *arg, struct sockaddr_un *addr)"
1546                 "arg= %p: addr= %p",arg,addr);
1547         }
1548         if (!l7vs_config_iomux) {
1549                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_ENVIRONMENT,20,"error / iom is null");
1550                 return;
1551         }
1552         memset(&rsp,0x00,sizeof(struct l7vs_config_msg_snmp));
1553         memcpy(&rsp,req,sizeof(struct l7vs_config_msg_snmp));
1554         rsp.code = 0;
1555         iov.iov_base = &rsp;
1556         iov.iov_len = sizeof(rsp);
1557         l7vs_snmpbridge_change_loglevel(req->kind,req->snmp_log_level);
1558         if(logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_SOCKET) == LOG_LV_DEBUG){
1559                 char config_str[DEBUG_STR_LEN] = {0};
1560                 snprintf(config_str,DEBUG_STR_LEN,
1561                         "cmd=%d: "
1562                         "code=%d: ",
1563                         rsp.cmd,rsp.code);
1564                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_SOCKET,16,
1565                                     "config snmp: send data=%s",
1566                                     config_str);
1567         }
1568         l7vs_config_send_response(addr, &iov, 1);
1569         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1570                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,43,
1571                 "out_fuction:  void l7vs_config_snmp return void");
1572         }
1573 }
1574
1575 /*!
1576  * config event change snmp bridge all category log level
1577  * @param[in]           union l7vs_config_req messege pointer
1578  * @param[in]           struct sockaddr_un l7vsd socket pointer
1579  * @return              void
1580  */
1581 static void
1582 l7vs_config_snmp_all (union l7vs_config_req *arg, struct sockaddr_un *addr)
1583 {
1584         struct l7vs_config_msg_snmp *req = &arg->msg_snmp;
1585         struct l7vs_config_msg_snmp rsp;
1586         struct iovec iov;
1587
1588         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1589                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,44,
1590                 "in_fuction:  void l7vs_config_snmp_all (union l7vs_config_req *arg, struct sockaddr_un *addr)"
1591                 "arg= %p: addr= %p",arg,addr);
1592         }
1593         if (!l7vs_config_iomux) {
1594                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_ENVIRONMENT,21,"error / iom is null");
1595                 return;
1596         }
1597         memset(&rsp,0x00,sizeof(struct l7vs_config_msg_snmp));
1598         memcpy(&rsp,req,sizeof(struct l7vs_config_msg_snmp));
1599         rsp.code = 0;
1600         iov.iov_base = &rsp;
1601         iov.iov_len = sizeof(rsp);
1602         l7vs_snmpbridge_change_loglevel_allcategory(req->snmp_log_level);
1603         if(logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_SOCKET) == LOG_LV_DEBUG){
1604                 char config_str[DEBUG_STR_LEN] = {0};
1605                 snprintf(config_str,DEBUG_STR_LEN,
1606                         "cmd=%d: "
1607                         "code=%d: ",
1608                         rsp.cmd,rsp.code);
1609                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_SOCKET,17,
1610                                     "config snmp: send data=%s",
1611                                     config_str);
1612         }
1613         l7vs_config_send_response(addr, &iov, 1);
1614         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1615                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,45,
1616                 "out_fuction:  void l7vs_config_snmp_all return void");
1617         }
1618 }
1619
1620 /*!
1621  * config event change l7vsd apointed category log level
1622  * @param[in]           union l7vs_config_req messege pointer
1623  * @param[in]           struct sockaddr_un l7vsd socket pointer
1624  * @return              void
1625  */
1626 static void
1627 l7vs_config_log (union l7vs_config_req *arg, struct sockaddr_un *addr)
1628 {
1629         struct l7vs_config_msg_log *req = &arg->msg_log;
1630         struct l7vs_config_msg_log rsp;
1631         struct iovec iov;
1632         LOG_CATEGORY_TAG log_start,log_stop;
1633         int  l_start,l_stop,i;
1634
1635         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1636                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,46,
1637                 "in_fuction:  void l7vs_config_log (union l7vs_config_req *arg, struct sockaddr_un *addr)"
1638                 "arg= %p: addr= %p",arg,addr);
1639         }
1640         if (!l7vs_config_iomux) {
1641                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_ENVIRONMENT,22,"error / iom is null");
1642                 return;
1643         }
1644         memset(&rsp,0x00,sizeof(struct l7vs_config_msg_log));
1645         memcpy(&rsp,req,sizeof(struct l7vs_config_msg_log));
1646         rsp.code = 0;
1647         iov.iov_base = &rsp;
1648         iov.iov_len = sizeof(rsp);
1649         if(rsp.cmd == L7VS_CONFIG_SET_LOG_LEVEL_ALL){
1650                 log_start = logger_get_category_range_start(LOG_MOD_L7VSD);
1651                 log_stop  = logger_get_category_range_end(LOG_MOD_L7VSD);
1652                 l_start =(int)log_start;
1653                 l_stop = (int)log_stop;
1654                 for(i = log_start;i <= l_stop; i++){
1655                         logger_set_log_level((LOG_CATEGORY_TAG)i,req->vsd_log_level);
1656                 }
1657
1658         }
1659         else{
1660                 logger_set_log_level(req->kind,req->vsd_log_level);
1661         }
1662
1663         if(logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_SOCKET) == LOG_LV_DEBUG){
1664                 char config_str[DEBUG_STR_LEN] = {0};
1665                 snprintf(config_str,DEBUG_STR_LEN,
1666                         "cmd=%d: "
1667                         "code=%d: ",
1668                         rsp.cmd,rsp.code);
1669                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_SOCKET,18,
1670                                     "config log level: send data=%s",
1671                                     config_str);
1672         }
1673         l7vs_config_send_response(addr, &iov, 1);
1674         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1675                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,47,
1676                 "out_fuction:  void l7vs_config_log return void");
1677         }
1678 }
1679
1680 /*!
1681  * config event relead parameter file
1682  * @param[in]           union l7vs_config_req messege pointer
1683  * @param[in]           struct sockaddr_un l7vsd socket pointer
1684  * @return              void
1685  */
1686 static void
1687 l7vs_config_parameter (union l7vs_config_req *arg, struct sockaddr_un *addr)
1688 {
1689         struct l7vs_config_msg_parameter *req = &arg->msg_parameter;
1690         struct l7vs_config_msg_parameter rsp;
1691         struct iovec iov;
1692
1693         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1694                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,48,
1695                 "in_fuction:  void l7vs_config_parameter (union l7vs_config_req *arg, struct sockaddr_un *addr)"
1696                 "arg= %p: addr= %p",arg,addr);
1697         }
1698
1699         if (!l7vs_config_iomux) {
1700                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_ENVIRONMENT,23,"error / iom is null");
1701                 return;
1702         }
1703         memset(&rsp,0x00,sizeof(struct l7vs_config_msg_parameter));
1704         memcpy(&rsp,req,sizeof(struct l7vs_config_msg_parameter));
1705         rsp.code = 0;
1706         iov.iov_base = &rsp;
1707         iov.iov_len = sizeof(rsp);
1708         parameter_reread_file(req->category);
1709         if(logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_SOCKET) == LOG_LV_DEBUG){
1710                 char config_str[DEBUG_STR_LEN] = {0};
1711                 snprintf(config_str,DEBUG_STR_LEN,
1712                         "cmd=%d: "
1713                         "code=%d: ",
1714                         rsp.cmd,rsp.code);
1715                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_SOCKET,19,
1716                                     "config parameter: send data=%s",
1717                                     config_str);
1718         }
1719         l7vs_config_send_response(addr, &iov, 1);
1720         if(logger_get_log_level(LOG_CAT_L7VSD_NETWORK) == LOG_LV_DEBUG){
1721                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_NETWORK,49,
1722                 "in_fuction:  void l7vs_config_parameter return void");
1723         }
1724 }