2 * @file sslproxyserver.cpp
3 * @brief module of SSLproxy_server
4 * @brief SSL setting and Accept connection.
6 * Copyright (C) 2008 NTT COMWARE Corporation.
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.
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.
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
23 **********************************************************************
25 * Distributed under the Boost Software Licence, Version 1.0
26 * http://www.boost.org/LICENSE_1_0.txt
28 **********************************************************************/
30 #include <sys/syscall.h> // for SYS_gettid
31 #include "sslproxyserver.h"
33 //! SSLproxy session management table.
34 std::map<long, int> sessionTable;
35 pthread_mutex_t sessionTable_mutex = PTHREAD_MUTEX_INITIALIZER;
38 * SSLproxy_server constructor.
39 * Set SSL context and Create session and Accept start.
41 * @param[in] io_service IO event dispatcher
42 * @param[in] target_itr target endpoint iterator
43 * @param[in] recv_endpoint recv endpoint
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)
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("")
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)");
63 /*------ DEBUG LOG END ------*/
65 std::string function_str = "";
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) {
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. "
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());
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. "
98 (ca_dir + ca_file).c_str());
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());
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() : "
114 /*------ DEBUG LOG END ------*/
116 // Set certificate chain file.
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. "
125 (cert_chain_dir + cert_chain_file).c_str());
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());
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.");
140 /*------ DEBUG LOG END ------*/
142 // Set password callback function.
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()");
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());
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.");
165 /*------ DEBUG LOG END ------*/
167 // Set private key file and filetype.
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. "
177 (private_key_dir + private_key_file).c_str(),
178 private_key_filetype);
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());
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.");
193 /*------ DEBUG LOG END ------*/
195 // Set verify options on the context.
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",
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());
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.");
219 /*------ DEBUG LOG END ------*/
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()) "
231 /*------ DEBUG LOG END ------*/
233 // Set SSL options on the context.
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. "
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());
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.");
257 /*------ DEBUG LOG END ------*/
259 // Set temporary Diffie-Hellman parameters file.
260 if (tmp_dh_use == true) {
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. "
269 (tmp_dh_dir + tmp_dh_file).c_str());
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());
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.");
285 /*------ DEBUG LOG END ------*/
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.");
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. "
301 cipher_list.c_str());
303 /*------ DEBUG LOG END ------*/
305 // Set session id context on the context.
306 SSL_CTX_set_session_id_context(sslcontext.impl(), (const unsigned char *)"sslproxy", 8);
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()));
318 /*------ DEBUG LOG END ------*/
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()));
330 /*------ DEBUG LOG END ------*/
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()));
342 /*------ DEBUG LOG END ------*/
344 // Create sslproxy_session for first acception.
345 function_str = "Create sslproxy_session for first";
346 sslproxy_session* session = new sslproxy_session(sslservice,
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.");
357 /*------ DEBUG LOG END ------*/
359 // Start an asynchronous accept for first.
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.");
368 /*------ DEBUG LOG END ------*/
370 sslacceptor.async_accept(sock,
371 boost::bind(&sslproxy_server::handle_accept,
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.");
381 /*------ DEBUG LOG END ------*/
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.");
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());
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.");
401 /*------ DEBUG LOG END ------*/
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());
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",
416 /*------ DEBUG LOG END ------*/
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)");
428 /*------ DEBUG LOG END ------*/
432 * SSLproxy_server destructor.
434 sslproxy_server::~sslproxy_server()
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()");
441 /*------ DEBUG LOG END ------*/
445 * Get password callback function.
447 * @return password string
448 * @retval string success
451 std::string sslproxy_server::get_password()
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)");
458 /*------ DEBUG LOG END ------*/
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 = "";
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. "
475 private_key_passwd.c_str());
477 /*------ DEBUG LOG END ------*/
478 } else if (private_key_passwd_from == "file") {
479 // Get password from file.
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.");
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.");
488 if (strlen(buf) > MAX_PASSWD_SIZE) {
489 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 16, "Password is too long.");
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.");
499 /*------ DEBUG LOG END ------*/
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. "
510 private_key_passwd.c_str());
512 /*------ DEBUG LOG END ------*/
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) : "
520 private_key_passwd.c_str());
522 /*------ DEBUG LOG END ------*/
523 return private_key_passwd;
527 * Acception handling function.
529 * @param[in] session session object
530 * @param[in] error error code
532 void sslproxy_server::handle_accept(sslproxy_session* session,
533 const boost::system::error_code& error)
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)");
542 /*------ DEBUG LOG END ------*/
544 std::string function_str = "";
546 // Check async_accept() result.
548 // sslproxy_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.");
556 /*------ DEBUG LOG END ------*/
558 // Create sslproxy_session for next acception.
559 function_str = "Create sslproxy_session for next";
560 session = new sslproxy_session(sslservice,
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.");
572 /*------ DEBUG LOG END ------*/
574 // Start an asynchronous accept for next.
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.");
583 /*------ DEBUG LOG END ------*/
585 sslacceptor.async_accept(sock,
586 boost::bind(&sslproxy_server::handle_accept,
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.");
596 /*------ DEBUG LOG END ------*/
598 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 17,
599 "Get session socket for next error.");
602 } catch (std::exception& e) {
603 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 18,
604 "Asynchronous accept for next error : %s.", e.what());
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.");
614 /*------ DEBUG LOG END ------*/
617 LOGGER_PUT_LOG_WARN(LOG_CAT_SSLPROXY_SERVER, 1,
618 "Acception result NG. Retry acception : %s.",
619 error.message().c_str());
621 // Start an asynchronous accept for retry.
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.");
630 /*------ DEBUG LOG END ------*/
632 sslacceptor.async_accept(sock,
633 boost::bind(&sslproxy_server::handle_accept,
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.");
643 /*------ DEBUG LOG END ------*/
645 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 19,
646 "Get session socket for retry error.");
649 } catch (std::exception& e) {
650 LOGGER_PUT_LOG_ERROR(LOG_CAT_SSLPROXY_SERVER, 20,
651 "Asynchronous accept for retry error : %s.", e.what());
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.");
661 /*------ DEBUG LOG END ------*/
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());
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",
675 /*------ DEBUG LOG END ------*/
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)");
685 /*------ DEBUG LOG END ------*/