static void set_sourcepos(lua_State *L, const GumboSourcePosition pos) { if (pos.line != 0) { set_integer(L, "line", pos.line); set_integer(L, "column", pos.column); set_integer(L, "offset", pos.offset); } }
int module_load( YR_SCAN_CONTEXT* context, YR_OBJECT* module_object, void* module_data, size_t module_data_size) { set_integer(1, module_object, "constants.one"); set_integer(2, module_object, "constants.two"); set_string("foo", module_object, "constants.foo"); set_string("", module_object, "constants.empty"); set_integer(1, module_object, "struct_array[1].i"); set_integer(0, module_object, "integer_array[%i]", 0); set_integer(1, module_object, "integer_array[%i]", 1); set_integer(2, module_object, "integer_array[%i]", 2); set_integer(256, module_object, "integer_array[%i]", 256); set_string("foo", module_object, "string_array[%i]", 0); set_string("bar", module_object, "string_array[%i]", 1); set_string("baz", module_object, "string_array[%i]", 2); set_sized_string("foo\0bar", 7, module_object, "string_array[%i]", 3); set_string("foo", module_object, "string_dict[%s]", "foo"); set_string("bar", module_object, "string_dict[\"bar\"]"); set_string("foo", module_object, "struct_dict[%s].s", "foo"); set_integer(1, module_object, "struct_dict[%s].i", "foo"); return ERROR_SUCCESS; }
bool PrefAgent::change_field (ChangeData *cd) { // Get the current field value and add the change to it. char *value = cd->field.Value(); int amount = atoi (value); free (value); amount += cd->change; // reached the limit, need to make the arrow go insensitive if (amount == cd->limit) { // see if incrementing or decrementing if(cd->change < 0) { // user is decrementing--make down arrow insensitive XtSetSensitive(cd->dn_arrow, False); } else { // user is incrementing--make down arrow insensitive XtSetSensitive(cd->up_arrow, False); } } else { // see if incrementing or decrementing if(cd->change < 0) { // user is decrementing--make up arrow sensitive if it is // insensitive if(!XtIsSensitive(cd->up_arrow)) XtSetSensitive(cd->up_arrow, True); } else { // user is incrementing--make down arrow sensitive if it is // insensitive if(!XtIsSensitive(cd->dn_arrow)) XtSetSensitive(cd->dn_arrow, True); } } // Make sure the change won't exceed any limits. // If change is negative, then limit is a lower limit (and vice-versa). if ((cd->change < 0 && amount < cd->limit) || (cd->change > 0 && amount > cd->limit)) { // Sorry, Charlie. window_system().beep(); return (FALSE); } // Update the field to display the new value. set_integer (cd->field, amount); return (TRUE); }
void read_l (st_parameter_dt *dtp, const fnode *f, char *dest, int length) { char *p; int w; w = f->u.w; p = read_block_form (dtp, &w); if (p == NULL) return; while (*p == ' ') { if (--w == 0) goto bad; p++; } if (*p == '.') { if (--w == 0) goto bad; p++; } switch (*p) { case 't': case 'T': set_integer (dest, (GFC_INTEGER_LARGEST) 1, length); break; case 'f': case 'F': set_integer (dest, (GFC_INTEGER_LARGEST) 0, length); break; default: bad: generate_error (&dtp->common, LIBERROR_READ_VALUE, "Bad value on logical read"); next_record (dtp, 1); break; } }
static void push_node(lua_State *L, const GumboNode *node) { luaL_checkstack(L, 10, "Unable to allocate Lua stack space"); switch (node->type) { case GUMBO_NODE_ELEMENT: { const GumboElement *element = &node->v.element; lua_createtable(L, 0, 7); set_tag(L, element); set_sourcepos(L, element->start_pos); if (node->parse_flags != GUMBO_INSERTION_NORMAL) { set_integer(L, "parseFlags", node->parse_flags); } set_attributes(L, &element->attributes); set_children(L, &element->children, 1); setmetatable(L, Element); return; } case GUMBO_NODE_TEMPLATE: { const GumboElement *element = &node->v.element; lua_createtable(L, 0, 8); set_literal(L, "localName", "template"); set_sourcepos(L, element->start_pos); set_attributes(L, &element->attributes); lua_createtable(L, 0, 0); setmetatable(L, NodeList); lua_setfield(L, -2, "childNodes"); lua_createtable(L, 0, 1); set_children(L, &element->children, 1); setmetatable(L, DocumentFragment); lua_setfield(L, -2, "content"); setmetatable(L, Element); return; } case GUMBO_NODE_TEXT: create_text_node(L, &node->v.text, Text); return; case GUMBO_NODE_WHITESPACE: create_text_node(L, &node->v.text, Text); set_literal(L, "type", "whitespace"); return; case GUMBO_NODE_COMMENT: create_text_node(L, &node->v.text, Comment); return; case GUMBO_NODE_CDATA: create_text_node(L, &node->v.text, Text); set_literal(L, "type", "cdata"); return; default: luaL_error(L, "GumboNodeType value out of bounds: %d", node->type); return; } }
/** * \brief Loads the initial values. */ void Savegame::set_initial_values() { // Set the savegame format version. set_integer(KEY_SAVEGAME_VERSION, SAVEGAME_VERSION); // Set the initial controls. set_default_keyboard_controls(); set_default_joypad_controls(); // Set the initial equipment. equipment.set_max_life(1); equipment.set_life(1); equipment.set_ability(ABILITY_TUNIC, 1); // Mandatory to have a valid hero sprite. }
void PrefAgent::reset() { // Reset browse preferences. if (IS_CHANGED (f_browse_geo)) set_geometry (f_browse_geo, ORIGINAL_VALUE (f_browse_geo, WindowGeometry)); if (IS_CHANGED (f_fs_field)) set_integer (f_fs_field, ORIGINAL_VALUE (f_fs_field, Integer)); if (IS_CHANGED (f_lock_toggle)) { set_lock (ORIGINAL_VALUE (f_lock_toggle, Boolean)); f_lock_toggle.Unmap(); f_lock_toggle.Map(); } // Reset map preferences. if (IS_CHANGED (f_map_geo)) set_geometry (f_map_geo, ORIGINAL_VALUE (f_map_geo, WindowGeometry)); if (IS_CHANGED (f_update_toggle)) set_update (ORIGINAL_VALUE (f_update_toggle, Boolean)); // Reset history preferences. if (IS_CHANGED (f_nh_field)) set_integer (f_nh_field, ORIGINAL_VALUE (f_nh_field, Integer)); if (IS_CHANGED (f_sh_field)) set_integer (f_sh_field, ORIGINAL_VALUE (f_sh_field, Integer)); // Reset Search preferences. if (IS_CHANGED (f_max_hits_field)) set_integer (f_max_hits_field, ORIGINAL_VALUE (f_max_hits_field, Integer)); if (IS_CHANGED (f_adisplay_toggle)) set_auto_display (ORIGINAL_VALUE (f_adisplay_toggle, Boolean)); // Desensitize appropriate controls. f_ok.SetSensitive (False); f_apply.SetSensitive (False); f_reset.SetSensitive (False); }
void tabs_widget_rep::handle_mouse (mouse_event ev) { int l= N(a) - 1; string type= ev->type; SI x= ev->x, y= ev->y; int focus; THIS << emit_find_child (x, y, focus); if (focus >= 0 && focus < l && (type == "release-left" || type == "release-right")) { a[l] << set_integer ("switch", focus); THIS << emit_update (); THIS << emit_reposition (); refresh_size (win->get_widget (), true); } else composite_widget_rep::handle_mouse (ev); }
static int push_document(lua_State *L) { const GumboDocument *document = lua_touserdata(L, 1); lua_createtable(L, 0, 4); if (document->has_doctype) { set_integer(L, "quirksModeEnum", document->doc_type_quirks_mode); set_children(L, &document->children, 2); lua_getfield(L, -1, "childNodes"); lua_createtable(L, 0, 3); // doctype set_string(L, "name", document->name); set_string(L, "publicId", document->public_identifier); set_string(L, "systemId", document->system_identifier); setmetatable(L, DocumentType); lua_rawseti(L, -2, 1); // childNodes[1] = doctype lua_pop(L, 1); } else { set_children(L, &document->children, 1); } setmetatable(L, Document); return 1; }
void read_radix (st_parameter_dt *dtp, const fnode *f, char *dest, int length, int radix) { GFC_UINTEGER_LARGEST value, maxv, maxv_r; GFC_INTEGER_LARGEST v; int w, negative; char c, *p; w = f->u.w; p = read_block_form (dtp, &w); if (p == NULL) return; p = eat_leading_spaces (&w, p); if (w == 0) { set_integer (dest, (GFC_INTEGER_LARGEST) 0, length); return; } maxv = max_value (length, 0); maxv_r = maxv / radix; negative = 0; value = 0; switch (*p) { case '-': negative = 1; /* Fall through */ case '+': p++; if (--w == 0) goto bad; /* Fall through */ default: break; } /* At this point we have a digit-string */ value = 0; for (;;) { c = next_char (dtp, &p, &w); if (c == '\0') break; if (c == ' ') { if (dtp->u.p.blank_status == BLANK_NULL) continue; if (dtp->u.p.blank_status == BLANK_ZERO) c = '0'; } switch (radix) { case 2: if (c < '0' || c > '1') goto bad; break; case 8: if (c < '0' || c > '7') goto bad; break; case 16: switch (c) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': break; case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': c = c - 'a' + '9' + 1; break; case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': c = c - 'A' + '9' + 1; break; default: goto bad; } break; } if (value > maxv_r) goto overflow; c -= '0'; value = radix * value; if (maxv - c < value) goto overflow; value += c; } v = value; if (negative) v = -v; set_integer (dest, v, length); return; bad: generate_error (&dtp->common, LIBERROR_READ_VALUE, "Bad value during integer read"); next_record (dtp, 1); return; overflow: generate_error (&dtp->common, LIBERROR_READ_OVERFLOW, "Value overflowed during integer read"); next_record (dtp, 1); }
void read_decimal (st_parameter_dt *dtp, const fnode *f, char *dest, int length) { GFC_UINTEGER_LARGEST value, maxv, maxv_10; GFC_INTEGER_LARGEST v; int w, negative; char c, *p; w = f->u.w; p = read_block_form (dtp, &w); if (p == NULL) return; p = eat_leading_spaces (&w, p); if (w == 0) { set_integer (dest, (GFC_INTEGER_LARGEST) 0, length); return; } maxv = max_value (length, 1); maxv_10 = maxv / 10; negative = 0; value = 0; switch (*p) { case '-': negative = 1; /* Fall through */ case '+': p++; if (--w == 0) goto bad; /* Fall through */ default: break; } /* At this point we have a digit-string */ value = 0; for (;;) { c = next_char (dtp, &p, &w); if (c == '\0') break; if (c == ' ') { if (dtp->u.p.blank_status == BLANK_NULL) continue; if (dtp->u.p.blank_status == BLANK_ZERO) c = '0'; } if (c < '0' || c > '9') goto bad; if (value > maxv_10 && compile_options.range_check == 1) goto overflow; c -= '0'; value = 10 * value; if (value > maxv - c && compile_options.range_check == 1) goto overflow; value += c; } v = value; if (negative) v = -v; set_integer (dest, v, length); return; bad: generate_error (&dtp->common, LIBERROR_READ_VALUE, "Bad value during integer read"); next_record (dtp, 1); return; overflow: generate_error (&dtp->common, LIBERROR_READ_OVERFLOW, "Value overflowed during integer read"); next_record (dtp, 1); }
int module_load( YR_SCAN_CONTEXT* context, YR_OBJECT* module_object, void* module_data, size_t module_data_size) { set_integer( IMAGE_FILE_MACHINE_I386, module_object, "MACHINE_I386"); set_integer( IMAGE_FILE_MACHINE_AMD64, module_object, "MACHINE_AMD64"); set_integer( IMAGE_SUBSYSTEM_UNKNOWN, module_object, "SUBSYSTEM_UNKNOWN"); set_integer( IMAGE_SUBSYSTEM_NATIVE, module_object, "SUBSYSTEM_NATIVE"); set_integer( IMAGE_SUBSYSTEM_WINDOWS_GUI, module_object, "SUBSYSTEM_WINDOWS_GUI"); set_integer( IMAGE_SUBSYSTEM_WINDOWS_CUI, module_object, "SUBSYSTEM_WINDOWS_CUI"); set_integer( IMAGE_SUBSYSTEM_OS2_CUI, module_object, "SUBSYSTEM_OS2_CUI"); set_integer( IMAGE_SUBSYSTEM_POSIX_CUI, module_object, "SUBSYSTEM_POSIX_CUI"); set_integer( IMAGE_SUBSYSTEM_NATIVE_WINDOWS, module_object, "SUBSYSTEM_NATIVE_WINDOWS"); set_integer( IMAGE_FILE_RELOCS_STRIPPED, module_object, "RELOCS_STRIPPED"); set_integer( IMAGE_FILE_EXECUTABLE_IMAGE, module_object, "EXECUTABLE_IMAGE"); set_integer( IMAGE_FILE_LINE_NUMS_STRIPPED, module_object, "LINE_NUMS_STRIPPED"); set_integer( IMAGE_FILE_LOCAL_SYMS_STRIPPED, module_object, "LOCAL_SYMS_STRIPPED"); set_integer( IMAGE_FILE_AGGRESIVE_WS_TRIM, module_object, "AGGRESIVE_WS_TRIM"); set_integer( IMAGE_FILE_LARGE_ADDRESS_AWARE, module_object, "LARGE_ADDRESS_AWARE"); set_integer( IMAGE_FILE_BYTES_REVERSED_LO, module_object, "BYTES_REVERSED_LO"); set_integer( IMAGE_FILE_32BIT_MACHINE, module_object, "32BIT_MACHINE"); set_integer( IMAGE_FILE_DEBUG_STRIPPED, module_object, "DEBUG_STRIPPED"); set_integer( IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP, module_object, "REMOVABLE_RUN_FROM_SWAP"); set_integer( IMAGE_FILE_NET_RUN_FROM_SWAP, module_object, "NET_RUN_FROM_SWAP"); set_integer( IMAGE_FILE_SYSTEM, module_object, "SYSTEM"); set_integer( IMAGE_FILE_DLL, module_object, "DLL"); set_integer( IMAGE_FILE_UP_SYSTEM_ONLY, module_object, "UP_SYSTEM_ONLY"); set_integer( IMAGE_FILE_BYTES_REVERSED_HI, module_object, "BYTES_REVERSED_HI"); YR_MEMORY_BLOCK* block; foreach_memory_block(context, block) { PIMAGE_NT_HEADERS32 pe_header = pe_get_header(block->data, block->size); if (pe_header != NULL) { // ignore DLLs while scanning a process if (!(context->flags & SCAN_FLAGS_PROCESS_MEMORY) || !(pe_header->FileHeader.Characteristics & IMAGE_FILE_DLL)) { PE* pe = (PE*) yr_malloc(sizeof(PE)); if (pe == NULL) return ERROR_INSUFICIENT_MEMORY; pe->data = block->data; pe->data_size = block->size; pe->header = pe_header; pe->object = module_object; module_object->data = pe; pe_parse( pe, block->base, context->flags); break; } } }
void pe_parse( PE* pe, size_t base_address, int flags) { PIMAGE_SECTION_HEADER section; char section_name[IMAGE_SIZEOF_SHORT_NAME + 1]; #define OptionalHeader(field) \ (pe->header->FileHeader.Machine == 0x8664 ? \ ((PIMAGE_NT_HEADERS64) pe->header)->OptionalHeader.field : \ pe->header->OptionalHeader.field) set_integer( pe->header->FileHeader.Machine, pe->object, "machine"); set_integer( pe->header->FileHeader.NumberOfSections, pe->object, "number_of_sections"); set_integer( pe->header->FileHeader.TimeDateStamp, pe->object, "timestamp"); set_integer( pe->header->FileHeader.Characteristics, pe->object, "characteristics"); set_integer( flags & SCAN_FLAGS_PROCESS_MEMORY ? base_address + OptionalHeader(AddressOfEntryPoint) : pe_rva_to_offset(pe, OptionalHeader(AddressOfEntryPoint)), pe->object, "entry_point"); set_integer( OptionalHeader(ImageBase), pe->object, "image_base"); set_integer( OptionalHeader(MajorLinkerVersion), pe->object, "linker_version.major"); set_integer( OptionalHeader(MinorLinkerVersion), pe->object, "linker_version.minor"); set_integer( OptionalHeader(MajorOperatingSystemVersion), pe->object, "os_version.major"); set_integer( OptionalHeader(MinorOperatingSystemVersion), pe->object, "os_version.minor"); set_integer( OptionalHeader(MajorImageVersion), pe->object, "image_version.major"); set_integer( OptionalHeader(MinorImageVersion), pe->object, "image_version.minor"); set_integer( OptionalHeader(MajorSubsystemVersion), pe->object, "subsystem_version.major"); set_integer( OptionalHeader(MinorSubsystemVersion), pe->object, "subsystem_version.minor"); set_integer( OptionalHeader(Subsystem), pe->object, "subsystem"); pe_iterate_resources( pe, (RESOURCE_CALLBACK_FUNC) pe_find_version_info_cb, (void*) pe); section = IMAGE_FIRST_SECTION(pe); int scount = min(pe->header->FileHeader.NumberOfSections, MAX_PE_SECTIONS); for (int i = 0; i < scount; i++) { if ((uint8_t*) section - (uint8_t*) pe + sizeof(IMAGE_SECTION_HEADER) >= pe->data_size) { break; } strlcpy(section_name, (char*) section->Name, IMAGE_SIZEOF_SHORT_NAME + 1); set_string( section_name, pe->object, "sections[%i].name", i); set_integer( section->Characteristics, pe->object, "sections[%i].characteristics", i); set_integer(section->SizeOfRawData, pe->object, "sections[%i].raw_data_size", i); set_integer(section->PointerToRawData, pe->object, "sections[%i].raw_data_offset", i); set_integer(section->VirtualAddress, pe->object, "sections[%i].virtual_address", i); set_integer( section->Misc.VirtualSize, pe->object, "sections[%i].virtual_size", i); section++; } }
static int play_vorbis(lua_State *lstate) { char buf[BLOCKSIZE]; char *pt, *oggbuf, **comm, *mark; int n, sock, sr_err, port; const char *host, *mount; VORBIS_FEED *feed; lua_pushstring(lstate, "host"); lua_gettable(lstate, -2); lua_pushstring(lstate, "port"); lua_gettable(lstate, -3); lua_pushstring(lstate, "mount"); lua_gettable(lstate, -4); mount = lua_tostring(lstate, -1); port = lua_tointeger(lstate, -2); host = lua_tostring(lstate, -3); sock = stream_connect(host, port, mount, buf, &mark); lua_pop(lstate, 3); if (sock == 0) { lua_pop(lstate, 1); return 0; } lua_pushstring(lstate, "intern"); lua_gettable(lstate, -2); feed = (VORBIS_FEED *)lua_touserdata(lstate, -1); lua_pop(lstate, 1); feed->base.sock = sock; pthread_mutex_init(&(feed->base.thread_lock), NULL); pthread_cond_init(&(feed->base.data_ready), NULL); ogg_sync_init(&(feed->oy)); oggbuf = ogg_sync_buffer(&(feed->oy), BLOCKSIZE); n = BLOCKSIZE - (mark - buf); memcpy(oggbuf, mark, n); read_sock(feed->base.sock, oggbuf + n, BLOCKSIZE - n); ogg_sync_wrote(&(feed->oy), BLOCKSIZE); if ((n = ogg_sync_pageout(&(feed->oy), &(feed->og))) != 1) { logmsg("out of data: %d\n", n); free_vorbis((FEED *)feed); lua_pop(lstate, 1); return 0; } ogg_stream_init(&(feed->os), ogg_page_serialno(&(feed->og))); vorbis_info_init(&(feed->vi)); vorbis_comment_init(&(feed->vc)); if (ogg_stream_pagein(&(feed->os), &(feed->og)) < 1) { logmsg("error reading first ogg page\n"); //free_feed(feed); //return 0; } if (ogg_stream_packetout(&(feed->os), &(feed->op)) != 1) { logmsg("error reading first header packet\n"); free_vorbis((FEED *)feed); lua_pop(lstate, 1); return 0; } if (vorbis_synthesis_headerin(&(feed->vi), &(feed->vc), &(feed->op)) < 0) { logmsg("stream is not vorbis\n"); free_vorbis((FEED *)feed); lua_pop(lstate, 1); return 0; } vorbis_headers(feed); add_table(lstate, "info"); add_table(lstate, "comments"); comm = feed->vc.user_comments; while (*comm) { if ((pt = index(*comm, '=')) != NULL) { *pt++ = '\0'; set_string(lstate, *comm, pt); } ++comm; } lua_pop(lstate, 1); // comments feed->base.channels = feed->vi.channels; set_integer(lstate, "channels", feed->base.channels); set_integer(lstate, "srate", feed->vi.rate); lua_pop(lstate, 1); // info feed->base.cbuf = new_ringbuf(feed->vi.rate, feed->base.channels, BUFSECS, 0.333, 0.667); if (jack_sr != feed->vi.rate) { feed->base.converter = src_new(SRC_SINC_MEDIUM_QUALITY, feed->base.channels, &sr_err); feed->base.src_data_in = (float *)malloc(SRC_DATA_FRAMES * feed->base.channels * sizeof(float)); feed->base.src_data.data_in = feed->base.src_data_in; feed->base.src_data_remain = 0; feed->base.src_data.src_ratio = jack_sr / (double)feed->vi.rate; feed->base.src_data_out = (float *)malloc( (int)ceil(SRC_DATA_FRAMES * feed->base.channels * sizeof(float) * feed->base.src_data.src_ratio)); } feed->base.init = 1; lua_pop(lstate, 1); pthread_create(&(feed->base.thread_id), NULL, vorbis_thread, feed); return 0; }
int module_load( YR_SCAN_CONTEXT* context, YR_OBJECT* module_object, void* module_data, size_t module_data_size) { YR_MEMORY_BLOCK* block; elf32_header_t* elf_header32; elf64_header_t* elf_header64; set_integer(ELF_ET_NONE, module_object, "ET_NONE"); set_integer(ELF_ET_REL, module_object, "ET_REL"); set_integer(ELF_ET_EXEC, module_object, "ET_EXEC"); set_integer(ELF_ET_DYN, module_object, "ET_DYN"); set_integer(ELF_ET_CORE, module_object, "ET_CORE"); set_integer(ELF_EM_NONE, module_object, "EM_NONE"); set_integer(ELF_EM_M32, module_object, "EM_M32"); set_integer(ELF_EM_SPARC, module_object, "EM_SPARC"); set_integer(ELF_EM_386, module_object, "EM_386"); set_integer(ELF_EM_68K, module_object, "EM_68K"); set_integer(ELF_EM_88K, module_object, "EM_88K"); set_integer(ELF_EM_860, module_object, "EM_860"); set_integer(ELF_EM_MIPS, module_object, "EM_MIPS"); set_integer(ELF_EM_MIPS_RS3_LE, module_object, "EM_MIPS_RS3_LE"); set_integer(ELF_EM_PPC, module_object, "EM_PPC"); set_integer(ELF_EM_PPC64, module_object, "EM_PPC64"); set_integer(ELF_EM_ARM, module_object, "EM_ARM"); set_integer(ELF_EM_X86_64, module_object, "EM_X86_64"); set_integer(ELF_EM_AARCH64, module_object, "EM_AARCH64"); set_integer(ELF_SHT_NULL, module_object, "SHT_NULL"); set_integer(ELF_SHT_PROGBITS, module_object, "SHT_PROGBITS"); set_integer(ELF_SHT_SYMTAB, module_object, "SHT_SYMTAB"); set_integer(ELF_SHT_STRTAB, module_object, "SHT_STRTAB"); set_integer(ELF_SHT_RELA, module_object, "SHT_RELA"); set_integer(ELF_SHT_HASH, module_object, "SHT_HASH"); set_integer(ELF_SHT_DYNAMIC, module_object, "SHT_DYNAMIC"); set_integer(ELF_SHT_NOTE, module_object, "SHT_NOTE"); set_integer(ELF_SHT_NOBITS, module_object, "SHT_NOBITS"); set_integer(ELF_SHT_REL, module_object, "SHT_REL"); set_integer(ELF_SHT_SHLIB, module_object, "SHT_SHLIB"); set_integer(ELF_SHT_DYNSYM, module_object, "SHT_DYNSYM"); set_integer(ELF_SHF_WRITE, module_object, "SHF_WRITE"); set_integer(ELF_SHF_ALLOC, module_object, "SHF_ALLOC"); set_integer(ELF_SHF_EXECINSTR, module_object, "SHF_EXECINSTR"); set_integer(ELF_PT_NULL, module_object, "PT_NULL"); set_integer(ELF_PT_LOAD, module_object, "PT_LOAD"); set_integer(ELF_PT_DYNAMIC, module_object, "PT_DYNAMIC"); set_integer(ELF_PT_INTERP, module_object, "PT_INTERP"); set_integer(ELF_PT_NOTE, module_object, "PT_NOTE"); set_integer(ELF_PT_SHLIB, module_object, "PT_SHLIB"); set_integer(ELF_PT_PHDR, module_object, "PT_PHDR"); set_integer(ELF_PT_TLS, module_object, "PT_TLS"); set_integer(ELF_PT_GNU_EH_FRAME, module_object, "PT_GNU_EH_FRAME"); set_integer(ELF_PT_GNU_STACK, module_object, "PT_GNU_STACK"); set_integer(ELF_PF_X, module_object, "PF_X"); set_integer(ELF_PF_W, module_object, "PF_W"); set_integer(ELF_PF_R, module_object, "PF_R"); foreach_memory_block(context, block) { switch(get_elf_type(block->data, block->size)) { case ELF_CLASS_32: if (block->size > sizeof(elf32_header_t)) { elf_header32 = (elf32_header_t*) block->data; if (!(context->flags & SCAN_FLAGS_PROCESS_MEMORY) || elf_header32->type == ELF_ET_EXEC) { parse_elf_header_32( elf_header32, block->base, block->size, context->flags, module_object); } } break; case ELF_CLASS_64: if (block->size > sizeof(elf64_header_t)) { elf_header64 = (elf64_header_t*) block->data; if (!(context->flags & SCAN_FLAGS_PROCESS_MEMORY) || elf_header64->type == ELF_ET_EXEC) { parse_elf_header_64( elf_header64, block->base, block->size, context->flags, module_object); } } break; } } return ERROR_SUCCESS; }