dnrops
/
radare2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix a new linting to remove the double error message in RLOG calls ##lint

This commit is contained in:
pancake 2022-07-07 20:25:26 +02:00 committed by GitHub
parent 34b21efc1e
commit ad1add71cb
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
53 changed files with 155 additions and 197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
libr/anal/arch/8051/8051_ass.c
View File

@ -882,18 +882,18 @@ static bool mnem_jb(char const*const*arg, ut16 pc, ut8**out) {
static bool mnem_jbc(char const*const*arg, ut16 pc, ut8**out) {
ut8 cmp_addr;
if (!address_bit (arg[0], &cmp_addr)) {
R_LOG_ERROR ("error during the assembly: address bit not found");
R_LOG_ERROR ("address bit not found");
return false;
}
ut16 jmp_addr;
if (!to_address (arg[1], &jmp_addr)) {
R_LOG_DEBUG ("error during the assembly: address %x not found", jmp_addr);
R_LOG_DEBUG ("address %x not found", jmp_addr);
return false;
}
if (!relative_address (pc + 1, jmp_addr, (*out) + 2)) {
R_LOG_DEBUG ("error during the assembly: address %x not found", jmp_addr);
R_LOG_DEBUG ("address %x not found", jmp_addr);
return false;
}

7
libr/anal/esil_trace.c
View File

@ -62,7 +62,7 @@ R_API RAnalEsilTrace *r_anal_esil_trace_new(RAnalEsil *esil) {
}
return trace;
error:
R_LOG_ERROR ("error");
R_LOG_ERROR ("trace initialization failed");
r_anal_esil_trace_free (trace);
return NULL;
}
@ -323,12 +323,9 @@ static int cmp_strings_by_leading_number(void *data1, void *data2) {
while (b[j] >= '0' && b[j] <= '9') {
j++;
}
if (!i) {
if (!i || !j) {
return 1;
}
if (!j) {
return -1;
}
i--;
j--;
if (i > j) {

6
libr/anal/flirt.c
View File

@ -1448,7 +1448,7 @@ R_API void r_sign_flirt_dump(const RAnal *anal, const char *flirt_file) {
node_free (node);
return;
} else {
eprintf ("We encountered an error while parsing the file. Sorry.\n");
R_LOG_ERROR ("We encountered a problem while parsing the file");
return;
}
}
@ -1467,12 +1467,12 @@ R_API void r_sign_flirt_scan(RAnal *anal, const char *flirt_file) {
r_buf_free (flirt_buf);
if (node) {
if (!node_match_functions (anal, node)) {
R_LOG_ERROR ("Error while scanning the file %s", flirt_file);
R_LOG_ERROR ("scanning file %s", flirt_file);
}
node_free (node);
return;
} else {
eprintf ("We encountered an error while parsing the file %s. Sorry.\n", flirt_file);
R_LOG_ERROR ("We encountered an error while parsing the file %s", flirt_file);
return;
}
}

2
libr/anal/p/anal_mips_gnu.c
View File

@ -1140,7 +1140,7 @@ static int disassemble(RAnal *a, RAnalOp *op, const ut8 *buf, int len) {
mips_mode = a->config->bits;
disasm_obj.arch = CPU_LOONGSON_2F;
disasm_obj.buffer = &bytes;
disasm_obj.buffer = (ut8*)&bytes;
disasm_obj.read_memory_func = &mips_buffer_read_memory;
disasm_obj.symbol_at_address_func = &symbol_at_address;
disasm_obj.memory_error_func = &memory_error_func;

2
libr/anal/rtti_itanium.c
View File

@ -196,7 +196,7 @@ static bool rtti_itanium_vmi_class_type_info_init(RVTableContext *context, ut64
}
at = at & 0xffffffff;
if (at < 1 || at > 0xfffff) {
R_LOG_ERROR ("Error reading vmi_base_count");
R_LOG_ERROR ("reading vmi_base_count");
return false;
}
vmi_cti->vmi_base_count = at;

29
libr/anal/sign.c
View File

@ -699,12 +699,12 @@ static bool addBBHash(RAnal *a, RAnalFunction *fcn, const char *name) {
R_API bool r_sign_add_hash(RAnal *a, const char *name, int type, const char *val, int len) {
r_return_val_if_fail (a && name && type && val && len > 0, false);
if (type != R_SIGN_BBHASH) {
R_LOG_ERROR ("error: hash type unknown");
R_LOG_ERROR ("hash type unknown");
return false;
}
int digestsize = r_hash_size (R_ZIGN_HASH) * 2;
if (len != digestsize) {
R_LOG_ERROR ("error: invalid hash size: %d (%s digest size is %d)", len, ZIGN_HASH, digestsize);
R_LOG_ERROR ("invalid hash size: %d (%s digest size is %d)", len, ZIGN_HASH, digestsize);
return false;
}
return addHash (a, name, type, val);
@ -2031,7 +2031,7 @@ static bool foreachCB(void *user, const char *k, const char *v) {
keep_going = ctx->cb (it, ctx->user);
}
} else {
R_LOG_ERROR ("error: cannot deserialize zign");
R_LOG_ERROR ("cannot deserialize zign");
}
if (ctx->freeit) {
r_sign_item_free (it);
@ -2873,7 +2873,7 @@ static bool loadCB(void *user, const char *k, const char *v) {
}
}
} else {
R_LOG_ERROR ("error: cannot deserialize zign");
R_LOG_ERROR ("cannot deserialize zign");
}
r_sign_item_free (it);
return true;
@ -2921,7 +2921,7 @@ R_API bool r_sign_load(RAnal *a, const char *file, bool merge) {
}
char *path = r_sign_path (a, file);
if (!r_file_exists (path)) {
R_LOG_ERROR ("error: file %s does not exist", file);
R_LOG_ERROR ("file %s does not exist", file);
free (path);
return false;
}
@ -2943,44 +2943,37 @@ R_API bool r_sign_load_gz(RAnal *a, const char *filename, bool merge) {
int size = 0;
char *tmpfile = NULL;
bool retval = true;
char *path = r_sign_path (a, filename);
if (!r_file_exists (path)) {
R_LOG_ERROR ("error: file %s does not exist", filename);
R_LOG_ERROR ("file %s does not exist", filename);
retval = false;
goto out;
}
if (!(buf = r_file_gzslurp (path, &size, 0))) {
R_LOG_ERROR ("error: cannot decompress file");
R_LOG_ERROR ("cannot decompress file");
retval = false;
goto out;
}
if (!(tmpfile = r_file_temp ("r2zign"))) {
R_LOG_ERROR ("error: cannot create temp file");
R_LOG_ERROR ("cannot create temp file");
retval = false;
goto out;
}
if (!r_file_dump (tmpfile, buf, size, 0)) {
R_LOG_ERROR ("error: cannot dump file");
R_LOG_ERROR ("cannot dump file");
retval = false;
goto out;
}
if (!r_sign_load (a, tmpfile, merge)) {
R_LOG_ERROR ("error: cannot load file");
R_LOG_ERROR ("cannot load file");
retval = false;
goto out;
}
if (!r_file_rm (tmpfile)) {
R_LOG_ERROR ("error: cannot delete temp file");
R_LOG_ERROR ("cannot delete temp file");
retval = false;
goto out;
}
out:
free (buf);
free (tmpfile);

2
libr/asm/arch/pyc/opcode.c
View File

@ -245,7 +245,7 @@ void (store_opN)(struct op_parameter par) {
def_op (.op_obj = par.op_obj, .op_name = par.op_name, .op_code = par.op_code, .pop = par.pop, .push = par.push);
break;
default:
R_LOG_ERROR ("Error in store_op in opcode.c, call function %u", par.func);
R_LOG_ERROR ("in store_op in opcode.c, call function %u", par.func);
return;
}
par.op_obj[par.op_code].type |= HASSTORE;

2
libr/asm/binutils_as.c
View File

@ -69,7 +69,7 @@ int binutils_assemble(RAsm *a, RAsmOp *op, const char *buf, const char *as, cons
}
res = op->size = len;
} else {
R_LOG_ERROR ("Error running: %s", cmd);
R_LOG_ERROR ("running: %s", cmd);
}
beach:
close (ofd);

4
libr/asm/p/asm_x86_nasm.c
View File

@ -1,4 +1,4 @@
/* radare - LGPL - Copyright 2009-2020 - pancake */
/* radare - LGPL - Copyright 2009-2022 - pancake */
#include <r_lib.h>
#include <r_asm.h>
@ -38,7 +38,7 @@ static int assemble(RAsm *a, RAsmOp *op, const char *buf) {
op->size = read (ofd, buf, sizeof (buf));
r_asm_op_set_buf (op, buf, op->size);
} else {
R_LOG_ERROR ("Error running 'nasm'");
R_LOG_ERROR ("running 'nasm'");
}
close (ofd);

1
libr/asm/p/asm_x86_nz.c
View File

@ -4895,7 +4895,6 @@ static int parseOperand(RAsm *a, const char *str, Operand *op, bool isrepop) {
bool first_reg = true;
while (str[pos] != ']') {
if (pos > nextpos) {
// R_LOG_ERROR ("Error parsing instruction");
break;
}
pos = nextpos;

2
libr/bin/bfile.c
View File

@ -482,7 +482,7 @@ static void get_strings_range(RBinFile *bf, RList *list, int min, int raw, ut64
} else if (!strcmp (enc, "utf32le")) {
type = R_STRING_TYPE_WIDE32;
} else { // TODO utf16be, utf32be
R_LOG_ERROR ("ERROR: encoding %s not supported", enc);
R_LOG_ERROR ("encoding %s not supported", enc);
return;
}
string_scan_range (list, bf, min, from, to, type, raw, section);

2
libr/bin/bobj.c
View File

@ -148,7 +148,7 @@ R_IPI RBinObject *r_bin_object_new(RBinFile *bf, RBinPlugin *plugin, ut64 basead
if (plugin && plugin->load_buffer) {
if (!plugin->load_buffer (bf, &bo->bin_obj, bf->buf, loadaddr, sdb)) {
if (bf->rbin->verbose) {
R_LOG_ERROR ("Error in r_bin_object_new: load_buffer failed for %s plugin", plugin->name);
R_LOG_ERROR ("r_bin_object_new: load_buffer failed for %s plugin", plugin->name);
}
sdb_free (bo->kv);
free (bo);

4
libr/bin/format/objc/mach0_classes.c
View File

@ -291,7 +291,7 @@ static void get_ivar_list_t(mach0_ut p, RBinFile *bf, RBinClass *klass) {
if (offset_at != 0 && left >= sizeof (mach0_ut)) {
len = r_buf_read_at (bf->buf, offset_at, offs, sizeof (mach0_ut));
if (len != sizeof (mach0_ut)) {
R_LOG_ERROR ("Error reading");
R_LOG_ERROR ("reading");
goto error;
}
ivar_offset = r_read_ble (offs, bigendian, 8 * sizeof (mach0_ut));
@ -315,7 +315,7 @@ static void get_ivar_list_t(mach0_ut p, RBinFile *bf, RBinClass *klass) {
name = malloc (name_len + 1);
len = r_buf_read_at (bf->buf, r, (ut8 *)name, name_len);
if (len < 1) {
R_LOG_ERROR ("Error reading");
R_LOG_ERROR ("reading2");
R_FREE (name);
goto error;
}

2
libr/bin/format/pe/pe.c
View File

@ -3134,7 +3134,7 @@ R_API void PE_(bin_pe_parse_resource)(RBinPEObj *pe) {
totalRes = curRes + rs_directory->NumberOfIdEntries;
if (totalRes > R_PE_MAX_RESOURCES) {
if (pe->verbose) {
R_LOG_ERROR ("Error parsing resource directory");
R_LOG_ERROR ("parsing resource directory");
}
ht_uu_free (dirs);
return;

2
libr/bin/format/pe/pemixed.c
View File

@ -37,7 +37,7 @@ struct PE_(r_bin_pe_obj_t)* r_bin_pemixed_init_dos(RBinPEObj* pe) {
}
if ((r_buf_read_at (pe->b, 0, tmp_buf, pe_hdr_off)) == -1) {
R_LOG_ERROR ("Error reading to buffer");
R_LOG_ERROR ("reading to buffer");
return NULL;
}

6
libr/bin/p/bin_dex.c
View File

@ -1152,19 +1152,19 @@ static void parse_dex_class_method(RBinFile *bf, RBinDexClass *c, RBinClass *cls
encoded_method_addr = r_buf_tell (bf->buf);
MI = peek_uleb (bf->buf, &err, &skip);
if (err) {
R_LOG_ERROR ("Error");
R_LOG_ERROR ("peek-uleb0");
break;
}
MI += omi;
omi = MI;
MA = peek_uleb (bf->buf, &err, &skip);
if (err) {
R_LOG_ERROR ("Error");
R_LOG_ERROR ("peek-uleb1");
break;
}
MC = peek_uleb (bf->buf, &err, &skip);
if (err) {
R_LOG_ERROR ("Error");
R_LOG_ERROR ("peek-uleb2");
break;
}
// TODO: MOVE CHECKS OUTSIDE!

33
libr/bin/p/bin_dyldcache.c
View File

@ -147,43 +147,34 @@ static void free_bin(RDyldBinImage *bin) {
}
static void rebase_info3_free(RDyldRebaseInfo3 *rebase_info) {
if (!rebase_info) {
return;
if (rebase_info) {
R_FREE (rebase_info->page_starts);
R_FREE (rebase_info);
}
R_FREE (rebase_info->page_starts);
R_FREE (rebase_info);
}
static void rebase_info2_free(RDyldRebaseInfo2 *rebase_info) {
if (!rebase_info) {
return;
if (rebase_info) {
R_FREE (rebase_info->page_starts);
R_FREE (rebase_info->page_extras);
R_FREE (rebase_info);
}
R_FREE (rebase_info->page_starts);
R_FREE (rebase_info->page_extras);
R_FREE (rebase_info);
}
static void rebase_info1_free(RDyldRebaseInfo1 *rebase_info) {
if (!rebase_info) {
return;
if (rebase_info) {
R_FREE (rebase_info->toc);
R_FREE (rebase_info->entries);
R_FREE (rebase_info);
}
R_FREE (rebase_info->toc);
R_FREE (rebase_info->entries);
R_FREE (rebase_info);
}
static void rebase_info_free(RDyldRebaseInfo *rebase_info) {
if (!rebase_info) {
return;
}
R_FREE (rebase_info->one_page_buf);
ut8 version = rebase_info->version;
if (version == 1) {
rebase_info1_free ((RDyldRebaseInfo1*) rebase_info);
} else if (version == 2 || version == 4) {
@ -1564,7 +1555,7 @@ static int dyldcache_io_read(RIO *io, RIODesc *fd, ut8 *buf, int count) {
result = R_MIN (count, internal_result);
memcpy (buf, internal_buf + page_offset, result);
} else {
R_LOG_ERROR ("ERROR rebasing");
R_LOG_ERROR ("rebasing");
result = cache->original_io_read (io, fd, buf, count);
}

10
libr/bin/pdb/pdb.c
View File

@ -91,7 +91,7 @@ static int read_int_var(char *var_name, int *var, RPdb *pdb) {
}
int bytes_read = r_buf_read (pdb->buf, (ut8 *) var, 4);
if (bytes_read != 4) {
R_LOG_ERROR ("Error while reading from file '%s'", var_name);
R_LOG_ERROR ("reading from file '%s'", var_name);
return 0;
}
return bytes_read;
@ -438,7 +438,7 @@ static bool pdb7_parse(RPdb *pdb) {
bytes_read = r_buf_read (pdb->buf, (unsigned char *) signature, PDB7_SIGNATURE_LEN);
if (bytes_read != PDB7_SIGNATURE_LEN) {
//R_LOG_ERROR ("Error while reading PDB7_SIGNATURE");
//R_LOG_ERROR ("while reading PDB7_SIGNATURE");
goto error;
}
if (!read_int_var ("page_size", &page_size, pdb)) {
@ -465,18 +465,18 @@ static bool pdb7_parse(RPdb *pdb) {
num_root_index_pages = count_pages ((num_root_pages * 4), page_size);
root_index_pages = (int *) calloc (sizeof (int), R_MAX (num_root_index_pages, 1));
if (!root_index_pages) {
R_LOG_ERROR ("Error memory allocation");
R_LOG_ERROR ("memory allocation");
goto error;
}
bytes_read = r_buf_read (pdb->buf, (unsigned char *) root_index_pages, 4 * num_root_index_pages);
// fread(root_index_pages, 4, num_root_index_pages, pdb->fp);
if (bytes_read != 4 * num_root_index_pages) {
R_LOG_ERROR ("Error while reading root_index_pages");
R_LOG_ERROR ("reading root_index_pages");
goto error;
}
if (page_size < 1 || num_root_index_pages < 1) {
eprintf ("Invalid root index pages size.\n");
R_LOG_ERROR ("Invalid root index pages size");
goto error;
}
root_page_data = (int *) calloc (page_size, num_root_index_pages);

2
libr/core/canal.c
View File

@ -3985,7 +3985,7 @@ R_API int r_core_anal_search(RCore *core, ut64 from, ut64 to, ut64 ref, int mode
}
}
} else {
R_LOG_ERROR ("error: block size too small");
R_LOG_ERROR ("block size too small");
}
r_cons_break_pop ();
free (buf);

2
libr/core/casm.c
View File

@ -95,7 +95,7 @@ R_API RList *r_core_asm_strsearch(RCore *core, const char *input, ut64 from, ut6
}
if (core->blocksize < 8) {
R_LOG_ERROR ("error: block size too small");
R_LOG_ERROR ("block size too small");
return NULL;
}
if (!(buf = (ut8 *)calloc (core->blocksize, 1))) {

6
libr/core/cconfig.c
View File

@ -3182,9 +3182,9 @@ static bool cb_linesabs(void *user, void *data) {
ut64 to = r_num_math (core->num, (to_str && *to_str) ? to_str : "$s");
core->print->lines_cache_sz = r_core_lines_initcache (core, from, to);
if (core->print->lines_cache_sz == -1) {
R_LOG_ERROR ("ERROR: \"lines.from\" and \"lines.to\" must be set");
R_LOG_ERROR ("\"lines.from\" and \"lines.to\" must be set");
} else {
eprintf ("Found %d lines\n", core->print->lines_cache_sz-1);
R_LOG_INFO ("Found %d lines", core->print->lines_cache_sz - 1);
}
}
return true;
@ -3193,14 +3193,12 @@ static bool cb_linesabs(void *user, void *data) {
static bool cb_malloc(void *user, void *data) {
RCore *core = (RCore*) user;
RConfigNode *node = (RConfigNode*) data;
if (node->value) {
if (!strcmp ("jemalloc", node->value) || !strcmp ("glibc", node->value)) {
if (core->dbg) {
core->dbg->malloc = data;
}
}
}
return true;
}

29
libr/core/cplugin.c
View File

@ -1,31 +1,24 @@
/* radare - LGPL - Copyright 2010-2021 - pancake */
/* covardly copied from r_cmd */
/* radare - LGPL - Copyright 2010-2022 - pancake */
#include <config.h>
#include <r_core.h>
#include <r_cmd.h>
#include <r_list.h>
#include <stdio.h>
static RCorePlugin *cmd_static_plugins[] = {
R_CORE_STATIC_PLUGINS
};
R_API void r_core_plugin_fini(RCmd *cmd) {
RListIter *iter;
RCorePlugin *plugin;
if (!cmd->plist) {
return;
}
r_list_foreach (cmd->plist, iter, plugin) {
if (plugin && plugin->fini) {
plugin->fini (cmd, NULL);
if (cmd->plist) {
RListIter *iter;
RCorePlugin *plugin;
r_list_foreach (cmd->plist, iter, plugin) {
if (plugin && plugin->fini) {
plugin->fini (cmd, NULL);
}
}
r_list_free (cmd->plist);
cmd->plist = NULL;
}
/* empty the list */
r_list_free (cmd->plist);
cmd->plist = NULL;
}
R_API bool r_core_plugin_add(RCmd *cmd, RCorePlugin *plugin) {
@ -42,7 +35,7 @@ R_API bool r_core_plugin_init(RCmd *cmd) {
cmd->plist = r_list_newf (NULL); // memleak or dblfree
for (i = 0; cmd_static_plugins[i]; i++) {
if (!r_core_plugin_add (cmd, cmd_static_plugins[i])) {
R_LOG_ERROR ("Error loading cmd plugin");
R_LOG_ERROR ("loading cmd plugin");
return false;
}
}

2
libr/core/esil2c.c
View File

@ -10,7 +10,7 @@ static char *esil2c(RCore *core, RAnalEsil *esil, const char *expr) {
RStrBuf *sb = r_strbuf_new ("");
user->sb = sb;
if (!r_anal_esil_parse (esil, expr)) {
R_LOG_ERROR ("ERROR");
R_LOG_ERROR ("Invalid ESIL expression");
}
user->sb = NULL;
return r_strbuf_drain (sb);

14
libr/core/linux_heap_jemalloc.c
View File

@ -202,7 +202,6 @@ static void GH(jemalloc_get_chunks)(RCore *core, const char *input) {
extent_node_t *head = R_NEW0 (extent_node_t);
if (!node || !head) {
R_LOG_ERROR ("Error calling calloc");
free (ar);
free (node);
free (head);
@ -367,7 +366,7 @@ static void GH(jemalloc_get_bins)(RCore *core, const char *input) {
break;
}
if (!GH(r_resolve_jemalloc)(core, "je_arena_bin_info", &bin_info)) {
R_LOG_ERROR ("Error resolving je_arena_bin_info");
R_LOG_ERROR ("resolving je_arena_bin_info");
R_FREE (b);
break;
}
@ -437,7 +436,6 @@ static void GH(jemalloc_get_runs)(RCore *core, const char *input) {
arena_chunk_t *c = R_NEW0 (arena_chunk_t);
if (!c) {
R_LOG_ERROR ("Error calling calloc");
return;
}
@ -445,19 +443,19 @@ static void GH(jemalloc_get_runs)(RCore *core, const char *input) {
chunk = r_num_math (core->num, input);
if (!GH(r_resolve_jemalloc)(core, "je_chunk_npages", &npages)) {
R_LOG_ERROR ("Error resolving je_chunk_npages");
R_LOG_ERROR ("resolving je_chunk_npages");
return;
}
if (!GH(r_resolve_jemalloc)(core, "je_chunksize_mask", &chunksize_mask)) {
R_LOG_ERROR ("Error resolving je_chunksize_mask");
R_LOG_ERROR ("resolving je_chunksize_mask");
return;
}
if (!GH(r_resolve_jemalloc)(core, "je_map_bias", &map_bias)) {
eprintf ("Error resolving je_map_bias");
eprintf ("resolving je_map_bias");
return;
}
if (!GH(r_resolve_jemalloc)(core, "je_map_misc_offset", &map_misc_offset)) {
eprintf ("Error resolving je_map_misc_offset");
eprintf ("resolving je_map_misc_offset");
return;
}
@ -480,7 +478,7 @@ static void GH(jemalloc_get_runs)(RCore *core, const char *input) {
arena_run_t *r = R_NEW0 (arena_run_t);
if (!r) {
R_LOG_ERROR ("Error calling calloc");
R_LOG_ERROR ("calling calloc");
return;
}
for (pageind = map_bias; pageind < npages; pageind++) {

2
libr/core/p/core_java.c
View File

@ -874,7 +874,7 @@ static int r_cmd_java_handle_replace_classname_value(RCore *core, const char *cm
core, obj, idx, addr,
(const ut8 *)result, res_len);
if (res == false) {
R_LOG_ERROR ("ERROR: r_cmd_java: Failed to write bytes or reload the binary");
R_LOG_ERROR ("r_cmd_java: Failed to write bytes or reload the binary");
}
}
free (result);

8
libr/core/rtr.c
View File

@ -636,12 +636,12 @@ static int r_core_rtr_gdb_run(RCore *core, int launch, const char *path) {
R_API int r_core_rtr_gdb(RCore *core, int launch, const char *path) {
int ret;
if (r_sandbox_enable (0)) {
eprintf ("sandbox: connect disabled\n");
R_LOG_ERROR ("connect disable the sandbox");
return -1;
}
// TODO: do stuff with launch
if (core->gdbserver_up) {
eprintf ("gdbserver is already running\n");
R_LOG_INFO ("the gdbserver is already running");
return -1;
}
ret = r_core_rtr_gdb_run (core, launch, path);
@ -659,7 +659,7 @@ R_API void r_core_rtr_pushout(RCore *core, const char *input) {
}
}
if (!(cmd = strchr (input, ' '))) {
R_LOG_ERROR ("Error");
R_LOG_ERROR ("Missing space");
return;
}
} else {
@ -1345,7 +1345,7 @@ R_API int r_core_rtr_cmds(RCore *core, const char *port) {
s->local = r_config_get_i (core->config, "tcp.islocal");
if (!r_socket_listen (s, port, NULL)) {
R_LOG_ERROR ("Error listening on port %s", port);
R_LOG_ERROR ("listening on port %s", port);
r_socket_free (s);
return false;
}

4
libr/core/vasm.c
View File

@ -82,14 +82,14 @@ R_API void r_core_visual_asm(RCore *core, ut64 off) {
if (cva.acode && cva.acode->len > 0) {
if (r_cons_yesno ('y', "Save changes? (Y/n)")) {
if (!r_io_write_at (core->io, off, cva.acode->bytes, cva.acode->len)) {
R_LOG_ERROR ("ERROR: Cannot write in here, check map permissions or reopen the file with oo+");
R_LOG_ERROR ("Cannot write in here, check map permissions or reopen the file with oo+");
r_cons_any_key (NULL);
}
// r_core_cmdf (core, "wx %s @ 0x%"PFMT64x, cva.acode->buf_hex, off);
}
#if 0
} else if (!cva.acode || cva.acode->len == 0) {
R_LOG_ERROR ("ERROR: Cannot assemble those instructions");
R_LOG_ERROR ("Cannot assemble those instructions");
// r_cons_any_key (NULL);
#endif
}

2
libr/core/vmenus.c
View File

@ -4075,7 +4075,7 @@ onemoretime:
int rc = r_anal_op (core->anal, &op, off,
core->block + off - core->offset, 32, R_ANAL_OP_MASK_BASIC);
if (rc < 1) {
R_LOG_ERROR ("Error analyzing opcode at 0x%08"PFMT64x, off);
R_LOG_ERROR ("analyzing opcode at 0x%08"PFMT64x, off);
} else {
tgt_addr = op.jump != UT64_MAX ? op.jump : op.ptr;
RAnalVar *var = r_anal_get_used_function_var (core->anal, op.addr);

21
libr/core/yank.c
View File

@ -58,11 +58,11 @@ static int perform_mapped_file_yank(RCore *core, ut64 offset, ut64 len, const ch
// address the file at its physical address!
addr += loadaddr;
} else if (yankdesc) {
eprintf ("Unable to map the opened file: %s\n", filename);
R_LOG_ERROR ("Unable to map the opened file: %s", filename);
r_io_desc_close (yankdesc);
yankdesc = NULL;
} else {
eprintf ("Unable to open the file: %s\n", filename);
R_LOG_ERROR ("Unable to open the file: %s", filename);
}
}
}
@ -86,16 +86,9 @@ static int perform_mapped_file_yank(RCore *core, ut64 offset, ut64 len, const ch
r_core_yank_set (core, R_CORE_FOREIGN_ADDR, buf, len);
res = true;
} else if (res != addr) {
eprintf (
"ERROR: Unable to yank data from file: (loadaddr (0x%"
PFMT64x ") (addr (0x%"
PFMT64x ") > file_sz (0x%"PFMT64x ")\n", res, addr,
yank_file_sz );
R_LOG_ERROR ("Unable to yank data from file: (loadaddr (0x%" PFMT64x ") (addr (0x%" PFMT64x ") > file_sz (0x%"PFMT64x ")", res, addr, yank_file_sz);
} else if (actual_len == 0) {
eprintf (
"ERROR: Unable to yank from file: addr+len (0x%"
PFMT64x ") > file_sz (0x%"PFMT64x ")\n", addr + len,
yank_file_sz );
R_LOG_ERROR ("Unable to yank from file: addr+len (0x%" PFMT64x ") > file_sz (0x%"PFMT64x ")", addr + len, yank_file_sz);
}
r_io_desc_close (yankdesc);
free (buf);
@ -419,13 +412,13 @@ R_API bool r_core_yank_file_ex(RCore *core, const char *input) {
adv = consume_chars (input, ' ');
len = r_num_math (core->num, input + adv);
if (len == 0) {
R_LOG_ERROR ("ERROR: Number of bytes read must be > 0");
R_LOG_ERROR ("Number of bytes read must be > 0");
return res;
}
// get the addr/offset from in the file we want to read
adv += find_next_char (input + adv, ' ');
if (adv == 0) {
R_LOG_ERROR ("ERROR: Address must be specified");
R_LOG_ERROR ("Address must be specified");
return res;
}
adv++;
@ -435,7 +428,7 @@ R_API bool r_core_yank_file_ex(RCore *core, const char *input) {
adv += find_next_char (input + adv, ' ');
if (adv == 0) {
R_LOG_ERROR ("ERROR: File must be specified");
R_LOG_ERROR ("File must be specified");
return res;
}
adv++;

2
libr/debug/p/debug_bf.c
View File

@ -34,7 +34,7 @@ static bool is_io_bf(RDebug *dbg) {
return true;
}
}
R_LOG_ERROR ("error: the iodesc data is not brainfuck friendly");
R_LOG_ERROR ("the iodesc data is not brainfuck friendly");
return false;
}

2
libr/debug/p/debug_bochs.c
View File

@ -24,7 +24,7 @@ static bool isBochs(RDebug *dbg) {
return true;
}
}
R_LOG_ERROR ("error: the iodesc data is not bochs friendly");
R_LOG_ERROR ("the iodesc data is not bochs friendly");
return false;
}

2
libr/debug/p/debug_gdb.c
View File

@ -373,7 +373,7 @@ static bool r_debug_gdb_attach(RDebug *dbg, int pid) {
int bits = dbg->anal->config->bits;
gdbr_set_architecture (desc, arch, bits);
} else {
R_LOG_ERROR ("ERROR: Underlying IO descriptor is not a GDB one");
R_LOG_ERROR ("Underlying IO descriptor is not a GDB one");
}
}
return true;

8
libr/debug/p/debug_native.c
View File

@ -301,7 +301,7 @@ static RDebugReasonType r_debug_native_wait(RDebug *dbg, int pid) {
RW32Dw *wrap = dbg->user;
if (pid == -1) {
R_LOG_ERROR ("ERROR: r_debug_native_wait called with pid -1");
R_LOG_ERROR ("r_debug_native_wait called with pid -1");
return R_DEBUG_REASON_ERROR;
}
@ -428,7 +428,7 @@ static RDebugReasonType r_debug_native_wait(RDebug *dbg, int pid) {
RDebugReasonType reason = R_DEBUG_REASON_UNKNOWN;
if (pid == -1) {
R_LOG_ERROR ("ERROR: r_debug_native_wait called with pid -1");
R_LOG_ERROR ("r_debug_native_wait called with pid -1");
return R_DEBUG_REASON_ERROR;
}
@ -441,7 +441,7 @@ static RDebugReasonType r_debug_native_wait(RDebug *dbg, int pid) {
RDebugReasonType reason = R_DEBUG_REASON_UNKNOWN;
if (pid == -1) {
R_LOG_ERROR ("ERROR: r_debug_native_wait called with pid -1");
R_LOG_ERROR ("r_debug_native_wait called with pid -1");
return R_DEBUG_REASON_ERROR;
}
@ -1587,7 +1587,7 @@ static int r_debug_setup_ownership(int fd, RDebug *dbg) {
RDebugInfo *info = r_debug_info (dbg, NULL);
if (!info) {
R_LOG_ERROR ("Error while getting debug info");
R_LOG_ERROR ("getting debug info");
return -1;
}
fchown (fd, info->uid, info->gid);

2
libr/debug/p/debug_rap.c
View File

@ -35,7 +35,7 @@ static bool __rap_attach(RDebug *dbg, int pid) {
if (!strcmp ("rap", d->plugin->name)) {
eprintf ("SUCCESS: rap attach with inferior rap rio worked\n");
} else {
R_LOG_ERROR ("ERROR: Underlying IO descriptor is not a rap one");
R_LOG_ERROR ("Underlying IO descriptor is not a rap one");
}
}
return true;

2
libr/debug/p/native/windows/windows_message.c
View File

@ -316,7 +316,7 @@ R_API void r_w32_identify_window(void) {
return;
}
if (!win) {
R_LOG_ERROR ("Error trying to get information from 0x%08"PFMT64x, (ut64)hwnd);
R_LOG_ERROR ("trying to get information from 0x%08"PFMT64x, (ut64)hwnd);
return;
}
RTable *tbl = __create_window_table ();

24
libr/debug/p/native/xnu/trap_x86.c
View File

@ -8,22 +8,20 @@ static bool xnu_x86_hwstep_enable64(RDebug *dbg, bool enable) {
xnu_thread_t *th = get_xnu_thread (dbg, dbg->tid);
ret = xnu_thread_get_gpr (dbg, th);
if (!ret) {
R_LOG_ERROR ("error to get gpr registers in trace bit intel");
R_LOG_ERROR ("cannot get gpr registers in trace bit intel");
return false;
}
state = (R_REG_T *)&th->gpr;
if (state->tsh.flavor == x86_THREAD_STATE32) {
state->uts.ts32.__eflags = (state->uts.ts32.__eflags & \
~0x100UL) | (enable ? 0x100UL : 0);
state->uts.ts32.__eflags = (state->uts.ts32.__eflags & ~0x100UL) | (enable ? 0x100UL : 0);
} else if (state->tsh.flavor == x86_THREAD_STATE64) {
state->uts.ts64.__rflags = (state->uts.ts64.__rflags & \
~0x100UL) | (enable ? 0x100UL : 0);
state->uts.ts64.__rflags = (state->uts.ts64.__rflags & ~0x100UL) | (enable ? 0x100UL : 0);
} else {
eprintf ("Invalid bit size\n");
R_LOG_ERROR ("Invalid bit size");
return false;
}
if (!xnu_thread_set_gpr (dbg, th)) {
R_LOG_ERROR ("error xnu_thread_set_gpr in modify_trace_bit intel");
R_LOG_ERROR ("xnu_thread_set_gpr in modify_trace_bit intel");
return false;
}
return true;
@ -34,27 +32,27 @@ static bool xnu_x86_hwstep_enable32(RDebug *dbg, bool enable) {
xnu_thread_t *th = get_xnu_thread (dbg, dbg->tid);
int ret = xnu_thread_get_gpr (dbg, th);
if (!ret) {
R_LOG_ERROR ("error to get gpr registers in trace bit intel");
R_LOG_ERROR ("cannot get gpr registers in trace bit intel");
return false;
}
state = (R_REG_T *)&th->gpr;
if (state->tsh.flavor == x86_THREAD_STATE32) {
state->uts.ts32.__eflags = (state->uts.ts32.__eflags & \
~0x100UL) | (enable ? 0x100UL : 0);
state->uts.ts32.__eflags = (state->uts.ts32.__eflags & ~0x100UL) | (enable ? 0x100UL : 0);
} else {
eprintf ("Invalid bit size\n");
R_LOG_ERROR ("Invalid bit size");
return false;
}
if (!xnu_thread_set_gpr (dbg, th)) {
R_LOG_ERROR ("error xnu_thread_set_gpr in modify_trace_bit intel");
R_LOG_ERROR ("xnu_thread_set_gpr in modify_trace_bit intel");
return false;
}
return true;
}
bool xnu_native_hwstep_enable(RDebug *dbg, bool enable) {
if (dbg->bits == R_SYS_BITS_64)
if (dbg->bits == R_SYS_BITS_64) {
return xnu_x86_hwstep_enable64 (dbg, enable);
}
return xnu_x86_hwstep_enable32 (dbg, enable);
}
#endif

11
libr/debug/p/native/xnu/xnu_debug.c
View File

@ -209,7 +209,7 @@ bool xnu_attach(RDebug *dbg, int pid) {
}
#else
if (!xnu_create_exception_thread (dbg, pid)) {
R_LOG_ERROR ("error setting up exception thread");
R_LOG_ERROR ("setting up exception thread");
return false;
}
dbg->pid = pid;
@ -304,19 +304,19 @@ bool xnu_continue(RDebug *dbg, int pid, int tid, int sig) {
//TODO free refs count threads
xnu_thread_t *th = get_xnu_thread (dbg, getcurthread (dbg));
if (!th) {
eprintf ("failed to get thread in xnu_continue\n");
R_LOG_ERROR ("failed to get thread in xnu_continue");
return false;
}
//disable trace bit if enable
if (th->stepping) {
if (!clear_trace_bit (dbg, th)) {
R_LOG_ERROR ("error clearing trace bit in xnu_continue");
R_LOG_ERROR ("clearing trace bit in xnu_continue");
return false;
}
}
kern_return_t kr = task_resume (task);
if (kr != KERN_SUCCESS) {
eprintf ("xnu_continue: Warning: Failed to resume task\n");
R_LOG_ERROR ("xnu_continue: Warning: Failed to resume task");
}
return true;
#endif
@ -513,8 +513,7 @@ static void xnu_free_threads_ports(RDebugPid *p) {
if (p->pid != old_pid) {
kr = mach_port_deallocate (old_pid, p->pid);
if (kr != KERN_SUCCESS) {
eprintf ("error mach_port_deallocate in "
"xnu_free_threads ports\n");
R_LOG_ERROR ("mach_port_deallocate in xnu_free_threads ports");
}
}
}

24
libr/debug/p/native/xnu/xnu_excthreads.c
View File

@ -18,7 +18,7 @@ static bool modify_trace_bit(RDebug *dbg, xnu_thread_t *th, int enable) {
int ret;
ret = xnu_thread_get_gpr (dbg, th);
if (!ret) {
R_LOG_ERROR ("error to get gpr registers in trace bit intel");
R_LOG_ERROR ("to get gpr registers in trace bit intel");
return false;
}
state = (R_REG_T *)&th->gpr;
@ -29,11 +29,11 @@ static bool modify_trace_bit(RDebug *dbg, xnu_thread_t *th, int enable) {
state->uts.ts64.__rflags = (state->uts.ts64.__rflags & \
~0x100UL) | (enable ? 0x100UL : 0);
} else {
eprintf ("Invalid bit size\n");
R_LOG_ERROR ("Invalid bit size");
return false;
}
if (!xnu_thread_set_gpr (dbg, th)) {
R_LOG_ERROR ("error xnu_thread_set_gpr in modify_trace_bit intel");
R_LOG_ERROR ("xnu_thread_set_gpr in modify_trace_bit intel");
return false;
}
return true;
@ -54,14 +54,14 @@ static bool modify_trace_bit(RDebug *dbg, xnu_thread *th, int enable) {
kr = thread_get_state (th->tid, R_REG_STATE_T,
(thread_state_t)&state, &state_count);
if (kr != KERN_SUCCESS) {
R_LOG_ERROR ("error modify_trace_bit");
R_LOG_ERROR ("modify_trace_bit");
return false;
}
state.srr1 = (state.srr1 & ~0x400UL) | (enable ? 0x400UL : 0);
kr = thread_set_state (th->tid, R_REG_STATE_T,
(thread_state_t)&state, state_count);
if (kr != KERN_SUCCESS) {
R_LOG_ERROR ("Error to set thread state modificy_trace_bit ppc");
R_LOG_ERROR ("set thread state modificy_trace_bit ppc");
return false;
}
return true;
@ -114,7 +114,7 @@ static bool is_thumb_32(ut16 op) {
static bool modify_trace_bit(RDebug *dbg, xnu_thread_t *th, int enable) {
int ret = xnu_thread_get_drx (dbg, th);
if (!ret) {
R_LOG_ERROR ("error to get drx registers modificy_trace_bit arm");
R_LOG_ERROR ("to get drx registers modificy_trace_bit arm");
return false;
}
#if __arm64 || __arm64__ || __aarch64 || __aarch64__
@ -140,7 +140,7 @@ static bool modify_trace_bit(RDebug *dbg, xnu_thread_t *th, int enable) {
R_REG_T *regs;
ret = xnu_thread_get_gpr (dbg, th);
if (!ret) {
R_LOG_ERROR ("error to get gpr register modificy_trace_bit arm");
R_LOG_ERROR ("to get gpr register modificy_trace_bit arm");
return false;
}
regs = (R_REG_T*)&th->gpr;
@ -203,7 +203,7 @@ static bool modify_trace_bit(RDebug *dbg, xnu_thread_t *th, int enable) {
}
//set state
if (!xnu_thread_set_drx (dbg, th)) {
R_LOG_ERROR ("error to set drx modificy_trace_bit arm");
R_LOG_ERROR ("to set drx modificy_trace_bit arm");
return false;
}
return true;
@ -454,18 +454,18 @@ bool xnu_create_exception_thread(RDebug *dbg, int pid) {
}
r_debug_ptrace (dbg, PT_ATTACHEXC, pid, 0, 0);
if (!MACH_PORT_VALID (task_self)) {
eprintf ("error to get the task for the current process"
eprintf ("to get the task for the current process"
" xnu_start_exception_thread\n");
return false;
}
// Allocate an exception port that we will use to track our child process
kr = mach_port_allocate (task_self, MACH_PORT_RIGHT_RECEIVE,
&exception_port);
RETURN_ON_MACH_ERROR ("error to allocate mach_port exception\n", false);
RETURN_ON_MACH_ERROR ("to allocate mach_port exception\n", false);
// Add the ability to send messages on the new exception port
kr = mach_port_insert_right (task_self, exception_port, exception_port,
MACH_MSG_TYPE_MAKE_SEND);
RETURN_ON_MACH_ERROR ("error to allocate insert right\n", false);
RETURN_ON_MACH_ERROR ("allocate insert right", false);
// Atomically swap out (and save) the child process's exception ports
// for the one we just created. We'll want to receive all exceptions.
ex.count = (sizeof (ex.ports) / sizeof (*ex.ports));
@ -477,7 +477,7 @@ bool xnu_create_exception_thread(RDebug *dbg, int pid) {
kr = mach_port_request_notification (task_self, task, MACH_NOTIFY_DEAD_NAME,
0, exception_port, MACH_MSG_TYPE_MAKE_SEND_ONCE, &req_port);
if (kr != KERN_SUCCESS) {
eprintf ("Termination notification request failed\n");
R_LOG_ERROR ("Termination notification request failed");
}
ex.exception_port = exception_port;
return true;

2
libr/debug/trace.c
View File

@ -135,7 +135,7 @@ R_API bool r_debug_trace_ins_after(RDebug *dbg) {
{
ut8 buf[32] = {0};
if (!dbg->iob.read_at (dbg->iob.io, val->base, buf, val->memref)) {
R_LOG_ERROR ("Error reading memory at 0x%"PFMT64x, val->base);
R_LOG_ERROR ("reading memory at 0x%"PFMT64x, val->base);
break;
}

19
libr/egg/egg.c
View File

@ -526,16 +526,15 @@ R_API bool r_egg_shellcode(REgg *egg, const char *name) {
R_API bool r_egg_encode(REgg *egg, const char *name) {
REggPlugin *p;
RListIter *iter;
RBuffer *b;
r_list_foreach (egg->plugins, iter, p) {
if (p->type == R_EGG_PLUGIN_ENCODER && !strcmp (name, p->name)) {
b = p->build (egg);
if (!b) {
return false;
RBuffer *b = p->build (egg);
if (b) {
r_buf_free (egg->bin);
egg->bin = b;
return true;
}
r_buf_free (egg->bin);
egg->bin = b;
return true;
return false;
}
}
return false;
@ -573,11 +572,11 @@ R_API void r_egg_finalize(REgg *egg) {
const ut8 *buf = r_buf_data (ep->b, &sz);
int r = r_buf_write_at (egg->bin, ep->off, buf, sz);
if (r < sz) {
R_LOG_ERROR ("Error during patch");
R_LOG_ERROR ("cannot write");
return;
}
} else {
eprintf ("Cannot patch outside\n");
R_LOG_ERROR ("Cannot patch outside");
return;
}
}
@ -589,6 +588,6 @@ R_API void r_egg_pattern(REgg *egg, int size) {
r_egg_prepend_bytes (egg, (const ut8*)ret, strlen(ret));
free (ret);
} else {
eprintf ("Invalid debruijn pattern length.\n");
R_LOG_ERROR ("Invalid debruijn pattern length");
}
}

9
libr/egg/egg_cfile.c
View File

@ -194,7 +194,7 @@ static struct cEnv_t* r_egg_cfile_set_cEnv(const char *arch, const char *os, int
cEnv->LDFLAGS = strdup (buffer);
if (r_egg_cfile_check_cEnv (cEnv)) {
R_LOG_ERROR ("Error with cEnv allocation!");
R_LOG_ERROR ("invalid cEnv allocation");
goto fail;
}
@ -230,7 +230,7 @@ static bool r_egg_cfile_parseCompiled(const char *file) {
free (fileExt);
fileExt = r_str_newf ("%s.s", file);
if (!r_file_dump (fileExt, (const ut8*) buffer, strlen (buffer), true)) {
R_LOG_ERROR ("Error while opening %s.s", file);
R_LOG_ERROR ("while opening %s.s", file);
goto fail;
}
@ -268,7 +268,7 @@ R_API char* r_egg_cfile_parser(const char *file, const char *arch, const char *o
}
if (!r_file_dump (fileExt, (const ut8*) cEnv->SHDR, strlen (cEnv->SHDR), false)) {
R_LOG_ERROR ("Error while opening %s.s", file);
R_LOG_ERROR ("while opening %s.s", file);
goto fail;
}
@ -286,8 +286,7 @@ R_API char* r_egg_cfile_parser(const char *file, const char *arch, const char *o
// Link
printf ("rabin2 -o '%s.text' -O d/S/'%s' '%s.o'\n", file, cEnv->TEXT, file);
output = r_sys_cmd_strf ("rabin2 -o '%s.text' -O d/S/'%s' '%s'.o",
file, cEnv->TEXT, file);
output = r_sys_cmd_strf ("rabin2 -o '%s.text' -O d/S/'%s' '%s'.o", file, cEnv->TEXT, file);
if (!output) {
eprintf ("Linkage failed!\n");
goto fail;

4
libr/egg/egg_lang.c
View File

@ -1,4 +1,4 @@
/* radare - LGPL - Copyright 2010-2018 - pancake */
/* radare - LGPL - Copyright 2010-2022 - pancake */
#include <r_egg.h>
@ -1020,7 +1020,7 @@ static void rcc_next(REgg *egg) {
if (!strcmp (str, "while")) {
char var[128];
if (egg->lang.lastctxdelta >= 0) {
R_LOG_ERROR ("ERROR: Unsupported while syntax");
R_LOG_ERROR ("Unsupported while syntax");
return;
}
sprintf (var, "__begin_%d_%d_%d\n", egg->lang.nfunctions, CTX, egg->lang.nestedi[CTX - 1]);

2
libr/io/io_cache.c
View File

@ -46,7 +46,7 @@ R_API void r_io_cache_commit(RIO *io, ut64 from, ut64 to) {
if (r_io_write_at (io, r_itv_begin (c->itv), c->data, r_itv_size (c->itv))) {
c->written = true;
} else {
R_LOG_ERROR ("Error writing change at 0x%08"PFMT64x, r_itv_begin (c->itv));
R_LOG_ERROR ("writing change at 0x%08"PFMT64x, r_itv_begin (c->itv));
}
io->cached = cached;
// break; // XXX old behavior, revisit this

2
libr/io/p/io_bochs.c
View File

@ -39,7 +39,7 @@ static RIODesc *__open(RIO *io, const char *file, int rw, int mode) {
fileCfg = strdup (i + 1);
} else {
free (fileCfg);
R_LOG_ERROR ("Error can't find :");
R_LOG_ERROR ("can't find :");
return NULL;
}
riob = R_NEW0 (RIOBochs);

2
libr/io/p/io_procpid.c
View File

@ -73,7 +73,7 @@ static RIODesc *__open(RIO *io, const char *file, int rw, int mode) {
} else if (__waitpid (pid)) {
ret = pid;
} else {
R_LOG_ERROR ("Error in waitpid");
R_LOG_ERROR ("waitpid");
}
} else {
ret = pid;

8
libr/io/p/io_ptrace.c
View File

@ -220,16 +220,16 @@ static RIODesc *__open(RIO *io, const char *file, int rw, int mode) {
ret = r_io_ptrace (io, PTRACE_ATTACH, pid, 0, 0);
if (ret == -1) {
#ifdef __ANDROID__
eprintf ("ptrace_attach: Operation not permitted\n");
R_LOG_ERROR ("ptrace_attach: Operation not permitted");
#else
switch (errno) {
case EPERM:
ret = pid;
eprintf ("ptrace_attach: Operation not permitted\n");
R_LOG_ERROR ("ptrace_attach: Operation not permitted");
break;
case EINVAL:
r_sys_perror ("ptrace: Cannot attach");
eprintf ("ERRNO: %d (EINVAL)\n", errno);
R_LOG_ERROR ("errno: %d (EINVAL)", errno);
break;
default:
break;
@ -239,7 +239,7 @@ static RIODesc *__open(RIO *io, const char *file, int rw, int mode) {
} else if (__waitpid (pid)) {
ret = pid;
} else {
R_LOG_ERROR ("Error in waitpid");
R_LOG_ERROR ("waitpid");
return NULL;
}
}

3
libr/parse/c/libtcc.c
View File

@ -228,8 +228,7 @@ ST_FUNC bool tcc_open_bf(TCCState *s1, const char *filename, int initlen) {
BufferedFile *bf = malloc (sizeof (BufferedFile) + buflen);
if (!bf) {
// err
R_LOG_ERROR ("Error");
R_LOG_ERROR ("too large buflen");
return false;
}
bf->buf_ptr = bf->buffer;

2
libr/socket/socket.c
View File

@ -346,7 +346,7 @@ R_API bool r_socket_connect(RSocket *s, const char *host, const char *port, int
hints.ai_protocol = proto;
int gai = getaddrinfo (host, port, &hints, &res);
if (gai != 0) {
R_LOG_ERROR ("Error in getaddrinfo: %s (%s:%s)",
R_LOG_ERROR ("getaddrinfo: %s (%s:%s)",
gai_strerror (gai), host, port);
return false;
}

2
libr/util/axml.c
View File

@ -314,7 +314,7 @@ R_API char *r_axml_decode(const ut8 *data, const ut64 data_size) {
RBuffer *buffer = r_buf_new_with_pointers (data, data_size, false);
if (!buffer) {
R_LOG_ERROR ("Error allocating RBuffer");
R_LOG_ERROR ("RBuffer allocation");
goto error;
}

1
libr/util/log.c
View File

@ -26,6 +26,7 @@ static R_TH_LOCAL RLog *rlog = NULL;
R_API void r_log_init(void) {
if (!rlog) {
rlog = R_NEW0 (RLog);
rlog->level = R_LOGLVL_DEFAULT;
}
}

2
libr/util/sandbox.c
View File

@ -289,7 +289,7 @@ R_API int r_sandbox_system(const char *x, int n) {
free (argv0);
return rc;
}
R_LOG_ERROR ("Error parsing command arguments");
R_LOG_ERROR ("parsing command arguments");
return -1;
}
#endif

1
sys/lint.sh
View File

@ -14,6 +14,7 @@
(git grep 'r_core_cmd' libr | grep -v /lang/ | grep '\\n') && exit 1
(git grep 'r_str_startswith ("' libr ) && exit 1
(git grep R_LOG | grep '\."' | grep -v sys/) && exit 1
(git grep -i 'R_LOG_ERROR ("ERROR' | grep -v sys) && exit 1
# pending cleanups
# ( git grep 'desc = "[A-Z]' ) && exit 1

2
test/db/tools/ragg2
View File

@ -29,7 +29,7 @@ EXPECT=<<EOF
41414141414141414141
EOF
EXPECT_ERR=<<EOF
Cannot patch outside
ERROR: Cannot patch outside
EOF
RUN