static void gui_init()
{
#if !GLIB_CHECK_VERSION(2,32,0)
if (g_thread_get_initialized() == FALSE) {
g_thread_init(NULL);
lwqq_log(LOG_DEBUG, "Init the gthread system\n");
}
#endif
get_info_loop = gqq_msgloop_start("Get informain");
if (get_info_loop == NULL) {
exit(1);
}
/* initialize lwdb */
lwdb_init();
lwqq_install_dir = g_strdup(LWQQ_INSTALL_DIR);
lwqq_icons_dir = g_strdup_printf("%s/icons", lwqq_install_dir);
lwqq_buddy_status_dir = g_strdup_printf("%s/status", lwqq_icons_dir);
lwqq_user_dir = g_strdup_printf("%s/lwqq", g_get_user_config_dir());
/* Hash table for chatwindow */
lwqq_chat_window = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, NULL);
}
/* we have no fail cases yet, but maybe in the future */
static gboolean
init_pre (GOptionContext * context, GOptionGroup * group, gpointer data,
GError ** error)
{
if (gst_initialized) {
GST_DEBUG ("already initialized");
return TRUE;
}
g_type_init ();
/* we need threading to be enabled right here */
g_assert (g_thread_get_initialized ());
_gst_debug_init ();
#ifdef ENABLE_NLS
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
#endif /* ENABLE_NLS */
#ifndef GST_DISABLE_GST_DEBUG
{
const gchar *debug_list;
if (g_getenv ("GST_DEBUG_NO_COLOR") != NULL)
gst_debug_set_colored (FALSE);
debug_list = g_getenv ("GST_DEBUG");
if (debug_list) {
parse_debug_list (debug_list);
}
}
priv_gst_dump_dot_dir = g_getenv ("GST_DEBUG_DUMP_DOT_DIR");
#endif
/* This is the earliest we can make stuff show up in the logs.
* So give some useful info about GStreamer here */
GST_INFO ("Initializing GStreamer Core Library version %s", VERSION);
GST_INFO ("Using library installed in %s", LIBDIR);
/* Print some basic system details if possible (OS/architecture) */
#ifdef HAVE_SYS_UTSNAME_H
{
struct utsname sys_details;
if (uname (&sys_details) == 0) {
GST_INFO ("%s %s %s %s %s", sys_details.sysname,
sys_details.nodename, sys_details.release, sys_details.version,
sys_details.machine);
}
}
#endif
return TRUE;
}
void core_init() {
// setup runtime
setlocale(LC_ALL, "C.UTF-8");
// do not terminate yet
g_termination = FALSE;
g_provider_config = NULL;
g_provider_queue = NULL;
g_provider_log = NULL;
// setup signal handling
struct sigaction signal;
signal.sa_handler = signal_handler;
sigemptyset(&signal.sa_mask);
signal.sa_flags = 0;
sigaction(SIGHUP, &signal, NULL);
sigaction(SIGINT, &signal, NULL); // CTRL+C [stty intr "^C"]
sigaction(SIGQUIT, &signal, NULL); // CTRL+\ [stty quit "^\\"]
sigaction(SIGTERM, &signal, NULL);
sigaction(SIGUSR1, &signal, NULL);
sigaction(SIGUSR2, &signal, NULL);
// init threads
#ifndef G_THREADS_ENABLED
#error "Threads not supported by GLib!"
#endif
#ifdef G_THREADS_IMPL_NONE
#error "No threads implementation in GLib!"
#endif
if (!g_thread_get_initialized()) {
g_thread_init(NULL);
if (!g_thread_get_initialized()) {
return;
}
}
// allocate global variables
g_options = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, g_free);
g_modules = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify) core_module_unload_ptr);
}
void libMaryInit ()
{
{
static bool initialized = false;
if (initialized) {
return;
}
initialized = true;
}
// Setting numeric locale for snprintf() to behave uniformly in all cases.
// Specifically, we need dot ('.') to be used as a decimal separator.
if (setlocale (LC_NUMERIC, "C") == NULL)
fprintf (stderr, "WARNING: Could not set LC_NUMERIC locale to \"C\"\n");
#ifndef LIBMARY_PLATFORM_WIN32
// GStreamer calls setlocale(LC_ALL, ""), which is lame. We fight this with setenv().
if (setenv ("LC_NUMERIC", "C", 1 /* overwrite */) == -1)
perror ("WARNING: Could not set LC_NUMERIC environment variable to \"C\"");
#endif
#ifdef LIBMARY_MT_SAFE
#ifdef LIBMARY__OLD_GTHREAD_API
if (!g_thread_get_initialized ())
g_thread_init (NULL);
#endif
#endif
initStatCounters ();
_libMary_stat = new (std::nothrow) Stat;
assert (_libMary_stat);
libMary_threadLocalInit ();
libMary_platformInit ();
// log*() logging is now available.
if (!updateTime ())
logE_ (_func, exc->toString());
#ifdef LIBMARY_ENABLE_MWRITEV
libMary_mwritevInit ();
#endif
randomSetSeed ((Uint32) getTimeMicroseconds());
}
/**
* gst_init_check:
* @argc: (inout) (allow-none): pointer to application's argc
* @argv: (inout) (array length=argc) (allow-none): pointer to application's argv
* @err: pointer to a #GError to which a message will be posted on error
*
* Initializes the GStreamer library, setting up internal path lists,
* registering built-in elements, and loading standard plugins.
*
* This function will return %FALSE if GStreamer could not be initialized
* for some reason. If you want your program to fail fatally,
* use gst_init() instead.
*
* This function should be called before calling any other GLib functions. If
* this is not an option, your program must initialise the GLib thread system
* using g_thread_init() before any other GLib functions are called.
*
* Returns: %TRUE if GStreamer could be initialized.
*/
gboolean
gst_init_check (int *argc, char **argv[], GError ** err)
{
#ifndef GST_DISABLE_OPTION_PARSING
GOptionGroup *group;
GOptionContext *ctx;
#endif
gboolean res;
if (!g_thread_get_initialized ())
g_thread_init (NULL);
if (gst_initialized) {
GST_DEBUG ("already initialized gst");
return TRUE;
}
#ifndef GST_DISABLE_OPTION_PARSING
ctx = g_option_context_new ("- GStreamer initialization");
g_option_context_set_ignore_unknown_options (ctx, TRUE);
group = gst_init_get_option_group ();
g_option_context_add_group (ctx, group);
res = g_option_context_parse (ctx, argc, argv, err);
g_option_context_free (ctx);
#else
init_pre (NULL, NULL, NULL, NULL);
init_post (NULL, NULL, NULL, NULL);
res = TRUE;
#endif
gst_initialized = res;
if (res) {
GST_INFO ("initialized GStreamer successfully");
} else {
GST_INFO ("failed to initialize GStreamer");
}
return res;
}
int main(int argc, char **argv)
{
int rc;
struct upnp_device_descriptor *upnp_renderer;
if (!process_cmdline(argc, argv)) {
return EXIT_FAILURE;
}
if (show_version) {
do_show_version();
exit(EXIT_SUCCESS);
}
if (show_connmgr_scpd) {
upnp_renderer_dump_connmgr_scpd();
exit(EXIT_SUCCESS);
}
if (show_control_scpd) {
upnp_renderer_dump_control_scpd();
exit(EXIT_SUCCESS);
}
if (show_transport_scpd) {
upnp_renderer_dump_transport_scpd();
exit(EXIT_SUCCESS);
}
if (show_outputs) {
output_dump_modules();
exit(EXIT_SUCCESS);
}
init_logging(log_file);
// Now we're going to start threads etc, which means we need
// to become a daemon before that.
// We need to open the pid-file now because relative filenames will
// break if we're becoming a daemon and cwd changes.
FILE *pid_file_stream = NULL;
if (pid_file) {
pid_file_stream = fopen(pid_file, "w");
}
if (daemon_mode) {
daemon(0, 0); // TODO: check for daemon() in configure.
}
if (pid_file_stream) {
fprintf(pid_file_stream, "%d\n", getpid());
fclose(pid_file_stream);
}
#if !GLIB_CHECK_VERSION(2, 32, 0)
// Only older version of glib require this.
if (!g_thread_get_initialized()) {
g_thread_init(NULL);
}
#endif
upnp_renderer = upnp_renderer_descriptor(friendly_name, uuid);
if (upnp_renderer == NULL) {
return EXIT_FAILURE;
}
rc = output_init(output);
if (rc != 0) {
Log_error("main",
"ERROR: Failed to initialize Output subsystem");
return EXIT_FAILURE;
}
struct upnp_device *device;
if (listen_port != 0 &&
(listen_port < 49152 || listen_port > 65535)) {
// Somewhere obscure internally in libupnp, they clamp the
// port to be outside of the IANA range, so at least 49152.
// Instead of surprising the user by ignoring lower port
// numbers, complain loudly.
Log_error("main", "Parameter error: --port needs to be in "
"range [49152..65535] (but was set to %d)",
listen_port);
return EXIT_FAILURE;
}
device = upnp_device_init(upnp_renderer, ip_address, listen_port);
if (device == NULL) {
Log_error("main", "ERROR: Failed to initialize UPnP device");
return EXIT_FAILURE;
}
upnp_transport_init(device);
upnp_control_init(device);
if (show_devicedesc) {
// This can only be run after all services have been
// initialized.
char *buf = upnp_create_device_desc(upnp_renderer);
assert(buf != NULL);
fputs(buf, stdout);
exit(EXIT_SUCCESS);
}
if (Log_info_enabled()) {
upnp_transport_register_variable_listener(log_variable_change,
(void*) "transport");
upnp_control_register_variable_listener(log_variable_change,
(void*) "control");
}
// Write both to the log (which might be disabled) and console.
Log_info("main", "Ready for rendering.");
fprintf(stderr, "Ready for rendering.\n");
output_loop();
// We're here, because the loop exited. Probably due to catching
// a signal.
Log_info("main", "Exiting.");
upnp_device_shutdown(device);
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
int rc;
int result = EXIT_FAILURE;
struct device *upnp_renderer;
rc = process_cmdline(argc, argv);
if (rc != 0) {
goto out;
}
if (show_version) {
do_show_version();
exit(EXIT_SUCCESS);
}
if (show_connmgr_scpd) {
upnp_renderer_dump_connmgr_scpd();
exit(EXIT_SUCCESS);
}
if (show_control_scpd) {
upnp_renderer_dump_control_scpd();
exit(EXIT_SUCCESS);
}
if (show_transport_scpd) {
upnp_renderer_dump_transport_scpd();
exit(EXIT_SUCCESS);
}
if (show_outputs) {
output_dump_modules();
exit(EXIT_SUCCESS);
}
if (pid_file && pid_file[0] != '/') {
// We need to canonicalize the filename because our
// cwd will change after becoming a daemon.
char *buf = (char*) malloc(PATH_MAX); // will leak. Ok.
char *result = getcwd(buf, PATH_MAX);
result = strcat(result, "/");
pid_file = strcat(result, pid_file);
}
if (daemon_mode) {
daemon(0, 0); // TODO: check for daemon() in configure.
}
if (pid_file) {
FILE *p = fopen(pid_file, "w+");
if (p) {
fprintf(p, "%d\n", getpid());
fclose(p);
} else {
perror("Failed to write pid file");
}
}
if (!g_thread_get_initialized()) {
g_thread_init(NULL);
}
upnp_renderer = upnp_renderer_new(friendly_name, uuid);
if (upnp_renderer == NULL) {
goto out;
}
if (show_devicedesc) {
char *buf;
buf = upnp_get_device_desc(upnp_renderer);
assert(buf != NULL);
fputs(buf, stdout);
exit(EXIT_SUCCESS);
}
rc = output_init(output);
if (rc != 0) {
fprintf(stderr,"ERROR: Failed to initialize Output subsystem\n");
goto out;
}
struct device_private *device;
device = upnp_device_init(upnp_renderer, ip_address);
if (device == NULL) {
fprintf(stderr,"ERROR: Failed to initialize UPnP device\n");
goto out;
}
upnp_transport_init(device);
upnp_control_init();
printf("Ready for rendering..\n");
output_loop();
result = EXIT_SUCCESS;
out:
return result;
}
struct rspamd_worker *
rspamd_fork_worker (struct rspamd_main *rspamd_main,
struct rspamd_worker_conf *cf,
guint index,
struct event_base *ev_base)
{
struct rspamd_worker *wrk;
gint rc;
struct rlimit rlim;
/* Starting worker process */
wrk = (struct rspamd_worker *) g_malloc0 (sizeof (struct rspamd_worker));
if (!rspamd_socketpair (wrk->control_pipe)) {
msg_err ("socketpair failure: %s", strerror (errno));
exit (-errno);
}
if (!rspamd_socketpair (wrk->srv_pipe)) {
msg_err ("socketpair failure: %s", strerror (errno));
exit (-errno);
}
wrk->srv = rspamd_main;
wrk->type = cf->type;
wrk->cf = cf;
REF_RETAIN (cf);
wrk->index = index;
wrk->ctx = cf->ctx;
wrk->finish_actions = g_ptr_array_new ();
wrk->pid = fork ();
switch (wrk->pid) {
case 0:
/* Update pid for logging */
rspamd_log_update_pid (cf->type, rspamd_main->logger);
/* Init PRNG after fork */
rc = ottery_init (rspamd_main->cfg->libs_ctx->ottery_cfg);
if (rc != OTTERY_ERR_NONE) {
msg_err_main ("cannot initialize PRNG: %d", rc);
abort ();
}
rspamd_random_seed_fast ();
#ifdef HAVE_EVUTIL_RNG_INIT
evutil_secure_rng_init ();
#endif
/* Remove the inherited event base */
event_reinit (rspamd_main->ev_base);
event_base_free (rspamd_main->ev_base);
/* Drop privilleges */
rspamd_worker_drop_priv (rspamd_main);
/* Set limits */
rspamd_worker_set_limits (rspamd_main, cf);
/* Re-set stack limit */
getrlimit (RLIMIT_STACK, &rlim);
rlim.rlim_cur = 100 * 1024 * 1024;
rlim.rlim_max = rlim.rlim_cur;
setrlimit (RLIMIT_STACK, &rlim);
setproctitle ("%s process", cf->worker->name);
rspamd_pidfile_close (rspamd_main->pfh);
/* Do silent log reopen to avoid collisions */
rspamd_log_close (rspamd_main->logger);
rspamd_log_open (rspamd_main->logger);
wrk->start_time = rspamd_get_calendar_ticks ();
#if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION <= 30))
# if (GLIB_MINOR_VERSION > 20)
/* Ugly hack for old glib */
if (!g_thread_get_initialized ()) {
g_thread_init (NULL);
}
# else
g_thread_init (NULL);
# endif
#endif
msg_info_main ("starting %s process %P (%d)", cf->worker->name,
getpid (), index);
/* Close parent part of socketpair */
close (wrk->control_pipe[0]);
close (wrk->srv_pipe[0]);
rspamd_socket_nonblocking (wrk->control_pipe[1]);
rspamd_socket_nonblocking (wrk->srv_pipe[1]);
/* Execute worker */
cf->worker->worker_start_func (wrk);
exit (EXIT_FAILURE);
break;
case -1:
msg_err_main ("cannot fork main process. %s", strerror (errno));
rspamd_pidfile_remove (rspamd_main->pfh);
exit (-errno);
break;
default:
/* Close worker part of socketpair */
close (wrk->control_pipe[1]);
close (wrk->srv_pipe[1]);
rspamd_socket_nonblocking (wrk->control_pipe[0]);
rspamd_socket_nonblocking (wrk->srv_pipe[0]);
rspamd_srv_start_watching (wrk, ev_base);
/* Insert worker into worker's table, pid is index */
g_hash_table_insert (rspamd_main->workers, GSIZE_TO_POINTER (
wrk->pid), wrk);
break;
}
return wrk;
}
GOptionGroup *
gst_init_get_option_group (void)
{
#ifndef GST_DISABLE_OPTION_PARSING
GOptionGroup *group;
static const GOptionEntry gst_args[] = {
{"gst-version", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
(gpointer) parse_goption_arg, N_("Print the GStreamer version"), NULL},
{"gst-fatal-warnings", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
(gpointer) parse_goption_arg, N_("Make all warnings fatal"), NULL},
#ifndef GST_DISABLE_GST_DEBUG
{"gst-debug-help", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
(gpointer) parse_goption_arg,
N_("Print available debug categories and exit"),
NULL},
{"gst-debug-level", 0, 0, G_OPTION_ARG_CALLBACK,
(gpointer) parse_goption_arg,
N_("Default debug level from 1 (only error) to 5 (anything) or "
"0 for no output"),
N_("LEVEL")},
{"gst-debug", 0, 0, G_OPTION_ARG_CALLBACK, (gpointer) parse_goption_arg,
N_("Comma-separated list of category_name:level pairs to set "
"specific levels for the individual categories. Example: "
"GST_AUTOPLUG:5,GST_ELEMENT_*:3"),
N_("LIST")},
{"gst-debug-no-color", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
(gpointer) parse_goption_arg, N_("Disable colored debugging output"),
NULL},
{"gst-debug-disable", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
(gpointer) parse_goption_arg, N_("Disable debugging"), NULL},
#endif
{"gst-plugin-spew", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
(gpointer) parse_goption_arg,
N_("Enable verbose plugin loading diagnostics"),
NULL},
{"gst-plugin-path", 0, 0, G_OPTION_ARG_CALLBACK,
(gpointer) parse_goption_arg,
N_("Colon-separated paths containing plugins"), N_("PATHS")},
{"gst-plugin-load", 0, 0, G_OPTION_ARG_CALLBACK,
(gpointer) parse_goption_arg,
N_("Comma-separated list of plugins to preload in addition to the "
"list stored in environment variable GST_PLUGIN_PATH"),
N_("PLUGINS")},
{"gst-disable-segtrap", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
(gpointer) parse_goption_arg,
N_("Disable trapping of segmentation faults during plugin loading"),
NULL},
{"gst-disable-registry-update", 0, G_OPTION_FLAG_NO_ARG,
G_OPTION_ARG_CALLBACK,
(gpointer) parse_goption_arg,
N_("Disable updating the registry"),
NULL},
{"gst-disable-registry-fork", 0, G_OPTION_FLAG_NO_ARG,
G_OPTION_ARG_CALLBACK,
(gpointer) parse_goption_arg,
N_("Disable spawning a helper process while scanning the registry"),
NULL},
{NULL}
};
/* Since GLib 2.23.2 calling g_thread_init() 'late' is allowed and is
* automatically done as part of g_type_init() */
if (glib_check_version (2, 23, 3)) {
/* The GLib threading system must be initialised before calling any other
* GLib function according to the documentation; if the application hasn't
* called gst_init() yet or initialised the threading system otherwise, we
* better issue a warning here (since chances are high that the application
* has already called other GLib functions such as g_option_context_new() */
if (!g_thread_get_initialized ()) {
g_warning ("The GStreamer function gst_init_get_option_group() was\n"
"\tcalled, but the GLib threading system has not been initialised\n"
"\tyet, something that must happen before any other GLib function\n"
"\tis called. The application needs to be fixed so that it calls\n"
"\t if (!g_thread_get_initialized ()) g_thread_init(NULL);\n"
"\tas very first thing in its main() function. Please file a bug\n"
"\tagainst this application.");
g_thread_init (NULL);
}
} else {
/* GLib >= 2.23.2 */
}
group = g_option_group_new ("gst", _("GStreamer Options"),
_("Show GStreamer Options"), NULL, NULL);
g_option_group_set_parse_hooks (group, (GOptionParseFunc) init_pre,
(GOptionParseFunc) init_post);
g_option_group_add_entries (group, gst_args);
g_option_group_set_translation_domain (group, GETTEXT_PACKAGE);
return group;
#else
return NULL;
#endif
}
void libMaryInit ()
{
{
static bool initialized = false;
if (initialized) {
return;
}
initialized = true;
}
// Setting numeric locale for snprintf() to behave uniformly in all cases.
// Specifically, we need dot ('.') to be used as a decimal separator.
if (setlocale (LC_NUMERIC, "C") == NULL)
fprintf (stderr, "WARNING: Could not set LC_NUMERIC locale to \"C\"\n");
#ifndef LIBMARY_PLATFORM_WIN32
// GStreamer calls setlocale(LC_ALL, ""), which is lame. We fight this with setenv().
if (setenv ("LC_NUMERIC", "C", 1 /* overwrite */) == -1)
perror ("WARNING: Could not set LC_NUMERIC environment variable to \"C\"");
#endif
#ifdef LIBMARY_MT_SAFE
#ifdef LIBMARY__OLD_GTHREAD_API
if (!g_thread_get_initialized ())
g_thread_init (NULL);
#endif
#endif
_libMary_stat = new Stat;
libMary_threadLocalInit ();
libMary_platformInit ();
// log*() logging is now available.
if (!updateTime ())
logE_ (_func, exc->toString());
#ifdef LIBMARY_ENABLE_MWRITEV
libMary_mwritevInit ();
#endif
randomSetSeed ((Uint32) getTime());
#ifdef LIBMARY_PLATFORM_WIN32
WSADATA wsaData;
WORD wVersionRequested = MAKEWORD(2, 2);
int res = WSAStartup(wVersionRequested, &wsaData);
if (res != 0) {
logE_ (_func_, "WSAStartup failed");
} else {
if (LOBYTE(wsaData.wVersion) != 2 ||
HIBYTE(wsaData.wVersion) != 2) {
logE_ (_func_, "Could not find a requested version of Winsock.dll");
WSACleanup();
}
else {
logD_ (_func_, "The Winsock 2.2 dll was found");
}
}
#endif
}
int main(int argc, char *argv[]) {
char *format = "auto";
char *optstring = "m:M:f:";
int c, opt_index = 0;
int files = 0;
char *kb_name = NULL;
char *model[argc], *uri[argc];
char *model_default = NULL;
int help=0;
static struct option long_options[] = {
{ "model", 1, 0, 'm' },
{ "model-default", 1, 0, 'M' },
{ "format", 1, 0, 'f' },
};
for (int i= 0; i < argc; ++i) {
model[i] = NULL;
}
while ((c = getopt_long (argc, argv, optstring, long_options, &opt_index)) != -1) {
if (c == 'm') {
model[files++] = optarg;
} else if (c == 'M') {
model_default = optarg;
} else if (c == 'f') {
format = optarg;
} else {
help = 1;
fprintf(stderr, "Unknown parameter '%c' \n", c);
fprintf(stderr, "Usage: %s <kbname> <rdf file/URI> ...\n", argv[0]);
fprintf(stderr, " -m --model specify a model URI for the next RDF file\n");
fprintf(stderr, " -M --model-default specify a model URI for all RDF files\n");
fprintf(stderr, " -f --format specify an RDF syntax for the import\n");
exit(1);
}
}
files = 0;
for (int k = optind; k < argc; ++k) {
if (!kb_name) {
kb_name = argv[k];
} else {
uri[files] = g_strdup(argv[k]);
if (!model[files]) {
if (!model_default) {
model[files] = uri[files];
} else {
model[files] = model_default;
}
}
files++;
}
}
if (help || !kb_name || files == 0) {
help = 1;
fprintf(stderr, "Usage: %s <kbname> <rdf file/URI> ...\n", argv[0]);
fprintf(stderr, " -m --model specify a model URI for the next RDF file\n");
fprintf(stderr, " -M --model-default specify a model URI for all RDF files\n");
fprintf(stderr, " -f --format specify an RDF syntax for the import\n");
exit(1);
}
if (!g_thread_get_initialized())
g_thread_init(NULL);
if (!fs_hash_uri)
fs_hash_init();
//g_mem_set_vtable(glib_mem_profiler_table);
//g_atexit(g_mem_profile);
int res = do_import(kb_name,uri,model,format,files);
#if 0
printf("press enter\n");
char foo;
#endif
exit(res);
}
int
BMI_AVULSION_Initialize (const char *config_file, BMI_Model **handle)
{
int rtn = BMI_FAILURE;
if (!g_thread_get_initialized ()) {
g_thread_init (NULL);
eh_init_glib ();
g_log_set_handler (NULL, G_LOG_LEVEL_MASK, &eh_logger, NULL);
}
if (handle) {
BMI_Model *self = avulsion_init (NULL);
if (self) {
int shape[2] = {30, 40};
double spacing[2] = {1, 1};
int hinge_indices[2] = {0, 20};
double angle_limit[2] = {60., 120.};
double variance = 10.;
double bed_load_exponent = 1.;
double discharge_exponent = 1.;
int number_of_river_mouths = 9;
if (config_file) {
FILE *fp = fopen (config_file, "r");
if (fp) {
fscanf (fp, "%d, %d\n", &shape[1], &shape[0]);
fscanf (fp, "%lf, %lf\n", &spacing[1], &spacing[0]);
fscanf (fp, "%d, %d\n", &hinge_indices[1], &hinge_indices[0]);
fscanf (fp, "%lf, %lf\n", &angle_limit[0], &angle_limit[1]);
fscanf (fp, "%lf\n", &variance);
fscanf (fp, "%lf\n", &bed_load_exponent);
fscanf (fp, "%lf\n", &discharge_exponent);
fscanf (fp, "%d\n", &number_of_river_mouths);
}
else
return BMI_FAILURE_UNABLE_TO_OPEN_ERROR;
}
//else
// return BMI_FAILURE;
angle_limit[0] *= 3.14/180.;
angle_limit[1] *= 3.14/180.;
variance *= 3.14/180.;
avulsion_set_grid (self, shape, spacing);
avulsion_set_river_hinge (self, hinge_indices);
avulsion_set_river_angle_limit (self, angle_limit);
avulsion_set_variance (self, variance);
avulsion_set_bed_load_exponent (self, bed_load_exponent);
avulsion_set_discharge_exponent (self, discharge_exponent);
avulsion_set_total_river_mouths (self, number_of_river_mouths);
avulsion_set_discharge (self, 1000.);
avulsion_set_sed_flux (self, 250.);
set_input_var_names (self);
set_output_var_names (self);
*handle = self;
rtn = BMI_SUCCESS;
}
else
rtn = BMI_FAILURE_UNKNOWN_ERROR;
}
else
rtn = BMI_FAILURE_BAD_ARGUMENT_ERROR;
return rtn;
}
struct rspamd_worker *
rspamd_fork_worker (struct rspamd_main *rspamd_main,
struct rspamd_worker_conf *cf,
guint index)
{
struct rspamd_worker *cur;
/* Starting worker process */
cur = (struct rspamd_worker *) g_malloc0 (sizeof (struct rspamd_worker));
if (!rspamd_socketpair (cur->control_pipe)) {
msg_err ("socketpair failure: %s", strerror (errno));
exit (-errno);
}
cur->srv = rspamd_main;
cur->type = cf->type;
cur->cf = g_malloc (sizeof (struct rspamd_worker_conf));
memcpy (cur->cf, cf, sizeof (struct rspamd_worker_conf));
cur->index = index;
cur->ctx = cf->ctx;
cur->pid = fork ();
switch (cur->pid) {
case 0:
/* Update pid for logging */
rspamd_log_update_pid (cf->type, rspamd_main->logger);
/* Lock statfile pool if possible XXX */
/* Init PRNG after fork */
ottery_init (NULL);
g_random_set_seed (ottery_rand_uint32 ());
/* Drop privilleges */
rspamd_worker_drop_priv (rspamd_main);
/* Set limits */
rspamd_worker_set_limits (rspamd_main, cf);
setproctitle ("%s process", cf->worker->name);
rspamd_pidfile_close (rspamd_main->pfh);
/* Do silent log reopen to avoid collisions */
rspamd_log_close (rspamd_main->logger);
rspamd_log_open (rspamd_main->logger);
cur->start_time = rspamd_get_calendar_ticks ();
#if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION <= 30))
# if (GLIB_MINOR_VERSION > 20)
/* Ugly hack for old glib */
if (!g_thread_get_initialized ()) {
g_thread_init (NULL);
}
# else
g_thread_init (NULL);
# endif
#endif
msg_info_main ("starting %s process %P", cf->worker->name, getpid ());
/* Close parent part of socketpair */
close (cur->control_pipe[0]);
rspamd_socket_nonblocking (cur->control_pipe[1]);
/* Execute worker */
cf->worker->worker_start_func (cur);
break;
case -1:
msg_err_main ("cannot fork main process. %s", strerror (errno));
rspamd_pidfile_remove (rspamd_main->pfh);
exit (-errno);
break;
default:
/* Close worker part of socketpair */
close (cur->control_pipe[1]);
rspamd_socket_nonblocking (cur->control_pipe[0]);
/* Insert worker into worker's table, pid is index */
g_hash_table_insert (rspamd_main->workers, GSIZE_TO_POINTER (
cur->pid), cur);
break;
}
return cur;
}
gint
main (gint argc,
gchar *argv[])
{
GError *error = NULL;
#ifdef G_OS_WIN32
/* Reduce risks */
{
typedef BOOL (WINAPI *t_SetDllDirectoryA) (LPCSTR lpPathName);
t_SetDllDirectoryA p_SetDllDirectoryA;
p_SetDllDirectoryA = GetProcAddress (GetModuleHandle ("kernel32.dll"), "SetDllDirectoryA");
if (p_SetDllDirectoryA)
(*p_SetDllDirectoryA) ("");
}
#ifndef _WIN64
{
typedef BOOL (WINAPI *t_SetProcessDEPPolicy) (DWORD dwFlags);
t_SetProcessDEPPolicy p_SetProcessDEPPolicy;
p_SetProcessDEPPolicy = GetProcAddress (GetModuleHandle ("kernel32.dll"), "SetProcessDEPPolicy");
if (p_SetProcessDEPPolicy)
(*p_SetProcessDEPPolicy) (PROCESS_DEP_ENABLE | PROCESS_DEP_DISABLE_ATL_THUNK_EMULATION);
}
#endif
if (fileno (stdout) != -1 && _get_osfhandle (fileno (stdout)) != -1) {
/* stdout is fine, presumably redirected to a file or pipe */
} else {
typedef BOOL (* WINAPI AttachConsole_t) (DWORD);
AttachConsole_t p_AttachConsole =
(AttachConsole_t) GetProcAddress (GetModuleHandle ("kernel32.dll"), "AttachConsole");
if (p_AttachConsole && p_AttachConsole (ATTACH_PARENT_PROCESS)) {
freopen ("CONOUT$", "w", stdout);
dup2 (fileno (stdout), 1);
freopen ("CONOUT$", "w", stderr);
dup2 (fileno (stderr), 2);
}
}
#endif
static GOptionEntry entries[] = {
{ "socket",
's',
G_OPTION_FLAG_IN_MAIN,
G_OPTION_ARG_INT,
&socket_id,
/* TRANSLATORS: don't translate the terms in brackets */
N_("ID of the socket to embed in"),
N_("socket") },
{ G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &remaining_args, NULL, NULL },
{ NULL, 0, 0, 0, NULL, NULL, NULL }
};
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
setlocale (LC_ALL, NULL);
if (!gtk_init_with_args (&argc, &argv, NULL, entries, NULL, &error))
g_error ("%s", error->message);
if (!g_thread_get_initialized ())
g_thread_init (NULL);
e_passwords_init ();
categories_icon_theme_hack ();
create_default_shell ();
gtk_main ();
return 0;
}