/// 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());
}
