int
sync_cb(struct ccns_handle *h,
struct ccn_charbuf *lhash,
struct ccn_charbuf *rhash,
struct ccn_charbuf *name)
{
char *hexL;
char *hexR;
struct ccn_charbuf *uri = ccn_charbuf_create();
ccn_uri_append(uri, name->buf, name->length, 1);
if (lhash == NULL || lhash->length == 0) {
hexL = strdup("none");
} else
hexL = hex_string(lhash->buf, lhash->length);
if (rhash == NULL || rhash->length == 0) {
hexR = strdup("none");
} else
hexR = hex_string(rhash->buf, rhash->length);
printf("%s %s %s\n", ccn_charbuf_as_string(uri), hexL, hexR);
fflush(stdout);
free(hexL);
free(hexR);
ccn_charbuf_destroy(&uri);
return(0);
}
//------------------------------------------------------------------------------
// Name: dump_lines(edb::address_t address, int lines)
// Desc:
//------------------------------------------------------------------------------
void DumpState::dump_lines(edb::address_t address, int lines) {
for(int i = 0; i < lines; ++i) {
quint8 buf[16];
if(edb::v1::debugger_core->read_bytes(address, buf, sizeof(buf))) {
std::cout << hex_string(address) << " : ";
for(int j = 0x00; j < 0x04; ++j) std::cout << hex_string(buf[j]) << " ";
std::cout << " ";
for(int j = 0x04; j < 0x08; ++j) std::cout << hex_string(buf[j]) << " ";
std::cout << "- ";
for(int j = 0x08; j < 0x0c; ++j) std::cout << hex_string(buf[j]) << " ";
std::cout << " ";
for(int j = 0x0c; j < 0x10; ++j) std::cout << hex_string(buf[j]) << " ";
for(int j = 0; j < 16; ++j) {
const quint8 ch = buf[j];
std::cout << (
(
std::isprint(ch) ||
(std::isspace(ch) && (ch != '\f' && ch != '\t' && ch != '\r' && ch != '\n') && ch < 0x80)
) ? static_cast<char>(ch) : '.');
}
std::cout << "\n";
} else {
break;
}
address += 16;
}
}
static int
gdbscm_memory_port_print (SCM exp, SCM port, scm_print_state *pstate)
{
ioscm_memory_port *iomem = (ioscm_memory_port *) SCM_STREAM (exp);
char *type = SCM_PTOBNAME (SCM_PTOBNUM (exp));
scm_puts ("#<", port);
scm_print_port_mode (exp, port);
/* scm_print_port_mode includes a trailing space. */
gdbscm_printf (port, "%s %s-%s", type,
hex_string (iomem->start), hex_string (iomem->end));
scm_putc ('>', port);
return 1;
}
int HostProxy_GadgetFS::reconnect() {
int status;
if (p_is_connected) {fprintf(stderr,"GadgetFS already connected.\n"); return 0;}
if (!descriptor) {return 1;}
if (debugLevel>0) {
char* hex=hex_string((void*)descriptor,descriptorLength);
fprintf(stderr,"%s\n",hex);
free(hex);
}
device_filename = find_gadget_filename();
p_device_file = open_gadget(device_filename);
if (p_device_file < 0) {
fprintf(stderr,"Fail on open %d %s\n",errno,strerror(errno));
return 1;
}
status = write(p_device_file, descriptor, descriptorLength);
if (status < 0) {
fprintf(stderr,"Fail on write %d %s\n",errno,strerror(errno));
close(p_device_file);
p_device_file=0;
return 1;
}
p_is_connected = true;
return 0;
}
//------------------------------------------------------------------------------
// Name: dump_code(const State &state)
// Desc:
//------------------------------------------------------------------------------
void DumpState::dump_code(const State &state) {
QSettings settings;
const int instructions_to_print = settings.value("DumpState/instructions_after_ip", 6).toInt();
const edb::address_t ip = state.instruction_pointer();
edb::address_t address = ip;
for(int i = 0; i < instructions_to_print + 1; ++i) {
quint8 buf[edb::Instruction::MAX_SIZE];
int size = sizeof(buf);
if(edb::v1::get_instruction_bytes(address, buf, size)) {
edb::Instruction insn(buf, size, address, std::nothrow);
if(insn.valid()) {
std::cout << ((address == ip) ? "> " : " ") << hex_string(address) << ": " << edisassm::to_string(insn) << "\n";
} else {
break;
}
address += insn.size();
} else {
break;
}
}
}
static const char *
get_function_name (CORE_ADDR funaddr, char *buf, int buf_size)
{
{
struct symbol *symbol = find_pc_function (funaddr);
if (symbol)
return SYMBOL_PRINT_NAME (symbol);
}
{
/* Try the minimal symbols. */
struct bound_minimal_symbol msymbol = lookup_minimal_symbol_by_pc (funaddr);
if (msymbol.minsym)
return MSYMBOL_PRINT_NAME (msymbol.minsym);
}
{
char *tmp = xstrprintf (_(RAW_FUNCTION_ADDRESS_FORMAT),
hex_string (funaddr));
gdb_assert (strlen (tmp) + 1 <= buf_size);
strcpy (buf, tmp);
xfree (tmp);
return buf;
}
}
std::basic_ostream<charT, traits> &
operator << ( std::basic_ostream<charT, traits> & s, const mapnik::color & c )
{
std::string hex_string( c.to_string() );
s << hex_string;
return s;
}
void
mi_cmd_var_create (char *command, char **argv, int argc)
{
struct ui_out *uiout = current_uiout;
CORE_ADDR frameaddr = 0;
struct varobj *var;
char *name;
char *frame;
char *expr;
struct cleanup *old_cleanups;
enum varobj_type var_type;
if (argc != 3)
error (_("-var-create: Usage: NAME FRAME EXPRESSION."));
name = xstrdup (argv[0]);
/* Add cleanup for name. Must be free_current_contents as name can
be reallocated. */
old_cleanups = make_cleanup (free_current_contents, &name);
frame = xstrdup (argv[1]);
make_cleanup (xfree, frame);
expr = xstrdup (argv[2]);
make_cleanup (xfree, expr);
if (strcmp (name, "-") == 0)
{
xfree (name);
name = varobj_gen_name ();
}
else if (!isalpha (*name))
error (_("-var-create: name of object must begin with a letter"));
if (strcmp (frame, "*") == 0)
var_type = USE_CURRENT_FRAME;
else if (strcmp (frame, "@") == 0)
var_type = USE_SELECTED_FRAME;
else
{
var_type = USE_SPECIFIED_FRAME;
frameaddr = string_to_core_addr (frame);
}
if (varobjdebug)
fprintf_unfiltered (gdb_stdlog,
"Name=\"%s\", Frame=\"%s\" (%s), Expression=\"%s\"\n",
name, frame, hex_string (frameaddr), expr);
var = varobj_create (name, expr, frameaddr, var_type);
if (var == NULL)
error (_("-var-create: unable to create variable object"));
print_varobj (var, PRINT_ALL_VALUES, 0 /* don't print expression */);
ui_out_field_int (uiout, "has_more", varobj_has_more (var, 0));
do_cleanups (old_cleanups);
}
static void _uid64(Request& r, MethodParams& /*params*/) {
unsigned char id[64/8];
random(&id, sizeof(id));
r.write_pass_lang(*new String(hex_string(id, sizeof(id), true)));
}
//------------------------------------------------------------------------------
// Name: show_menu()
// Desc:
//------------------------------------------------------------------------------
void DumpState::show_menu() {
State state;
edb::v1::debugger_core->get_state(state);
std::cout << "------------------------------------------------------------------------------\n";
dump_registers(state);
std::cout << "[" << hex_string<quint16>(*state["ss"]) << ":" << hex_string(state.stack_pointer()) << "]---------------------------------------------------------[stack]\n";
dump_stack(state);
const edb::address_t data_address = edb::v1::current_data_view_address();
std::cout << "[" << hex_string<quint16>(*state["ds"]) << ":" << hex_string(data_address) << "]---------------------------------------------------------[ data]\n";
dump_data(data_address);
std::cout << "[" << hex_string<quint16>(*state["cs"]) << ":" << hex_string(state.instruction_pointer()) << "]---------------------------------------------------------[ code]\n";
dump_code(state);
std::cout << "------------------------------------------------------------------------------\n";
}
void DeviceQualifier::print(__u8 tabs) {
int i;
char* hex=hex_string(&descriptor,sizeof(descriptor));
printf("%.*sHS Qualifier: %s\n",tabs,TABPADDING,hex);
free(hex);
for(i=0;i<descriptor.bNumConfigurations;i++) {
if (configurations[i]) {configurations[i]->print(tabs+1,(configurations[i]==device->get_active_configuration())?true:false);}
}
}
//return -1 to stall
int DeviceProxy_Loopback::control_request(const usb_ctrlrequest* setup_packet, int* nbytes, __u8* dataptr, int timeout) {
if (debugLevel>1) {
char* hex=hex_string((void*)setup_packet,sizeof(*setup_packet));
fprintf(stderr, "Loopback< %s\n",hex);
free(hex);
}
if((setup_packet->bRequestType & USB_DIR_IN) && setup_packet->bRequest == USB_REQ_GET_DESCRIPTOR) {
__u8* buf;
__u8* p;
__u8 idx;
const usb_string_descriptor* string_desc;
switch ((setup_packet->wValue)>>8) {
case USB_DT_DEVICE:
memcpy(dataptr, &loopback_device_descriptor, loopback_device_descriptor.bLength);
*nbytes = loopback_device_descriptor.bLength;
break;
case USB_DT_CONFIG:
idx=setup_packet->wValue & 0xff;
if (idx>=loopback_device_descriptor.bNumConfigurations) return -1;
buf=(__u8*)malloc(loopback_config_descriptor.wTotalLength);
p=buf;
memcpy(p, &loopback_config_descriptor, loopback_config_descriptor.bLength);
p+=loopback_config_descriptor.bLength;
memcpy(p, &loopback_interface_descriptor, loopback_interface_descriptor.bLength);
p+=loopback_interface_descriptor.bLength;
memcpy(p, &loopback_eps[0], loopback_eps[0].bLength);
p+=loopback_eps[0].bLength;
memcpy(p, &loopback_eps[1], loopback_eps[1].bLength);
*nbytes = loopback_config_descriptor.wTotalLength>setup_packet->wLength?setup_packet->wLength:loopback_config_descriptor.wTotalLength;
memcpy(dataptr, buf, *nbytes);
free(buf);
break;
case USB_DT_STRING:
idx=setup_packet->wValue & 0xff;
if (idx>0 && setup_packet->wIndex!=0x409) return -1;
if (idx>loopback_stringMaxIndex) return -1;
string_desc=loopback_strings[idx]->get_descriptor();
*nbytes=string_desc->bLength>setup_packet->wLength?setup_packet->wLength:string_desc->bLength;
memcpy(dataptr,string_desc,*nbytes);
/*
if (true) {
char* hex=hex_string(dataptr, *nbytes);
fprintf(stderr, "Loopback> %s\n",hex);
free(hex);
}
exit(0);
*/
break;
case USB_DT_DEVICE_QUALIFIER:
return -1;
break;
case USB_DT_OTHER_SPEED_CONFIG:
return -1;
break;
}
} else if ((setup_packet->bRequestType & USB_DIR_IN) && setup_packet->bRequest == USB_REQ_GET_CONFIGURATION){
void stratum_client::handle_job_succeeded(const std::string& job_id,
uint32_t nonce, const binary& hash)
{
std::cout << "job [" << job_id << "] succeeded, " <<
nonce << std::endl;
{
std::ostringstream oss;
oss << "{\"method\": \"submit\", \"params\": "
"{\"id\": \"" << rpc_id_ << "\", \"job_id\": \"" << job_id <<
"\", \"nonce\": \"" << std::string(hex_string(nonce)) <<
"\", \"result\": \"" << std::string(hex_string(hash)) <<
"\"}, \"id\":1}\n";
std::ostream request_stream(&request_);
request_stream << oss.str();
}
boost::asio::async_write(socket_, request_,
boost::bind(&stratum_client::handle_write_completed, this,
boost::asio::placeholders::error));
}
static void _md5(Request& r, MethodParams& params) {
const char *string=params.as_string(0, PARAMETER_MUST_BE_STRING).cstr_to_string_body_untaint(String::L_AS_IS, r.connection(false), &r.charsets).cstr();
PA_MD5_CTX context;
unsigned char digest[16];
pa_MD5Init(&context);
pa_MD5Update(&context, (const unsigned char*)string, strlen(string));
pa_MD5Final(digest, &context);
r.write_pass_lang(*new String(hex_string(digest, sizeof(digest), false)));
}
/// Return the first specified number of hex digits of a given value.
std::string hex_string(const std::string& preceding,
const long double value,
const long digits) {
if (digits == 0L) {
return preceding;
}
const long double magnitude(std::abs(value));
const long double front(16.0L * (magnitude - std::floor(magnitude)));
const std::string accumulated(preceding + hex_digit(front));
return hex_string(accumulated, front, digits - 1L);
}
static void _sha1(Request& r, MethodParams& params) {
const char *string = params.as_string(0, PARAMETER_MUST_BE_STRING).cstr_to_string_body_untaint(String::L_AS_IS, r.connection(false), &r.charsets).cstr();
SHA1Context c;
unsigned char digest[20];
SHA1Reset (&c);
SHA1Input (&c, (const unsigned char*)string, strlen(string));
SHA1ReadDigest(digest, &c);
r.write_pass_lang(*new String(hex_string(digest, sizeof(digest), false)));
}
/* Appends OpenCL programs to the list of `struct so_list' objects. */
static void
append_ocl_sos (struct so_list **link_ptr)
{
CORE_ADDR *ocl_program_addr_base;
struct objfile *objfile;
ALL_OBJFILES (objfile)
{
ocl_program_addr_base
= (CORE_ADDR *) objfile_data (objfile, ocl_program_data_key);
if (ocl_program_addr_base != NULL)
{
enum bfd_endian byte_order = bfd_big_endian (objfile->obfd)?
BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
TRY
{
CORE_ADDR data =
read_memory_unsigned_integer (*ocl_program_addr_base,
sizeof (CORE_ADDR),
byte_order);
if (data != 0x0)
{
struct so_list *newobj;
/* Allocate so_list structure. */
newobj = XCNEW (struct so_list);
/* Encode FD and object ID in path name. */
xsnprintf (newobj->so_name, sizeof newobj->so_name, "@%s <%d>",
hex_string (data),
SPUADDR_SPU (*ocl_program_addr_base));
strcpy (newobj->so_original_name, newobj->so_name);
*link_ptr = newobj;
link_ptr = &newobj->next;
}
}
CATCH (ex, RETURN_MASK_ALL)
{
/* Ignore memory errors. */
switch (ex.error)
{
case MEMORY_ERROR:
break;
default:
throw_exception (ex);
break;
}
}
END_CATCH
}
}
}
static int
rs6000_ptrace64 (int req, int id, long long addr, int data, void *buf)
{
#ifdef ARCH3264
int ret = ptracex (req, id, addr, data, buf);
#else
int ret = 0;
#endif
#if 0
printf ("rs6000_ptrace64 (%d, %d, %s, %08x, 0x%x) = 0x%x\n",
req, id, hex_string (addr), data, (unsigned int)buf, ret);
#endif
return ret;
}
static int
lsscm_print_lazy_string_smob (SCM self, SCM port, scm_print_state *pstate)
{
lazy_string_smob *ls_smob = (lazy_string_smob *) SCM_SMOB_DATA (self);
gdbscm_printf (port, "#<%s", lazy_string_smob_name);
gdbscm_printf (port, " @%s", hex_string (ls_smob->address));
if (ls_smob->length >= 0)
gdbscm_printf (port, " length %d", ls_smob->length);
if (ls_smob->encoding != NULL)
gdbscm_printf (port, " encoding %s", ls_smob->encoding);
scm_puts (">", port);
scm_remember_upto_here_1 (self);
/* Non-zero means success. */
return 1;
}
static CORE_ADDR
find_toc_address (CORE_ADDR pc)
{
struct vmap *vp;
extern CORE_ADDR get_toc_offset (struct objfile *); /* xcoffread.c */
for (vp = vmap; vp; vp = vp->nxt)
{
if (pc >= vp->tstart && pc < vp->tend)
{
/* vp->objfile is only NULL for the exec file. */
return vp->dstart + get_toc_offset (vp->objfile == NULL
? symfile_objfile
: vp->objfile);
}
}
error ("Unable to find TOC entry for pc %s\n", hex_string (pc));
}
static void
mi_memory_changed (struct inferior *inferior, CORE_ADDR memaddr,
ssize_t len, const bfd_byte *myaddr)
{
struct mi_interp *mi = top_level_interpreter_data ();
struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
struct obj_section *sec;
if (mi_suppress_notification.memory)
return;
target_terminal_ours ();
fprintf_unfiltered (mi->event_channel,
"memory-changed");
ui_out_redirect (mi_uiout, mi->event_channel);
ui_out_field_fmt (mi_uiout, "thread-group", "i%d", inferior->num);
ui_out_field_core_addr (mi_uiout, "addr", target_gdbarch (), memaddr);
ui_out_field_fmt (mi_uiout, "len", "%s", hex_string (len));
/* Append 'type=code' into notification if MEMADDR falls in the range of
sections contain code. */
sec = find_pc_section (memaddr);
if (sec != NULL && sec->objfile != NULL)
{
flagword flags = bfd_get_section_flags (sec->objfile->obfd,
sec->the_bfd_section);
if (flags & SEC_CODE)
ui_out_field_string (mi_uiout, "type", "code");
}
ui_out_redirect (mi_uiout, NULL);
gdb_flush (mi->event_channel);
}
static void __init
test_pointer(void)
{
plain();
null_pointer();
invalid_pointer();
symbol_ptr();
kernel_ptr();
struct_resource();
addr();
escaped_str();
hex_string();
mac();
ip();
uuid();
dentry();
struct_va_format();
struct_rtc_time();
struct_clk();
bitmap();
netdev_features();
flags();
}
//------------------------------------------------------------------------------
// Name: dump_registers(const State &state)
// Desc:
//------------------------------------------------------------------------------
void DumpState::dump_registers(const State &state) {
#if defined(EDB_X86)
std::cout << " eax:" << hex_string(*state["eax"]);
std::cout << " ebx:" << hex_string(*state["ebx"]);
std::cout << " ecx:" << hex_string(*state["ecx"]);
std::cout << " edx:" << hex_string(*state["edx"]);
std::cout << " eflags:" << hex_string(*state["eflags"]);
std::cout << "\n";
std::cout << " esi:" << hex_string(*state["esi"]);
std::cout << " edi:" << hex_string(*state["edi"]);
std::cout << " esp:" << hex_string(*state["esp"]);
std::cout << " ebp:" << hex_string(*state["ebp"]);
std::cout << " eip:" << hex_string(state.instruction_pointer());
std::cout << "\n";
std::cout << " cs:" << hex_string<quint16>(*state["cs"]);
std::cout << " ds:" << hex_string<quint16>(*state["ds"]);
std::cout << " es:" << hex_string<quint16>(*state["es"]);
std::cout << " fs:" << hex_string<quint16>(*state["fs"]);
std::cout << " gs:" << hex_string<quint16>(*state["gs"]);
std::cout << " ss:" << hex_string<quint16>(*state["ss"]);
std::cout << " ";
std::cout << ((*state["eflags"] & (1 << 11)) != 0 ? 'O' : 'o') << ' ';
std::cout << ((*state["eflags"] & (1 << 10)) != 0 ? 'D' : 'd') << ' ';
std::cout << ((*state["eflags"] & (1 << 9)) != 0 ? 'I' : 'i') << ' ';
std::cout << ((*state["eflags"] & (1 << 8)) != 0 ? 'T' : 't') << ' ';
std::cout << ((*state["eflags"] & (1 << 7)) != 0 ? 'S' : 's') << ' ';
std::cout << ((*state["eflags"] & (1 << 6)) != 0 ? 'Z' : 'z') << ' ';
std::cout << ((*state["eflags"] & (1 << 4)) != 0 ? 'A' : 'a') << ' ';
std::cout << ((*state["eflags"] & (1 << 2)) != 0 ? 'P' : 'p') << ' ';
std::cout << ((*state["eflags"] & (1 << 0)) != 0 ? 'C' : 'c');
std::cout << "\n";
#elif defined(EDB_X86_64)
std::cout << " rax:" << hex_string(*state["rax"]);
std::cout << " rbx:" << hex_string(*state["rbx"]);
std::cout << " rcx:" << hex_string(*state["rcx"]);
std::cout << " rdx:" << hex_string(*state["rdx"]);
std::cout << " rflags:" << hex_string(*state["rflags"]);
std::cout << "\n";
std::cout << " rsi:" << hex_string(*state["rsi"]);
std::cout << " rdi:" << hex_string(*state["rdi"]);
std::cout << " rsp:" << hex_string(*state["rsp"]);
std::cout << " rbp:" << hex_string(*state["rbp"]);
std::cout << " rip:" << hex_string(state.instruction_pointer());
std::cout << "\n";
std::cout << " r8:" << hex_string(*state["r8"]);
std::cout << " r9:" << hex_string(*state["r9"]);
std::cout << " r10:" << hex_string(*state["r10"]);
std::cout << " r11:" << hex_string(*state["r11"]);
std::cout << " ";
std::cout << ((*state["rflags"] & (1 << 11)) != 0 ? 'O' : 'o') << ' ';
std::cout << ((*state["rflags"] & (1 << 10)) != 0 ? 'D' : 'd') << ' ';
std::cout << ((*state["rflags"] & (1 << 9)) != 0 ? 'I' : 'i') << ' ';
std::cout << ((*state["rflags"] & (1 << 8)) != 0 ? 'T' : 't') << ' ';
std::cout << ((*state["rflags"] & (1 << 7)) != 0 ? 'S' : 's') << ' ';
std::cout << ((*state["rflags"] & (1 << 6)) != 0 ? 'Z' : 'z') << ' ';
std::cout << ((*state["rflags"] & (1 << 4)) != 0 ? 'A' : 'a') << ' ';
std::cout << ((*state["rflags"] & (1 << 2)) != 0 ? 'P' : 'p') << ' ';
std::cout << ((*state["rflags"] & (1 << 0)) != 0 ? 'C' : 'c');
std::cout << "\n";
std::cout << " r12:" << hex_string(*state["r12"]);
std::cout << " r13:" << hex_string(*state["r13"]);
std::cout << " r14:" << hex_string(*state["r14"]);
std::cout << " r15:" << hex_string(*state["r15"]);
std::cout << "\n";
std::cout << " cs:" << hex_string<quint16>(*state["cs"]);
std::cout << " ds:" << hex_string<quint16>(*state["ds"]);
std::cout << " es:" << hex_string<quint16>(*state["es"]);
std::cout << " fs:" << hex_string<quint16>(*state["fs"]);
std::cout << "\n";
std::cout << " gs:" << hex_string<quint16>(*state["gs"]);
std::cout << " ss:" << hex_string<quint16>(*state["ss"]);
std::cout << "\n";
#endif
}
/* Build a list of `struct so_list' objects describing the shared
objects currently loaded in the inferior. */
static struct so_list *
spu_current_sos (void)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
struct so_list *head;
struct so_list **link_ptr;
gdb_byte buf[MAX_SPE_FD * 4];
int i, size;
/* First, retrieve the SVR4 shared library list. */
head = svr4_so_ops.current_sos ();
/* Append our libraries to the end of the list. */
for (link_ptr = &head; *link_ptr; link_ptr = &(*link_ptr)->next)
;
/* Determine list of SPU ids. */
size = target_read (¤t_target, TARGET_OBJECT_SPU, NULL,
buf, 0, sizeof buf);
/* Do not add stand-alone SPE executable context as shared library,
but relocate main SPE executable objfile. */
if (spu_standalone_p ())
{
if (size == 4)
{
int fd = extract_unsigned_integer (buf, 4, byte_order);
spu_relocate_main_executable (fd);
/* Re-enable breakpoints after main SPU context was established;
see also comments in spu_solib_create_inferior_hook. */
enable_breakpoints_after_startup ();
}
return head;
}
/* Create an so_list entry for each SPU id. */
for (i = 0; i < size; i += 4)
{
int fd = extract_unsigned_integer (buf + i, 4, byte_order);
struct so_list *newobj;
unsigned long long addr;
char annex[32], id[100];
int len;
/* Read object ID. There's a race window where the inferior may have
already created the SPE context, but not installed the object-id
yet. Skip such entries; we'll be back for them later. */
xsnprintf (annex, sizeof annex, "%d/object-id", fd);
len = target_read (¤t_target, TARGET_OBJECT_SPU, annex,
(gdb_byte *) id, 0, sizeof id);
if (len <= 0 || len >= sizeof id)
continue;
id[len] = 0;
if (sscanf (id, "0x%llx", &addr) != 1 || !addr)
continue;
/* Allocate so_list structure. */
newobj = XCNEW (struct so_list);
/* Encode FD and object ID in path name. Choose the name so as not
to conflict with any (normal) SVR4 library path name. */
xsnprintf (newobj->so_name, sizeof newobj->so_name, "@%s <%d>",
hex_string (addr), fd);
strcpy (newobj->so_original_name, newobj->so_name);
*link_ptr = newobj;
link_ptr = &newobj->next;
}
/* Append OpenCL sos. */
append_ocl_sos (link_ptr);
return head;
}
void HID::print(__u8 tabs) {
char* hex=hex_string((void*)descriptor,descriptor->bLength);
printf("%.*sHID: %s\n",tabs,TABPADDING,hex);
free(hex);
}
static void test_invalids()
{
struct invalid_instructions invalids[] = {{
CS_ARCH_ARM,
CS_MODE_THUMB,
"Thumb",
1,
{{
(unsigned char *)"\xbd\xe8\x1e\xff",
4,
"invalid thumb2 pop because sp used and because both pc and lr are "
"present at the same time"
}},
}};
struct invalid_instructions * invalid = NULL;
uint64_t address = 0x1000;
cs_insn *insn;
int i;
int j;
size_t count;
printf("\nShould be invalid\n"
"-----------------\n");
for (i = 0; i < sizeof(invalids)/sizeof(invalids[0]); i++) {
cs_err err;
invalid = invalids + i;
err = cs_open(invalid->arch, invalid->mode, &handle);
if (err) {
printf("Failed on cs_open() with error returned: %u\n", err);
continue;
}
cs_option(handle, CS_OPT_DETAIL, CS_OPT_ON);
cs_option(handle, CS_OPT_SYNTAX, CS_OPT_SYNTAX_NOREGNAME);
for (j = 0; j < invalid->num_invalid_codes; ++j) {
struct invalid_code *invalid_code = NULL;
char *hex_str = NULL;
invalid_code = invalid->invalid_codes + j;
hex_str = hex_string(invalid_code->code, invalid_code->size);
printf("%s %s: %s\n", invalid->platform_comment, hex_str, invalid_code->comment);
free(hex_str);
count = cs_disasm(handle,
invalid_code->code, invalid_code->size, address, 0, &insn
);
if (count) {
size_t k;
printf(" ERROR:\n");
for (k = 0; k < count; k++) {
printf(" 0x%"PRIx64":\t%s\t%s\n",
insn[k].address, insn[k].mnemonic, insn[k].op_str);
print_insn_detail(&insn[k]);
}
cs_free(insn, count);
} else {
printf(" SUCCESS: invalid\n");
}
}
cs_close(&handle);
}
}
static void _digest(Request& r, MethodParams& params) {
const String &smethod = params.as_string(0, PARAMETER_MUST_BE_STRING);
Value& vdata=params.as_no_junction(1, "parameter must be string or file");
String::C data;
if(const String* sdata=vdata.get_string()){
String::Body body=sdata->cstr_to_string_body_untaint(String::L_AS_IS, r.connection(false), &r.charsets); // explode content, honor tainting changes
data=String::C(body.cstr(), body.length());
} else {
VFile *file=vdata.as_vfile(String::L_AS_IS);
data=String::C(file->value_ptr(),file->value_size());
}
enum Method { M_MD5, M_SHA1, M_SHA256, M_SHA512 } method;
if (smethod == "md5") method = M_MD5;
else if (smethod == "sha1" ) method = M_SHA1;
else if (smethod == "sha256" ) method = M_SHA256;
else if (smethod == "sha512" ) method = M_SHA512;
else throw Exception(PARSER_RUNTIME, &smethod, "must be 'md5' or 'sha1'");
const char *hmac=0;
enum Format { F_HEX, F_BASE64 } format = F_HEX;
if(params.count() == 3)
if(HashStringValue* options=params.as_hash(2)) {
int valid_options=0;
if(Value* value=options->get("hmac")) {
hmac=value->as_string().cstr();
valid_options++;
}
if(Value* value=options->get("format")) {
const String& sformat=value->as_string();
if (sformat == "hex") format = F_HEX;
else if (sformat == "base64" ) format = F_BASE64;
else throw Exception(PARSER_RUNTIME, &sformat, "must be 'hex' or 'base64'");
valid_options++;
}
if(valid_options!=options->count())
throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
}
String::C digest;
if(method == M_MD5){
PA_MD5_CTX c;
if(hmac){
HMAC(hmac, pa_MD5Init, pa_MD5Update, pa_MD5Final, 64, 16);
} else {
pa_MD5Init(&c);
pa_MD5Update(&c, (const unsigned char*)data.str, data.length);
}
char *str=(char *)pa_malloc(16);
pa_MD5Final((unsigned char *)str, &c);
digest = String::C(str, 16);
}
if(method == M_SHA1){
SHA1Context c;
if(hmac){
HMAC(hmac, SHA1Reset, SHA1Input, SHA1ReadDigest, 64, 20);
} else {
SHA1Reset(&c);
SHA1Input(&c, (const unsigned char*)data.str, data.length);
}
char *str=(char *)pa_malloc(20);
SHA1ReadDigest(str, &c);
digest = String::C(str, 20);
}
if(method == M_SHA256){
SHA256_CTX c;
if(hmac){
HMAC(hmac, pa_SHA256_Init, pa_SHA256_Update, pa_SHA256_Final, 64, SHA256_DIGEST_LENGTH);
} else {
pa_SHA256_Init(&c);
pa_SHA256_Update(&c, (const unsigned char*)data.str, data.length);
}
char *str=(char *)pa_malloc(SHA256_DIGEST_LENGTH);
pa_SHA256_Final((unsigned char *)str, &c);
digest = String::C(str, SHA256_DIGEST_LENGTH);
}
if(method == M_SHA512){
SHA512_CTX c;
if(hmac){
HMAC(hmac, pa_SHA512_Init, pa_SHA512_Update, pa_SHA512_Final, 128, SHA512_DIGEST_LENGTH);
} else {
pa_SHA512_Init(&c);
pa_SHA512_Update(&c, (const unsigned char*)data.str, data.length);
}
char *str=(char *)pa_malloc(SHA512_DIGEST_LENGTH);
pa_SHA512_Final((unsigned char *)str, &c);
digest = String::C(str, SHA512_DIGEST_LENGTH);
}
if(format == F_HEX){
r.write_pass_lang(*new String(hex_string((unsigned char *)digest.str, digest.length, false)));
}
if(format == F_BASE64){
r.write_pass_lang(*new String(pa_base64_encode(digest.str, digest.length)));
}
}
std::string hex_string(const long double value, const long digits) {
return hex_string(std::string(), value, digits);
}
void Endpoint::print(__u8 tabs) {
char* hex=hex_string(&descriptor,descriptor.bLength);
printf("%.*sEP(%02x): %s\n",tabs,TABPADDING,descriptor.bEndpointAddress,hex);
free(hex);
}
static void test_valids()
{
struct valid_instructions valids[] = {{
CS_ARCH_ARM,
CS_MODE_THUMB,
"Thumb",
3,
{{ (unsigned char *)"\x00\xf0\x26\xe8", 4, 0x352,
"0x352:\tblx\t#0x3a0\n"
"\top_count: 1\n"
"\t\toperands[0].type: IMM = 0x3a0\n",
"thumb2 blx with misaligned immediate"
}, { (unsigned char *)"\x05\xdd", 2, 0x1f0,
"0x1f0:\tble\t#0x1fe\n"
"\top_count: 1\n"
"\t\toperands[0].type: IMM = 0x1fe\n"
"\tCode condition: 14\n",
"thumb b cc with thumb-aligned target"
}, { (unsigned char *)"\xbd\xe8\xf0\x8f", 4, 0,
"0x0:\tpop.w\t{r4, r5, r6, r7, r8, r9, r10, r11, pc}\n"
"\top_count: 9\n"
"\t\toperands[0].type: REG = r4\n"
"\t\toperands[1].type: REG = r5\n"
"\t\toperands[2].type: REG = r6\n"
"\t\toperands[3].type: REG = r7\n"
"\t\toperands[4].type: REG = r8\n"
"\t\toperands[5].type: REG = r9\n"
"\t\toperands[6].type: REG = r10\n"
"\t\toperands[7].type: REG = r11\n"
"\t\toperands[8].type: REG = pc\n",
"thumb2 pop that should be valid"
},
}
}};
struct valid_instructions * valid = NULL;
uint64_t address = 0x1000;
cs_insn *insn;
int i;
int j;
size_t count;
for (i = 0; i < sizeof(valids)/sizeof(valids[0]); i++) {
cs_err err;
valid = valids + i;
err = cs_open(valid->arch, valid->mode, &handle);
if (err) {
printf("Failed on cs_open() with error returned: %u\n", err);
continue;
}
cs_option(handle, CS_OPT_DETAIL, CS_OPT_ON);
cs_option(handle, CS_OPT_SYNTAX, CS_OPT_SYNTAX_NOREGNAME);
#define _this_printf(...) \
{ \
size_t used = 0; \
used = snprintf(tmp_buf + cur, left, __VA_ARGS__); \
left -= used; \
cur += used; \
}
printf("\nShould be valid\n"
"---------------\n");
for (j = 0; j < valid->num_valid_codes; ++j) {
char tmp_buf[2048];
size_t left = 2048;
size_t cur = 0;
size_t used = 0;
int success = 0;
char * hex_str = NULL;
struct valid_code * valid_code = NULL;
valid_code = valid->valid_codes + j;
hex_str = hex_string(valid_code->code, valid_code->size);
printf("%s %s @ 0x%04x: %s\n %s",
valid->platform_comment, hex_str, valid_code->start_addr,
valid_code->comment, valid_code->expected_out);
count = cs_disasm(handle,
valid_code->code, valid_code->size,
valid_code->start_addr, 0, &insn
);
if (count) {
size_t k;
size_t max_len = 0;
size_t tmp_len = 0;
for (k = 0; k < count; k++) {
_this_printf(
"0x%"PRIx64":\t%s\t%s\n",
insn[k].address, insn[k].mnemonic,
insn[k].op_str
);
snprint_insn_detail(tmp_buf, &cur, &left, &insn[k]);
}
max_len = strlen(tmp_buf);
tmp_len = strlen(valid_code->expected_out);
if (tmp_len > max_len) {
max_len = tmp_len;
}
if (memcmp(tmp_buf, valid_code->expected_out, max_len)) {
printf(
" ERROR: '''\n%s''' does not match"
" expected '''\n%s'''\n",
tmp_buf, valid_code->expected_out
);
} else {
printf(" SUCCESS: valid\n");
}
cs_free(insn, count);
} else {
printf("ERROR: invalid\n");
}
}
cs_close(&handle);
}
#undef _this_prinf
}
