int main(int argc, char** argv) { register_handlers(); sscanf(argv[0], "%d", &parent_pid); sscanf(argv[1], "%d", &fid); sscanf(argv[2], "%d", &mem_size); #ifdef DEBUG printf("KBD: %d %d %d\n", parent_pid, mem_size, fid); #endif mem_ptr = mmap((caddr_t)0, mem_size, PROT_READ|PROT_WRITE, MAP_SHARED, fid, (off_t)0); mem_buffer *buffer = (mem_buffer*) mem_ptr; char local_buffer[MEMBLOCK_SIZE]; int index = 0; char kbd_in = '\0'; unmask(); while(1) { kbd_in = getchar(); putc(kbd_in, stdout); //echo back if (kbd_in != '\r' && index < MEMBLOCK_SIZE-1) { local_buffer[index++] = kbd_in; } else { local_buffer[index++] = '\0'; while (buffer->flag != MEM_DONE) sleep(1); //1-sec polling strcpy(buffer->data, local_buffer); buffer->flag = MEM_READY; buffer->length = index; index = 0; kill(parent_pid, SIGUSR1); } } return 0; }
PUBLIC Jdb_pic::Jdb_pic() { static Jdb_handler enter(at_enter); static Jdb_handler leave(at_leave); register_handlers(enter,leave); }
int main(int argc, char **argv) { struct netns_entry *root; int netns_ok, err; arg_register_batch(options, ARRAY_SIZE(options)); register_frontends(); register_handlers(); if ((err = arg_parse(argc, argv))) exit(err); if (!check_caps()) { fprintf(stderr, "Must be run under root (or with enough capabilities).\n"); exit(1); } netns_ok = netns_switch_root(); if (netns_ok > 0) { fprintf(stderr, "Cannot change to the root name space: %s\n", strerror(netns_ok)); exit(1); } global_handler_init(); if ((err = netns_list(&root, netns_ok == 0))) { fprintf(stderr, "ERROR: %s\n", strerror(err)); exit(1); } if ((err = frontend_output(root))) { fprintf(stderr, "Invalid output format specified.\n"); exit(1); } global_handler_cleanup(root); netns_list_free(root); return 0; }
int ikarus_main(int argc, char** argv, char* boot_file){ if(! cpu_has_sse2()){ fprintf(stderr, "Ikarus Scheme cannot run on your computer because\n"); fprintf(stderr, "your CPU does not support the SSE2 instruction set.\n"); fprintf(stderr, "Refer to the Ikarus Scheme User's Guide for the\n"); fprintf(stderr, "minimum hardware requirements.\n"); exit(-1); } if(sizeof(mp_limb_t) != sizeof(long int)){ fprintf(stderr, "ERROR: limb size does not match\n"); exit(-1); } if(mp_bits_per_limb != (8*sizeof(long int))){ fprintf(stderr, "ERROR: invalid bits_per_limb=%d\n", mp_bits_per_limb); exit(-1); } ikpcb* pcb = ik_make_pcb(); the_pcb = pcb; { /* set up arg_list */ ikptr arg_list = null_object; int i = argc-1; while(i > 0){ char* s = argv[i]; int n = strlen(s); ikptr bv = ik_unsafe_alloc(pcb, align(disp_bytevector_data+n+1)) + bytevector_tag; ref(bv, off_bytevector_length) = fix(n); memcpy((char*)(bv+off_bytevector_data), s, n+1); ikptr p = ik_unsafe_alloc(pcb, pair_size); ref(p, disp_car) = bv; ref(p, disp_cdr) = arg_list; arg_list = p+pair_tag; i--; } pcb->arg_list = arg_list; } register_handlers(); register_alt_stack(); ik_fasl_load(pcb, boot_file); /* fprintf(stderr, "collect time: %d.%03d utime, %d.%03d stime (%d collections)\n", pcb->collect_utime.tv_sec, pcb->collect_utime.tv_usec/1000, pcb->collect_stime.tv_sec, pcb->collect_stime.tv_usec/1000, pcb->collection_id ); */ ik_delete_pcb(pcb); return 0; }
int main(int argc, char **argv) { int i; pid_t pid; if(argc < 4) { printf("Usage: fork_stochastic seed max n\n"); return 0; } register_handlers(); int seed = strtol(argv[1], NULL, 10); int max = strtol(argv[2], NULL, 10); int n = strtol(argv[3], NULL, 10); int p = getpid(); printf("%d\n", p); fflush(stdout); srand(seed); int r = rand(); int count = r % max; char new_seed[4]; char new_n[4]; snprintf(new_n, sizeof(new_n), "%d", n - 1); for(i = 0; i < count && n > 0; i++) { snprintf(new_seed, sizeof(new_seed), "%d", r + i); pid = fork(); if(pid == 0){ execl("./fork_stochastic", "./fork_stochastic", new_seed, argv[2], new_n, NULL); } } while(1) ; return 0; }
int main () { mca_status_t status; mcapi_param_t parms; mcapi_info_t version; mcapi_set_debug_level(1); /* create a node */ mcapi_initialize(DOMAIN,NODE,NULL,&parms,&version,&status); if (status != MCAPI_SUCCESS) { fprintf(stderr,"FAILED 1: mcapi_initialize NODE=%i, status=%s",NODE,mcapi_display_status(status,status_buff,sizeof(status_buff))); return -1; } register_handlers(); raise(SIGINT); return 0; }
int interface_main(int argc, char *argv[]) { if (argc < 2) return 1; int *const daemons = find_daemon(argv[1]), *current_socket = daemons; if (!daemons) return 1; register_handlers(); unsigned int return_value = 0x00, single_value = 0x00; static char input_data[PARAM_MAX_INPUT_SECTION]; char *working = NULL, *current = NULL; if (*current_socket) do { FILE *new_stream = fdopen(*current_socket, "r+"); if (!new_stream) { fprintf(stderr, "%s: couldn't connect to daemon '%s': %s\n", argv[0], argv[1], strerror(errno)); shutdown(*current_socket, SHUT_RDWR); return_value |= event_bad_target; continue; } int I; for (I = 2; I < argc; I++) fprintf(new_stream, "%s\n", argv[I]); fflush(new_stream); shutdown(*current_socket, SHUT_WR); while (fgets(input_data, PARAM_MAX_INPUT_SECTION, new_stream)) { if (strlen(input_data)) input_data[ strlen(input_data) - 1 ] = 0x00; if (!strlen(input_data)) continue; current = input_data; if (!(working = strsep(¤t, " "))) continue; if (strcmp(working, "\\") == 0) fprintf(stdout, "%s\n", current); else if (parse_integer16(working, &single_value)) { return_value |= single_value; if (!current) continue; fprintf(stderr, "%s\n", current); if (!--I) break; } else fprintf(stderr, "(bad response data received)\n"); } shutdown(*current_socket, SHUT_RDWR); fclose(new_stream); } while (*++current_socket); free(daemons); return return_value; }
BrokerMessageHandler::BrokerMessageHandler() { register_handlers(); }
int main (int argc, char **argv) { int c, status; char *domain; progname = strrchr (argv[0], '/'); if (!progname) progname = argv[0]; while ((c = getopt (argc, argv, "b:f:p:to:")) != EOF) { switch (c) { case 'b': switch (optarg[0]) { case 'd': smtp_mode = 1; break; default: /*FIXME*/; } break; case 'f': from_person = optarg; break; case 'p': port = strtoul (optarg, NULL, 0); break; case 't': read_recipients = 1; break; case 'o': switch (optarg[0]) { case 'i': dot = 0; break; default: /* FIXME */ ; } break; default: exit (1); } } if (!diag) { char *name = getenv ("MTA_DIAG"); if (name) { char *mode = getenv ("MTA_APPEND") ? "a" : "w"; diag = fopen (name, mode); if (!diag) { mu_error ("%s: can't open diagnostic output: %s", progname, name); return 1; } } else diag = stdout; } register_handlers (); domain = getenv ("MTA_DOMAIN"); mu_set_user_email_domain (domain ? domain : "localhost"); argc -= optind; argv += optind; if (smtp_mode) status = mta_smtp (argc, argv); else status = mta_stdin (argc, argv); fclose (diag); return status; }
// initialize the shared library void initialize(void) { register_handlers(); }
/* #define SERVER_DEBUG 1 */ int main( int, char ** ) { int status; rsComm_t rsComm; char *tmpStr; ProcessType = AGENT_PT; // capture server properties irods::server_properties& props = irods::server_properties::getInstance(); irods::error result = props.capture_if_needed(); if ( !result.ok() ) { irods::log( PASSMSG( "failed to read server configuration", result ) ); } #ifdef windows_platform iRODSNtAgentInit( argc, argv ); #endif #ifndef windows_platform signal( SIGINT, signalExit ); signal( SIGHUP, signalExit ); signal( SIGTERM, signalExit ); /* set to SIG_DFL as recommended by andy.salnikov so that system() * call returns real values instead of 1 */ signal( SIGCHLD, SIG_DFL ); signal( SIGUSR1, signalExit ); signal( SIGPIPE, SIG_IGN ); // register irods signal handlers register_handlers(); #endif #ifndef windows_platform #ifdef SERVER_DEBUG if ( isPath( "/tmp/rodsdebug" ) ) { sleep( 20 ); } #endif #endif memset( &rsComm, 0, sizeof( rsComm ) ); rsComm.thread_ctx = ( thread_context* )malloc( sizeof( thread_context ) ); status = initRsCommWithStartupPack( &rsComm, NULL ); // =-=-=-=-=-=-=- // manufacture a network object for comms irods::network_object_ptr net_obj; irods::error ret = irods::network_factory( &rsComm, net_obj ); if ( !ret.ok() ) { irods::log( PASS( ret ) ); } if ( status < 0 ) { sendVersion( net_obj, status, 0, NULL, 0 ); cleanupAndExit( status ); } /* Handle option to log sql commands */ tmpStr = getenv( SP_LOG_SQL ); if ( tmpStr != NULL ) { #ifdef SYSLOG int j = atoi( tmpStr ); rodsLogSqlReq( j ); #else rodsLogSqlReq( 1 ); #endif } /* Set the logging level */ tmpStr = getenv( SP_LOG_LEVEL ); if ( tmpStr != NULL ) { int i; i = atoi( tmpStr ); rodsLogLevel( i ); } else { rodsLogLevel( LOG_NOTICE ); /* default */ } #ifdef SYSLOG /* Open a connection to syslog */ openlog( "rodsAgent", LOG_ODELAY | LOG_PID, LOG_DAEMON ); #endif status = getRodsEnv( &rsComm.myEnv ); if ( status < 0 ) { rodsLog( LOG_ERROR, "agentMain :: getRodsEnv failed" ); sendVersion( net_obj, SYS_AGENT_INIT_ERR, 0, NULL, 0 ); cleanupAndExit( status ); } ret = setRECacheSaltFromEnv(); if ( !ret.ok() ) { rodsLog( LOG_ERROR, "rodsAgent::main: Failed to set RE cache mutex name\n%s", ret.result().c_str() ); exit( 1 ); } // =-=-=-=-=-=-=- // load server side pluggable api entries irods::api_entry_table& RsApiTable = irods::get_server_api_table(); irods::pack_entry_table& ApiPackTable = irods::get_pack_table(); ret = irods::init_api_table( RsApiTable, ApiPackTable, false ); if ( !ret.ok() ) { irods::log( PASS( ret ) ); return 1; } // =-=-=-=-=-=-=- // load client side pluggable api entries irods::api_entry_table& RcApiTable = irods::get_client_api_table(); ret = irods::init_api_table( RcApiTable, ApiPackTable, true ); if ( !ret.ok() ) { irods::log( PASS( ret ) ); return 1; } #if RODS_CAT if ( strstr( rsComm.myEnv.rodsDebug, "CAT" ) != NULL ) { chlDebug( rsComm.myEnv.rodsDebug ); } #endif status = initAgent( RULE_ENGINE_TRY_CACHE, &rsComm ); if ( status < 0 ) { rodsLog( LOG_ERROR, "agentMain :: initAgent failed: %d", status ); sendVersion( net_obj, SYS_AGENT_INIT_ERR, 0, NULL, 0 ); cleanupAndExit( status ); } /* move configConnectControl behind initAgent for now. need zoneName if * the user does not specify one in the input */ initConnectControl(); if ( rsComm.clientUser.userName[0] != '\0' ) { status = chkAllowedUser( rsComm.clientUser.userName, rsComm.clientUser.rodsZone ); if ( status < 0 ) { sendVersion( net_obj, status, 0, NULL, 0 ); cleanupAndExit( status ); } } // =-=-=-=-=-=-=- // handle negotiations with the client regarding TLS if requested // this scope block makes valgrind happy { std::string neg_results; ret = irods::client_server_negotiation_for_server( net_obj, neg_results ); if ( !ret.ok() || neg_results == irods::CS_NEG_FAILURE ) { irods::log( PASS( ret ) ); // =-=-=-=-=-=-=- // send a 'we failed to negotiate' message here?? // or use the error stack rule engine thingie irods::log( PASS( ret ) ); sendVersion( net_obj, SYS_AGENT_INIT_ERR, 0, NULL, 0 ); cleanupAndExit( ret.code() ); } else { // =-=-=-=-=-=-=- // copy negotiation results to comm for action by network objects snprintf( rsComm.negotiation_results, sizeof( rsComm.negotiation_results ), "%s", neg_results.c_str() ); //rsComm.ssl_do_accept = 1; } } /* send the server version and atatus as part of the protocol. Put * rsComm.reconnPort as the status */ ret = sendVersion( net_obj, status, rsComm.reconnPort, rsComm.reconnAddr, rsComm.cookie ); if ( !ret.ok() ) { irods::log( PASS( ret ) ); sendVersion( net_obj, SYS_AGENT_INIT_ERR, 0, NULL, 0 ); cleanupAndExit( status ); } logAgentProc( &rsComm ); // call initialization for network plugin as negotiated irods::network_object_ptr new_net_obj; ret = irods::network_factory( &rsComm, new_net_obj ); if ( !ret.ok() ) { return ret.code(); } ret = sockAgentStart( new_net_obj ); if ( !ret.ok() ) { irods::log( PASS( ret ) ); return ret.code(); } new_net_obj->to_server( &rsComm ); status = agentMain( &rsComm ); // call initialization for network plugin as negotiated ret = sockAgentStop( new_net_obj ); if ( !ret.ok() ) { irods::log( PASS( ret ) ); return ret.code(); } new_net_obj->to_server( &rsComm ); cleanup(); free( rsComm.thread_ctx ); free( rsComm.auth_scheme ); rodsLog( LOG_NOTICE, "Agent exiting with status = %d", status ); return status; }