int botan_rng_init(botan_rng_t* rng_out, const char* rng_type) { try { BOTAN_ASSERT_ARG_NON_NULL(rng_out); if(rng_type == nullptr || *rng_type == 0) rng_type = "system"; const std::string rng_type_s(rng_type); std::unique_ptr<Botan::RandomNumberGenerator> rng; if(rng_type_s == "system") rng.reset(new Botan::System_RNG); else if(rng_type_s == "user") rng.reset(new Botan::AutoSeeded_RNG); if(rng) { *rng_out = new botan_rng_struct(rng.release()); return 0; } } catch(std::exception& e) { log_exception(BOTAN_CURRENT_FUNCTION, e.what()); } catch(...) { log_exception(BOTAN_CURRENT_FUNCTION, "unknown"); } return -1; }
static nx_logdata_t *nx_patterndb_pattern_exec(nx_module_t *module, nx_logdata_t *logdata, nx_pattern_t *pattern) { nx_expr_eval_ctx_t eval_ctx; nx_exception_t e; nx_expr_eval_ctx_init(&eval_ctx, logdata, module, NULL); try { nx_expr_statement_list_execute(&eval_ctx, pattern->exec); } catch(e) { log_exception(e); } if ( eval_ctx.logdata == NULL ) { // dropped nx_module_logqueue_pop(module, logdata); nx_logdata_free(logdata); } logdata = eval_ctx.logdata; nx_expr_eval_ctx_destroy(&eval_ctx); return ( logdata ); }
static void im_ssl_write(nx_module_t *module, nx_event_t *event) { int rv; SSL *ssl; apr_socket_t *sock; nx_module_input_t *input = NULL; int errcode; nx_exception_t e; sock = (apr_socket_t *) event->data; ASSERT(module != NULL); CHECKERR_MSG(apr_socket_data_get((void **) &input, "input", sock), "couldn't get input data from socket"); ASSERT(input != NULL); ssl = (SSL *) nx_module_input_data_get(input, "ssl"); ASSERT(ssl != NULL); if ( !SSL_is_init_finished(ssl) ) { log_debug("doing handshake"); try { if ( (rv = SSL_do_handshake(ssl)) <= 0 ) { switch ( (errcode = nx_ssl_check_io_error(ssl, rv)) ) { case SSL_ERROR_ZERO_RETURN: // disconnected throw_msg("im_ssl got disconnected during handshake"); break; case SSL_ERROR_WANT_WRITE: log_debug("im_ssl WANT_WRITE"); nx_module_pollset_add_socket(module, input->desc.s, APR_POLLOUT | APR_POLLHUP); break; case SSL_ERROR_WANT_READ: log_debug("im_ssl WANT_READ"); nx_module_pollset_add_socket(module, input->desc.s, APR_POLLIN | APR_POLLHUP); break; default: throw_msg("im_ssl couldn't write handshake data (error code: %d)", errcode); } } } catch(e) { log_exception(e); im_ssl_disconnect(input); return; } } else { log_warn("SSL socket should not be sending anything after the handshake"); nx_module_pollset_add_socket(module, input->desc.s, APR_POLLIN | APR_POLLHUP); } }
void StarbookDriver::TimerHit() { try { Telescope::TimerHit(); } catch (std::exception &e) { log_exception(getDeviceName(), e.what()); throw e; } }
void ISNewSwitch(const char* dev, const char* name, ISState* states, char* names[], int n) { try { starbook_driver->ISNewSwitch(dev, name, states, names, n); } catch (std::exception &e) { log_exception(starbook_driver->getDeviceName(), e.what()); throw e; } }
void ISNewText(const char* dev, const char* name, char* texts[], char* names[], int n) { try { starbook_driver->ISNewText(dev, name, texts, names, n); } catch (std::exception &e) { log_exception(starbook_driver->getDeviceName(), e.what()); throw e; } }
void ISNewNumber(const char* dev, const char* name, double values[], char* names[], int n) { try { starbook_driver->ISNewNumber(dev, name, values, names, n); } catch (std::exception &e) { log_exception(starbook_driver->getDeviceName(), e.what()); throw e; } }
void ISGetProperties(const char* dev) { try { starbook_driver->ISGetProperties(dev); } catch (std::exception &e) { log_exception(starbook_driver->getDeviceName(), e.what()); throw e; } }
int csl_compile(char *str, char *name, char **codeptr, size_t *sizeptr) { PyObject *pCode, *pStr; node *n; size_t size; // compile into a code object n = PyParser_SimpleParseString(str, Py_file_input); if (!n) { log_exception(); return CSL_BADCODE; } pCode = (PyObject *) PyNode_Compile(n, name); PyNode_Free(n); if (!pCode) { log_exception(); return CSL_BADCODE; } // serialize code object #if PY_MINOR_VERSION == 3 pStr = PyMarshal_WriteObjectToString(pCode); #else pStr = PyMarshal_WriteObjectToString(pCode, 0); #endif Py_DECREF(pCode); if (!pStr) { return CSL_NOMEM; } size = PyString_Size(pStr); *codeptr = malloc(size); if (!*codeptr) { Py_DECREF(pStr); return CSL_NOMEM; } memcpy(*codeptr, PyString_AsString(pStr), size); *sizeptr = size; Py_DECREF(pStr); return 0; }
int cb_cpu_restore_state(CPUState *env, TranslationBlock *tb){ printf("EXCEPTION - logging\n"); DynValBuffer *dynval_buffer = PIFP->PIV->getDynvalBuffer(); log_exception(dynval_buffer); // Then execute taint ops up until the exception occurs. Execution of taint // ops will stop at the point of the exception. rewind_dynval_buffer(dynval_buffer); execute_taint_ops(PTFP->ttb, shadow, dynval_buffer); // Make sure there's nothing left in the buffer assert(dynval_buffer->ptr - dynval_buffer->start == dynval_buffer->cur_size); return 0; }
int botan_hex_encode(const uint8_t* in, size_t len, char* out, uint32_t flags) { try { const bool uppercase = (flags & BOTAN_FFI_HEX_LOWER_CASE) == 0; Botan::hex_encode(out, in, len, uppercase); return 0; } catch(std::exception& e) { log_exception(BOTAN_CURRENT_FUNCTION, e.what()); } return 1; }
static void im_exec_event(nx_module_t *module, nx_event_t *event) { nx_im_exec_conf_t *imconf; nx_exception_t e; ASSERT(event != NULL); imconf = (nx_im_exec_conf_t *) module->config; switch ( event->type ) { case NX_EVENT_DISCONNECT: // FIXME: restart if imconf->restart == TRUE log_warn("im_exec process %s exited", imconf->cmd); imconf->running = FALSE; im_exec_add_restart_event(module); break; case NX_EVENT_READ: try { im_exec_read(module); } catch(e) { log_exception(e); im_exec_add_restart_event(module); } break; case NX_EVENT_POLL: #ifdef WIN32 nx_panic("pollset based im_exec implementation doesn't work on windows"); #else if ( nx_module_get_status(module) == NX_MODULE_STATUS_RUNNING ) { nx_module_pollset_poll(module, TRUE); } break; #endif default: nx_panic("invalid event type: %d", event->type); } }
void nx_expr_proc__xm_fileop_file_remove(nx_expr_eval_ctx_t *eval_ctx, nx_module_t *module, nx_expr_arg_list_t *args) { nx_expr_arg_t *arg; nx_value_t file; apr_status_t rv; apr_pool_t *pool = NULL; apr_dir_t *dir; nx_exception_t e; nx_string_t *dirname = NULL; nx_string_t *fname = NULL; char *filename; char *idx; int flags = 0; apr_finfo_t finfo; nx_expr_arg_t *older; nx_value_t olderval; apr_time_t older_time = 0LL; ASSERT(module != NULL); ASSERT(args != NULL); arg = NX_DLIST_FIRST(args); ASSERT(arg != NULL); ASSERT(arg->expr != NULL); nx_expr_evaluate(eval_ctx, &file, arg->expr); if ( file.defined != TRUE ) { throw_msg("'file' is undef"); } try { if ( file.type != NX_VALUE_TYPE_STRING ) { throw_msg("string type required for 'file'"); } older = NX_DLIST_NEXT(arg, link); if ( older != NULL ) { ASSERT(older->expr != NULL); nx_expr_evaluate(eval_ctx, &olderval, older->expr); if ( olderval.type != NX_VALUE_TYPE_DATETIME ) { nx_value_kill(&olderval); throw_msg("datetime type required for 'older'"); } if ( olderval.defined == TRUE ) { older_time = olderval.datetime; } } if ( apr_fnmatch_test(file.string->buf) != 0 ) { // we have wildcards, expand it pool = nx_pool_create_core(); filename = file.string->buf; idx = strrchr(filename, '/'); #ifndef WIN32 flags = APR_FNM_CASE_BLIND; if ( idx == NULL ) { idx = strrchr(filename, '\\'); } #endif if ( idx == NULL ) { dirname = nx_string_create("."NX_DIR_SEPARATOR, -1); } else { dirname = nx_string_create(filename, (int) (idx + 1 - filename)); filename = idx + 1; } CHECKERR_MSG(apr_dir_open(&dir, dirname->buf, pool), "failed to open directory: %s", dirname->buf); fname = nx_string_new(); while ( apr_dir_read(&finfo, APR_FINFO_NAME | APR_FINFO_TYPE | APR_FINFO_CTIME, dir) == APR_SUCCESS ) { if ( finfo.filetype == APR_REG ) { log_debug("checking '%s' against wildcard '%s':", finfo.name, filename); if ( apr_fnmatch(filename, finfo.name, flags) == APR_SUCCESS ) { nx_string_sprintf(fname, "%s%s", dirname->buf, finfo.name); if ( (older_time == 0) || ((older_time != 0) && (finfo.ctime < older_time)) ) { log_debug("'%s' matches wildcard '%s' and is 'older', removing", fname->buf, file.string->buf); log_info("removing file %s", fname->buf); rv = apr_file_remove(fname->buf, NULL); if ( APR_STATUS_IS_ENOENT(rv) ) { } else if ( rv == APR_SUCCESS ) { } else { log_aprerror(rv, "failed to remove file '%s'", fname->buf); } _reopen_logfile(fname->buf); } } } } nx_string_free(fname); apr_pool_destroy(pool); } else { CHECKERR_MSG(apr_file_remove(file.string->buf, NULL), "failed to remove file '%s'", file.string->buf); } } catch(e) { nx_value_kill(&file); if ( pool != NULL ) { apr_pool_destroy(pool); } if ( dirname != NULL ) { nx_string_free(dirname); } log_exception(e); } }
void nx_expr_proc__xm_fileop_file_cycle(nx_expr_eval_ctx_t *eval_ctx, nx_module_t *module, nx_expr_arg_list_t *args) { nx_expr_arg_t *arg; nx_value_t file; nx_expr_arg_t *val; nx_value_t value; apr_status_t rv; apr_pool_t *pool = NULL; nx_exception_t e; volatile int64_t max = 0; int32_t i, last; nx_string_t *tmpstr = NULL; nx_string_t *tmpstr2 = NULL; ASSERT(module != NULL); ASSERT(args != NULL); arg = NX_DLIST_FIRST(args); ASSERT(arg != NULL); ASSERT(arg->expr != NULL); nx_expr_evaluate(eval_ctx, &file, arg->expr); if ( file.defined != TRUE ) { throw_msg("'file' is undef"); } if ( file.type != NX_VALUE_TYPE_STRING ) { nx_value_kill(&file); throw_msg("string type required for 'file'"); } val = NX_DLIST_NEXT(arg, link); if ( val != NULL ) { ASSERT(val->expr != NULL); nx_expr_evaluate(eval_ctx, &value, val->expr); if ( value.type != NX_VALUE_TYPE_INTEGER ) { nx_value_kill(&file); nx_value_kill(&value); throw_msg("integer type required for 'max'"); } if ( value.defined == TRUE ) { if ( value.integer <= 0 ) { nx_value_kill(&file); nx_value_kill(&value); throw_msg("'max' must be a positive integer"); } max = value.integer; } } try { pool = nx_pool_create_core(); if ( _file_exists(file.string->buf, pool) == TRUE ) { // check if the file we need to cycle exists tmpstr = nx_string_new(); tmpstr2 = nx_string_new(); last = 0; for ( i = 1; i < 2147483647 /*APR_INT32_MAX*/; i++ ) { nx_string_sprintf(tmpstr, "%s.%d", file.string->buf, i); if ( _file_exists(tmpstr->buf, pool) == FALSE ) { break; } if ( (max > 0) && (i >= max) ) { log_info("removing file %s", tmpstr->buf); if ( (rv = apr_file_remove(tmpstr->buf, NULL)) != APR_SUCCESS ) { log_aprerror(rv, "failed to remove file '%s'", tmpstr->buf); } } else { last = i; } } if ( last > 0 ) { // now starting from the last existing file, cycle them for ( i = last; i > 0; i-- ) { nx_string_sprintf(tmpstr, "%s.%d", file.string->buf, i); nx_string_sprintf(tmpstr2, "%s.%d", file.string->buf, i + 1); log_debug("cycling %s to %s", tmpstr->buf, tmpstr2->buf); if ( (rv = apr_file_rename(tmpstr->buf, tmpstr2->buf, NULL)) != APR_SUCCESS ) { log_aprerror(rv, "failed to rename file from '%s' to '%s'", tmpstr->buf, tmpstr2->buf); } } } // finally rename file to file.1 nx_string_sprintf(tmpstr, "%s.%d", file.string->buf, 1); if ( (rv = apr_file_rename(file.string->buf, tmpstr->buf, NULL)) != APR_SUCCESS ) { log_aprerror(rv, "failed to rename file from '%s' to '%s'", file.string->buf, tmpstr->buf); } _reopen_logfile(file.string->buf); nx_string_free(tmpstr); nx_string_free(tmpstr2); } apr_pool_destroy(pool); nx_value_kill(&file); } catch(e) { nx_value_kill(&file); if ( pool != NULL ) { apr_pool_destroy(pool); } if ( tmpstr != NULL ) { nx_string_free(tmpstr); } if ( tmpstr2 != NULL ) { nx_string_free(tmpstr2); } log_exception(e); } }
// return TRUE if there was an error and we need to clean up the input static boolean im_ssl_fill_buffer(nx_module_t *module, nx_module_input_t *input) { volatile int retval; SSL *ssl; int nbytes; nx_exception_t e; ASSERT(input != NULL); ASSERT(input->desc_type == APR_POLL_SOCKET); ASSERT(input->desc.s != NULL); ASSERT(input->buf != NULL); ssl = (SSL *) nx_module_input_data_get(input, "ssl"); ASSERT(ssl != NULL); if ( input->bufstart == input->bufsize ) { input->bufstart = 0; input->buflen = 0; } if ( input->buflen == 0 ) { input->bufstart = 0; } nbytes = (int) (input->bufsize - (input->buflen + input->bufstart)); if ( nbytes > 0 ) { try { retval = nx_ssl_read(ssl, input->buf + input->bufstart + input->buflen, &nbytes); } catch(e) { log_exception(e); return ( TRUE ); } ASSERT(nbytes <= (int) (input->bufsize - (input->buflen + input->bufstart))); input->buflen += nbytes; switch ( retval ) { case SSL_ERROR_NONE: log_debug("Module %s read %u bytes", input->module->name, (unsigned int) input->buflen); nx_module_pollset_add_socket(module, input->desc.s, APR_POLLIN | APR_POLLHUP); break; case SSL_ERROR_ZERO_RETURN: // disconnected log_debug("remote ssl connection closed"); return ( TRUE ); case SSL_ERROR_WANT_WRITE: log_debug("im_ssl WANT_WRITE"); nx_module_pollset_add_socket(module, input->desc.s, APR_POLLOUT | APR_POLLHUP); break; case SSL_ERROR_WANT_READ: log_debug("im_ssl WANT_READ"); nx_module_pollset_add_socket(module, input->desc.s, APR_POLLIN | APR_POLLHUP); break; default: log_error("im_ssl couldn't read, disconnecting (error code: %d)", retval); return ( TRUE ); } } else { log_debug("im_ssl_fill_buffer called with full buffer"); } return ( FALSE ); }
static void WINAPI nx_win32_svc_main(DWORD argc, LPTSTR *argv) { nx_context_t thread_context; nx_exception_t e; if ( _nxlog_initializer == 0 ) { // running from service manager ASSERT(nx_init(&argc, &argv, NULL) == TRUE); nxlog_init(&nxlog); nx_logger_disable_foreground(); } else if ( _nxlog_initializer != apr_os_thread_current() ) { // service dispatcher runs in a new thread, we need // to initialize the exception context. _nxlog_initializer = apr_os_thread_current(); memset(&thread_context, 0, sizeof(nx_context_t)); init_exception_context(&thread_context.exception_context); apr_threadkey_private_set(&thread_context, nx_get_context_key()); } log_debug("nx_win32_svc_main"); try { // read config cache nx_config_cache_read(); log_debug("nxlog cache read"); // load DSO and read and verify module config nx_ctx_config_modules(nxlog.ctx); log_debug("nxlog config OK"); // initialize modules nx_ctx_init_modules(nxlog.ctx); // initialize log routes nx_ctx_init_routes(nxlog.ctx); nx_ctx_init_jobs(nxlog.ctx); nx_ctx_restore_queues(nxlog.ctx); // setup threadpool nxlog_create_threads(&nxlog); // start modules nx_ctx_start_modules(nxlog.ctx); if ( nxlog.foreground != TRUE ) { // register to service manager svc_status_handle = RegisterServiceCtrlHandler("nxlog", nx_win32_svc_change); if ( svc_status_handle == 0 ) { nx_win32_error("RegisterServiceCtrlHandler() failed, couldn't register the service control handler"); } // Signal to svc manager that we are running svc_status.dwWin32ExitCode = 0; svc_status.dwServiceSpecificExitCode = 0; svc_status.dwCheckPoint = 0; svc_status.dwWaitHint = 0; svc_status.dwServiceType = SERVICE_WIN32; svc_status.dwCurrentState = SERVICE_RUNNING; svc_status.dwControlsAccepted = SERVICE_ACCEPT_STOP; if ( SetServiceStatus(svc_status_handle, &svc_status) == FALSE ) { nx_win32_error("Cannot send start service status update"); } } log_info(PACKAGE"-"VERSION_STRING" started"); } catch(e) { log_exception(e); log_error("exiting..."); svc_status.dwCurrentState = SERVICE_STOPPED; SetServiceStatus(svc_status_handle, &svc_status); exit(e.code); } // mainloop nxlog_mainloop(&nxlog, FALSE); nxlog_shutdown(&nxlog); if ( nxlog.foreground != TRUE ) { // Signal back that we are stopped svc_status.dwCurrentState = SERVICE_STOPPED; SetServiceStatus(svc_status_handle, &svc_status); log_debug("service stopped"); } nxlog_exit_function(); }
int cb_cpu_restore_state(CPUState *env, TranslationBlock *tb){ printf("EXCEPTION - logging\n"); DynValBuffer *dynval_buffer = PIFP->PIV->getDynvalBuffer(); log_exception(dynval_buffer); return 0; }
int main(int argc, const char * const *argv, const char * const *env) { DWORD dispmode; nx_exception_t e; ASSERT(nx_init(&argc, &argv, &env) == TRUE); nxlog_init(&nxlog); _nxlog_initializer = apr_os_thread_current(); try { // read cmd line parse_cmd_line(argc, argv); /* // reload switch? if ( nxlog.do_restart == TRUE ) { //FIXME restart service; use custom control code? } */ // stop switch? if ( nxlog.do_stop == TRUE ) { nx_win32_svc_stop(); exit(0); } if ( do_install == TRUE ) { nx_win32_svc_install(); exit(0); } if ( do_uninstall == TRUE ) { nx_win32_svc_uninstall(); exit(0); } // load and parse config nx_ctx_parse_cfg(nxlog.ctx, nxlog.cfgfile); if ( nxlog.ctx->spooldir != NULL ) { CHECKERR_MSG(apr_filepath_set(nxlog.ctx->spooldir, nxlog.pool), "Couldn't change to SpoolDir '%s'", nxlog.ctx->spooldir); } nx_ctx_init_logging(nxlog.ctx); if ( nxlog.ctx->rootdir != NULL ) { throw_msg("RootDir not supported on windows"); } if ( nxlog.verify_conf == TRUE ) { // load DSO and read and verify module config nx_ctx_config_modules(nxlog.ctx); nx_ctx_init_routes(nxlog.ctx); log_info("configuration OK"); exit(0); } if ( nxlog.foreground == TRUE ) { nx_win32_svc_main(argc, argv); } else { // detect wheter we are invoked by SVM or from the console if ( GetConsoleDisplayMode(&dispmode) == 0 ) { nx_win32_svc_dispatch(); } else { nx_win32_svc_start(argc, argv); } } } catch(e) { apr_file_t *f = NULL; apr_pool_t *pool; HKEY regkey; uint32_t regtype = 0; char regvalbuf[1024]; uint32_t regvalbufsize = 1024; const char *logfile = "c:\\nxlog-service-error.txt"; pool = nx_pool_create_core(); // TODO: log to eventlog in addition? if ( RegOpenKey(HKEY_LOCAL_MACHINE, "SOFTWARE\\nxlog", ®key) == ERROR_SUCCESS ) { if ( RegQueryValueEx(regkey, "installdir", 0, ®type, (unsigned char *) regvalbuf, ®valbufsize) == ERROR_SUCCESS ) { if ( regtype == REG_SZ ) { logfile = apr_psprintf(nxlog.pool, "%sdata\\nxlog.log", regvalbuf); } } RegCloseKey(regkey); } apr_file_open(&f, logfile, APR_READ | APR_WRITE | APR_CREATE | APR_APPEND, APR_OS_DEFAULT, pool); // FXIME: check status code if ( f != NULL ) { nx_string_t *tmpstr; int i; char errmsg[1024]; tmpstr = nx_string_new(); for ( i = ((int) e.num_throw) - 1; i >= 0; i-- ) { if ( tmpstr->len > 0 ) { nx_string_append(tmpstr, NX_LINEFEED, -1); } nx_string_append(tmpstr, e.msgbuf + e.throwlist[i].msgoffs, -1); } nx_string_append(tmpstr, NX_LINEFEED, -1); if ( e.code != APR_SUCCESS ) { apr_strerror(e.code, errmsg, sizeof(errmsg)); nx_string_append(tmpstr, errmsg, -1); nx_string_append(tmpstr, NX_LINEFEED, -1); } apr_file_printf(f, "nxlog failed to start: %s\r\n", tmpstr->buf); apr_file_close(f); nx_string_free(tmpstr); } apr_pool_destroy(pool); log_exception(e); exit(e.code); } return ( 0 ); }
static void xm_multiline_config(nx_module_t *module) { nx_xm_multiline_conf_t *modconf; const nx_directive_t * volatile curr; nx_exception_t e; modconf = apr_pcalloc(module->pool, sizeof(nx_xm_multiline_conf_t)); module->config = modconf; curr = module->directives; while ( curr != NULL ) { if ( nx_module_common_keyword(curr->directive) == TRUE ) { } else if ( strcasecmp(curr->directive, "headerline") == 0 ) { if ( modconf->headerline != NULL ) { nx_conf_error(curr, "HeaderLine is already defined"); } try { if ( (strlen(curr->args) > 1) && (curr->args[0] == '/') && (curr->args[strlen(curr->args) - 1] == '/') ) { // TODO: this is a hack because regexp and division are not correctly // handled by the lexer/parser. expr-tokens.l needs to be fixed and // needs to be stateful. curr->args[strlen(curr->args) - 1] = '\0'; modconf->headerline = nx_value_new_regexp(curr->args + 1); } else { modconf->headerline_expr = nx_expr_parse(module, curr->args, module->pool, curr->filename, curr->line_num, curr->argsstart); if ( !((modconf->headerline_expr->rettype == NX_VALUE_TYPE_STRING) || (modconf->headerline_expr->rettype == NX_VALUE_TYPE_REGEXP)) ) { throw_msg("string or regexp type required in expression, found '%s'", nx_value_type_to_string(modconf->headerline_expr->rettype)); } if ( modconf->headerline_expr->type == NX_EXPR_TYPE_VALUE ) { ASSERT(modconf->headerline_expr->value.defined == TRUE); modconf->headerline = &(modconf->headerline_expr->value); } } } catch(e) { log_exception(e); nx_conf_error(curr, "invalid expression in 'HeaderLine'"); } } else if ( strcasecmp(curr->directive, "endline") == 0 ) { if ( modconf->endline != NULL ) { nx_conf_error(curr, "EndLine is already defined"); } try { if ( (strlen(curr->args) > 1) && (curr->args[0] == '/') && (curr->args[strlen(curr->args) - 1] == '/') ) { // TODO: this is a hack because regexp and division are not correctly // handled by the lexer/parser. expr-tokens.l needs to be fixed and // needs to be stateful. curr->args[strlen(curr->args) - 1] = '\0'; modconf->endline = nx_value_new_regexp(curr->args + 1); } else { modconf->endline_expr = nx_expr_parse(module, curr->args, module->pool, curr->filename, curr->line_num, curr->argsstart); if ( !((modconf->endline_expr->rettype == NX_VALUE_TYPE_STRING) || (modconf->endline_expr->rettype == NX_VALUE_TYPE_REGEXP)) ) { throw_msg("string or regexp type required in expression, found '%s'", nx_value_type_to_string(modconf->endline_expr->rettype)); } if ( modconf->endline_expr->type == NX_EXPR_TYPE_VALUE ) { ASSERT(modconf->endline_expr->value.defined == TRUE); modconf->endline = &(modconf->endline_expr->value); } } } catch(e) { log_exception(e); nx_conf_error(curr, "invalid expression in 'Endline'"); } } else if ( strcasecmp(curr->directive, "fixedlinecount") == 0 ) { if ( modconf->fixedlinecount != 0 ) { nx_conf_error(curr, "FixedLineCount is already defined"); } if ( sscanf(curr->args, "%u", &(modconf->fixedlinecount)) != 1 ) { nx_conf_error(curr, "invalid number: %s", curr->args); } } else { nx_conf_error(curr, "invalid keyword: %s", curr->directive); } curr = curr->next; } if ( (modconf->headerline == NULL) && (modconf->endline == NULL) && (modconf->fixedlinecount == 0) ) { nx_conf_error(module->directives, "At least one of HeaderLine, EndLine or FixedLineCount is required"); } if ( (modconf->headerline != NULL) && (modconf->endline != NULL) && (nx_value_eq(modconf->headerline, modconf->endline) == TRUE) ) { nx_conf_error(module->directives, "HeaderLine and EndLine cannot be the same"); } if ( nx_module_input_func_lookup(module->name) == NULL ) { nx_module_input_func_register(NULL, module->name, &xm_multiline_input_func, module); log_debug("Inputreader '%s' registered", module->name); } }
static nx_logdata_t *xm_multiline_input_func(nx_module_input_t *input, void *data) { volatile int i; nx_logdata_t * volatile retval = NULL; boolean foundcr = FALSE; nx_xm_multiline_ctx_t *ctx; nx_xm_multiline_conf_t *modconf; nx_module_t *module; boolean appendline; boolean gotline; volatile boolean done = FALSE; ASSERT(input != NULL); ASSERT(input->buflen >= 0); ASSERT(data != NULL); if ( input->buflen == 0 ) { return ( NULL ); } if ( input->ctx == NULL ) { input->ctx = apr_pcalloc(input->pool, sizeof(nx_xm_multiline_ctx_t)); } ctx = input->ctx; module = (nx_module_t *) data; modconf = (nx_xm_multiline_conf_t *) module->config; do { foundcr = FALSE; appendline = TRUE; gotline = FALSE; for ( i = 0; (i < input->buflen) && (gotline == FALSE) ; i++ ) { switch ( input->buf[input->bufstart + i] ) { case APR_ASCII_CR: if ( foundcr == TRUE ) { gotline = TRUE; i--; } else { foundcr = TRUE; } break; case APR_ASCII_LF: if ( foundcr == TRUE ) { gotline = TRUE; i--; } else { foundcr = TRUE; } break; default: if ( foundcr == TRUE ) { gotline = TRUE; i--; } break; } } if ( ctx->tmpline == NULL ) { ctx->tmpline = nx_logdata_new_logline(input->buf + input->bufstart, i); } else { nx_logdata_append_logline(ctx->tmpline, input->buf + input->bufstart, i); } //log_info("tmpline: [%s]", ctx->tmpline->raw_event->buf); if ( foundcr == TRUE ) { // got a complete line if ( module->exec != NULL ) { nx_expr_eval_ctx_t eval_ctx; nx_exception_t e; nx_expr_eval_ctx_init(&eval_ctx, ctx->tmpline, module, input); try { nx_expr_statement_list_execute(&eval_ctx, module->exec); } catch(e) { log_exception(e); } if ( eval_ctx.logdata == NULL ) { // dropped //log_info("dropped"); appendline = FALSE; ctx->tmpline = NULL; } else { // TODO: merge fields } nx_expr_eval_ctx_destroy(&eval_ctx); } if ( appendline == TRUE ) { // not dropped size_t len; boolean gotheaderline = FALSE; boolean gotendline = FALSE; //log_info("appendline"); // ignore trailing new line for ( len = ctx->tmpline->raw_event->len; (len > 0) && ((ctx->tmpline->raw_event->buf[len - 1] == APR_ASCII_CR) || (ctx->tmpline->raw_event->buf[len - 1] == APR_ASCII_LF)); len--); // Check headerline if ( modconf->headerline != NULL ) { gotheaderline = match_line(modconf->headerline, ctx->tmpline->raw_event->buf, len); } // Check endline if ( modconf->endline != NULL ) { gotendline = match_line(modconf->endline, ctx->tmpline->raw_event->buf, len); } // log_debug("gotheader: %d gotend: %d for [%s]", gotheaderline, gotendline, // ctx->tmpline->raw_event->buf); if ( (gotendline == TRUE) && (gotheaderline == TRUE) ) { log_error("HeaderLine and Endline both match"); } //log_info("gotheaderline: %d string: [%s]", gotheaderline, ctx->tmpline->raw_event->buf); if ( ctx->logdata == NULL ) { if ( (modconf->fixedlinecount <= 0) && (gotheaderline == FALSE) ) { // return if no header is found and there is no fixed linecount //log_info("return logdata: no header, no fixed linecount"); retval = ctx->tmpline; ctx->tmpline = NULL; ctx->linecount = 0; done = TRUE; } else { ctx->logdata = ctx->tmpline; ctx->tmpline = NULL; (ctx->linecount)++; } } else { // there is saved data if ( gotendline == TRUE ) { nx_string_append(ctx->logdata->raw_event, ctx->tmpline->raw_event->buf, (int) ctx->tmpline->raw_event->len); nx_logdata_free(ctx->tmpline); ctx->tmpline = NULL; retval = ctx->logdata; ctx->logdata = NULL; done = TRUE; } else if ( gotheaderline == TRUE ) { //log_info("return logdata %lu: header ok", ctx->logdata); retval = ctx->logdata; ctx->logdata = ctx->tmpline; ctx->tmpline = NULL; (ctx->linecount)++; done = TRUE; } else { nx_string_append(ctx->logdata->raw_event, ctx->tmpline->raw_event->buf, (int) ctx->tmpline->raw_event->len); nx_logdata_free(ctx->tmpline); ctx->tmpline = NULL; (ctx->linecount)++; } } // Check FixedLineCount if ( modconf->fixedlinecount > 0 ) { if ( ctx->linecount >= modconf->fixedlinecount ) { //log_info("return logdata: fixed linecount"); retval = ctx->logdata; ctx->logdata = NULL; ctx->linecount = 0; done = TRUE; } } } } input->buflen -= i; input->bufstart += i; //log_info("buflen: %d, foundcr: %d, i: %d, linecount: %d", input->buflen, foundcr, i, ctx->linecount); if ( input->buflen <= 0 ) { done = TRUE; } } while ( done != TRUE ); if ( retval != NULL ) { nx_string_strip_crlf(retval->raw_event); } return ( retval ); }
int csl_execute(char *code, size_t size, const char *func_name, struct pack *pak, char **resptr, int *reslen) { PyObject *pCode, *pModule, *pDict, *pFunc, *pValue, *pStr; PyObject *pArgs, *pkArgs; PyMethodDef *meth; node *n; pModule = PyImport_AddModule("__builtin__"); pDict = PyModule_GetDict(pModule); for (meth = methods; meth->ml_name; meth++) { pCode = PyCFunction_New(meth, NULL); PyDict_SetItemString(pDict, meth->ml_name, pCode); } if (size == 0) { n = PyParser_SimpleParseString(code, Py_file_input); if (!n) { log_exception(); return CSL_BADCODE; } pCode = (PyObject *) PyNode_Compile(n, "lala"); PyNode_Free(n); if (!pCode) { log_exception(); return CSL_BADCODE; } } else { pCode = PyMarshal_ReadObjectFromString(code, size); if (!pCode) { log_exception(); return CSL_BADCODE; } } pModule = PyImport_ExecCodeModule("csl", pCode); Py_DECREF(pCode); if (!pModule || !PyModule_Check(pModule)) { return CSL_BADCODE; } pDict = PyModule_GetDict(pModule); if (!pDict) { Py_DECREF(pModule); return CSL_BADCODE; } pFunc = PyDict_GetItemString(pDict, func_name); if (!pFunc || !PyCallable_Check(pFunc)) { Py_DECREF(pModule); return CSL_NOFUNC; } pArgs = NULL; pkArgs = PyDict_New(); while (pak) { PyObject *p; char *t, *t2; size_t sz; if (pack_get(pak, &t, &sz) == 0) break; if (pack_get(pak, &t2, &sz) == 0) { pArgs = PyTuple_New(1); PyTuple_SetItem(pArgs, 0, PyString_FromString(t)); Py_DECREF(pkArgs); break; } p = PyString_FromStringAndSize(t2, sz); PyDict_SetItemString(pkArgs, t, p); } if (!pArgs) pArgs = PyTuple_New(0); pValue = PyObject_Call(pFunc, pArgs, pkArgs); if (!pValue) { log_exception(); Py_DECREF(pModule); return CSL_FUNCERR; } pStr = PyObject_Str(pValue); Py_DECREF(pValue); Py_DECREF(pModule); // is return value asked? if (resptr == NULL) return 0; *reslen = PyString_Size(pStr); *resptr = malloc((*reslen) + 1); if (!*resptr) { Py_DECREF(pStr); return CSL_NOMEM; } memcpy(*resptr, PyString_AsString(pStr), *reslen); (*resptr)[*reslen] = '\0'; return 0; }