// This function takes a small screenshot at the specified position, checks for // the magic pattern, and then fills in the measurement struct with data // decoded from the pixels of the pattern. Returns true if successful, false // if the screenshot failed or the magic pattern was not present. static bool read_data_from_screen(uint32_t x, uint32_t y, const uint8_t magic_pattern[], measurement_t *out) { assert(out); screenshot *screenshot = take_screenshot(x, y, pattern_pixels, 1); if (!screenshot) { return false; } if (screenshot->width != pattern_pixels) { free_screenshot(screenshot); return false; } // Check that the magic pattern is there, starting at the first pixel. size_t found_x, found_y; if (!find_pattern(magic_pattern, screenshot, &found_x, &found_y) || found_x || found_y) { free_screenshot(screenshot); return false; } out->javascript_frames = screenshot->pixels[pattern_magic_pixels * 4 + 0]; out->key_down_events = screenshot->pixels[pattern_magic_pixels * 4 + 1]; out->test_mode = (test_mode_t) screenshot->pixels[pattern_magic_pixels * 4 + 2]; out->scroll_position = screenshot->pixels[(pattern_magic_pixels + 1) * 4]; out->css_frames = screenshot->pixels[(pattern_magic_pixels + 2) * 4]; out->screenshot_time = screenshot->time_nanoseconds; free_screenshot(screenshot); debug_log("javascript frames: %d, javascript events: %d, scroll position: %d" ", css frames: %d, test mode: %d", out->javascript_frames, out->key_down_events, out->scroll_position, out->css_frames, out->test_mode); return true; }
static int SI_GetZ80 (void) { int offset=0; offset = find_pattern(SI_Z80_Block, 0x10); if (offset) SI_CurrentVer = 0; else SI_CurrentVer = SI_INVALID_VER; return offset; }
bool Cgiter_get_local_bp_dist(const Cgiter* cgiter, Tstamp* dist) { rassert(cgiter != NULL); rassert(dist != NULL); rassert(Tstamp_cmp(dist, TSTAMP_AUTO) >= 0); if (Cgiter_has_finished(cgiter)) return false; const Pattern* pattern = find_pattern(cgiter); if (pattern == NULL) return false; // Check pattern end const Tstamp* pat_length = Pattern_get_length(pattern); const Tstamp* dist_to_end = Tstamp_sub(TSTAMP_AUTO, pat_length, &cgiter->pos.pat_pos); if (Tstamp_cmp(dist_to_end, TSTAMP_AUTO) <= 0) { // We cannot move forwards in playback time Tstamp_set(dist, 0, 0); return true; } // Check next trigger row Column* column = Pattern_get_column(pattern, cgiter->col_index); rassert(column != NULL); Column_iter* citer = Column_iter_init(COLUMN_ITER_AUTO); Column_iter_change_col(citer, column); const Tstamp* epsilon = Tstamp_set(TSTAMP_AUTO, 0, 1); Tstamp* next_pos_min = Tstamp_add(TSTAMP_AUTO, &cgiter->pos.pat_pos, epsilon); const Trigger_list* row = Column_iter_get_row(citer, next_pos_min); if (row != NULL) { rassert(row->next != NULL); rassert(row->next->trigger != NULL); if (Tstamp_cmp(&row->next->trigger->pos, pat_length) <= 0) { // Trigger row found inside this pattern const Tstamp* dist_to_row = Tstamp_sub( TSTAMP_AUTO, &row->next->trigger->pos, &cgiter->pos.pat_pos); Tstamp_mina(dist, dist_to_row); return true; } } // No trigger row found Tstamp_mina(dist, dist_to_end); return true; }
/* * This function patch the padRead calls */ int patch_padRead(void) { u32 *ptr = NULL; u32 memscope, inst, fncall; u32 pattern[1], mask[1]; u32 start = 0x00100000; int pattern_found = 0; const pattern_t *pat; GS_BGCOLOUR = 0x800080; /* Purple while padRead pattern search */ memscope = 0x01f00000 - start; /* First try to locate the orginal libpad's scePadRead function */ pat = _padread_patterns; while (pat->seq) { ptr = find_pattern((u32*)start, memscope, pat); if (ptr) { scePadRead_style = pat->tag; /* tag tells the version */ break; } pat++; } if (!ptr) { GS_BGCOLOUR = 0x808080; /* Gray, pattern not found */ return 0; } GS_BGCOLOUR = 0x008000; /* Green while padRead patches */ /* Save original scePadRead ptr */ if (scePadRead_style == 2) scePad2Read = (void *)ptr; else scePadRead = (void *)ptr; /* Retrieve scePadRead call Instruction code */ inst = 0x0c000000; inst |= 0x03ffffff & ((u32)ptr >> 2); /* Make pattern with function call code saved above */ pattern[0] = inst; mask[0] = 0xffffffff; /* Get Hook_scePadRead call Instruction code */ if (scePadRead_style == 2) { inst = 0x0c000000; inst |= 0x03ffffff & ((u32)Hook_scePad2Read >> 2); }
/** * Finds all occurrences of a given string in the html box tree * * \param pattern the string pattern to search for * \param p_len pattern length * \param cur pointer to the current box * \param case_sens whether to perform a case sensitive search * \return true on success, false on memory allocation failure */ static bool find_occurrences_html(const char *pattern, int p_len, struct box *cur, bool case_sens, struct search_context *context) { struct box *a; /* ignore this box, if there's no visible text */ if (!cur->object && cur->text) { const char *text = cur->text; unsigned length = cur->length; while (length > 0) { struct list_entry *entry; unsigned match_length; unsigned match_offset; const char *new_text; const char *pos = find_pattern(text, length, pattern, p_len, case_sens, &match_length); if (!pos) break; /* found string in box => add to list */ match_offset = pos - cur->text; entry = add_entry(cur->byte_offset + match_offset, cur->byte_offset + match_offset + match_length, context); if (!entry) return false; entry->start_box = cur; entry->end_box = cur; new_text = pos + match_length; length -= (new_text - text); text = new_text; } } /* and recurse */ for (a = cur->children; a; a = a->next) { if (!find_occurrences_html(pattern, p_len, a, case_sens, context)) return false; } return true; }
int main() { srand(time(NULL)); printf("!"); while (1) { int pattern_len = rand() % MAX_LEN; int text_len = rand() % MAX_LEN; char pattern[pattern_len]; char text[text_len]; fill(pattern_len, pattern); fill(text_len, text); int *matches = NULL; find_pattern(pattern_len, pattern, text_len, text, &matches); printf("."); } }
static void find_devs(bool block) { char *path = block ? "/sys/dev/block" : "/sys/dev/char"; struct dirent *dp; DIR *dir; dir = opendir(path); if (!dir) return; path = buf2 + sprintf(buf2, "%s/", path); while ((dp = readdir(dir)) != NULL) { char *c; int major = 0, minor = 0; int len; if (dp->d_type != DT_LNK) continue; if (sscanf(dp->d_name, "%d:%d", &major, &minor) != 2) continue; strcpy(path, dp->d_name); len = readlink(buf2, buf, sizeof(buf)); if (len <= 0) continue; buf[len] = 0; if (!find_pattern(buf)) continue; c = strrchr(buf, '/'); if (!c) continue; c++; make_dev(c, block, major, minor); } closedir(dir); }
static bool find_occurrences_text(const char *pattern, int p_len, struct content *c, bool case_sens, struct search_context *context) { int nlines = textplain_line_count(c); int line; for(line = 0; line < nlines; line++) { size_t offset, length; const char *text = textplain_get_line(c, line, &offset, &length); if (text) { while (length > 0) { struct list_entry *entry; unsigned match_length; size_t start_idx; const char *new_text; const char *pos = find_pattern(text, length, pattern, p_len, case_sens, &match_length); if (!pos) break; /* found string in line => add to list */ start_idx = offset + (pos - text); entry = add_entry(start_idx, start_idx + match_length, context); if (!entry) return false; new_text = pos + match_length; offset += (new_text - text); length -= (new_text - text); text = new_text; } } } return true; }
/* * Example data = $NAME:111$STAT:222 find_match_pattern(name, strlen(name), * data, "$NAME", ""); produces : ret = 1, name = 111 find_match_pattern(ip, * strlen(ip), data, "$IP", "0.0.0.0"); produces : ret = 0, ip = 0.0.0.0 */ int find_match_pattern(char *name, size_t mlen, const char *data, const char *pattern, char *def) { int ret = 0; unsigned int offset, len, length; ret = find_pattern(data, strlen(data), pattern, strlen(pattern), '$', &offset, &len); // printf("ret=[%d] offset=[%d] len=[%d]\n", ret, offset,len); if (ret == 1 && len > 0) { length = len > mlen ? mlen : len; strncpy(name, data + offset, length); name[length] = '\0'; } else snprintf(name, mlen + 1, "%s", def); // not found and set to // default value return ret; }
int main() { int test_count; scanf("%d", &test_count); for (int i = 0; i < test_count; i ++) { int source_row, source_column, search_row, search_column; scanf("%d %d", &source_row, &source_column); char source[source_row][source_column]; for(int j = 0; j < source_row; j++) { scanf("%s", source[j]); } scanf("%d %d", &search_row, &search_column); char search[search_row][search_column]; for (int m = 0; m < search_row; m++) { scanf("%s", search[m]); } bool found; found = find_pattern(source_row, source_column, source, search_row, search_column, search); if (found == true) { printf("YES\n"); } else { printf("NO\n"); } } return 0; }
player_won Referee::five_in_a_row() { int tab_buff[][2] = {{0, -1}, {1, -1}, {1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1}}; unsigned int buff_x, buff_y, buff_val; bool is_breakable; size_t size_five, j; for (unsigned int x = 0; x < Map::Size; ++x) for (unsigned int y = 0; y < Map::Size; ++y) { //_map->set_ref_winning(x, y, case_ref_winning::NONE_WINNING); buff_val = _map->get_occ_case(x, y); if (buff_val != case_type::EMPTY) { int pattern_tab[][2] = {{-1, case_type::EMPTY}, {0, static_cast<int>(buff_val)}, {1, static_cast<int>(buff_val)}, {2, (buff_val == case_type::WHITE ? case_type::BLACK : case_type::WHITE)}}; int pattern_tab_inv[][2] = {{-2, case_type::EMPTY}, {-1, static_cast<int>(buff_val)}, {0, static_cast<int>(buff_val)}, {1, (buff_val == case_type::WHITE ? case_type::BLACK : case_type::WHITE)}}; for (size_t i = 0; i < 8; ++i) { size_five = 0; for (j = 0; j < 5; j++) { size_five++; buff_x = x + (tab_buff[i][0] * j); buff_y = y + (tab_buff[i][1] * j); if (!(buff_x >= Map::Size || buff_y >= Map::Size)) { if (buff_val != _map->get_occ_case(buff_x, buff_y)) break; } else break; } if (j == 5) { is_breakable = false; for (int k = 0; k < 5; k++) { buff_x = x + (tab_buff[i][0] * k); buff_y = y + (tab_buff[i][1] * k); if (find_pattern(i, pattern_tab, pattern_tab_inv, buff_x, buff_y)) is_breakable = true; } if (!is_breakable) { return ((buff_val == case_type::WHITE) ? player_won::WHITE_WON : player_won::BLACK_WON); } } else if (j == 4) { for (int k = 0; k < 4; k++) { buff_x = x + (tab_buff[i][0] * k); buff_y = y + (tab_buff[i][1] * k); find_pattern(i, pattern_tab, pattern_tab_inv, buff_x, buff_y); } buff_x = x + (tab_buff[i][0] * -1); buff_y = y + (tab_buff[i][1] * -1); if (!(buff_x >= Map::Size || buff_y >= Map::Size)) _map->set_ref_winning(buff_x, buff_y, (buff_val == case_type::WHITE) ? case_ref_winning::WHITE_WINNING : case_ref_winning::BLACK_WINNING); buff_x = x + (tab_buff[i][0] * 4); buff_y = y + (tab_buff[i][1] * 4); if (!(buff_x >= Map::Size || buff_y >= Map::Size)) _map->set_ref_winning(buff_x, buff_y, (buff_val == case_type::WHITE) ? case_ref_winning::WHITE_WINNING : case_ref_winning::BLACK_WINNING); } else if (j == 3) { for (int k = 0; k < 3; k++) { buff_x = x + (tab_buff[i][0] * k); buff_y = y + (tab_buff[i][1] * k); find_pattern(i, pattern_tab, pattern_tab_inv, buff_x, buff_y); } buff_x = x + (tab_buff[i][0] * -1); buff_y = y + (tab_buff[i][1] * -1); if (!(buff_x >= Map::Size || buff_y >= Map::Size)) _map->set_ref_winning(buff_x, buff_y, (buff_val == case_type::WHITE) ? case_ref_winning::WHITE_POSSIBLE : case_ref_winning::BLACK_POSSIBLE); buff_x = x + (tab_buff[i][0] * 3); buff_y = y + (tab_buff[i][1] * 3); if (!(buff_x >= Map::Size || buff_y >= Map::Size)) _map->set_ref_winning(buff_x, buff_y, (buff_val == case_type::WHITE) ? case_ref_winning::WHITE_POSSIBLE : case_ref_winning::BLACK_POSSIBLE); } } } } return (player_won::NONE); }
/* Find a free name for an object given a a prefix. */ char * find_name(const char *prefix, int type, int namelen) { struct gctl_req *req; char comment[1], buf[GV_CFG_LEN - 1], *name, *sname, *ptr; const char *errstr; int i, n, begin, len, conflict; char line[1024]; comment[0] = '\0'; /* Find a name. Fetch out configuration first. */ req = gctl_get_handle(); gctl_ro_param(req, "class", -1, "VINUM"); gctl_ro_param(req, "verb", -1, "getconfig"); gctl_ro_param(req, "comment", -1, comment); gctl_rw_param(req, "config", sizeof(buf), buf); errstr = gctl_issue(req); if (errstr != NULL) { warnx("can't get configuration: %s", errstr); return (NULL); } gctl_free(req); begin = 0; len = strlen(buf); i = 0; sname = malloc(namelen + 1); /* XXX: Max object setting? */ for (n = 0; n < 10000; n++) { snprintf(sname, namelen, "%s%d", prefix, n); conflict = 0; begin = 0; /* Loop through the configuration line by line. */ for (i = 0; i < len; i++) { if (buf[i] == '\n' || buf[i] == '\0') { ptr = buf + begin; strlcpy(line, ptr, (i - begin) + 1); begin = i + 1; switch (type) { case GV_TYPE_DRIVE: name = find_pattern(line, "drive"); break; case GV_TYPE_VOL: name = find_pattern(line, "volume"); break; case GV_TYPE_PLEX: case GV_TYPE_SD: name = find_pattern(line, "name"); break; default: printf("Invalid type given\n"); continue; } if (name == NULL) continue; if (!strcmp(sname, name)) { conflict = 1; /* XXX: Could quit the loop earlier. */ } } } if (!conflict) return (sname); } free(sname); return (NULL); }
/* * This function patch the _sceSifLoadModule calls */ int patch_loadModule(void) { u32 *ptr = NULL; u32 memscope, inst, fncall; u32 pattern[1], mask[1]; u32 start = 0x00100000; int pattern_found = 0; const pattern_t *pat; GS_BGCOLOUR = 0x00a5ff; /* Orange while _sceSifLoadModule pattern search */ memscope = 0x01f00000 - start; /* First try to locate the orginal _sceSifLoadModule function */ pat = _loadmodule_patterns; while (pat->seq) { ptr = find_pattern((u32*)start, memscope, pat); if (ptr) break; pat++; } if (!ptr) { GS_BGCOLOUR = 0x808080; /* Gray, pattern not found */ return 0; } GS_BGCOLOUR = 0xcbc0ff; /* Pink while _sceSifLoadModule patches */ /* Save original _sceSifLoadModule ptr */ _sceSifLoadModule = (void *)ptr; /* Retrieve _sceSifLoadModule call Instruction code */ inst = 0x0c000000; inst |= 0x03ffffff & ((u32)ptr >> 2); /* Make pattern with function call code saved above */ pattern[0] = inst; mask[0] = 0xffffffff; /* Get Hook_SifLoadModule call Instruction code */ inst = 0x0c000000; inst |= 0x03ffffff & ((u32)Hook_SifLoadModule >> 2); /* Search & patch for calls to _sceSifLoadModule */ ptr = (u32*)start; while (ptr) { memscope = 0x01f00000 - (u32)ptr; ptr = find_pattern_with_mask(ptr, memscope, pattern, mask, sizeof(pattern)); if (ptr) { pattern_found = 1; fncall = (u32)ptr; _sw(inst, fncall); /* overwrite the original _sceSifLoadModule function call with our function call */ ptr += 2; } } if (!pattern_found) GS_BGCOLOUR = 0x808080; /* gray, pattern not found */ else GS_BGCOLOUR = 0x000000; /* Black, done */ return 1; }
// Main test function. Locates the given magic pixel pattern on the screen, then // runs one full latency test, sending input events and recording responses. On // success, the results of the test are reported in the output parameters, and // true is returned. If the test fails, the error parameter is filled in with // an error message and false is returned. bool measure_latency( const uint8_t magic_pattern[], double *out_key_down_latency_ms, double *out_scroll_latency_ms, double *out_max_js_pause_time_ms, double *out_max_css_pause_time_ms, double *out_max_scroll_pause_time_ms, char **error) { screenshot *screenshot = take_screenshot(0, 0, UINT32_MAX, UINT32_MAX); if (!screenshot) { *error = "Failed to take screenshot."; return false; } assert(screenshot->width > 0 && screenshot->height > 0); size_t x, y; bool found_pattern = find_pattern(magic_pattern, screenshot, &x, &y); free_screenshot(screenshot); if (!found_pattern) { *error = "Failed to find test pattern on screen."; return false; } uint8_t full_pattern[pattern_bytes]; for (int i = 0; i < pattern_magic_bytes; i++) { full_pattern[i] = magic_pattern[i]; } measurement_t measurement; measurement_t previous_measurement; memset(&measurement, 0, sizeof(measurement_t)); memset(&previous_measurement, 0, sizeof(measurement_t)); int screenshots = 0; bool first_screenshot_successful = read_data_from_screen((uint32_t)x, (uint32_t) y, magic_pattern, &measurement); if (!first_screenshot_successful) { *error = "Failed to read data from test pattern."; return false; } if (measurement.test_mode == TEST_MODE_NATIVE_REFERENCE) { uint8_t *test_pattern = (uint8_t *)malloc(pattern_bytes); memset(test_pattern, 0, pattern_bytes); for (int i = 0; i < pattern_magic_bytes; i++) { test_pattern[i] = rand(); } if (!open_native_reference_window(test_pattern)) { *error = "Failed to open native reference window."; return false; } bool return_value = measure_latency(test_pattern, out_key_down_latency_ms, out_scroll_latency_ms, out_max_js_pause_time_ms, out_max_css_pause_time_ms, out_max_scroll_pause_time_ms, error); if (!close_native_reference_window()) { debug_log("Failed to close native reference window."); }; return return_value; } int64_t start_time = measurement.screenshot_time; previous_measurement = measurement; statistic javascript_frames; statistic css_frames; statistic key_down_events; statistic scroll_stats; init_statistic("javascript_frames", &javascript_frames, measurement.javascript_frames, start_time); init_statistic("key_down_events", &key_down_events, measurement.key_down_events, start_time); init_statistic("css_frames", &css_frames, measurement.css_frames, start_time); init_statistic("scroll", &scroll_stats, measurement.scroll_position, start_time); int sent_events = 0; int scroll_x = x + 40; int scroll_y = y + 40; int64_t last_scroll_sent = start_time; if (measurement.test_mode == TEST_MODE_SCROLL_LATENCY) { send_scroll_down(scroll_x, scroll_y); scroll_stats.previous_change_time = get_nanoseconds(); } while(true) { bool screenshot_successful = read_data_from_screen((uint32_t)x, (uint32_t) y, magic_pattern, &measurement); if (!screenshot_successful) { *error = "Test window moved during test. The test window must remain " "stationary and focused during the entire test."; return false; } if (measurement.test_mode == TEST_MODE_ABORT) { *error = "Test aborted."; return false; } screenshots++; int64_t screenshot_time = measurement.screenshot_time; int64_t previous_screenshot_time = previous_measurement.screenshot_time; debug_log("screenshot time %f", (screenshot_time - previous_screenshot_time) / (double)nanoseconds_per_millisecond); update_statistic(&javascript_frames, measurement.javascript_frames, screenshot_time, previous_screenshot_time); update_statistic(&key_down_events, measurement.key_down_events, screenshot_time, previous_screenshot_time); update_statistic(&css_frames, measurement.css_frames, screenshot_time, previous_screenshot_time); bool scroll_updated = update_statistic(&scroll_stats, measurement.scroll_position, screenshot_time, previous_screenshot_time); if (measurement.test_mode == TEST_MODE_JAVASCRIPT_LATENCY) { if (key_down_events.measurements >= latency_measurements_to_take) { break; } if (key_down_events.value_delta > sent_events) { *error = "More events received than sent! This is probably a bug in " "the test."; return false; } if (screenshot_time - key_down_events.previous_change_time > event_response_timeout_ms * nanoseconds_per_millisecond) { *error = "Browser did not respond to keyboard input. Make sure the " "test page remains focused for the entire test."; return false; } if (key_down_events.value_delta == sent_events) { // We want to avoid sending input events at a predictable time relative // to frames, so introduce a random delay of up to 1 frame (16.67 ms) // before sending the next event. usleep((rand() % 17) * 1000); if (!send_keystroke_z()) { *error = "Failed to send keystroke for \"Z\" key to test window."; return false; } key_down_events.previous_change_time = get_nanoseconds(); sent_events++; } } else if (measurement.test_mode == TEST_MODE_SCROLL_LATENCY) { if (scroll_stats.measurements >= latency_measurements_to_take) { break; } if (screenshot_time - scroll_stats.previous_change_time > event_response_timeout_ms * nanoseconds_per_millisecond) { *error = "Browser did not respond to scroll events. Make sure the " "test page remains focused for the entire test."; return false; } if (scroll_updated) { // We saw the start of a scroll. Wait for the scroll animation to // finish before continuing. We assume the animation is finished if // it's been 100 milliseconds since we last saw the scroll position // change. int64_t scroll_update_time = screenshot_time; int64_t scroll_wait_start_time = screenshot_time; while (screenshot_time - scroll_update_time < 100 * nanoseconds_per_millisecond) { screenshot_successful = read_data_from_screen((uint32_t)x, (uint32_t) y, magic_pattern, &measurement); if (!screenshot_successful) { *error = "Test window moved during test. The test window must " "remain stationary and focused during the entire test."; return false; } screenshot_time = measurement.screenshot_time; if (screenshot_time - scroll_wait_start_time > nanoseconds_per_second) { *error = "Browser kept scrolling for more than 1 second after a " "single scrollwheel event."; return false; } if (measurement.scroll_position != scroll_stats.value) { scroll_stats.value = measurement.scroll_position; scroll_update_time = screenshot_time; } } // We want to avoid sending input events at a predictable time // relative to frames, so introduce a random delay of up to 1 frame // (16.67 ms) before sending the next event. usleep((rand() % 17) * 1000); send_scroll_down(scroll_x, scroll_y); scroll_stats.previous_change_time = get_nanoseconds(); } } else if (measurement.test_mode == TEST_MODE_PAUSE_TIME) { // For the pause time test we want the browser to scroll continuously. // Send a scroll event every frame. if (screenshot_time - last_scroll_sent > 17 * nanoseconds_per_millisecond) { send_scroll_down(scroll_x, scroll_y); last_scroll_sent = get_nanoseconds(); } } else if (measurement.test_mode == TEST_MODE_PAUSE_TIME_TEST_FINISHED) { break; } else { *error = "Invalid test type. This is a bug in the test."; return false; } if (screenshot_time - start_time > test_timeout_ms * nanoseconds_per_millisecond) { *error = "Timeout."; return false; } previous_measurement = measurement; usleep(0); } // The latency we report is the midpoint of the interval given by the average // upper and lower bounds we've computed. *out_key_down_latency_ms = (upper_bound_ms(&key_down_events) + lower_bound_ms(&key_down_events)) / 2; *out_scroll_latency_ms = (upper_bound_ms(&scroll_stats) + lower_bound_ms(&scroll_stats) / 2); *out_max_js_pause_time_ms = javascript_frames.max_lower_bound / (double) nanoseconds_per_millisecond; *out_max_css_pause_time_ms = css_frames.max_lower_bound / (double) nanoseconds_per_millisecond; *out_max_scroll_pause_time_ms = scroll_stats.max_lower_bound / (double) nanoseconds_per_millisecond; debug_log("out_key_down_latency_ms: %f out_scroll_latency_ms: %f " "out_max_js_pause_time_ms: %f out_max_css_pause_time: %f\n " "out_max_scroll_pause_time_ms: %f", *out_key_down_latency_ms, *out_scroll_latency_ms, *out_max_js_pause_time_ms, *out_max_css_pause_time_ms, *out_max_scroll_pause_time_ms); return true; }
int main(int argc, char* argv[]) { FILE* file; char* inputfile; char* outputfile; UINT8* buffer; INT32 filesize; INT32 read; UINT8* rest; INT32 rest_size; UINT8* module; UINT32 module_counter; UINT8 error_code; if(argc < 3) { printf("PMPatch v0.3.1\nThis program patches UEFI BIOS files\nto be compatible with MacOS X SpeedStep implementation\n\n" "Usage: PMPatch INFILE OUTFILE\n\n"); return ERR_ARGS; } inputfile = argv[1]/*/"in.rom"*/; outputfile = argv[2]/*/"out.rom"*/; /* Opening input file */ file = fopen(inputfile, "rb"); if (!file) { perror("Can't open input file.\n"); return ERR_INPUT_FILE; } /* Determining file size */ fseek(file, 0, SEEK_END); filesize = ftell(file); fseek(file, 0, SEEK_SET); /* Allocating memory for buffer */ buffer = (UINT8*)malloc(filesize); if (!buffer) { fprintf(stderr, "Can't allocate memory for buffer.\n"); return ERR_MEMORY; } /* Reading whole file to buffer */ read = fread((void*)buffer, sizeof(char), filesize, file); if (read != filesize) { perror("Can't read input file.\n"); return ERR_INPUT_FILE; } /* Closing input file */ fclose(file); /* Searching for PowerManagement modules and patching them if found */ module_counter = 0; rest = buffer; rest_size = filesize; do { module = find_pattern(rest, rest_size, PWRMGMT_UUID, MODULE_UUID_LENGTH); if(module) { rest_size = filesize - (module - buffer); rest = module + 1; module_counter++; if(patch_powermanagement_module(module, &error_code)) printf("PowerManagement module at %08X patched.\n", module - buffer); else printf("PowerManagement module at %08X not patched.\n%s\n", module - buffer, PATCH_PWRMGMT_ERROR_MESSAGES[error_code]); } } while(module); if(!module_counter) { printf("PowerManagement module not found.\n"); /* Searching for CpuPei modules and patching them if found */ module_counter = 0; rest = buffer; rest_size = filesize; do { module = find_pattern(rest, rest_size, CPUPEI_UUID, MODULE_UUID_LENGTH); if(module) { rest_size = filesize - (module - buffer); rest = module + 1; module_counter++; if(patch_cpupei_module(module, &error_code)) printf("CpuPei module at %08X patched.\n", module - buffer); else printf("CpuPei module at %08X not patched.\n%s\n", module - buffer, PATCH_CPUPEI_ERROR_MESSAGES[error_code]); } } while(module); if(!module_counter) { printf("CpuPei module not found. Nothing to do.\n"); return ERR_NO_MODULE; } } /* Creating output file*/ file = fopen(outputfile, "wb"); if (!file) { perror("Can't create output file.\n"); return ERR_OUTPUT_FILE; } /* Writing modified BIOS file*/ if(fwrite(buffer, sizeof(char), filesize, file) != filesize) { perror("Can't write input file.\n"); return ERR_INPUT_FILE; } /* Closing output file */ fclose(file); /* Freeing buffer */ free(buffer); return ERR_OK; }