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