src/replication.c

   1 /*! @file
   2  *  @brief Replication structure program
   3  *
   4  *  @author NTT COMWARE
   5  *  @date
   6  *  @version
   7  */
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <stdint.h>
  12 #include <sys/types.h>
  13 #include <sys/socket.h>
  14 #include <sys/time.h>
  15 #include <sys/ioctl.h>
  16 #include <time.h>
  17 #include <netdb.h>
  18 #include <errno.h>
  19 #include "logger_wrapper.h"
  20 #include "parameter_wrapper.h"
  21 #include "l7vs_replication.h"
  22 #include "l7vs_iom.h"
  23 #include "l7vs_iomuxlist.h"
  24
  25 #include <net/if.h>
  26 #include <netinet/in.h>
  27 #include <arpa/inet.h>
  28 #include <iostream>
  29 #include <limits.h>
  30
  31 //---------- Initial set value
  32
  33 //! Initial value of Essential information set to SG file.
  34
  35
  36 static struct l7vs_replication_info replication_info;
  37
  38 //! Initial value of Replication status
  39 static struct l7vs_replication_state replication_state = {
  40         REPLICATION_OUT,
  41         0,
  42         0,
  43         0,
  44         0,
  45         NULL,
  46         NULL,
  47         0,
  48         NULL
  49 };
  50 //! iomux structure
  51 static struct l7vs_iomux *l7vs_replication_iomux = NULL;
  52
  53 //! recv sock
  54 struct  addressinfo{
  55         struct sockaddr_in      addr_in;
  56         struct sockaddr_in6     addr_in6;
  57 };
  58
  59 struct  addressinfo addr;
  60
  61 //! Internal value structure
  62 struct replication_internal_val
  63 {
  64         int                     socket;                 //!< Opened socket file descriptor
  65         struct addrinfo         *address_info;          //!< Socket property internal_val
  66         struct  addressinfo     addr;
  67 };
  68
  69
  70 static struct replication_internal_val internal_val = {
  71                 -1,
  72                 NULL,
  73                 addr
  74 };
  75
  76 //! emun States Type string
  77 static char replication_mode[6][24] = {
  78         "REPLICATION_OUT",
  79         "REPLICATION_SINGLE",
  80         "REPLICATION_MASTER",
  81         "REPLICATION_SLAVE",
  82         "REPLICATION_MASTER_STOP",
  83         "REPLICATION_SLAVE_STOP"
  84 };
  85
  86 // Initialize network socket
  87 static int l7vs_replication_send_sock_init();
  88 // Initialize network socket
  89 static int l7vs_replication_recv_sock_init();
  90 // Finalize network socket
  91 static void l7vs_replication_sock_fini();
  92 // Set master mode to iomux
  93 static int l7vs_replication_set_master();
  94 // Set slave mode to iomux
  95 static int l7vs_replication_set_slave();
  96 // Obtain the memory the replication is done
  97 static void *l7vs_replication_get_replication_address();
  98 // Release replication memory
  99 static void l7vs_replication_release_replication_address();
 100 // The memory the component uses
 101 static void *l7vs_replication_get_component_address();
 102 // Release component memory
 103 static void l7vs_replication_release_components_address();
 104 // The memory with information on respect switch
 105 static uint64_t *l7vs_replication_get_surface_info_address();
 106 // Release memory of information on respect switch
 107 static void l7vs_replication_release_surface_info_address();
 108 // get value check
 109 static int l7vs_replication_check_parameter();
 110 // make serial
 111 static unsigned long long l7vs_replication_make_serial();
 112 // send
 113 static int l7vs_replication_send_data(struct l7vs_replication_data *replication_data);
 114 // recve
 115 static int l7vs_replication_recv_data(struct l7vs_replication_data *replication_data);
 116 // get ip from nic
 117 static int getNICAddressInfo( const char* nicname, struct addressinfo* info );
 118
 119
 120 //---------- Debug Function declaration
 121 static void l7vs_replication_data_c_str(char *ret, struct l7vs_replication_data *replication_data);
 122 static void l7vs_replication_component_c_str(char *ret, struct l7vs_replication_component *component_info, int i);
 123 static void l7vs_replication_state_c_str(char *ret, struct l7vs_replication_state *replication_state);
 124 static void l7vs_replication_info_c_str(char *ret, struct l7vs_replication_info *replication_info);
 125 static void sockaddr_in_c_str(char *ret, struct sockaddr_in *addr_in);
 126
 127 /*! Initialize Replication
 128  *
 129  * @return 0/-1
 130  * @retval 0 Success
 131  * @retval -1 Error
 132  *
 133  */
 134
 135 int l7vs_replication_init()
 136 {
 137         int     component_num = 0;
 138         int     ret = -1;
 139         int     ip_addr_ret = -1;
 140         int     service_name_ret = -1;
 141         int     nic_ret = -1;
 142         int     interval_ret = -1;
 143
 144         // Check by continuous initialize.
 145         if ( REPLICATION_OUT != replication_state.service_status )
 146         {
 147                 // Initialization has already been done.
 148                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,1, "Initialization is a failure, because nitialization has already been done. mode : %s",
 149                                                                 replication_mode[(int)replication_state.service_status]);
 150                 ret = -1;
 151                 goto END;
 152         }
 153
 154         memset(&replication_info, 0, sizeof(struct l7vs_replication_info));
 155
 156         // Debug log
 157         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
 158                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,1, "in_function : int l7vs_replication_init(void)");
 159         }
 160         // Debug log END
 161
 162         // Debug log
 163         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG)
 164         {
 165                 char replication_state_str[DEBUG_STR_LEN] = {0};
 166                 l7vs_replication_state_c_str(replication_state_str,&replication_state);
 167                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,2,
 168                                         "set_l7vs_replication_state_struct : %s",
 169                                         replication_state_str);
 170
 171                 char replication_info_str[DEBUG_STR_LEN] = {0};
 172                 l7vs_replication_info_c_str(replication_info_str,&replication_info);
 173                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,3,
 174                                         "set_l7vs_replication_info_struct : %s",
 175                                         replication_info_str);
 176
 177                 for ( int i=0; i<replication_info.component_num; i++)
 178                 {
 179                         char replication_component_str[DEBUG_STR_LEN] = {0};
 180                         l7vs_replication_component_c_str(replication_component_str,replication_info.component_info,i);
 181                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,4,
 182                                                 "set_l7vs_replication_component_struct : %s",
 183                                                 replication_component_str);
 184                 }
 185         }
 186         // Debug log END
 187
 188         // Check the Parameter exists
 189         ip_addr_ret = parameter_is_char_exist( PARAM_COMP_REPLICATION,"ip_addr");
 190         service_name_ret = parameter_is_char_exist( PARAM_COMP_REPLICATION, "service_name" );
 191         nic_ret = parameter_is_char_exist( PARAM_COMP_REPLICATION, "nic");
 192         interval_ret = parameter_is_int_exist( PARAM_COMP_REPLICATION, "interval" );
 193
 194         // SG File not set
 195         if ( (0 == ip_addr_ret) && (0 == service_name_ret) && (0 == nic_ret) && (0 == interval_ret))
 196         {
 197                 // Status Set
 198                 replication_state.service_status = REPLICATION_SINGLE;
 199                 LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,1, "Required item is not set in l7vs. ");
 200                 ret = 0;
 201                 goto END;
 202         }
 203         // IP Address exists
 204         if ( 0 == ip_addr_ret  )
 205         {
 206                 // Status Set
 207                 replication_state.service_status = REPLICATION_SINGLE;
 208                 LOGGER_PUT_LOG_ERROR( LOG_CAT_L7VSD_REPLICATION,2, "IP Address is not set." );
 209                 ret = -1;
 210                 goto END;
 211         }
 212         // Port exists
 213         else if ( 0 == service_name_ret )
 214         {
 215                 // Status Set
 216                 replication_state.service_status = REPLICATION_SINGLE;
 217                 LOGGER_PUT_LOG_ERROR( LOG_CAT_L7VSD_REPLICATION,3, "Port is not set." );
 218                 ret = -1;
 219                 goto END;
 220         }
 221         // NIC exists
 222         else if ( 0 == nic_ret )
 223         {
 224                 // Status Set
 225                 replication_state.service_status = REPLICATION_SINGLE;
 226                 LOGGER_PUT_LOG_ERROR( LOG_CAT_L7VSD_REPLICATION,4, "NIC is not set." );
 227                 ret = -1;
 228                 goto END;
 229         }
 230         // Interval exists
 231         else if ( 0 == interval_ret )
 232         {
 233                 // Status Set
 234                 replication_state.service_status = REPLICATION_SINGLE;
 235                 LOGGER_PUT_LOG_ERROR( LOG_CAT_L7VSD_REPLICATION,5, "Interval is not set." );
 236                 ret = -1;
 237                 goto END;
 238         }
 239
 240         // Get IP Addressa
 241         strncpy(replication_info.ip_addr, parameter_get_char_value( PARAM_COMP_REPLICATION, "ip_addr" ),NI_MAXHOST);
 242         // Failed in the acquisition of IP
 243         if ( strcmp(replication_info.ip_addr,"") == 0)
 244         {
 245                 LOGGER_PUT_LOG_ERROR( LOG_CAT_L7VSD_REPLICATION,6, "Could not get IP Address." );
 246                 replication_state.service_status = REPLICATION_SINGLE;
 247                 ret = -1;
 248                 goto END;
 249         }
 250
 251         // Get service_name (port)
 252         strncpy(replication_info.service_name,
 253                  parameter_get_char_value( PARAM_COMP_REPLICATION,
 254                  "service_name"), NI_MAXSERV);
 255         // Failed in the acquisition of Port
 256         if ( strcmp(replication_info.service_name,"") == 0)
 257         {
 258                 LOGGER_PUT_LOG_ERROR( LOG_CAT_L7VSD_REPLICATION,7, "Could not get Port." );
 259                 replication_state.service_status = REPLICATION_SINGLE;
 260                 ret = -1;
 261                 goto END;
 262         }
 263
 264         // Get NIC
 265         strncpy(replication_info.nic, parameter_get_char_value( PARAM_COMP_REPLICATION, "nic" ),NIC_LENGTH);
 266         // Failed in the acquisition of NIC
 267         if ( strcmp(replication_info.nic,"") == 0)
 268         {
 269                 LOGGER_PUT_LOG_ERROR( LOG_CAT_L7VSD_REPLICATION,8, "Could not get NIC." );
 270                 replication_state.service_status = REPLICATION_SINGLE;
 271                 ret = -1;
 272                 goto END;
 273         }
 274
 275         // Get interval
 276         replication_info.interval =  parameter_get_int_value( PARAM_COMP_REPLICATION, "interval" );
 277
 278         // Set a starting component block number
 279         replication_info.component_num = 0;
 280         // Variable that sets ID
 281         char key_id[ID_LENGTH];
 282         char key_size[CMP_SIZE_LENGTH];
 283
 284         // Conponent exists
 285         // Get Component infomation
 286         for ( int i=0; i<CMP_MAX; i++)
 287         {
 288                 memset( &key_id, 0, ID_LENGTH );
 289                 memset( &key_size, 0, CMP_SIZE_LENGTH);
 290
 291                 sprintf( key_id, "cmponent_id_%02d",i);
 292                 sprintf( key_size, "cmponent_size_%02d",i);
 293
 294                 // ID and the Size exist
 295                 if ( 0 == parameter_is_char_exist( PARAM_COMP_REPLICATION, key_id ) &&
 296                                         0 == parameter_is_int_exist( PARAM_COMP_REPLICATION, key_size ) )
 297                 {
 298                         break;
 299                 }else{
 300                         // Get Conmponent ID
 301                         strcpy( replication_info.component_info[i].id,
 302                                 parameter_get_char_value(PARAM_COMP_REPLICATION,
 303                                 key_id));
 304                         if ( 0 == strcmp(replication_info.component_info[i].id,""))
 305                         {
 306                                 LOGGER_PUT_LOG_ERROR( LOG_CAT_L7VSD_REPLICATION,9,
 307                                                                         "Could not get  %s.",key_id );
 308                                 replication_state.service_status = REPLICATION_SINGLE;
 309                                 ret = -1;
 310                                 goto END;
 311                         }
 312
 313                         // Get Block size of Component
 314                         replication_info.component_info[i].block_size=parameter_get_int_value(PARAM_COMP_REPLICATION,
 315                                                                                                                 key_size);
 316
 317                         // Count block head number
 318                         if ( 0 == i)
 319                         {
 320                                 replication_info.component_info[i].block_head = 0;
 321                                 replication_state.total_block += replication_info.component_info[i].block_size;
 322                         }else{
 323                                 replication_info.component_info[i].block_head =  replication_info.component_info[i-1].block_head
 324                                                                                  + replication_info.component_info[i-1].block_size;
 325                                 replication_state.total_block += replication_info.component_info[i].block_size;
 326                         }
 327                         // Number of Component
 328                         component_num++;
 329                 }
 330                 replication_info.component_num = component_num;
 331         }
 332
 333
 334         // Check the Parameters value
 335         if ( 0 != l7vs_replication_check_parameter() )
 336         {
 337                 // Status Set
 338                 replication_state.service_status = REPLICATION_SINGLE;
 339                 LOGGER_PUT_LOG_ERROR( LOG_CAT_L7VSD_REPLICATION,10, "Failed in parameter check." );
 340                 ret = -1;
 341                 goto SINGLE_END;
 342         }
 343
 344         // The memory is 0 or less.
 345         if ( 0 >= replication_state.total_block)
 346         {
 347                 // Status Set
 348                 replication_state.service_status = REPLICATION_SINGLE;
 349                 ret = 0;
 350                 goto SINGLE_END;
 351         }
 352
 353         // The memory is larger than int.
 354         if ( 100000 < replication_state.total_block)
 355         {
 356                 // Status Set
 357                 replication_state.service_status = REPLICATION_SINGLE;
 358                 LOGGER_PUT_LOG_ERROR( LOG_CAT_L7VSD_REPLICATION,57, "Set number of blocks exceeds %d.",CMP_BLOCK_MAX );
 359                 ret = -1;
 360                 goto SINGLE_END;
 361         }
 362
 363         // Get the Replication memory
 364         replication_state.replication_memory = l7vs_replication_get_replication_address();
 365         // Confirmation of Replication memory
 366         if ( NULL == replication_state.replication_memory )
 367         {
 368                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_MEMORY,30, "Replication memory is NULL.");
 369                 // Status Set
 370                 replication_state.service_status = REPLICATION_SINGLE;
 371                 ret = -1;
 372                 goto SINGLE_END;
 373
 374         }
 375         // Get the Components memory
 376         replication_state.component_memory = l7vs_replication_get_component_address();
 377         // Confirmation of Components memory
 378         if ( NULL == replication_state.component_memory )
 379         {
 380                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_MEMORY,31, "Components memory is NULL.");
 381                 // free memory
 382                 l7vs_replication_release_replication_address();
 383                 // Status Set
 384                 replication_state.service_status = REPLICATION_SINGLE;
 385                 ret = -1;
 386                 goto SINGLE_END;
 387         }
 388
 389         // Memory for Switch Sarface Number
 390         replication_state.sarface_block_array_ptr = l7vs_replication_get_surface_info_address();
 391         if ( NULL == replication_state.sarface_block_array_ptr )
 392         {
 393                 // free memory
 394                 l7vs_replication_release_replication_address();
 395                 l7vs_replication_release_components_address();
 396                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_MEMORY,32, "Surface infomation memory is NULL.");
 397                 // Status Set
 398                 replication_state.service_status = REPLICATION_SINGLE;
 399                 ret = -1;
 400                 goto SINGLE_END;
 401         }
 402
 403         // Get iomux
 404         l7vs_replication_iomux = l7vs_iomux_get_from_avail_list();
 405         if ( NULL == l7vs_replication_iomux )
 406         {
 407                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM,2, "Can not get replication_iomux.");
 408                 ret = -1;
 409                 goto SINGLE_END;
 410         }
 411
 412         // Status Set to Slave
 413         ret = l7vs_replication_set_slave();
 414
 415         if (0 == ret)
 416         {
 417                 replication_state.service_status = REPLICATION_SLAVE;
 418                 goto END;
 419         }else{
 420                 goto SINGLE_END;
 421         }
 422
 423 END:
 424                 LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,2, "Initialized in %s mode.",
 425                                                 replication_mode[(int)replication_state.service_status]);
 426                 // Debug log
 427                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG)
 428                 {
 429                         char replication_state_str[DEBUG_STR_LEN] = {0};
 430                         l7vs_replication_state_c_str(replication_state_str,&replication_state);
 431                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,5,
 432                                                 "set_l7vs_replication_state_struct : %s",
 433                                                 replication_state_str);
 434
 435                         char replication_info_str[DEBUG_STR_LEN] = {0};
 436                         l7vs_replication_info_c_str(replication_info_str,&replication_info);
 437                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,6,
 438                                                 "set_l7vs_replication_info_struct : %s",
 439                                                 replication_info_str);
 440
 441                         for ( int i=0; i<replication_info.component_num; i++)
 442                         {
 443                                 char replication_component_str[DEBUG_STR_LEN] = {0};
 444                                 l7vs_replication_component_c_str(replication_component_str,replication_info.component_info,i);
 445                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,7,
 446                                                         "set_l7vs_replication_component_struct : %s",
 447                                                         replication_component_str);
 448                         }
 449                 }
 450                 // Debug log END
 451                 // Debug log
 452                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
 453                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,8,
 454                                                         "out_function : int l7vs_replication_initialize(void)"
 455                                                         "return = %d",ret);
 456                 }
 457                 // Debug log END
 458                 return ret;
 459
 460 SINGLE_END:
 461                 if ( -1 != internal_val.socket)
 462                 {
 463                         close(internal_val.socket);
 464                         internal_val.socket = -1;
 465                 }
 466
 467                 if ( NULL != internal_val.address_info)
 468                 {
 469                         freeaddrinfo(internal_val.address_info);
 470                         internal_val.address_info = NULL;
 471                 }
 472
 473                 LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,3, "Initialized in %s mode.",
 474                                         replication_mode[(int)replication_state.service_status]);
 475
 476                 // Debug log
 477                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG)
 478                 {
 479                         char replication_state_str[DEBUG_STR_LEN] = {0};
 480                         l7vs_replication_state_c_str(replication_state_str,&replication_state);
 481                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,9,
 482                                                 "set_l7vs_replication_state_struct : %s",
 483                                                 replication_state_str);
 484
 485                         char replication_info_str[DEBUG_STR_LEN] = {0};
 486                         l7vs_replication_info_c_str(replication_info_str,&replication_info);
 487                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,10,
 488                                                 "set_l7vs_replication_info_struct : %s",
 489                                                 replication_info_str);
 490
 491                         for ( int i=0; i<replication_info.component_num; i++)
 492                         {
 493                                 char replication_component_str[DEBUG_STR_LEN] = {0};
 494                                 l7vs_replication_component_c_str(replication_component_str,replication_info.component_info,i);
 495                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,11,
 496                                                         "set_l7vs_replication_component_struct : %s",
 497                                                         replication_component_str);
 498                         }
 499                 }
 500
 501                 // Debug log END
 502                 // Debug log
 503                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
 504                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,12,
 505                                                         "out_function : int l7vs_replication_initialize(void)"
 506                                                         "return = %d",ret);
 507                 }
 508                 // Debug log END
 509
 510                 return ret;
 511
 512 }
 513
 514 /*! Finalize Replication
 515  */
 516 void l7vs_replication_fini()
 517 {
 518
 519         // Debug log
 520         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
 521                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,13,
 522                                         "in_function : void l7vs_replication_fini(void)");
 523         }
 524         // Debug log END
 525
 526         // Debug log
 527         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG)
 528         {
 529                 char replication_state_str[DEBUG_STR_LEN] = {0};
 530                 l7vs_replication_state_c_str(replication_state_str,&replication_state);
 531                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,14,
 532                                         "set_l7vs_replication_state_struct : %s",
 533                                         replication_state_str);
 534
 535                 char replication_info_str[DEBUG_STR_LEN] = {0};
 536                 l7vs_replication_info_c_str(replication_info_str,&replication_info);
 537                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,15,
 538                                         "set_l7vs_replication_info_struct : %s",
 539                                         replication_info_str);
 540
 541                 for ( int i=0; i<replication_info.component_num; i++)
 542                 {
 543                         char replication_component_str[DEBUG_STR_LEN] = {0};
 544                         l7vs_replication_component_c_str(replication_component_str,replication_info.component_info,i);
 545                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,16,
 546                                                 "set_l7vs_replication_component_struct : %s",
 547                                                 replication_component_str);
 548                 }
 549         }
 550         // Debug log END
 551         // Socket finalaize
 552         l7vs_replication_sock_fini();
 553         // Release replication memory
 554         l7vs_replication_release_replication_address();
 555         // Release component memory
 556         l7vs_replication_release_components_address();
 557         // Release sarface block memory
 558         l7vs_replication_release_surface_info_address();
 559
 560         // reset of replication_state
 561         replication_state.send_time = 0;
 562         replication_state.last_send_block = 0;
 563         replication_state.last_recv_block = 0;
 564         replication_state.total_block = 0;
 565         replication_state.sarface_block_no = 0;
 566
 567         // reset of replication_info
 568         memset(&replication_info, 0, sizeof(struct l7vs_replication_info));
 569
 570         // imoux
 571         if ( NULL != l7vs_replication_iomux )
 572         {
 573                 l7vs_iomux_put_to_avail_list(l7vs_replication_iomux);
 574                 l7vs_replication_iomux = NULL;
 575         }
 576
 577         // status change
 578         replication_state.service_status = REPLICATION_OUT;
 579
 580         // Debug log
 581         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG)
 582         {
 583                 char replication_state_str[DEBUG_STR_LEN] = {0};
 584                 l7vs_replication_state_c_str(replication_state_str,&replication_state);
 585                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,17,
 586                                         "set_l7vs_replication_state_struct : %s",
 587                                         replication_state_str);
 588
 589                 char replication_info_str[DEBUG_STR_LEN] = {0};
 590                 l7vs_replication_info_c_str(replication_info_str,&replication_info);
 591                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,18,
 592                                         "set_l7vs_replication_info_struct : %s",
 593                                         replication_info_str);
 594
 595                 for ( int i=0; i<replication_info.component_num; i++)
 596                 {
 597                         char replication_component_str[DEBUG_STR_LEN] = {0};
 598                         l7vs_replication_component_c_str(replication_component_str,replication_info.component_info,i);
 599                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,19,
 600                                                 "set_l7vs_replication_component_struct : %s",
 601                                                 replication_component_str);
 602                 }
 603         }
 604         // Debug log END
 605
 606         // Debug log
 607         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
 608                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,20, "out_function : l7vs_replication_fini(void)");
 609         }
 610         // Debug log END
 611
 612 }
 613
 614 /*! Switch Slave to Master
 615  */
 616 extern void l7vs_replication_switch_to_master()
 617 {
 618         int ret = -1;
 619
 620         // Debug log
 621         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
 622                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,21,
 623                                                 "extern void l7vs_replication_switch_to_master(void)");
 624         }
 625         // Debug log END
 626
 627         switch (replication_state.service_status){
 628                 case REPLICATION_SLAVE:
 629                         // Set Mastre Mode
 630                         ret = l7vs_replication_set_master();
 631                         if ( 0 != ret )
 632                         {
 633                                 replication_state.service_status = REPLICATION_SINGLE;
 634
 635                                 if ( -1 != internal_val.socket)
 636                                 {
 637                                         close(internal_val.socket);
 638                                         internal_val.socket = -1;
 639                                 }
 640                                 if ( NULL != internal_val.address_info)
 641                                 {
 642                                         freeaddrinfo(internal_val.address_info);
 643                                         internal_val.address_info = NULL;
 644                                 }
 645                                 l7vs_replication_release_replication_address();
 646                                 l7vs_replication_release_components_address();
 647                                 l7vs_replication_release_surface_info_address();
 648
 649                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,54, "Switch to master NG. mode : %s",
 650                                                                 replication_mode[(int)replication_state.service_status]);
 651                                 // change iomux status
 652                                 l7vs_replication_iomux->status = iomux_replication_error;
 653
 654                                 break;
 655
 656                         }else{
 657
 658                                 // Copy from component area to replication area.
 659                                 memcpy(replication_state.replication_memory, replication_state.component_memory, replication_state.total_block*DATA_SIZE);
 660
 661                                 // Set mode.
 662                                 replication_state.service_status = REPLICATION_MASTER;
 663
 664                                 // change iomux status
 665                                 l7vs_replication_iomux->status = iomux_replication_send_wait;
 666                                 // Debug log
 667                                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
 668                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,22,
 669                                                                         "l7vs_replication_iomux->status :"
 670                                                                         "befor : iomux_replication_recv_wait"
 671                                                                         "after : iomux_replication_send_wait");
 672                                 }
 673                                 // Debug log END
 674
 675                                 // Debug log
 676                                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG)
 677                                 {
 678                                         char replication_state_str[DEBUG_STR_LEN] = {0};
 679                                         l7vs_replication_state_c_str(replication_state_str,&replication_state);
 680                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,23,
 681                                                                 "set_l7vs_replication_state_struct : %s",
 682                                                                 replication_state_str);
 683
 684                                         char replication_info_str[DEBUG_STR_LEN] = {0};
 685                                         l7vs_replication_info_c_str(replication_info_str,&replication_info);
 686                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,24,
 687                                                                 "set_l7vs_replication_info_struct : %s",
 688                                                                 replication_info_str);
 689
 690                                         for ( int i=0; i<replication_info.component_num; i++)
 691                                         {
 692                                                 char replication_component_str[DEBUG_STR_LEN] = {0};
 693                                                 l7vs_replication_component_c_str(replication_component_str,replication_info.component_info,i);
 694                                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,25,
 695                                                                         "set_l7vs_replication_component_struct : %s",
 696                                                                         replication_component_str);
 697                                         }
 698                                 }
 699                                 // Debug log END
 700
 701                                 LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,5, "Switch to master OK. mode : %s",
 702                                                                 replication_mode[(int)replication_state.service_status]);
 703                                 break;
 704                         }
 705                 case REPLICATION_SLAVE_STOP:
 706                         // Set Mastre Mode
 707                         ret = l7vs_replication_set_master();
 708                         if ( 0 != ret )
 709                         {
 710                                 replication_state.service_status = REPLICATION_SINGLE;
 711
 712                                 if ( -1 != internal_val.socket)
 713                                 {
 714                                         close(internal_val.socket);
 715                                         internal_val.socket = -1;
 716                                 }
 717                                 if ( NULL != internal_val.address_info)
 718                                 {
 719                                         freeaddrinfo(internal_val.address_info);
 720                                         internal_val.address_info = NULL;
 721                                 }
 722                                 l7vs_replication_release_replication_address();
 723                                 l7vs_replication_release_components_address();
 724                                 l7vs_replication_release_surface_info_address();
 725
 726                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,53, "Switch to master NG. mode : %s",
 727                                                                 replication_mode[(int)replication_state.service_status]);
 728                                 // change iomux status
 729                                 l7vs_replication_iomux->status = iomux_replication_error;
 730
 731                                 break;
 732                         }else{
 733
 734                                 // Copy from component area to replication area.
 735                                 memcpy(replication_state.replication_memory, replication_state.component_memory, replication_state.total_block*DATA_SIZE);
 736
 737                                 // Set mode.
 738                                 replication_state.service_status = REPLICATION_MASTER_STOP;
 739
 740                                 // change iomux status
 741                                 l7vs_replication_iomux->status = iomux_replication_send_stop;
 742                                 // Debug log
 743                                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
 744                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,26,
 745                                                                         "l7vs_replication_iomux->status :"
 746                                                                         "befor : iomux_replication_recv_stop)"
 747                                                                         "after : iomux_replication_send_stop");
 748                                 }
 749                                 // Debug log END
 750
 751                                 // Debug log
 752                                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG)
 753                                 {
 754                                         char replication_state_str[DEBUG_STR_LEN] = {0};
 755                                         l7vs_replication_state_c_str(replication_state_str,&replication_state);
 756                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,27,
 757                                                                 "set_l7vs_replication_state_struct : %s",
 758                                                                 replication_state_str);
 759
 760                                         char replication_info_str[DEBUG_STR_LEN] = {0};
 761                                         l7vs_replication_info_c_str(replication_info_str,&replication_info);
 762                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,28,
 763                                                                 "set_l7vs_replication_info_struct : %s",
 764                                                                 replication_info_str);
 765
 766                                         for ( int i=0; i<replication_info.component_num; i++)
 767                                         {
 768                                                 char replication_component_str[DEBUG_STR_LEN] = {0};
 769                                                 l7vs_replication_component_c_str(replication_component_str,replication_info.component_info,i);
 770                                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,29,
 771                                                                         "set_l7vs_replication_component_struct : %s",
 772                                                                         replication_component_str);
 773                                         }
 774                                 }
 775                                 // Debug log END
 776
 777                                 LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,7, "Switch to master OK. mode : %s",
 778                                                                 replication_mode[(int)replication_state.service_status]);
 779                                 break;
 780                         }
 781                 case REPLICATION_SINGLE:
 782                         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,42,"Starting by %s, doesn't shift to MASTER. ",
 783                                                         replication_mode[(int)replication_state.service_status]);
 784                         break;
 785                 default:
 786                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSD_REPLICATION,2, "Can not switch to master. mode : %s",
 787                                                                         replication_mode[(int)replication_state.service_status]);
 788                         break;
 789         }
 790         // Debug log
 791         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
 792                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,30, "extern void l7vs_replication_switch_to_master(void)");
 793         }
 794 }
 795
 796 /*! Set Master mode
 797 */
 798 static int l7vs_replication_set_master()
 799 {
 800         int sock_ret = -1;
 801
 802         // Debug log
 803         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
 804                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,31, "in_function : static int l7vs_replication_set_master(void)");
 805         }
 806         // Debug log END
 807
 808         if ( REPLICATION_SLAVE != replication_state.service_status &&
 809                                                  REPLICATION_SLAVE_STOP != replication_state.service_status )
 810         {
 811                 // Status Set
 812                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSD_REPLICATION,3, "Can not set to master. mode : %s",
 813                                                                 replication_mode[(int)replication_state.service_status]);
 814                 // Debug log
 815                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
 816                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,32,
 817                                                 "out_function : static int l7vs_replication_set_master(void)"
 818                                                 "return = -1");
 819                 }
 820                 // Debug log END
 821                 return -1;
 822         }
 823
 824         // close socket and delete l7vs_iomux
 825         l7vs_replication_sock_fini();
 826
 827         // make send socket
 828         sock_ret = l7vs_replication_send_sock_init();
 829         if ( -1 == sock_ret )
 830         {
 831                 // Status Set
 832                 replication_state.service_status = REPLICATION_SINGLE;
 833                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,11, "Failed in the initialization of the send socket.");
 834                 // Debug log
 835                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
 836                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,33,
 837                                                 "out_function : static int l7vs_replication_set_master(void)"
 838                                                 "return = -1");
 839                 }
 840                 // Debug log END
 841                 return -1;
 842         }
 843
 844         // set of send socket : struct l7vs_iomux l7vs_replication_iomux
 845         // fd
 846         l7vs_replication_iomux->fd = internal_val.socket;
 847         // callback
 848         l7vs_replication_iomux->callback = l7vs_replication_send_callback;
 849         // status
 850         l7vs_replication_iomux->status = iomux_replication_out;
 851
 852         // Debug log
 853         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
 854                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,34,
 855                                                 "l7vs_replication_iomux->status :"
 856                                                 "befor : Any execution mode"
 857                                                 "after : iomux_replication_out");
 858         }
 859         // Debug log END
 860
 861         // add : struct l7vs_iomux l7vs_replication_iomux
 862         l7vs_iomux_add(l7vs_replication_iomux, iom_write);
 863
 864         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,8,"Initialization of send socket is success.");
 865         // Debug log
 866         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
 867                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,35,
 868                                         "out_function : static int l7vs_replication_set_master(void)"
 869                                         "return = 0");
 870         }
 871         // Debug log END
 872
 873         return 0;
 874
 875 }
 876
 877 /*! Switch Master to Slave
 878  */
 879 extern void l7vs_replication_switch_to_slave()
 880 {
 881         int ret = -1;
 882
 883         // Debug log
 884         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
 885                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,36,
 886                                         "in_function : extern void l7vs_replication_switch_to_slave(void)");
 887         }
 888         // Debug log END
 889
 890         switch (replication_state.service_status){
 891                 case REPLICATION_MASTER:
 892                         // Set Mastre Mode
 893                         ret = l7vs_replication_set_slave();
 894                         if ( 0 != ret )
 895                         {
 896                                 replication_state.service_status = REPLICATION_SINGLE;
 897
 898                                 if ( -1 != internal_val.socket)
 899                                 {
 900                                         close(internal_val.socket);
 901                                         internal_val.socket = -1;
 902                                 }
 903                                 if ( NULL != internal_val.address_info)
 904                                 {
 905                                         freeaddrinfo(internal_val.address_info);
 906                                         internal_val.address_info = NULL;
 907                                 }
 908                                 l7vs_replication_release_replication_address();
 909                                 l7vs_replication_release_components_address();
 910                                 l7vs_replication_release_surface_info_address();
 911
 912                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,55, "Switch to slave NG. mode : %s",
 913                                                                 replication_mode[(int)replication_state.service_status]);
 914                                 // change iomux status
 915                                 l7vs_replication_iomux->status = iomux_replication_error;
 916
 917                                 break;
 918                         }else{
 919
 920                                 // initialize to replication area.
 921                                 memset(replication_state.replication_memory, 0, replication_state.total_block*DATA_SIZE);
 922
 923                                 // Set mode.
 924                                 replication_state.service_status = REPLICATION_SLAVE;
 925
 926                                 // change iomux status
 927                                 l7vs_replication_iomux->status = iomux_replication_recv_wait;
 928                                 // Debug log
 929                                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
 930                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,37,
 931                                                                         "l7vs_replication_iomux->status :"
 932                                                                         "befor : iomux_replication_send_wait"
 933                                                                         "after : iomux_replication_recv_wait");
 934                                 }
 935                                 // Debug log END
 936
 937                                 // Debug log
 938                                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG)
 939                                 {
 940                                         char replication_state_str[DEBUG_STR_LEN] = {0};
 941                                         l7vs_replication_state_c_str(replication_state_str,&replication_state);
 942                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,38,
 943                                                                 "set_l7vs_replication_state_struct : %s",
 944                                                                 replication_state_str);
 945
 946                                         char replication_info_str[DEBUG_STR_LEN] = {0};
 947                                         l7vs_replication_info_c_str(replication_info_str,&replication_info);
 948                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,39,
 949                                                                 "set_l7vs_replication_info_struct : %s",
 950                                                                 replication_info_str);
 951
 952                                         for ( int i=0; i<replication_info.component_num; i++)
 953                                         {
 954                                                 char replication_component_str[DEBUG_STR_LEN] = {0};
 955                                                 l7vs_replication_component_c_str(replication_component_str,replication_info.component_info,i);
 956                                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,40,
 957                                                                         "set_l7vs_replication_component_struct : %s",
 958                                                                         replication_component_str);
 959                                         }
 960                                 }
 961                                 // Debug log END
 962
 963                                 LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,10, "Switch to slave OK. mode : %s",
 964                                                                 replication_mode[(int)replication_state.service_status]);
 965                                 break;
 966                         }
 967                 case REPLICATION_MASTER_STOP:
 968                         // Set Mastre Mode
 969                         ret = l7vs_replication_set_slave();
 970                         if ( 0 != ret )
 971                         {
 972                                 replication_state.service_status = REPLICATION_SINGLE;
 973
 974                                 if ( -1 != internal_val.socket)
 975                                 {
 976                                         close(internal_val.socket);
 977                                         internal_val.socket = -1;
 978                                 }
 979                                 if ( NULL != internal_val.address_info)
 980                                 {
 981                                         freeaddrinfo(internal_val.address_info);
 982                                         internal_val.address_info = NULL;
 983                                 }
 984                                 l7vs_replication_release_replication_address();
 985                                 l7vs_replication_release_components_address();
 986                                 l7vs_replication_release_surface_info_address();
 987
 988                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,56, "Switch to slave NG. mode : %s",
 989                                                                 replication_mode[(int)replication_state.service_status]);
 990                                 // change iomux status
 991                                 l7vs_replication_iomux->status = iomux_replication_error;
 992
 993                                 break;
 994                         }else{
 995
 996                                 // initialize to replication area.
 997                                 memset(replication_state.replication_memory, 0, replication_state.total_block*DATA_SIZE);
 998
 999                                 // Set mode.
1000                                 replication_state.service_status = REPLICATION_SLAVE_STOP;
1001
1002                                 // change iomux status
1003                                 l7vs_replication_iomux->status = iomux_replication_recv_stop;
1004                                 // Debug log
1005                                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1006                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,41,
1007                                                                         "l7vs_replication_iomux->status :"
1008                                                                         "befor : iomux_replication_send_stop"
1009                                                                         "after : iomux_replication_recv_stop");
1010                                 }
1011                                 // Debug log END
1012
1013                                 // Debug log
1014                                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG)
1015                                 {
1016                                         char replication_state_str[DEBUG_STR_LEN] = {0};
1017                                         l7vs_replication_state_c_str(replication_state_str,&replication_state);
1018                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,42,
1019                                                                 "set_l7vs_replication_state_struct : %s",
1020                                                                 replication_state_str);
1021
1022                                         char replication_info_str[DEBUG_STR_LEN] = {0};
1023                                         l7vs_replication_info_c_str(replication_info_str,&replication_info);
1024                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,43,
1025                                                                 "set_l7vs_replication_info_struct : %s",
1026                                                                 replication_info_str);
1027
1028                                         for ( int i=0; i<replication_info.component_num; i++)
1029                                         {
1030                                                 char replication_component_str[DEBUG_STR_LEN] = {0};
1031                                                 l7vs_replication_component_c_str(replication_component_str,replication_info.component_info,i);
1032                                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,44,
1033                                                                         "set_l7vs_replication_component_struct : %s",
1034                                                                         replication_component_str);
1035                                         }
1036                                 }
1037                                 // Debug log END
1038
1039                                 LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,12, "Switch to slave OK. mode : %s",
1040                                                                 replication_mode[(int)replication_state.service_status]);
1041                                 break;
1042                         }
1043                 case REPLICATION_SINGLE:
1044                         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,13, "Starting by %s , doesn't shift to SLAVE .",
1045                                                         replication_mode[(int)replication_state.service_status]);
1046                         break;
1047                 default:
1048                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSD_REPLICATION,4, "Can not switch to slave. mode : %s",
1049                                                         replication_mode[(int)replication_state.service_status]);
1050                         break;
1051         }
1052         // Debug log
1053         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1054                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,45, "out_function : extern void l7vs_replication_switch_to_slave(void)");
1055         }
1056         // Debug log END
1057 }
1058
1059 /*! Set Slave mode
1060 */
1061 static int l7vs_replication_set_slave()
1062 {
1063         int sock_ret = -1;
1064
1065         // Debug log
1066         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1067                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,46, "int_function : static int l7vs_replication_set_slave(void)");
1068         }
1069         // Debug log END
1070
1071
1072         if ( REPLICATION_MASTER != replication_state.service_status &&
1073                                 REPLICATION_MASTER_STOP != replication_state.service_status &&
1074                                                 REPLICATION_OUT != replication_state.service_status )
1075         {
1076                 // Status Set
1077                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSD_REPLICATION,5, "Can not set to slave. mode : %s",
1078                                                                 replication_mode[(int)replication_state.service_status]);
1079                 // Debug log
1080                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1081                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,47,
1082                                                 "out_function : static int l7vs_replication_set_slave(void)"
1083                                                 "return = -1");
1084                 }
1085                 // Debug log END
1086
1087                 return -1;
1088         }
1089
1090         // close socket and delete l7vs_iomux
1091         l7vs_replication_sock_fini();
1092         // make send socket
1093         sock_ret = l7vs_replication_recv_sock_init();
1094         if ( -1 == sock_ret )
1095         {
1096                 // Status Set
1097                 replication_state.service_status = REPLICATION_SINGLE;
1098                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,12, "Failed in the initialization of the recv socket.");
1099                 // Debug log
1100                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1101                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,48,
1102                                                 "out_function : static int l7vs_replication_set_slave(void)"
1103                                                 "return = -1");
1104                 }
1105                 // Debug log END
1106                 return -1;
1107         }
1108
1109         // set of send socket : struct l7vs_iomux l7vs_replication_iomux
1110         // fd
1111         l7vs_replication_iomux->fd = internal_val.socket;
1112         // callback
1113         l7vs_replication_iomux->callback = l7vs_replication_recv_callback;
1114         // status
1115         l7vs_replication_iomux->status = iomux_replication_out;
1116                         // Debug log
1117                         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1118                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,49,
1119                                                                 "l7vs_replication_iomux->status : iomux_replication_out");
1120                         }
1121                         // Debug log END
1122         // add : struct l7vs_iomux l7vs_replication_iomux
1123         l7vs_iomux_add(l7vs_replication_iomux, iom_read);
1124
1125         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,14,"Initialization of receive socket is success.");
1126         // Debug log
1127         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1128                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,50,
1129                                 "out_function : static int l7vs_replication_set_slave(void)"
1130                                 "return = 0");
1131         }
1132         // Debug log END
1133         return 0;
1134
1135 }
1136
1137 /*! Pay replication memory
1138  *
1139  * @param component_id is the one to identify the component.
1140  * @param size of component use blocks
1141  *
1142  * @return Replication memory address
1143  * @retval nonnull Replication memory address
1144  * @retval NULL Error
1145  */
1146 extern void *l7vs_replication_pay_memory( char* component_id, unsigned int* size )
1147 {
1148         char demand_id[ID_LENGTH];
1149         void *ret = NULL;
1150         int cmp_ret = -1;
1151
1152         // Debug log
1153         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1154                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,51,
1155                                         "extern void *l7vs_replication_pay_memory( char* component_id, unsigned int* size)"
1156                                         "component_id = %p"
1157                                         "size = %p",
1158                                         component_id,
1159                                         size);
1160         }
1161         // Debug log END
1162
1163
1164         // argument is illegal
1165         if ( NULL == component_id || NULL == size)
1166         {
1167                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,13, "Argument illegal. Component id or component size is NULL. ");
1168                 // Debug log
1169                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1170                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,52,
1171                         "out_function : extern void *l7vs_replication_pay_memory( char* component_id, unsigned int* size)"
1172                         "return = NULL");
1173                 }
1174                 // Debug log END
1175                 return NULL;
1176         }
1177         *size = 0;
1178         // Check replication mode.
1179         if ( REPLICATION_OUT == replication_state.service_status ||
1180                                                 REPLICATION_SINGLE == replication_state.service_status)
1181         {
1182                 // Check mode that can use the replication.
1183                 LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,15,
1184                                         "Improper mode for Replication. mode : %s",
1185                                         replication_mode[(int)replication_state.service_status]);
1186                 // Debug log
1187                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1188                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,53,
1189                         "out_function : extern void *l7vs_replication_pay_memory( char* component_id, unsigned int* size)"
1190                         "return = NULL");
1191                 }
1192                 // Debug log END
1193                 return NULL;
1194         }
1195
1196         if ( NULL == replication_state.component_memory )
1197         {
1198                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_MEMORY,33,
1199                                                 "You can't get memory. Component memory is NULL. ");
1200                 // Debug log
1201                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1202                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,54,
1203                         "out_function : extern void *l7vs_replication_pay_memory( char* component_id, unsigned int* size)"
1204                         "return = NULL");
1205                 }
1206                 // Debug log END
1207                 return NULL;
1208         }
1209
1210         // memory initialize
1211         memset( demand_id, 0, ID_LENGTH );
1212
1213         // get Demand ID
1214         strncpy( demand_id, component_id, ID_LENGTH );
1215
1216         // search Component ID
1217         for ( int i = 0; i < replication_info.component_num; i++ )
1218         {
1219                 // Demand ID is compared with Component ID
1220                 cmp_ret = strncmp(demand_id, replication_info.component_info[i].id, ID_LENGTH);
1221                 if ( 0 == cmp_ret )
1222                 {
1223
1224                         // size check
1225                         if ( 0 == replication_info.component_info[i].block_size )
1226                         {
1227                                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSD_REPLICATION,16, "Component block size is 0.");
1228                                 // Debug log
1229                                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1230                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,191,
1231                                         "out_function : extern void *l7vs_replication_pay_memory( char* component_id, unsigned int* size)"
1232                                         "return = NULL");
1233                                 }
1234                                 // Debug log END
1235                                 return NULL;
1236                         }
1237
1238                         // block_head check
1239                         if ( replication_info.component_info[i].block_head < 0 ||
1240                                 replication_info.component_info[i].block_head > replication_state.total_block)
1241                         {
1242                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,14,
1243                                         "Too many component block. Max is %d . ",replication_state.total_block);
1244                                 // Debug log
1245                                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1246                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,55,
1247                                         "out_function : extern void *l7vs_replication_pay_memory( char* component_id, unsigned int* size)"
1248                                         "return = NULL");
1249                                 }
1250                                 // Debug log END
1251                                 return NULL;
1252                         }
1253                         // Pay memory address
1254                         ret = (char *)replication_state.component_memory
1255                                         + replication_info.component_info[i].block_head * DATA_SIZE;
1256                         // Nnumber of blocks of ID was returned.
1257                         *size = replication_info.component_info[i].block_size;
1258
1259                         // Debug log
1260                         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1261                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,56,
1262                                         "size data : %u",replication_info.component_info[i].block_size);
1263                         }
1264                         // Debug log END
1265
1266                         // LOG INFO
1267                         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,16,
1268                                         "Component Info ID : \"%s\". Block size : %d . Head Block No : %d/  Pay memory : %p ",
1269                                         replication_info.component_info[i].id,
1270                                         replication_info.component_info[i].block_size,
1271                                         replication_info.component_info[i].block_head,
1272                                         (char *)ret);
1273                         // Debug log
1274                         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1275                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,57,
1276                                         "out_function : extern void *l7vs_replication_pay_memory( char* component_id, unsigned int* size)"
1277                                         "return = %p",
1278                                         ret);
1279                         }
1280                         // Debug log END
1281                         return ret;
1282                 }
1283         }
1284         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,15,
1285                                         "Unknown component ID. Component ID : %s",demand_id);
1286         // Debug log
1287         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1288                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,58,
1289                 "out_function : extern void *l7vs_replication_pay_memory( char* component_id, unsigned int* size)"
1290                 "return = NULL");
1291         }
1292                 // Debug log END
1293         return NULL;
1294 }
1295
1296
1297
1298 /*! Replication Callback
1299  *
1300  * @param sturuct l7vs_iomux *iom
1301  *
1302  * @return 0/1
1303  *
1304  */
1305 extern int l7vs_replication_send_callback( struct l7vs_iomux *iom )
1306 {
1307         struct l7vs_replication_data replication_data;
1308         int send_ret = -1;
1309
1310         // Debug log
1311 //      if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1312 //              LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,59,
1313 //                                      "in_function : extern int l7vs_replication_send_callback( struct l7vs_iomux *iom )"
1314 //                                      "iomux = %p",iom);
1315 //      }
1316         // Debug log END
1317
1318         // change to iom_write
1319         l7vs_iomux_mod(iom, iom_write);
1320
1321         // Check by continuous initialize.
1322         if ( REPLICATION_MASTER != replication_state.service_status &&
1323                 REPLICATION_MASTER_STOP != replication_state.service_status )
1324         {
1325                 // Initialization has already been done.
1326                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,16,
1327                                         "Can not send_callback. Mode is difficult.  mode : %s",
1328                                         replication_mode[(int)replication_state.service_status]);
1329                 // Debug log
1330                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1331                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,60,
1332                                                 "out_function : extern int l7vs_replication_send_callback( struct l7vs_iomux *iom )"
1333                                                 "return = -1" );
1334                 }
1335                 // Debug log END
1336                 return -1;
1337         }else if ( REPLICATION_MASTER_STOP == replication_state.service_status ) {
1338                 // Debug log
1339 //              if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1340 //                      LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,61,
1341 //                                              "Can not send Replication data, because mode is MASTER_STOP..");
1342 //                      LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,62,
1343 //                                              "out_function : extern int l7vs_replication_send_callback( struct l7vs_iomux *iom )"
1344 //                                              "return = 0" );
1345 //              }
1346                 // Debug log END
1347
1348                 return 0;
1349         }
1350
1351         // iomux is NULL
1352         if ( (void *)NULL ==iom )
1353         {
1354                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_MEMORY,34, "Send Argument(struct iomux) is NULL." );
1355                 // Debug log
1356                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1357                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,63,
1358                                                 "out_function : extern int l7vs_replication_send_callback( struct l7vs_iomux *iom )"
1359                                                 "return = -1" );
1360                 }
1361                 // Debug log END
1362                 return -1;
1363         }
1364
1365         // Replication memory is NULL
1366         if ( NULL == replication_state.replication_memory )
1367         {
1368                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_MEMORY,35, "Replication memory is NULL." );
1369                 // Debug log
1370                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1371                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,64,
1372                                                 "out_function : extern int l7vs_replication_send_callback( struct l7vs_iomux *iom )"
1373                                                 "return = -1" );
1374                 }
1375                 // Debug log END
1376                 return -1;
1377         }
1378
1379         // Component memory is NULL
1380         if ( NULL == replication_state.component_memory )
1381         {
1382                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_MEMORY,36, "Component memory is NULL." );
1383                 // Debug log
1384                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1385                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,65,
1386                                                 "out_function : extern int l7vs_replication_send_callback( struct l7vs_iomux *iom )"
1387                                                 "return = -1" );
1388                 }
1389                 // Debug log END
1390                 return -1;
1391         }
1392
1393         //
1394         if ( 0 != l7vs_replication_checkinterval() )
1395         {
1396                 // Debug log
1397                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1398                         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_SYSTEM_MEMORY,1, "Send data wait ...." );
1399                 }
1400                 // Debug log END
1401
1402                 return 0;
1403         }
1404
1405         // Temporary preservation sturuct initialize
1406         memset( &replication_data, 0, sizeof(struct l7vs_replication_data) );
1407         send_ret = l7vs_replication_send_data(&replication_data);
1408
1409         // change iomux status
1410         l7vs_replication_iomux->status = iomux_replication_send_wait;
1411         // Debug log
1412         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1413                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,66,
1414                                         "l7vs_replication_iomux->status :"
1415                                         "befor : iomux_replication_sending"
1416                                         "after : iomux_replication_send_wait");
1417         }
1418
1419         // Debug log
1420         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1421                 char replication_data_str[DEBUG_STR_LEN] = {0};
1422                 l7vs_replication_data_c_str(replication_data_str,&replication_data);
1423                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,67,
1424                                                 "replication_data_struct : %s",
1425                                                 replication_data_str);
1426         }
1427         // Debug log END
1428
1429         if ( 0 != send_ret )
1430         {
1431                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM,3,
1432                                         "Send data is Failed." );
1433                 // Debug log
1434                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1435                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,68,
1436                                                 "out_function : extern int l7vs_replication_send_callback( struct l7vs_iomux *iom )"
1437                                                 "return = -1" );
1438                 }
1439                 // Debug log END
1440                 return -1;
1441         }
1442
1443         // set last send block number
1444         if ( replication_state.last_send_block < replication_state.total_block-1 )
1445         {
1446                 replication_state.last_send_block += 1;
1447         }else if(replication_state.last_send_block == replication_state.total_block-1){
1448                 replication_state.last_send_block = 0;
1449         }else{
1450                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,17,
1451                                         "Last send block number is illegal.");
1452                 // Debug log
1453                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1454                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,69,
1455                                                 "out_function : extern int l7vs_replication_send_callback( struct l7vs_iomux *iom )"
1456                                                 "return = -1" );
1457                 }
1458                 // Debug log END
1459                 return -1;
1460         }
1461
1462         // sarface block number is change
1463         if(replication_state.total_block == replication_state.last_send_block + 1 )
1464         {
1465                 // Synchronization is executed.
1466                 memcpy(replication_state.replication_memory,
1467                         replication_state.component_memory,
1468                         replication_state.total_block*DATA_SIZE );
1469
1470                 // serial initialize
1471                 replication_state.sarface_block_no = 0;
1472
1473                 // make new serial
1474                 replication_state.sarface_block_no = (uint64_t)l7vs_replication_make_serial();
1475                 if ( 0 == replication_state.sarface_block_no )
1476                 {
1477                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,18,
1478                                                 "Could not get serial number .");
1479                         // Debug log
1480                         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1481                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,70,
1482                                                         "out_function : extern int l7vs_replication_send_callback( struct l7vs_iomux *iom )"
1483                                                         "return = -1" );
1484                         }
1485                         // Debug log END
1486                         return -1;
1487                 }
1488 //              if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1489 //                      LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION, 0,
1490 //                                              "Copy Success from component memory to replication memory." );
1491 //              }
1492         }
1493         // Debug log
1494         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1495                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,71,
1496                                         "out_function : extern int l7vs_replication_send_callback( struct l7vs_iomux *iom )"
1497                                         "return = 0" );
1498         }
1499         // Debug log END
1500
1501         return 0;
1502 }
1503
1504 /*! Replication Callback
1505  *
1506  * @param sturuct l7vs_iomux *iom
1507  *
1508  * @return 0/1
1509  *
1510  */
1511 extern int l7vs_replication_recv_callback( struct l7vs_iomux *iom )
1512 {
1513         struct l7vs_replication_data replication_data;
1514         int recv_ret = -1;
1515         // Debug log
1516         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1517                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,72,
1518                                         "in_function : extern int l7vs_replication_recv_callback( struct l7vs_iomux *iom )"
1519                                         "iom = %p",iom);
1520         }
1521         // Debug log END
1522
1523         // change to iom_read
1524         l7vs_iomux_mod(iom, iom_read);
1525
1526         // Check by continuous initialize.
1527         if ( REPLICATION_SLAVE != replication_state.service_status &&
1528                 REPLICATION_SLAVE_STOP != replication_state.service_status )
1529         {
1530                 // Initialization has already been done.
1531                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,19,
1532                                         "Can not recv_callback. Mode is difficult.  mode : %s",
1533                                         replication_mode[(int)replication_state.service_status]);
1534                 // Debug log
1535                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1536                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,73,
1537                                                 "out_function : extern int l7vs_replication_recv_callback( struct l7vs_iomux *iom )"
1538                                                 "return = -1");
1539                 }
1540                 // Debug log END
1541                 return -1;
1542         }else if ( REPLICATION_SLAVE_STOP == replication_state.service_status ) {
1543                 LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,17,
1544                                         "Can not receive Replication data, because mode is SLAVE_STOP.");
1545                 // Debug log
1546                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1547                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,74,
1548                                                 "out_function : extern int l7vs_replication_recv_callback( struct l7vs_iomux *iom )"
1549                                                 "return = 0");
1550                 }
1551                 // Debug log END
1552                 return 0;
1553         }
1554
1555         // iomux is NULL
1556         if ( (void *)NULL ==iom )
1557         {
1558                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_MEMORY,37, "Recv Argument(struct iomux) is NULL." );
1559                 // Debug log
1560                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1561                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,75,
1562                                                 "out_function : extern int l7vs_replication_recv_callback( struct l7vs_iomux *iom )"
1563                                                 "return = -1");
1564                 }
1565                 // Debug log END
1566                 return -1;
1567         }
1568
1569         // Replication memory is NULL
1570         if ( NULL == replication_state.replication_memory )
1571         {
1572                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_MEMORY,38, "Replication memory is NULL." );
1573                 // Debug log
1574                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1575                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,76,
1576                                                 "out_function : extern int l7vs_replication_recv_callback( struct l7vs_iomux *iom )"
1577                                                 "return = -1");
1578                 }
1579                 // Debug log END
1580                 return -1;
1581         }
1582
1583         // Component memory is NULL
1584         if ( NULL == replication_state.component_memory )
1585         {
1586                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_MEMORY,39, "Component memory is NULL." );
1587                 // Debug log
1588                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1589                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,77,
1590                                                 "out_function : extern int l7vs_replication_recv_callback( struct l7vs_iomux *iom )"
1591                                                 "return = -1");
1592                 }
1593                 // Debug log END
1594                 return -1;
1595         }
1596
1597         // Sarface block array memory is NULL
1598         if ( NULL == replication_state.sarface_block_array_ptr)
1599         {
1600                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,20, "sarface block array pointer is NULL.");
1601                 // Debug log
1602                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1603                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,78,
1604                                                 "out_function : extern int l7vs_replication_recv_callback( struct l7vs_iomux *iom )"
1605                                                 "return = -1");
1606                 }
1607                 // Debug log END
1608                 return -1;
1609         }
1610
1611         // Temporary preservation sturuct initialize
1612         memset( &replication_data, 0, sizeof(struct l7vs_replication_data) );
1613         recv_ret = l7vs_replication_recv_data(&replication_data);
1614
1615         // change iomux status
1616         l7vs_replication_iomux->status = iomux_replication_recv_wait;
1617         // Debug log
1618         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1619                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,79,
1620                                         "l7vs_replication_iomux->status :"
1621                                         "befor : iomux_replication_receving"
1622                                         "after : iomux_replication_recv_wait");
1623         }
1624         // Debug log END
1625
1626         // Debug log
1627         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1628                 char replication_data_str[DEBUG_STR_LEN] = {0};
1629                 l7vs_replication_data_c_str(replication_data_str,&replication_data);
1630                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,80,
1631                                                 "replication_data_struct : %s",
1632                                                 replication_data_str);
1633         }
1634         // Debug log END
1635
1636         if ( 0 != recv_ret )
1637         {
1638                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSD_SYSTEM,3,
1639                                         "Failed in the reception processing of data because of illegal receive data." );
1640                 // Debug log
1641                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1642                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,81,
1643                                                 "out_function : extern int l7vs_replication_recv_callback( struct l7vs_iomux *iom )"
1644                                                 "return = -1");
1645                 }
1646                 // Debug log END
1647                 return -1;
1648         }
1649
1650         // set sarface block
1651         replication_state.sarface_block_array_ptr[replication_data.block_num] = replication_data.serial;
1652
1653         // set last send block number
1654         if ( replication_state.last_recv_block < replication_state.total_block-1 )
1655         {
1656                 replication_state.last_recv_block += 1;
1657         }else if(replication_state.last_recv_block == replication_state.total_block-1){
1658                 replication_state.last_recv_block = 0;
1659         }else{
1660                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,21,
1661                                         "Last send block number is illegal.");
1662                 // Debug log
1663                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1664                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,83,
1665                                                 "out_function : extern int l7vs_replication_recv_callback( struct l7vs_iomux *iom )"
1666                                                 "return = -1");
1667                 }
1668                 // Debug log END
1669                 return -1;
1670         }
1671
1672         // Debug log
1673         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1674                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,84,
1675                                         "out_function : extern int l7vs_replication_recv_callback( struct l7vs_iomux *iom )"
1676                                         "return = 0");
1677         }
1678         // Debug log END
1679         return 0;
1680
1681
1682 }
1683
1684 /*! Replication Dump
1685  *
1686  */
1687 extern void l7vs_replication_dump_memory()
1688 {
1689         int size;
1690         char *p;
1691         char *head;
1692         int h = 0;
1693         int i = 0;
1694
1695         // Debug log
1696         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1697                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,85, "in_function : extern void l7vs_replication_dump_memory(void)");
1698         }
1699         // Debug log END
1700
1701         if ( ( REPLICATION_SINGLE == replication_state.service_status ) ||
1702                                 ( REPLICATION_OUT == replication_state.service_status ) )
1703         {
1704                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSD_REPLICATION,6,
1705                                 "Replication memory dump failure. mode : %s",
1706                                 replication_mode[(int)replication_state.service_status]);
1707                 // Debug log
1708                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1709                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,86, "out_function : extern void l7vs_replication_dump_memory(void)");
1710                 }
1711                 // Debug log END
1712                 return;
1713         }
1714
1715         // Replication memory is NULL.
1716         if ( NULL == replication_state.replication_memory)
1717         {
1718                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSD_SYSTEM,1,
1719                                 "Replication memory is NULL.");
1720                 // Debug log
1721                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1722                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,87, "out_function : extern void l7vs_replication_dump_memory(void)");
1723                 }
1724                 // Debug log END
1725                 return;
1726         }
1727
1728         // Dump size
1729         size = 480 * replication_state.total_block;
1730
1731         if ( 0 == size )
1732         {
1733                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSD_REPLICATION,7,
1734                                 "Can not get Replication memory");
1735                 // Debug log
1736                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1737                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,88, "out_function : extern void l7vs_replication_dump_memory(void)");
1738                 }
1739                 // Debug log END
1740                 return;
1741
1742         }
1743
1744         // Memory Dump
1745         p = (char *)replication_state.replication_memory;
1746
1747         // Output mode
1748         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,18,"Replication Dump Start ----------------------------");
1749         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,19,"Mode is [ %s ].",
1750                                         replication_mode[(int)replication_state.service_status]);
1751         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,20,"Total Block is [ %u ]",
1752                                         replication_state.total_block);
1753
1754         // Converts into the binary, and writes it to the file.
1755         for ( h = 0; h < size / DATA_SIZE ; h++ )
1756         {
1757         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,21,"Block Number [ %d ]",h);
1758
1759                 for ( i = 0; i < DATA_SIZE / LOG_DATA_WIDTH ; i++ )
1760                 {
1761                         head = p + h*DATA_SIZE + i*LOG_DATA_WIDTH;
1762                         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,22,
1763                                                 "%02hhX %02hhX %02hhX %02hhX  %02hhX %02hhX %02hhX %02hhX  "
1764                                                 "%02hhX %02hhX %02hhX %02hhX  %02hhX %02hhX %02hhX %02hhX"
1765                                                 , *head, *(head+1), *(head+2), *(head+3)
1766                                                 , *(head+4), *(head+5), *(head+6), *(head+7)
1767                                                 , *(head+8), *(head+9), *(head+10), *(head+11)
1768                                                 , *(head+12), *(head+13), *(head+14), *(head+15));
1769
1770                 }
1771         }
1772         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,23,"Replication Dump End ------------------------------");
1773
1774
1775         // Debug log
1776         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1777
1778                 char    *q;
1779                 char    *head_debug;
1780                 int     j=0;
1781                 int     k=0;
1782
1783                 // Component Memory Dump
1784                 q = (char *)replication_state.component_memory;
1785
1786                 // Output mode
1787                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,89,"Component Dump Satrt ----------------------------");
1788                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,90,"Mode is [ %s ].",
1789                                                 replication_mode[(int)replication_state.service_status]);
1790                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,91,"Total Block is [ %u ]",
1791                                                 replication_state.total_block);
1792
1793                 // Converts into the binary, and writes it to the file.
1794                 for ( j = 0; j < size / DATA_SIZE ; j++ )
1795                 {
1796                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,92,"Block Number [ %d ]",j);
1797
1798                         for ( k = 0; k < DATA_SIZE / LOG_DATA_WIDTH ; k++ )
1799                         {
1800                                 head_debug = q + j*DATA_SIZE + k*LOG_DATA_WIDTH;
1801                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,93,
1802                                                         "%02hhX %02hhX %02hhX %02hhX  %02hhX %02hhX %02hhX %02hhX  "
1803                                                         "%02hhX %02hhX %02hhX %02hhX  %02hhX %02hhX %02hhX %02hhX"
1804                                                         , *head_debug, *(head_debug+1), *(head_debug+2), *(head_debug+3)
1805                                                         , *(head_debug+4), *(head_debug+5), *(head_debug+6), *(head_debug+7)
1806                                                         , *(head_debug+8), *(head_debug+9), *(head_debug+10), *(head_debug+11)
1807                                                         , *(head_debug+12), *(head_debug+13), *(head_debug+14), *(head_debug+15));
1808
1809                         }
1810                 }
1811                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,94,"Component Dump End ------------------------------");
1812                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,95, "out_function : extern void l7vs_replication_dump_memory(void)");
1813         }
1814         // Debug log END
1815         return;
1816 }
1817
1818
1819 /*! Chenge Status isActive
1820  */
1821 extern void l7vs_replication_start()
1822 {
1823
1824         // Debug log
1825         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1826                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,96, "in_function : extern void l7vs_replication_start(void)");
1827         }
1828         // Debug log END
1829
1830         switch (replication_state.service_status){
1831                 case REPLICATION_MASTER_STOP:
1832                         replication_state.service_status = REPLICATION_MASTER;
1833                         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,24, "Replication start. mode : %s",
1834                                         replication_mode[(int)replication_state.service_status]);
1835                         break;
1836                 case REPLICATION_SLAVE_STOP:
1837                         replication_state.service_status = REPLICATION_SLAVE;
1838                         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,25, "Replication start. mode : %s",
1839                                         replication_mode[(int)replication_state.service_status]);
1840                         break;
1841                 case REPLICATION_MASTER:
1842                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSD_REPLICATION,8, "Could not MASTER start, because already start. mode : %s",
1843                                         replication_mode[(int)replication_state.service_status]);
1844                         break;
1845                 case REPLICATION_SLAVE:
1846                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSD_REPLICATION,9, "Could not SALVE start, because already start. mode : %s",
1847                                         replication_mode[(int)replication_state.service_status]);
1848                         break;
1849                 default:
1850                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSD_REPLICATION,10, "Could not start, because  mode is %s.",
1851                                         replication_mode[(int)replication_state.service_status]);
1852                         break;
1853         }
1854         // Debug log
1855         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1856                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,97, "out_function : extern void l7vs_replication_start(void)");
1857         }
1858         // Debug log END
1859
1860 }
1861
1862 /*! Chenge Status isStop
1863  */
1864 extern void l7vs_replication_stop()
1865 {
1866         // Debug log
1867         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1868                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,98, "in_function : extern void l7vs_replication_start(void)");
1869         }
1870         // Debug log END
1871         switch (replication_state.service_status){
1872                 case REPLICATION_MASTER:
1873                         replication_state.service_status = REPLICATION_MASTER_STOP;
1874                         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,26, "Replication stop. mode : %s",
1875                                                         replication_mode[(int)replication_state.service_status]);
1876                         break;
1877                 case REPLICATION_SLAVE:
1878                         replication_state.service_status = REPLICATION_SLAVE_STOP;
1879                         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,27, "Replication stop. mode : %s",
1880                                                         replication_mode[(int)replication_state.service_status]);
1881                         break;
1882                 case REPLICATION_MASTER_STOP:
1883                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSD_REPLICATION,11, "Could not MASTER stop, because already stop. mode : %s",
1884                                                         replication_mode[(int)replication_state.service_status]);
1885                         break;
1886                 case REPLICATION_SLAVE_STOP:
1887                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSD_REPLICATION,12, "Could not SLAVE stop, because already stop. mode : %s",
1888                                                         replication_mode[(int)replication_state.service_status]);
1889                         break;
1890                 default:
1891                         LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSD_REPLICATION,17, "Could not stop, because  mode is %s",
1892                                                         replication_mode[(int)replication_state.service_status]);
1893                         break;
1894
1895         }
1896         // Debug log
1897         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1898                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,99, "out_function : extern void l7vs_replication_start(void)");
1899         }
1900         // Debug log END
1901 }
1902
1903 /*! Compulsion reproduction execution
1904  */
1905 extern void l7vs_replication_compulsorily()
1906 {
1907         struct  l7vs_replication_data replication_data;
1908         int     send_ret = -1;
1909         int     interval_ret = -1;
1910         int     ms_time = 0;
1911         struct timespec time;
1912
1913         // Debug log
1914         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1915                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,100, "in_function : extern void l7vs_replication_compulsorily(void)");
1916         }
1917         // Debug log END
1918
1919         // Check by continuous initialize.
1920         if ( REPLICATION_MASTER != replication_state.service_status &&
1921                 REPLICATION_MASTER_STOP != replication_state.service_status )
1922         {
1923                 // Initialization has already been done.
1924                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,23,
1925                                         "Could not compulsion replication. Mode is different. mode : %s",
1926                                         replication_mode[(int)replication_state.service_status]);
1927                 // Debug log
1928                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1929                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,101, "out_function : extern void l7vs_replication_compulsorily(void)");
1930                 }
1931                 // Debug log END
1932                 return;
1933         }else if ( REPLICATION_MASTER_STOP == replication_state.service_status ) {
1934                 LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,28,
1935                                         "Can not replication compulsorily, because mode is %s .",
1936                                                 replication_mode[(int)replication_state.service_status]);
1937                 // Debug log
1938                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1939                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,102, "out_function : extern void l7vs_replication_compulsorily(void)");
1940                 }
1941                 // Debug log END
1942                 return;
1943         }
1944
1945         // Replication memory is NULL
1946         if ( NULL == replication_state.replication_memory )
1947         {
1948                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_MEMORY,40, "Replication memory is NULL." );
1949                 // Debug log
1950                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1951                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,103, "out_function : extern void l7vs_replication_compulsorily(void)");
1952                 }
1953                 // Debug log END
1954                 return;
1955         }
1956
1957         // Component memory is NULL
1958         if ( NULL == replication_state.component_memory )
1959         {
1960                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_MEMORY,41, "Component memory is NULL." );
1961                 // Debug log
1962                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
1963                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,104, "out_function : extern void l7vs_replication_compulsorily(void)");
1964                 }
1965                 // Debug log END
1966                 return;
1967         }
1968
1969         // set send interval
1970         time.tv_sec = 0;
1971         time.tv_nsec = 0;
1972         interval_ret = parameter_is_int_exist( PARAM_COMP_REPLICATION, "compulsorily_interval" );
1973
1974         if ( 0 == interval_ret )
1975         {
1976                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION, 51, "Could not get interval value for replication compulsorily.");
1977                 return;
1978         }
1979
1980         ms_time = parameter_get_int_value( PARAM_COMP_REPLICATION, "compulsorily_interval" );
1981
1982         if ( ms_time < MIN_COMPULSORILRY_INTERVAL || MAX_COMPULSORILRY_INTERVAL < ms_time )
1983         {
1984                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION, 52, "Invalid compulsorily interval.");
1985                 return;
1986         }
1987
1988         time.tv_nsec =  (long)( ms_time * 1000000 );
1989
1990         // set last send block is c maximum block
1991         replication_state.last_send_block = replication_state.total_block-1;
1992
1993         for(unsigned int i = 0; i < replication_state.total_block; i++)
1994         {
1995                 // set compulsorily interval.
1996                 nanosleep( &time, NULL);
1997
1998                 // Temporary preservation sturuct initialize
1999                 memset( &replication_data, 0, sizeof(struct l7vs_replication_data) );
2000                 send_ret = l7vs_replication_send_data(&replication_data);
2001
2002                 // change iomux status
2003                 l7vs_replication_iomux->status = iomux_replication_send_wait;
2004                 // Debug log
2005                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2006                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,105,
2007                                                 "l7vs_replication_iomux->status :"
2008                                                 "befor : iomux_replication_sending"
2009                                                 "after : iomux_replication_send_wait");
2010                 }
2011                 // Debug log END
2012
2013                 if ( 0 != send_ret )
2014                 {
2015                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM,5,
2016                                                 "Send data is Failed." );
2017                         // Debug log
2018                         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2019                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,106, "out_function : extern void l7vs_replication_compulsorily(void)");
2020                         }
2021                         // Debug log END
2022                         return;
2023                 }
2024
2025                 // set last send block number
2026                 if ( replication_state.last_send_block < replication_state.total_block-1 )
2027                 {
2028                         replication_state.last_send_block += 1;
2029                         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,29,
2030                                                 "Data sending succeeded. Send block number : %u Version : %llu"
2031                                                 ,replication_state.last_send_block
2032                                                 ,(unsigned long long)replication_state.sarface_block_no );
2033                 }else if(replication_state.last_send_block == replication_state.total_block-1){
2034                         replication_state.last_send_block = 0;
2035                         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,30,
2036                                                 "Data sending succeeded. Send block number : %u Version : %llu"
2037                                                 ,replication_state.last_send_block
2038                                                 ,(unsigned long long)replication_state.sarface_block_no );
2039                 }else{
2040                         LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,24,
2041                                                 "Last send block number is illegal.");
2042                         // Debug log
2043                         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2044                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,107, "out_function : extern void l7vs_replication_compulsorily(void)");
2045                         }
2046                         // Debug log END
2047                         return;
2048                 }
2049
2050                 // sarface block number is change
2051                 if(replication_state.total_block == replication_state.last_send_block + 1 )
2052                 {
2053                         // Synchronization is executed.
2054                         memcpy(replication_state.replication_memory,
2055                                 replication_state.component_memory,
2056                                 replication_state.total_block*DATA_SIZE );
2057
2058                         // serial initialize
2059                         replication_state.sarface_block_no = 0;
2060
2061                         // make new serial
2062                         replication_state.sarface_block_no = (uint64_t)l7vs_replication_make_serial();
2063                         if ( 0 == replication_state.sarface_block_no )
2064                         {
2065                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,25,
2066                                                         "Could not get serial number.");
2067                                 // Debug log
2068                                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2069                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,108, "out_function : extern void l7vs_replication_compulsorily(void)");
2070                                 }
2071                                 // Debug log END
2072                                 return;
2073                         }
2074                         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2075                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,109,
2076                                                         "Copy Success from component memory to replication memory." );
2077                         }
2078                 }
2079         }
2080         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,31, "Replication compulsorily is success." );
2081         // Debug log
2082         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2083                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,110, "out_function : extern void l7vs_replication_compulsorily(void)");
2084         }
2085         // Debug log END
2086         return;
2087
2088 }
2089
2090 /*! Interval Re-setting
2091  */
2092 extern void l7vs_replication_reset()
2093 {
2094         int ret;
2095         unsigned short value = 0;
2096
2097         // Debug log
2098         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2099                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,111, "in_function : extern void l7vs_replication_reset(void)");
2100         }
2101         // Debug log END
2102
2103         // Check Parameter exists
2104         ret = parameter_is_int_exist(PARAM_COMP_REPLICATION,"interval");
2105         if ( 0 == ret )
2106         {
2107                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSD_REPLICATION,13, "Not chage re-setting value.");
2108                 // Debug log
2109                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2110                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,112, "out_function : extern void l7vs_replication_reset(void)");
2111                 }
2112                 // Debug log END
2113                 return;
2114         }
2115
2116         // Get interval
2117         value =  parameter_get_int_value( PARAM_COMP_REPLICATION, "interval" );
2118
2119         // Check interval
2120         if ( value < MIN_INTERVAL || MAX_INTERVAL < value ){
2121                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSD_REPLICATION,14, "Invalid Interval value. value : %d",(int)value);
2122                 // Debug log
2123                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2124                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,113, "out_function : extern void l7vs_replication_reset(void)");
2125                 }
2126                 // Debug log END
2127                 return;
2128         }
2129         //set interval
2130         replication_info.interval =  value;
2131 }
2132
2133 /*! Get Status
2134  *
2135  * @return REPLICATION_MODE_TAG enumration
2136  *
2137  */
2138 extern enum REPLICATION_MODE_TAG l7vs_replication_get_status()
2139 {
2140
2141         // Debug log
2142         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2143                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,114, "function : extern enum REPLICATION_MODE_TAG l7vs_replication_get_status(void)");
2144         }
2145         // Debug log END
2146         return replication_state.service_status;
2147 };
2148
2149
2150 /*! Send Interval Check
2151  *
2152  * @return 0/-1
2153  * @retval 0 Send data
2154  * @retval -1 Not send data
2155  */
2156 extern int l7vs_replication_checkinterval()
2157 {
2158         struct timeval tv;
2159         struct timezone tz;
2160         unsigned long long sending_time = 0;
2161         unsigned long long last_send_time = 0;
2162         unsigned long long diff_time = 0;
2163
2164         // Debug log
2165         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2166                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,115, "in_function : extern int l7vs_replication_checkinterval(void)");
2167         }
2168         // Debug log END
2169
2170         // last time
2171         last_send_time = replication_state.send_time;
2172
2173         // now time
2174         gettimeofday(&tv,&tz);
2175         sending_time = (unsigned long long)(tv.tv_sec*1000000+tv.tv_usec);
2176
2177
2178         // Last send time is 0.
2179         if ( 0 == last_send_time )
2180         {
2181                 replication_state.send_time = sending_time;
2182                 LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,32,
2183                         " Last send time is 0. ");
2184                 // Debug log
2185                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2186                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,116,
2187                                                 "out_function : extern int l7vs_replication_checkinterval(void)"
2188                                                 "return = 0");
2189                 }
2190                 // Debug log END
2191                 return 0;
2192         }
2193         //Last send time is illegal.
2194         if ( last_send_time > sending_time)
2195         {
2196                 replication_state.send_time = sending_time;
2197                 LOGGER_PUT_LOG_ERROR (LOG_CAT_L7VSD_REPLICATION,26,
2198                         " Last send time illegal. ");
2199                 // Debug log
2200                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2201                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,117,
2202                                                 "out_function : extern int l7vs_replication_checkinterval(void)"
2203                                                 "return = -1");
2204                 }
2205                 // Debug log END
2206                 return -1;
2207         }
2208         // interval
2209         diff_time = sending_time - last_send_time;
2210         // exit
2211
2212         if ( diff_time >= replication_info.interval)
2213         {
2214                 replication_state.send_time = sending_time;
2215                 // Debug log
2216                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2217                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,118," Send time is arrived ");
2218                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,119,
2219                                                 "out_function : extern int l7vs_replication_checkinterval(void)"
2220                                                 "return = 0");
2221                 }
2222                 // Debug log END
2223                 return 0;
2224         }else{
2225
2226                 // Debug log
2227                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2228                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,120," Send time is not arrived. ");
2229                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,121,
2230                                                 "out_function : extern int l7vs_replication_checkinterval(void)"
2231                                                 "return = -1");
2232                 }
2233                 // Debug log END
2234                 return -1;
2235         }
2236 }
2237
2238 /*! Parameter Check
2239  *
2240  * @return 0/-1
2241  * @retval 0 Success
2242  * @retval -1 Error
2243  */
2244 static int l7vs_replication_check_parameter()
2245 {
2246         int ret = -1;
2247         int info_ret = -1;
2248         int cmp_ret = -1;
2249         struct addrinfo hints;
2250         size_t sum=0;
2251
2252         // Debug log
2253         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2254                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,122,
2255                                         "in_function : static int l7vs_replication_check_parameter(void)");
2256         }
2257         // Debug log END
2258
2259         // initialize structure
2260         memset(&hints, 0, sizeof(struct addrinfo));
2261
2262
2263         // set address hints
2264         hints.ai_family = AF_UNSPEC;     // permit any protocol (IPv4, IPv6, etc.)
2265         hints.ai_socktype = SOCK_DGRAM;  // UDP
2266         // IP NULL check
2267         if ( 0 == strcmp(replication_info.ip_addr, "") )
2268         {
2269                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,27,"IP is unsetting.");
2270                 ret = -1;
2271                 goto END;
2272         }
2273         // Port NULL check
2274         if ( 0 == strcmp(replication_info.service_name,"") )
2275         {
2276                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,28,"Port is unsetting.");
2277                 ret = -1;
2278                 goto END;
2279         }
2280         // Whether IP and the port are effective is confirmed.
2281         info_ret = getaddrinfo(replication_info.ip_addr,replication_info.service_name,&hints,&internal_val.address_info);
2282         if ( 0 != info_ret )
2283         {
2284                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_SOCKET,27, "Failed to get IP or Service Name.(%d)",ret);
2285                 ret = -1;
2286                 goto END;
2287         }
2288         struct sockaddr_in *sin;
2289         sin = (sockaddr_in *)internal_val.address_info->ai_addr;
2290
2291         // Port check
2292         if ( sin->sin_port == htons(0))
2293         {
2294                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSD_REPLICATION,15, "You can't specify port number 0.")
2295                 ret = -1;
2296                 goto END;
2297         }
2298         // NIC check
2299         if ( 0 == strcmp( replication_info.nic, "") )
2300         {
2301                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,29,"NIC is unsetting.");
2302                 ret = -1;
2303                 goto END;
2304         }
2305         // Interval check
2306         if ((MIN_INTERVAL>replication_info.interval) || (MAX_INTERVAL<replication_info.interval))
2307         {
2308                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,30,"Invalid Interval value");
2309                 ret = -1;
2310                 goto END;
2311         }
2312         // Components ID check
2313         // Components Size check
2314         if (0 == replication_info.component_num)
2315         {
2316                 LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,33,"Can not get component, because component is 0.");
2317                 ret = 0;
2318                 goto END;
2319         }
2320         for ( int i=0; i < replication_info.component_num; i++ )
2321         {
2322                 sum += replication_info.component_info[i].block_size ;
2323                 for ( int j=i+1; j<replication_info.component_num; j++)
2324                 {
2325                         cmp_ret = strcmp(replication_info.component_info[j].id,replication_info.component_info[i].id);
2326                         if (0 == cmp_ret)
2327                         {
2328                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,31,
2329                                                 "Too many component block. Max is %d . ",replication_state.total_block);
2330                                 ret = -1;
2331                                 goto END;
2332                         }
2333                 }
2334         }
2335         if ( sum > CMP_BLOCK_MAX )
2336         {
2337                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,32,"Total component size is too large.");
2338                 ret = -1;
2339                 goto END;
2340         }
2341         ret = 0;
2342 END:
2343         if ( NULL != internal_val.address_info )
2344         {
2345                 freeaddrinfo(internal_val.address_info);
2346                 internal_val.address_info = NULL;
2347         }
2348
2349         if ( 0 == ret )
2350         {
2351                 LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,34,"Parameter Check OK.");
2352         }else{
2353                 LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,35,"Parameter Check NG.");
2354         }
2355         // Debug log
2356         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2357                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,123,
2358                                         "out_function : static int l7vs_replication_check_parameter(void)"
2359                                         "return = %d",ret);
2360         }
2361         // Debug log END
2362         return ret;
2363 };
2364
2365
2366 /*! Get Replication Memory
2367  *
2368  * @param total_block The entire block that the component uses.
2369  *
2370  * @return memory Replication memory
2371  * @retval memory memory get Success
2372  * @retval NULL Error
2373  *
2374  */
2375 static void *l7vs_replication_get_replication_address()
2376 {
2377         unsigned int total_block = replication_state.total_block;
2378         void *memory = NULL;
2379
2380
2381         // Debug log
2382         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2383                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,124,
2384                                         "in_function : static void *l7vs_replication_get_replication_address(void)");
2385         }
2386         // Debug log END
2387
2388         // Check by continuous initialize.
2389         if ( REPLICATION_OUT != replication_state.service_status )
2390         {
2391                 // Initialization has already been done.
2392                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,33, "Already got replication memory.");
2393                 // Debug log
2394                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2395                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,125,
2396                                                 "out_function : static void *l7vs_replication_get_replication_address(void)"
2397                                                 "return = NULL");
2398                 }
2399                 // Debug log END
2400                 return NULL;
2401         }
2402
2403         // Check Total Block
2404         if ( 0 == total_block || total_block > CMP_BLOCK_MAX)
2405         {
2406                 // Check Total Block
2407                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,34, "Invalid total component blocks.");
2408                 // Debug log
2409                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2410                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,126,
2411                                                 "out_function : static void *l7vs_replication_get_replication_address(void)"
2412                                                 "return = NULL");
2413                 }
2414                 // Debug log END
2415                 return NULL;
2416         }
2417         // Get replication memory
2418         memory = malloc( total_block*DATA_SIZE );
2419
2420         // Debug log
2421         if (logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_MEMORY) == LOG_LV_DEBUG){
2422                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_MEMORY,40, "malloc : memory=%p: size=%d",memory,total_block*DATA_SIZE);
2423         }
2424         // Debug log END
2425
2426         // malloc Error
2427         if ( (void *)NULL == memory )
2428         {
2429                 LOGGER_PUT_LOG_FATAL(LOG_CAT_L7VSD_SYSTEM_MEMORY,1,"Replication memory is Malloc Error.");
2430                 // Debug log
2431                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2432                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,127,
2433                                                 "out_function : static void *l7vs_replication_get_replication_address(void)"
2434                                                 "return = NULL");
2435                 }
2436                 // Debug log END
2437                 return NULL;
2438         }
2439         memset(memory,0,total_block*DATA_SIZE);
2440
2441         // Debug log
2442         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2443                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,128,
2444                                         "out_function : static void *l7vs_replication_get_replication_address(void)"
2445                                         "return = %p",memory);
2446         }
2447         // Debug log END
2448         return memory;
2449 }
2450
2451
2452 /*! Get Component Memory
2453  *
2454  * @return memory Component memory
2455  * @retval memory memory get Success
2456  * @retval NULL Error
2457  *
2458  */
2459 static void *l7vs_replication_get_component_address()
2460 {
2461         unsigned int total_block ;
2462         void *memory = NULL ;
2463
2464         // Debug log
2465         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2466                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,129, "in_function : static void *l7vs_replication_get_component_address(void)");
2467         }
2468         // Debug log END
2469
2470         total_block = replication_state.total_block;
2471         // Check by continuous initialize.
2472         if ( REPLICATION_OUT != replication_state.service_status )
2473         {
2474                 // Initialization has already been done.
2475                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,35, "Already got component memory.");
2476                 // Debug log
2477                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2478                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,130,
2479                         "out_function : static void *l7vs_replication_get_component_address(void)"
2480                         "return = NULL");
2481                 }
2482                 // Debug log END
2483                 return NULL;
2484         }
2485         // Check Total Block
2486         if ( 0 == total_block || total_block > CMP_BLOCK_MAX)
2487         {
2488                 // Check Total Block
2489                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,36, "Invalid total component blocks.");
2490                 // Debug log
2491                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2492                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,131,
2493                         "out_function : static void *l7vs_replication_get_component_address(void)"
2494                         "return = NULL");
2495                 }
2496                 // Debug log END
2497                 return NULL;
2498         }
2499         // Get component memory
2500         memory = malloc( total_block*DATA_SIZE );
2501
2502         // Debug log
2503         if (logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_MEMORY) == LOG_LV_DEBUG){
2504                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_MEMORY,41, "malloc : memory=%p: size=%d",memory,total_block*DATA_SIZE);
2505         }
2506         // Debug log END
2507
2508         // malloc Error
2509         if ( (void *)NULL == memory )
2510         {
2511                 LOGGER_PUT_LOG_FATAL(LOG_CAT_L7VSD_SYSTEM_MEMORY,2,"Component memory is Malloc Error.");
2512                 // Debug log
2513                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2514                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,132,
2515                         "out_function : static void *l7vs_replication_get_component_address(void)"
2516                         "return = NULL");
2517                 }
2518                 // Debug log END
2519                 return NULL;
2520         }
2521         memset(memory,0,total_block*DATA_SIZE);
2522
2523         // Debug log
2524         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2525                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,133,
2526                 "out_function : static void *l7vs_replication_get_component_address(void)"
2527                 "return = %p",memory);
2528         }
2529         // Debug log END
2530         return memory;
2531 }
2532
2533
2534 /*! Get Sarface Number Memory
2535  *
2536  * @return memory Component memory
2537  * @retval memory memory get Success
2538  * @retval NULL Error
2539  *
2540  */
2541 static uint64_t *l7vs_replication_get_surface_info_address()
2542 {
2543         unsigned int total_block;
2544         uint64_t *memory = NULL;
2545
2546         // Debug log
2547         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2548                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,134,
2549                                 "in_function : static uint64_t *l7vs_replication_get_surface_info_address(void)");
2550         }
2551         // Debug log END
2552         total_block = replication_state.total_block;
2553         // Check by continuous initialize.
2554         if ( REPLICATION_OUT != replication_state.service_status )
2555         {
2556                 // Initialization has already been done.
2557                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,37, "Already got surface info memory.");
2558                 // Debug log
2559                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2560                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,135,
2561                         "out_function : static uint64_t *l7vs_replication_get_surface_info_address(void)"
2562                         "return = NULL");
2563                 }
2564                 // Debug log END
2565                 return NULL;
2566         }
2567         // Check Total Block
2568         if ( 0 == total_block || total_block > CMP_BLOCK_MAX)
2569         {
2570                 // Check Total Block
2571                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,38, "Invalid total component blocks.");
2572                 // Debug log
2573                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2574                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,136,
2575                         "out_function : static uint64_t *l7vs_replication_get_surface_info_address(void)"
2576                         "return = NULL");
2577                 }
2578                 // Debug log END
2579                 return NULL;
2580         }
2581         // Get memory
2582         memory = (uint64_t*)malloc( total_block*sizeof(uint64_t) );
2583
2584         // Debug log
2585         if (logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_MEMORY) == LOG_LV_DEBUG){
2586                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_MEMORY,42, "malloc : memory=%p: size=%lu",memory,total_block*sizeof(uint64_t));
2587         }
2588         // Debug log END
2589
2590         // malloc Error
2591         if ( (uint64_t *)NULL == memory )
2592         {
2593                 LOGGER_PUT_LOG_FATAL(LOG_CAT_L7VSD_SYSTEM_MEMORY,3,"Surface info address is Malloc Error.");
2594                 // Debug log
2595                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2596                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,137,
2597                         "out_function : static uint64_t *l7vs_replication_get_surface_info_address(void)"
2598                         "return = NULL");
2599                 }
2600                 // Debug log END
2601                 return NULL;
2602         }
2603         memset(memory,0,total_block*sizeof(uint64_t));
2604         // Debug log
2605         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2606                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,138,
2607                 "out_function : static uint64_t *l7vs_replication_get_surface_info_address(void)"
2608                 "return = %p",memory);
2609         }
2610         // Debug log END
2611         return memory;
2612 }
2613
2614 /*! Initialize send network socket
2615  *
2616  * @param *fd file descriptor
2617  *
2618  * @return 0/-1
2619  *  @retval  0 Success
2620  *  @retval -1 Error
2621  */
2622 static int l7vs_replication_send_sock_init( )
2623 {
2624         int info_ret;
2625         int sockopt_ret;
2626         int errsv;
2627         int ret = -1;
2628         struct addrinfo hints;
2629
2630         // Debug log
2631         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2632                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,139,
2633                 "in_function : static int l7vs_replication_send_sock_init(void)");
2634         }
2635         // Debug log END
2636
2637         // Check by continuous initialize.
2638         if ( REPLICATION_SINGLE == replication_state.service_status ||
2639                 REPLICATION_MASTER == replication_state.service_status ||
2640                 REPLICATION_MASTER_STOP == replication_state.service_status )
2641         {
2642                 // Initialization has already been done.
2643                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,39,
2644                                         "send-socket initialization has already been done. mode : %s",
2645                                         replication_mode[(int)replication_state.service_status]);
2646                 ret = -1;
2647                 goto END;
2648         }
2649         // initialize structure
2650         memset(&hints, 0, sizeof(struct addrinfo));
2651
2652         // set address hints
2653         hints.ai_family = AF_UNSPEC;     // permit any protocol (IPv4, IPv6, etc.)
2654         hints.ai_socktype = SOCK_DGRAM;  // UDP
2655         hints.ai_flags = AI_ALL;
2656
2657         //------ Make send socket -------//
2658         // Whether IP and the port are effective is confirmed.
2659         info_ret = getaddrinfo(replication_info.ip_addr,
2660                                 replication_info.service_name,
2661                                 &hints,
2662                                 &internal_val.address_info);
2663         if ( 0 != info_ret )
2664         {
2665                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,40, "Failed to get IP or Port.");
2666                 ret = -1;
2667                 goto END;
2668         }
2669
2670         internal_val.socket = socket( internal_val.address_info->ai_family,
2671                                         internal_val.address_info->ai_socktype,
2672                                         internal_val.address_info->ai_protocol );
2673         // if cannot make a socket
2674         if ( internal_val.socket < 3 )
2675         {
2676                 errsv = errno;
2677                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_SOCKET,28,
2678                                         "Make send socket error : %s ai_family:%d ai_socktype:%d ai_protocol:%d",
2679                                         strerror(errsv),internal_val.address_info->ai_family,
2680                                         internal_val.address_info->ai_socktype,
2681                                         internal_val.address_info->ai_protocol);
2682                 ret = -1;
2683                 goto END;
2684         }
2685         // set a NIC
2686          sockopt_ret = setsockopt(internal_val.socket, SOL_SOCKET, SO_BINDTODEVICE,
2687                                                 replication_info.nic, strlen(replication_info.nic) + 1);
2688         if ( -1 == sockopt_ret )
2689         {
2690                 // get error no
2691                 errsv = errno;
2692                 // cannot set a NIC.  Close a Socket.
2693                 close(internal_val.socket);
2694                 internal_val.socket = -1;
2695                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_SOCKET,29,
2696                                         "Fails in the option operation of send socket : %s File descriptor : %d NIC : %s",
2697                                         strerror(errsv),internal_val.socket,replication_info.nic);
2698                 ret = -1;
2699                 goto END;
2700         }
2701         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_SYSTEM_SOCKET,1,"send-socket is make success.");
2702         ret = 0;
2703 END:
2704
2705         if ( 0 == ret )
2706         {
2707                 LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,36,"send-soket initialization is  succeess.");
2708         }else{
2709                 if ( -1 != internal_val.socket )
2710                 {
2711                         close(internal_val.socket);
2712                         internal_val.socket = -1;
2713                 }
2714                 LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,37,"send-soket initialization is failure.");
2715         }
2716         // Debug log
2717         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2718                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,140,
2719                 "out_function : static int l7vs_replication_send_sock_init(void)"
2720                 "ret = %d",ret);
2721         }
2722         // Debug log END
2723         return ret;
2724 }
2725
2726
2727 /*! Initialize recv network socket
2728  *
2729  * @param *fd file descriptor
2730  *
2731  * @return 0/-1
2732  *  @retval  0 Success
2733  *  @retval -1 Error
2734  */
2735 static int l7vs_replication_recv_sock_init( )
2736 {
2737         int     getip_ret;
2738         int     bind_ret;
2739         int     errsv;
2740         int     ret = -1;
2741         struct  servent         *servent_info;
2742
2743
2744         // Debug log
2745         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2746                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,141,
2747                 "in_function : static int l7vs_replication_recv_sock_init(void)");
2748         }
2749         // Debug log END
2750
2751         // Check by continuous initialize.
2752         if ( REPLICATION_SINGLE == replication_state.service_status ||
2753                 REPLICATION_SLAVE == replication_state.service_status ||
2754                 REPLICATION_SLAVE_STOP == replication_state.service_status )
2755         {
2756                 // Initialization has already been done.
2757                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,41,
2758                                         "recv-socket initialization has already been done. mode : %s",
2759                                         replication_mode[(int)replication_state.service_status]);
2760                 ret = -1;
2761                 goto END;
2762         }
2763
2764         // get Name for NetworkDeviceName ( IPv4 or IPv6 )
2765         // address info structs initialize
2766         memset( &internal_val.addr, 0, sizeof(struct  addressinfo) );
2767
2768         // get ip address from nic
2769         getip_ret = getNICAddressInfo(replication_info.nic, &addr);
2770         if ( 0 == getip_ret )
2771         {
2772                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_SOCKET,31,"You can not get IP address from nic.");
2773                 ret = -1;
2774                 goto END;
2775         }
2776
2777
2778         servent_info = getservbyname(replication_info.service_name,"udp");
2779         if( !servent_info )
2780         {
2781                 internal_val.addr.addr_in.sin_port = htons( atoi(replication_info.service_name ) );
2782         }
2783         else{
2784                 internal_val.addr.addr_in.sin_port = servent_info->s_port ;
2785         }
2786
2787         if ( 0 == internal_val.addr.addr_in.sin_port )
2788         {
2789                 LOGGER_PUT_LOG_ERROR( LOG_CAT_L7VSD_SYSTEM_SOCKET,32,"You can not get port address from %s.",replication_info.service_name );
2790                 ret = -1;
2791                 goto END;
2792         }
2793
2794
2795         //make recv socket
2796         internal_val.socket = socket( PF_INET,
2797                                         SOCK_DGRAM,
2798                                         IPPROTO_UDP );
2799
2800         // if cannot make a socket
2801         if ( internal_val.socket < 3 )
2802         {
2803                 errsv = errno;
2804                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_SOCKET,34,
2805                                         "Make recv socket error : %s ai_family:%d ai_socktype:%d ai_protocol:%d",
2806                                         strerror(errsv),
2807                                         PF_INET,
2808                                         SOCK_DGRAM,
2809                                         IPPROTO_UDP);
2810                 ret = -1;
2811                 goto END;
2812         }
2813
2814         bind_ret = bind(internal_val.socket,(sockaddr *)&internal_val.addr.addr_in, sizeof(internal_val.addr.addr_in));
2815
2816         // get error no
2817         errsv = errno;
2818         // Error
2819         if ( bind_ret != 0 )
2820         {
2821                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_SOCKET,33,
2822                                          "Bind error : %s File descriptor : %d ai_addrlen : %d",
2823                                         strerror(errsv),
2824                                         internal_val.socket,
2825                                         (int)sizeof(struct sockaddr));
2826                 //! Close a Socket.
2827                 ret = -1;
2828                 goto END;
2829         }
2830         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_SYSTEM_SOCKET,2,"recv-socket is make success.");
2831         ret = 0;
2832 END:
2833
2834         if ( 0 == ret )
2835         {
2836                 LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,38,"recv-socket initialization is  succeess.");
2837         }else{
2838                 if ( -1 != internal_val.socket )
2839                 {
2840                         close(internal_val.socket);
2841                         internal_val.socket = -1;
2842                 }
2843                 LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,39,"recv-socket initialization is failure..");
2844         }
2845         // Debug log
2846         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2847                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,142,
2848                 "out_function : static int l7vs_replication_recv_sock_init(void)"
2849                 "ret = %d",ret);
2850         }
2851         // Debug log END
2852         return ret;
2853 }
2854
2855 /*! Finalize network socket
2856  */
2857 static void l7vs_replication_sock_fini()
2858 {
2859         // Debug log
2860         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2861                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,143,
2862                 "in_function : static void l7vs_replication_sock_fini(void)");
2863         }
2864         // Debug log END
2865
2866         // close a send socket.
2867         if ( -1 != internal_val.socket )
2868         {
2869                 close(internal_val.socket);
2870                 internal_val.socket = -1;
2871         }
2872         // free address info
2873         if ( NULL != internal_val.address_info)
2874         {
2875                 freeaddrinfo(internal_val.address_info);
2876                 internal_val.address_info = NULL;
2877         }
2878
2879         LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,40, "Socket(send-socket,recv-socket) is finalize.");
2880
2881         if ( NULL != l7vs_replication_iomux)
2882         {
2883                 // replication fini
2884                 l7vs_replication_iomux->status = iomux_replication_destroy;
2885                 // Debug log
2886                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2887                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,144,
2888                                                 "l7vs_replication_iomux->status : iomux_replication_destroy");
2889                 }
2890                 // Debug log END
2891
2892                 // delete l7vs_iomux
2893                 if ( -1 != l7vs_replication_iomux->fd ) {
2894                         l7vs_iomux_remove(l7vs_replication_iomux);
2895                         l7vs_replication_iomux->fd = -1;
2896                 }
2897         }
2898         // Debug log
2899         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2900                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,145,
2901                 "out_function : static void l7vs_replication_sock_fini(void)");
2902         }
2903         // Debug log END
2904         return;
2905 }
2906
2907 /*! Make serial number
2908  *
2909  *  @return Serial number
2910  *  @retval nonzero Serial number
2911  *  @retval 0 Error
2912  */
2913 static unsigned long long l7vs_replication_make_serial()
2914 {
2915         unsigned long long int serial_num;
2916         struct timespec current_time;
2917
2918         // Debug log
2919         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2920                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,146,
2921                 "in_function : static void l7vs_replication_sock_fini(void)");
2922         }
2923         // Debug log END
2924
2925         // get time by clock_gettime
2926         if ( clock_gettime(CLOCK_REALTIME, &current_time) == -1 )
2927         {
2928                 // failre.
2929                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM,6, "You failed to get of time.");
2930                 serial_num = 0;
2931         } else {
2932                 // make a serial succeeds.
2933                 serial_num = (unsigned long long int) current_time.tv_sec * 1000000 +
2934                                         (unsigned long long int) current_time.tv_nsec / 1000;
2935         }
2936         // Debug log
2937         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2938                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,147,
2939                 "in_function : static void l7vs_replication_sock_fini(void)"
2940                 "return = %llu",serial_num);
2941         }
2942         // Debug log END
2943
2944         return serial_num;
2945 }
2946
2947 /*! Send transfer data to standby server
2948  *
2949  *  @param data Points to input data from external program. This will be send to standby server.
2950  *
2951  *  @return 0/-1
2952  *  @retval 0 Success
2953  *  @retval -1 Error
2954  */
2955 static int l7vs_replication_send_data(struct l7vs_replication_data *replication_data)
2956 {
2957         char *send_memory;
2958         int send_byte;
2959         int errsv;
2960         struct l7vs_replication_data send_data;
2961
2962         // Debug log
2963         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2964                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,148,
2965                 "in_function : static int l7vs_replication_send_data(struct l7vs_replication_data *replication_data)"
2966                 "replication_data = %p",replication_data);
2967         }
2968         // Debug log END
2969
2970
2971         // Check Argument is NULL.
2972         if ( NULL == replication_data )
2973         {
2974                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,42, "Argument is NULL.");
2975                 // Debug log
2976                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2977                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,149,
2978                         "out_function : static int l7vs_replication_send_data(struct l7vs_replication_data *replication_data)"
2979                         "return = -1");
2980                 }
2981                 // Debug log END
2982                 return -1;
2983         }
2984
2985         // mode check
2986         if ( REPLICATION_MASTER != replication_state.service_status)
2987         {
2988                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,43, "Can not send replication data. Mode is difficult.  mode : %s",
2989                                                 replication_mode[(int)replication_state.service_status]);
2990                 // Debug log
2991                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
2992                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,150,
2993                         "out_function : static int l7vs_replication_send_data(struct l7vs_replication_data *replication_data)"
2994                         "return = -1");
2995                 }
2996                 // Debug log END
2997                 return -1;
2998         }
2999         // Check to replication memory is not  NULL
3000         if ( NULL == replication_state.replication_memory )
3001         {
3002                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_MEMORY,42, "Replication memory is NULL.");
3003                 // Debug log
3004                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3005                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,151,
3006                         "out_function : static int l7vs_replication_send_data(struct l7vs_replication_data *replication_data)"
3007                         "return = -1");
3008                 }
3009                 // Debug log END
3010                 return -1;
3011         }
3012
3013         // Check to iomux memory is not NULL
3014         if ( NULL == l7vs_replication_iomux)
3015         {
3016                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_MEMORY,43, "Initialize is not yet. Iomux is NULL.");
3017                 // Debug log
3018                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3019                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,152,
3020                         "out_function : static int l7vs_replication_send_data(struct l7vs_replication_data *replication_data)"
3021                         "return = -1");
3022                 }
3023                 // Debug log END
3024                 return -1;
3025         }
3026
3027         // internal_val.address_info is NULL
3028         if ( NULL == internal_val.address_info)
3029         {
3030                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_MEMORY,44, "Initialize is not yet. address info is NULL.");
3031                 // Debug log
3032                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3033                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,153,
3034                         "out_function : static int l7vs_replication_send_data(struct l7vs_replication_data *replication_data)"
3035                         "return = -1");
3036                 }
3037                 // Debug log END
3038                 return -1;
3039         }
3040
3041
3042         // make replication data struct
3043         //initialize
3044         memset(replication_data, 0, sizeof(struct l7vs_replication_data));
3045         // Set replication id
3046         replication_data->id = REPLICATION_ID;
3047         // set block_num (replication_state.last_send_block + 1) and Range check of memory
3048         if ( replication_state.last_send_block < replication_state.total_block -1)
3049         {
3050                 replication_data->block_num = replication_state.last_send_block + 1;
3051         } else if ( replication_state.last_send_block == replication_state.total_block -1){
3052                 replication_data->block_num = 0;
3053         }else{
3054                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,44, "Recv block number is too large.");
3055                 // Debug log
3056                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3057                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,154,
3058                         "out_function : static int l7vs_replication_send_data(struct l7vs_replication_data *replication_data)"
3059                         "return = -1");
3060                 }
3061                 // Debug log END
3062                 return -1;
3063         }
3064
3065         // set serial
3066         replication_data->serial = replication_state.sarface_block_no;
3067         if ( 0 == replication_data->serial && 0 == replication_data->block_num)
3068         {
3069                 LOGGER_PUT_LOG_INFO(LOG_CAT_L7VSD_REPLICATION,41, "Serial number is 0, first send processing. ");
3070         }
3071
3072         // set data size (sizeof(replication_data))
3073         replication_data->size = sizeof(struct l7vs_replication_data);
3074
3075         if ( replication_data->size > SEND_DATA_SIZE)
3076         {
3077                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,45, "Recv block data size is too large.");
3078                 // Debug log
3079                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3080                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,155,
3081                         "out_function : static int l7vs_replication_send_data(struct l7vs_replication_data *replication_data)"
3082                         "return = -1");
3083                 }
3084                 // Debug log END
3085                 return -1;
3086         }
3087
3088         // change iomux status
3089         l7vs_replication_iomux->status = iomux_replication_sending;
3090         // Debug log
3091         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3092                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,156,
3093                                         "l7vs_replication_iomux->status :"
3094                                         "befor : iomux_replication_send_wait"
3095                                         "after : iomux_replication_sending");
3096         }
3097         // Debug log END
3098
3099         // set send data
3100         memset(&send_data,0,sizeof(struct l7vs_replication_data));
3101         // change to network byteorder
3102         send_data.id = htons(replication_data->id);
3103         send_data.serial = replication_data->serial;
3104         send_data.block_num = htonl(replication_data->block_num);
3105         send_data.size = (uint64_t)replication_data->size;
3106
3107         // set replication data (1 block)
3108         send_memory = (char *)replication_state.replication_memory + DATA_SIZE*replication_data->block_num;
3109         memcpy( &send_data.data, send_memory, DATA_SIZE );
3110
3111         // send to data
3112         send_byte = sendto(internal_val.socket, &send_data, (int)replication_data->size, 0,
3113                                         internal_val.address_info->ai_addr, internal_val.address_info->ai_addrlen);
3114         errsv = errno;
3115
3116         // Debug log
3117         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3118                 char replication_data_str[DEBUG_STR_LEN] = {0};
3119                 l7vs_replication_data_c_str(replication_data_str,replication_data);
3120                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,157,
3121                                                 "replication_data_struct : %s",
3122                                                 replication_data_str);
3123         }
3124
3125         // Debug log END
3126         // Debug log
3127         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG)
3128         {
3129                 char    *head;
3130                 int     h=0;
3131
3132                 for ( h = 0; h < (DATA_SIZE / LOG_DATA_WIDTH) ; h++ )
3133                 {
3134                         head = (char *)&send_data.data + h*LOG_DATA_WIDTH;
3135                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,158,
3136                                                 "%02hhX %02hhX %02hhX %02hhX  %02hhX %02hhX %02hhX %02hhX  "
3137                                                 "%02hhX %02hhX %02hhX %02hhX  %02hhX %02hhX %02hhX %02hhX"
3138                                                 , *head, *(head+1), *(head+2), *(head+3)
3139                                                 , *(head+4), *(head+5), *(head+6), *(head+7)
3140                                                 , *(head+8), *(head+9), *(head+10), *(head+11)
3141                                                 , *(head+12), *(head+13), *(head+14), *(head+15));
3142                 }
3143         }
3144         // Debug log END
3145         if (-1 ==  send_byte)
3146         {
3147                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM,7,
3148                                         "Data send error : %s  fd : %d size : %d ai_addr : %p addrlen : %d",
3149                                         strerror(errsv),
3150                                         internal_val.socket,
3151                                         (int)replication_data->size,
3152                                         internal_val.address_info->ai_addr,
3153                                         internal_val.address_info->ai_addrlen);
3154                 // Debug log
3155                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3156                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,159,
3157                         "out_function : static int l7vs_replication_send_data(struct l7vs_replication_data *replication_data)"
3158                         "return = -1");
3159                 }
3160                 // Debug log END
3161                 return -1;
3162         }
3163         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3164                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,160,"Sent data is success. %d", send_byte);
3165                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,161,
3166                 "out_function : static int l7vs_replication_send_data(struct l7vs_replication_data *replication_data)"
3167                 "return = 0");
3168         }
3169         // Debug log END
3170         return 0;
3171 }
3172 /*! Receive transfer data from active server
3173  *
3174  *  @param  recv_data Points to output data from external program.
3175  *
3176  *  @return 0/-1
3177  *  @retval 0 Success
3178  *  @retval -1 Error
3179  */
3180 static int l7vs_replication_recv_data(struct l7vs_replication_data *replication_data)
3181 {
3182         char    *recv_memory;
3183         int     recv_byte;
3184         int     errsv = 0;
3185         socklen_t fromlen;
3186         struct l7vs_replication_data recv_data;
3187
3188         // Debug log
3189         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3190                 if ( NULL == replication_data )
3191                 {
3192                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,162,
3193                         "in_function : static int l7vs_replication_recv_data(struct l7vs_replication_data *replication_data)"
3194                         "replication_data = NULL");
3195
3196                 }else{
3197                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,163,
3198                         "in_function : static int l7vs_replication_recv_data(struct l7vs_replication_data *replication_data)"
3199                         "replication_data = %p",replication_data);
3200                 }
3201         }
3202         // Debug log END
3203
3204         // Check Argument is NULL.
3205         if ( NULL == replication_data )
3206         {
3207                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,46, "Argument is NULL.");
3208                 // Debug log
3209                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3210                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,164,
3211                         "out_function : static int l7vs_replication_recv_data(struct l7vs_replication_data *replication_data)"
3212                         "return = -1");
3213                 }
3214                 // Debug log END
3215                 return -1;
3216         }
3217
3218         // mode check
3219         if ( REPLICATION_SLAVE != replication_state.service_status)
3220         {
3221                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,47, "Can not receive replication data. Mode is difficult.  mode : %s",
3222                                                 replication_mode[(int)replication_state.service_status]);
3223                 // Debug log
3224                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3225                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,165,
3226                         "out_function : static int l7vs_replication_recv_data(struct l7vs_replication_data *replication_data)"
3227                         "return = -1");
3228                 }
3229                 // Debug log END
3230                 return -1;
3231         }
3232
3233         // Check to replication memory is not  NULL
3234         if ( NULL == replication_state.replication_memory )
3235         {
3236                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_MEMORY,45, "Replication memory is NULL.");
3237                 // Debug log
3238                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3239                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,166,
3240                         "out_function : static int l7vs_replication_recv_data(struct l7vs_replication_data *replication_data)"
3241                         "return = -1");
3242                 }
3243                 // Debug log END
3244                 return -1;
3245         }
3246
3247         // Check to iomux memory is not NULL
3248         if ( NULL == l7vs_replication_iomux)
3249         {
3250                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_SYSTEM_MEMORY,46, "Initialize is not yet. Iomux is NULL.");
3251                 // Debug log
3252                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3253                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,167,
3254                         "out_function : static int l7vs_replication_recv_data(struct l7vs_replication_data *replication_data)"
3255                         "return = -1");
3256                 }
3257                 // Debug log END
3258                 return -1;
3259         }
3260
3261         fromlen = sizeof(struct sockaddr);
3262
3263         // change iomux status
3264         l7vs_replication_iomux->status = iomux_replication_receving;
3265         // Debug log
3266         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3267                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,168,
3268                                         "l7vs_replication_iomux->status :"
3269                                         "before : iomux_replication_recv_wait :"
3270                                         "after : iomux_replication_receving");
3271         }
3272         // Debug log END
3273
3274         //initialize
3275         memset(&recv_data, 0, sizeof(struct l7vs_replication_data));
3276         memset(replication_data, 0, sizeof(struct l7vs_replication_data));
3277
3278         // recv data
3279         recv_byte = recvfrom( internal_val.socket, &recv_data,
3280                                 sizeof(struct l7vs_replication_data),
3281                                 MSG_DONTWAIT,
3282                                 (sockaddr *)&internal_val.addr.addr_in,
3283                                 &fromlen );
3284         errsv = errno;
3285
3286         // change to host byteorder
3287         replication_data->id = ntohs(recv_data.id);
3288         replication_data->serial = recv_data.serial;
3289         replication_data->block_num = ntohl(recv_data.block_num);
3290         replication_data->size = (uint64_t) recv_data.size;
3291
3292         memcpy(&replication_data->data, &recv_data.data, DATA_SIZE);
3293
3294         // Debug log
3295         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG)
3296         {
3297                 char    *head;
3298                 int     h;
3299
3300                 for ( h = 0; h < (DATA_SIZE / LOG_DATA_WIDTH) ; h++ )
3301                 {
3302                         head = (char *)&recv_data.data + h*LOG_DATA_WIDTH;
3303                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,169,
3304                                                 "%02hhX %02hhX %02hhX %02hhX  %02hhX %02hhX %02hhX %02hhX  "
3305                                                 "%02hhX %02hhX %02hhX %02hhX  %02hhX %02hhX %02hhX %02hhX"
3306                                                 , *head, *(head+1), *(head+2), *(head+3)
3307                                                 , *(head+4), *(head+5), *(head+6), *(head+7)
3308                                                 , *(head+8), *(head+9), *(head+10), *(head+11)
3309                                                 , *(head+12), *(head+13), *(head+14), *(head+15));
3310                 }
3311         }
3312         // Debug log END
3313         if (-1 ==  recv_byte)
3314         {
3315                 LOGGER_PUT_LOG_WARN(LOG_CAT_L7VSD_SYSTEM,2,
3316                                         "Reception processing is error : %s  fd : %d data : %p size : %d ai_addr : %p addrlen : %d",
3317                                         strerror(errsv),
3318                                         internal_val.socket,
3319                                         (void *)&recv_data,
3320                                         (int)recv_data.size,
3321                                         &internal_val.addr.addr_in,
3322                                         fromlen);
3323                 // Debug log
3324                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3325                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,170,
3326                         "out_function : static int l7vs_replication_recv_data(struct l7vs_replication_data *replication_data)"
3327                         "return = -1");
3328                 }
3329                 // Debug log END
3330                 return -1;
3331         }
3332         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3333                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,171,"Recv data is success. %u", recv_byte);
3334         }
3335         // Check replication ID
3336         if (replication_data->id != REPLICATION_ID)
3337         {
3338                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,48, "Get invalid data.");
3339                 // Debug log
3340                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3341                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,172,
3342                         "out_function : static int l7vs_replication_recv_data(struct l7vs_replication_data *replication_data)"
3343                         "return = -1");
3344                 }
3345                 // Debug log END
3346                 return -1;
3347         }
3348
3349         // block number is over
3350
3351         if (replication_data->block_num > replication_state.total_block)
3352         {
3353                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,49, "Recv block number is too large.");
3354                 // Debug log
3355                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3356                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,173,
3357                         "out_function : static int l7vs_replication_recv_data(struct l7vs_replication_data *replication_data)"
3358                         "return = -1");
3359                 }
3360                 // Debug log END
3361                 return -1;
3362         }
3363
3364         // Comparison of serial numbers
3365         if ( replication_data->serial < replication_state.sarface_block_array_ptr[replication_data->block_num])
3366         {
3367                 LOGGER_PUT_LOG_ERROR(LOG_CAT_L7VSD_REPLICATION,50, "Recv replication data is too old.");
3368                 // Debug log
3369                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3370                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,174,
3371                         "out_function : static int l7vs_replication_recv_data(struct l7vs_replication_data *replication_data)"
3372                         "return = -1");
3373                 }
3374                 // Debug log END
3375                 return -1;
3376         }else{
3377                 // Substitution of version
3378                 replication_state.sarface_block_array_ptr[replication_data->block_num] = replication_data->serial;
3379         }
3380
3381         // set recv data
3382         recv_memory = (char *)replication_state.replication_memory + DATA_SIZE*replication_data->block_num;
3383
3384         // received data.
3385         memcpy(recv_memory, &replication_data->data, DATA_SIZE);
3386
3387         // set sarface block
3388         replication_state.sarface_block_array_ptr[replication_data->block_num] = replication_data->serial;
3389
3390         // Sarface numbers are compared.
3391         for ( unsigned int i = 0; i < replication_state.total_block-1; i++ )
3392         {
3393                 if ( replication_state.sarface_block_array_ptr[i] != replication_state.sarface_block_array_ptr[i+1])
3394                 {
3395                         break;
3396                 }
3397                 if ( i == replication_state.total_block-2)
3398                 {
3399                         // Synchronization is executed.
3400                         memcpy(replication_state.component_memory,
3401                                 replication_state.replication_memory,
3402                                 replication_state.total_block*DATA_SIZE );
3403                         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3404                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,82, "Copy Success from replication memory to component memory.");
3405                         }
3406                 }
3407         }
3408
3409         // Debug log
3410         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3411                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,175,
3412                 "out_function : static int l7vs_replication_recv_data(struct l7vs_replication_data *replication_data)"
3413                 "return = 0");
3414         }
3415         // Debug log END
3416         return 0;
3417 }
3418
3419 /*! Release Replication Memory
3420  */
3421 static void l7vs_replication_release_replication_address()
3422 {
3423         // Debug log
3424         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3425                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,176,
3426                                 "in_function : static void l7vs_replication_release_replication_address(void)");
3427         }
3428         // Debug log END
3429
3430         // Debug log
3431         if (logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_MEMORY) == LOG_LV_DEBUG){
3432                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_MEMORY,43,
3433                                         "free : replication_state.replication_memory=%p",
3434                                         replication_state.replication_memory);
3435         }
3436         // Debug log END
3437         if (NULL != replication_state.replication_memory )
3438         {
3439                 free(replication_state.replication_memory);
3440         }
3441         replication_state.replication_memory=NULL;
3442
3443         // Debug log
3444         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3445                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,177,
3446                                 "out_function : static void l7vs_replication_release_replication_address(void)");
3447         }
3448         // Debug log END
3449 }
3450
3451 /*!
3452  * Release Components Memory
3453  */
3454 static void l7vs_replication_release_components_address()
3455 {
3456         // Debug log
3457         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3458                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,178,
3459                                 "in_function : static void l7vs_replication_release_components_address(void)");
3460         }
3461         // Debug log END
3462
3463         // Debug log
3464         if (logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_MEMORY) == LOG_LV_DEBUG){
3465                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_MEMORY,44,
3466                                         "free : replication_state.component_memory=%p",
3467                                         replication_state.component_memory);
3468         }
3469         // Debug log END
3470         if ( NULL != replication_state.component_memory)
3471         {
3472                 free(replication_state.component_memory);
3473         }
3474         replication_state.component_memory=NULL;
3475
3476         // Debug log
3477         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3478                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,179,
3479                                 "out_function : static void l7vs_replication_release_components_address(void)");
3480         }
3481         // Debug log END
3482 }
3483
3484 /*! Release Sarface Memory
3485  */
3486 static void l7vs_replication_release_surface_info_address()
3487 {
3488         // Debug log
3489         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3490                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,180,
3491                                 "in_function : static void l7vs_replication_release_surface_info_address(void)");
3492         }
3493
3494         // Debug log END
3495
3496         // Debug log
3497         if (logger_get_log_level(LOG_CAT_L7VSD_SYSTEM_MEMORY) == LOG_LV_DEBUG){
3498                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM_MEMORY,45,
3499                                         "free : replication_state.sarface_block_array_ptr=%p",
3500                                         replication_state.sarface_block_array_ptr);
3501         }
3502         // Debug log END
3503         if ( NULL != replication_state.sarface_block_array_ptr )
3504         {
3505                 free(replication_state.sarface_block_array_ptr);
3506         }
3507         replication_state.sarface_block_array_ptr=NULL;
3508
3509         // Debug log
3510         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3511                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,181,
3512                                 "out_function : static void l7vs_replication_release_surface_info_address(void)");
3513         }
3514         // Debug log END
3515
3516 }
3517
3518 /*
3519  * get Name for NetworkDeviceName
3520  * @param[IN]   const char*             NetworkDeviceName
3521  * @param[OUT]  struct addressinfo*     address info struct
3522  * @return      0 is fail / not 0 is success.
3523  */
3524 static int getNICAddressInfo( const char* nicname, struct addressinfo* info )
3525 {
3526         // Debug log
3527         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3528                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,182,
3529                                 "in_function : static int getNICAddressInfo( const char* nicname, struct addressinfo* info )"
3530                                 "nicname = %p"
3531                                 "info = %p",
3532                                 nicname,
3533                                 info);
3534         }
3535         // Debug log END
3536
3537         //NIC NAME Check
3538         if( !nicname || !info )
3539         {
3540                 // Debug log
3541                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3542                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,183,
3543                                         "out_function : static int getNICAddressInfo( const char* nicname, struct addressinfo* info )"
3544                                         "return = 0");
3545                 }
3546                 // Debug log END
3547                 return 0;
3548         }
3549
3550         //Networkdevice struct define
3551         struct ifreq ifr;
3552         memset( &ifr, 0, sizeof( struct ifreq ) );
3553
3554         //create socket
3555         int fd  = socket( AF_INET, SOCK_DGRAM, 0 );
3556         if( fd < 0 )
3557         {
3558                 // Debug log
3559                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3560                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,184,
3561                                         "out_function : static int getNICAddressInfo( const char* nicname, struct addressinfo* info )"
3562                                         "return = 0");
3563                 }
3564                 // Debug log END
3565                 return 0;
3566         }
3567
3568         //get networkdevice struct for IPv4
3569         strncpy( ifr.ifr_name, nicname, IFNAMSIZ-1 );
3570         ifr.ifr_addr.sa_family = AF_INET;
3571
3572         // Debug log
3573         if (logger_get_log_level(LOG_CAT_L7VSD_SYSTEM) == LOG_LV_DEBUG){
3574                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_SYSTEM,2,
3575                                 "Use ioctl() :"
3576                                 "in_function : static int getNICAddressInfo( const char* nicname, struct addressinfo* info )"
3577                                 "nicname = %p"
3578                                 "info = %p",
3579                                 nicname,
3580                                 info);
3581         }
3582         // Debug log END
3583
3584         if( ioctl( fd, SIOCGIFADDR, &ifr ) < 0 )
3585         {
3586                 // Debug log
3587                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3588                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,185,
3589                                         "out_function : static int getNICAddressInfo( const char* nicname, struct addressinfo* info )"
3590                                         "return = 0");
3591                 }
3592                 // Debug log END
3593                 return 0;
3594         }
3595         memcpy( &(info->addr_in), &(ifr.ifr_addr), sizeof( struct sockaddr_in ) );
3596
3597         // Debug log
3598         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3599                 char sockaddr_in_str[DEBUG_STR_LEN] = {0};
3600                 sockaddr_in_c_str(sockaddr_in_str,&(info->addr_in));
3601                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,186,
3602                                                 "sockaddr_in_struct : %s",
3603                                                 sockaddr_in_str);
3604         }
3605         // Debug log END
3606
3607
3608         //get networkdevice struct for IPv6
3609         memset( &ifr, 0, sizeof( struct ifreq ) );
3610         strncpy( ifr.ifr_name, nicname, IFNAMSIZ-1 );
3611         ifr.ifr_addr.sa_family = AF_INET6;
3612         if( ioctl( fd, SIOCGIFADDR, &ifr ) < 0 )
3613         {
3614                 // Debug log
3615                 if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3616                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,187,
3617                                         "out_function : static int getNICAddressInfo( const char* nicname, struct addressinfo* info )"
3618                                         "return = 0");
3619                 }
3620                 // Debug log END
3621         // Debug log
3622         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3623                 char sockaddr_in_str[DEBUG_STR_LEN] = {0};
3624                 sockaddr_in_c_str(sockaddr_in_str,&(info->addr_in));
3625                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,188,
3626                                                 "sockaddr_in_struct : %s",
3627                                                 sockaddr_in_str);
3628         }
3629         // Debug log END
3630                 return 0;
3631         }
3632         memcpy( &(info->addr_in6 ), &(ifr.ifr_addr), sizeof( struct sockaddr_in6 ) );
3633
3634         close( fd );
3635
3636         // Debug log
3637         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3638                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,189,
3639                                 "out_function : static int getNICAddressInfo( const char* nicname, struct addressinfo* info )"
3640                                 "return = 1");
3641         }
3642         // Debug log END
3643         // Debug log
3644         if (logger_get_log_level(LOG_CAT_L7VSD_REPLICATION) == LOG_LV_DEBUG){
3645                 char sockaddr_in_str[DEBUG_STR_LEN] = {0};
3646                 sockaddr_in_c_str(sockaddr_in_str,&(info->addr_in));
3647                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_L7VSD_REPLICATION,190,
3648                                                 "sockaddr_in_struct : %s",
3649                                                 sockaddr_in_str);
3650         }
3651         // Debug log END
3652         return 1;
3653 }
3654
3655
3656 /*!
3657  * Extract struct l7vs_protomod to strings for debug log.
3658  * @param  string
3659  * @return l7vs_replication_data
3660  */
3661
3662 static void l7vs_replication_data_c_str(char *ret, struct l7vs_replication_data *replication_data)
3663 {
3664         if ( !replication_data ){
3665                 snprintf(ret, DEBUG_STR_LEN, "(nil)");
3666                 return;
3667         }
3668         snprintf( ret, DEBUG_STR_LEN,
3669                         "replication_data = %p:"
3670                         "id = %u:"
3671                         "serial = %llu:"
3672                         "block_num = %u:"
3673                         "size = %llu:"
3674                         "data = %s:",
3675                         replication_data,
3676                         replication_data->id,
3677                         replication_data->serial,
3678                         replication_data->block_num,
3679                         (long long int)replication_data->size,
3680                         replication_data->data);
3681         printf("%s",ret);
3682         return;
3683 }
3684
3685 static void l7vs_replication_component_c_str(char *ret, struct l7vs_replication_component *component_info, int i)
3686 {
3687         if ( !component_info )
3688         {
3689                 snprintf(ret, DEBUG_STR_LEN, "(nil)");
3690                 return;
3691         }
3692         snprintf( ret, DEBUG_STR_LEN,
3693                         "replication_component = %p:"
3694                         "id[%d] = %s:"
3695                         "block_head[%d] = %u:"
3696                         "block_size[%d] = %u:",
3697                         component_info,
3698                         i,component_info[i].id,
3699                         i,component_info[i].block_head,
3700                         i,component_info[i].block_size);
3701         return;
3702 }
3703
3704 static void l7vs_replication_state_c_str(char *ret, struct l7vs_replication_state *replication_state)
3705 {
3706         if ( !replication_state )
3707         {
3708                 snprintf(ret, DEBUG_STR_LEN, "(nil)");
3709                 return;
3710         }
3711
3712         snprintf( ret, DEBUG_STR_LEN,
3713                         "replication_state = %p:"
3714                         "service_status = %s:"
3715                         "send_time = %llu:"
3716                         "last_send_block = %u:"
3717                         "last_recv_block = %u:"
3718                         "total_block = %d:"
3719                         "replication_memory = %p:"
3720                         "component_memory = %p:"
3721                         "sarface_block_no = %llu:"
3722                         "sarface_block_array_ptr = %p:",
3723                         replication_state,
3724                         replication_mode[(int)replication_state->service_status],
3725                         replication_state->send_time,
3726                         replication_state->last_send_block,
3727                         replication_state->last_recv_block,
3728                         replication_state->total_block,
3729                         replication_state->replication_memory,
3730                         replication_state->component_memory,
3731                         (long long int)replication_state->sarface_block_no,
3732                         replication_state->sarface_block_array_ptr);
3733         return;
3734 }
3735
3736 static void l7vs_replication_info_c_str(char *ret, struct l7vs_replication_info *replication_info)
3737 {
3738         if ( !replication_info )
3739         {
3740                 snprintf(ret, DEBUG_STR_LEN, "(nil)");
3741                 return;
3742         }
3743
3744         snprintf( ret, DEBUG_STR_LEN,
3745                         "replication_info = %p:"
3746                         "ip_addr = %s:"
3747                         "service_name = %s:"
3748                         "nic = %s:"
3749                         "interval = %u:"
3750                         "component_num = %d:"
3751                         "component_info = %p:",
3752                         replication_info,
3753                         replication_info->ip_addr,
3754                         replication_info->service_name,
3755                         replication_info->nic,
3756                         replication_info->interval,
3757                         replication_info->component_num,
3758                         replication_info->component_info);
3759 }
3760
3761 static void sockaddr_in_c_str(char *ret, struct sockaddr_in *addr_in)
3762 {
3763         struct sockaddr_in p;
3764
3765         memset(&p,0,sizeof(struct sockaddr_in));
3766
3767         if ( !addr_in )
3768         {
3769                 snprintf(ret, DEBUG_STR_LEN, "(nil)");
3770                 return;
3771         }
3772
3773         memcpy(&p,addr_in,sizeof(struct sockaddr_in));
3774         snprintf( ret, DEBUG_STR_LEN,
3775                         "addr_in = %p:"
3776                         "sin_family = %d:"
3777                         "sin_port = %u:"
3778                         "in_addr.sin_addr = %llu:"
3779                         "sin_zero = %s:",
3780                         addr_in,
3781                         addr_in->sin_family,
3782                         addr_in->sin_port,
3783                         (long long int)p.sin_addr.s_addr,
3784                         addr_in->sin_zero);
3785         return;
3786
3787 }
3788