VALUE read_dict(unsigned char **pData, VALUE forceToEncoding) {
int type = read_1(pData);
if(!(type == ERL_LIST || type == ERL_NIL)) {
rb_raise(rb_eStandardError, "Invalid dict spec, not an erlang list");
}
unsigned int length = 0;
if(type == ERL_LIST) {
length = read_4(pData);
}
VALUE cHash = rb_const_get(rb_cObject, rb_intern("Hash"));
VALUE hash = rb_funcall(cHash, rb_intern("new"), 0);
int i;
for(i = 0; i < length; ++i) {
VALUE pair = read_dict_pair(pData, forceToEncoding);
VALUE first = rb_ary_entry(pair, 0);
VALUE last = rb_ary_entry(pair, 1);
rb_funcall(hash, rb_intern("store"), 2, first, last);
}
if(type == ERL_LIST) {
read_1(pData);
}
return hash;
}
VALUE read_large_bignum(unsigned char **pData) {
if(read_1(pData) != ERL_LARGE_BIGNUM) {
rb_raise(rb_eStandardError, "Invalid Type, not a small bignum");
}
unsigned int size = read_4(pData);
unsigned int sign = read_1(pData);
VALUE num = INT2NUM(0);
VALUE tmp;
unsigned char buf[size + 1];
read_string_raw(buf, pData, size);
int i;
for(i = 0; i < size; ++i) {
tmp = INT2FIX(*(buf + i));
tmp = rb_funcall(tmp, rb_intern("<<"), 1, INT2NUM(i * 8));
num = rb_funcall(num, rb_intern("+"), 1, tmp);
}
if(sign) {
num = rb_funcall(num, rb_intern("*"), 1, INT2NUM(-1));
}
return num;
}
VALUE read_small_tuple(unsigned char **pData, VALUE forceToEncoding) {
if(read_1(pData) != ERL_SMALL_TUPLE) {
rb_raise(rb_eStandardError, "Invalid Type, not a small tuple");
}
int arity = read_1(pData);
return read_tuple(pData, arity, forceToEncoding);
}
VALUE read_small_int(unsigned char **pData) {
if(read_1(pData) != ERL_SMALL_INT) {
rb_raise(rb_eStandardError, "Invalid Type, not a small int");
}
int value = read_1(pData);
return INT2FIX(value);
}
VALUE read_dict_pair(unsigned char **pData, VALUE forceToEncoding) {
if(read_1(pData) != ERL_SMALL_TUPLE) {
rb_raise(rb_eStandardError, "Invalid dict pair, not a small tuple");
}
int arity = read_1(pData);
if(arity != 2) {
rb_raise(rb_eStandardError, "Invalid dict pair, not a 2-tuple");
}
return read_tuple(pData, arity, forceToEncoding);
}
VALUE read_pid(unsigned char **pData) {
if(read_1(pData) != ERL_PID) {
rb_raise(rb_eStandardError, "Invalid Type, not a pid");
}
VALUE node = read_atom(pData);
VALUE id = INT2NUM(read_4(pData));
VALUE serial = INT2NUM(read_4(pData));
VALUE creation = INT2FIX(read_1(pData));
VALUE pid_class = rb_const_get(mErlectricity, rb_intern("Pid"));
return rb_funcall(pid_class, rb_intern("new"), 4, node, id, serial, creation);
}
VALUE read_nil(unsigned char **pData) {
if(read_1(pData) != ERL_NIL) {
rb_raise(rb_eStandardError, "Invalid Type, not a nil list");
}
return rb_ary_new2(0);
}
VALUE read_small_tuple(unsigned char **pData) {
if(read_1(pData) != ERL_SMALL_TUPLE) {
rb_raise(rb_eStandardError, "Invalid Type, not a small tuple");
}
int arity = read_1(pData);
VALUE array = rb_ary_new2(arity);
int i;
for(i = 0; i < arity; ++i) {
rb_ary_store(array, i, read_any_raw(pData));
}
return array;
}
VALUE read_large_tuple(unsigned char **pData, VALUE forceToEncoding) {
if(read_1(pData) != ERL_LARGE_TUPLE) {
rb_raise(rb_eStandardError, "Invalid Type, not a large tuple");
}
unsigned int arity = read_4(pData);
return read_tuple(pData, arity, forceToEncoding);
}
VALUE read_nil(unsigned char **pData) {
if(read_1(pData) != ERL_NIL) {
rb_raise(rb_eStandardError, "Invalid Type, not a nil list");
}
VALUE newref_class = rb_const_get(mErlectricity, rb_intern("List"));
return rb_funcall(newref_class, rb_intern("new"), 0);
}
VALUE read_list(unsigned char **pData) {
if(read_1(pData) != ERL_LIST) {
rb_raise(rb_eStandardError, "Invalid Type, not an erlang list");
}
int size = read_4(pData);
VALUE array = rb_ary_new2(size);
int i;
for(i = 0; i < size; ++i) {
rb_ary_store(array, i, read_any_raw(pData));
}
read_1(pData);
return array;
}
VALUE read_new_reference(unsigned char **pData) {
if(read_1(pData) != ERL_NEW_REF) {
rb_raise(rb_eStandardError, "Invalid Type, not a new-style reference");
}
int size = read_2(pData);
VALUE node = read_atom(pData);
VALUE creation = INT2FIX(read_1(pData));
VALUE id = rb_ary_new2(size);
int i;
for(i = 0; i < size; ++i) {
rb_ary_store(id, i, INT2NUM(read_4(pData)));
}
VALUE newref_class = rb_const_get(mErlectricity, rb_intern("NewReference"));
return rb_funcall(newref_class, rb_intern("new"), 3, node, creation, id);
}
VALUE read_list(unsigned char **pData) {
if(read_1(pData) != ERL_LIST) {
rb_raise(rb_eStandardError, "Invalid Type, not an erlang list");
}
unsigned int size = read_4(pData);
VALUE newref_class = rb_const_get(mErlectricity, rb_intern("List"));
VALUE array = rb_funcall(newref_class, rb_intern("new"), 1, INT2NUM(size));
int i;
for(i = 0; i < size; ++i) {
rb_ary_store(array, i, read_any_raw(pData));
}
read_1(pData);
return array;
}
VALUE method_read_any_from(VALUE klass, VALUE rString) {
unsigned char *data = (unsigned char *) StringValuePtr(rString);
unsigned char **pData = &data;
// check protocol version
if(read_1(pData) != ERL_VERSION) {
rb_raise(rb_eStandardError, "Bad Magic");
}
return read_any_raw(pData);
}
VALUE read_atom(unsigned char **pData) {
if(read_1(pData) != ERL_ATOM) {
rb_raise(rb_eStandardError, "Invalid Type, not an atom");
}
int length = read_2(pData);
unsigned char buf[length + 1];
read_string_raw(buf, pData, length);
return ID2SYM(rb_intern((char *) buf));
}
VALUE read_float(unsigned char **pData) {
if(read_1(pData) != ERL_FLOAT) {
rb_raise(rb_eStandardError, "Invalid Type, not a float");
}
unsigned char buf[32];
read_string_raw(buf, pData, 31);
VALUE rString = rb_str_new2((char *) buf);
return rb_funcall(rString, rb_intern("to_f"), 0);
}
VALUE read_bin(unsigned char **pData) {
if(read_1(pData) != ERL_BIN) {
rb_raise(rb_eStandardError, "Invalid Type, not an erlang binary");
}
int length = read_4(pData);
unsigned char buf[length + 1];
read_string_raw(buf, pData, length);
return rb_str_new2((char *) buf);
}
VALUE read_bin(unsigned char **pData) {
if(read_1(pData) != ERL_BIN) {
rb_raise(rb_eStandardError, "Invalid Type, not an erlang binary");
}
unsigned int length = read_4(pData);
VALUE rStr = rb_str_new((char *) *pData, length);
*pData += length;
return rStr;
}
VALUE read_int(unsigned char **pData) {
if(read_1(pData) != ERL_INT) {
rb_raise(rb_eStandardError, "Invalid Type, not an int");
}
long long value = read_4(pData);
long long negative = ((value >> 31) & 0x1 == 1);
if(negative) {
value = (value - ((long long) 1 << 32));
}
return INT2FIX(value);
}
VALUE read_string(unsigned char **pData, VALUE forceToEncoding) {
if(read_1(pData) != ERL_STRING) {
rb_raise(rb_eStandardError, "Invalid Type, not an erlang string");
}
int length = read_2(pData);
VALUE array = rb_ary_new2(length);
int i = 0;
for(i; i < length; ++i) {
rb_ary_store(array, i, INT2NUM(**pData));
*pData += 1;
}
return force_encoding(array, forceToEncoding);
}
VALUE method_decode(int argc, VALUE *argv, VALUE self) {
VALUE rString = Qnil;
VALUE forceToEncoding = Qnil;
rb_scan_args(argc, argv, "11", &rString, &forceToEncoding);
unsigned char *data = (unsigned char *) StringValuePtr(rString);
unsigned char **pData = &data;
// check protocol version
if(read_1(pData) != ERL_VERSION) {
rb_raise(rb_eStandardError, "Bad Magic");
}
return read_any_raw(pData, forceToEncoding);
}
VALUE read_string(unsigned char **pData) {
if(read_1(pData) != ERL_STRING) {
rb_raise(rb_eStandardError, "Invalid Type, not an erlang string");
}
int length = read_2(pData);
VALUE newref_class = rb_const_get(mErlectricity, rb_intern("List"));
VALUE array = rb_funcall(newref_class, rb_intern("new"), 1, INT2NUM(length));
int i = 0;
for(i; i < length; ++i) {
rb_ary_store(array, i, INT2NUM(**pData));
*pData += 1;
}
return array;
}
VALUE read_string(unsigned char **pData) {
if(read_1(pData) != ERL_STRING) {
rb_raise(rb_eStandardError, "Invalid Type, not an erlang string");
}
int length = read_2(pData);
unsigned char buf[length + 1];
read_string_raw(buf, pData, length);
VALUE array = rb_ary_new2(length);
int i = 0;
for(i; i < length; ++i) {
rb_ary_store(array, i, INT2NUM(*(buf + i)));
}
return array;
}
VALUE read_atom(unsigned char **pData) {
if(read_1(pData) != ERL_ATOM) {
rb_raise(rb_eStandardError, "Invalid Type, not an atom");
}
int length = read_2(pData);
unsigned char buf[length + 1];
read_string_raw(buf, pData, length);
// Erlang true and false are actually atoms
if(length == 4 && strncmp((char *) buf, "true", length) == 0) {
return Qtrue;
} else if(length == 5 && strncmp((char *) buf, "false", length) == 0) {
return Qfalse;
} else {
return ID2SYM(rb_intern((char *) buf));
}
}
handle rget( CLIENT *client,char *remote_file_name,char *local_file_name){
openargs open_args;
open_args.file=remote_file_name;
open_args.mode=O_RDONLY;
handle *result;
result = open_1(&open_args,client);
readargs read_args;
read_args.h = *result;
read_args.nbytes=MAXBUF;
readresults *read_results;
read_results = read_1(&read_args, client);
if(read_results->status==0){
FILE *file;
file = fopen(local_file_name,"w+");
fwrite((read_results -> readresults_u.buf.buf_val),(read_results -> readresults_u.buf.buf_len),1,file);
printf("Success");
}else{
printf("Failure");
exit(1);
}
close_1(result,client);
return(*result);
}
static gboolean
handle_dwarf2_section (DebuginfoData *data, GHashTable *files, GError **error)
{
Elf_Data *e_data;
int i;
debug_section_t *debug_sections;
ptr_size = 0;
if (data->ehdr.e_ident[EI_DATA] == ELFDATA2LSB)
{
do_read_16 = buf_read_ule16;
do_read_32 = buf_read_ule32;
}
else if (data->ehdr.e_ident[EI_DATA] == ELFDATA2MSB)
{
do_read_16 = buf_read_ube16;
do_read_32 = buf_read_ube32;
}
else
{
return flatpak_fail (error, "%s: Wrong ELF data encoding", data->filename);
}
debug_sections = data->debug_sections;
if (debug_sections[DEBUG_INFO].data != NULL)
{
unsigned char *ptr, *endcu, *endsec;
uint32_t value;
struct abbrev_tag *t;
g_autofree REL *relbuf = NULL;
if (debug_sections[DEBUG_INFO].relsec)
{
Elf_Scn *scn;
int ndx, maxndx;
GElf_Rel rel;
GElf_Rela rela;
GElf_Sym sym;
GElf_Addr base = data->shdr[debug_sections[DEBUG_INFO].sec].sh_addr;
Elf_Data *symdata = NULL;
int rtype;
i = debug_sections[DEBUG_INFO].relsec;
scn = data->scns[i];
e_data = elf_getdata (scn, NULL);
g_assert (e_data != NULL && e_data->d_buf != NULL);
g_assert (elf_getdata (scn, e_data) == NULL);
g_assert (e_data->d_off == 0);
g_assert (e_data->d_size == data->shdr[i].sh_size);
maxndx = data->shdr[i].sh_size / data->shdr[i].sh_entsize;
relbuf = g_malloc (maxndx * sizeof (REL));
reltype = data->shdr[i].sh_type;
symdata = elf_getdata (data->scns[data->shdr[i].sh_link], NULL);
g_assert (symdata != NULL && symdata->d_buf != NULL);
g_assert (elf_getdata (data->scns[data->shdr[i].sh_link], symdata) == NULL);
g_assert (symdata->d_off == 0);
g_assert (symdata->d_size == data->shdr[data->shdr[i].sh_link].sh_size);
for (ndx = 0, relend = relbuf; ndx < maxndx; ++ndx)
{
if (data->shdr[i].sh_type == SHT_REL)
{
gelf_getrel (e_data, ndx, &rel);
rela.r_offset = rel.r_offset;
rela.r_info = rel.r_info;
rela.r_addend = 0;
}
else
{
gelf_getrela (e_data, ndx, &rela);
}
gelf_getsym (symdata, ELF64_R_SYM (rela.r_info), &sym);
/* Relocations against section symbols are uninteresting
in REL. */
if (data->shdr[i].sh_type == SHT_REL && sym.st_value == 0)
continue;
/* Only consider relocations against .debug_str, .debug_line
and .debug_abbrev. */
if (sym.st_shndx != debug_sections[DEBUG_STR].sec &&
sym.st_shndx != debug_sections[DEBUG_LINE].sec &&
sym.st_shndx != debug_sections[DEBUG_ABBREV].sec)
continue;
rela.r_addend += sym.st_value;
rtype = ELF64_R_TYPE (rela.r_info);
switch (data->ehdr.e_machine)
{
case EM_SPARC:
case EM_SPARC32PLUS:
case EM_SPARCV9:
if (rtype != R_SPARC_32 && rtype != R_SPARC_UA32)
goto fail;
break;
case EM_386:
if (rtype != R_386_32)
goto fail;
break;
case EM_PPC:
case EM_PPC64:
if (rtype != R_PPC_ADDR32 && rtype != R_PPC_UADDR32)
goto fail;
break;
case EM_S390:
if (rtype != R_390_32)
goto fail;
break;
case EM_IA_64:
if (rtype != R_IA64_SECREL32LSB)
goto fail;
break;
case EM_X86_64:
if (rtype != R_X86_64_32)
goto fail;
break;
case EM_ALPHA:
if (rtype != R_ALPHA_REFLONG)
goto fail;
break;
#if defined(EM_AARCH64) && defined(R_AARCH64_ABS32)
case EM_AARCH64:
if (rtype != R_AARCH64_ABS32)
goto fail;
break;
#endif
case EM_68K:
if (rtype != R_68K_32)
goto fail;
break;
default:
fail:
return flatpak_fail (error, "%s: Unhandled relocation %d in .debug_info section",
data->filename, rtype);
}
relend->ptr = debug_sections[DEBUG_INFO].data
+ (rela.r_offset - base);
relend->addend = rela.r_addend;
++relend;
}
if (relbuf == relend)
{
g_free (relbuf);
relbuf = NULL;
relend = NULL;
}
else
{
qsort (relbuf, relend - relbuf, sizeof (REL), rel_cmp);
}
}
ptr = debug_sections[DEBUG_INFO].data;
relptr = relbuf;
endsec = ptr + debug_sections[DEBUG_INFO].size;
while (ptr != NULL && ptr < endsec)
{
g_autoptr(GHashTable) abbrev = NULL;
if (ptr + 11 > endsec)
return flatpak_fail (error, "%s: .debug_info CU header too small", data->filename);
endcu = ptr + 4;
endcu += read_32 (ptr);
if (endcu == ptr + 0xffffffff)
return flatpak_fail (error, "%s: 64-bit DWARF not supported", data->filename);
if (endcu > endsec)
return flatpak_fail (error, "%s: .debug_info too small", data->filename);
cu_version = read_16 (ptr);
if (cu_version != 2 && cu_version != 3 && cu_version != 4)
return flatpak_fail (error, "%s: DWARF version %d unhandled", data->filename, cu_version);
value = read_32_relocated (ptr);
if (value >= debug_sections[DEBUG_ABBREV].size)
{
if (debug_sections[DEBUG_ABBREV].data == NULL)
return flatpak_fail (error, "%s: .debug_abbrev not present", data->filename);
else
return flatpak_fail (error, "%s: DWARF CU abbrev offset too large", data->filename);
}
if (ptr_size == 0)
{
ptr_size = read_1 (ptr);
if (ptr_size != 4 && ptr_size != 8)
return flatpak_fail (error, "%s: Invalid DWARF pointer size %d", data->filename, ptr_size);
}
else if (read_1 (ptr) != ptr_size)
{
return flatpak_fail (error, "%s: DWARF pointer size differs between CUs", data->filename);
}
abbrev = read_abbrev (data,
debug_sections[DEBUG_ABBREV].data + value);
while (ptr < endcu)
{
guint entry = read_uleb128 (ptr);
if (entry == 0)
continue;
t = g_hash_table_lookup (abbrev, GINT_TO_POINTER (entry));
if (t == NULL)
{
g_warning ("%s: Could not find DWARF abbreviation %d", data->filename, entry);
}
else
{
ptr = handle_attributes (data, ptr, t, files, error);
if (ptr == NULL)
return FALSE;
}
}
}
}
return TRUE;
}
