diff --git a/librz/analysis/class.c b/librz/analysis/class.c index 124fa8c4b23..82e7d9ea836 100644 --- a/librz/analysis/class.c +++ b/librz/analysis/class.c @@ -604,7 +604,7 @@ static RzAnalysisClassErr rz_analysis_class_add_attr_unique(RzAnalysis *analysis static char *flagname_method(const char *class_name, const char *meth_name) { if (rz_str_startswith(meth_name, "method.")) { - return rz_str_new(meth_name); + return rz_str_dup(meth_name); } return flagname_attr("method", class_name, meth_name); } @@ -628,9 +628,9 @@ RZ_API void rz_analysis_class_method_recover(RzAnalysis *analysis, RzBinClass *c method.addr = sym->vaddr; method.vtable_offset = -1; RzAnalysisFunction *fcn = rz_analysis_get_function_at(analysis, sym->vaddr); - char *method_name = rz_str_new(sym->name); + char *method_name = rz_str_dup(sym->name); rz_str_split(method_name, '('); - method.name = fcn ? rz_str_new(fcn->name) : rz_str_new(method_name); + method.name = fcn ? rz_str_dup(fcn->name) : rz_str_dup(method_name); // this replace is required due SDB using commas to split the stored data. // some c++ function names might have templates like foo() // which breaks the decoding from the SDB data @@ -675,11 +675,11 @@ RZ_API RzAnalysisClassErr rz_analysis_class_method_get_by_addr(RzAnalysis *analy RzAnalysisMethod *meth; rz_vector_foreach(vec, meth) { if (meth->addr == addr) { - method->name = rz_str_new(meth->name); + method->name = rz_str_dup(meth->name); method->addr = meth->addr; method->method_type = meth->method_type; method->vtable_offset = meth->vtable_offset; - method->real_name = rz_str_new(meth->real_name); + method->real_name = rz_str_dup(meth->real_name); rz_vector_free(vec); return RZ_ANALYSIS_CLASS_ERR_SUCCESS; } @@ -725,7 +725,7 @@ RZ_API RzAnalysisClassErr rz_analysis_class_method_get(RzAnalysis *analysis, con } sdb_anext(cur, NULL); - meth->real_name = rz_str_new(cur); + meth->real_name = rz_str_dup(cur); // this replace is required due SDB using commas to split the stored data. // some c++ function names might have templates like foo() // which breaks the decoding from the SDB data @@ -803,7 +803,7 @@ RZ_API RzAnalysisClassErr rz_analysis_class_method_set(RzAnalysis *analysis, con RZ_API RzAnalysisClassErr rz_analysis_class_method_rename(RzAnalysis *analysis, const char *class_name, const char *old_meth_name, const char *new_meth_name) { RzAnalysisMethod meth; if (rz_analysis_class_method_get(analysis, class_name, old_meth_name, &meth) == RZ_ANALYSIS_CLASS_ERR_SUCCESS) { - meth.real_name = rz_str_new(new_meth_name); + meth.real_name = rz_str_dup(new_meth_name); rz_analysis_class_method_set(analysis, class_name, &meth); rz_analysis_class_method_fini(&meth); } diff --git a/librz/analysis/dwarf_process.c b/librz/analysis/dwarf_process.c index 8c048cb10b6..801861973c6 100644 --- a/librz/analysis/dwarf_process.c +++ b/librz/analysis/dwarf_process.c @@ -1033,7 +1033,7 @@ static void RzType_from_base_type(RzType *t, RzBaseType *b) { rz_return_if_fail(t && b); t->kind = RZ_TYPE_KIND_IDENTIFIER; free(t->identifier.name); - t->identifier.name = rz_str_new(b->name); + t->identifier.name = rz_str_dup(b->name); switch (b->kind) { case RZ_BASE_TYPE_KIND_STRUCT: t->identifier.kind = RZ_TYPE_IDENTIFIER_KIND_STRUCT; @@ -1268,7 +1268,7 @@ static RzType *type_parse_from_abstract_origin(Context *ctx, ut64 offset, char * } const char *prefer_name = select_name(NULL, linkname, name, ctx->unit->language); if (prefer_name && name_out) { - *name_out = rz_str_new(prefer_name); + *name_out = rz_str_dup(prefer_name); } beach: free(name); @@ -2004,7 +2004,7 @@ static bool store_base_type(void *u, const void *k, const void *v) { } free(a->type->identifier.name); char *newname = rz_str_newf("%s_0", name); - a->type->identifier.name = rz_str_new(newname); + a->type->identifier.name = rz_str_dup(newname); update_base_type(analysis->typedb, a); db_save_renamed(analysis->typedb, rz_base_type_clone(b), newname); diff --git a/librz/analysis/pdb_process.c b/librz/analysis/pdb_process.c index 9fb3b727c41..ed10d4e1c78 100644 --- a/librz/analysis/pdb_process.c +++ b/librz/analysis/pdb_process.c @@ -270,7 +270,7 @@ static RzType *type_new_identify(const char *name, RzTypeIdentifierKind k) { return NULL; } t->kind = RZ_TYPE_KIND_IDENTIFIER; - t->identifier.name = rz_str_new(name); + t->identifier.name = rz_str_dup(name); t->identifier.kind = k; return t; } @@ -341,7 +341,7 @@ static RzTypeStructMember *class_member_parse( } case TpiKind_NESTTYPE: { name = rz_bin_pdb_get_type_name(t); - type = nest_parse(typedb, stream, t, rz_str_new(name)); + type = nest_parse(typedb, stream, t, rz_str_dup(name)); break; } case TpiKind_VBCLASS: @@ -527,7 +527,7 @@ static RzTypeUnionMember *union_member_parse(const RzTypeDB *typedb, RzPdbTpiStr } case TpiKind_NESTTYPE: { name = rz_bin_pdb_get_type_name(type_info); - type = nest_parse(typedb, stream, type_info, rz_str_new(name)); + type = nest_parse(typedb, stream, type_info, rz_str_dup(name)); break; } default: diff --git a/librz/analysis/rtti_itanium.c b/librz/analysis/rtti_itanium.c index 0198c73b1fd..a40fa0a34ce 100644 --- a/librz/analysis/rtti_itanium.c +++ b/librz/analysis/rtti_itanium.c @@ -776,16 +776,16 @@ static void recovery_apply_vtable(RVTableContext *context, const char *class_nam meth.addr = vmeth->addr; meth.vtable_offset = vmeth->vtable_offset; RzAnalysisFunction *fcn = rz_analysis_get_function_at(context->analysis, vmeth->addr); - meth.name = fcn ? rz_str_new(fcn->name) : rz_str_newf("virtual_%" PFMT64d, meth.vtable_offset); + meth.name = fcn ? rz_str_dup(fcn->name) : rz_str_newf("virtual_%" PFMT64d, meth.vtable_offset); // Temporarily set as attr name - meth.real_name = fcn ? rz_str_new(fcn->name) : rz_str_newf("virtual_%" PFMT64d, meth.vtable_offset); + meth.real_name = fcn ? rz_str_dup(fcn->name) : rz_str_newf("virtual_%" PFMT64d, meth.vtable_offset); meth.method_type = RZ_ANALYSIS_CLASS_METHOD_VIRTUAL; } else { RzAnalysisMethod exist_meth; if (rz_analysis_class_method_get_by_addr(context->analysis, class_name, vmeth->addr, &exist_meth) == RZ_ANALYSIS_CLASS_ERR_SUCCESS) { meth.addr = vmeth->addr; - meth.name = rz_str_new(exist_meth.name); - meth.real_name = rz_str_new(exist_meth.real_name); + meth.name = rz_str_dup(exist_meth.name); + meth.real_name = rz_str_dup(exist_meth.real_name); meth.vtable_offset = vmeth->vtable_offset; meth.method_type = RZ_ANALYSIS_CLASS_METHOD_VIRTUAL; rz_analysis_class_method_fini(&exist_meth); diff --git a/librz/analysis/rtti_msvc.c b/librz/analysis/rtti_msvc.c index bcdb202d89f..0ab79a79997 100644 --- a/librz/analysis/rtti_msvc.c +++ b/librz/analysis/rtti_msvc.c @@ -830,16 +830,16 @@ static void recovery_apply_vtable(RVTableContext *context, const char *class_nam meth.addr = vmeth->addr; meth.vtable_offset = vmeth->vtable_offset; RzAnalysisFunction *fcn = rz_analysis_get_function_at(context->analysis, vmeth->addr); - meth.name = fcn ? rz_str_new(fcn->name) : rz_str_newf("virtual_%" PFMT64d, meth.vtable_offset); + meth.name = fcn ? rz_str_dup(fcn->name) : rz_str_newf("virtual_%" PFMT64d, meth.vtable_offset); // Temporarily set as attr name - meth.real_name = fcn ? rz_str_new(fcn->name) : rz_str_newf("virtual_%" PFMT64d, meth.vtable_offset); + meth.real_name = fcn ? rz_str_dup(fcn->name) : rz_str_newf("virtual_%" PFMT64d, meth.vtable_offset); meth.method_type = RZ_ANALYSIS_CLASS_METHOD_VIRTUAL; } else { RzAnalysisMethod exist_meth; if (rz_analysis_class_method_get_by_addr(context->analysis, class_name, vmeth->addr, &exist_meth) == RZ_ANALYSIS_CLASS_ERR_SUCCESS) { meth.addr = vmeth->addr; - meth.name = rz_str_new(exist_meth.name); - meth.real_name = rz_str_new(exist_meth.real_name); + meth.name = rz_str_dup(exist_meth.name); + meth.real_name = rz_str_dup(exist_meth.real_name); meth.vtable_offset = vmeth->vtable_offset; meth.method_type = RZ_ANALYSIS_CLASS_METHOD_VIRTUAL; rz_analysis_class_method_fini(&exist_meth); diff --git a/librz/analysis/value.c b/librz/analysis/value.c index 1b63762ce1d..d62314ae6f6 100644 --- a/librz/analysis/value.c +++ b/librz/analysis/value.c @@ -66,7 +66,7 @@ RZ_API int rz_analysis_value_set_ut64(RzAnalysis *analysis, RzAnalysisValue *val RZ_API char *rz_analysis_value_to_string(RzAnalysisValue *value) { char *out = NULL; if (value) { - out = rz_str_new(""); + out = rz_str_dup(""); if (!value->base && !value->reg) { if (value->imm != -1LL) { out = rz_str_appendf(out, "0x%" PFMT64x, value->imm); diff --git a/librz/asm/aop.c b/librz/asm/aop.c index c3798718c03..989064b5b97 100644 --- a/librz/asm/aop.c +++ b/librz/asm/aop.c @@ -71,7 +71,7 @@ RZ_API void rz_asm_op_setf_asm(RZ_NONNULL RzAsmOp *op, RZ_NONNULL const char *fm RZ_API int rz_asm_op_set_hex(RZ_NONNULL RzAsmOp *op, RZ_NONNULL const char *str) { rz_return_val_if_fail(op && str, 0); - ut8 *bin = (ut8 *)rz_str_new(str); + ut8 *bin = (ut8 *)rz_str_dup(str); if (!bin) { return 0; } diff --git a/librz/asm/arch/8051/8051_disas.c b/librz/asm/arch/8051/8051_disas.c index fbac0f51e24..346a5ff71a8 100644 --- a/librz/asm/arch/8051/8051_disas.c +++ b/librz/asm/arch/8051/8051_disas.c @@ -89,7 +89,7 @@ static char *rz_8051_disas(ut64 pc, const ut8 *buf, int len, int *olen) { // op @Ri; op Rn disasm = rz_str_newf(name, buf[0] & mask); } else { - disasm = rz_str_new(name); + disasm = rz_str_dup(name); } break; case 2: diff --git a/librz/asm/arch/luac/v53/disassembly_53.c b/librz/asm/arch/luac/v53/disassembly_53.c index b62d8c2643c..92901414db0 100644 --- a/librz/asm/arch/luac/v53/disassembly_53.c +++ b/librz/asm/arch/luac/v53/disassembly_53.c @@ -120,7 +120,7 @@ int lua53_disasm(RzAsmOp *op, const ut8 *buf, int len, LuaOpNameList opnames) { asm_string = luaop_new_str_1arg(opnames[opcode], ax); break; default: - asm_string = rz_str_new("invalid"); + asm_string = rz_str_dup("invalid"); break; } diff --git a/librz/asm/arch/pyc/opcode_arg_fmt.c b/librz/asm/arch/pyc/opcode_arg_fmt.c index 33a728cce46..f3866d84a2c 100644 --- a/librz/asm/arch/pyc/opcode_arg_fmt.c +++ b/librz/asm/arch/pyc/opcode_arg_fmt.c @@ -25,20 +25,20 @@ const char *format_CALL_FUNCTION_KW_36(ut32 oparg) { } const char *format_CALL_FUNCTION_EX_36(ut32 oparg) { - return rz_str_new((oparg & 0x01) ? "keyword args" : ""); + return rz_str_dup((oparg & 0x01) ? "keyword args" : ""); } static const char *MAKE_FUNCTION_FLAGS[] = { "default", "keyword-only", "annotation", "closure" }; const char *format_MAKE_FUNCTION_arg_36(ut32 oparg) { size_t i; - char *ret = rz_str_new(" "); + char *ret = rz_str_dup(" "); for (i = 0; i < sizeof(MAKE_FUNCTION_FLAGS) / sizeof(char *); ++i) { if (oparg & 0x1) { rz_str_appendf(ret, ", %s", MAKE_FUNCTION_FLAGS[i]); } else { free(ret); - ret = rz_str_new(MAKE_FUNCTION_FLAGS[i]); + ret = rz_str_dup(MAKE_FUNCTION_FLAGS[i]); } oparg >>= 1; } @@ -63,7 +63,7 @@ const char *format_value_flags_36(ut32 oparg) { // empty fmt_spec. ret = ""; } - return rz_str_new(ret); + return rz_str_dup(ret); } const char *format_extended_arg_36(ut32 oparg) { diff --git a/librz/asm/arch/pyc/pyc_dis.c b/librz/asm/arch/pyc/pyc_dis.c index 03096a5f543..4be4cb6c336 100644 --- a/librz/asm/arch/pyc/pyc_dis.c +++ b/librz/asm/arch/pyc/pyc_dis.c @@ -99,7 +99,7 @@ static const char *parse_arg(pyc_opcode_object *op, ut32 oparg, RzList /*data); break; default: - arg = rz_str_new(t->data); + arg = rz_str_dup(t->data); } } if (op->type & HASNAME) { @@ -107,7 +107,7 @@ static const char *parse_arg(pyc_opcode_object *op, ut32 oparg, RzList /*data); + arg = rz_str_dup(t->data); } if ((op->type & HASJREL) || (op->type & HASJABS)) { arg = rz_str_newf("%u", oparg); @@ -116,10 +116,10 @@ static const char *parse_arg(pyc_opcode_object *op, ut32 oparg, RzList /*data); + arg = rz_str_dup(t->data); } if (op->type & HASCOMPARE) { - arg = rz_str_new(cmp_op[oparg]); + arg = rz_str_dup(cmp_op[oparg]); } if (op->type & HASFREE) { if (!cellvars || !freevars) { @@ -139,7 +139,7 @@ static const char *parse_arg(pyc_opcode_object *op, ut32 oparg, RzList /*data); + arg = rz_str_dup(t->data); } if (op->type & HASNARGS) { arg = rz_str_newf("%u", oparg); diff --git a/librz/asm/p/asm_mips_gnu.c b/librz/asm/p/asm_mips_gnu.c index b21f5a51e95..c1c73e29051 100644 --- a/librz/asm/p/asm_mips_gnu.c +++ b/librz/asm/p/asm_mips_gnu.c @@ -74,19 +74,23 @@ static int disassemble(struct rz_asm_t *a, struct rz_asm_op_t *op, const ut8 *bu } else if (!rz_str_casecmp(a->cpu, "mips32")) { ctx->disasm_obj.mach = bfd_mach_mipsisa32; } - pre_cpu = rz_str_dup(pre_cpu, a->cpu); + char *tmp = rz_str_dup(a->cpu); + free(pre_cpu); + pre_cpu = tmp; } if (a->features && (!pre_features || !strcmp(a->features, pre_features))) { free(ctx->disasm_obj.disassembler_options); if (strstr(a->features, "n64")) { - ctx->disasm_obj.disassembler_options = rz_str_new("abi=n64"); + ctx->disasm_obj.disassembler_options = rz_str_dup("abi=n64"); } else if (strstr(a->features, "n32")) { - ctx->disasm_obj.disassembler_options = rz_str_new("abi=n32"); + ctx->disasm_obj.disassembler_options = rz_str_dup("abi=n32"); } else if (strstr(a->features, "o32")) { - ctx->disasm_obj.disassembler_options = rz_str_new("abi=o32"); + ctx->disasm_obj.disassembler_options = rz_str_dup("abi=o32"); } - pre_features = rz_str_dup(pre_features, a->features); + char *tmp = rz_str_dup(a->features); + free(pre_features); + pre_features = tmp; } mips_mode = a->bits; diff --git a/librz/bin/bin.c b/librz/bin/bin.c index f5ae3b1f136..326d167e2dc 100644 --- a/librz/bin/bin.c +++ b/librz/bin/bin.c @@ -940,9 +940,9 @@ RZ_API RzBinField *rz_bin_field_new(ut64 paddr, ut64 vaddr, int size, const char return NULL; } - ptr->name = rz_str_new(name); - ptr->comment = rz_str_new(comment); - ptr->format = rz_str_new(format); + ptr->name = rz_str_dup(name); + ptr->comment = rz_str_dup(comment); + ptr->format = rz_str_dup(format); ptr->format_named = format_named; ptr->paddr = paddr; ptr->size = size; @@ -970,10 +970,10 @@ RZ_API RzBinClassField *rz_bin_class_field_new(ut64 vaddr, ut64 paddr, const cha ptr->vaddr = vaddr ? vaddr : UT64_MAX; ptr->paddr = paddr; - ptr->name = rz_str_new(name); - ptr->classname = rz_str_new(classname); - ptr->libname = rz_str_new(libname); - ptr->type = rz_str_new(type); + ptr->name = rz_str_dup(name); + ptr->classname = rz_str_dup(classname); + ptr->libname = rz_str_dup(libname); + ptr->type = rz_str_dup(type); return ptr; } diff --git a/librz/bin/bobj.c b/librz/bin/bobj.c index f6ab1183703..fdcead99318 100644 --- a/librz/bin/bobj.c +++ b/librz/bin/bobj.c @@ -230,7 +230,7 @@ static RzBinClass *bin_class_new(RzBinObject *o, const char *name, const char *s } c->name = strdup(name); - c->super = rz_str_new(super); + c->super = rz_str_dup(super); c->methods = rz_list_newf((RzListFree)rz_bin_symbol_free); c->fields = rz_list_newf((RzListFree)rz_bin_class_field_free); c->addr = address; @@ -384,7 +384,7 @@ RZ_API RZ_BORROW RzBinSymbol *rz_bin_object_add_method(RZ_NONNULL RzBinObject *o if (!symbol) { return NULL; } - symbol->classname = rz_str_new(klass); + symbol->classname = rz_str_dup(klass); if (!c->methods->sorted) { rz_list_sort(c->methods, (RzListComparator)rz_bin_compare_method); diff --git a/librz/bin/bobj_process_class.c b/librz/bin/bobj_process_class.c index feca9f75ae8..3c557ac28ac 100644 --- a/librz/bin/bobj_process_class.c +++ b/librz/bin/bobj_process_class.c @@ -36,7 +36,7 @@ static void process_class_field(RzBinObject *o, RzBinClassField *field) { static void process_handle_class(RzBinObject *o, RzBinClass *klass) { if (!klass->name) { - klass->name = rz_str_new("unknown_class"); + klass->name = rz_str_dup("unknown_class"); } RzBinClass *found = ht_pp_find(o->name_to_class_object, klass->name, NULL); if (!found) { diff --git a/librz/bin/dwarf/dwarf.c b/librz/bin/dwarf/dwarf.c index 7850b8fecaa..90742f66722 100644 --- a/librz/bin/dwarf/dwarf.c +++ b/librz/bin/dwarf/dwarf.c @@ -114,7 +114,7 @@ static inline RzBinDWARF *dwarf_from_debuglink( if (RZ_STR_ISNOTEMPTY(file_directory) && strlen(file_directory) >= 2 && file_directory[1] == ':') { file_dir = rz_str_newf("/%c%s", file_directory[0], file_directory + 2); } else { - file_dir = rz_str_new(file_directory); + file_dir = rz_str_dup(file_directory); } RzListIter *it = NULL; const char *debug_file_directory = NULL; diff --git a/librz/bin/dwarf/endian_reader.c b/librz/bin/dwarf/endian_reader.c index 6d2e1e65bc0..84bbaeee4df 100644 --- a/librz/bin/dwarf/endian_reader.c +++ b/librz/bin/dwarf/endian_reader.c @@ -15,7 +15,7 @@ RZ_IPI RzBinSection *rz_bin_dwarf_section_by_name(RzBinFile *binfile, const char if (!o || !o->sections || RZ_STR_ISEMPTY(sn)) { return NULL; } - char *name = is_dwo ? rz_str_newf("%s.dwo", sn) : rz_str_new(sn); + char *name = is_dwo ? rz_str_newf("%s.dwo", sn) : rz_str_dup(sn); if (!name) { return NULL; } @@ -145,7 +145,7 @@ RZ_IPI RzBinEndianReader *RzBinEndianReader_from_file(RzBinFile *binfile, const reader->buffer = buf; reader->big_endian = bf_bigendian(binfile); - reader->section_name = rz_str_new(section->name); + reader->section_name = rz_str_dup(section->name); reader->relocations = relocations; return reader; } diff --git a/librz/bin/dwarf/line.c b/librz/bin/dwarf/line.c index bcac8360a06..e4e09742454 100644 --- a/librz/bin/dwarf/line.c +++ b/librz/bin/dwarf/line.c @@ -265,7 +265,7 @@ static char *full_file_path( } else if (dir) { file_path_abs = rz_str_newf("%s/%s", dir, file->path_name); } else { - file_path_abs = rz_str_new(file->path_name); + file_path_abs = rz_str_dup(file->path_name); } return file_path_abs; } diff --git a/librz/bin/format/elf/elf_sections.c b/librz/bin/format/elf/elf_sections.c index ee61668184a..c98a9fef331 100644 --- a/librz/bin/format/elf/elf_sections.c +++ b/librz/bin/format/elf/elf_sections.c @@ -422,7 +422,7 @@ RZ_OWN RzVector /**/ *Elf_(rz_bin_elf_sections_new)(RZ_NONNULL ELFOB RZ_OWN char *Elf_(rz_bin_elf_section_type_to_string)(ut64 type) { for (size_t i = 0; i < RZ_ARRAY_SIZE(type_translation_table); i++) { if (type == type_translation_table[i].type) { - return rz_str_new(type_translation_table[i].name); + return rz_str_dup(type_translation_table[i].name); } } diff --git a/librz/bin/format/elf/elf_symbols.c b/librz/bin/format/elf/elf_symbols.c index 6eabfb4ab56..054b10d4793 100644 --- a/librz/bin/format/elf/elf_symbols.c +++ b/librz/bin/format/elf/elf_symbols.c @@ -196,7 +196,7 @@ static bool is_section_local_symbol(ELFOBJ *bin, Elf_(Sym) * symbol) { static bool set_elf_symbol_name(ELFOBJ *bin, struct symbols_segment *segment, RzBinElfSymbol *elf_symbol, Elf_(Sym) * symbol, RzBinElfSection *section) { if (section && is_section_local_symbol(bin, symbol)) { - elf_symbol->name = rz_str_new(section->name); + elf_symbol->name = rz_str_dup(section->name); return elf_symbol->name; } diff --git a/librz/bin/format/luac/luac_bin.c b/librz/bin/format/luac/luac_bin.c index a3531c53e27..9ee4ed2ac13 100644 --- a/librz/bin/format/luac/luac_bin.c +++ b/librz/bin/format/luac/luac_bin.c @@ -10,7 +10,7 @@ void luac_add_section(RzPVector /**/ *section_vec, char *name, u return; } - bin_sec->name = rz_str_new(name); + bin_sec->name = rz_str_dup(name); bin_sec->vaddr = bin_sec->paddr = offset; bin_sec->size = bin_sec->vsize = size; bin_sec->is_data = false; @@ -36,7 +36,7 @@ void luac_add_symbol(RzList /**/ *symbol_list, char *name, ut64 o return; } - bin_sym->name = rz_str_new(name); + bin_sym->name = rz_str_dup(name); bin_sym->vaddr = bin_sym->paddr = offset; bin_sym->size = size; bin_sym->type = type; @@ -67,7 +67,7 @@ void luac_add_string(RzList /**/ *string_list, char *string, ut64 bin_string->vaddr = offset; bin_string->size = size; bin_string->length = size; - bin_string->string = rz_str_new(string); + bin_string->string = rz_str_dup(string); bin_string->type = RZ_STRING_ENC_UTF8; rz_list_append(string_list, bin_string); @@ -247,7 +247,7 @@ void _luac_build_info(LuaProto *proto, LuacBinInfo *info) { // replace name with current offset proto_name = rz_str_newf("fcn.%08llx", proto->offset); } else { - proto_name = rz_str_new((char *)proto->proto_name); + proto_name = rz_str_dup((char *)proto->proto_name); } // 1.1 set section name as function_name.header diff --git a/librz/bin/format/luac/v53/parse_53.c b/librz/bin/format/luac/v53/parse_53.c index 2264e946f99..9cb179baa9b 100644 --- a/librz/bin/format/luac/v53/parse_53.c +++ b/librz/bin/format/luac/v53/parse_53.c @@ -523,11 +523,11 @@ RzBinInfo *lua_parse_header_53(RzBinFile *bf, st32 major, st32 minor) { if (!(ret = RZ_NEW0(RzBinInfo))) { return NULL; } - ret->file = rz_str_new(bf->file); + ret->file = rz_str_dup(bf->file); ret->type = rz_str_newf("Lua %c.%c compiled file", major + '0', minor + '0'); - ret->bclass = rz_str_new("Lua compiled file"); - ret->rclass = rz_str_new("luac"); - ret->arch = rz_str_new("luac"); + ret->bclass = rz_str_dup("Lua compiled file"); + ret->rclass = rz_str_dup("luac"); + ret->arch = rz_str_dup("luac"); ret->machine = rz_str_newf("Lua %c.%c VM", major + '0', minor + '0'); ret->os = rz_str_newf("%c.%c", major + '0', minor + '0'); ret->cpu = rz_str_newf("%c.%c", major + '0', minor + '0'); @@ -535,10 +535,10 @@ RzBinInfo *lua_parse_header_53(RzBinFile *bf, st32 major, st32 minor) { /* official format ? */ if (luac_format != LUAC_54_FORMAT) { - ret->compiler = rz_str_new("Unofficial Lua Compiler"); + ret->compiler = rz_str_dup("Unofficial Lua Compiler"); return ret; } - ret->compiler = rz_str_new("Official Lua Compiler"); + ret->compiler = rz_str_dup("Official Lua Compiler"); /* Check Size */ // TODO : remove this check and process different compiler options @@ -566,7 +566,7 @@ RzBinInfo *lua_parse_header_53(RzBinFile *bf, st32 major, st32 minor) { lua_parse_string(buffer, ((ut8 **)&(src_file_name)), &name_len, LUAC_FILENAME_OFFSET, bf->size); /* put source file info into GUID */ - ret->guid = rz_str_new(src_file_name ? src_file_name : "stripped"); + ret->guid = rz_str_dup(src_file_name ? src_file_name : "stripped"); free(src_file_name); return ret; diff --git a/librz/bin/format/luac/v54/parse_54.c b/librz/bin/format/luac/v54/parse_54.c index 57275c7ebc6..660d033faa1 100644 --- a/librz/bin/format/luac/v54/parse_54.c +++ b/librz/bin/format/luac/v54/parse_54.c @@ -520,11 +520,11 @@ RzBinInfo *lua_parse_header_54(RzBinFile *bf, st32 major, st32 minor) { if (!(ret = RZ_NEW0(RzBinInfo))) { return NULL; } - ret->file = rz_str_new(bf->file); + ret->file = rz_str_dup(bf->file); ret->type = rz_str_newf("Lua %c.%c compiled file", major + '0', minor + '0'); - ret->bclass = rz_str_new("Lua compiled file"); - ret->rclass = rz_str_new("luac"); - ret->arch = rz_str_new("luac"); + ret->bclass = rz_str_dup("Lua compiled file"); + ret->rclass = rz_str_dup("luac"); + ret->arch = rz_str_dup("luac"); ret->machine = rz_str_newf("Lua %c.%c VM", major + '0', minor + '0'); ret->os = rz_str_newf("%c.%c", major + '0', minor + '0'); ret->cpu = rz_str_newf("%c.%c", major + '0', minor + '0'); @@ -532,10 +532,10 @@ RzBinInfo *lua_parse_header_54(RzBinFile *bf, st32 major, st32 minor) { /* official format ? */ if (luac_format != LUAC_54_FORMAT) { - ret->compiler = rz_str_new("Unofficial Lua Compiler"); + ret->compiler = rz_str_dup("Unofficial Lua Compiler"); return ret; } - ret->compiler = rz_str_new("Official Lua Compiler"); + ret->compiler = rz_str_dup("Official Lua Compiler"); /* Check Size */ if ((instruction_size != sizeof(LUA_INSTRUCTION)) || @@ -560,7 +560,7 @@ RzBinInfo *lua_parse_header_54(RzBinFile *bf, st32 major, st32 minor) { lua_parse_string(buffer, ((ut8 **)&(src_file_name)), &name_len, LUAC_FILENAME_OFFSET, bf->size); /* put source file info into GUID */ - ret->guid = rz_str_new(src_file_name ? src_file_name : "stripped"); + ret->guid = rz_str_dup(src_file_name ? src_file_name : "stripped"); free(src_file_name); return ret; diff --git a/librz/bin/format/mach0/mach0.c b/librz/bin/format/mach0/mach0.c index a35e33f8d93..41218c0e66d 100644 --- a/librz/bin/format/mach0/mach0.c +++ b/librz/bin/format/mach0/mach0.c @@ -2102,29 +2102,29 @@ RzPVector /**/ *MACH0_(get_segments)(RzBinFile *bf) { char *MACH0_(section_type_to_string)(ut64 type) { switch (type) { case S_REGULAR: - return rz_str_new("REGULAR"); + return rz_str_dup("REGULAR"); case S_ZEROFILL: - return rz_str_new("ZEROFILL"); + return rz_str_dup("ZEROFILL"); case S_CSTRING_LITERALS: - return rz_str_new("CSTRING_LITERALS"); + return rz_str_dup("CSTRING_LITERALS"); case S_4BYTE_LITERALS: - return rz_str_new("4BYTE_LITERALS"); + return rz_str_dup("4BYTE_LITERALS"); case S_LITERAL_POINTERS: - return rz_str_new("LITERAL_POINTERS"); + return rz_str_dup("LITERAL_POINTERS"); case S_NON_LAZY_SYMBOL_POINTERS: - return rz_str_new("NON_LAZY_SYMBOL_POINTERS"); + return rz_str_dup("NON_LAZY_SYMBOL_POINTERS"); case S_LAZY_SYMBOL_POINTERS: - return rz_str_new("LAZY_SYMBOL_POINTERS"); + return rz_str_dup("LAZY_SYMBOL_POINTERS"); case S_SYMBOL_STUBS: - return rz_str_new("SYMBOL_STUBS"); + return rz_str_dup("SYMBOL_STUBS"); case S_MOD_INIT_FUNC_POINTERS: - return rz_str_new("MOD_INIT_FUNC_POINTERS"); + return rz_str_dup("MOD_INIT_FUNC_POINTERS"); case S_MOD_TERM_FUNC_POINTERS: - return rz_str_new("MOD_TERM_FUNC_POINTERS"); + return rz_str_dup("MOD_TERM_FUNC_POINTERS"); case S_COALESCED: - return rz_str_new("COALESCED"); + return rz_str_dup("COALESCED"); case S_GB_ZEROFILL: - return rz_str_new("GB_ZEROFILL"); + return rz_str_dup("GB_ZEROFILL"); default: return rz_str_newf("0x%" PFMT64x, type); } @@ -2843,9 +2843,9 @@ ut64 MACH0_(get_baddr)(struct MACH0_(obj_t) * bin) { char *MACH0_(get_class)(struct MACH0_(obj_t) * bin) { #if RZ_BIN_MACH064 - return rz_str_new("MACH064"); + return rz_str_dup("MACH064"); #else - return rz_str_new("MACH0"); + return rz_str_dup("MACH0"); #endif } diff --git a/librz/bin/format/pyc/marshal.c b/librz/bin/format/pyc/marshal.c index fefc575523b..4a0a0dbbfe6 100644 --- a/librz/bin/format/pyc/marshal.c +++ b/librz/bin/format/pyc/marshal.c @@ -438,7 +438,7 @@ static bool add_string_to_cache(RzBinPycObj *pyc, ut64 addr, const char *data, u string->length = length; string->ordinal = 0; string->type = type; - string->string = rz_str_new(data); + string->string = rz_str_dup(data); if (!rz_pvector_push(pyc->strings_cache, string)) { return false; } diff --git a/librz/bin/format/xnu/rz_cf_dict.c b/librz/bin/format/xnu/rz_cf_dict.c index 9ab9689665b..8d9b58edfad 100644 --- a/librz/bin/format/xnu/rz_cf_dict.c +++ b/librz/bin/format/xnu/rz_cf_dict.c @@ -322,7 +322,7 @@ RZ_API RzCFValueDict *rz_cf_value_dict_parse(RzBuffer *file_buf, ut64 offset, ut break; } if (!content) { - content = rz_str_new(x.data); + content = rz_str_dup(x.data); } else { content = rz_str_append(content, x.data); } @@ -701,7 +701,7 @@ static RzCFValue *rz_cf_value_clone(RzCFValue *value) { RzListIter *iter; RzCFKeyValue *item; rz_list_foreach (((RzCFValueDict *)value)->pairs, iter, item) { - char *key = rz_str_new(item->key); + char *key = rz_str_dup(item->key); if (key) { RzCFValue *clone = rz_cf_value_clone(item->value); if (clone) { @@ -742,7 +742,7 @@ static RzCFValue *rz_cf_value_clone(RzCFValue *value) { case RZ_CF_STRING: { RzCFValueString *string = RZ_NEW0(RzCFValueString); if (string) { - string->value = rz_str_new(((RzCFValueString *)value)->value); + string->value = rz_str_dup(((RzCFValueString *)value)->value); if (string->value) { copy = (RzCFValue *)string; } else { diff --git a/librz/bin/p/bin_elf.inc b/librz/bin/p/bin_elf.inc index 1f27c8add54..1a23bf7fee3 100644 --- a/librz/bin/p/bin_elf.inc +++ b/librz/bin/p/bin_elf.inc @@ -496,7 +496,7 @@ static RzBinSymbol *convert_symbol(ELFOBJ *bin, RzBinElfSymbol *elf_symbol) { result->paddr = elf_symbol->paddr; result->vaddr = elf_symbol->vaddr; - result->name = rz_str_new(elf_symbol->name); + result->name = rz_str_dup(elf_symbol->name); result->forwarder = "NONE"; result->bind = elf_symbol->bind; result->type = elf_symbol->type; @@ -526,7 +526,7 @@ static RzBinImport *convert_import(RzBinElfSymbol *symbol) { return NULL; } - result->name = rz_str_new(symbol->name); + result->name = rz_str_dup(symbol->name); result->bind = symbol->bind; result->type = symbol->type; result->ordinal = symbol->ordinal; @@ -707,7 +707,7 @@ static RzPVector /**/ *maps_unpatched(RzBinFile *bf) { break; } - map->name = rz_str_new(section->name); + map->name = rz_str_dup(section->name); map->paddr = section->offset; map->psize = section->type != SHT_NOBITS ? section->size : 0; map->vsize = section->size; @@ -1623,9 +1623,9 @@ static RzPVector /**/ *sections(RzBinFile *bf) { if (!(ptr = RZ_NEW0(RzBinSection))) { break; } - ptr->name = rz_str_new(section->name); + ptr->name = rz_str_dup(section->name); if (!ptr->name) { - ptr->name = rz_str_new(""); + ptr->name = rz_str_dup(""); } if (strstr(ptr->name, "data") && !strstr(ptr->name, "rel") && !strstr(ptr->name, "pydata")) { ptr->is_data = true; diff --git a/librz/bin/p/bin_mach0.c b/librz/bin/p/bin_mach0.c index cfdb023f063..e846dcd2499 100644 --- a/librz/bin/p/bin_mach0.c +++ b/librz/bin/p/bin_mach0.c @@ -36,7 +36,7 @@ static char *entitlements(RzBinFile *bf, bool json) { pj_s(pj, (const char *)bin->signature); return pj_drain(pj); } else { - return rz_str_dup(NULL, (const char *)bin->signature); + return rz_str_dup((const char *)bin->signature); } } @@ -465,8 +465,8 @@ static RzBinInfo *info(RzBinFile *bf) { ret->dbg_info = bin->dbg_info; ret->lang = bin->lang; } - ret->intrp = rz_str_dup(NULL, MACH0_(get_intrp)(bf->o->bin_obj)); - ret->compiler = rz_str_dup(NULL, ""); + ret->intrp = rz_str_dup(MACH0_(get_intrp)(bf->o->bin_obj)); + ret->compiler = rz_str_dup(""); ret->rclass = strdup("mach0"); ret->os = strdup("darwin"); ret->subsystem = strdup(MACH0_(get_platform)(bf->o->bin_obj)); diff --git a/librz/bin/p/bin_qnx.c b/librz/bin/p/bin_qnx.c index 56ffa929380..d55c252d8b5 100644 --- a/librz/bin/p/bin_qnx.c +++ b/librz/bin/p/bin_qnx.c @@ -368,7 +368,7 @@ static char *signature(RzBinFile *bf, bool json) { pj_n(pj, qo->rwend.signature); return pj_drain(pj); } else { - return rz_str_dup(NULL, sdb_itoa(qo->rwend.signature, buf, 10)); + return rz_str_dup(sdb_itoa(qo->rwend.signature, buf, 10)); } } diff --git a/librz/core/casm.c b/librz/core/casm.c index 405c001f5ae..861ced1d6f1 100644 --- a/librz/core/casm.c +++ b/librz/core/casm.c @@ -300,7 +300,7 @@ RZ_API RzList /**/ *rz_core_asm_strsearch(RzCore *core, const ch } rz_asm_disassemble(core->rasm, &op, buf + addrbytes * idx, core->blocksize - addrbytes * idx); - hit->code = rz_str_new(rz_strbuf_get(&op.buf_asm)); + hit->code = rz_str_dup(rz_strbuf_get(&op.buf_asm)); rz_asm_op_fini(&op); rz_analysis_op_fini(&aop); idx = (matchcount) ? tidx + 1 : idx + 1; diff --git a/librz/core/cbin.c b/librz/core/cbin.c index 87c5314c934..5220922a783 100644 --- a/librz/core/cbin.c +++ b/librz/core/cbin.c @@ -531,7 +531,7 @@ RZ_API bool rz_core_bin_apply_strings(RzCore *r, RzBinFile *binfile) { break; } rz_meta_set_with_subtype(r->analysis, RZ_META_TYPE_STRING, string->type, vaddr, string->size, string->string); - char *f_name = rz_str_new(string->string); + char *f_name = rz_str_dup(string->string); rz_name_filter(f_name, -1, true); char *str; if (r->bin->prefix) { @@ -657,7 +657,7 @@ static inline RzBinDWARF *load_dwarf(RzCore *core, RzBinFile *binfile) { if (rz_config_get_b(core->config, "bin.dbginfo.debuginfod")) { char *debuginfod_urls = (char *)rz_config_get(core->config, "bin.dbginfo.debuginfod_urls"); if (RZ_STR_ISNOTEMPTY(debuginfod_urls)) { - debuginfod_urls = rz_str_new(debuginfod_urls); + debuginfod_urls = rz_str_dup(debuginfod_urls); } else { debuginfod_urls = rz_sys_getenv("DEBUGINFOD_URLS"); } @@ -1357,10 +1357,10 @@ RZ_API void rz_core_sym_name_init(RZ_NONNULL RZ_OUT RzBinSymNames *names, RZ_NON const char *name = demangle && symbol->dname ? symbol->dname : symbol->name; names->name = rz_str_newf("%s%s", symbol->is_imported ? "imp." : "", name); - names->libname = rz_str_new(symbol->libname); + names->libname = rz_str_dup(symbol->libname); names->nameflag = construct_symbol_flagname(symbol, symbol->name); if (RZ_STR_ISNOTEMPTY(symbol->classname)) { - names->classname = rz_str_new(symbol->classname); + names->classname = rz_str_dup(symbol->classname); names->classflag = rz_str_newf("sym.%s.%s", names->classname, names->name); rz_name_filter(names->classflag, -1, true); names->methname = rz_str_newf("%s::%s", names->classname, name); diff --git a/librz/core/cmd/cmd_eval.c b/librz/core/cmd/cmd_eval.c index cace6d9f8f9..f1c2cbb8749 100644 --- a/librz/core/cmd/cmd_eval.c +++ b/librz/core/cmd/cmd_eval.c @@ -59,11 +59,14 @@ RZ_API bool rz_core_theme_load(RzCore *core, const char *name) { return false; } if (!rz_str_cmp(name, "default", strlen(name))) { - core->curtheme = rz_str_dup(core->curtheme, name); + char *tmp = rz_str_dup(name); + free(core->curtheme); + core->curtheme = tmp; rz_cons_pal_init(core->cons->context); return true; } + char *tmp = NULL; char *home_themes = rz_path_home_prefix(RZ_THEMES); char *system_themes = rz_path_system(RZ_THEMES); char *extra_themes = rz_path_extra(RZ_THEMES); @@ -95,7 +98,9 @@ RZ_API bool rz_core_theme_load(RzCore *core, const char *name) { goto fail; success: - core->curtheme = rz_str_dup(core->curtheme, name); + tmp = rz_str_dup(name); + free(core->curtheme); + core->curtheme = tmp; fail: free(home_file); free(system_file); diff --git a/librz/core/cmd/cmd_print.c b/librz/core/cmd/cmd_print.c index 7dd9b916c14..f5d6ac98147 100644 --- a/librz/core/cmd/cmd_print.c +++ b/librz/core/cmd/cmd_print.c @@ -787,7 +787,9 @@ RZ_IPI RzCmdStatus rz_cmd_print_gadget_add_handler(RzCore *core, int argc, const int w = argc > 4 ? rz_num_math(core->num, argv[3]) : 1; int h = argc > 5 ? rz_num_math(core->num, argv[4]) : 1; if (x && y && w && h) { - cmd = rz_str_dup(cmd, argv[argc - 1]); + char *tmp = rz_str_dup(argv[argc - 1]); + free(cmd); + cmd = tmp; if (cmd) { RzCoreGadget *g = RZ_NEW0(RzCoreGadget); g->x = x; diff --git a/librz/core/core.c b/librz/core/core.c index b88a881b59d..0cac8505bdc 100644 --- a/librz/core/core.c +++ b/librz/core/core.c @@ -1051,7 +1051,7 @@ static void autocomplete_process_path(RzLineCompletion *completion, const char * goto out; } - lpath = rz_str_new(path); + lpath = rz_str_dup(path); #if __WINDOWS__ rz_str_replace_ch(lpath, '/', '\\', true); #endif @@ -1062,7 +1062,7 @@ static void autocomplete_process_path(RzLineCompletion *completion, const char * #if __WINDOWS__ dirname = strdup("\\.\\"); #else - dirname = rz_str_new(RZ_SYS_DIR); + dirname = rz_str_dup(RZ_SYS_DIR); #endif } else if (lpath[0] == '~' && lpath[1]) { // ~/xxx/yyy dirname = rz_str_home(lpath + 2); @@ -1083,10 +1083,10 @@ static void autocomplete_process_path(RzLineCompletion *completion, const char * #endif dirname = rz_str_newf(fmt, RZ_SYS_DIR, lpath, RZ_SYS_DIR); } - basename = rz_str_new(p + 1); + basename = rz_str_dup(p + 1); } else { // xxx dirname = rz_str_newf(".%s", RZ_SYS_DIR); - basename = rz_str_new(lpath); + basename = rz_str_dup(lpath); } if (!dirname || !basename) { @@ -1126,9 +1126,9 @@ static void autocompleteFilename(RzLineCompletion *completion, RzLineBuffer *buf int n = 0, i = 0; char *pipe = strchr(buf->data, '>'); if (pipe) { - args = rz_str_new(pipe + 1); + args = rz_str_dup(pipe + 1); } else { - args = rz_str_new(buf->data); + args = rz_str_dup(buf->data); } if (!args) { goto out; @@ -1139,7 +1139,7 @@ static void autocompleteFilename(RzLineCompletion *completion, RzLineBuffer *buf goto out; } - input = rz_str_new(rz_str_word_get0(args, narg)); + input = rz_str_dup(rz_str_word_get0(args, narg)); if (!input) { goto out; } @@ -1258,7 +1258,7 @@ static void autocomplete_sdb(RzCore *core, RzLineCompletion *completion, const c if (pipe) { str = rz_str_trim_head_ro(pipe + 1); } - lpath = rz_str_new(str); + lpath = rz_str_dup(str); p1 = strchr(lpath, '/'); if (p1) { *p1 = 0; diff --git a/librz/core/disasm.c b/librz/core/disasm.c index 7e7bbbbf6cd..02286a40cd2 100644 --- a/librz/core/disasm.c +++ b/librz/core/disasm.c @@ -4082,7 +4082,7 @@ static void ds_print_ptr(RzDisasmState *ds, int len, int idx) { f = rz_flag_get_i(core->flags, refaddr); if (f) { if (strlen(msg) != 1) { - char *msg2 = rz_str_new(msg); + char *msg2 = rz_str_dup(msg); if (msg2) { rz_str_filter(msg2); if (!strncmp(msg2, "UH..", 4)) { @@ -6632,7 +6632,7 @@ RZ_API RZ_OWN char *rz_core_disasm_instruction(RzCore *core, ut64 addr, ut64 rel free(param); return colored_asm ? rz_strbuf_drain(colored_asm) : NULL; } else { - buf_asm = rz_str_new(str); + buf_asm = rz_str_dup(str); } return buf_asm; } diff --git a/librz/core/linux_heap_glibc.c b/librz/core/linux_heap_glibc.c index 55b987a9c87..375f226dafb 100644 --- a/librz/core/linux_heap_glibc.c +++ b/librz/core/linux_heap_glibc.c @@ -908,7 +908,7 @@ RZ_API RzHeapBin *GH(rz_heap_fastbin_content)(RzCore *core, MallocState *main_ar heap_bin->chunks = rz_list_newf((RzListFree)GH(rz_heap_chunk_free)); heap_bin->bin_num = bin_num + 1; heap_bin->size = FASTBIN_IDX_TO_SIZE(bin_num + 1); - heap_bin->type = rz_str_new("Fast"); + heap_bin->type = rz_str_dup("Fast"); GHT next = main_arena->fastbinsY[bin_num]; if (!next) { free(cnk); @@ -930,7 +930,7 @@ RZ_API RzHeapBin *GH(rz_heap_fastbin_content)(RzCore *core, MallocState *main_ar break; } item->addr = next; - item->status = rz_str_new("free"); + item->status = rz_str_dup("free"); rz_list_append(heap_bin->chunks, item); while (double_free == GHT_MAX && next_tmp && next_tmp >= brk_start && next_tmp <= main_arena->top) { rz_io_read_at(core->io, next_tmp, (ut8 *)cnk, sizeof(GH(RzHeapChunk))); @@ -948,7 +948,7 @@ RZ_API RzHeapBin *GH(rz_heap_fastbin_content)(RzCore *core, MallocState *main_ar if (cnk->prev_size > size || ((cnk->size >> 3) << 3) > size) { char message[50]; rz_snprintf(message, 50, "Linked list corrupted @ 0x%" PFMT64x, (ut64)next); - heap_bin->message = rz_str_new(message); + heap_bin->message = rz_str_dup(message); free(cnk); return heap_bin; } @@ -957,7 +957,7 @@ RZ_API RzHeapBin *GH(rz_heap_fastbin_content)(RzCore *core, MallocState *main_ar if (double_free == next) { char message[50]; rz_snprintf(message, 50, "Double free detected @ 0x%" PFMT64x, (ut64)next); - heap_bin->message = rz_str_new(message); + heap_bin->message = rz_str_dup(message); free(cnk); return heap_bin; } @@ -965,7 +965,7 @@ RZ_API RzHeapBin *GH(rz_heap_fastbin_content)(RzCore *core, MallocState *main_ar if (next && (next < brk_start || next >= main_arena->top)) { char message[50]; rz_snprintf(message, 50, "Linked list corrupted @ 0x%" PFMT64x, (ut64)next); - heap_bin->message = rz_str_new(message); + heap_bin->message = rz_str_dup(message); free(cnk); return heap_bin; } @@ -1160,7 +1160,7 @@ RZ_API RzList /**/ *GH(rz_heap_tcache_content)(RzCore *core, GHT ar if (!bin) { goto error; } - bin->type = rz_str_new("Tcache"); + bin->type = rz_str_dup("Tcache"); bin->bin_num = i; bin->chunks = rz_list_newf((RzListFree)GH(rz_heap_chunk_free)); rz_list_append(tcache_bins_list, bin); @@ -1414,11 +1414,11 @@ void GH(print_malloc_info)(RzCore *core, GHT m_state, GHT malloc_state) { char *GH(rz_bin_num_to_type)(int bin_num) { if (bin_num == 0) { - return rz_str_new("Unsorted"); + return rz_str_dup("Unsorted"); } else if (bin_num >= 1 && bin_num <= NSMALLBINS - 1) { - return rz_str_new("Small"); + return rz_str_dup("Small"); } else if (bin_num >= NSMALLBINS && bin_num <= NBINS - 2) { - return rz_str_new("Large"); + return rz_str_dup("Large"); } return NULL; } @@ -1499,7 +1499,7 @@ RZ_API RzHeapBin *GH(rz_heap_bin_content)(RzCore *core, MallocState *main_arena, bin->addr = base; while (fw != head->fd) { if (fw > main_arena->top || fw < initial_brk) { - bin->message = rz_str_new("Corrupted list"); + bin->message = rz_str_dup("Corrupted list"); break; } rz_io_read_at(core->io, fw, (ut8 *)cnk, sizeof(GH(RzHeapChunk))); @@ -1754,7 +1754,7 @@ RZ_API RzList /**/ *GH(rz_heap_arenas_list)(RzCore *core, GHT return arena_list; } item->addr = m_arena; - item->type = rz_str_new("Main"); + item->type = rz_str_dup("Main"); item->arena = ta; rz_list_append(arena_list, item); if (main_arena->next != m_arena) { @@ -1773,7 +1773,7 @@ RZ_API RzList /**/ *GH(rz_heap_arenas_list)(RzCore *core, GHT break; } item->addr = ta_addr; - item->type = rz_str_new("Thread"); + item->type = rz_str_dup("Thread"); item->arena = ta; rz_list_append(arena_list, item); } @@ -1858,7 +1858,7 @@ RZ_API RzList /**/ *GH(rz_heap_chunks_list)(RzCore *core, break; } block->addr = next_chunk; - block->status = rz_str_new("corrupted"); + block->status = rz_str_dup("corrupted"); block->size = size_tmp; rz_list_append(chunks, block); break; @@ -1959,7 +1959,7 @@ RZ_API RzList /**/ *GH(rz_heap_chunks_list)(RzCore *core, if (!block) { break; } - char *status = rz_str_new("allocated"); + char *status = rz_str_dup("allocated"); if (fastbin) { if (is_free) { strcpy(status, "free"); @@ -1982,7 +1982,7 @@ RZ_API RzList /**/ *GH(rz_heap_chunks_list)(RzCore *core, RzHeapChunkListItem *block = RZ_NEW0(RzHeapChunkListItem); if (block) { block->addr = main_arena->top; - block->status = rz_str_new("free (top)"); + block->status = rz_str_dup("free (top)"); RzHeapChunkSimple *chunkSimple = GH(rz_heap_chunk_wrapper)(core, main_arena->top); if (chunkSimple) { block->size = chunkSimple->size; @@ -2104,7 +2104,7 @@ RZ_IPI RzCmdStatus GH(rz_cmd_heap_chunks_print_handler)(RzCore *core, int argc, RzANode *top = RZ_EMPTY, *chunk_node = RZ_EMPTY, *prev_node = RZ_EMPTY; char *top_title = NULL, *top_data = NULL, *node_title = NULL, *node_data = NULL; bool first_node = true; - top_data = rz_str_new(""); + top_data = rz_str_dup(""); RzList *chunks = GH(rz_heap_chunks_list)(core, main_arena, m_arena, m_state, false); if (mode == RZ_OUTPUT_MODE_JSON) { if (!pj) { diff --git a/librz/core/tui/config.c b/librz/core/tui/config.c index 8b585b72a76..643d1c63bd3 100644 --- a/librz/core/tui/config.c +++ b/librz/core/tui/config.c @@ -36,7 +36,9 @@ static void config_visual_hit(RzCore *core, const char *name, int editor) { // XXX: must use config_set () to run callbacks! if (editor) { char *buf = rz_core_editor(core, NULL, node->value); - node->value = rz_str_dup(node->value, buf); + char *tmp = rz_str_dup(buf); + free(node->value); + node->value = tmp; free(buf); } else { // FGETS AND SO diff --git a/librz/core/tui/panels.c b/librz/core/tui/panels.c index 631d4aef065..e821a7696f2 100644 --- a/librz/core/tui/panels.c +++ b/librz/core/tui/panels.c @@ -792,7 +792,7 @@ bool __check_panel_type(RzPanel *panel, const char *type) { if (!panel->model->cmd || !type) { return false; } - char *tmp = rz_str_new(panel->model->cmd); + char *tmp = rz_str_dup(panel->model->cmd); int n = rz_str_split(tmp, ' '); if (!n) { free(tmp); @@ -891,7 +891,7 @@ void __set_cmd_str_cache(RzCore *core, RzPanel *p, char *s) { void __set_read_only(RzCore *core, RzPanel *p, char *s) { free(p->model->readOnly); - p->model->readOnly = rz_str_new(s); + p->model->readOnly = rz_str_dup(s); __set_dcb(core, p); __set_pcb(p); } @@ -2846,8 +2846,12 @@ void __replace_cmd(RzCore *core, const char *title, const char *cmd) { RzPanel *cur = __get_cur_panel(panels); __free_panel_model(cur); cur->model = RZ_NEW0(RzPanelModel); - cur->model->title = rz_str_dup(cur->model->title, title); - cur->model->cmd = rz_str_dup(cur->model->cmd, cmd); + char *tmp = rz_str_dup(title); + free(cur->model->title); + cur->model->title = tmp; + tmp = rz_str_dup(cmd); + free(cur->model->cmd); + cur->model->cmd = tmp; __set_cmd_str_cache(core, cur, NULL); __set_panel_addr(core, cur, core->offset); cur->model->type = PANEL_TYPE_DEFAULT; @@ -2908,7 +2912,9 @@ bool __check_func_diff(RzCore *core, RzPanel *p) { return true; } if (!p->model->funcName || strcmp(p->model->funcName, func->name)) { - p->model->funcName = rz_str_dup(p->model->funcName, func->name); + char *tmp = rz_str_dup(func->name); + free(p->model->cmd); + p->model->cmd = tmp; return true; } return false; @@ -3007,18 +3013,32 @@ void __init_panel_param(RzCore *core, RzPanel *p, const char *title, const char v->refresh = true; v->edge = 0; if (title) { - m->title = rz_str_dup(m->title, title); + char *tmp = rz_str_dup(title); + free(m->title); + m->title = tmp; if (cmd) { - m->cmd = rz_str_dup(m->cmd, cmd); + char *tmp = rz_str_dup(cmd); + free(m->cmd); + m->cmd = tmp; } else { - m->cmd = rz_str_dup(m->cmd, ""); + char *tmp = rz_str_dup(""); + free(m->cmd); + m->cmd = tmp; } } else if (cmd) { - m->title = rz_str_dup(m->title, cmd); - m->cmd = rz_str_dup(m->cmd, cmd); + char *tmp = rz_str_dup(cmd); + free(m->title); + m->title = tmp; + tmp = rz_str_dup(cmd); + free(m->cmd); + m->cmd = tmp; } else { - m->title = rz_str_dup(m->title, ""); - m->cmd = rz_str_dup(m->cmd, ""); + char *tmp = rz_str_dup(""); + free(m->title); + m->title = tmp; + tmp = rz_str_dup(""); + free(m->cmd); + m->cmd = tmp; } __set_pcb(p); if (RZ_STR_ISNOTEMPTY(m->cmd)) { @@ -3538,8 +3558,12 @@ void __update_help(RzCore *core, RzPanels *ps) { msg = help_msg_panels; break; } - p->model->title = rz_str_dup(p->model->title, cmd); - p->model->cmd = rz_str_dup(p->model->cmd, cmd); + char *tmp = rz_str_dup(cmd); + free(p->model->title); + p->model->title = tmp; + tmp = rz_str_dup(cmd); + free(p->model->cmd); + p->model->cmd = tmp; rz_core_visual_append_help(rsb, title, msg); if (!rsb) { return; @@ -4196,7 +4220,7 @@ void __add_menu(RzCore *core, const char *parent, const char *name, RzPanelsMenu } item->n_sub = 0; item->selectedIndex = 0; - item->name = name ? rz_str_new(name) : NULL; + item->name = name ? rz_str_dup(name) : NULL; item->sub = NULL; item->cb = cb; item->p = RZ_NEW0(RzPanel); @@ -4976,7 +5000,7 @@ void __init_almighty_db(RzCore *core) { SdbList *sdb_list = sdb_foreach_list(visual->panels->db, true); ls_foreach (sdb_list, sdb_iter, kv) { const char *key = sdbkv_key(kv); - sdb_ptr_set(db, rz_str_new(key), &__create_panel_db, 0); + sdb_ptr_set(db, rz_str_dup(key), &__create_panel_db, 0); } sdb_ptr_set(db, "Search strings in data sections", &__search_strings_data_create, 0); sdb_ptr_set(db, "Search strings in the whole bin", &__search_strings_bin_create, 0); @@ -5511,8 +5535,12 @@ RZ_IPI bool rz_load_panels_layout(RzCore *core, const char *_name) { __set_geometry(&p->view->pos, x, y, w, h); __init_panel_param(core, p, title, cmd); if (rz_str_endswith(cmd, "Help")) { - p->model->title = rz_str_dup(p->model->title, "Help"); - p->model->cmd = rz_str_dup(p->model->cmd, "Help"); + char *tmp = rz_str_dup("Help"); + free(p->model->title); + p->model->title = tmp; + tmp = rz_str_dup("Help"); + free(p->model->cmd); + p->model->cmd = tmp; RzStrBuf *rsb = rz_strbuf_new(NULL); rz_core_visual_append_help(rsb, "Visual Ascii Art Panels", help_msg_panels); if (!rsb) { @@ -5975,7 +6003,9 @@ void __rotate_panel_cmds(RzCore *core, const char **cmds, const int cmdslen, con snprintf(replace, sizeof(replace), "%s%s", prefix, between); p->model->cmd = rz_str_replace(p->model->cmd, replace, tmp, 1); } else { - p->model->cmd = rz_str_dup(p->model->cmd, tmp); + char *tmp1 = rz_str_dup(tmp); + free(p->model->cmd); + p->model->cmd = tmp1; } __set_cmd_str_cache(core, p, NULL); p->view->refresh = true; @@ -6304,8 +6334,8 @@ void __handle_tab_new_with_cur_panel(RzCore *core) { RzPanel *new_panel = __get_panel(new_panels, 0); __init_panel_param(core, new_panel, cur->model->title, cur->model->cmd); new_panel->model->cache = cur->model->cache; - new_panel->model->funcName = rz_str_new(cur->model->funcName); - __set_cmd_str_cache(core, new_panel, rz_str_new(cur->model->cmdStrCache)); + new_panel->model->funcName = rz_str_dup(cur->model->funcName); + __set_cmd_str_cache(core, new_panel, rz_str_dup(cur->model->cmdStrCache)); __maximize_panel_size(new_panels); visual->panels = prev; diff --git a/librz/core/tui/rop.c b/librz/core/tui/rop.c index 1602f429a4b..d4e6df655d9 100644 --- a/librz/core/tui/rop.c +++ b/librz/core/tui/rop.c @@ -65,7 +65,7 @@ RZ_IPI int rz_core_visual_view_rop(RzCore *core) { char *wlist = rz_str_widget_list(core, rops, rows, cur, print_rop); rz_cons_printf("%s", wlist); free(wlist); - char *curline = rz_str_dup(NULL, rz_str_trim_head_ro(rz_str_widget_list(core, rops, rows, cur, print_rop))); + char *curline = rz_str_dup(rz_str_trim_head_ro(rz_str_widget_list(core, rops, rows, cur, print_rop))); if (curline) { char *sp = strchr(curline, ' '); if (sp) { diff --git a/librz/core/tui/visual.c b/librz/core/tui/visual.c index 49d7c7440b0..3a3c2653a8d 100644 --- a/librz/core/tui/visual.c +++ b/librz/core/tui/visual.c @@ -200,7 +200,7 @@ static const char *__core_visual_print_command(RzCore *core) { } if (rz_config_get_i(core->config, "scr.dumpcols")) { free(core->stkcmd); - core->stkcmd = rz_str_new(stackPrintCommand(core)); + core->stkcmd = rz_str_dup(stackPrintCommand(core)); return printfmtColumns[PIDX]; } return printfmtSingle[PIDX]; @@ -1283,7 +1283,7 @@ RZ_IPI int rz_core_visual_xrefs(RzCore *core, bool xref_to, bool fcnInsteadOfAdd rz_cons_newline(); } /* prepare highlight */ - char *cmd = rz_str_new(rz_cons_singleton()->highlight); + char *cmd = rz_str_dup(rz_cons_singleton()->highlight); char *ats = rz_str_newf("%" PFMT64x, curat); if (ats && RZ_STR_ISEMPTY(cmd)) { rz_cons_highlight(ats); diff --git a/librz/core/tui/vmenus.c b/librz/core/tui/vmenus.c index ba43f125de7..01866990cf7 100644 --- a/librz/core/tui/vmenus.c +++ b/librz/core/tui/vmenus.c @@ -66,12 +66,12 @@ static RzPVector /**/ *capture_filter_keywords(char *inputing) { return NULL; } char *processing = rz_str_trim_dup(inputing); - char *buf = rz_str_new(""); + char *buf = rz_str_dup(""); for (int i = 0; i < strlen(processing); i++) { if (IS_WHITESPACE(processing[i])) { if (strlen(buf)) { rz_pvector_push(keywords, buf); - buf = rz_str_new(""); + buf = rz_str_dup(""); } } else { buf = rz_str_appendch(buf, processing[i]); @@ -674,7 +674,7 @@ RZ_IPI void rz_core_visual_analysis(RzCore *core, const char *input) { // add new keyword visual->is_inputing = true; if (!visual->inputing) { - visual->inputing = rz_str_new(""); + visual->inputing = rz_str_dup(""); } option = 0; } diff --git a/librz/include/rz_bin_dwarf.h b/librz/include/rz_bin_dwarf.h index a26940b7a86..7bf7e1af7b8 100644 --- a/librz/include/rz_bin_dwarf.h +++ b/librz/include/rz_bin_dwarf.h @@ -1826,13 +1826,13 @@ static inline char *rz_bin_dwarf_attr_string( rz_return_val_if_fail(attr, NULL); const RzBinDwarfAttrValue *v = &attr->value; if (v->kind == RzBinDwarfAttr_String) { - return rz_str_new(v->string); + return rz_str_dup(v->string); } else if (v->kind == RzBinDwarfAttr_StrRef && dw) { - return rz_str_new(rz_bin_dwarf_str_get(dw->str, v->u64)); + return rz_str_dup(rz_bin_dwarf_str_get(dw->str, v->u64)); } else if (v->kind == RzBinDwarfAttr_StrOffsetIndex && dw) { - return rz_str_new(rz_bin_dwarf_str_offsets_get(dw->str, dw->str_offsets, str_offsets_base, v->u64)); + return rz_str_dup(rz_bin_dwarf_str_offsets_get(dw->str, dw->str_offsets, str_offsets_base, v->u64)); } else if (v->kind == RzBinDwarfAttr_LineStrRef && dw) { - return rz_str_new(rz_bin_dwarf_line_str_get(dw->line_str, v->u64)); + return rz_str_dup(rz_bin_dwarf_line_str_get(dw->line_str, v->u64)); } return NULL; } diff --git a/librz/include/rz_constructor.h b/librz/include/rz_constructor.h index 274bff00bd0..9903757b79e 100644 --- a/librz/include/rz_constructor.h +++ b/librz/include/rz_constructor.h @@ -62,7 +62,7 @@ extern int (*_array##_func)(void); \ int _func##_wrapper(void) { \ _func(); \ - char *_func##_var = rz_str_new(""); \ + char *_func##_var = rz_str_dup(""); \ free(_func##_var); \ return 0; \ } \ @@ -74,7 +74,7 @@ extern int (*_array##_func)(void); \ int _func##_constructor(void) { \ atexit(_func); \ - char *_func##_var = rz_str_new(""); \ + char *_func##_var = rz_str_dup(""); \ free(_func##_var); \ return 0; \ } \ diff --git a/librz/include/rz_util/rz_str.h b/librz/include/rz_util/rz_str.h index 75bd7451e80..b1457c50be4 100644 --- a/librz/include/rz_util/rz_str.h +++ b/librz/include/rz_util/rz_str.h @@ -124,7 +124,6 @@ RZ_API char *rz_str_arg_escape(const char *arg); RZ_API int rz_str_arg_unescape(char *arg); RZ_API char **rz_str_argv(const char *str, int *_argc); RZ_API void rz_str_argv_free(char **argv); -RZ_API char *rz_str_new(const char *str); RZ_API int rz_snprintf(char *string, int len, const char *fmt, ...) RZ_PRINTF_CHECK(3, 4); RZ_API bool rz_str_is_whitespace(RZ_NONNULL const char *str); RZ_API bool rz_str_is_ascii(const char *str); @@ -194,7 +193,7 @@ static inline const char *rz_str_get_null(const char *str) { return str ? str : "(null)"; } RZ_API char *rz_str_ndup(RZ_NULLABLE const char *ptr, int len); -RZ_API char *rz_str_dup(char *ptr, const char *string); +RZ_API RZ_OWN char *rz_str_dup(RZ_NULLABLE const char *str); RZ_API int rz_str_delta(char *p, char a, char b); RZ_API void rz_str_filter(char *str); RZ_API const char *rz_str_tok(const char *str1, const char b, size_t len); diff --git a/librz/lang/p/lib.c b/librz/lang/p/lib.c index 878919b69eb..6f66e1fb741 100644 --- a/librz/lang/p/lib.c +++ b/librz/lang/p/lib.c @@ -12,7 +12,7 @@ static int lang_lib_init(RzLang *user) { static int lang_lib_file_run(RzLang *user, const char *file) { char *libpath; void *lib; - if (!(libpath = rz_str_new(file))) { + if (!(libpath = rz_str_dup(file))) { return -1; } if (!rz_str_startswith(libpath, "/") && !rz_str_startswith(libpath, "./")) { diff --git a/librz/main/rz-ax.c b/librz/main/rz-ax.c index a23f7f7252f..ac91a09281b 100644 --- a/librz/main/rz-ax.c +++ b/librz/main/rz-ax.c @@ -644,7 +644,7 @@ static int rax(RzNum *num, char *str, int len, int last, ut64 *_flags, int *fm) if (*str != '0') { modified_str = rz_str_newf("0%s", str); } else { - modified_str = rz_str_new(str); + modified_str = rz_str_dup(str); } ut64 n = rz_num_math(num, modified_str); diff --git a/librz/main/rz-diff.c b/librz/main/rz-diff.c index 79a073742cc..5b32b0662c4 100644 --- a/librz/main/rz-diff.c +++ b/librz/main/rz-diff.c @@ -183,7 +183,7 @@ typedef struct diff_hex_view_t { #define rz_diff_ctx_add_evar(x, o) \ do { \ - char *copy = rz_str_new(o); \ + char *copy = rz_str_dup(o); \ if (!copy || !rz_list_append((x)->evars, copy)) { \ free(copy); \ rz_diff_error_opt(x, DIFF_OPT_ERROR, "cannot add evar '%s' to list\n", o); \ diff --git a/librz/main/rz-sign.c b/librz/main/rz-sign.c index e549b680378..0b146916b68 100644 --- a/librz/main/rz-sign.c +++ b/librz/main/rz-sign.c @@ -110,7 +110,7 @@ RZ_API int rz_main_rz_sign(int argc, const char **argv) { option = RZ_SIGN_OPT_DUMP_FLIRT; break; case 'e': - if (!(config = rz_str_new(opt.arg)) || !rz_list_append(evars, config)) { + if (!(config = rz_str_dup(opt.arg)) || !rz_list_append(evars, config)) { free(config); RZ_LOG_ERROR("rz-sign: cannot add evaluable config variable '%s' to RzList\n", opt.arg); ret = -1; diff --git a/librz/parse/filter.c b/librz/parse/filter.c index 040fdd57e88..ee9d92da462 100644 --- a/librz/parse/filter.c +++ b/librz/parse/filter.c @@ -316,7 +316,7 @@ static bool filter(RzParse *p, ut64 addr, RzFlag *f, RzAnalysisHint *hint, char if (label) { flagname = rz_str_newf(".%s", label); } else { - flagname = rz_str_new(f->realnames ? flag->realname : flag->name); + flagname = rz_str_dup(f->realnames ? flag->realname : flag->name); } int maxflagname = p->maxflagnamelen; if (maxflagname > 0 && flagname && strlen(flagname) > maxflagname) { diff --git a/librz/reg/reg.c b/librz/reg/reg.c index 404a8dd3833..f0ee7ba7178 100644 --- a/librz/reg/reg.c +++ b/librz/reg/reg.c @@ -139,7 +139,9 @@ RZ_API int rz_reg_get_name_idx(const char *type) { RZ_API bool rz_reg_set_name(RZ_NONNULL RzReg *reg, RzRegisterId role, RZ_NONNULL const char *name) { rz_return_val_if_fail(reg && name, false); if (role >= 0 && role < RZ_REG_NAME_LAST) { - reg->name[role] = rz_str_dup(reg->name[role], name); + char *tmp = rz_str_dup(name); + free(reg->name[role]); + reg->name[role] = tmp; return true; } return false; diff --git a/librz/socket/run.c b/librz/socket/run.c index 9815e61aaac..01c4d1da7ad 100644 --- a/librz/socket/run.c +++ b/librz/socket/run.c @@ -537,7 +537,7 @@ static bool parse_key_value(const char *input, char **key, char **value) { if (equal[1] == '$') { s_value = rz_sys_getenv(equal + 1); } else { - s_value = rz_str_new(equal + 1); + s_value = rz_str_dup(equal + 1); } if (!s_key || !s_value) { diff --git a/librz/type/base.c b/librz/type/base.c index 0907f577a6b..3ac3470eab1 100644 --- a/librz/type/base.c +++ b/librz/type/base.c @@ -129,7 +129,7 @@ static void RzTypeStructMember_cpy(RzTypeStructMember *dst, RzTypeStructMember * return; } memcpy(dst, src, sizeof(RzTypeStructMember)); - dst->name = rz_str_new(src->name); + dst->name = rz_str_dup(src->name); dst->type = rz_type_clone(src->type); } @@ -138,7 +138,7 @@ static void RzTypeEnumCase_cpy(RzTypeEnumCase *dst, RzTypeEnumCase *src) { return; } memcpy(dst, src, sizeof(RzTypeEnumCase)); - dst->name = rz_str_new(src->name); + dst->name = rz_str_dup(src->name); } static void RzTypeUnionMember_cpy(RzTypeUnionMember *dst, RzTypeUnionMember *src) { @@ -146,7 +146,7 @@ static void RzTypeUnionMember_cpy(RzTypeUnionMember *dst, RzTypeUnionMember *src return; } memcpy(dst, src, sizeof(RzTypeUnionMember)); - dst->name = rz_str_new(src->name); + dst->name = rz_str_dup(src->name); dst->type = rz_type_clone(src->type); } @@ -161,7 +161,7 @@ RZ_API bool rz_base_type_clone_into( RZ_NONNULL RZ_BORROW RZ_IN RzBaseType *src) { rz_return_val_if_fail(src && dst, false); rz_mem_copy(dst, sizeof(RzBaseType), src, sizeof(RzBaseType)); - dst->name = rz_str_new(src->name); + dst->name = rz_str_dup(src->name); dst->type = src->type ? rz_type_clone(src->type) : NULL; switch (src->kind) { diff --git a/librz/type/type.c b/librz/type/type.c index 4479249da9c..51496c6e35c 100644 --- a/librz/type/type.c +++ b/librz/type/type.c @@ -1183,7 +1183,7 @@ RZ_API RZ_OWN RzType *rz_type_clone(RZ_BORROW RZ_NONNULL const RzType *type) { newtype->kind = type->kind; newtype->identifier.kind = type->identifier.kind; newtype->identifier.is_const = type->identifier.is_const; - newtype->identifier.name = rz_str_new(type->identifier.name); + newtype->identifier.name = rz_str_dup(type->identifier.name); break; case RZ_TYPE_KIND_ARRAY: newtype->kind = RZ_TYPE_KIND_ARRAY; diff --git a/librz/util/axml.c b/librz/util/axml.c index 2e805a95977..7f826d150d6 100644 --- a/librz/util/axml.c +++ b/librz/util/axml.c @@ -198,7 +198,7 @@ static char *resource_value(string_pool_t *pool, const ut8 *data, ut64 data_size resource_value_t *value) { switch (value->type) { case RESOURCE_NULL: - return rz_str_new(""); + return rz_str_dup(""); case RESOURCE_REFERENCE: return rz_str_newf("@0x%x", value->data.d); case RESOURCE_STRING: @@ -215,7 +215,7 @@ static char *resource_value(string_pool_t *pool, const ut8 *data, ut64 data_size RZ_LOG_WARN("Resource type is not recognized: %#x\n", value->type); break; } - return rz_str_new("null"); + return rz_str_dup("null"); } static bool dump_element(RzStrBuf *sb, string_pool_t *pool, namespace_t *namespace, diff --git a/librz/util/str.c b/librz/util/str.c index f3efeb643a3..70f1a170218 100644 --- a/librz/util/str.c +++ b/librz/util/str.c @@ -890,12 +890,6 @@ RZ_API const char *rz_str_case_nstr(RZ_NONNULL const char *s, RZ_NONNULL const c return res; } -// Returns a new heap-allocated copy of str. -// XXX what's the diff with rz_str_dup ? -RZ_API char *rz_str_new(const char *str) { - return str ? strdup(str) : NULL; -} - // Returns a new heap-allocated copy of str, sets str[len] to '\0'. // If the input str is longer than len, it will be truncated. RZ_API char *rz_str_newlen(const char *str, int len) { @@ -1047,11 +1041,17 @@ RZ_API char *rz_str_ndup(RZ_NULLABLE const char *ptr, int len) { return out; } -// TODO: deprecate? -RZ_API char *rz_str_dup(char *ptr, const char *string) { - char *str = rz_str_new(string); - free(ptr); // in case ptr == string - return str; +/** + * \brief Duplicates a string. + * + * This function duplicates the given string. If the input string is NULL, + * the function will return NULL. + * + * \param str The string to duplicate. Can be NULL. + * \return A new string which is a duplicate of the input string, or NULL if the input string was NULL. + */ +RZ_API RZ_OWN char *rz_str_dup(RZ_NULLABLE const char *str) { + return str ? strdup(str) : NULL; } RZ_API char *rz_str_prepend(char *ptr, const char *string) { diff --git a/librz/util/syscmd.c b/librz/util/syscmd.c index 4bf69fb1ae6..1aefedc0129 100644 --- a/librz/util/syscmd.c +++ b/librz/util/syscmd.c @@ -173,7 +173,7 @@ RZ_API RZ_OWN char *rz_syscmd_join(RZ_NONNULL const char *file1, RZ_NONNULL cons } rz_list_foreach (list2, iter2, str2) { if (rz_str_startswith(str2, field)) { - char *out = rz_str_new(field); + char *out = rz_str_dup(field); char *first = strchr(str1, ' '); char *second = strchr(str2, ' '); rz_str_append(out, first ? first : " "); @@ -228,7 +228,7 @@ RZ_API RZ_OWN char *rz_syscmd_mkdir(RZ_NONNULL const char *dir) { const char *suffix = rz_str_trim_head_ro(strchr(dir, ' ')); if (!suffix || !strncmp(suffix, "-p", 3)) { - return rz_str_dup(NULL, "Usage: mkdir [-p] [directory]\n"); + return rz_str_dup("Usage: mkdir [-p] [directory]\n"); } int ret; char *dirname = (!strncmp(suffix, "-p ", 3)) diff --git a/librz/util/table.c b/librz/util/table.c index 584e8038d80..076d0767f3f 100644 --- a/librz/util/table.c +++ b/librz/util/table.c @@ -252,7 +252,7 @@ RZ_API void rz_table_set_columnsf(RzTable *t, const char *fmt, ...) { rz_pvector_push(row, strdup(arg ? arg : "")); \ break; \ case 'b': \ - rz_pvector_push(row, rz_str_new(rz_str_bool(va_arg(ap, int)))); \ + rz_pvector_push(row, rz_str_dup(rz_str_bool(va_arg(ap, int)))); \ break; \ case 'i': \ case 'd': \ diff --git a/test/unit/test_table.c b/test/unit/test_table.c index 5f1c49a4b38..159ceffcf75 100644 --- a/test/unit/test_table.c +++ b/test/unit/test_table.c @@ -168,16 +168,16 @@ static void simple_merge(RzTableRow *acc, RzTableRow *new_row, int nth) { if (cnt != nth) { if (!strcmp(item_lhs, "a")) { free(item_lhs); - rz_pvector_set(lhs, cnt, rz_str_new("a | e")); + rz_pvector_set(lhs, cnt, rz_str_dup("a | e")); } else if (!strcmp(item_lhs, "b")) { free(item_lhs); - rz_pvector_set(lhs, cnt, rz_str_new("b | f")); + rz_pvector_set(lhs, cnt, rz_str_dup("b | f")); } else if (!strcmp(item_lhs, "c")) { free(item_lhs); - rz_pvector_set(lhs, cnt, rz_str_new("c | h")); + rz_pvector_set(lhs, cnt, rz_str_dup("c | h")); } else if (!strcmp(item_lhs, "d")) { free(item_lhs); - rz_pvector_set(lhs, cnt, rz_str_new("d | g")); + rz_pvector_set(lhs, cnt, rz_str_dup("d | g")); } } }