/** * Finalize PC Groups: free DBMaps and config. * @public */ void do_final_pc_groups(void) { if (pc_group_db != NULL) db_destroy(pc_group_db); if (pc_groupname_db != NULL ) db_destroy(pc_groupname_db); destroy_config(); }
static void set_config(CONFIG **config, char *data, int length, char *filename) { char name[256]; char val[256]; CONFIG_ENTRY **prev, *p; int pos; init_config(FALSE); GUI_printf("wtf2\n"); if (*config) { destroy_config(*config); *config = NULL; } *config = malloc(sizeof(CONFIG)); if (!(*config)) return; (*config)->head = NULL; (*config)->dirty = FALSE; if (filename) { (*config)->filename = malloc(strlen(filename)+1); if ((*config)->filename) strcpy((*config)->filename, filename); } else (*config)->filename = NULL; prev = &(*config)->head; pos = 0; while (pos < length) { pos += get_line(data+pos, length-pos, name, val); p = malloc(sizeof(CONFIG_ENTRY)); if (!p) return; if (name[0]) { p->name = malloc(strlen(name)+1); if (p->name) strcpy(p->name, name); } else p->name = NULL; p->data = malloc(strlen(val)+1); if (p->data) strcpy(p->data, val); p->next = NULL; *prev = p; prev = &p->next; } }
/* config_cleanup: * Called at shutdown time to free memory being used by the config routines, * and write any changed data out to disk. */ void config_cleanup() { CONFIG_HOOK *hook, *nexthook; int i; for (i=0; i<MAX_CONFIGS; i++) { if (config[i]) { destroy_config(config[i]); config[i] = NULL; } } if (config_override) { destroy_config(config_override); config_override = NULL; } if (config_language) { destroy_config(config_language); config_language = NULL; } if (system_config) { destroy_config(system_config); system_config = NULL; } if (config_hook) { hook = config_hook; while (hook) { if (hook->section) free(hook->section); nexthook = hook->next; free(hook); hook = nexthook; } config_hook = NULL; } // _remove_exit_func(config_cleanup); config_installed = FALSE; }
/* config_cleanup: * Called at shutdown time to free memory being used by the config routines, * and write any changed data out to disk. */ static void config_cleanup() { int i; for (i=0; i<MAX_CONFIGS; i++) { if (config[i]) { destroy_config(config[i]); config[i] = NULL; } } if (config_override) { destroy_config(config_override); config_override = NULL; } /* _remove_exit_func(config_cleanup);*/ config_installed = FALSE; }
int main(int argc, char* argv[]) { // Parse command line arguments. if (! set_config(argc, argv)) { exit(-1); } // Use default Citrusleaf client logging, but set a filter. cf_set_log_level(CF_WARN); // Connect to the database server cluster. if (! start_cluster_management()) { stop_cluster_management(); destroy_config(); exit(-1); } // Set up an array of event bases and thread IDs on the stack. base bases[g_config.num_bases]; // Make these globally available. g_bases = bases; // Set up an array of record keys on the stack. ev2citrusleaf_object keys[g_config.num_keys]; // Make these globally available. g_keys = keys; // Start transactions on all the bases. start_transactions(); // Wait for everything to finish, then exit cleanly. block_until_transactions_done(); stop_cluster_management(); destroy_config(); LOG("example3 is done"); return 0; }
/* push_config_state: * Pushes the current config state onto the stack. */ void push_config_state() { int i; if (config[MAX_CONFIGS-1]) destroy_config(config[MAX_CONFIGS-1]); for (i=MAX_CONFIGS-1; i>0; i--) config[i] = config[i-1]; config[0] = NULL; }
/* pop_config_state: * Pops the current config state off the stack. */ void pop_config_state() { int i; if (config[0]) destroy_config(config[0]); for (i=0; i<MAX_CONFIGS-1; i++) config[i] = config[i+1]; config[MAX_CONFIGS-1] = NULL; }
static void run(Options *options) { int socket = open_udp_socket(options->listen_port); if (options->verbose) fprintf(stderr, "Opened socket on port %d\n", options->listen_port); if (signal(SIGQUIT, handle_sigquit) == SIG_IGN) signal(SIGQUIT, SIG_IGN); reload_config = 1; while (1) { int sleep_time; if (reload_config) { if (options->config != NULL) destroy_config(options->config); options->config = load_config(options->config_filename); if (!options->config) { fprintf(stderr, "Warning: Config file cannot be read: %s\n", options->config_filename); options->config = create_config(); } initialise_config(options->config); if (options->verbose) { fprintf(stderr, "Loaded config from %s\n", options->config_filename); print_config(options->config, stderr); } reload_config = 0; } //TODO how long until the next request goes out? sleep_time = 1; input_timeout(socket, sleep_time); check_for_responses(options, socket); check_requests(options, socket); } close(socket); }
void destroy_supervisor(supervisor_thread_t *thiz) { if(thiz) { int w = 0; for(w = 0; w < thiz->config->num_workers; w++) { destroy_worker(thiz->worker_threads[w]); } thiz->worker_threads = NULL; destroy_rate_limiter(thiz->rate_limiter); destroy_queue(thiz->queue); destroy_config(thiz->config); destroy_worker_array(); TESR_LOG_FREE(thiz, supervisor_thread_t); free(thiz); thiz = NULL; } else { LOG_ERROR("can not free supervisor_thread_t* as it is NULL"); } }
static int ss7_unload_module(void) { cli_unregister(); #ifdef SCCP sccp_cleanup(); #endif isup_cleanup(); cleanup_dump(0, 1, 1); if(monitor_running) { stop_monitor(); } stop_mtp_thread(); mtp_cleanup(); timers_cleanup(); destroy_config(); ast_verbose(VERBOSE_PREFIX_3 "SS7 channel unloaded.\n"); return AST_MODULE_LOAD_SUCCESS; }
/* load_config_file: * Does the work of loading a config file. */ static void load_config_file(CONFIG **config, char *filename, char *savefile) { int length; GUI_printf("wtf\n"); if (*config) { destroy_config(*config); *config = NULL; } length = file_size(filename); GUI_printf("wtf3\n"); if (length > 0) { FS_lock(); FILE *f = fopen(filename, "rb"); if (f) { char *tmp = malloc(length); if (tmp) { fread(tmp, 1, length, f); set_config(config, tmp, length, savefile); free(tmp); } else set_config(config, NULL, 0, savefile); fclose(f); } else set_config(config, NULL, 0, savefile); FS_unlock(); } else set_config(config, NULL, 0, savefile); }
int main(int argc, char *argv[]) { char *user = NULL; char *input = NULL; char *output = NULL; int input_location = 0; bool multiple_input = false; bool one_passed = false; bool output_is_dir = false; struct config cfg; int c; while((c=getopt(argc, argv, "hdu:")) != -1) { switch(c) { case 'u': user = optarg; break; case 'h': usage(argv[0]); exit(NO_ERROR); case 'd': _debug = 1; break; case '?': if(strchr("u", optopt) == NULL) fprintf(stderr, "Unknown option -%c encountered\n", optopt); else fprintf(stderr, "Option -%c requires an argument\n", optopt); exit(USAGE_ERROR); default: abort(); } } debug("optind: %d, argc: %d", optind, argc); if(optind + 2 == argc) { input = argv[optind]; output = argv[optind + 1]; multiple_input = false; } else if (optind + 2 < argc) { input_location = optind; output = argv[argc - 1]; multiple_input = true; } else { fprintf(stderr, "Invalid number of arguments\n"); usage(argv[0]); exit(USAGE_ERROR); } if(user == NULL) { fprintf(stderr, "Error, user must be supplied with -u <user> argument\n" "\tRerun with -h to see usage-details\n"); exit(USAGE_ERROR); } /* All of these functions exit the program unless everything is A-OK */ read_config(CONFIG_PATH, &cfg); /* If the user running the program doesn't match the config-file, exit */ die_unless_user(cfg.required_user); /* Try to become target user iff. they are a member of the right group */ if_valid_become(user, cfg.required_group); /* Append a '/' if the output is a dir and it doesn't have one */ output = dirify_output(output, &output_is_dir); debug("output now: %s (%d)", output, output_is_dir); /* If the output path isn't in the list of allowed outputs, exit */ validate_output(output, cfg.allowed_paths); destroy_config(&cfg); /* Do the actual copy, failing on any error condition */ if(!multiple_input) { copy_file(input, output); } else { struct stat sb; char *p; int i; if(!output_is_dir) log_exit(USAGE_ERROR, "Error: destination %s must be a directory", output); debug("Multiple inputs, %d files to %s", argc - input_location - 1, output); for(i = input_location; i < argc - 1; i++) { p = argv[i]; if(stat(p, &sb) < 0) log_exit_perror(FILEPERM_ERROR, "stat input: %s", p); switch(sb.st_mode & S_IFMT) { case S_IFREG: debug("************** Copy file %d ****************", i - input_location + 1); copy_file(p, output); one_passed = true; break; case S_IFDIR: log_msg("%s is a directory, skipping", p); break; default: log_msg("%s is not a regular file, skip", p); break; } } } /* changed by dirify() above */ free(output); if(multiple_input && !one_passed) { debug("No files copied, exit NO_ACTION_ERROR"); return NO_ACTION_ERROR; } else { debug("Finished, exit OK"); return NO_ERROR; } }
static void set_config(CONFIG **config, char *data, int length, char *filename) { char name[256]; char val[256]; CONFIG_SECTION **prev, *p; CONFIG_ENTRY **prev_e, *p_e; int pos; int in_section = 0; init_config(FALSE); if (*config) { destroy_config(*config); *config = NULL; } *config = malloc(sizeof(CONFIG)); if (!(*config)) return; (*config)->head = NULL; (*config)->dirty = FALSE; if (filename) { (*config)->filename = malloc(strlen(filename)+1); if ((*config)->filename) strcpy((*config)->filename, filename); } else (*config)->filename = NULL; prev = &(*config)->head; pos = 0; while (pos < length) { pos += get_line(data+pos, length-pos, name, val); if (in_section && name[0] == '[') { in_section = 0; } if (in_section) { p_e = malloc(sizeof(CONFIG_ENTRY)); if (!p_e) return; if (name[0]) { p_e->name = malloc(strlen(name)+1); if (p_e->name) strcpy(p_e->name, name); } else p_e->name = NULL; p_e->data = malloc(strlen(val)+1); if (p_e->data) strcpy(p_e->data, val); p_e->next = NULL; *prev_e = p_e; prev_e = &p_e->next; continue; } p = malloc(sizeof(CONFIG_SECTION)); if (!p) return; p->key = NULL; if (name[0]) { p->name = malloc(strlen(name)+1); if (p->name) strcpy(p->name, name); } else p->name = NULL; p->data = malloc(strlen(val)+1); if (p->data) strcpy(p->data, val); p->next = NULL; *prev = p; prev = &p->next; // FIXME if (name[0] == '[') { prev_e = &p->head; in_section = 1; } } }
static DBusMessage *create_proxy_config(DBusConnection *conn, DBusMessage *msg, void *user_data) { DBusMessage *reply; DBusMessageIter iter, array; struct proxy_config *config; const char *sender, *method = NULL, *interface = NULL; const char *url = NULL, *script = NULL; char **servers = NULL, **excludes = NULL; char **domains = NULL, **nameservers = NULL; sender = dbus_message_get_sender(msg); dbus_message_iter_init(msg, &iter); dbus_message_iter_recurse(&iter, &array); while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) { DBusMessageIter entry, value, list; const char *key; dbus_message_iter_recurse(&array, &entry); dbus_message_iter_get_basic(&entry, &key); dbus_message_iter_next(&entry); dbus_message_iter_recurse(&entry, &value); switch (dbus_message_iter_get_arg_type(&value)) { case DBUS_TYPE_STRING: if (g_str_equal(key, "Method")) { dbus_message_iter_get_basic(&value, &method); if (strlen(method) == 0) method = NULL; } else if (g_str_equal(key, "URL")) { dbus_message_iter_get_basic(&value, &url); if (strlen(url) == 0) url = NULL; } else if (g_str_equal(key, "Script")) { dbus_message_iter_get_basic(&value, &script); if (strlen(script) == 0) script = NULL; } else if (g_str_equal(key, "Interface")) { dbus_message_iter_get_basic(&value, &interface); if (strlen(interface) == 0) interface = NULL; } break; case DBUS_TYPE_ARRAY: dbus_message_iter_recurse(&value, &list); if (dbus_message_iter_get_arg_type(&list) == DBUS_TYPE_INVALID) break; if (g_str_equal(key, "Servers")) { g_strfreev(servers); servers = extract_string_array(&list); } else if (g_str_equal(key, "Excludes")) { g_strfreev(excludes); excludes = extract_string_array(&list); } else if (g_str_equal(key, "Domains")) { g_strfreev(domains); domains = extract_string_array(&list); } else if (g_str_equal(key, "Nameservers")) { g_strfreev(nameservers); nameservers = extract_string_array(&list); } break; } dbus_message_iter_next(&array); } DBG("sender %s method %s interface %s", sender, method, interface); DBG("url %s script %p", url, script); if (!method) { reply = g_dbus_create_error(msg, PACRUNNER_ERROR_INTERFACE ".Failed", "No proxy method specified"); goto done; } config = create_config(conn, sender, interface); if (!config) { reply = g_dbus_create_error(msg, PACRUNNER_ERROR_INTERFACE ".Failed", "Memory allocation failed"); goto done; } config->domains = domains; config->nameservers = nameservers; domains = NULL; nameservers = NULL; if (g_str_equal(method, "direct")) { if (pacrunner_proxy_set_direct(config->proxy) < 0) pacrunner_error("Failed to set direct proxy"); } else if (g_str_equal(method, "manual")) { if (pacrunner_proxy_set_manual(config->proxy, servers, excludes) < 0) pacrunner_error("Failed to set proxy servers"); } else if (g_str_equal(method, "auto")) { if (pacrunner_proxy_set_auto(config->proxy, url, script) < 0) pacrunner_error("Failed to set auto proxy"); } else { destroy_config(config); reply = g_dbus_create_error(msg, PACRUNNER_ERROR_INTERFACE ".Failed", "Invalid proxy method specified"); goto done; } g_hash_table_insert(config_list, config->path, config); reply = g_dbus_create_reply(msg, DBUS_TYPE_OBJECT_PATH, &config->path, DBUS_TYPE_INVALID); done: g_strfreev(servers); g_strfreev(excludes); g_strfreev(domains); g_strfreev(nameservers); return reply; }
extern int fini ( void ) { destroy_config(); return SLURM_SUCCESS; }
int reload_config(void) { destroy_config(); return load_config(); }
struct config* parse_config(FILE *input) { struct config *config = malloc(sizeof(struct config)); if (config == NULL) { stats_error_log("malloc() error"); return NULL; } init_proto_config(&config->carbon_config); if (config->carbon_config.ring == NULL) { stats_error_log("failed to allocate ring"); free(config); return NULL; } config->carbon_config.bind = strdup("127.0.0.1:2003"); init_proto_config(&config->statsd_config); config->statsd_config.bind = strdup("127.0.0.1:8125"); yaml_parser_t parser; yaml_event_t event; if (!yaml_parser_initialize(&parser)) { stats_log("failed to initialize yaml parser"); goto parse_err; } yaml_parser_set_input_file(&parser, input); struct proto_config *protoc = NULL; char *strval; long numval; int shard_count = -1; int map_nesting = 0; bool in_document = false; bool keep_going = true; bool is_key = false; bool update_bind = false; bool update_send_queue = false; bool update_validate = false; bool update_tcp_cork = false; bool always_resolve_dns = false; bool expect_shard_map = false; while (keep_going) { if (!yaml_parser_parse(&parser, &event)) { goto parse_err; } switch(event.type) { case YAML_NO_EVENT: case YAML_STREAM_START_EVENT: break; // nothing to do case YAML_STREAM_END_EVENT: keep_going = false; break; case YAML_DOCUMENT_START_EVENT: if (in_document) { stats_error_log("config should not have nested documents"); goto parse_err; } in_document = true; break; case YAML_DOCUMENT_END_EVENT: in_document = false; break; case YAML_SEQUENCE_START_EVENT: case YAML_SEQUENCE_END_EVENT: stats_error_log("unexpectedly got sequence"); goto parse_err; break; case YAML_MAPPING_START_EVENT: is_key = true; map_nesting++; break; case YAML_MAPPING_END_EVENT: map_nesting--; break; case YAML_ALIAS_EVENT: stats_error_log("don't know how to handle yaml aliases"); goto parse_err; break; case YAML_SCALAR_EVENT: strval = (char *) event.data.scalar.value; switch (map_nesting) { case 0: stats_error_log("unexpectedly got scalar outside of a map"); goto parse_err; break; case 1: if (strcmp(strval, "carbon") == 0) { protoc = &config->carbon_config; config->carbon_config.initialized = true; } else if (strcmp(strval, "statsd") == 0) { protoc = &config->statsd_config; config->statsd_config.initialized = true; } else { stats_error_log("unexpectedly got map value: \"%s\"", strval); goto parse_err; } break; case 2: if (is_key) { if (strcmp(strval, "bind") == 0) { update_bind = true; } else if (strcmp(strval, "max_send_queue") == 0) { update_send_queue = true; } else if (strcmp(strval, "shard_map") == 0) { shard_count = -1; expect_shard_map = true; } else if (strcmp(strval, "validate") == 0) { update_validate = true; } else if (strcmp(strval, "tcp_cork") == 0) { update_tcp_cork = true; } else if (strcmp(strval, "always_resolve_dns") == 0) { always_resolve_dns = true; } } else { if (update_bind) { free(protoc->bind); protoc->bind = strdup(strval); update_bind = false; } else if (update_send_queue) { if (!convert_number(strval, &numval)) { stats_error_log("max_send_queue was not a number: %s", strval); } protoc->max_send_queue = numval; update_send_queue = false; } else if (update_validate) { if (!set_boolean(strval, &protoc->enable_validation)) { goto parse_err; } update_validate = false; } else if (update_tcp_cork) { if (!set_boolean(strval, &protoc->enable_tcp_cork)) { goto parse_err; } update_tcp_cork = false; } else if (always_resolve_dns) { if (!set_boolean(strval, &protoc->always_resolve_dns)) { goto parse_err; } } } break; case 3: if (!expect_shard_map) { stats_error_log("was not expecting shard map"); goto parse_err; } else if (is_key) { if (!convert_number(strval, &numval)) { stats_error_log("shard key was not a number: \"%s\"", strval); goto parse_err; } shard_count++; if (numval != shard_count) { stats_error_log("expected to see shard key %d, instead saw %d", shard_count, numval); goto parse_err; } } else { if (statsrelay_list_expand(protoc->ring) == NULL) { stats_error_log("unable to expand list"); goto parse_err; } if ((protoc->ring->data[protoc->ring->size - 1] = strdup(strval)) == NULL) { stats_error_log("failed to copy string"); goto parse_err; } } } is_key = !is_key; break; default: stats_error_log("unhandled yaml event"); goto parse_err; } yaml_event_delete(&event); } yaml_parser_delete(&parser); return config; parse_err: destroy_config(config); yaml_event_delete(&event); yaml_parser_delete(&parser); return NULL; }
//------------------------------------------------ // Parse command line options. // static bool set_config(int argc, char* argv[]) { g_config.p_host = DEFAULT_HOST; g_config.port = DEFAULT_PORT; g_config.p_namespace = DEFAULT_NAMESPACE; g_config.p_set = DEFAULT_SET; g_config.trigger_usec = DEFAULT_TRIGGER_USEC; g_config.timeout_msec = DEFAULT_TIMEOUT_MSEC; g_config.num_bases = DEFAULT_NUM_BASES; g_config.num_keys = DEFAULT_NUM_KEYS; int c; while ((c = getopt(argc, argv, "h:p:n:s:u:m:b:k:")) != -1) { switch (c) { case 'h': g_config.p_host = strdup(optarg); break; case 'p': g_config.port = atoi(optarg); break; case 'n': g_config.p_namespace = strdup(optarg); break; case 's': g_config.p_set = strdup(optarg); break; case 'u': g_config.trigger_usec = atoi(optarg); break; case 'm': g_config.timeout_msec = atoi(optarg); break; case 'b': g_config.num_bases = atoi(optarg); break; case 'k': g_config.num_keys = atoi(optarg); break; default: destroy_config(); usage(); return false; } } LOG("host: %s", g_config.p_host); LOG("port: %d", g_config.port); LOG("namespace: %s", g_config.p_namespace); LOG("set name: %s", g_config.p_set); LOG("transaction trigger: every %d usec", g_config.trigger_usec); LOG("transaction timeout: %d msec", g_config.timeout_msec); LOG("number of bases: %d", g_config.num_bases); LOG("number of keys: %d", g_config.num_keys); return true; }
int main (int argc, char **argv) { #ifdef G_OS_WIN32 extern void link_shutdown (void); #endif GConfClient *client; #if DEVELOPMENT gboolean skip_warning_dialog; #endif GnomeProgram *program; GnomeClient *master_client; GOptionContext *context; char *filename; /* Make ElectricFence work. */ free (malloc (10)); bindtextdomain (GETTEXT_PACKAGE, EVOLUTION_LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); context = g_option_context_new (_("- The Evolution PIM and Email Client")); g_option_context_add_main_entries (context, options, GETTEXT_PACKAGE); g_option_context_set_translation_domain(context, GETTEXT_PACKAGE); #ifdef G_OS_WIN32 set_paths (); #endif program = gnome_program_init (PACKAGE, VERSION, LIBGNOMEUI_MODULE, argc, argv, GNOME_PROGRAM_STANDARD_PROPERTIES, GNOME_PARAM_GOPTION_CONTEXT, context, GNOME_PARAM_HUMAN_READABLE_NAME, _("Evolution"), NULL); #ifdef G_OS_WIN32 if (strcmp (_(""), "") == 0) { /* No message catalog installed for the current locale language, * so don't bother with the localisations provided by other things then * either. Reset thread locale to "en-US" and C library locale to "C". */ SetThreadLocale (MAKELCID (MAKELANGID (LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT)); setlocale (LC_ALL, "C"); } #endif if (start_online && start_offline) { fprintf (stderr, _("%s: --online and --offline cannot be used together.\n Use %s --help for more information.\n"), argv[0], argv[0]); exit (1); } if (killev) { filename = g_build_filename (EVOLUTION_TOOLSDIR, "killev", NULL); execl (filename, "killev", NULL); /* Not reached */ exit (0); } client = gconf_client_get_default (); #if DEVELOPMENT if (force_migrate) { destroy_config (client); } #endif if (disable_preview) { gconf_client_set_bool (client, "/apps/evolution/mail/display/show_preview", FALSE, NULL); gconf_client_set_bool (client, "/apps/evolution/mail/display/safe_list", TRUE, NULL); gconf_client_set_bool (client, "/apps/evolution/addressbook/display/show_preview", FALSE, NULL); gconf_client_set_bool (client, "/apps/evolution/calendar/display/show_task_preview", FALSE, NULL); } setup_segv_redirect (); if (evolution_debug_log) { int fd; fd = g_open (evolution_debug_log, O_WRONLY | O_CREAT | O_TRUNC, 0600); if (fd != -1) { dup2 (fd, STDOUT_FILENO); dup2 (fd, STDERR_FILENO); close (fd); } else g_warning ("Could not set up debugging output file."); } master_client = gnome_master_client (); g_signal_connect (G_OBJECT (master_client), "save_yourself", G_CALLBACK (gnome_master_client_save_yourself_cb), NULL); g_signal_connect (G_OBJECT (master_client), "die", G_CALLBACK (gnome_master_client_die_cb), NULL); glade_init (); e_cursors_init (); e_icon_factory_init (); e_passwords_init(); gtk_window_set_default_icon_name ("evolution"); if (setup_only) exit (0); gnome_sound_init ("localhost"); if (!disable_eplugin) { e_plugin_register_type(e_plugin_lib_get_type()); e_plugin_hook_register_type(es_menu_hook_get_type()); e_plugin_hook_register_type(es_event_hook_get_type()); #ifdef ENABLE_PROFILING e_plugin_hook_register_type(e_profile_event_hook_get_type()); #endif e_plugin_hook_register_type(e_plugin_type_hook_get_type()); e_plugin_hook_register_type(e_import_hook_get_type()); e_plugin_hook_register_type(E_TYPE_PLUGIN_UI_HOOK); e_plugin_load_plugins(); } #if DEVELOPMENT skip_warning_dialog = gconf_client_get_bool ( client, SKIP_WARNING_DIALOG_KEY, NULL); if (!skip_warning_dialog && !getenv ("EVOLVE_ME_HARDER")) gconf_client_set_bool ( client, SKIP_WARNING_DIALOG_KEY, show_development_warning (), NULL); else g_idle_add ((GSourceFunc) idle_cb, remaining_args); #else g_idle_add ((GSourceFunc) idle_cb, remaining_args); #endif g_object_unref (client); bonobo_main (); e_icon_factory_shutdown (); g_object_unref (program); gnome_sound_shutdown (); e_cursors_shutdown (); #ifdef G_OS_WIN32 link_shutdown (); #endif return 0; }
int main(int argc, char **argv) { char *config_name = (char *) default_config; int8_t c = 0; while (c != -1) { c = (int8_t)getopt_long(argc, argv, "c:h", long_options, NULL); switch (c) { case -1: break; case 0: case 'h': print_help(argv[0]); return 0; case 'c': config_name = optarg; break; default: printf("%s: Unknown argument %c\n", argv[0], c); return 1; } } if (optind != 1 && optind != 3) { printf("%s: unexpected command optoins\n", argv[0]); return 1; } FILE *config_file = fopen(config_name, "r"); if (config_file == NULL) { fprintf(stderr, "failed to open %s\n", config_name); return 1; } struct config *app_cfg = parse_config(config_file); fclose(config_file); if (app_cfg == NULL) { fprintf(stderr, "failed to parse config %s\n", config_name); return 1; } hashring_t carbon_ring = NULL, statsd_ring = NULL; if (app_cfg->carbon_config.initialized) { carbon_ring = hashring_load_from_config( &app_cfg->carbon_config, NULL, my_strdup, free); } if (app_cfg->statsd_config.initialized) { statsd_ring = hashring_load_from_config( &app_cfg->statsd_config, NULL, my_strdup, free); } destroy_config(app_cfg); uint32_t shard; char *choice = NULL; char *line = NULL; size_t len; ssize_t bytes_read; while ((bytes_read = getline(&line, &len, stdin)) != -1) { // trim whitespace for (ssize_t i = 0; i < bytes_read; i++) { if (isspace(line[i])) { line[i] = '\0'; break; } } printf("key=%s", line); if (carbon_ring != NULL) { choice = hashring_choose(carbon_ring, line, &shard); if (choice != NULL) { printf(" carbon=%s carbon_shard=%d", choice, shard); } } if (statsd_ring != NULL) { choice = hashring_choose(statsd_ring, line, &shard); if (choice != NULL) { printf(" statsd=%s statsd_shard=%d", choice, shard); } } putchar('\n'); fflush(stdout); } free(line); hashring_dealloc(carbon_ring); hashring_dealloc(statsd_ring); return 0; }
int main ( int argc, char** argv ) { FILE* pipe; SHAREDBUFFER* shared_buffer; CONFIG* config; char main_process_lifetime[15]; int producer_count = 0; char producer_lifetime[15]; int consumer_count = 0; int child_exit_status = 0; int child_exit_pid; int child_pid; int i = 0; int logfd; char message[150]; char dir[255]; int available_process_count = 10000; strncpy(dir, argv[0], last_index_of(argv[0], '/')); chdir(dir); logfd = log_open_file( NULL ); if ( !logfd ) { printf("Unable to open log file.\n"); return EXIT_FAILURE; } log_event( "--------------------------------" ); log_event( "Main process started." ); // first of all load configuration file config = load_config_file(); if ( !config ) { log_event( "Unable to access configuration." ); return EXIT_FAILURE; } // read values from configuration producer_count = atoi(read_configuration(config, "producer_count", "5")); consumer_count = atoi(read_configuration(config, "consumer_count", "2")); strcpy(producer_lifetime, read_configuration(config, "producer_lifetime", "10")); strcpy(main_process_lifetime, read_configuration(config, "main_process_lifetime", "40")); destroy_config( config ); log_event( "Fetching available process count of system." ); pipe = popen(PROCESS_COUNT_SCRIPT, "r"); if ( pipe ) { fgets(message, 100, pipe); pclose(pipe); available_process_count = atoi(message); } if ( producer_count + consumer_count + 1 > available_process_count ) { log_event( "Requested total process count is more than available process count of system." ); goto SAFE_EXIT; } //initialize shared buffer shared_buffer = create_shared_buffer(); if ( !shared_buffer ) { log_event( "Unable to initialize shared buffer." ); destroy_config( config ); return EXIT_FAILURE; } // create and start producer processes // producer processes run for a specified lifetime ( in seconds ) // which is read from configuration for ( i=0; i<producer_count; ++i) { child_pid = vfork(); if ( child_pid == 0 ) // producer process { execl("producer", "producer", producer_lifetime, NULL); exit(0); } } // start consumer processes // consumer processes run until a SIGKILL signal // there is no specific entry in the requirements that // when a consumer process should end. for ( i=0; i<consumer_count; ++i) { child_pid = vfork(); if ( child_pid == 0 ) // consumer process { execl("consumer", "consumer", NULL); exit(0); } } // start controller process // controller process checks elapsed time // once in every 5 seconds // if total execution time is above a specified time (in seconds) // signals all child processes except itself, to force exit child_pid = vfork(); if ( child_pid == 0 ) //controller process { execl("controller", "controller", main_process_lifetime, NULL); exit(0); } // in order to catch all child processes exits // we need a common wait for all them // here exitting processes is cought with pid and exit status // wait childs to exit while( (child_exit_pid = wait(&child_exit_status)) > 0 ) { sprintf( message, "Process [PID:%d] exitid with status: %d", child_exit_pid, child_exit_status ); log_event( message ); } SAFE_EXIT: log_event( "Main process is being closed." ); // relase allocated data structures to OS destroy_shared_buffer( shared_buffer ); log_close_file( ); return EXIT_SUCCESS; }