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;
}
