src/sslproxymain.cpp

   1 /*
   2  * @file  sslproxymain.cpp
   3  * @brief the main module of SSLproxy
   4  * @brief SSLproxy module is terminal as for the SSL communication,
   5  * @brief and it operates as reverse Proxy.
   6  *
   7  * Copyright (C) 2008  NTT COMWARE Corporation.
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  22  * 02110-1301 USA
  23  *
  24  **********************************************************************
  25  *
  26  * Distributed under the Boost Software Licence, Version 1.0
  27  * http://www.boost.org/LICENSE_1_0.txt
  28  *
  29  **********************************************************************/
  30
  31 #include <sys/time.h>
  32 #include <sys/resource.h>
  33 #include "sslproxy.h"
  34 #include "sslproxyserver.h"
  35
  36 using namespace l7vs;
  37
  38 //! Prototype of functions.
  39 static int convVerifyOption(std::string opt_string);
  40 static long int convSslOption(std::string opt_string);
  41 static int getParameters(std::string config_filename);
  42 static int splitEndpoint(std::string endpoint_str, std::string& host, std::string& port);
  43 static void sig_exit_handler(int sig);
  44 static int set_sighandler(int sig, void (*handler)(int));
  45 static int set_sighandlers(void);
  46 static void usage(void);
  47
  48 //! Target_id.
  49 std::string target_id;
  50
  51 //! SSLproxy parameters.
  52 std::string recv_endpoint;
  53 std::string target_endpoint;
  54 int num_thread;
  55 int timeout_sec;
  56 std::string ca_dir;
  57 std::string ca_file;
  58 std::string cert_chain_dir;
  59 std::string cert_chain_file;
  60 std::string private_key_dir;
  61 std::string private_key_file;
  62 boost::asio::ssl::context::file_format private_key_filetype;
  63 std::string private_key_passwd_from;
  64 std::string private_key_passwd_dir;
  65 std::string private_key_passwd_file;
  66 int verify_options;
  67 int verify_cert_depth;
  68 long int ssl_options;
  69 bool tmp_dh_use;
  70 std::string tmp_dh_dir;
  71 std::string tmp_dh_file;
  72 std::string cipher_list;
  73 long session_cache_mode;
  74 long session_cache_size;
  75 long session_cache_timeout;
  76 std::string conn_log_flag;
  77 bool edit_client_msg;
  78 bool edit_server_msg;
  79 int x_forwarded_for_mode;
  80 std::string custom_field;
  81
  82
  83 /*!
  84  * Convert verify option string to intger(#define).
  85  *
  86  * @param[in]   opt_string      option string
  87  * @retval      ret     option value
  88  * @retval      -1      no match
  89  */
  90 static int convVerifyOption(std::string opt_string)
  91 {
  92         /*-------- DEBUG LOG --------*/
  93         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
  94                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 1,
  95                         "in_function : static int convVerifyOption(std::string opt_string) : "
  96                         "opt_string = %s",
  97                         opt_string.c_str());
  98         }
  99         /*------ DEBUG LOG END ------*/
 100
 101         int ret = -1;
 102         /*!
 103          * /usr/include/openssl/ssl.h
 104          * #define SSL_VERIFY_NONE                 0x00
 105          * #define SSL_VERIFY_PEER                 0x01
 106          * #define SSL_VERIFY_FAIL_IF_NO_PEER_CERT 0x02
 107          * #define SSL_VERIFY_CLIENT_ONCE          0x04
 108          */
 109         if (opt_string == "SSL_VERIFY_NONE") {
 110                 /*-------- DEBUG LOG --------*/
 111                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 112                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 2,
 113                                 "function : static int convVerifyOption(std::string opt_string) : "
 114                                 "SSL_VERIFY_NONE");
 115                 }
 116                 /*------ DEBUG LOG END ------*/
 117                 ret = SSL_VERIFY_NONE;
 118         }
 119         if (opt_string == "SSL_VERIFY_PEER") {
 120                 /*-------- DEBUG LOG --------*/
 121                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 122                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 3,
 123                                 "function : static int convVerifyOption(std::string opt_string) : "
 124                                 "SSL_VERIFY_PEER");
 125                 }
 126                 /*------ DEBUG LOG END ------*/
 127                 ret = SSL_VERIFY_PEER;
 128         }
 129         if (opt_string == "SSL_VERIFY_FAIL_IF_NO_PEER_CERT") {
 130                 /*-------- DEBUG LOG --------*/
 131                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 132                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 4,
 133                                 "function : static int convVerifyOption(std::string opt_string) : "
 134                                 "SSL_VERIFY_FAIL_IF_NO_PEER_CERT");
 135                 }
 136                 /*------ DEBUG LOG END ------*/
 137                 ret = SSL_VERIFY_FAIL_IF_NO_PEER_CERT;
 138         }
 139         if (opt_string == "SSL_VERIFY_CLIENT_ONCE") {
 140                 /*-------- DEBUG LOG --------*/
 141                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 142                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 5,
 143                                 "function : static int convVerifyOption(std::string opt_string) : "
 144                                 "SSL_VERIFY_CLIENT_ONCE");
 145                 }
 146                 /*------ DEBUG LOG END ------*/
 147                 ret = SSL_VERIFY_CLIENT_ONCE;
 148         }
 149
 150         /*-------- DEBUG LOG --------*/
 151         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 152                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 6,
 153                         "out_function : static int convVerifyOption(std::string opt_string) : "
 154                         "return_value = %d",
 155                         ret);
 156         }
 157         /*------ DEBUG LOG END ------*/
 158         // if ret == -1 then No match.
 159         return ret;
 160 }
 161
 162 /*!
 163  * Convert SSL option string to intger(#define).
 164  *
 165  * @param[in]   opt_string      option string
 166  * @retval      ret     option value
 167  * @retval      -1      no match
 168  */
 169 static long int convSslOption(std::string opt_string)
 170 {
 171         /*-------- DEBUG LOG --------*/
 172         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 173                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 7,
 174                         "in_function : static long int convSslOption(std::string opt_string) : "
 175                         "opt_string = %s",
 176                         opt_string.c_str());
 177         }
 178         /*------ DEBUG LOG END ------*/
 179
 180         long int ret = -1;
 181         /*!
 182          * /usr/include/openssl/ssl.h
 183          * #define SSL_OP_MICROSOFT_SESS_ID_BUG                    0x00000001L
 184          * #define SSL_OP_NETSCAPE_CHALLENGE_BUG                   0x00000002L
 185          * #define SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG         0x00000008L
 186          * #define SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG              0x00000010L
 187          * #define SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER               0x00000020L
 188          * #define SSL_OP_MSIE_SSLV2_RSA_PADDING                   0x00000040L
 189          * #define SSL_OP_SSLEAY_080_CLIENT_DH_BUG                 0x00000080L
 190          * #define SSL_OP_TLS_D5_BUG                               0x00000100L
 191          * #define SSL_OP_TLS_BLOCK_PADDING_BUG                    0x00000200L
 192          * #define SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS              0x00000800L
 193          * #define SSL_OP_ALL                                      0x00000FF7L
 194          * #define SSL_OP_NO_QUERY_MTU                             0x00001000L
 195          * #define SSL_OP_COOKIE_EXCHANGE                          0x00002000L
 196          * #define SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION   0x00010000L
 197          * #define SSL_OP_SINGLE_ECDH_USE                          0x00080000L
 198          * #define SSL_OP_SINGLE_DH_USE                            0x00100000L
 199          * #define SSL_OP_EPHEMERAL_RSA                            0x00200000L
 200          * #define SSL_OP_CIPHER_SERVER_PREFERENCE                 0x00400000L
 201          * #define SSL_OP_TLS_ROLLBACK_BUG                         0x00800000L
 202          * #define SSL_OP_NO_SSLv2                                 0x01000000L
 203          * #define SSL_OP_NO_SSLv3                                 0x02000000L
 204          * #define SSL_OP_NO_TLSv1                                 0x04000000L
 205          * #define SSL_OP_PKCS1_CHECK_1                            0x08000000L
 206          * #define SSL_OP_PKCS1_CHECK_2                            0x10000000L
 207          * #define SSL_OP_NETSCAPE_CA_DN_BUG                       0x20000000L
 208          * #define SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG          0x40000000L
 209          */
 210         if (opt_string == "SSL_OP_MICROSOFT_SESS_ID_BUG") {
 211                 /*-------- DEBUG LOG --------*/
 212                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 213                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 8,
 214                                 "function : static int convSslOption(std::string opt_string) : "
 215                                 "SSL_OP_MICROSOFT_SESS_ID_BUG");
 216                 }
 217                 /*------ DEBUG LOG END ------*/
 218                 ret = SSL_OP_MICROSOFT_SESS_ID_BUG;
 219         }
 220         if (opt_string == "SSL_OP_NETSCAPE_CHALLENGE_BUG") {
 221                 /*-------- DEBUG LOG --------*/
 222                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 223                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 9,
 224                                 "function : static int convSslOption(std::string opt_string) : "
 225                                 "SSL_OP_NETSCAPE_CHALLENGE_BUG");
 226                 }
 227                 /*------ DEBUG LOG END ------*/
 228                 ret = SSL_OP_NETSCAPE_CHALLENGE_BUG;
 229         }
 230         if (opt_string == "SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG") {
 231                 /*-------- DEBUG LOG --------*/
 232                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 233                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 10,
 234                                 "function : static int convSslOption(std::string opt_string) : "
 235                                 "SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG");
 236                 }
 237                 /*------ DEBUG LOG END ------*/
 238                 ret = SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG;
 239         }
 240         if (opt_string == "SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG") {
 241                 /*-------- DEBUG LOG --------*/
 242                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 243                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 11,
 244                                 "function : static int convSslOption(std::string opt_string) : "
 245                                 "SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG");
 246                 }
 247                 /*------ DEBUG LOG END ------*/
 248                 ret = SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG;
 249         }
 250         if (opt_string == "SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER") {
 251                 /*-------- DEBUG LOG --------*/
 252                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 253                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 12,
 254                                 "function : static int convSslOption(std::string opt_string) : "
 255                                 "SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER");
 256                 }
 257                 /*------ DEBUG LOG END ------*/
 258                 ret = SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER;
 259         }
 260         if (opt_string == "SSL_OP_MSIE_SSLV2_RSA_PADDING") {
 261                 /*-------- DEBUG LOG --------*/
 262                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 263                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 13,
 264                                 "function : static int convSslOption(std::string opt_string) : "
 265                                 "SSL_OP_MSIE_SSLV2_RSA_PADDING");
 266                 }
 267                 /*------ DEBUG LOG END ------*/
 268                 ret = SSL_OP_MSIE_SSLV2_RSA_PADDING;
 269         }
 270         if (opt_string == "SSL_OP_SSLEAY_080_CLIENT_DH_BUG") {
 271                 /*-------- DEBUG LOG --------*/
 272                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 273                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 14,
 274                                 "function : static int convSslOption(std::string opt_string) : "
 275                                 "SSL_OP_SSLEAY_080_CLIENT_DH_BUG");
 276                 }
 277                 /*------ DEBUG LOG END ------*/
 278                 ret = SSL_OP_SSLEAY_080_CLIENT_DH_BUG;
 279         }
 280         if (opt_string == "SSL_OP_TLS_D5_BUG") {
 281                 /*-------- DEBUG LOG --------*/
 282                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 283                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 15,
 284                                 "function : static int convSslOption(std::string opt_string) : "
 285                                 "SSL_OP_TLS_D5_BUG");
 286                 }
 287                 /*------ DEBUG LOG END ------*/
 288                 ret = SSL_OP_TLS_D5_BUG;
 289         }
 290         if (opt_string == "SSL_OP_TLS_BLOCK_PADDING_BUG") {
 291                 /*-------- DEBUG LOG --------*/
 292                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 293                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 16,
 294                                 "function : static int convSslOption(std::string opt_string) : "
 295                                 "SSL_OP_TLS_BLOCK_PADDING_BUG");
 296                 }
 297                 /*------ DEBUG LOG END ------*/
 298                 ret = SSL_OP_TLS_BLOCK_PADDING_BUG;
 299         }
 300         if (opt_string == "SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS") {
 301                 /*-------- DEBUG LOG --------*/
 302                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 303                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 17,
 304                                 "function : static int convSslOption(std::string opt_string) : "
 305                                 "SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS");
 306                 }
 307                 /*------ DEBUG LOG END ------*/
 308                 ret = SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS;
 309         }
 310         if (opt_string == "SSL_OP_ALL") {
 311                 /*-------- DEBUG LOG --------*/
 312                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 313                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 18,
 314                                 "function : static int convSslOption(std::string opt_string) : "
 315                                 "SSL_OP_ALL");
 316                 }
 317                 /*------ DEBUG LOG END ------*/
 318                 // boost::asio::ssl::context::default_workarounds
 319                 ret = SSL_OP_ALL;
 320         }
 321         if (opt_string == "SSL_OP_NO_QUERY_MTU") {
 322                 /*-------- DEBUG LOG --------*/
 323                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 324                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 19,
 325                                 "function : static int convSslOption(std::string opt_string) : "
 326                                 "SSL_OP_NO_QUERY_MTU");
 327                 }
 328                 /*------ DEBUG LOG END ------*/
 329                 ret = SSL_OP_NO_QUERY_MTU;
 330         }
 331         if (opt_string == "SSL_OP_COOKIE_EXCHANGE") {
 332                 /*-------- DEBUG LOG --------*/
 333                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 334                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 20,
 335                                 "function : static int convSslOption(std::string opt_string) : "
 336                                 "SSL_OP_COOKIE_EXCHANGE");
 337                 }
 338                 /*------ DEBUG LOG END ------*/
 339                 ret = SSL_OP_COOKIE_EXCHANGE;
 340         }
 341         if (opt_string == "SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION") {
 342                 /*-------- DEBUG LOG --------*/
 343                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 344                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 21,
 345                                 "function : static int convSslOption(std::string opt_string) : "
 346                                 "SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION");
 347                 }
 348                 /*------ DEBUG LOG END ------*/
 349                 ret = SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION;
 350         }
 351         if (opt_string == "SSL_OP_SINGLE_ECDH_USE") {
 352                 /*-------- DEBUG LOG --------*/
 353                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 354                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 22,
 355                                 "function : static int convSslOption(std::string opt_string) : "
 356                                 "SSL_OP_SINGLE_ECDH_USE");
 357                 }
 358                 /*------ DEBUG LOG END ------*/
 359                 ret = SSL_OP_SINGLE_ECDH_USE;
 360         }
 361         if (opt_string == "SSL_OP_SINGLE_DH_USE") {
 362                 /*-------- DEBUG LOG --------*/
 363                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 364                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 23,
 365                                 "function : static int convSslOption(std::string opt_string) : "
 366                                 "SSL_OP_SINGLE_DH_USE");
 367                 }
 368                 /*------ DEBUG LOG END ------*/
 369                 // boost::asio::ssl::context::single_dh_use
 370                 ret = SSL_OP_SINGLE_DH_USE;
 371         }
 372         if (opt_string == "SSL_OP_EPHEMERAL_RSA") {
 373                 /*-------- DEBUG LOG --------*/
 374                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 375                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 24,
 376                                 "function : static int convSslOption(std::string opt_string) : "
 377                                 "SSL_OP_EPHEMERAL_RSA");
 378                 }
 379                 /*------ DEBUG LOG END ------*/
 380                 ret = SSL_OP_EPHEMERAL_RSA;
 381         }
 382         if (opt_string == "SSL_OP_CIPHER_SERVER_PREFERENCE") {
 383                 /*-------- DEBUG LOG --------*/
 384                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 385                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 25,
 386                                 "function : static int convSslOption(std::string opt_string) : "
 387                                 "SSL_OP_CIPHER_SERVER_PREFERENCE");
 388                 }
 389                 /*------ DEBUG LOG END ------*/
 390                 ret = SSL_OP_CIPHER_SERVER_PREFERENCE;
 391         }
 392         if (opt_string == "SSL_OP_TLS_ROLLBACK_BUG") {
 393                 /*-------- DEBUG LOG --------*/
 394                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 395                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 26,
 396                                 "function : static int convSslOption(std::string opt_string) : "
 397                                 "SSL_OP_TLS_ROLLBACK_BUG");
 398                 }
 399                 /*------ DEBUG LOG END ------*/
 400                 ret = SSL_OP_TLS_ROLLBACK_BUG;
 401         }
 402         if (opt_string == "SSL_OP_NO_SSLv2") {
 403                 /*-------- DEBUG LOG --------*/
 404                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 405                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 27,
 406                                 "function : static int convSslOption(std::string opt_string) : "
 407                                 "SSL_OP_NO_SSLv2");
 408                 }
 409                 /*------ DEBUG LOG END ------*/
 410                 // boost::asio::ssl::context::no_sslv2
 411                 ret = SSL_OP_NO_SSLv2;
 412         }
 413         if (opt_string == "SSL_OP_NO_SSLv3") {
 414                 /*-------- DEBUG LOG --------*/
 415                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 416                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 28,
 417                                 "function : static int convSslOption(std::string opt_string) : "
 418                                 "SSL_OP_NO_SSLv3");
 419                 }
 420                 /*------ DEBUG LOG END ------*/
 421                 // boost::asio::ssl::context::no_sslv3
 422                 ret = SSL_OP_NO_SSLv3;
 423         }
 424         if (opt_string == "SSL_OP_NO_TLSv1") {
 425                 /*-------- DEBUG LOG --------*/
 426                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 427                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 29,
 428                                 "function : static int convSslOption(std::string opt_string) : "
 429                                 "SSL_OP_NO_TLSv1");
 430                 }
 431                 /*------ DEBUG LOG END ------*/
 432                 // boost::asio::ssl::context::no_tlsv1
 433                 ret = SSL_OP_NO_TLSv1;
 434         }
 435         if (opt_string == "SSL_OP_PKCS1_CHECK_1") {
 436                 /*-------- DEBUG LOG --------*/
 437                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 438                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 30,
 439                                 "function : static int convSslOption(std::string opt_string) : "
 440                                 "SSL_OP_PKCS1_CHECK_1");
 441                 }
 442                 /*------ DEBUG LOG END ------*/
 443                 ret = SSL_OP_PKCS1_CHECK_1;
 444         }
 445         if (opt_string == "SSL_OP_PKCS1_CHECK_2") {
 446                 /*-------- DEBUG LOG --------*/
 447                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 448                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 31,
 449                                 "function : static int convSslOption(std::string opt_string) : "
 450                                 "SSL_OP_PKCS1_CHECK_2");
 451                 }
 452                 /*------ DEBUG LOG END ------*/
 453                 ret = SSL_OP_PKCS1_CHECK_2;
 454         }
 455         if (opt_string == "SSL_OP_NETSCAPE_CA_DN_BUG") {
 456                 /*-------- DEBUG LOG --------*/
 457                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 458                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 32,
 459                                 "function : static int convSslOption(std::string opt_string) : "
 460                                 "SSL_OP_NETSCAPE_CA_DN_BUG");
 461                 }
 462                 /*------ DEBUG LOG END ------*/
 463                 ret = SSL_OP_NETSCAPE_CA_DN_BUG;
 464         }
 465         if (opt_string == "SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG") {
 466                 /*-------- DEBUG LOG --------*/
 467                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 468                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 33,
 469                                 "function : static int convSslOption(std::string opt_string) : "
 470                                 "SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG");
 471                 }
 472                 /*------ DEBUG LOG END ------*/
 473                 ret = SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG;
 474         }
 475
 476         /*-------- DEBUG LOG --------*/
 477         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 478                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 34,
 479                         "out_function : static long int convSslOption(std::string opt_string) : "
 480                         "return_value = %ld",
 481                         ret);
 482         }
 483         /*------ DEBUG LOG END ------*/
 484         // if ret == -1 then No match.
 485         return ret;
 486 }
 487
 488 /*!
 489  * Get SSLproxy parameter from parameter file.
 490  *
 491  * @param[in]   config_filename config filename string
 492  * @retval      0       success
 493  * @retval      -1      failed
 494  */
 495 static int getParameters(std::string config_filename)
 496 {
 497         /*-------- DEBUG LOG --------*/
 498         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 499                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 35,
 500                         "in_function : static int getParameters(std::string config_filename) : "
 501                         "config_filename = %s",
 502                         config_filename.c_str());
 503         }
 504         /*------ DEBUG LOG END ------*/
 505
 506         int ret = 0;
 507
 508         try {
 509                 // Read configuration file.
 510                 if (parameter_reread_file(PARAM_COMP_ALL, config_filename) == -1) {
 511                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 1,
 512                                              "Config file read error.");
 513                         throw -1;
 514                 }
 515
 516                 // Get parameter "recv_endpoint".
 517                 if (Parameter::getInstance().isStringExist(PARAM_COMP_SSLPROXY, "recv_endpoint")) {
 518                         recv_endpoint = Parameter::getInstance().getStringValue(PARAM_COMP_SSLPROXY,
 519                                                                                 "recv_endpoint");
 520                         /*-------- DEBUG LOG --------*/
 521                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 522                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 36,
 523                                         "function : static int getParameters("
 524                                         "std::string config_filename) : "
 525                                         "get recv_endpoint OK.");
 526                         }
 527                         /*------ DEBUG LOG END ------*/
 528                 } else {
 529                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 2,
 530                                              "Cannot get recv_endpoint parameter.");
 531                         throw -1;
 532                 }
 533
 534                 // Get parameter "target_endpoint".
 535                 if (Parameter::getInstance().isStringExist(PARAM_COMP_SSLPROXY, "target_endpoint")) {
 536                         target_endpoint = Parameter::getInstance().getStringValue(PARAM_COMP_SSLPROXY,
 537                                                                                   "target_endpoint");
 538                         /*-------- DEBUG LOG --------*/
 539                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 540                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 37,
 541                                         "function : static int getParameters("
 542                                         "std::string config_filename) : "
 543                                         "get target_endpoint OK.");
 544                         }
 545                         /*------ DEBUG LOG END ------*/
 546                 } else {
 547                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 3,
 548                                              "Cannot get target_endpoint parameter.");
 549                         throw -1;
 550                 }
 551
 552                 // Get parameter "num_thread".
 553                 if (Parameter::getInstance().isIntExist(PARAM_COMP_SSLPROXY, "num_thread")) {
 554                         num_thread = Parameter::getInstance().getIntValue(PARAM_COMP_SSLPROXY,
 555                                                                           "num_thread");
 556                         /*-------- DEBUG LOG --------*/
 557                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 558                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 38,
 559                                         "function : static int getParameters("
 560                                         "std::string config_filename) : "
 561                                         "get num_thread OK.");
 562                         }
 563                         /*------ DEBUG LOG END ------*/
 564                         if (num_thread <= 0 || num_thread > INT_MAX) {
 565                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 4,
 566                                                      "Invalid num_thread parameter value.");
 567                                 throw -1;
 568                         }
 569                 } else {
 570                         LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 1,
 571                                             "num_thread parameter not found. "
 572                                             "Use default value.");
 573                         num_thread = DEFAULT_NUM_THREAD;
 574                 }
 575
 576                 // Get parameter "timeout_sec".
 577                 if (Parameter::getInstance().isIntExist(PARAM_COMP_SSLPROXY, "timeout_sec")) {
 578                         timeout_sec = Parameter::getInstance().getIntValue(PARAM_COMP_SSLPROXY,
 579                                                                            "timeout_sec");
 580                         /*-------- DEBUG LOG --------*/
 581                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 582                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 39,
 583                                         "function : static int getParameters("
 584                                         "std::string config_filename) : "
 585                                         "get timeout_sec OK.");
 586                         }
 587                         /*------ DEBUG LOG END ------*/
 588                         if (timeout_sec <= 0 || timeout_sec > INT_MAX) {
 589                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 5,
 590                                                      "Invalid timeout_sec parameter value.");
 591                                 throw -1;
 592                         }
 593                 } else {
 594                         LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 2,
 595                                             "timeout_sec parameter not found. "
 596                                             "Use default value.");
 597                         timeout_sec = DEFAULT_TIMEOUT_SEC;
 598                 }
 599
 600                 // Get parameter "ca_dir".
 601                 if (Parameter::getInstance().isStringExist(PARAM_COMP_SSLPROXY, "ca_dir")) {
 602                         ca_dir = Parameter::getInstance().getStringValue(PARAM_COMP_SSLPROXY,
 603                                                                          "ca_dir");
 604                         /*-------- DEBUG LOG --------*/
 605                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 606                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 40,
 607                                         "function : static int getParameters("
 608                                         "std::string config_filename) : "
 609                                         "get ca_dir OK.");
 610                         }
 611                         /*------ DEBUG LOG END ------*/
 612                         if (ca_dir == "") {
 613                                 LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 3,
 614                                                     "ca_dir parameter is nothing. "
 615                                                     "Use default value.");
 616                                 ca_dir = DEFAULT_CA_DIR;
 617                         }
 618                 } else {
 619                         LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 4,
 620                                             "ca_dir parameter not found. "
 621                                             "Use default value.");
 622                         ca_dir = DEFAULT_CA_DIR;
 623                 }
 624
 625                 // Get parameter "ca_file".
 626                 if (Parameter::getInstance().isStringExist(PARAM_COMP_SSLPROXY, "ca_file")) {
 627                         ca_file = Parameter::getInstance().getStringValue(PARAM_COMP_SSLPROXY,
 628                                                                           "ca_file");
 629                         /*-------- DEBUG LOG --------*/
 630                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 631                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 41,
 632                                         "function : static int getParameters("
 633                                         "std::string config_filename) : "
 634                                         "get ca_file OK.");
 635                         }
 636                         /*------ DEBUG LOG END ------*/
 637                 } else {
 638                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 6,
 639                                              "Cannot get ca_file parameter.");
 640                         throw -1;
 641                 }
 642
 643                 // Get parameter "cert_chain_dir".
 644                 if (Parameter::getInstance().isStringExist(PARAM_COMP_SSLPROXY, "cert_chain_dir")) {
 645                         cert_chain_dir = Parameter::getInstance().getStringValue(PARAM_COMP_SSLPROXY,
 646                                                                                  "cert_chain_dir");
 647                         /*-------- DEBUG LOG --------*/
 648                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 649                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 42,
 650                                         "function : static int getParameters("
 651                                         "std::string config_filename) : "
 652                                         "get cert_chain_dir OK.");
 653                         }
 654                         /*------ DEBUG LOG END ------*/
 655                         if (cert_chain_dir == "") {
 656                                 LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 5,
 657                                                     "cert_chain_dir parameter is nothing. "
 658                                                     "Use default value.");
 659                                 cert_chain_dir = DEFAULT_CERT_CHAIN_DIR;
 660                         }
 661                 } else {
 662                         LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 6,
 663                                             "cert_chain_dir parameter not found. "
 664                                             "Use default value.");
 665                         cert_chain_dir = DEFAULT_CERT_CHAIN_DIR;
 666                 }
 667
 668                 // Get parameter "cert_chain_file".
 669                 if (Parameter::getInstance().isStringExist(PARAM_COMP_SSLPROXY, "cert_chain_file")) {
 670                         cert_chain_file = Parameter::getInstance().getStringValue(PARAM_COMP_SSLPROXY,
 671                                                                                   "cert_chain_file");
 672                         /*-------- DEBUG LOG --------*/
 673                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 674                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 43,
 675                                         "function : static int getParameters("
 676                                         "std::string config_filename) : "
 677                                         "get cert_chain_file OK.");
 678                         }
 679                         /*------ DEBUG LOG END ------*/
 680                         if (cert_chain_file == "") {
 681                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 7,
 682                                                      "cert_chain_file parameter is nothing.");
 683                                 throw -1;
 684                         }
 685                 } else {
 686                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 8,
 687                                              "Cannot get cert_chain_file parameter.");
 688                         throw -1;
 689                 }
 690
 691                 // Get parameter "private_key_dir".
 692                 if (Parameter::getInstance().isStringExist(PARAM_COMP_SSLPROXY, "private_key_dir")) {
 693                         private_key_dir = Parameter::getInstance().getStringValue(PARAM_COMP_SSLPROXY,
 694                                                                                   "private_key_dir");
 695                         /*-------- DEBUG LOG --------*/
 696                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 697                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 44,
 698                                         "function : static int getParameters("
 699                                         "std::string config_filename) : "
 700                                         "get private_key_dir OK.");
 701                         }
 702                         /*------ DEBUG LOG END ------*/
 703                         if (private_key_dir == "") {
 704                                 LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 7,
 705                                                     "private_key_dir parameter is nothing. "
 706                                                     "Use default value.");
 707                                 private_key_dir = DEFAULT_PRIVATE_KEY_DIR;
 708                         }
 709                 } else {
 710                         LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 8,
 711                                             "private_key_dir parameter not found. Use default value.");
 712                         private_key_dir = DEFAULT_PRIVATE_KEY_DIR;
 713                 }
 714
 715                 // Get parameter "private_key_file".
 716                 if (Parameter::getInstance().isStringExist(PARAM_COMP_SSLPROXY, "private_key_file")) {
 717                         private_key_file = Parameter::getInstance().getStringValue(PARAM_COMP_SSLPROXY,
 718                                                                                    "private_key_file");
 719                         /*-------- DEBUG LOG --------*/
 720                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 721                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 45,
 722                                         "function : static int getParameters("
 723                                         "std::string config_filename) : "
 724                                         "get private_key_file OK.");
 725                         }
 726                         /*------ DEBUG LOG END ------*/
 727                         if (private_key_file == "") {
 728                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 9,
 729                                                      "private_key_file parameter is nothing.");
 730                                 throw -1;
 731                         }
 732                 } else {
 733                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 10,
 734                                              "Cannot get private_key_file parameter.");
 735                         throw -1;
 736                 }
 737
 738                 // Get parameter "private_key_filetype".
 739                 // Convert string to enum.
 740                 if (Parameter::getInstance().isStringExist(PARAM_COMP_SSLPROXY, "private_key_filetype")) {
 741                         std::string private_key_filetype_string =
 742                                 Parameter::getInstance().getStringValue(PARAM_COMP_SSLPROXY,
 743                                                                         "private_key_filetype");
 744                         /*-------- DEBUG LOG --------*/
 745                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 746                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 46,
 747                                         "function : static int getParameters("
 748                                         "std::string config_filename) : "
 749                                         "get private_key_filetype_string OK.");
 750                         }
 751                         /*------ DEBUG LOG END ------*/
 752                         /*!
 753                          * /usr/include/openssl/ssl.h
 754                          * #define SSL_FILETYPE_PEM        X509_FILETYPE_PEM  ->1
 755                          * #define SSL_FILETYPE_ASN1       X509_FILETYPE_ASN1 ->2
 756                          */
 757                         if (private_key_filetype_string == "SSL_FILETYPE_PEM") {
 758                                 /*-------- DEBUG LOG --------*/
 759                                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 760                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 47,
 761                                                 "function : static int getParameters("
 762                                                 "std::string config_filename) : "
 763                                                 "set SSL_FILETYPE_PEM.");
 764                                 }
 765                                 /*------ DEBUG LOG END ------*/
 766                                 private_key_filetype = boost::asio::ssl::context::pem;
 767                         } else if (private_key_filetype_string == "SSL_FILETYPE_ASN1") {
 768                                 /*-------- DEBUG LOG --------*/
 769                                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 770                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 48,
 771                                                 "function : static int getParameters("
 772                                                 "std::string config_filename) : "
 773                                                 "set SSL_FILETYPE_ASN1.");
 774                                 }
 775                                 /*------ DEBUG LOG END ------*/
 776                                 private_key_filetype = boost::asio::ssl::context::asn1;
 777                         } else {
 778                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 11,
 779                                                      "private_key_filetype convert error. [%s]",
 780                                                      private_key_filetype_string.c_str());
 781                                 throw -1;
 782                         }
 783                 } else {
 784                         LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 9,
 785                                             "private_key_filetype parameter not found. "
 786                                             "Use default value.");
 787                         private_key_filetype = DEFAULT_PRIVATE_KEY_FILETYPE;
 788                 }
 789
 790                 // Get parameter "private_key_passwd_from".
 791                 if (Parameter::getInstance().isStringExist(PARAM_COMP_SSLPROXY, "private_key_passwd_from")) {
 792                         private_key_passwd_from =
 793                                 Parameter::getInstance().getStringValue(PARAM_COMP_SSLPROXY,
 794                                                                         "private_key_passwd_from");
 795                         /*-------- DEBUG LOG --------*/
 796                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 797                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 49,
 798                                         "function : static int getParameters("
 799                                         "std::string config_filename) : "
 800                                         "get private_key_passwd_from OK.");
 801                         }
 802                         /*------ DEBUG LOG END ------*/
 803                         if (private_key_passwd_from == "") {
 804                                 LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 10,
 805                                                     "private_key_passwd_from parameter is nothing. "
 806                                                     "Use default value.");
 807                                 private_key_passwd_from = DEFAULT_PRIVATE_KEY_PASSWD_FROM;
 808                         } else if (private_key_passwd_from != "console" &&
 809                                    private_key_passwd_from != "file") {
 810                                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 12,
 811                                                              "Invalid private_key_passwd_from parameter value.");
 812                                         throw -1;
 813                         }
 814                 } else {
 815                                 LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 11,
 816                                                     "private_key_passwd_from parameter not found. "
 817                                                     "Use default value.");
 818                                 private_key_passwd_from = DEFAULT_PRIVATE_KEY_PASSWD_FROM;
 819                 }
 820
 821                 if (private_key_passwd_from == "file") {
 822                         // Get parameter "private_key_passwd_dir".
 823                         if (Parameter::getInstance().isStringExist(PARAM_COMP_SSLPROXY, "private_key_passwd_dir")) {
 824                                 private_key_passwd_dir =
 825                                         Parameter::getInstance().getStringValue(PARAM_COMP_SSLPROXY,
 826                                                                                 "private_key_passwd_dir");
 827                                 /*-------- DEBUG LOG --------*/
 828                                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 829                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 50,
 830                                                 "function : static int getParameters("
 831                                                 "std::string config_filename) : "
 832                                                 "get private_key_passwd_dir OK.");
 833                                 }
 834                                 /*------ DEBUG LOG END ------*/
 835                                 if (private_key_passwd_dir == "") {
 836                                         LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 12,
 837                                                             "private_key_passwd_dir parameter is nothing. "
 838                                                             "Use default value.");
 839                                         private_key_passwd_dir = DEFAULT_PRIVATE_KEY_DIR;
 840                                 }
 841                         } else {
 842                                 LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 13,
 843                                                     "private_key_passwd_dir parameter not found. "
 844                                                     "Use default value.");
 845                                 private_key_passwd_dir = DEFAULT_PRIVATE_KEY_PASSWD_DIR;
 846                         }
 847
 848                         // Get parameter "private_key_passwd_file".
 849                         if (Parameter::getInstance().isStringExist(PARAM_COMP_SSLPROXY, "private_key_passwd_file")) {
 850                                 private_key_passwd_file =
 851                                         Parameter::getInstance().getStringValue(PARAM_COMP_SSLPROXY,
 852                                                                                 "private_key_passwd_file");
 853                                 /*-------- DEBUG LOG --------*/
 854                                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 855                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 51,
 856                                                 "function : static int getParameters("
 857                                                 "std::string config_filename) : "
 858                                                 "get private_key_passwd_file OK.");
 859                                 }
 860                                 /*------ DEBUG LOG END ------*/
 861                                 if (private_key_passwd_file == "") {
 862                                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 13,
 863                                                              "private_key_passwd_file parameter is nothing.");
 864                                         throw -1;
 865                                 }
 866                         } else {
 867                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 14,
 868                                                      "Cannot get private_key_passwd_file parameter.");
 869                                 throw -1;
 870                         }
 871                 }
 872
 873                 // Get parameter "verify_options".
 874                 // Get map data and Convert string to integer and Make bit data.
 875                 if (Parameter::getInstance().isStringExist(PARAM_COMP_SSLPROXY, "verify_options")) {
 876                         std::multimap<std::string, std::string> vopMap;
 877                         Parameter::getInstance().getStringMapValue(PARAM_COMP_SSLPROXY,
 878                                                                    "verify_options",
 879                                                                    vopMap);
 880                         if (vopMap.size() != 0) {
 881                                 /*-------- DEBUG LOG --------*/
 882                                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 883                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 52,
 884                                                 "function : static int getParameters("
 885                                                 "std::string config_filename) : "
 886                                                 "get verify_options map OK.");
 887                                 }
 888                                 /*------ DEBUG LOG END ------*/
 889                                 for(std::multimap<std::string, std::string>::iterator stritr = vopMap.begin();
 890                                     stritr != vopMap.end();
 891                                     ++stritr ) {
 892                                         /*-------- DEBUG LOG --------*/
 893                                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 894                                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 53,
 895                                                         "function : "
 896                                                         "static int getParameters(std::string config_filename) : "
 897                                                         "verify option map key = %s, value = %s",
 898                                                         (stritr->first).c_str(),
 899                                                         (stritr->second).c_str());
 900                                         }
 901                                         /*------ DEBUG LOG END ------*/
 902                                         int retvop = convVerifyOption(stritr->second);
 903                                         if (retvop == -1) {
 904                                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 15,
 905                                                                      "verify_options convert error. [%s]",
 906                                                                      stritr->second.c_str());
 907                                                 throw -1;
 908                                         }
 909                                         verify_options = (verify_options | retvop);
 910                                 }
 911                         } else {
 912                                 LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 14,
 913                                                     "verify_options parameter is nothing. "
 914                                                     "Use default value.");
 915                                 verify_options = DEFAULT_VERIFY_OPTIONS;
 916                         }
 917                 } else {
 918                         LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 15,
 919                                             "verify_options parameter not found. "
 920                                             "Use default value.");
 921                         verify_options = DEFAULT_VERIFY_OPTIONS;
 922                 }
 923
 924                 // Get parameter "verify_cert_depth".
 925                 if (Parameter::getInstance().isIntExist(PARAM_COMP_SSLPROXY, "verify_cert_depth")) {
 926                         verify_cert_depth = Parameter::getInstance().getIntValue(PARAM_COMP_SSLPROXY,
 927                                                                                  "verify_cert_depth");
 928                         /*-------- DEBUG LOG --------*/
 929                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 930                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 54,
 931                                         "function : static int getParameters("
 932                                         "std::string config_filename) : "
 933                                         "get verify_cert_depth OK.");
 934                         }
 935                         /*------ DEBUG LOG END ------*/
 936                         if (verify_cert_depth < 0 || verify_cert_depth > INT_MAX) {
 937                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 16,
 938                                                      "Invalid verify_cert_depth parameter value.");
 939                                 throw -1;
 940                         }
 941                 } else {
 942                         LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 16,
 943                                             "verify_cert_depth parameter not found. "
 944                                             "Use default value.");
 945                         verify_cert_depth = DEFAULT_VERIFY_CERT_DEPTH;
 946                 }
 947
 948                 // Get parameter "ssl_options".
 949                 // Get map data and Convert string to integer and Make bit data.
 950                 // and Check dh parameter file use or not.
 951                 tmp_dh_use = false;
 952                 if (Parameter::getInstance().isStringExist(PARAM_COMP_SSLPROXY, "ssl_options")) {
 953                         std::multimap<std::string, std::string> sopMap;
 954                         Parameter::getInstance().getStringMapValue(PARAM_COMP_SSLPROXY,
 955                                                                    "ssl_options",
 956                                                                    sopMap);
 957                         if (sopMap.size() != 0) {
 958                                 /*-------- DEBUG LOG --------*/
 959                                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 960                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 55,
 961                                                 "function : static int getParameters("
 962                                                 "std::string config_filename) : "
 963                                                 "get ssl_options map OK.");
 964                                 }
 965                                 /*------ DEBUG LOG END ------*/
 966                                 for(std::multimap<std::string, std::string>::iterator stritr = sopMap.begin();
 967                                     stritr != sopMap.end();
 968                                     ++stritr ) {
 969                                         /*-------- DEBUG LOG --------*/
 970                                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 971                                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 56,
 972                                                         "function : "
 973                                                         "static int getParameters(std::string config_filename) : "
 974                                                         "SSL option map key = %s, value = %s",
 975                                                         (stritr->first).c_str(),
 976                                                         (stritr->second).c_str());
 977                                         }
 978                                         /*------ DEBUG LOG END ------*/
 979                                         long int retsop = convSslOption(stritr->second);
 980                                         if (retsop == -1) {
 981                                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 17,
 982                                                                      "ssl_options convert error. [%s]",
 983                                                                      stritr->second.c_str());
 984                                                 throw -1;
 985                                         }
 986                                         if (retsop == SSL_OP_SINGLE_DH_USE) {
 987                                                 /*-------- DEBUG LOG --------*/
 988                                                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
 989                                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 57,
 990                                                                 "function : "
 991                                                                 "static int getParameters(std::string config_filename) : "
 992                                                                 "tmp_dh_use is true.");
 993                                                 }
 994                                                 /*------ DEBUG LOG END ------*/
 995                                                 tmp_dh_use = true;
 996                                         }
 997                                         ssl_options = (ssl_options | retsop);
 998                                 }
 999                         } else {
1000                                 LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 17,
1001                                                     "ssl_options parameter is nothing. "
1002                                                     "Use default value.");
1003                                 ssl_options = DEFAULT_SSL_OPTIONS;
1004                                 tmp_dh_use = true;
1005                         }
1006                 } else {
1007                         LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 18,
1008                                             "ssl_options parameter not found. "
1009                                             "Use default value.");
1010                         ssl_options = DEFAULT_SSL_OPTIONS;
1011                         tmp_dh_use = true;
1012                 }
1013
1014                 if (tmp_dh_use == true) {
1015                         // Get parameter "tmp_dh_dir".
1016                         if (Parameter::getInstance().isStringExist(PARAM_COMP_SSLPROXY, "tmp_dh_dir")) {
1017                                 tmp_dh_dir = Parameter::getInstance().getStringValue(PARAM_COMP_SSLPROXY,
1018                                                                                      "tmp_dh_dir");
1019                                 /*-------- DEBUG LOG --------*/
1020                                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1021                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 58,
1022                                                 "function : static int getParameters("
1023                                                 "std::string config_filename) : "
1024                                                 "get tmp_dh_dir OK.");
1025                                 }
1026                                 /*------ DEBUG LOG END ------*/
1027                                 if (tmp_dh_dir == "") {
1028                                         LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 19,
1029                                                             "tmp_dh_dir parameter is nothing. "
1030                                                             "Use default value.");
1031                                         tmp_dh_dir = DEFAULT_TMP_DH_DIR;
1032                                 }
1033                         } else {
1034                                 LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 20,
1035                                                     "tmp_dh_dir parameter not found. "
1036                                                     "Use default value.");
1037                                 tmp_dh_dir = DEFAULT_TMP_DH_DIR;
1038                         }
1039
1040                         // Get parameter "tmp_dh_file".
1041                         if (Parameter::getInstance().isStringExist(PARAM_COMP_SSLPROXY, "tmp_dh_file")) {
1042                                 tmp_dh_file = Parameter::getInstance().getStringValue(PARAM_COMP_SSLPROXY,
1043                                                                                       "tmp_dh_file");
1044                                 /*-------- DEBUG LOG --------*/
1045                                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1046                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 59,
1047                                                 "function : static int getParameters("
1048                                                 "std::string config_filename) : "
1049                                                 "get tmp_dh_file OK.");
1050                                 }
1051                                 /*------ DEBUG LOG END ------*/
1052                                 if (tmp_dh_file == "") {
1053                                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 18,
1054                                                              "tmp_dh_file parameter is nothing.");
1055                                         throw -1;
1056                                 }
1057                         } else {
1058                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 19,
1059                                                      "Cannot get tmp_dh_file parameter.");
1060                                 throw -1;
1061                         }
1062                 }
1063
1064                 // Get parameter "cipher_list".
1065                 if (Parameter::getInstance().isStringExist(PARAM_COMP_SSLPROXY, "cipher_list")) {
1066                         cipher_list = Parameter::getInstance().getStringValue(PARAM_COMP_SSLPROXY,
1067                                                                               "cipher_list");
1068                         /*-------- DEBUG LOG --------*/
1069                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1070                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 60,
1071                                         "function : static int getParameters("
1072                                         "std::string config_filename) : "
1073                                         "get cipher_list OK.");
1074                         }
1075                         /*------ DEBUG LOG END ------*/
1076                         if (cipher_list == "") {
1077                                 LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 21,
1078                                                     "cipher_list parameter is nothing. "
1079                                                     "Use default value.");
1080                                 cipher_list = DEFAULT_CIPHER_LIST;
1081                         }
1082                 } else {
1083                         LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 22,
1084                                             "cipher_list parameter not found. "
1085                                             "Use default value.");
1086                         cipher_list = DEFAULT_CIPHER_LIST;
1087                 }
1088
1089                 // Get parameter "session_cache".
1090                 if (Parameter::getInstance().isStringExist(PARAM_COMP_SSLPROXY, "session_cache")) {
1091                         std::string session_cache = Parameter::getInstance().getStringValue(PARAM_COMP_SSLPROXY,
1092                                                                                 "session_cache");
1093                         /*-------- DEBUG LOG --------*/
1094                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1095                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 97,
1096                                         "function : static int getParameters("
1097                                         "std::string config_filename) : "
1098                                         "get session_cache OK.");
1099                         }
1100                         /*------ DEBUG LOG END ------*/
1101                         if (session_cache == "") {
1102                                 LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 25,
1103                                                     "session_cache parameter is nothing. "
1104                                                     "Use default value.");
1105                                 session_cache_mode = DEFAULT_SESSION_CACHE_MODE;
1106                         } else if (session_cache == "on") {
1107                                 session_cache_mode = SSL_SESS_CACHE_SERVER;
1108                         } else if (session_cache == "off") {
1109                                 session_cache_mode = SSL_SESS_CACHE_OFF;
1110                         } else {
1111                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 47,
1112                                                      "Invalid session_cache parameter value.");
1113                                 throw -1;
1114                         }
1115                 } else {
1116                         LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 26,
1117                                             "session_cache parameter not found. "
1118                                             "Use default value.");
1119                         session_cache_mode = DEFAULT_SESSION_CACHE_MODE;
1120                 }
1121
1122                 // Get parameter "session_cache_size".
1123                 if (Parameter::getInstance().isIntExist(PARAM_COMP_SSLPROXY, "session_cache_size")) {
1124                         session_cache_size = Parameter::getInstance().getIntValue(PARAM_COMP_SSLPROXY,
1125                                                                           "session_cache_size");
1126                         /*-------- DEBUG LOG --------*/
1127                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1128                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 98,
1129                                         "function : static int getParameters("
1130                                         "std::string config_filename) : "
1131                                         "get session_cache_size OK.");
1132                         }
1133                         /*------ DEBUG LOG END ------*/
1134                         if (session_cache_size < 0 || session_cache_size > LONG_MAX) {
1135                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 48,
1136                                                      "Invalid session_cache_size parameter value.");
1137                                 throw -1;
1138                         }
1139                 } else {
1140                         LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 27,
1141                                             "session_cache_size parameter not found. "
1142                                             "Use default value.");
1143                         session_cache_size = DEFAULT_SESSION_CACHE_SIZE;
1144                 }
1145
1146                 // Get parameter "session_cache_timeout".
1147                 if (Parameter::getInstance().isIntExist(PARAM_COMP_SSLPROXY, "session_cache_timeout")) {
1148                         session_cache_timeout = Parameter::getInstance().getIntValue(PARAM_COMP_SSLPROXY,
1149                                                                           "session_cache_timeout");
1150                         /*-------- DEBUG LOG --------*/
1151                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1152                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 99,
1153                                         "function : static int getParameters("
1154                                         "std::string config_filename) : "
1155                                         "get session_cache_timeout OK.");
1156                         }
1157                         /*------ DEBUG LOG END ------*/
1158                         if (session_cache_timeout < 0 || session_cache_timeout > LONG_MAX) {
1159                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 49,
1160                                                      "Invalid session_cache_timeout parameter value.");
1161                                 throw -1;
1162                         }
1163                 } else {
1164                         LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 28,
1165                                             "session_cache_timeout parameter not found. "
1166                                             "Use default value.");
1167                         session_cache_timeout = DEFAULT_SESSION_CACHE_TIMEOUT;
1168                 }
1169
1170                 // Get parameter "conn_log_flag".
1171                 if (Parameter::getInstance().isStringExist(PARAM_COMP_LOGGER, "conn_log_flag")) {
1172                         conn_log_flag = Parameter::getInstance().getStringValue(PARAM_COMP_LOGGER,
1173                                                                                 "conn_log_flag");
1174                         /*-------- DEBUG LOG --------*/
1175                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1176                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 61,
1177                                         "function : static int getParameters("
1178                                         "std::string config_filename) : "
1179                                         "get conn_log_flag OK.");
1180                         }
1181                         /*------ DEBUG LOG END ------*/
1182                         if (conn_log_flag == "") {
1183                                 LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 23,
1184                                                     "conn_log_flag parameter is nothing. "
1185                                                     "Use default value.");
1186                                 conn_log_flag = DEFAULT_CONN_LOG_FLAG;
1187                         } else if (conn_log_flag != "on" && conn_log_flag != "off") {
1188                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 20,
1189                                                      "Invalid conn_log_flag parameter value.");
1190                                 throw -1;
1191                         }
1192                 } else {
1193                         LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 24,
1194                                             "conn_log_flag parameter not found. "
1195                                             "Use default value.");
1196                         conn_log_flag = DEFAULT_CONN_LOG_FLAG;
1197                 }
1198
1199                 // Get parameter "edit_client_msg".
1200                 if (Parameter::getInstance().isStringExist(PARAM_COMP_SSLPROXY, "edit_client_msg")) {
1201                         std::string edit_client = Parameter::getInstance().getStringValue(PARAM_COMP_SSLPROXY,
1202                                                                          "edit_client_msg");
1203                         /*-------- DEBUG LOG --------*/
1204                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1205                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 40, // XXX fix log
1206                                         "function : static int getParameters("
1207                                         "std::string config_filename) : "
1208                                         "get edit_client_msg OK.");
1209                         }
1210                         /*------ DEBUG LOG END ------*/
1211                         if (edit_client == "") {
1212                                 LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 23, // XXX fix log
1213                                                     "edit_client_msg parameter is nothing. "
1214                                                     "Use default value.");
1215                                 edit_client_msg = DEFAULT_EDIT_CLIENT_MSG;
1216                         } else if (edit_client != "on" && edit_client != "off") {
1217                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 20, // XXX fix log
1218                                                      "Invalid edit_client_msg parameter value.");
1219                                 throw -1;
1220                         }
1221                         if (edit_client == "on")
1222                                 edit_client_msg = true;
1223                         else
1224                                 edit_client_msg = false;
1225                 } else {
1226                         LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 999, // XXX fix log
1227                                             "edit_client_msg parameter not found. "
1228                                             "Use default value.");
1229                         edit_client_msg = DEFAULT_EDIT_CLIENT_MSG;
1230                 }
1231
1232                 // Get parameter "edit_server_msg".
1233                 if (Parameter::getInstance().isStringExist(PARAM_COMP_SSLPROXY, "edit_server_msg")) {
1234                         std::string edit_server = Parameter::getInstance().getStringValue(PARAM_COMP_SSLPROXY,
1235                                                                          "edit_server_msg");
1236                         /*-------- DEBUG LOG --------*/
1237                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1238                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 40, // XXX fix log
1239                                         "function : static int getParameters("
1240                                         "std::string config_filename) : "
1241                                         "get edit_server_msg OK.");
1242                         }
1243                         /*------ DEBUG LOG END ------*/
1244                         if (edit_server == "") {
1245                                 LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 23, // XXX fix log
1246                                                     "edit_server_msg parameter is nothing. "
1247                                                     "Use default value.");
1248                                 edit_server_msg = DEFAULT_EDIT_SERVER_MSG;
1249                         } else if (edit_server != "on" && edit_server != "off") {
1250                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 20, // XXX fix log
1251                                                      "Invalid edit_server_msg parameter value.");
1252                                 throw -1;
1253                         }
1254                         if (edit_server == "on")
1255                                 edit_server_msg = true;
1256                         else
1257                                 edit_server_msg = false;
1258                 } else {
1259                         LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 999, // XXX fix log
1260                                             "edit_server_msg parameter not found. "
1261                                             "Use default value.");
1262                         edit_server_msg = DEFAULT_EDIT_SERVER_MSG;
1263                 }
1264
1265                 // Get parameter "x_forwarded_for_mode".
1266                 if (Parameter::getInstance().isStringExist(PARAM_COMP_SSLPROXY, "x_forwarded_for_mode")) {
1267                         std::string x_forwarded = Parameter::getInstance().getStringValue(PARAM_COMP_SSLPROXY,
1268                                                                                 "x_forwarded_for_mode");
1269                         /*-------- DEBUG LOG --------*/
1270                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1271                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 61, // XXX fix log
1272                                         "function : static int getParameters("
1273                                         "std::string config_filename) : "
1274                                         "get x_forwarded_for_mode OK.");
1275                         }
1276                         /*------ DEBUG LOG END ------*/
1277                         if (x_forwarded == "") {
1278                                 LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_COMMON, 23, // XXX fix log
1279                                                     "x_forwarded_for_mode parameter is nothing. "
1280                                                     "Use default value.");
1281                                 x_forwarded_for_mode = DEFAULT_X_FORWARDED_FOR_MODE;
1282                         } else if (x_forwarded != "add") {
1283                                 x_forwarded_for_mode = ADD_X_FORWARDED_FOR;
1284                         } else if (x_forwarded != "set") {
1285                                 x_forwarded_for_mode = SET_X_FORWARDED_FOR;
1286                         } else if (x_forwarded != "delete") {
1287                                 x_forwarded_for_mode = DELETE_X_FORWARDED_FOR;
1288                         } else if (x_forwarded != "none") {
1289                                 x_forwarded_for_mode = NONE_X_FORWARDED_FOR;
1290                         } else {
1291                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 20, // XXX fix log
1292                                                      "Invalid x_forwarded_for_mode parameter value.");
1293                                 throw -1;
1294                         }
1295                 } else {
1296                         x_forwarded_for_mode = DEFAULT_X_FORWARDED_FOR_MODE;
1297                 }
1298         } catch (int e) {
1299                 /*-------- DEBUG LOG --------*/
1300                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1301                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 62,
1302                                 "function : "
1303                                 "static int getParameters(std::string config_filename) : "
1304                                 "Catch exception e = %d.",
1305                                 e);
1306                 }
1307                 /*------ DEBUG LOG END ------*/
1308                 ret = -1;
1309         }
1310         /*-------- DEBUG LOG --------*/
1311         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1312                 std::ostringstream oss;
1313                 oss <<
1314                 "  recv_endpoint = "            << recv_endpoint                <<
1315                 ", target_endpoint = "          << target_endpoint              <<
1316                 ", num_thread = "               << num_thread                   <<
1317                 ", timout_sec = "               << timeout_sec                  <<
1318                 ", ca_dir = "                   << ca_dir                       <<
1319                 ", ca_file = "                  << ca_file                      <<
1320                 ", cert_chain_dir = "           << cert_chain_dir               <<
1321                 ", cert_chain_file = "          << cert_chain_file              <<
1322                 ", private_key_dir = "          << private_key_dir              <<
1323                 ", private_key_file = "         << private_key_file             <<
1324                 ", private_key_filetype = "     << private_key_filetype         <<
1325                 ", private_key_passwd_from = "  << private_key_passwd_from      <<
1326                 ", private_key_passwd_dir = "   << private_key_passwd_dir       <<
1327                 ", private_key_passwd_file = "  << private_key_passwd_file      <<
1328                 ", verify_options = "           << verify_options               <<
1329                 ", verify_cert_depth = "        << verify_cert_depth            <<
1330                 ", ssl_options = "              << ssl_options                  <<
1331                 ", tmp_dh_dir = "               << tmp_dh_dir                   <<
1332                 ", tmp_dh_file = "              << tmp_dh_file                  <<
1333                 ", cipher_list = "              << cipher_list                  <<
1334                 ", session_cache_mode = "       << session_cache_mode           <<
1335                 ", session_cache_size = "       << session_cache_size           <<
1336                 ", session_cache_timeout = "    << session_cache_timeout        <<
1337                 ", conn_log_flag = "            << conn_log_flag;
1338                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 63,
1339                         "out_function : "
1340                         "static int getParameters(std::string config_filename) : "
1341                         "return value = %d : "
1342                         "parameter value %s",
1343                         ret,
1344                         oss.str().c_str());
1345         }
1346         /*------ DEBUG LOG END ------*/
1347         return ret;
1348 }
1349
1350 /*!
1351  * Split endpoint data to host and port string.
1352  *
1353  * @param[in]   endpoint_str    endpoint string
1354  * @param[out]  host    host string
1355  * @param[out]  port    port string
1356  * @retval      0       success
1357  * @retval      -1      failed
1358  */
1359 static int splitEndpoint(std::string endpoint_str, std::string& host, std::string& port)
1360 {
1361         /*-------- DEBUG LOG --------*/
1362         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1363                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 64,
1364                         "in_function : "
1365                         "static int splitEndpoint"
1366                         "(std::string endpoint_str, std::string& host, std::string& port) : "
1367                         "endpoint_str = %s",
1368                         endpoint_str.c_str());
1369         }
1370         /*------ DEBUG LOG END ------*/
1371
1372         int ret = 0;
1373         try {
1374                 int mark = endpoint_str.find_first_of(":");
1375                 if (mark == -1) {
1376                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 21, "Delimitation not found.");
1377                         throw -1;
1378                 }
1379                 if (mark <= 0) {
1380                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 22, "Host string not found.");
1381                         throw -1;
1382                 }
1383                 host = endpoint_str.substr(0, mark);
1384                 port = endpoint_str.substr(mark + 1);
1385                 /*-------- DEBUG LOG --------*/
1386                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1387                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 65,
1388                                 "function : "
1389                                 "static int splitEndpoint"
1390                                 "(std::string endpoint_str, std::string& host, std::string& port) : "
1391                                 "set host and port string");
1392                 }
1393                 /*------ DEBUG LOG END ------*/
1394                 if (port.length() <= 0) {
1395                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 23, "Port string not found.");
1396                         throw -1;
1397                 }
1398         } catch (int e) {
1399                 /*-------- DEBUG LOG --------*/
1400                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1401                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 66,
1402                                 "function : "
1403                                 "static int splitEndpoint"
1404                                 "(std::string endpoint_str, std::string& host, std::string& port) : "
1405                                 "Catch exception e = %d.",
1406                                 e);
1407                 }
1408                 /*------ DEBUG LOG END ------*/
1409                 ret = -1;
1410         }
1411
1412         /*-------- DEBUG LOG --------*/
1413         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1414                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 67,
1415                         "out_function : "
1416                         "static int splitEndpoint"
1417                         "(std::string endpoint_str, std::string& host, std::string& port) : "
1418                         "return value ret = %d : "
1419                         "host = %s, "
1420                         "port = %s",
1421                         ret,
1422                         host.c_str(),
1423                         port.c_str());
1424         }
1425         /*------ DEBUG LOG END ------*/
1426         return ret;
1427 }
1428
1429 /*!
1430  * exit signal handler
1431  *
1432  * @param[in]   sig     signal
1433  * @return      void
1434  */
1435 static void sig_exit_handler(int sig)
1436 {
1437         /*-------- DEBUG LOG --------*/
1438         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1439                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 68,
1440                         "in_function : static void sig_exit_handler(int sig) "
1441                         "sig = %d",
1442                         sig);
1443         }
1444         /*------ DEBUG LOG END ------*/
1445         int retexit;
1446
1447         if (sig == SIGTERM) {
1448                 LOGGER_PUT_LOG_INFO(LOG_CAT_SSLPROXY_COMMON, 1, "SIGTERM received.");
1449                 retexit = EXIT_SUCCESS;
1450         } else {
1451                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 24, "Signal received. signal=%d.", sig);
1452                 retexit = EXIT_FAILURE;
1453         }
1454
1455         fflush(stdout);
1456         fsync(1);
1457
1458         /*-------- DEBUG LOG --------*/
1459         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1460                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 69,
1461                         "out_function : static void sig_exit_handler(int sig) : "
1462                         "exit_value = %d",
1463                         retexit);
1464         }
1465         /*------ DEBUG LOG END ------*/
1466         _exit(retexit);
1467 }
1468
1469 /*!
1470  * setup signal handler
1471  *
1472  * @param[in]   sig     signal
1473  * @param[in]   handler signal handler
1474  * @retval       0 succeed
1475  * @retval      -1 failed
1476  */
1477 static int set_sighandler(int sig, void (*handler)(int))
1478 {
1479         /*-------- DEBUG LOG --------*/
1480         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1481                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 70,
1482                         "in_function : static int set_sighandler(int sig, void (*handler)(int)) "
1483                         "sig = %d: "
1484                         "handler = %p",
1485                         sig, handler);
1486         }
1487         /*------ DEBUG LOG END ------*/
1488
1489         struct sigaction act;
1490         int ret;
1491
1492         /*-------- DEBUG LOG --------*/
1493         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1494                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 71,
1495                         "sigaction : sig = %d : act = NULL",
1496                         sig);
1497         }
1498         /*------ DEBUG LOG END ------*/
1499         ret = sigaction(sig, NULL, &act);
1500         if (ret < 0) {
1501                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 25, "sigaction on signal %d failed", sig);
1502                 /*-------- DEBUG LOG --------*/
1503                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1504                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 72,
1505                                 "out_function : static int set_sighandler(int sig, void (*handler)(int)) "
1506                                 "return_value : %d",
1507                                 ret);
1508                 }
1509                 /*------ DEBUG LOG END ------*/
1510                 return ret;
1511         }
1512         act.sa_flags &= ~SA_RESETHAND;
1513         act.sa_handler = handler;
1514
1515         /*-------- DEBUG LOG --------*/
1516         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1517                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 73,
1518                         "sigaction : sig=%d: act.sa_flags=%d, act.sa_handler=%p",
1519                         sig, act.sa_flags, act.sa_handler);
1520         }
1521         /*------ DEBUG LOG END ------*/
1522         ret = sigaction(sig, &act, NULL);
1523         if (ret < 0) {
1524                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 26, "sigaction on signal %d failed", sig);
1525                 /*-------- DEBUG LOG --------*/
1526                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1527                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 74,
1528                                 "out_function : static int set_sighandler(int sig, void (*handler)(int)) "
1529                                 "return_value : %d",
1530                                 ret);
1531                 }
1532                 /*------ DEBUG LOG END ------*/
1533                 return ret;
1534         }
1535
1536         /*-------- DEBUG LOG --------*/
1537         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1538                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 75,
1539                         "out_function : static int set_sighandler(int sig, void (*handler)(int)) "
1540                         "return_value : 0");
1541         }
1542         /*------ DEBUG LOG END ------*/
1543         return 0;
1544 }
1545
1546 /*!
1547  * setup all signal handlers
1548  *
1549  * @param[in]   void
1550  * @retval       0 succeed
1551  * @retval      -1 failed
1552  */
1553 static int set_sighandlers(void)
1554 {
1555         /*-------- DEBUG LOG --------*/
1556         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1557                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 76,
1558                         "in_function : static int set_sighandlers(void) ");
1559         }
1560         /*------ DEBUG LOG END ------*/
1561         int ret;
1562
1563 #define SET_SIGHANDLER(sig, handler)                                                            \
1564         do {                                                                                    \
1565                 ret = set_sighandler((sig), (handler));                                         \
1566                 if (ret < 0) {                                                                  \
1567                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {    \
1568                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 77,               \
1569                                         "out_function : static int set_sighandlers(void) "      \
1570                                         "return_value : %d",                                    \
1571                                         ret);                                                   \
1572                         }                                                                       \
1573                         return ret;                                                             \
1574                 }                                                                               \
1575         } while (0)
1576
1577         SET_SIGHANDLER(SIGHUP,  sig_exit_handler);
1578         SET_SIGHANDLER(SIGINT,  sig_exit_handler);
1579         SET_SIGHANDLER(SIGQUIT, sig_exit_handler);
1580         SET_SIGHANDLER(SIGTERM, sig_exit_handler);
1581         SET_SIGHANDLER(SIGUSR1, SIG_IGN);
1582         SET_SIGHANDLER(SIGUSR2, SIG_IGN);
1583         SET_SIGHANDLER(SIGALRM, SIG_IGN);
1584         SET_SIGHANDLER(SIGCHLD, SIG_IGN);
1585
1586 #undef SET_SIGHANDLER
1587
1588         /*-------- DEBUG LOG --------*/
1589         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1590                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 78,
1591                         "out_function : static int set_sighandlers(void) "
1592                         "return_value : 0");
1593         }
1594         /*------ DEBUG LOG END ------*/
1595         return 0;
1596 }
1597
1598 /*!
1599  * Show usage.
1600  *
1601  */
1602 static void usage(void)
1603 {
1604         /*-------- DEBUG LOG --------*/
1605         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1606                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 79,
1607                         "in_function : static void usage(void)");
1608         }
1609         /*------ DEBUG LOG END ------*/
1610
1611         std::cerr << "Usage   : " << "sslproxy <target_id> <config_filename>" << std::endl;
1612         std::cerr << "Example : " << "sslproxy target_1 /etc/l7vs/sslproxy/sslproxy.target_1.cf" << std::endl;
1613
1614         /*-------- DEBUG LOG --------*/
1615         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1616                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 80,
1617                         "out_function : static void usage(void) "
1618                         "return_value = void");
1619         }
1620         /*------ DEBUG LOG END ------*/
1621 }
1622
1623 /*!
1624  * SSLproxy main function.
1625  *
1626  * @param[in]   argc    number of argument
1627  * @param[in]   *argv[] array of argument string
1628  */
1629 void sslproxy_main(int argc, char* argv[])
1630 {
1631         /*-------- DEBUG LOG --------*/
1632         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1633                 std::ostringstream oss;
1634                 oss << "argc = " <<  argc;
1635                 for (int i = 0; i < argc; i++) {
1636                         oss << ", arg[" << i << "] = " << argv[i];
1637                 }
1638                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 81,
1639                         "in_function : void sslproxy_main(int argc, char* argv[]) : "
1640                         "%s",
1641                         oss.str().c_str());
1642         }
1643         /*------ DEBUG LOG END ------*/
1644
1645         int result = EXIT_SUCCESS;
1646         int log_msg_id = 0;
1647         std::string function_str = "";
1648
1649         try {
1650                 // Set max file open num
1651                 struct rlimit lim;
1652                 if (getrlimit( RLIMIT_NOFILE, &lim ) == 0) {
1653                         if (lim.rlim_cur < DEFAULT_MAX_FILE_NUM) {
1654                                 lim.rlim_cur = DEFAULT_MAX_FILE_NUM;
1655                         }
1656                         if (lim.rlim_max < DEFAULT_MAX_FILE_NUM) {
1657                                 lim.rlim_max = DEFAULT_MAX_FILE_NUM;
1658                         }
1659                         if (setrlimit( RLIMIT_NOFILE, &lim ) != 0) {
1660                                 std::cerr << "Set max file open num error." << std::endl;
1661                                 throw EXIT_FAILURE;
1662                         }
1663                 } else {
1664                         std::cerr << "Get max file open num error." << std::endl;
1665                         throw EXIT_FAILURE;
1666                 }
1667
1668                 // Argument check.
1669                 if (argc != 3) {
1670                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 27, "Argument argc is illegal.");
1671                         std::cerr << "Argument argc is illegal." << std::endl;
1672                         usage();
1673                         throw EXIT_FAILURE;
1674                 }
1675
1676                 // Check argument 1. (target_id)
1677                 if (strlen(argv[1]) > MAX_TARGET_ID_SIZE) {
1678                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 28, "Target_id is too long.");
1679                         std::cerr << "Target_id is too long." << std::endl;
1680                         throw EXIT_FAILURE;
1681                 }
1682                 target_id = argv[1];
1683
1684                 // Check argument 2. (config file)
1685                 if (argv[2][0] != '/') {
1686                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 29,
1687                                 "Need specify config file in full path. %s", target_id.c_str());
1688                         std::cerr << "Need specify config file in full path. " << target_id << std::endl;
1689                         throw EXIT_FAILURE;
1690                 }
1691                 FILE  *fp;
1692                 if ((fp = fopen(argv[2], "r")) == NULL) {
1693                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 30,
1694                                 "Config file cannot open. %s", target_id.c_str());
1695                         std::cerr << "Config file cannot open. " << target_id << std::endl;
1696                         throw EXIT_FAILURE;
1697                 }
1698                 fclose(fp);
1699                 std::string config_filename = argv[2];
1700
1701                 /*-------- DEBUG LOG --------*/
1702                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1703                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 82,
1704                                 "function : void sslproxy_main(int argc, char* argv[]) : "
1705                                 "Argument check END. "
1706                                 "target_id = %s, "
1707                                 "config_filename = %s",
1708                                 target_id.c_str(),
1709                                 config_filename.c_str());
1710                 }
1711                 /*------ DEBUG LOG END ------*/
1712
1713                 // Get config parameters.
1714                 if (getParameters(config_filename) == -1) {
1715                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 31,
1716                                 "Get parameter error. %s", target_id.c_str());
1717                         std::cerr << "Get parameter error. " << target_id << std::endl;
1718                         throw EXIT_FAILURE;
1719                 }
1720
1721                 /*-------- DEBUG LOG --------*/
1722                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1723                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 83,
1724                                 "function : void sslproxy_main(int argc, char* argv[]) : "
1725                                 "Get parameter END.");
1726                 }
1727                 /*------ DEBUG LOG END ------*/
1728
1729                 // Set signal handlers.
1730                 if (set_sighandlers() < 0) {
1731                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 32,
1732                                 "Set signal handler error. %s", target_id.c_str());
1733                         std::cerr << "Set signal handler error. " << target_id << std::endl;
1734                         throw EXIT_FAILURE;
1735                 }
1736
1737                 /*-------- DEBUG LOG --------*/
1738                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1739                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 84,
1740                                 "function : void sslproxy_main(int argc, char* argv[]) : "
1741                                 "Set signal END.");
1742                 }
1743                 /*------ DEBUG LOG END ------*/
1744
1745                 // Check target endpoint id duplication.
1746                 // Read all sslproxy process and target id is extracted.
1747                 if ((fp = popen(TARGET_ID_CHECK_STRING, "r")) == NULL) {
1748                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 33,
1749                                 "popen error. %s", target_id.c_str());
1750                         std::cerr << "popen error. " << target_id << std::endl;
1751                         throw EXIT_FAILURE;
1752                 }
1753                 char key[MAX_TARGET_ID_SIZE], buf[MAX_TARGET_ID_SIZE];
1754                 int match_cnt = 0;
1755                 while (fgets(buf, MAX_TARGET_ID_SIZE, fp) != NULL) {
1756                         /*-------- DEBUG LOG --------*/
1757                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1758                                 std::string buf_str = buf;
1759                                 buf_str.erase(buf_str.size() - 1, 1);
1760                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 85,
1761                                         "function : void sslproxy_main(int argc, char* argv[]) : "
1762                                         "Target id of executing process = %s.",
1763                                         buf_str.c_str());
1764                         }
1765                         /*------ DEBUG LOG END ------*/
1766                         sprintf(key, "%s\n", target_id.c_str());
1767                         if (strcmp(key, buf) == 0) {
1768                                 /*-------- DEBUG LOG --------*/
1769                                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1770                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 86,
1771                                                 "function : void sslproxy_main(int argc, char* argv[]) : "
1772                                                 "Same target id found.");
1773                                 }
1774                                 /*------ DEBUG LOG END ------*/
1775                                 // Count same target id process.
1776                                 match_cnt++;
1777                         }
1778                         // Duplication error when the one the same besides oneself exists.
1779                         if (match_cnt > 1) {
1780                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 34,
1781                                         "sslproxy process is already exist. %s", target_id.c_str());
1782                                 std::cerr << "sslproxy process is already exist. " << target_id << std::endl;
1783                                 pclose(fp);
1784                                 throw EXIT_FAILURE;
1785                         }
1786                 }
1787                 pclose(fp);
1788
1789                 /*-------- DEBUG LOG --------*/
1790                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1791                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 87,
1792                                 "function : void sslproxy_main(int argc, char* argv[]) : "
1793                                 "Check target id END.");
1794                 }
1795                 /*------ DEBUG LOG END ------*/
1796
1797                 // SSLproxy server initialize and setting.
1798                 // IO event dispatcher class.
1799                 boost::asio::io_service ioservice;
1800
1801                 // resolver class.
1802                 log_msg_id = 39;
1803                 function_str = "resolver()";
1804                 boost::asio::ip::tcp::resolver resolver(ioservice);
1805
1806                 std::string hoststr;
1807                 std::string portstr;
1808
1809                 // Target endpoint -> hoststr:portstr
1810                 if (splitEndpoint(target_endpoint, hoststr, portstr) == -1) {
1811                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 35,
1812                                 "Invalid target_endpoint. [%s]", target_id.c_str());
1813                         std::cerr << "Invalid target_endpoint. [" << target_id << "]" << std::endl;
1814                         throw EXIT_FAILURE;
1815                 }
1816
1817                 // query class for target.
1818                 log_msg_id = 40;
1819                 function_str = "target_query()";
1820                 boost::asio::ip::tcp::resolver::query target_query(boost::asio::ip::tcp::v4(), hoststr, portstr);
1821
1822                 // query result for target. (iterator)
1823                 log_msg_id = 41;
1824                 function_str = "Target resolver.resolve()";
1825                 boost::asio::ip::tcp::resolver::iterator target_itr = resolver.resolve(target_query);
1826
1827                 // query result for target. (endpoint_type)
1828                 boost::asio::ip::tcp::resolver::endpoint_type target_entry = *target_itr;
1829                 /*-------- DEBUG LOG --------*/
1830                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1831                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 88,
1832                                 "function : void sslproxy_main(int argc, char* argv[]) : "
1833                                 "Check target_endpoint END. "
1834                                 "%s:%d",
1835                                 target_entry.address().to_string().c_str(),
1836                                 target_entry.port());
1837                 }
1838                 /*------ DEBUG LOG END ------*/
1839
1840                 // Recv endpoint -> hoststr:portstr
1841                 if (splitEndpoint(recv_endpoint, hoststr, portstr) == -1) {
1842                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 36,
1843                                 "Invalid recv_endpoint. [%s]", target_id.c_str());
1844                         std::cerr << "Invalid recv_endpoint. [" << target_id << "]" << std::endl;
1845                         throw EXIT_FAILURE;
1846                 }
1847
1848                 // query class for recv.
1849                 log_msg_id = 42;
1850                 function_str = "recv_query()";
1851                 boost::asio::ip::tcp::resolver::query recv_query(boost::asio::ip::tcp::v4(), hoststr, portstr);
1852
1853                 // query result for recv. (iterator)
1854                 log_msg_id = 43;
1855                 function_str = "Recv resolver.resolve()";
1856                 boost::asio::ip::tcp::resolver::iterator recv_itr = resolver.resolve(recv_query);
1857
1858                 // query result for recv. (endpoint_type)
1859                 boost::asio::ip::tcp::resolver::endpoint_type recv_entry = *recv_itr;
1860                 /*-------- DEBUG LOG --------*/
1861                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1862                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 89,
1863                                 "function : void sslproxy_main(int argc, char* argv[]) : "
1864                                 "Check recv_endpoint END. "
1865                                 "%s:%d",
1866                                 recv_entry.address().to_string().c_str(),
1867                                 recv_entry.port());
1868                 }
1869                 /*------ DEBUG LOG END ------*/
1870
1871                 // Create sslproxy_server and create SSLcontext.
1872                 log_msg_id = 44;
1873                 function_str = "Create sslproxy_server";
1874                 sslproxy_server server(ioservice, target_itr, recv_entry);
1875
1876                 /*-------- DEBUG LOG --------*/
1877                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1878                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 90,
1879                                 "function : void sslproxy_main(int argc, char* argv[]) : "
1880                                 "Create sslproxy_server END.");
1881                 }
1882                 /*------ DEBUG LOG END ------*/
1883
1884                 // Daemon start.
1885                 if (daemon(1, 1) < 0) {
1886                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 37,
1887                                 "Start daemon() error. [%s]",
1888                                 target_id.c_str());
1889                         std::cerr << "Start daemon() error. [" << target_id << "]" << std::endl;
1890                         throw EXIT_FAILURE;
1891                 }
1892                 /*-------- DEBUG LOG --------*/
1893                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1894                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 91,
1895                                 "function : void sslproxy_main(int argc, char* argv[]) : "
1896                                 "Start daemon END.");
1897                 }
1898                 /*------ DEBUG LOG END ------*/
1899
1900                 // Create threads for IO event dispatcher.
1901                 // Threadgroup class. (thread pool)
1902                 boost::thread_group threadgroup;
1903
1904                 // Create num_thread threads.
1905                 log_msg_id = 45;
1906                 function_str = "create_thread()";
1907                 for (int i = 0; i < num_thread; ++i) {
1908                         threadgroup.create_thread(boost::bind(&boost::asio::io_service::run, &ioservice));
1909                         /*-------- DEBUG LOG --------*/
1910                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1911                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 92,
1912                                         "function : void sslproxy_main(int argc, char* argv[]) : "
1913                                         "Thread %d create.",
1914                                         i);
1915                         }
1916                         /*------ DEBUG LOG END ------*/
1917                 }
1918
1919                 /*-------- DEBUG LOG --------*/
1920                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1921                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 93,
1922                                 "function : void sslproxy_main(int argc, char* argv[]) : "
1923                                 "Create threads END.");
1924                 }
1925                 /*------ DEBUG LOG END ------*/
1926
1927                 LOGGER_PUT_LOG_INFO(LOG_CAT_SSLPROXY_COMMON, 2,
1928                                 "SSLproxy process start success. %s",
1929                                 target_id.c_str());
1930
1931                 // Wait for threads finish.
1932                 log_msg_id = 46;
1933                 function_str = "join_all()";
1934                 threadgroup.join_all();
1935
1936                 /*-------- DEBUG LOG --------*/
1937                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1938                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 94,
1939                                 "function : void sslproxy_main(int argc, char* argv[]) : "
1940                                 "join_all END.");
1941                 }
1942                 /*------ DEBUG LOG END ------*/
1943
1944         } catch (std::exception& e) {
1945                 std::cerr << function_str << " error : " << e.what() << "." << std::endl;
1946                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, log_msg_id,
1947                         "%s error : %s.", function_str.c_str(), e.what());
1948                 result = EXIT_FAILURE;
1949         } catch (int e) {
1950                 /*-------- DEBUG LOG --------*/
1951                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1952                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 95,
1953                                 "function : void sslproxy_main(int argc, char* argv[]) : "
1954                                 "Catch int exception. %d",
1955                                 e);
1956                 }
1957                 /*------ DEBUG LOG END ------*/
1958                 result = e;
1959         } catch (...) {
1960                 std::cout << "Unknown exception." << std::endl;
1961                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_COMMON, 38, "Unknown exception.");
1962                 result = EXIT_FAILURE;
1963         }
1964
1965         fflush(stdout);
1966         fsync(1);
1967
1968         /*-------- DEBUG LOG --------*/
1969         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_COMMON)) {
1970                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_COMMON, 96,
1971                         "out_function : void sslproxy_main(int argc, char* argv[]) : "
1972                         "return value = %d.",
1973                         result);
1974         }
1975         /*------ DEBUG LOG END ------*/
1976         _exit(result);
1977 }