src/sslproxyserver.cpp

   1 /*
   2  * @file  sslproxyserver.cpp
   3  * @brief module of SSLproxy_server
   4  * @brief SSL setting and Accept connection.
   5  *
   6  * Copyright (C) 2008  NTT COMWARE Corporation.
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  21  * 02110-1301 USA
  22  *
  23  **********************************************************************
  24  *
  25  * Distributed under the Boost Software Licence, Version 1.0
  26  * http://www.boost.org/LICENSE_1_0.txt
  27  *
  28  **********************************************************************/
  29
  30 #include <sys/syscall.h>        // for SYS_gettid
  31 #include "sslproxyserver.h"
  32
  33 //! SSLproxy session management table.
  34 std::map<long, int> sessionTable;
  35 pthread_mutex_t sessionTable_mutex = PTHREAD_MUTEX_INITIALIZER;
  36
  37 /*!
  38  * SSLproxy_server constructor.
  39  * Set SSL context and Create session and Accept start.
  40  *
  41  * @param[in]   io_service      IO event dispatcher
  42  * @param[in]   target_itr      target endpoint iterator
  43  * @param[in]   recv_endpoint   recv endpoint
  44  */
  45 sslproxy_server::sslproxy_server(boost::asio::io_service& io_service,
  46                                  boost::asio::ip::tcp::resolver::iterator target_itr,
  47                                  boost::asio::ip::tcp::endpoint recv_endpoint)
  48                                  :
  49                                  sslservice(io_service),
  50                                  sslacceptor(io_service, recv_endpoint),
  51                                  sslcontext(io_service, DEFAULT_SSL_METHOD),
  52                                  target_endpoint_iterator(target_itr),
  53                                  private_key_passwd("")
  54 {
  55         /*-------- DEBUG LOG --------*/
  56         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
  57                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 1,
  58                         "in_function : Constructor sslproxy_server::sslproxy_server("
  59                         "boost::asio::io_service& io_service, "
  60                         "boost::asio::ip::tcp::resolver::iterator target_itr, "
  61                         "boost::asio::ip::tcp::endpoint recv_endpoint)");
  62         }
  63         /*------ DEBUG LOG END ------*/
  64
  65         std::string function_str = "";
  66         try {
  67                 // SSL context setting.
  68                 // Set root CA file or path.
  69                 // If ca_file is valid then specified file. (load_verify_file())
  70                 // If ca_file is invalid then specified path. (add_verify_path())
  71                 if (ca_file.size() == 0) {
  72                         try {
  73                                 sslcontext.add_verify_path(ca_dir);
  74                                 /*-------- DEBUG LOG --------*/
  75                                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
  76                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 2,
  77                                                 "function : Constructor sslproxy_server::sslproxy_server() : "
  78                                                 "add_verify_path() END. "
  79                                                 "path = %s",
  80                                                 ca_dir.c_str());
  81                                 }
  82                                 /*------ DEBUG LOG END ------*/
  83                         } catch (std::exception& e) {
  84                                 std::cerr << "Set root CA path error : " << e.what() << "." << std::endl;
  85                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 1,
  86                                         "Set root CA path error : %s.", e.what());
  87                                 throw -1;
  88                         }
  89                 } else {
  90                         try {
  91                                 sslcontext.load_verify_file(ca_dir + ca_file);
  92                                 /*-------- DEBUG LOG --------*/
  93                                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
  94                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 3,
  95                                                 "function : Constructor sslproxy_server::sslproxy_server() : "
  96                                                 "load_verify_file() END. "
  97                                                 "file = %s",
  98                                                 (ca_dir + ca_file).c_str());
  99                                 }
 100                                 /*------ DEBUG LOG END ------*/
 101                         } catch (std::exception& e) {
 102                                 std::cerr << "Set root CA file error : " << e.what() << "." << std::endl;
 103                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 2,
 104                                         "Set root CA file error : %s.", e.what());
 105                                 throw -1;
 106                         }
 107                 }
 108                 /*-------- DEBUG LOG --------*/
 109                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 110                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 4,
 111                                 "function : Constructor sslproxy_server::sslproxy_server() : "
 112                                 "Set root CA END.");
 113                 }
 114                 /*------ DEBUG LOG END ------*/
 115
 116                 // Set certificate chain file.
 117                 try {
 118                         sslcontext.use_certificate_chain_file(cert_chain_dir + cert_chain_file);
 119                         /*-------- DEBUG LOG --------*/
 120                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 121                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 5,
 122                                         "function : Constructor sslproxy_server::sslproxy_server() : "
 123                                         "use_certificate_chain_file() END. "
 124                                         "file = %s",
 125                                         (cert_chain_dir + cert_chain_file).c_str());
 126                         }
 127                         /*------ DEBUG LOG END ------*/
 128                 } catch (std::exception& e) {
 129                         std::cerr << "Set certificate chain file error : " << e.what() << "." << std::endl;
 130                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 3,
 131                                 "Set certificate chain file error : %s.", e.what());
 132                         throw -1;
 133                 }
 134                 /*-------- DEBUG LOG --------*/
 135                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 136                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 6,
 137                                 "function : Constructor sslproxy_server::sslproxy_server() : "
 138                                 "Set certificate chain END.");
 139                 }
 140                 /*------ DEBUG LOG END ------*/
 141
 142                 // Set password callback function.
 143                 try {
 144                         sslcontext.set_password_callback(boost::bind(&sslproxy_server::get_password, this));
 145                         /*-------- DEBUG LOG --------*/
 146                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 147                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 7,
 148                                         "function : Constructor sslproxy_server::sslproxy_server() : "
 149                                         "set_password_callback() END. "
 150                                         "callback = get_password()");
 151                         }
 152                         /*------ DEBUG LOG END ------*/
 153                 } catch (std::exception& e) {
 154                         std::cerr << "Set password callback error : " << e.what() << "." << std::endl;
 155                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 4,
 156                                 "Set password callback error : %s.", e.what());
 157                         throw -1;
 158                 }
 159                 /*-------- DEBUG LOG --------*/
 160                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 161                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 8,
 162                                 "function : Constructor sslproxy_server::sslproxy_server() : "
 163                                 "Set password callback END.");
 164                 }
 165                 /*------ DEBUG LOG END ------*/
 166
 167                 // Set private key file and filetype.
 168                 try {
 169                         sslcontext.use_private_key_file(private_key_dir + private_key_file, private_key_filetype);
 170                         /*-------- DEBUG LOG --------*/
 171                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 172                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 9,
 173                                         "function : Constructor sslproxy_server::sslproxy_server() : "
 174                                         "use_private_key_file() END. "
 175                                         "file = %s, "
 176                                         "filetype = %d",
 177                                         (private_key_dir + private_key_file).c_str(),
 178                                         private_key_filetype);
 179                         }
 180                         /*------ DEBUG LOG END ------*/
 181                 } catch (std::exception& e) {
 182                         std::cerr << "Set private key file and filetype error : " << e.what() << "." << std::endl;
 183                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 5,
 184                                 "Set private key file and filetype error : %s.", e.what());
 185                         throw -1;
 186                 }
 187                 /*-------- DEBUG LOG --------*/
 188                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 189                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 10,
 190                                 "function : Constructor sslproxy_server::sslproxy_server() : "
 191                                 "Set private key END.");
 192                 }
 193                 /*------ DEBUG LOG END ------*/
 194
 195                 // Set verify options on the context.
 196                 try {
 197                         sslcontext.set_verify_mode(verify_options);
 198                         /*-------- DEBUG LOG --------*/
 199                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 200                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 11,
 201                                         "function : Constructor sslproxy_server::sslproxy_server() : "
 202                                         "set_verify_mode() END. "
 203                                         "verify_options = %d",
 204                                         verify_options);
 205                         }
 206                         /*------ DEBUG LOG END ------*/
 207                 } catch (std::exception& e) {
 208                         std::cerr << "Set verify option error : " << e.what() << "." << std::endl;
 209                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 6,
 210                                 "Set verify option error : %s.", e.what());
 211                         throw -1;
 212                 }
 213                 /*-------- DEBUG LOG --------*/
 214                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 215                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 12,
 216                                 "function : Constructor sslproxy_server::sslproxy_server() : "
 217                                 "Set verify option END.");
 218                 }
 219                 /*------ DEBUG LOG END ------*/
 220
 221                 // Set verify depth on the context.
 222                 SSL_CTX_set_verify_depth(sslcontext.impl(), verify_cert_depth);
 223                 /*-------- DEBUG LOG --------*/
 224                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 225                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 13,
 226                                 "function : Constructor sslproxy_server::sslproxy_server() : "
 227                                 "Set verify depth END. (SSL_CTX_set_verify_depth()) "
 228                                 "depth = %d",
 229                                 verify_cert_depth);
 230                 }
 231                 /*------ DEBUG LOG END ------*/
 232
 233                 // Set SSL options on the context.
 234                 try {
 235                         sslcontext.set_options(ssl_options);
 236                         /*-------- DEBUG LOG --------*/
 237                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 238                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 14,
 239                                         "function : Constructor sslproxy_server::sslproxy_server() : "
 240                                         "set_options() END. "
 241                                         "ssl_options = %ld",
 242                                         ssl_options);
 243                         }
 244                         /*------ DEBUG LOG END ------*/
 245                 } catch (std::exception& e) {
 246                         std::cerr << "Set SSL option error : " << e.what() << "." << std::endl;
 247                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 7,
 248                                 "Set SSL option error : %s.", e.what());
 249                         throw -1;
 250                 }
 251                 /*-------- DEBUG LOG --------*/
 252                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 253                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 15,
 254                                 "function : Constructor sslproxy_server::sslproxy_server() : "
 255                                 "Set SSL option END.");
 256                 }
 257                 /*------ DEBUG LOG END ------*/
 258
 259                 // Set temporary Diffie-Hellman parameters file.
 260                 if (tmp_dh_use == true) {
 261                         try {
 262                                 sslcontext.use_tmp_dh_file(tmp_dh_dir + tmp_dh_file);
 263                                 /*-------- DEBUG LOG --------*/
 264                                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 265                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 16,
 266                                                 "function : Constructor sslproxy_server::sslproxy_server() : "
 267                                                 "use_tmp_dh_file() END. "
 268                                                 "file = %s",
 269                                                 (tmp_dh_dir + tmp_dh_file).c_str());
 270                                 }
 271                                 /*------ DEBUG LOG END ------*/
 272                         } catch (std::exception& e) {
 273                                 std::cerr << "Set tmp DH file error : " << e.what() << "." << std::endl;
 274                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 8,
 275                                         "Set tmp DH file error : %s.", e.what());
 276                                 throw -1;
 277                         }
 278
 279                         /*-------- DEBUG LOG --------*/
 280                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 281                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 17,
 282                                         "function : Constructor sslproxy_server::sslproxy_server() : "
 283                                         "Set tmp DH file END.");
 284                         }
 285                         /*------ DEBUG LOG END ------*/
 286                 }
 287
 288                 // Set cipher list on the context.
 289                 if (SSL_CTX_set_cipher_list(sslcontext.impl(), cipher_list.c_str()) != 1) {
 290                         std::cerr << "Set cipher list error : no valid ciphers." << std::endl;
 291                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 9,
 292                                 "Set cipher list error : no valid ciphers.");
 293                         throw -1;
 294                 }
 295                 /*-------- DEBUG LOG --------*/
 296                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 297                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 18,
 298                                 "function : Constructor sslproxy_server::sslproxy_server() : "
 299                                 "Set cipher list END. "
 300                                 "cipher_list = %s",
 301                                 cipher_list.c_str());
 302                 }
 303                 /*------ DEBUG LOG END ------*/
 304
 305                 // Set session id context on the context.
 306                 SSL_CTX_set_session_id_context(sslcontext.impl(), (const unsigned char *)"sslproxy", 8);
 307
 308                 // Set session cache mode on the context.
 309                 SSL_CTX_set_session_cache_mode(sslcontext.impl(), session_cache_mode);
 310                 /*-------- DEBUG LOG --------*/
 311                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 312                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 42,
 313                                 "function : Constructor sslproxy_server::sslproxy_server() : "
 314                                 "Set session cache mode END. "
 315                                 "session_cache_mode = %ld",
 316                                 SSL_CTX_get_session_cache_mode(sslcontext.impl()));
 317                 }
 318                 /*------ DEBUG LOG END ------*/
 319
 320                 // Set session cache size on the context.
 321                 SSL_CTX_sess_set_cache_size(sslcontext.impl(), session_cache_size);
 322                 /*-------- DEBUG LOG --------*/
 323                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 324                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 43,
 325                                 "function : Constructor sslproxy_server::sslproxy_server() : "
 326                                 "Set session cache size END. "
 327                                 "session_cache_size = %ld",
 328                                 SSL_CTX_sess_get_cache_size(sslcontext.impl()));
 329                 }
 330                 /*------ DEBUG LOG END ------*/
 331
 332                 // Set session cache timeout on the context.
 333                 SSL_CTX_set_timeout(sslcontext.impl(), session_cache_timeout);
 334                 /*-------- DEBUG LOG --------*/
 335                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 336                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 44,
 337                                 "function : Constructor sslproxy_server::sslproxy_server() : "
 338                                 "Set session cache timeout END. "
 339                                 "session_cache_timeout = %ld",
 340                                 SSL_CTX_get_timeout(sslcontext.impl()));
 341                 }
 342                 /*------ DEBUG LOG END ------*/
 343
 344                 // Create sslproxy_session for first acception.
 345                 function_str = "Create sslproxy_session for first";
 346                 sslproxy_session* session = new sslproxy_session(sslservice,
 347                                                                  sslcontext,
 348                                                                  target_endpoint_iterator);
 349                 sessionTable.clear();
 350                 sessionTable[(long)session] = 1;
 351                 /*-------- DEBUG LOG --------*/
 352                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 353                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 19,
 354                                 "function : Constructor sslproxy_server::sslproxy_server() : "
 355                                 "Create sslproxy_session END.");
 356                 }
 357                 /*------ DEBUG LOG END ------*/
 358
 359                 // Start an asynchronous accept for first.
 360                 try {
 361                         ssl_socket::lowest_layer_type& sock = session->low_socket();
 362                         /*-------- DEBUG LOG --------*/
 363                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 364                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 20,
 365                                         "function : Constructor sslproxy_server::sslproxy_server() : "
 366                                         "low_socket() END.");
 367                         }
 368                         /*------ DEBUG LOG END ------*/
 369
 370                         sslacceptor.async_accept(sock,
 371                                                  boost::bind(&sslproxy_server::handle_accept,
 372                                                              this,
 373                                                              session,
 374                                                              boost::asio::placeholders::error));
 375                         /*-------- DEBUG LOG --------*/
 376                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 377                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 21,
 378                                         "function : Constructor sslproxy_server::sslproxy_server() : "
 379                                         "async_accept() END.");
 380                         }
 381                         /*------ DEBUG LOG END ------*/
 382                 } catch (int e) {
 383                         std::cerr << "Get session socket for first error." << std::endl;
 384                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 10,
 385                                 "Get session socket for first error.");
 386                         delete session;
 387                         throw -1;
 388                 } catch (std::exception& e) {
 389                         std::cerr << "Asynchronous accept for first error : " << e.what() << "." << std::endl;
 390                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 11,
 391                                 "Asynchronous accept for first error : %s.", e.what());
 392                         delete session;
 393                         throw -1;
 394                 }
 395                 /*-------- DEBUG LOG --------*/
 396                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 397                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 22,
 398                                 "function : Constructor sslproxy_server::sslproxy_server() : "
 399                                 "Asynchronous accept for first END.");
 400                 }
 401                 /*------ DEBUG LOG END ------*/
 402
 403         } catch (std::exception& e) {
 404                 std::cerr << function_str << " error : " << e.what() << "." << std::endl;
 405                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 12,
 406                         "%s error : %s.", function_str.c_str(), e.what());
 407                 throw -1;
 408         } catch (int e) {
 409                 /*-------- DEBUG LOG --------*/
 410                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 411                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 23,
 412                                 "function : Constructor sslproxy_server::sslproxy_server() : "
 413                                 "Catch int exception. %d",
 414                                 e);
 415                 }
 416                 /*------ DEBUG LOG END ------*/
 417                 throw -1;
 418         }
 419
 420         /*-------- DEBUG LOG --------*/
 421         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 422                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 24,
 423                         "out_function : Constructor sslproxy_server::sslproxy_server("
 424                         "boost::asio::io_service& io_service, "
 425                         "boost::asio::ip::tcp::resolver::iterator target_itr, "
 426                         "boost::asio::ip::tcp::endpoint recv_endpoint)");
 427         }
 428         /*------ DEBUG LOG END ------*/
 429 }
 430
 431 /*!
 432  * SSLproxy_server destructor.
 433  */
 434 sslproxy_server::~sslproxy_server()
 435 {
 436         /*-------- DEBUG LOG --------*/
 437         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 438                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 25,
 439                         "in/out_function : Destructor sslproxy_server::~sslproxy_server()");
 440         }
 441         /*------ DEBUG LOG END ------*/
 442 }
 443
 444 /*!
 445  * Get password callback function.
 446  *
 447  * @return      password string
 448  * @retval      string  success
 449  * @retval      ""      failed
 450  */
 451 std::string sslproxy_server::get_password()
 452 {
 453         /*-------- DEBUG LOG --------*/
 454         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 455                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 26,
 456                         "in_function : std::string sslproxy_server::get_password(void)");
 457         }
 458         /*------ DEBUG LOG END ------*/
 459
 460         private_key_passwd = "";
 461         if (private_key_passwd_from == "console") {
 462                 // Get password from console.
 463                 std::cout << "Input private key passwd : ";
 464                 std::cin >> private_key_passwd;
 465                 if (private_key_passwd.size() > MAX_PASSWD_SIZE) {
 466                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 13, "Password is too long.");
 467                         private_key_passwd = "";
 468                 }
 469                 /*-------- DEBUG LOG --------*/
 470                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 471                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 27,
 472                                 "function : std::string sslproxy_server::get_password(void) : "
 473                                 "Get password from console END. "
 474                                 "pass = %s",
 475                                 private_key_passwd.c_str());
 476                 }
 477                 /*------ DEBUG LOG END ------*/
 478         } else if (private_key_passwd_from == "file") {
 479                 // Get password from file.
 480                 FILE  *fp;
 481                 char buf[MAX_PASSWD_SIZE + 3];
 482                 if ((fp = fopen((private_key_passwd_dir + private_key_passwd_file).c_str(), "r")) == NULL) {
 483                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 14, "Password file cannot open.");
 484                 } else {
 485                         if (fgets(buf, MAX_PASSWD_SIZE + 3, fp) == NULL) {
 486                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 15, "Password not found in file.");
 487                         } else {
 488                                 if (strlen(buf) > MAX_PASSWD_SIZE) {
 489                                         LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 16, "Password is too long.");
 490                                 } else {
 491                                         buf[strlen(buf) - 1] = '\0';
 492                                         private_key_passwd = buf;
 493                                         /*-------- DEBUG LOG --------*/
 494                                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 495                                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 28,
 496                                                         "function : std::string sslproxy_server::get_password(void) : "
 497                                                         "Read password from file END.");
 498                                         }
 499                                         /*------ DEBUG LOG END ------*/
 500                                 }
 501                         }
 502                         fclose(fp);
 503                 }
 504                 /*-------- DEBUG LOG --------*/
 505                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 506                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 29,
 507                                 "function : std::string sslproxy_server::get_password(void) : "
 508                                 "Get password from file END. "
 509                                 "pass = %s",
 510                                 private_key_passwd.c_str());
 511                 }
 512                 /*------ DEBUG LOG END ------*/
 513         }
 514
 515         /*-------- DEBUG LOG --------*/
 516         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 517                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 30,
 518                         "out_function : std::string sslproxy_server::get_password(void) : "
 519                         "return value = %s",
 520                         private_key_passwd.c_str());
 521         }
 522         /*------ DEBUG LOG END ------*/
 523         return private_key_passwd;
 524 }
 525
 526 /*!
 527  * Acception handling function.
 528  *
 529  * @param[in]   session session object
 530  * @param[in]   error   error code
 531  */
 532 void sslproxy_server::handle_accept(sslproxy_session* session,
 533                                     const boost::system::error_code& error)
 534 {
 535         /*-------- DEBUG LOG --------*/
 536         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 537                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 31,
 538                         "in_function : void sslproxy_server::handle_accept("
 539                         "sslproxy_session* session, "
 540                         "const boost::system::error_code& error)");
 541         }
 542         /*------ DEBUG LOG END ------*/
 543
 544         std::string function_str = "";
 545         try {
 546                 // Check async_accept() result.
 547                 if (!error) {
 548                         // sslproxy_session start.
 549                         session->start();
 550                         /*-------- DEBUG LOG --------*/
 551                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 552                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 32,
 553                                         "function : void sslproxy_server::handle_accept() : "
 554                                         "Session start END.");
 555                         }
 556                         /*------ DEBUG LOG END ------*/
 557
 558                         // Create sslproxy_session for next acception.
 559                         function_str = "Create sslproxy_session for next";
 560                         session = new sslproxy_session(sslservice,
 561                                                        sslcontext,
 562                                                        target_endpoint_iterator);
 563                         pthread_mutex_lock( &sessionTable_mutex );
 564                         sessionTable[(long)session] = 1;
 565                         pthread_mutex_unlock( &sessionTable_mutex );
 566                         /*-------- DEBUG LOG --------*/
 567                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 568                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 33,
 569                                         "function : void sslproxy_server::handle_accept() : "
 570                                         "Create sslproxy_session for next END.");
 571                         }
 572                         /*------ DEBUG LOG END ------*/
 573
 574                         // Start an asynchronous accept for next.
 575                         try {
 576                                 ssl_socket::lowest_layer_type& sock = session->low_socket();
 577                                 /*-------- DEBUG LOG --------*/
 578                                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 579                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 34,
 580                                                 "function : void sslproxy_server::handle_accept() : "
 581                                                 "low_socket() END.");
 582                                 }
 583                                 /*------ DEBUG LOG END ------*/
 584
 585                                 sslacceptor.async_accept(sock,
 586                                                          boost::bind(&sslproxy_server::handle_accept,
 587                                                          this,
 588                                                          session,
 589                                                          boost::asio::placeholders::error));
 590                                 /*-------- DEBUG LOG --------*/
 591                                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 592                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 35,
 593                                                 "function : void sslproxy_server::handle_accept() : "
 594                                                 "async_accept() for next END.");
 595                                 }
 596                                 /*------ DEBUG LOG END ------*/
 597                         } catch (int e) {
 598                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 17,
 599                                         "Get session socket for next error.");
 600                                 delete session;
 601                                 throw -1;
 602                         } catch (std::exception& e) {
 603                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 18,
 604                                         "Asynchronous accept for next error : %s.", e.what());
 605                                 delete session;
 606                                 throw -1;
 607                         }
 608                         /*-------- DEBUG LOG --------*/
 609                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 610                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 36,
 611                                         "function : void sslproxy_server::handle_accept() : "
 612                                         "Asynchronous accept for next END.");
 613                         }
 614                         /*------ DEBUG LOG END ------*/
 615
 616                 } else {
 617                         LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_SERVER, 1,
 618                                 "Acception result NG. Retry acception : %s.",
 619                                 error.message().c_str());
 620
 621                         // Start an asynchronous accept for retry.
 622                         try {
 623                                 ssl_socket::lowest_layer_type& sock = session->low_socket();
 624                                 /*-------- DEBUG LOG --------*/
 625                                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 626                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 37,
 627                                                 "function : void sslproxy_server::handle_accept() : "
 628                                                 "low_socket() END.");
 629                                 }
 630                                 /*------ DEBUG LOG END ------*/
 631
 632                                 sslacceptor.async_accept(sock,
 633                                                          boost::bind(&sslproxy_server::handle_accept,
 634                                                          this,
 635                                                          session,
 636                                                          boost::asio::placeholders::error));
 637                                 /*-------- DEBUG LOG --------*/
 638                                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 639                                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 38,
 640                                                 "function : void sslproxy_server::handle_accept() : "
 641                                                 "async_accept() for retry END.");
 642                                 }
 643                                 /*------ DEBUG LOG END ------*/
 644                         } catch (int e) {
 645                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 19,
 646                                         "Get session socket for retry error.");
 647                                 delete session;
 648                                 throw -1;
 649                         } catch (std::exception& e) {
 650                                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 20,
 651                                         "Asynchronous accept for retry error : %s.", e.what());
 652                                 delete session;
 653                                 throw -1;
 654                         }
 655                         /*-------- DEBUG LOG --------*/
 656                         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 657                                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 39,
 658                                         "function : void sslproxy_server::handle_accept() : "
 659                                         "Asynchronous accept for retry END.");
 660                         }
 661                         /*------ DEBUG LOG END ------*/
 662                 }
 663
 664         } catch (std::exception& e) {
 665                 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 21,
 666                         "%s error : %s.", function_str.c_str(), e.what());
 667         } catch (int e) {
 668                 /*-------- DEBUG LOG --------*/
 669                 if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 670                         LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 40,
 671                                 "function : void sslproxy_server::handle_accept() : "
 672                                 "Catch int exception. %d",
 673                                 e);
 674                 }
 675                 /*------ DEBUG LOG END ------*/
 676         }
 677
 678         /*-------- DEBUG LOG --------*/
 679         if (LOG_LV_DEBUG == logger_get_log_level(LOG_CAT_SSLPROXY_SERVER)) {
 680                 LOGGER_PUT_LOG_DEBUG(LOG_CAT_SSLPROXY_SERVER, 41,
 681                                 "out_function : void sslproxy_server::handle_accept("
 682                                 "sslproxy_session* session, "
 683                                 "const boost::system::error_code& error)");
 684         }
 685         /*------ DEBUG LOG END ------*/
 686 }