/// Ctor. Prepares session for connection as an initiator. ClientSession (const F8MetaCntx& ctx, const std::string& conf_file, const std::string& session_name, bool init_con_later=false) : ClientSessionBase(ctx, conf_file, session_name), _sci(get_sender_comp_id(_ses)), _tci(get_target_comp_id(_ses)), _id(_ctx._beginStr, _sci, _tci), _log(create_logger(_ses, session_log, &_id)), _plog(create_logger(_ses, protocol_log, &_id)), _persist(create_persister(_ses, nullptr, this->_loginParameters._reset_sequence_numbers)), _session(new T(_ctx, _id, _persist, _log, _plog)), _addr(get_address(_ses)) #ifdef FIX8_HAVE_OPENSSL ,_ssl(get_ssl_context(_ses), true) #endif { if (!init_con_later) { #ifdef FIX8_HAVE_OPENSSL bool secured(_ssl.is_secure()); _sock = secured ? new Poco::Net::SecureStreamSocket(_ssl._context) : new Poco::Net::StreamSocket; #else bool secured(false); _sock = new Poco::Net::StreamSocket; #endif _cc = new ClientConnection(_sock, _addr, *_session, this->_loginParameters._hb_int, get_process_model(_ses), true, secured); } _session->set_login_parameters(this->_loginParameters); _session->set_session_config(this); }
/* * Read a log message */ int LIBWDI_API wdi_read_logger(char* buffer, DWORD buffer_size, DWORD* message_size) { int size; DWORD r; MUTEX_START; if ( (logger_rd_handle == INVALID_HANDLE_VALUE) && (create_logger(0) != WDI_SUCCESS) ) { *message_size = 0; MUTEX_RETURN(WDI_ERROR_NOT_FOUND); } if (log_messages_pending == 0) { size = safe_snprintf(buffer, buffer_size, "ERROR: log buffer is empty"); if (size <0) { buffer[buffer_size-1] = 0; MUTEX_RETURN(buffer_size); } *message_size = (DWORD)size; MUTEX_RETURN(WDI_SUCCESS); } log_messages_pending--; if (ReadFile(logger_rd_handle, (void*)buffer, buffer_size, message_size, NULL)) { MUTEX_RETURN(WDI_SUCCESS); } *message_size = 0; r = GetLastError(); if ((r == ERROR_INSUFFICIENT_BUFFER) || (r == ERROR_MORE_DATA)) { MUTEX_RETURN(WDI_ERROR_OVERFLOW); } MUTEX_RETURN(WDI_ERROR_IO); }
/* * Register a Window as destination for logging message * This Window will be notified with a message event and should call * wdi_read_logger() to retreive the message data */ int LIBWDI_API wdi_register_logger(HWND hWnd, UINT message, DWORD buffsize) { int r; MUTEX_START; if (logger_dest != NULL) { MUTEX_RETURN(WDI_ERROR_EXISTS); } r = create_logger(buffsize); if (r == WDI_SUCCESS) { logger_dest = hWnd; logger_msg = message; } MUTEX_RETURN(r); }
static void *worker_proc(void *userdata){ zmq_thread_data_t *ztd = userdata; ztd->ctx = zmq_ctx_new (); ztd->socket = zmq_socket(ztd->ctx,ZMQ_PULL); char url[256]; sprintf(url, "tcp://%s:5557", ztd->server_ip); zmq_connect(ztd->socket, url); char file_prefix[256]; config_t *conf = ztd->conf; sprintf(file_prefix, "%s-%s", ztd->server_ip, conf->file_prefix); ztd->logger = create_logger(conf->home_dir, file_prefix, conf->max_file_count, conf->file_size_limit); struct tm *ptm; char query_log[1024]; char datetime[100]; char buf[1024]; int msg_len; time_t tt; LogMessage *msg; pthread_t _pid = pthread_self(); while(run) { msg_len = zmq_recv(ztd->socket, buf, MAX_MSG_SIZE, 0); msg = log_message__unpack(NULL, msg_len, buf); tt = msg->date; ptm = localtime(&tt); strftime(datetime, 100, "%Y-%m-%d %H:%M:%S ", ptm); sprintf(query_log, "%s %s %s: %s %d %d\n", datetime, msg->cip, msg->view, msg->domain, msg->rtype, msg->rcode); log_msg(ztd->logger, query_log); log_message__free_unpacked(msg, NULL); if (ztd->count++%100000== 0) { printf(query_log); printf("!!! thread %d:msglen %d count....%d\n", (int)_pid, msg_len, ztd->count); } } }
/* entry point */ int main(int ac, char **av) { int ret; memset(&ctx, 0, sizeof(ctx)); /* instance handle of this module */ { HMODULE module; module = GetModuleHandle(NULL); if(module == NULL) { error_message_le("GetModuleHandle() failed"); return 1; } ctx.instance = (HINSTANCE)module; } /* initialize COM */ { HRESULT hres; hres = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED); if(FAILED(hres)) { error_message_hr("CoInitializeEx() failed", hres); return 1; } hres = init_regexp(); if(FAILED(hres)) { error_message_hr("init_regexp() failed", hres); return 1; } } /* create main message window */ ctx.main_window = create_main_window(); if(ctx.main_window == NULL) { error_message_le("create_main_window() failed"); return 1; } /* logger */ ret = create_logger(); if(ret == 0) { error_message_le("create_logger() failed"); return 1; } ctx.sprocs.hdr.api_ver = MP_OP_API_VERSION; ctx.sprocs.hdr.type = MP_OP_TYPE_SUPPORT; ctx.sprocs.log_printf = log_printf; ctx.sprocs.log_s_exp = log_print_s_exp; ctx.sprocs.log_lasterror = log_print_lasterror; ctx.sprocs.log_hresult = log_print_hresult; /* command line option */ { LPWSTR *avw, file; int acw; avw = CommandLineToArgvW(GetCommandLineW(), &acw); if(avw != NULL && acw >= 2) { file = avw[1]; } else { file = NULL; } /* load setting file */ load_setting(file, TRUE); } /* start message */ log_printf(LOG_LEVEL_NOTIFY, L"\nmouse-processor started\n"); /* main message loop */ ret = message_loop(); /* uninitialize COM */ CoUninitialize(); /* end logger */ destroy_logger(); return ret; }
VOID WINAPI service_main(DWORD argc, LPTSTR* argv) { service_configuration configuration; parse_service_options(argc, argv, configuration); const fscp::logger logger = create_logger(configuration); logger(fscp::log_level::information) << "Log starts at " << boost::posix_time::to_simple_string(boost::posix_time::second_clock::local_time()); if (configuration.configuration_file.empty()) { logger(fscp::log_level::warning) << "No configuration specified."; } else { logger(fscp::log_level::information) << "Reading configuration at: " << configuration.configuration_file; } /* Initializations */ cryptoplus::crypto_initializer crypto_initializer; cryptoplus::algorithms_initializer algorithms_initializer; cryptoplus::error::error_strings_initializer error_strings_initializer; freelan::initializer freelan_initializer; service_context ctx; ctx.service_status.dwServiceType = SERVICE_WIN32; ctx.service_status.dwCurrentState = SERVICE_STOPPED; ctx.service_status.dwControlsAccepted = 0; ctx.service_status.dwWin32ExitCode = NO_ERROR; ctx.service_status.dwServiceSpecificExitCode = NO_ERROR; ctx.service_status.dwCheckPoint = 0; ctx.service_status.dwWaitHint = 0; ctx.service_status_handle = ::RegisterServiceCtrlHandlerEx(SERVICE_NAME, &handler_ex, &ctx); if (ctx.service_status_handle != 0) { ctx.service_status.dwCurrentState = SERVICE_START_PENDING; // Start pending ::SetServiceStatus(ctx.service_status_handle, &ctx.service_status); try { boost::asio::io_service io_service; fl::configuration fl_configuration = get_freelan_configuration(logger, configuration); fl::core core(io_service, fl_configuration); core.set_log_level(logger.level()); core.set_log_callback(logger.callback()); if (!fl_configuration.tap_adapter.up_script.empty()) { core.set_tap_adapter_up_callback(boost::bind(&execute_tap_adapter_up_script, fl_configuration.tap_adapter.up_script, logger, _1)); } if (!fl_configuration.tap_adapter.down_script.empty()) { core.set_tap_adapter_down_callback(boost::bind(&execute_tap_adapter_down_script, fl_configuration.tap_adapter.down_script, logger, _1)); } if (!fl_configuration.security.certificate_validation_script.empty()) { core.set_certificate_validation_callback(boost::bind(&execute_certificate_validation_script, fl_configuration.security.certificate_validation_script, logger, _1)); } if (!fl_configuration.server.authentication_script.empty()) { core.set_authentication_callback(boost::bind(&execute_authentication_script, fl_configuration.server.authentication_script, logger, _1, _2, _3, _4)); } if (!fl_configuration.router.dns_script.empty()) { core.set_dns_callback(boost::bind(&execute_dns_script, fl_configuration.router.dns_script, logger, _1, _2, _3)); } core.open(); boost::unique_lock<boost::mutex> lock(ctx.stop_function_mutex); ctx.stop_function = boost::bind(&fl::core::close, boost::ref(core)); lock.unlock(); // Running ctx.service_status.dwControlsAccepted |= (SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN); ctx.service_status.dwCurrentState = SERVICE_RUNNING; ::SetServiceStatus(ctx.service_status_handle, &ctx.service_status); boost::thread_group threads; unsigned int thread_count = configuration.thread_count; if (thread_count == 0) { thread_count = boost::thread::hardware_concurrency(); // Some implementation can return 0. if (thread_count == 0) { // We create 2 threads. thread_count = 2; } } logger(fscp::log_level::information) << "Using " << thread_count << " thread(s)."; logger(fscp::log_level::information) << "Execution started."; for (std::size_t i = 0; i < thread_count; ++i) { threads.create_thread(boost::bind(&boost::asio::io_service::run, &io_service)); } threads.join_all(); logger(fscp::log_level::information) << "Execution stopped."; lock.lock(); ctx.stop_function = NULL; lock.unlock(); } catch (boost::system::system_error& ex) { ctx.service_status.dwWin32ExitCode = ex.code().value(); ::SetServiceStatus(ctx.service_status_handle, &ctx.service_status); logger(fscp::log_level::error) << "Error: " << ex.code() << ":" << ex.code().message() << ":" << ex.what(); } catch (std::exception& ex) { ctx.service_status.dwWin32ExitCode = ERROR_SERVICE_SPECIFIC_ERROR; ctx.service_status.dwServiceSpecificExitCode = 1; ::SetServiceStatus(ctx.service_status_handle, &ctx.service_status); logger(fscp::log_level::error) << "Error: " << ex.what(); } // Stop ctx.service_status.dwControlsAccepted &= ~(SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN); ctx.service_status.dwCurrentState = SERVICE_STOPPED; ::SetServiceStatus(ctx.service_status_handle, &ctx.service_status); } logger(fscp::log_level::information) << "Log stops at " << boost::posix_time::to_simple_string(boost::posix_time::second_clock::local_time()); }