DirectResult direct_signals_initialize( void ) { #ifndef ANDROID_NDK sigset_t mask; int i; #endif D_DEBUG_AT( Direct_Signals, "Initializing...\n" ); direct_recursive_mutex_init( &handlers_lock ); #ifdef ANDROID_NDK install_handlers(); #else if (direct_config->sighandler) { if (direct_config->sighandler_thread) { sigemptyset( &mask ); for (i=0; i<NUM_SIGS_TO_HANDLE; i++) sigaddset( &mask, sigs_to_handle[i] ); pthread_sigmask( SIG_BLOCK, &mask, NULL ); sighandler_thread = direct_thread_create( DTT_CRITICAL, handle_signals, NULL, "SigHandler" ); D_ASSERT( sighandler_thread != NULL ); } else install_handlers(); } #endif return DR_OK; }
Q_DECL_EXPORT void Init_plasma_applet() { rb_require("korundum4"); // need to initialize the core runtime first init_plasma_Smoke(); set_qtruby_embedded(true); binding = QtRuby::Binding(plasma_Smoke); smokeList << plasma_Smoke; QtRubyModule module = { "Plasma", resolve_classname_plasma, 0, &binding }; qtruby_modules[plasma_Smoke] = module; install_handlers(Plasma_handlers); plasma_module = rb_define_module("Plasma"); plasma_internal_module = rb_define_module_under(plasma_module, "Internal"); rb_define_singleton_method(plasma_module, "method_missing", (VALUE (*) (...)) plasma_module_method_missing, -1); rb_define_singleton_method(plasma_module, "const_missing", (VALUE (*) (...)) plasma_module_method_missing, -1); rb_define_singleton_method(plasma_internal_module, "getClassList", (VALUE (*) (...)) getClassList, 0); rb_require("KDE/plasma.rb"); rb_funcall(plasma_internal_module, rb_intern("init_all_classes"), 0); }
/* Register a cleanup function to be executed when a catchable fatal signal occurs. */ void at_fatal_signal (action_t action) { static bool cleanup_initialized = false; if (!cleanup_initialized) { install_handlers (); cleanup_initialized = true; } if (actions_count == actions_allocated) { /* Extend the actions array. Note that we cannot use xrealloc(), because then the cleanup() function could access an already deallocated array. */ actions_entry_t *old_actions = actions; size_t new_actions_allocated = 2 * actions_allocated; actions_entry_t *new_actions = xmalloc (new_actions_allocated * sizeof (actions_entry_t)); memcpy (new_actions, old_actions, actions_allocated * sizeof (actions_entry_t)); actions = new_actions; actions_allocated = new_actions_allocated; /* Now we can free the old actions array. */ if (old_actions != static_actions) free (old_actions); } /* The two uses of 'volatile' in the types above (and ISO C 99 section 5.1.2.3.(5)) ensure that we increment the actions_count only after the new action has been written to the memory location actions[actions_count]. */ actions[actions_count].action = action; actions_count++; }
Q_DECL_EXPORT void Init_soprano() { init_soprano_Smoke(); binding = QtRuby::Binding(soprano_Smoke); smokeList << soprano_Smoke; QtRubyModule module = { "Soprano", resolve_classname_soprano, 0, &binding }; qtruby_modules[soprano_Smoke] = module; install_handlers(Soprano_handlers); soprano_module = rb_define_module("Soprano"); soprano_internal_module = rb_define_module_under(soprano_module, "Internal"); rb_define_singleton_method(soprano_internal_module, "getClassList", (VALUE (*) (...)) getClassList, 0); (void) qRegisterMetaType<Soprano::Statement>(); (void) qRegisterMetaType<Soprano::Node>(); rb_require("soprano/soprano.rb"); rb_funcall(soprano_internal_module, rb_intern("init_all_classes"), 0); }
DirectResult direct_signals_initialize( void ) { D_DEBUG_AT( Direct_Signals, "Initializing...\n" ); direct_recursive_mutex_init( &handlers_lock ); install_handlers(); return DR_OK; }
void PayguideInit() { /* Init variables from payguide namespace */ payguide::namespace_init(); ReloadConfigIfImportant(); if (curl_global_init(CURL_GLOBAL_ALL)!=0) { printf("CURL init failed! Payguide shutdown.\n"); exit(1); } /* Deatch from console */ if (payguide::daemonize==1) { if (Daemonize()!=0) { LogWrite(LOGMSG_ERROR, "Daemonize failed!"); } } my_init(); DBVeryFirstInit(); OperatorsInit(); OpenSSLInit(); StatisticInit(); /* Catching TERM signal - shut down server */ struct sigaction sterm; memset (&sterm, 0, sizeof(sterm)); sterm.sa_handler=&SigHandler; sigaction(SIGTERM, &sterm, NULL); /* Catching INT signal - shut down server */ struct sigaction sint; memset (&sint, 0, sizeof(sint)); sint.sa_handler=&SigHandler; sigaction(SIGINT, &sint, NULL); atexit (CleanUp); /* Init backtrace */ #ifdef ENABLE_BACKTRACE open_backtrace_fd(payguide::backtrace_file.c_str()); install_handlers() ; #endif }
/* Register a cleanup function to be executed when a catchable fatal signal occurs. */ void at_fatal_signal (action_t action) { static bool cleanup_initialized = false; if (!cleanup_initialized) { init_fatal_signals (); install_handlers (); cleanup_initialized = true; } if (actions_count == actions_allocated) { /* Extend the actions array. Note that we cannot use xrealloc(), because then the cleanup() function could access an already deallocated array. */ actions_entry_t *old_actions = actions; size_t old_actions_allocated = actions_allocated; size_t new_actions_allocated = 2 * actions_allocated; actions_entry_t *new_actions = XNMALLOC (new_actions_allocated, actions_entry_t); size_t k; /* Don't use memcpy() here, because memcpy takes non-volatile arguments and is therefore not guaranteed to complete all memory stores before the next statement. */ for (k = 0; k < old_actions_allocated; k++) new_actions[k] = old_actions[k]; actions = new_actions; actions_allocated = new_actions_allocated; /* Now we can free the old actions array. */ if (old_actions != static_actions) free (old_actions); } /* The two uses of 'volatile' in the types above (and ISO C 99 section 5.1.2.3.(5)) ensure that we increment the actions_count only after the new action has been written to the memory location actions[actions_count]. */ actions[actions_count].action = action; actions_count++; }
Q_DECL_EXPORT void Init_nepomuk() { init_nepomuk_Smoke(); binding = QtRuby::Binding(nepomuk_Smoke); smokeList << nepomuk_Smoke; QtRubyModule module = { "Nepomuk", resolve_classname_nepomuk, 0, &binding }; qtruby_modules[nepomuk_Smoke] = module; install_handlers(Nepomuk_handlers); nepomuk_module = rb_define_module("Nepomuk"); nepomuk_internal_module = rb_define_module_under(nepomuk_module, "Internal"); rb_define_singleton_method(nepomuk_internal_module, "getClassList", (VALUE (*) (...)) getClassList, 0); rb_require("nepomuk/nepomuk.rb"); rb_funcall(nepomuk_internal_module, rb_intern("init_all_classes"), 0); }
static void _init(void) { int i; acf_t f_error_addr; fcode_env_t *env; NOTICE; fcode_impl_count = 0; env = MALLOC(sizeof (fcode_env_t)); env->table = MALLOC((MAX_FCODE + 1) * sizeof (fcode_token)); env->base = MALLOC(dict_size); env->here = env->base; env->ds = env->ds0 = MALLOC(stack_size * sizeof (fstack_t)); env->rs = env->rs0 = MALLOC(stack_size * sizeof (fstack_t)); env->order = MALLOC(MAX_ORDER * sizeof (token_t)); env->input = MALLOC(sizeof (input_typ)); env->num_base = 0x10; /* Setup the initial forth environment */ do_forth(env); do_definitions(env); install_handlers(env); initial_env = env; /* * Need to define this early because it is the default for * all unimpl, FCODE functions */ P1275(0x0fc, IMMEDIATE, "ferror", f_error); f_error_addr = LINK_TO_ACF(env->lastlink); for (i = 0; i <= MAX_FCODE; i++) { DEBUGF(ANY, env->table[i].usage = 0); SET_TOKEN(i, IMMEDIATE, "ferror", f_error_addr); } fcode_impl_count = 0; }
Q_DECL_EXPORT void Init_phonon() { init_phonon_Smoke(); binding = QtRuby::Binding(phonon_Smoke); smokeList << phonon_Smoke; QtRubyModule module = { "Phonon", resolve_classname_phonon, 0, &binding }; qtruby_modules[phonon_Smoke] = module; install_handlers(Phonon_handlers); phonon_module = rb_define_module("Phonon"); phonon_internal_module = rb_define_module_under(phonon_module, "Internal"); rb_define_singleton_method(phonon_internal_module, "getClassList", (VALUE (*) (...)) getClassList, 0); rb_require("phonon/phonon.rb"); rb_funcall(phonon_internal_module, rb_intern("init_all_classes"), 0); }
Q_DECL_EXPORT void Init_qtdeclarative() { init_qtdeclarative_Smoke(); binding = QtRuby::Binding(qtdeclarative_Smoke); smokeList << qtdeclarative_Smoke; QtRubyModule module = { "QtDeclarative", resolve_classname_qtdeclarative, 0, &binding }; qtruby_modules[qtdeclarative_Smoke] = module; install_handlers(QtDeclarative_handlers); qtdeclarative_module = rb_define_module("QtDeclarative"); qtdeclarative_internal_module = rb_define_module_under(qtdeclarative_module, "Internal"); rb_define_singleton_method(qtdeclarative_internal_module, "getClassList", (VALUE (*) (...)) getClassList, 0); rb_require("qtdeclarative/qtdeclarative.rb"); rb_funcall(qtdeclarative_internal_module, rb_intern("init_all_classes"), 0); }
Q_DECL_EXPORT void Init_qscintilla() { init_qsci_Smoke(); binding = QtRuby::Binding(qsci_Smoke); smokeList << qsci_Smoke; QtRubyModule module = { "Qsci", resolve_classname_qsci, 0, &binding }; qtruby_modules[qsci_Smoke] = module; install_handlers(QScintilla_handlers); qscintilla_module = rb_define_module("Qsci"); qscintilla_internal_module = rb_define_module_under(qscintilla_module, "Internal"); rb_define_singleton_method(qscintilla_internal_module, "getClassList", (VALUE (*) (...)) getClassList, 0); rb_require("qscintilla/qscintilla.rb"); rb_funcall(qscintilla_internal_module, rb_intern("init_all_classes"), 0); }
int main( int argc, const char* argv[] ) { /* WORKTODO ... args handling */ int fd; void* region; char* fname = FNAME; unsigned offset = 0; unsigned length = 0x100000; int rc; unsigned fill_value = 0xdeadbeef; enum MODE { M_READ, M_WRITE, M_FILL, M_TEST, M_NOP } mode = M_READ; struct poptOption opt_table[] = { { "device", 'f', POPT_ARG_STRING, &fname, 0 }, { "help", 'h', POPT_ARG_NONE, 0, 'h' }, { "read", 'r', POPT_ARG_NONE, 0, 'r' }, { "write", 'w', POPT_ARG_NONE, 0, 'w' }, { "nop", 'n', POPT_ARG_NONE, 0, 'n' }, { "fill", 'b', POPT_ARG_NONE, 0, 'f' }, { "offset", 'o', POPT_ARG_INT, &offset, 'o' }, { "length", 'l', POPT_ARG_INT, &length, 'l' }, { "value", 'v', POPT_ARG_INT, &fill_value, 0 }, { "regstest", 'T', POPT_ARG_NONE, 0, 'T' }, { "verbose", 'V', POPT_ARG_INT, &acq200_debug, 0 }, { } }; poptContext opt_context; opt_context = poptGetContext( argv[0], argc, argv, opt_table, 0 ); int open_mode = O_RDONLY; int mmap_mode = PROT_READ; while ( (rc = poptGetNextOpt( opt_context )) > 0 ){ switch( rc ){ case 'h': fprintf( stderr, HELP ); return 1; case 'r': mode = M_READ; break; case 'w': open_mode = O_RDWR; mmap_mode = PROT_READ|PROT_WRITE; mode = M_WRITE; break; case 'n': mode = M_NOP; break; case 'f': open_mode = O_RDWR; mmap_mode = PROT_READ|PROT_WRITE; mode = M_FILL; break; case 'T': mode = M_TEST; break; } } // processes all other opts via arg pointers if ( (fd = open( fname, open_mode)) < 0 ){ fprintf( stderr, "mmap: failed to open device \"%s\" - ", fname ); perror( "" ); return 1; } region = mmap( NULL, length, mmap_mode, MAP_SHARED, fd, 0 ); if ( region == (caddr_t)-1 ){ perror( "mmap" ); return 1; } switch( mode ){ default: case M_READ: // spew to stdout in one big blurt write( 1, (char*)region+offset, length ); break; case M_FILL: { unsigned* praw = (unsigned*)&((char*)region)[offset]; int iwrite; int imax = length/sizeof(unsigned); for ( iwrite = 0; iwrite != imax; ++iwrite ){ praw[iwrite] = fill_value; } break; } case M_WRITE:{ // write to memory - read input until first of EOF or length // it's slow char at a time stuff but who cares? int iwrite; int cc; char* praw = &((char*)region)[offset]; for ( iwrite=0; (cc = getchar()) != -1 && iwrite != length; ++iwrite ){ praw[iwrite] = cc; } break; } case M_NOP : fprintf( stderr, "mmap: blocking. Hit any key to continue, q to quit\n" ); while ( getchar() != 'q' ){ char aline[128]; FILE* fp = fopen( "/proc/self/maps", "r" ); assert( fp ); while( fgets( aline, sizeof(aline), fp ) != NULL ) { fputs(aline, stderr); } fclose( fp ); } break; case M_TEST: install_handlers(); // alarm(2); return regsTest(region, poptGetArgs(opt_context)); break; } return 0; }
/*************************************************************************** * * implementation * **************************************************************************/ int main (int argc, char *argv[]) { GtkWidget *widget; GnomeClient *client; gchar *mode_string = NULL; gchar *cl_filter = NULL; gchar *cl_interface = NULL; gchar *cl_input_file = NULL; gchar *export_file_final = NULL; gchar *export_file_signal = NULL; gboolean cl_numeric = FALSE; glong midelay = 0; glong madelay = G_MAXLONG; gchar *version; gchar *cl_glade_file = NULL; poptContext poptcon; struct poptOption optionsTable[] = { {"diagram-only", 'd', POPT_ARG_NONE, &(pref.diagram_only), 0, N_("don't display any node text identification"), NULL}, {"replay-file", 'r', POPT_ARG_STRING, &cl_input_file, 0, N_("replay packets from file"), N_("<file to replay>")}, {"filter", 'f', POPT_ARG_STRING, &cl_filter, 0, N_("set capture filter"), N_("<capture filter>")}, {"interface", 'i', POPT_ARG_STRING, &cl_interface, 0, N_("set interface to listen to"), N_("<interface name>")}, {"final-export", 0, POPT_ARG_STRING, &export_file_final, 0, N_("export to named file at end of replay"), N_("<file to export to>")}, {"signal-export", 0, POPT_ARG_STRING, &export_file_signal, 0, N_("export to named file on receiving USR1"), N_("<file to export to>")}, {"stationary", 's', POPT_ARG_NONE, &(pref.stationary), 0, N_("don't move nodes around (deprecated)"), NULL}, {"node-limit", 'l', POPT_ARG_INT, &(appdata.node_limit), 0, N_("limits nodes displayed"), N_("<number of nodes>")}, {"mode", 'm', POPT_ARG_STRING, &mode_string, 0, N_("mode of operation"), N_("<link|ip|tcp>")}, {"numeric", 'n', POPT_ARG_NONE, &cl_numeric, 0, N_("don't convert addresses to names"), NULL}, {"quiet", 'q', POPT_ARG_NONE, &quiet, 0, N_("Disable informational messages"), NULL}, {"min-delay", 0, POPT_ARG_LONG, &midelay, 0, N_("minimum packet delay in ms for reading capture files [cli only]"), N_("<delay>")}, {"max-delay", 0, POPT_ARG_LONG, &madelay, 0, N_("maximum packet delay in ms for reading capture files [cli only]"), N_("<delay>")}, {"glade-file", 0, POPT_ARG_STRING, &(cl_glade_file), 0, N_("uses the named libglade file for widgets"), N_("<glade file>")}, POPT_AUTOHELP {NULL, 0, 0, NULL, 0, NULL, NULL} }; #ifdef ENABLE_NLS bindtextdomain (PACKAGE, PACKAGE_LOCALE_DIR); bind_textdomain_codeset(PACKAGE, "UTF-8"); /* force UTF-8 conversion */ textdomain (PACKAGE); #endif /* We set the window icon to use */ if (!getenv ("GNOME_DESKTOP_ICON")) putenv ("GNOME_DESKTOP_ICON=" PIXMAPS_DIR "/etherape.png"); #ifdef PACKAGE_SCM_REV /* We initiate the application and read command line options */ version = g_strdup_printf("%s (hg id %s)", VERSION, (*PACKAGE_SCM_REV) ? PACKAGE_SCM_REV : _("-unknown-")); #else version = g_strdup(VERSION); #endif gnome_program_init ("EtherApe", version, LIBGNOMEUI_MODULE, argc, argv, GNOME_PARAM_POPT_TABLE, optionsTable, GNOME_PARAM_NONE); g_free(version); appdata_init(&appdata); /* We obtain application parameters * First, absolute defaults * Second, values saved in the config file * Third, whatever given in the command line */ init_config(&pref); set_debug_level(); /* Config file */ load_config(); /* Command line */ cl_numeric = !pref.name_res; poptcon = poptGetContext ("Etherape", argc, (const char **) argv, optionsTable, 0); while (poptGetNextOpt (poptcon) > 0); if (cl_interface) { if (appdata.interface) g_free (appdata.interface); appdata.interface = g_strdup (cl_interface); } if (export_file_final) { if (appdata.export_file_final) g_free (appdata.export_file_final); appdata.export_file_final = g_strdup (export_file_final); } if (export_file_signal) { if (appdata.export_file_signal) g_free (appdata.export_file_signal); appdata.export_file_signal = g_strdup (export_file_signal); } pref.name_res = !cl_numeric; if (cl_input_file) { if (appdata.input_file) g_free (appdata.input_file); appdata.input_file = g_strdup (cl_input_file); } /* Find mode of operation */ if (mode_string) { if (strstr (mode_string, "link")) appdata.mode = LINK6; else if (strstr (mode_string, "ip")) appdata.mode = IP; else if (strstr (mode_string, "tcp")) appdata.mode = TCP; else g_warning (_ ("Unrecognized mode. Do etherape --help for a list of modes")); g_free(pref.filter); pref.filter = get_default_filter(appdata.mode); } if (cl_filter) { if (pref.filter) g_free (pref.filter); pref.filter = g_strdup (cl_filter); } if (midelay >= 0 && midelay <= G_MAXLONG) { appdata.min_delay = midelay; if (appdata.min_delay != 0) g_message("Minimum delay set to %lu ms", appdata.min_delay); } else g_message("Invalid minimum delay %ld, ignored", midelay); if (madelay >= 0 && madelay <= G_MAXLONG) { if (madelay < appdata.min_delay) { g_message("Maximum delay must be less of minimum delay"); appdata.max_delay = appdata.min_delay; } else appdata.max_delay = madelay; if (appdata.max_delay != G_MAXLONG) g_message("Maximum delay set to %lu ms", appdata.max_delay); } else g_message("Invalid maximum delay %ld, ignored", madelay); /* Glade */ glade_gnome_init (); glade_require("gnome"); glade_require("canvas"); if (!appdata_init_glade(cl_glade_file)) return 1; /* prepare decoders */ services_init(); /* Sets controls to the values of variables and connects signals */ init_diagram (appdata.xml); /* Session handling */ client = gnome_master_client (); g_signal_connect (G_OBJECT (client), "save_yourself", GTK_SIGNAL_FUNC (save_session), argv[0]); g_signal_connect (G_OBJECT (client), "die", GTK_SIGNAL_FUNC (session_die), NULL); gtk_widget_show (appdata.app1); install_handlers(); /* With this we force an update of the diagram every x ms * Data in the diagram is updated, and then the canvas redraws itself when * the gtk loop is idle. If the CPU can't handle the set refresh_period, * then it will just do a best effort */ widget = glade_xml_get_widget (appdata.xml, "canvas1"); destroying_idle (widget); /* This other timeout makes sure that the info windows are updated */ g_timeout_add (500, (GtkFunction) update_info_windows, NULL); /* another timeout to handle IP-cache timeouts */ g_timeout_add (10000, (GtkFunction) ipcache_tick, NULL); init_menus (); gui_start_capture (); /* MAIN LOOP */ gtk_main (); free_static_data(); return 0; } /* main */