bool GBACheatAddLine(struct GBACheatSet* cheats, const char* line) { uint32_t op1; uint16_t op2; uint16_t op3; line = hex32(line, &op1); if (!line) { return false; } while (isspace((int) line[0])) { ++line; } line = hex16(line, &op2); if (!line) { return false; } if (!line[0] || isspace((int) line[0])) { return GBACheatAddCodeBreaker(cheats, op1, op2); } line = hex16(line, &op3); if (!line) { return false; } uint32_t realOp2 = op2; realOp2 <<= 16; realOp2 |= op3; return GBACheatAddAutodetect(cheats, op1, realOp2); }
static void dump_section_table (MonoSectionTable *st) { guint32 flags = st->st_flags; printf ("\n\tName: %s\n", st->st_name); hex32 (" Virtual Size", st->st_virtual_size); hex32 ("Virtual Address", st->st_virtual_address); hex32 (" Raw Data Size", st->st_raw_data_size); hex32 (" Raw Data Ptr", st->st_raw_data_ptr); hex32 (" Reloc Ptr", st->st_reloc_ptr); hex32 (" LineNo Ptr", st->st_lineno_ptr); hex16 (" Reloc Count", st->st_reloc_count); hex16 (" Line Count", st->st_line_count); printf ("\tFlags: %s%s%s%s%s%s%s%s%s%s\n", (flags & SECT_FLAGS_HAS_CODE) ? "code, " : "", (flags & SECT_FLAGS_HAS_INITIALIZED_DATA) ? "data, " : "", (flags & SECT_FLAGS_HAS_UNINITIALIZED_DATA) ? "bss, " : "", (flags & SECT_FLAGS_MEM_DISCARDABLE) ? "discard, " : "", (flags & SECT_FLAGS_MEM_NOT_CACHED) ? "nocache, " : "", (flags & SECT_FLAGS_MEM_NOT_PAGED) ? "nopage, " : "", (flags & SECT_FLAGS_MEM_SHARED) ? "shared, " : "", (flags & SECT_FLAGS_MEM_EXECUTE) ? "exec, " : "", (flags & SECT_FLAGS_MEM_READ) ? "read, " : "", (flags & SECT_FLAGS_MEM_WRITE) ? "write" : ""); }
static void dump_coff_header (MonoCOFFHeader *coff) { printf ("\nCOFF Header:\n"); hex16 (" Machine", coff->coff_machine); hex16 (" Sections", coff->coff_sections); hex32 (" Time stamp", coff->coff_time); hex32 ("Pointer to Symbol Table", coff->coff_symptr); hex32 (" Symbol Count", coff->coff_symcount); hex16 (" Optional Header Size", coff->coff_opt_header_size); hex16 (" Characteristics", coff->coff_attributes); }
static void dump_nt_header (MonoPEHeaderNT *nt) { printf ("\nNT Header:\n"); hex32 (" Image Base (0x400000)", nt->pe_image_base); hex32 ("Section Alignment (8192)", nt->pe_section_align); hex32 (" File Align (512/4096)", nt->pe_file_alignment); hex16 (" OS Major (4)", nt->pe_os_major); hex16 (" OS Minor (0)", nt->pe_os_minor); hex16 (" User Major (0)", nt->pe_user_major); hex16 (" User Minor (0)", nt->pe_user_minor); hex16 (" Subsys major (4)", nt->pe_subsys_major); hex16 (" Subsys minor (0)", nt->pe_subsys_minor); hex32 (" Reserverd", nt->pe_reserved_1); hex32 (" Image Size", nt->pe_image_size); hex32 (" Header Size", nt->pe_header_size); hex32 (" Checksum (0)", nt->pe_checksum); hex16 (" Subsystem", nt->pe_subsys_required); hex16 (" DLL Flags (0)", nt->pe_dll_flags); hex32 (" Stack Reserve Size (1M)", nt->pe_stack_reserve); hex32 ("Stack commit Size (4096)", nt->pe_stack_commit); hex32 (" Heap Reserve Size (1M)", nt->pe_heap_reserve); hex32 (" Heap Commit Size (4096)", nt->pe_heap_commit); hex32 (" Loader flags (0x1)", nt->pe_loader_flags); hex32 (" Data Directories (16)", nt->pe_data_dir_count); }
int VnetId_aton(const char *s, VnetId *vnet){ int err = -EINVAL; const char *p, *q; uint16_t v; char buf[5]; int buf_n = sizeof(buf) - 1; int i, n; const int elts_n = VNETID_SIZE16; q = s; p = strchr(q, ':'); i = (p ? 0 : elts_n - 1); do { if(!p){ if(i < elts_n - 1) goto exit; p = s + strlen(s); } n = p - q; if(n > buf_n) goto exit; memcpy(buf, q, n); buf[n] = '\0'; err = hex16(buf, &v); if(err) goto exit; vnet->u.vnet16[i] = htons(v); q = p+1; p = strchr(q, ':'); i++; } while(i < elts_n); err = 0; exit: if(err){ *vnet = (VnetId){}; } return err; }
bool GBACheatAddLine(struct mCheatSet* set, const char* line, int type) { struct GBACheatSet* cheats = (struct GBACheatSet*) set; switch (type) { case GBA_CHEAT_AUTODETECT: break; case GBA_CHEAT_CODEBREAKER: return GBACheatAddCodeBreakerLine(cheats, line); case GBA_CHEAT_GAMESHARK: return GBACheatAddGameSharkLine(cheats, line); case GBA_CHEAT_PRO_ACTION_REPLAY: return GBACheatAddProActionReplayLine(cheats, line); case GBA_CHEAT_VBA: return GBACheatAddVBALine(cheats, line); default: return false; } uint32_t op1; uint16_t op2; uint16_t op3; const char* lineNext = hex32(line, &op1); if (!lineNext) { return false; } if (lineNext[0] == ':') { return GBACheatAddVBALine(cheats, line); } while (isspace((int) lineNext[0])) { ++lineNext; } lineNext = hex16(lineNext, &op2); if (!lineNext) { return false; } if (!lineNext[0] || isspace((int) lineNext[0])) { return GBACheatAddCodeBreaker(cheats, op1, op2); } lineNext = hex16(lineNext, &op3); if (!lineNext) { return false; } uint32_t realOp2 = op2; realOp2 <<= 16; realOp2 |= op3; return GBACheatAddAutodetect(cheats, op1, realOp2); }
static void dump_pe_header (MonoPEHeader *pe) { printf ("\nPE Header:\n"); hex16 (" Magic (0x010b)", pe->pe_magic); hex8 (" LMajor (6)", pe->pe_major); hex8 (" LMinor (0)", pe->pe_minor); hex32 (" Code Size", pe->pe_code_size); hex32 (" Initialized Data Size", pe->pe_data_size); hex32 ("Uninitialized Data Size", pe->pe_uninit_data_size); hex32 (" Entry Point RVA", pe->pe_rva_entry_point); hex32 (" Code Base RVA", pe->pe_rva_code_base); hex32 (" Data Base RVA", pe->pe_rva_data_base); printf ("\n"); }
static int pkconv(char *pd) { char *buf, *p; int i; if((buf = malloc(INBUFSIZ)) == NULL) { error("Memory allocation error"); } p = pd; for(i = 0;*p != '\0';++i) { if(p[0] == '%' && isxdigit(p[1]) && isxdigit(p[2])) { buf[i] = (16 * hex16(p[1])) + hex16(p[2]); p = &p[3]; } else if(p[0] == '+') { buf[i] = ' '; ++p; } else buf[i] = *p++; } buf[i] = '\0'; cnvbuff(buf); strcpy(pd, buf); }
bool GBACheatAddCodeBreakerLine(struct GBACheatSet* cheats, const char* line) { uint32_t op1; uint16_t op2; line = hex32(line, &op1); if (!line) { return false; } while (*line == ' ') { ++line; } line = hex16(line, &op2); if (!line) { return false; } return GBACheatAddCodeBreaker(cheats, op1, op2); }
static inline int __init parse_eth0_hwaddr(const char *buf, u8 *out) { int i, t; u8 addr[6]; for (i = 0; i < 6; i++) { t = hex16(buf); if (t == -1) return -1; addr[i] = t; buf += 3; } memcpy(out, addr, 6); return 0; }
uint16_t ihx_record_address(char line[]) { return hex16(&line[3]); }