void delete_bootstrap_services(bootstrap_info_t *bootstrap) { server_t *serverp; service_t *servicep; service_t *next; for ( servicep = FIRST(services) ; !IS_END(servicep, services) ; servicep = next) { next = NEXT(servicep); if (bootstrap != servicep->bootstrap) continue; if (!servicep->isActive || !servicep->server) { delete_service(servicep); continue; } serverp = servicep->server; delete_service(servicep); serverp->active_services--; if (!active_server(serverp)) delete_server(serverp); } }
int WINAPI manage_npf_driver(LPCTSTR LogFileName, char operation) { FILE *log; DWORD ReturnValue = NO_ERROR; if (LogFileName != NULL) log = fopen(LogFileName, "a"); else log = NULL; switch(operation) { case 's': ReturnValue = start_service(log,"NPF"); break; case 'x': ReturnValue = stop_service(log,"NPF"); break; case 'u': ReturnValue = delete_service(log,"NPF"); break; case 'i': ReturnValue = create_driver_service(log,"NPF","NetGroup Packet Filter Driver","system32\\drivers\\npf.sys"); break; case 'r': (void)delete_service(log,"NPF"); Sleep(100); ReturnValue = create_driver_service(log,"NPF","NetGroup Packet Filter Driver","system32\\drivers\\npf.sys"); break; case 'a': ReturnValue = change_start_type_service(log,"NPF", SERVICE_AUTO_START); break; case 'd': ReturnValue = change_start_type_service(log,"NPF", SERVICE_DEMAND_START); break; default: ReturnValue = ERROR_INVALID_PARAMETER; break; } if (log != NULL) fclose(log); return (int)ReturnValue; }
void delete_server(server_t *serverp) { service_t *servicep; service_t *next; info("Deleting server %s", serverp->cmd); ASSERT(serverp->prev->next == serverp); ASSERT(serverp->next->prev == serverp); serverp->prev->next = serverp->next; serverp->next->prev = serverp->prev; for ( servicep = FIRST(services) ; !IS_END(servicep, services) ; servicep = next) { next = NEXT(servicep); if (serverp == servicep->server) delete_service(servicep); } deallocate_bootstrap(serverp->bootstrap); if (serverp->port) mach_port_mod_refs(mach_task_self(), serverp->port, MACH_PORT_RIGHT_RECEIVE, -1); free(serverp); }
ERROR_CODE destroy_service() { /* prints a debug message about the initial stage of the service structures destruction */ V_DEBUG("Destroying the service structures\n"); /* deletes the service, disallowing any further access to the service instance, and then sets its reference back to the original (unset sate) */ delete_service(service); service = NULL; /* prints a debug message about the final stage of the service structures destruction */ V_DEBUG("Finished destroying the service structures\n"); /* raises no error to the caller method, normal exit operation (should provide no problem) */ RAISE_NO_ERROR; }
long test3(const char* timeLog_filepath, int num_of_clients, int ksm ) { char shell_command[BUFSIZ]; char cache_filepath[1024]; char client_name[1024]; char group_name[1024]; int i,j,k; long total_time = 0.0L; FILE* timeLog_file = NULL; char* base_client_name = (ksm==2)? KSM2_BASE_CLIENT_NAME:KSM1_BASE_CLIENT_NAME; // Create client principals and its cache for each client for( i = 0; i < num_of_clients; i++ ) { //printf("\rCreating client principal and ticket cache %d of %d", // i+1, num_of_clients); snprintf(client_name, 1024, "%s%d", base_client_name, i); create_client_princ( client_name ); create_client_cache( client_name ); } //printf("\n"); // Execute all client request sequentially for( i = 1; i <= group_count; i++ ) { memset(group_name, 0, 1024); snprintf(group_name, 1024, "group%d", i); int a[num_of_clients], nvalues = num_of_clients; for( k = 0; k < nvalues; k++ ) a[k] = k; for( k = 0; k < nvalues -1; k++) { int c = rand() / (RAND_MAX/(nvalues-k) + 1 ); int t = a[k]; a[k] = a[k+c]; a[k+c] = t; } for( j = 0; j < group_size; j++ ) { int cid = a[j]; // client id snprintf(client_name, 1024, "%s%d", base_client_name, cid); snprintf(cache_filepath, 1024, "%s/%s%d.cache", RUNTIME_DIR, base_client_name, cid); if( client_exec( group_name, cache_filepath, timeLog_filepath, ksm) < 0 ) { for( k = 0; k < num_of_clients; k++ ) { snprintf(client_name, 1024, "%s%d", base_client_name, k); delete_client_cache( client_name ); delete_client_princ( client_name ); } delete_service("group",group_count); printf("Client failed\n"); exit(1); } long last_val = get_last_value( timeLog_filepath ); if( last_val > 100 || last_val < 0) { snprintf(shell_command, BUFSIZ,"%s %s", DEL_LAST_LINE, timeLog_filepath, NULL); // Reject data that's out of range system(shell_command); if (ksm == 2) { delete_client_cache( client_name ); create_client_cache( client_name ); } // printf("last_val too high, reject%ld\n", last_val); j--; } } } timeLog_file = fopen(timeLog_filepath, "r"); if( timeLog_file != NULL ) { char line[128]; for(i = 0; i < group_size*group_count; i++ ) { if( fgets(line, sizeof(line), timeLog_file) != NULL ) { total_time += atol( line ); } } fclose(timeLog_file); } else { perror( timeLog_filepath ); } for( i = 0; i < num_of_clients; i++ ) { snprintf(client_name, 1024, "%s%d", base_client_name, i); delete_client_cache( client_name ); delete_client_princ( client_name ); } //printf("\n"); return total_time; }
int main(int argc, char* argv[]) { // Simulation configuration int num_of_clients = 50; // Indexing int i,j,n,l; // Temporary Logging generalLog_filepath = TEST3_GENERAL_LOG; starting_k = 5; max_k = 20; ignore_count = 3; if( getenv("SUDO_UID") ) { user_uid = atoi(getenv("SUDO_UID")); } else { printf("You need sudo to run the test\n"); exit(0); } #ifdef HARD_UPPER_LIMIT if( argc > 1 ) { upper_limit = atoi(argv[1]); } #endif if( argc > 2 ) { num_of_clients = atoi(argv[2]); } seteuid(user_uid); setfsuid(user_uid); setup_logs(); // Statistical variables running_stats_t rs; //set_default_running_stats( &rs ); create_service("group",group_count); for( l=1; l <= sizeof(group_size_array)/sizeof(int); l++) { group_size = group_size_array[l-1]; num_of_clients = group_size; set_default_running_stats( &rs ); printf("===================Pre-test Runs=====================\n"); for( j = 0; j < ignore_count; j++ ) { // ignore first few iterations timeLog_file = fopen( timeLog_filepath, "w" ); fclose(timeLog_file); test3( timeLog_filepath, num_of_clients, 1); } printf("===================Starting KSM1=====================\n"); resultsLogRAW_file = fopen( resultsLogRAW_filepath, "a" ); fprintf(resultsLogRAW_file, "===================Starting KSM1=====================\n"); if(resultsLogRAW_file) fclose(resultsLogRAW_file); run_test3(&rs, num_of_clients, 1); log_data( test3_dat_ksm1_filepath, group_size, &rs ); set_default_running_stats( &rs ); printf("===================Pre-test Runs=====================\n"); for( j = 0; j < ignore_count; j++ ) { // ignore first few iterations timeLog_file = fopen( timeLog_filepath, "w" ); fclose(timeLog_file); test3( timeLog_filepath, num_of_clients, 2); } printf("===================Starting KSM2=====================\n"); resultsLogRAW_file = fopen( resultsLogRAW_filepath, "a" ); fprintf(resultsLogRAW_file, "===================Starting KSM2=====================\n"); if(resultsLogRAW_file) fclose(resultsLogRAW_file); run_test3(&rs, num_of_clients, 2); log_data( test3_dat_ksm2_filepath, group_size, &rs ); } delete_service("group",group_count); merge_data(test3_dat_filepath, test3_dat_ksm1_filepath, test3_dat_ksm2_filepath); remove(test3_dat_ksm1_filepath); remove(test3_dat_ksm2_filepath); remove(timeLog_filepath); return 0; }
int main(int argc, char **argv) { int i; char *p; startup_log("main()"); dirsep = '\\'; GetModuleFileName(NULL, cfgdir, sizeof cfgdir); startup_log("cfgdir = '%s'", cfgdir); p = strrchr(cfgdir, dirsep); if (p) *p = '\0'; cfgfile[0] = '\0'; snprcat(cfgfile, sizeof cfgfile, "%s%c%s", cfgdir, dirsep, "mrbig.cfg"); startup_log("cfgfile = '%s'", cfgfile); startup_log("SystemRoot = '%s'", getenv("SystemRoot")); for (i = 1; i < argc; i++) { if (!strcmp(argv[i], "-c")) { i++; if (argv[i] == NULL) { fprintf(stderr, "No cfg file\n"); return EXIT_FAILURE; } } else if (!strcmp(argv[i], "-d")) { debug++; } else if (!strcmp(argv[i], "-m")) { debug_memory = 1; } else if (!strncmp(argv[i], "-i", 2)) { if (argv[i][2] == '\0') { install_service("MrBig", "Mr Big Monitoring Agent"); } else { install_service(argv[i]+2, argv[i]+2); } return 0; } else if (!strncmp(argv[i], "-u", 2)) { if (argv[i][2] == '\0') { delete_service("MrBig"); } else { delete_service(argv[i]+2); } return 0; } else if (!strcmp(argv[i], "-t")) { standalone = 1; } else { fprintf(stderr, "Bogus option '%s'\n", argv[i]); usage(); } } if (standalone) { mrbig(); return 0; } startup_log("We want to become a service"); service_main(argc, argv); dump_chunks(); check_chunks("just before exit"); dump_files(); return 0; }
/* * kern_return_t * bootstrap_register(mach_port_t bootstrap_port, * name_t service_name, * mach_port_t service_port) * * Registers send rights for the port service_port for the service named by * service_name. Registering a declared service or registering a service for * which bootstrap has receive rights via a port backup notification is * allowed. * The previous service port will be deallocated. Restarting services wishing * to resume service for previous clients must first attempt to checkin to the * service. * * Errors: Returns appropriate kernel errors on rpc failure. * Returns BOOTSTRAP_NOT_PRIVILEGED, if request directed to * unprivileged bootstrap port. * Returns BOOTSTRAP_SERVICE_ACTIVE, if service has already been * register or checked-in. */ kern_return_t x_bootstrap_register( mach_port_t bootstrap_port, name_t service_name, mach_port_t service_port) { kern_return_t result; service_t *servicep; server_t *serverp; bootstrap_info_t *bootstrap; mach_port_t old_port; debug("Register attempt for service %s port %x", service_name, service_port); /* * Validate the bootstrap. */ bootstrap = lookup_bootstrap_by_port(bootstrap_port); if (!bootstrap || !active_bootstrap(bootstrap)) return BOOTSTRAP_NOT_PRIVILEGED; /* * If this bootstrap port is for a server, or it's an unprivileged * bootstrap can't register the port. */ serverp = lookup_server_by_port(bootstrap_port); servicep = lookup_service_by_name(bootstrap, service_name); if (servicep && servicep->server && servicep->server != serverp) return BOOTSTRAP_NOT_PRIVILEGED; if (servicep == NULL || servicep->bootstrap != bootstrap) { servicep = new_service(bootstrap, service_name, service_port, ACTIVE, REGISTERED, NULL_SERVER); debug("Registered new service %s", service_name); } else { if (servicep->isActive) { debug("Register: service %s already active, port %x", servicep->name, servicep->port); ASSERT(!canReceive(servicep->port)); return BOOTSTRAP_SERVICE_ACTIVE; } old_port = servicep->port; if (servicep->servicetype == DECLARED) { servicep->servicetype = REGISTERED; if (servicep->server) { ASSERT(servicep->server == serverp); ASSERT(active_server(serverp)); servicep->server = NULL_SERVER; serverp->activity++; } result = mach_port_mod_refs( mach_task_self(), old_port, MACH_PORT_RIGHT_RECEIVE, -1); if (result != KERN_SUCCESS) kern_fatal(result, "mach_port_mod_refs"); } result = mach_port_deallocate( mach_task_self(), old_port); if (result != KERN_SUCCESS) kern_fatal(result, "mach_port_mod_refs"); servicep->port = service_port; servicep->isActive = TRUE; debug("Re-registered inactive service %x bootstrap %x: %s", servicep->port, servicep->bootstrap->bootstrap_port, service_name); } /* detect the new service port going dead */ result = mach_port_request_notification( mach_task_self(), service_port, MACH_NOTIFY_DEAD_NAME, 0, notify_port, MACH_MSG_TYPE_MAKE_SEND_ONCE, &old_port); if (result != KERN_SUCCESS) { debug("Can't request notification on service %x bootstrap %x: %s", service_port, servicep->bootstrap->bootstrap_port, "must be dead"); delete_service(servicep); return BOOTSTRAP_SUCCESS; } else if (old_port != MACH_PORT_NULL) { debug("deallocating old notification port (%x) for service %x", old_port, service_port); result = mach_port_deallocate( mach_task_self(), old_port); if (result != KERN_SUCCESS) kern_fatal(result, "mach_port_deallocate"); } info("Registered service %x bootstrap %x: %s", servicep->port, servicep->bootstrap->bootstrap_port, servicep->name); return BOOTSTRAP_SUCCESS; }