void server_serve(struct client *client) { /* unix connection is secure, other insecure */ run_only_safe_commands = addr.sa.sa_family != AF_UNIX; read_commands(client); run_only_safe_commands = 0; }
int main(int argc, char *argv[]) { // Shell read-evaluate loop for (;;) { // Read user input and evaluate commands Command_vec *commands = read_commands(rl_gets()); eval(commands); free_command_vec(commands); } printf("\n"); return 0; }
int main_menu(SDL_Renderer *renderer) { int should_quit = 0; Code code = CODE_OK; Menu menu; CommandTable command_table; char title[MAXIMUM_STRING_SIZE]; char *options[] = {"Play", "Top Scores", "Info", "Quit"}; sprintf(title, "%s %s", "Walls of Doom", WALLS_OF_DOOM_VERSION); menu.title = title; menu.options = options; menu.option_count = 4; menu.selected_option = 0; initialize_command_table(&command_table); while (!should_quit) { write_menu(&menu, renderer); read_commands(&command_table); if (test_command_table(&command_table, COMMAND_UP, REPETITION_DELAY)) { if (menu.selected_option > 0) { menu.selected_option--; } else { menu.selected_option = menu.option_count - 1; } } else if (test_command_table(&command_table, COMMAND_DOWN, REPETITION_DELAY)) { if (menu.selected_option + 1 < menu.option_count) { menu.selected_option++; } else { menu.selected_option = 0; } } else if (test_command_table(&command_table, COMMAND_ENTER, REPETITION_DELAY) || test_command_table(&command_table, COMMAND_CENTER, REPETITION_DELAY)) { if (menu.selected_option == 0) { code = game(renderer, &command_table); } else if (menu.selected_option == 1) { code = top_scores(renderer, &command_table); } else if (menu.selected_option == 2) { code = info(renderer, &command_table); } else if (menu.selected_option == 3) { should_quit = 1; } /* If it is not defined whether or not we should quit, check the code. */ if (should_quit == 0) { should_quit = is_termination_code(code); } } /* Quit if the user selected the Quit option or closed the window. */ should_quit = should_quit || test_command_table(&command_table, COMMAND_QUIT, REPETITION_DELAY); } return 0; }
int main(int ac, char **av) { t_platine *platine_a; t_platine *platine_b; t_command *commands; if (ac < 3) { printf("Usage: ./%s platineA platineB < commandes\n", av[0]); return (1); } platine_a = create_platine(av[1]); platine_b = create_platine(av[2]); commands = read_commands(); if (!platine_a || !platine_b || !commands) { printf("Error while getting platine or commands\n"); return (1); } run_dj(platine_a, platine_b, commands); return (0); }
int main( int argc, char **argv) { bool command_pipe_open; struct command_buffer_t command_buffer; struct net_state_t net_state; /* To minimize security risk, the only thing done prior to dropping SUID should be opening the network state for raw sockets. */ init_net_state_privileged(&net_state); if (drop_elevated_permissions()) { perror("Unable to drop elevated permissions"); exit(EXIT_FAILURE); } init_net_state(&net_state); init_command_buffer(&command_buffer, fileno(stdin)); command_pipe_open = true; /* Dispatch commands and respond to probe replies until the command stream is closed. */ while (true) { /* Ensure any responses are written before waiting */ fflush(stdout); wait_for_activity(&command_buffer, &net_state); /* Receive replies first so that the timestamps are as close to the response arrival time as possible. */ receive_replies(&net_state); if (command_pipe_open) { if (read_commands(&command_buffer)) { if (errno == EPIPE) { command_pipe_open = false; } } } check_probe_timeouts(&net_state); /* Dispatch commands late so that the window between probe departure and arriving replies is as small as possible. */ dispatch_buffer_commands(&command_buffer, &net_state); /* If the command pipe has been closed, exit after all in-flight probes have reported their status. */ if (!command_pipe_open) { if (net_state.outstanding_probe_count == 0) { break; } } } return 0; }
// Main function int main (int argc, char *argv[]) { char *input = "input.txt"; // File containing the commands // Initialize Process Table struct process process_table[25]; // Initialize CPU 1 struct hardware cpu1; cpu1.busy = 0; // Initialize CPU 2 struct hardware cpu2; cpu2.busy = 0; // Initialize SSD struct hardware ssd; ssd.busy = 0; // Initialize IO priority queue struct queue io_q; io_q.nextEmpty = 0; io_q.busy = 0; // Setting NULL values int x; for(x = 0; x < 26; x++) { io_q.pid[x] = NULL_VALUE; } // Initialize Ready queue. struct queue ready_q; ready_q.nextEmpty = 0; ready_q.busy = 0; // Setting NULL values for(x = 0; x < 26; x++) { ready_q.pid[x] = NULL_VALUE; } // Initialize SSD queue. struct queue ssd_q; ssd_q.nextEmpty = 0; ssd_q.busy = 0; // Setting NULL values for(x = 0; x < 26; x++) { ssd_q.pid[x] = NULL_VALUE; } // Read the file with the commands. read_commands(input, process_table); // Testing code to check if the process were created correctly int i, j; for(i=0;i<process_ctr;i++) { printf("PID %d\n", process_table[i].pid); printf("STATE %d\n", process_table[i].state); printf("COMMAND_INDEX %d\n", process_table[i].command_index); printf("TOTAL_COMMANDS %d\n", process_table[i].total_commands); printf("SSD_ACCESS_COUNTER %d\n", process_table[i].ssd_access_counter); printf("SSD_USAGE_TIME %d\n", process_table[i].ssd_usage_time); printf("SSD_WAIT_TIME %d\n", process_table[i].ssd_wait_time); printf("SSD_ENTRY_TIME %d\n", process_table[i].ssd_entry_time); for(j=0;j<process_table[i].command_index;j++) { printf("\tNAME %d", process_table[i].commands[j].name); printf("\tTIME %d\n", process_table[i].commands[j].time); } printf("\n"); } // Setting the total commands and reseting the command_index of each process to 0; for(i=0;i<process_ctr;i++) { process_table[i].total_commands = process_table[i].command_index; process_table[i].command_index = 0; } printf("Current Time: %d, Total Processes in Table: %d\n", global_time,process_ctr); for(i = 0; i < process_ctr; i++) { printf("PROCESS %d: ", process_table[i].pid); if (process_table[i].state == READY) { printf("Current State = READY"); } else if (process_table[i].state == RUNNING) { printf("Current State = RUNNING"); } else if (process_table[i].state == WAITING) { printf("Current State = WAITING"); } else if (process_table[i].state == FINISHED) { printf("Current State = FINISHED"); } printf(" Next Index = %d\n", process_table[i].command_index); } printf("\n\n\n"); while(finished_processes < process_ctr){ /////////////// Check minimum end time /////////////// int minFinishTime = 9999999; // Check cpu1 if(cpu1.busy) { if(cpu1.finish_time < minFinishTime) { minFinishTime = cpu1.finish_time; } } // Check cpu2 if(cpu2.busy) { if(cpu2.finish_time < minFinishTime) { minFinishTime = cpu2.finish_time; } } // Check ssd if(ssd.busy) { if(ssd.finish_time < minFinishTime) { minFinishTime = ssd.finish_time; } } // Check INP queue if(io_q.busy) { if(process_table[io_q.pid[0]].commands[process_table[io_q.pid[0]].command_index].time + process_table[io_q.pid[0]].io_entry_time < minFinishTime) { minFinishTime = process_table[io_q.pid[0]].commands[process_table[io_q.pid[0]].command_index].time + process_table[io_q.pid[0]].io_entry_time; } } // Check if create a new process if(next_new_process < process_ctr) { if(process_table[next_new_process].commands[0].time < minFinishTime) { minFinishTime = process_table[next_new_process].commands[0].time; } } // Updating global time global_time = minFinishTime; /////////////// Free up hardware, io queue, and new process /////////////// // Free cpu1 if(cpu1.busy) { if(cpu1.finish_time == minFinishTime) { execute_next_command(get_process_from_hardware(&cpu1, process_table), process_table, &io_q, &ssd_q, &ready_q); } } // Free cpu2 if(cpu2.busy) { if(cpu2.finish_time == minFinishTime) { execute_next_command(get_process_from_hardware(&cpu2, process_table), process_table, &io_q, &ssd_q, &ready_q); } } // Free ssd if(ssd.busy) { if(ssd.finish_time == minFinishTime) { execute_next_command(get_process_from_hardware(&ssd, process_table), process_table, &io_q, &ssd_q, &ready_q); } } // Dequeue from INP queue if(io_q.busy) { while(io_q.busy && (process_table[io_q.pid[0]].commands[process_table[io_q.pid[0]].command_index].time + process_table[io_q.pid[0]].io_entry_time == minFinishTime) ) { execute_next_command(dequeue(&io_q), process_table, &io_q, &ssd_q, &ready_q); } } // Creating a new process if(next_new_process < process_ctr) { while(process_table[next_new_process].commands[0].time == minFinishTime) { execute_next_command(next_new_process, process_table, &io_q, &ssd_q, &ready_q); next_new_process = next_new_process + 1; } } /////////////// Put process from queue to hardware /////////////// // Check if cpu1 is busy if(cpu1.busy == 0) { // Check if ready q has something if(ready_q.busy) { // Add to cpu1 cpu1.pid = dequeue(&ready_q); cpu1.busy = 1; cpu1.finish_time = global_time + process_table[cpu1.pid].commands[process_table[cpu1.pid].command_index].time; process_table[cpu1.pid].state = RUNNING; process_table[cpu1.pid].cpu_usage_time = process_table[cpu1.pid].cpu_usage_time + process_table[cpu1.pid].commands[process_table[cpu1.pid].command_index].time; // Increment command index } } // Check if cpu2 is busy if(cpu2.busy == 0) { // Check if ready q has something if(ready_q.busy) { // Add to cpu2 cpu2.pid = dequeue(&ready_q); cpu2.busy = 1; cpu2.finish_time = global_time + process_table[cpu2.pid].commands[process_table[cpu2.pid].command_index].time; process_table[cpu2.pid].state = RUNNING; process_table[cpu2.pid].cpu_usage_time = process_table[cpu2.pid].cpu_usage_time + process_table[cpu2.pid].commands[process_table[cpu2.pid].command_index].time; // Increment command index } } // Check if ssd is busy if(ssd.busy == 0) { // Check if ssd q has something if(ssd_q.busy) { // Add to cpu2 ssd.pid = dequeue(&ssd_q); ssd.busy = 1; ssd.finish_time = global_time + process_table[ssd.pid].commands[process_table[ssd.pid].command_index].time; process_table[ssd.pid].state = WAITING; process_table[ssd.pid].ssd_wait_time = (process_table[ssd.pid].ssd_wait_time + global_time) - process_table[ssd.pid].ssd_entry_time; process_table[ssd.pid].ssd_access_counter++; process_table[ssd.pid].ssd_usage_time = process_table[ssd.pid].ssd_usage_time + process_table[ssd.pid].commands[process_table[ssd.pid].command_index].time; // Increment command index } } printf("Current Time: %d, Total Processes in Table: %d\n", global_time,process_ctr); for(i = 0; i < process_ctr; i++) { printf("PROCESS %d: ", process_table[i].pid); if (process_table[i].state == READY) { printf("Current State = READY"); } else if (process_table[i].state == RUNNING) { printf("Current State = RUNNING"); } else if (process_table[i].state == WAITING) { printf("Current State = WAITING"); } else if (process_table[i].state == FINISHED) { printf("Current State = FINISHED"); } if (process_table[i].state == FINISHED) { printf(" Next Index = %d\n", process_table[i].command_index); } else { printf(" Next Index = %d\n", process_table[i].command_index + 1); } } printf("\n\n\n"); } printf("Summary: \n"); printf("Total Processes Completed: %d \n", finished_processes); int ssdAccesses = 0; int ssdWaitTime = 0; int ssdUsageTime = 0; int cpuUsageTime = 0; for(i=0; i < finished_processes; i++) { ssdAccesses = ssdAccesses + process_table[i].ssd_access_counter; ssdWaitTime = ssdWaitTime + process_table[i].ssd_usage_time + process_table[i].ssd_wait_time; ssdUsageTime = ssdUsageTime + process_table[i].ssd_usage_time; cpuUsageTime = cpuUsageTime + process_table[i].cpu_usage_time; } printf("Total Number of SSD Accesses: %d\n", ssdAccesses); if(ssdAccesses != 0) { printf("Average SSD Access Duration: %f ms\n", ((double)ssdWaitTime/(double)ssdAccesses)); } else { printf("Average SSD Access Duration: 0 ms\n"); } printf("Total Elapsed Time %d ms\n", global_time-process_table[0].commands[0].time); printf("CPU Utilization %f\n", ( (double) cpuUsageTime / ((double) global_time-process_table[0].commands[0].time))); printf("SSD Utilization %f\n", ((double)ssdUsageTime/((double)global_time-process_table[0].commands[0].time))); // Finish program return 0; };
int main(int argc, char **argv) { FILE *head_fp; Ilist just; Plist demodulators, p; Mindex idx; Term t; int rewritten = 0; BOOL verbose = string_member("verbose", argv, argc);; if (string_member("help", argv, argc) || string_member("-help", argv, argc) || argc < 2) { printf("\n%s, version %s, %s\n",PROGRAM_NAME,PROGRAM_VERSION,PROGRAM_DATE); printf("%s", Help_string); exit(1); } init_standard_ladr(); head_fp = fopen(argv[1], "r"); if (head_fp == NULL) fatal_error("demodulator file can't be opened for reading"); t = read_commands(head_fp, stderr, verbose, KILL_UNKNOWN); if (!is_term(t, "clauses", 1) && !is_term(t, "formulas", 1)) fatal_error("formulas(demodulators) not found"); /* Read list of demodulators. */ demodulators = read_clause_list(head_fp, stderr, TRUE); fclose(head_fp); /* AC-canonicalize and index the demodulators. */ if (assoc_comm_symbols() || comm_symbols()) idx = mindex_init(DISCRIM_WILD, BACKTRACK_UNIF, 0); else idx = mindex_init(DISCRIM_BIND, ORDINARY_UNIF, 0); for (p = demodulators; p != NULL; p = p->next) { /* assume positive equality unit */ Topform d = p->v; Literals lit = d->literals; Term alpha = lit->atom->args[0]; mark_oriented_eq(lit->atom); /* don not check for termination */ if (assoc_comm_symbols()) ac_canonical(lit->atom, -1); mindex_update(idx, alpha, INSERT); } if (verbose) fwrite_clause_list(stdout, demodulators, "demodulators", CL_FORM_BARE); /* Read and demodulate terms. */ t = read_term(stdin, stderr); while (t != NULL) { rewritten++; if (verbose) { fprintf(stdout, "\nBefore: "); fwrite_term_nl(stdout, t); } if (assoc_comm_symbols()) ac_canonical(t, -1); just = NULL; t = demodulate(t, idx, &just, FALSE); if (verbose) fprintf(stdout, "After: "); fwrite_term_nl(stdout, t); fflush(stdout); zap_ilist(just); zap_term(t); t = read_term(stdin, stderr); } printf("%% %s %s: rewrote %d terms with %d rewrite steps in %.2f seconds.\n", PROGRAM_NAME, argv[1], rewritten, demod_rewrites(), user_seconds()); exit(0); } /* main */