Magic-Mirror/radare2
1
0
Fork 0
mirror of https://github.com/radareorg/radare2.git synced 2025-02-03 12:12:06 +00:00
Code Issues Actions 7 Packages Projects Releases Wiki Activity

Lowercase all the help messages for consistency ##shell

Browse Source
This commit is contained in:
Apkunpacker 2022-04-11 14:39:41 +05:30 committed by GitHub
parent 39bdef0df9
commit 6d0bf405ac
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 742 additions and 742 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

230
libr/core/cmd_anal.c
View File

@ -55,7 +55,7 @@ static const char *help_msg_a[] = {
"aL", "", "list all asm/anal plugins (e asm.arch=?)",
"an", "[?] [name]", "show/rename/create whatever var/flag/function is used in current instruction",
"ao", "[?] [len]", "analyze Opcodes (or emulate it)",
"aO", "[?] [len]", "Analyze N instructions in M bytes",
"aO", "[?] [len]", "analyze N instructions in M bytes",
"ap", "", "find prelude for current offset",
"ar", "[?]", "like 'dr' but for the esil vm. (registers)",
"as", "[?] [num]", "analyze syscall using dbg.reg",
@ -79,11 +79,11 @@ static const char *help_msg_afu[] = {
static const char *help_msg_aae[] = {
"Usage:", "aae", "[pf] ([addr]) # analyze all kind of stuff using esil",
"aaep", "", "Same as aepa@@@i - define anal pins by import flag names",
"aaep", "a", "Run 'aep ret0@@@i' and then 'aaep' - all unknown imports are faked to return 0",
"aaef", "", "Emulate all functions using esil to find out computed references (same as aef@@@F)",
"aae", " [addr]", "Same as aepa@@@i - define anal pins by import flag names",
"aae", "", "Honor anal.{in,from,to} and emulate all executable regions",
"aaep", "", "same as aepa@@@i - define anal pins by import flag names",
"aaep", "a", "run 'aep ret0@@@i' and then 'aaep' - all unknown imports are faked to return 0",
"aaef", "", "emulate all functions using esil to find out computed references (same as aef@@@F)",
"aae", " [addr]", "same as aepa@@@i - define anal pins by import flag names",
"aae", "", "honor anal.{in,from,to} and emulate all executable regions",
NULL
};
@ -104,21 +104,21 @@ static const char *help_msg_aan[] = {
static const char *help_msg_afm[] = {
"Usage:", "afm", "[name] # merge two functions.",
"afm", " sym.func.100003d74", "Merge current function into 0x100003d74",
"afm", " sym.func.100003d74", "merge current function into 0x100003d74",
NULL
};
static const char *help_msg_aF[] = {
"Usage:", "aF", " # analyze a function, but using anal.depth=1",
"aF", "", "Check af? for more options and information.",
"aF", "", "check af? for more options and information.",
NULL
};
static const char *help_msg_an[] = {
"Usage:", "an", " # analyze name for the current address",
"an", "", "Show flag/function/symbol name",
"an*", "", "Same as above but in r2 commands",
"anj", "", "Same as above but in json",
"an", "", "show flag/function/symbol name",
"an*", "", "same as above but in r2 commands",
"anj", "", "same as above but in json",
NULL
};
@ -137,7 +137,7 @@ static const char *help_msg_ap[] = {
static const char *help_msg_avg[] = {
"Usage:", "avg", " # analyze variable global",
"avg", "", "Use ESIL emulation to find out arguments of a call (uses 'abte')",
"avg", "", "use ESIL emulation to find out arguments of a call (uses 'abte')",
"avg", " [type] [name]", "add global",
"avg-", "", "delete global",
NULL
@ -145,8 +145,8 @@ static const char *help_msg_avg[] = {
static const char *help_msg_aC[] = {
"Usage:", "aC[fej] [addr-of-call]", " # analyze call args",
"aCe", "", "Use ESIL emulation to find out arguments of a call (uses 'abte')",
"aCf", "", "Same as .aCe* $$ @@=`pdr~call`",
"aCe", "", "use ESIL emulation to find out arguments of a call (uses 'abte')",
"aCf", "", "same as .aCe* $$ @@=`pdr~call`",
NULL
};
@ -334,7 +334,7 @@ static const char *help_msg_ae[] = {
"aepc", " [addr]", "change esil PC to this address",
"aer", "[?] [..]", "handle ESIL registers like 'ar' or 'dr' does",
"aes", "[?]", "perform emulated debugger step",
"aets", "[?]", "ESIL Trace session",
"aets", "[?]", "esil Trace session",
"aev", " [esil]", "visual esil debugger for the given expression or current instruction",
"aex", " [hex]", "evaluate opcode expression",
NULL
@ -344,13 +344,13 @@ static const char *help_detail_ae[] = {
"Examples:", "ESIL", " examples and documentation",
"=", "", "assign updating internal flags",
":=", "", "assign without updating internal flags",
"+=", "", "A+=B => B,A,+=",
"+", "", "A=A+B => B,A,+,A,=",
"++", "", "increment, 2,A,++ == 3 (see rsi,--=[1], ... )",
"--", "", "decrement, 2,A,-- == 1",
"*=", "", "A*=B => B,A,*=",
"/=", "", "A/=B => B,A,/=",
"%=", "", "A%=B => B,A,%=",
"+=", "", "a+=b => b,a,+=",
"+", "", "a=a+b => b,a,+,a,=",
"++", "", "increment, 2,a,++ == 3 (see rsi,--=[1], ... )",
"--", "", "decrement, 2,a,-- == 1",
"*=", "", "a*=b => b,a,*=",
"/=", "", "a/=b => b,a,/=",
"%=", "", "a%=b => b,a,%=",
"&=", "", "and ax, bx => bx,ax,&=",
"|", "", "or r0, r1, r2 => r2,r1,|,r0,=",
"!=", "", "negate all bits",
@ -407,15 +407,15 @@ static const char *help_detail_ae[] = {
static const char *help_msg_aea[] = {
"Examples:", "aea", " show regs and memory accesses used in a range",
"aea", " [ops]", "Show regs/memory accesses used in N instructions ",
"aea*", " [ops]", "Create mem.* flags for memory accesses",
"aeab", "", "Show regs used in current basic block",
"aeaf", "", "Show regs used in current function",
"aear", " [ops]", "Show regs read in N instructions",
"aeaw", " [ops]", "Show regs written in N instructions",
"aean", " [ops]", "Show regs not written in N instructions",
"aeaj", " [ops]", "Show aea output in JSON format",
"aeA", " [len]", "Show regs used in N bytes (subcommands are the same)",
"aea", " [ops]", "show regs/memory accesses used in N instructions ",
"aea*", " [ops]", "create mem.* flags for memory accesses",
"aeab", "", "show regs used in current basic block",
"aeaf", "", "show regs used in current function",
"aear", " [ops]", "show regs read in N instructions",
"aeaw", " [ops]", "show regs written in N instructions",
"aean", " [ops]", "show regs not written in N instructions",
"aeaj", " [ops]", "show aea output in JSON format",
"aeA", " [len]", "show regs used in N bytes (subcommands are the same)",
"Legend:", "", "",
"I", "", "input registers (read before being set)",
"A", "", "all regs accessed",
@ -431,11 +431,11 @@ static const char *help_msg_aea[] = {
static const char *help_msg_aec[] = {
"Examples:", "aec", " continue until ^c",
"aec", "", "Continue until exception",
"aecs", "", "Continue until syscall",
"aecc", "", "Continue until call",
"aecu", "[addr]", "Continue until address",
"aecue", "[addr]", "Continue until esil expression",
"aec", "", "continue until exception",
"aecs", "", "continue until syscall",
"aecc", "", "continue until call",
"aecu", "[addr]", "continue until address",
"aecue", "[addr]", "continue until esil expression",
NULL
};
@ -472,16 +472,16 @@ static const char *help_msg_aep[] = {
static const char *help_msg_aek[] = {
"Usage:", "aek ", " [...]",
"aek", "", "Dump the esil.stats database contents",
"aek ", "sdb.query", "Evaluate sdb query on esil.stats db",
"aek-", "", "Clear the esil.stats sdb instance",
"aek", "", "dump the esil.stats database contents",
"aek ", "sdb.query", "evaluate sdb query on esil.stats db",
"aek-", "", "clear the esil.stats sdb instance",
NULL
};
static const char *help_msg_aets[] = {
"Usage:", "aets ", " [...]",
"aets+", "", "Start ESIL trace session",
"aets-", "", "Stop ESIL trace session",
"aets+", "", "start ESIL trace session",
"aets-", "", "stop ESIL trace session",
NULL
};
@ -519,9 +519,9 @@ static const char *help_msg_af[] = {
};
static const char *help_msg_afb[] = {
"Usage:", "afb", " List basic blocks of given function",
".afbr-", "", "Set breakpoint on every return address of the function",
".afbr-*", "", "Remove breakpoint on every return address of the function",
"Usage:", "afb", " list basic blocks of given function",
".afbr-", "", "set breakpoint on every return address of the function",
".afbr-*", "", "remove breakpoint on every return address of the function",
"afb", " [addr]", "list basic blocks of function",
"afb.", " [addr]", "show info of current basic block",
"afb=", "", "display ascii-art bars for basic block regions",
@ -530,23 +530,23 @@ static const char *help_msg_afb[] = {
"afbe", " bbfrom bbto", "add basic-block edge for switch-cases",
"afbi", "[j]", "print current basic block information",
"afbj", " [addr]", "show basic blocks information in json",
"afbr", "", "Show addresses of instructions which leave the function",
"afbt", "", "Show basic blocks of current function in a table",
"afbr", "", "show addresses of instructions which leave the function",
"afbt", "", "show basic blocks of current function in a table",
"afB", " [bits]", "define asm.bits for the given function",
NULL
};
static const char *help_msg_afc[] = {
"Usage:", "afc[agl?]", "# see also tcc command to manage all calling conventions",
"afc", " ccname", "Manually set calling convention for current function",
"afc", "", "Show Calling convention for the Current function (same as tcc)",
"afcr", "[j]", "Show register usage for the current function",
"afca", "", "Analyse function for finding the current calling convention",
"afcf", "[j] [name]", "Prints return type function(arg1, arg2...), see afij",
"afck", "", "List SDB details of call loaded calling conventions",
"afcl", "", "List all available calling conventions",
"afco", " path", "Open Calling Convention sdb profile from given path",
"afcR", "", "Register telescoping using the calling conventions order",
"afc", " ccname", "manually set calling convention for current function",
"afc", "", "show calling convention for the Current function (same as tcc)",
"afcr", "[j]", "show register usage for the current function",
"afca", "", "analyse function for finding the current calling convention",
"afcf", "[j] [name]", "prints return type function(arg1, arg2...), see afij",
"afck", "", "list SDB details of call loaded calling conventions",
"afcl", "", "list all available calling conventions",
"afco", " path", "open Calling Convention sdb profile from given path",
"afcR", "", "register telescoping using the calling conventions order",
NULL
};
@ -705,33 +705,33 @@ static const char *help_msg_afvs[] = {
static const char *help_msg_ag[] = {
"Usage:", "ag<graphtype><format> [addr]", "",
"Graph commands:", "", "",
"aga", "[format]", "Data references graph",
"agA", "[format]", "Global data references graph",
"agc", "[format]", "Function callgraph",
"agC", "[format]", "Global callgraph",
"agd", "[format] [fcn addr]", "Diff graph",
"agf", "[format]", "Basic blocks function graph",
"agi", "[format]", "Imports graph",
"agr", "[format]", "References graph",
"agR", "[format]", "Global references graph",
"agx", "[format]", "Cross references graph",
"agg", "[format]", "Custom graph",
"ag-", "", "Clear the custom graph",
"agn", "[?] title body", "Add a node to the custom graph",
"age", "[?] title1 title2", "Add an edge to the custom graph",
"aga", "[format]", "data references graph",
"agA", "[format]", "global data references graph",
"agc", "[format]", "function callgraph",
"agC", "[format]", "global callgraph",
"agd", "[format] [fcn addr]", "diff graph",
"agf", "[format]", "basic blocks function graph",
"agi", "[format]", "imports graph",
"agr", "[format]", "references graph",
"agR", "[format]", "global references graph",
"agx", "[format]", "cross references graph",
"agg", "[format]", "custom graph",
"ag-", "", "clear the custom graph",
"agn", "[?] title body", "add a node to the custom graph",
"age", "[?] title1 title2", "add an edge to the custom graph",
"","","",
"Output formats:", "", "",
"<blank>", "", "Ascii art",
"<blank>", "", "ascii art",
"*", "", "r2 commands",
"b", "", "Braile art rendering (agfb)",
"d", "", "Graphviz dot",
"g", "", "Graph Modelling Language (gml)",
"b", "", "braile art rendering (agfb)",
"d", "", "graphviz dot",
"g", "", "graph Modelling Language (gml)",
"j", "", "json ('J' for formatted disassembly)",
"k", "", "SDB key-value",
"m", "", "Mermaid",
"t", "", "Tiny ascii art",
"v", "", "Interactive ascii art",
"w", " [path]", "Write to path or display graph image (see graph.gv.format and graph.web)",
"k", "", "sdb key-value",
"m", "", "mermaid",
"t", "", "tiny ascii art",
"v", "", "interactive ascii art",
"w", " [path]", "write to path or display graph image (see graph.gv.format and graph.web)",
NULL
};
@ -744,18 +744,18 @@ static const char *help_msg_age[] = {
"ageh", "", "List all the highlighted edges",
"ageh", " nodeA nodeB", "Highlight edge between nodeA and nodeB",
"ageh-", " nodeA nodeB", "Highlight edge between nodeA and nodeB",
"age?", "", "Show this help",
"age?", "", "show this help",
NULL
};
static const char *help_msg_agn[] = {
"Usage:", "agn [title] [body]", "",
"Examples:", "", "",
"agn", " title1 body1", "Add a node with title \"title1\" and body \"body1\"",
"agn", " \"title with space\" \"body with space\"", "Add a node with spaces in the title and in the body",
"agn", " title1 base64:Ym9keTE=", "Add a node with the body specified as base64",
"agn-", " title1", "Remove a node with title \"title1\"",
"agn?", "", "Show this help",
"agn", " title1 body1", "add a node with title \"title1\" and body \"body1\"",
"agn", " \"title with space\" \"body with space\"", "add a node with spaces in the title and in the body",
"agn", " title1 base64:Ym9keTE=", "add a node with the body specified as base64",
"agn-", " title1", "remove a node with title \"title1\"",
"agn?", "", "show this help",
NULL
};
@ -831,8 +831,8 @@ static const char *help_msg_ahi[] = {
static const char *help_msg_aht[] = {
"Usage:", "aht[s] [addr|type]", "Mark immediate as type offset (moved to aho)",
"ahts", " <offset>", "List all matching structure offsets",
"aht", " <struct.member>", "Change immediate to structure offset",
"ahts", " <offset>", "list all matching structure offsets",
"aht", " <struct.member>", "change immediate to structure offset",
"aht?", "", "show this help",
NULL
};
@ -874,35 +874,35 @@ static const char *help_msg_ao[] = {
static const char *help_msg_ar[] = {
"Usage: ar", "", "# Analysis Registers",
"ar", "", "Show 'gpr' registers",
"ar.", ">$snapshot", "Show r2 commands to set register values to the current state",
"ar,", "", "Show registers in table format (see dr,)",
".ar*", "", "Import register values as flags",
".ar-", "", "Unflag all registers",
"ar0", "", "Reset register arenas to 0",
"ara", "[?]", "Manage register arenas",
"arj", "", "Show 'gpr' registers in JSON format",
"arA", "", "Show values of function argument calls (A0, A1, A2, ..)",
"ar", " 16", "Show 16 bit registers",
"ar", " 32", "Show 32 bit registers",
"ar", " all", "Show all bit registers",
"ar", " <type>", "Show all registers of given type",
"arC", "", "Display register profile comments",
"arr", "", "Show register references (telescoping)",
"arrj", "", "Show register references (telescoping) in JSON format",
"ar=", "([size])(:[regs])", "Show register values in columns",
"ar?", " <reg>", "Show register value",
"arb", " <type>", "Display hexdump of the given arena",
"arc", "[cq=] <name>", "Conditional flag registers",
"arcc", "", "Derive calling convention from the register profile",
"ard", " <name>", "Show only different registers",
"arn", " <regalias>", "Get regname for pc,sp,bp,a0-3,zf,cf,of,sg",
"aro", "", "Show old (previous) register values",
"arp", "[?] <file>", "Load register profile from file",
"ars", "", "Stack register state",
"arS", "", "Show the size of the register profile",
"art", "", "List all register types",
"arw", " <hexnum>", "Set contents of the register arena",
"ar", "", "show 'gpr' registers",
"ar.", ">$snapshot", "show r2 commands to set register values to the current state",
"ar,", "", "show registers in table format (see dr,)",
".ar*", "", "import register values as flags",
".ar-", "", "unflag all registers",
"ar0", "", "reset register arenas to 0",
"ara", "[?]", "manage register arenas",
"arj", "", "show 'gpr' registers in JSON format",
"arA", "", "show values of function argument calls (A0, A1, A2, ..)",
"ar", " 16", "show 16 bit registers",
"ar", " 32", "show 32 bit registers",
"ar", " all", "show all bit registers",
"ar", " <type>", "show all registers of given type",
"arC", "", "display register profile comments",
"arr", "", "show register references (telescoping)",
"arrj", "", "show register references (telescoping) in JSON format",
"ar=", "([size])(:[regs])", "show register values in columns",
"ar?", " <reg>", "show register value",
"arb", " <type>", "display hexdump of the given arena",
"arc", "[cq=] <name>", "conditional flag registers",
"arcc", "", "derive calling convention from the register profile",
"ard", " <name>", "show only different registers",
"arn", " <regalias>", "get regname for pc,sp,bp,a0-3,zf,cf,of,sg",
"aro", "", "show old (previous) register values",
"arp", "[?] <file>", "load register profile from file",
"ars", "", "stack register state",
"arS", "", "show the size of the register profile",
"art", "", "list all register types",
"arw", " <hexnum>", "set contents of the register arena",
NULL
};

18
libr/core/cmd_cmp.c
View File

@ -4,16 +4,16 @@
static const char *help_message_ci[] = {
"Usage: ci", "[sil] ([obid])", "Compare two bin objects",
"cis", " 0", "Compare symbols with current `ob 1` with given obid (0)",
"cii", " 0", "Compare imports",
"cil", " 0", "Compare libraries",
"cis", " 0", "compare symbols with current `ob 1` with given obid (0)",
"cii", " 0", "compare imports",
"cil", " 0", "compare libraries",
NULL
};
static const char *help_msg_cmp[] = {
"Usage: cmp", " [file] [file]", "Compare two ($alias) files, and change $? value",
"cmp", " ls ls.old", "Compare contents of given files",
"cmp", " $a $b", "Same as above but using alias files",
"cmp", " ls ls.old", "compare contents of given files",
"cmp", " $a $b", "same as above but using alias files",
NULL
};
@ -34,17 +34,17 @@ static const char *help_msg_c[] = {
// "cc", " [offset]", "code bindiff current block against offset"
// "cD", " [file]", "like above, but using radiff -b",
"cf", " [file]", "compare contents of file at current seek",
"cg", "[?] [o] [file]", "Graphdiff current file and [file]",
"ci", "[?] [obid] ([obid2])", "Compare two bin-objects (symbols, imports, ...)",
"cg", "[?] [o] [file]", "graphdiff current file and [file]",
"ci", "[?] [obid] ([obid2])", "compare two bin-objects (symbols, imports, ...)",
"cl|cls|clear", "", "clear screen, (clear0 to goto 0, 0 only)",
"cmp", " [file] [file]", "compare two files\n",
"cu", "[?] [addr] @at", "compare memory hexdumps of $$ and dst in unified diff",
"cud", " [addr] @at", "unified diff disasm from $$ and given address",
"cv", "[1248] [hexpairs] @at", "Compare 1,2,4,8-byte (silent return in $?)",
"cv", "[1248] [hexpairs] @at", "compare 1,2,4,8-byte (silent return in $?)",
"cV", "[1248] [addr] @at", "compare 1,2,4,8-byte address contents (silent, return in $?)",
"cw", "[?][*dqjru] [addr]", "compare memory watchers",
"cx", " [hexpair]", "compare hexpair string (use '.' as nibble wildcard)",
"cx*", " [hexpair]", "Compare hexpair string (output r2 commands)",
"cx*", " [hexpair]", "compare hexpair string (output r2 commands)",
"cX", " [addr]", "Like 'cc' but using hexdiff output",
NULL
};

576
libr/core/cmd_debug.c
View File

@ -22,100 +22,100 @@ void cmd_anal_reg (RCore *core, const char *str);
static const char *help_msg_d[] = {
"Usage:", "d", " # Debug commands",
"db", "[?]", "Breakpoints commands",
"dbt", "[?]", "Display backtrace based on dbg.btdepth and dbg.btalgo",
"dc", "[?]", "Continue execution",
"dd", "[?]", "File descriptors (!fd in r1)",
"de", "[-sc] [perm] [rm] [e]", "Debug with ESIL (see de?)",
"dg", " <file>", "Generate a core-file (WIP)",
"dH", " [handler]", "Transplant process to a new handler",
"di", "[?]", "Show debugger backend information (See dh)",
"dk", "[?]", "List, send, get, set, signal handlers of child",
"dL", "[?]", "List or set debugger handler",
"dm", "[?]", "Show memory maps",
"do", "[?]", "Open process (reload, alias for 'oo')",
"doo", "[args]", "Reopen in debug mode with args (alias for 'ood')",
"doof", "[file]", "Reopen in debug mode from file (alias for 'oodf')",
"doc", "", "Close debug session",
"dp", "[?]", "List, attach to process or thread id",
"dr", "[?]", "Cpu registers",
"ds", "[?]", "Step, over, source line",
"dt", "[?]", "Display instruction traces",
"dw", " <pid>", "Block prompt until pid dies",
"db", "[?]", "breakpoints commands",
"dbt", "[?]", "display backtrace based on dbg.btdepth and dbg.btalgo",
"dc", "[?]", "continue execution",
"dd", "[?]", "file descriptors (!fd in r1)",
"de", "[-sc] [perm] [rm] [e]", "debug with ESIL (see de?)",
"dg", " <file>", "generate a core-file (WIP)",
"dH", " [handler]", "transplant process to a new handler",
"di", "[?]", "show debugger backend information (See dh)",
"dk", "[?]", "list, send, get, set, signal handlers of child",
"dL", "[?]", "list or set debugger handler",
"dm", "[?]", "show memory maps",
"do", "[?]", "open process (reload, alias for 'oo')",
"doo", "[args]", "reopen in debug mode with args (alias for 'ood')",
"doof", "[file]", "reopen in debug mode from file (alias for 'oodf')",
"doc", "", "close debug session",
"dp", "[?]", "list, attach to process or thread id",
"dr", "[?]", "cpu registers",
"ds", "[?]", "step, over, source line",
"dt", "[?]", "display instruction traces",
"dw", " <pid>", "block prompt until pid dies",
#if __WINDOWS__
"dW", "", "List process windows",
"dWi", "", "Identify window under cursor",
"dW", "", "list process windows",
"dWi", "", "identify window under cursor",
#endif
"dx", "[?]", "Inject and run code on target process (See gs)",
"dx", "[?]", "inject and run code on target process (See gs)",
NULL
};
static const char *help_msg_db[] = {
"Usage: db", "", " # Breakpoints commands",
"db", "", "List breakpoints",
"db*", "", "List breakpoints in r commands",
"db", "", "list breakpoints",
"db*", "", "list breakpoints in r commands",
"db", " sym.main", "Add breakpoint into sym.main",
"db", " <addr>", "Add breakpoint",
"dbH", " <addr>", "Add hardware breakpoint",
"db-", " <addr>", "Remove breakpoint",
"db-*", "", "Remove all the breakpoints",
"db.", "", "Show breakpoint info in current offset",
"dbj", "", "List breakpoints in JSON format",
"db.", "", "show breakpoint info in current offset",
"dbj", "", "list breakpoints in JSON format",
// "dbi", " 0x848 ecx=3", "stop execution when condition matches",
"dbc", " <addr> <cmd>", "Run command when breakpoint is hit",
"dbC", " <addr> <cmd>", "Run command but continue until <cmd> returns zero",
"dbd", " <addr>", "Disable breakpoint",
"dbe", " <addr>", "Enable breakpoint",
"dbs", " <addr>", "Toggle breakpoint",
"dbf", "", "Put a breakpoint into every no-return function",
"dbd", " <addr>", "disable breakpoint",
"dbe", " <addr>", "enable breakpoint",
"dbs", " <addr>", "toggle breakpoint",
"dbf", "", "put a breakpoint into every no-return function",
//
"dbm", " <module> <offset>", "Add a breakpoint at an offset from a module's base",
"dbn", " [<name>]", "Show or set name for current breakpoint",
"dbn", " [<name>]", "show or set name for current breakpoint",
//
"dbi", "", "List breakpoint indexes",
"dbi", " <addr>", "Show breakpoint index in givengiven offset",
"dbi.", "", "Show breakpoint index in current offset",
"dbi", "", "list breakpoint indexes",
"dbi", " <addr>", "show breakpoint index in givengiven offset",
"dbi.", "", "show breakpoint index in current offset",
"dbi-", " <idx>", "Remove breakpoint by index",
"dbix", " <idx> [expr]", "Set expression for bp at given index",
"dbix", " <idx> [expr]", "set expression for bp at given index",
"dbic", " <idx> <cmd>", "Run command at breakpoint index",
"dbie", " <idx>", "Enable breakpoint by index",
"dbid", " <idx>", "Disable breakpoint by index",
"dbis", " <idx>", "Swap Nth breakpoint",
"dbite", " <idx>", "Enable breakpoint Trace by index",
"dbitd", " <idx>", "Disable breakpoint Trace by index",
"dbits", " <idx>", "Swap Nth breakpoint trace",
"dbie", " <idx>", "enable breakpoint by index",
"dbid", " <idx>", "disable breakpoint by index",
"dbis", " <idx>", "swap Nth breakpoint",
"dbite", " <idx>", "enable breakpoint Trace by index",
"dbitd", " <idx>", "disable breakpoint Trace by index",
"dbits", " <idx>", "swap Nth breakpoint trace",
//
"dbh", " x86", "Set/list breakpoint plugin handlers",
"dbh", " x86", "set/list breakpoint plugin handlers",
"dbh-", " <name>", "Remove breakpoint plugin handler",
"dbt", "[?]", "Show backtrace. See dbt? for more details",
"dbx", " [expr]", "Set expression for bp in current offset",
"dbt", "[?]", "show backtrace. See dbt? for more details",
"dbx", " [expr]", "set expression for bp in current offset",
"dbw", " <addr> <r/w/rw>", "Add watchpoint",
#if __WINDOWS__
"dbW", " <WM_DEFINE> [?|handle|name]", "Set cond. breakpoint on a window message handler",
#if __WINDOWs__
"dbW", " <WM_DEFINE> [?|handle|name]", "set cond. breakpoint on a window message handler",
#endif
"drx", " number addr len perm", "Modify hardware breakpoint",
"drx-", "number", "Clear hardware breakpoint",
"drx", " number addr len perm", "modify hardware breakpoint",
"drx-", "number", "clear hardware breakpoint",
NULL
};
static const char *help_msg_dbt[] = {
"Usage: dbt", "", " # Backtrace commands",
"dbt", "", "Display backtrace based on dbg.btdepth and dbg.btalgo",
"dbt*", "", "Display backtrace in flags",
"dbt=", "", "Display backtrace in one line (see dbt=s and dbt=b for sp or bp)",
"dbtv", "", "Display backtrace with local vars if any",
"dbtj", "", "Display backtrace in JSON",
"dbta", "", "Display ascii-art representation of the stack backtrace",
"dbte", " <addr>", "Enable Breakpoint Trace",
"dbtd", " <addr>", "Disable Breakpoint Trace",
"dbts", " <addr>", "Swap Breakpoint Trace",
"dbt", "", "display backtrace based on dbg.btdepth and dbg.btalgo",
"dbt*", "", "display backtrace in flags",
"dbt=", "", "display backtrace in one line (see dbt=s and dbt=b for sp or bp)",
"dbtv", "", "display backtrace with local vars if any",
"dbtj", "", "display backtrace in JSON",
"dbta", "", "display ascii-art representation of the stack backtrace",
"dbte", " <addr>", "enable Breakpoint Trace",
"dbtd", " <addr>", "disable Breakpoint Trace",
"dbts", " <addr>", "swap Breakpoint Trace",
NULL
};
static const char *help_msg_drr[] = {
"Usage: drr", ""," # Show references to registers (see pxr?)",
"drr", "", "Periscope register values",
"drrj", "", "Same, but output in JSON",
"drr", "", "periscope register values",
"drrj", "", "same, but output in JSON",
NULL
};
@ -126,23 +126,23 @@ static const char *help_msg_dbw[] = {
static const char *help_msg_dc[] = {
"Usage: dc", "", "Execution continuation commands",
"dc", "", "Continue execution of all children",
"dc", " <pid>", "Continue execution of pid",
"dc", "[-pid]", "Stop execution of pid",
"dca", " [sym] [sym].", "Continue at every hit on any given symbol",
"dcb", "", "Continue back until breakpoint",
"dcc", "", "Continue until call (use step into)",
"dccu", "", "Continue until unknown call (call reg)",
"dc", "", "continue execution of all children",
"dc", " <pid>", "continue execution of pid",
"dc", "[-pid]", "stop execution of pid",
"dca", " [sym] [sym].", "continue at every hit on any given symbol",
"dcb", "", "continue back until breakpoint",
"dcc", "", "continue until call (use step into)",
"dccu", "", "continue until unknown call (call reg)",
#if __WINDOWS__
"dce", "", "Continue execution (pass exception to program)",
"dce", "", "continue execution (pass exception to program)",
#endif
"dcf", "", "Continue until fork (TODO)",
"dck", " <signal> <pid>", "Continue sending signal to process",
"dcp", "", "Continue until program code (mapped io section)",
"dcr", "", "Continue until ret (uses step over)",
"dcs", "[?] <num>", "Continue until syscall",
"dct", " <len>", "Traptrace from curseek to len, no argument to list",
"dcu", "[?] [..end|addr] ([end])", "Continue until address (or range)",
"dcf", "", "continue until fork (TODO)",
"dck", " <signal> <pid>", "continue sending signal to process",
"dcp", "", "continue until program code (mapped io section)",
"dcr", "", "continue until ret (uses step over)",
"dcs", "[?] <num>", "continue until syscall",
"dct", " <len>", "traptrace from curseek to len, no argument to list",
"dcu", "[?] [..end|addr] ([end])", "continue until address (or range)",
/*"TODO: dcu/dcr needs dbg.untilover=true??",*/
/*"TODO: same for only user/libs side, to avoid steping into libs",*/
/*"TODO: support for threads?",*/
@ -151,31 +151,31 @@ static const char *help_msg_dc[] = {
static const char *help_msg_dcs[] = {
"Usage:", "dcs", " Continue until syscall",
"dcs", "", "Continue until next syscall",
"dcs [str]", "", "Continue until next call to the 'str' syscall",
"dcs", "*", "Trace all syscalls, a la strace",
"dcs", "", "continue until next syscall",
"dcs [str]", "", "continue until next call to the 'str' syscall",
"dcs", "*", "trace all syscalls, a la strace",
NULL
};
static const char *help_msg_dcu[] = {
"Usage:", "dcu", " Continue until address",
"dcu.", "", "Alias for dcu $$ (continue until current address)",
"dcu", " address", "Continue until address",
"dcu", " [..tail]", "Continue until the range",
"dcu", " [from] [to]", "Continue until the range",
"dcu.", "", "alias for dcu $$ (continue until current address)",
"dcu", " address", "continue until address",
"dcu", " [..tail]", "continue until the range",
"dcu", " [from] [to]", "continue until the range",
NULL
};
static const char *help_msg_dd[] = {
"Usage: dd", "", "Manage child process files (prepend '.' to inject it)",
"dd", "", "List file descriptors",
"dd", " <file>", "Open file in child process as O_RDONLY)",
"dd-", "<fd>", "Close stdout fd",
"dd+", "<file>", "Open file in read-write (O_RDWR)",
"dd*", "", "List file descriptors (in radare commands)",
"dds", " <fd> <off>", "Seek given fd to offset",
"ddd", " <fd1> <fd2>", "Dup2 from fd1 to fd2",
"ddf", " <addr>", "Create pipe and write fd to address",
"dd", "", "list file descriptors",
"dd", " <file>", "open file in child process as O_RDONLY)",
"dd-", "<fd>", "close stdout fd",
"dd+", "<file>", "open file in read-write (O_RDWR)",
"dd*", "", "list file descriptors (in radare commands)",
"dds", " <fd> <off>", "seek given fd to offset",
"ddd", " <fd1> <fd2>", "dup2 from fd1 to fd2",
"ddf", " <addr>", "create pipe and write fd to address",
"ddr", " <fd> <size>", "Read N bytes from fd",
"ddw", " <fd> <hexpairs>", "Write N bytes to fd",
NULL
@ -183,12 +183,12 @@ static const char *help_msg_dd[] = {
static const char *help_msg_de[] = {
"Usage:", "de", "[-sc] [perm] [rm] [expr]",
"de", "", "List esil watchpoints",
"de-*", "", "Delete all esil watchpoints",
"de", " [perm] [rm] [addr|reg|from..to]", "Stop on condition",
"dec", "", "Continue execution until matching expression",
"des", "[?] [N]", "Step-in N instructions with esildebug",
"desu", " [addr]", "Esildebug until specific address",
"de", "", "list esil watchpoints",
"de-*", "", "delete all esil watchpoints",
"de", " [perm] [rm] [addr|reg|from..to]", "stop on condition",
"dec", "", "continue execution until matching expression",
"des", "[?] [N]", "step-in N instructions with esildebug",
"desu", " [addr]", "esildebug until specific address",
NULL
};
@ -201,178 +201,178 @@ static const char *help_msg_des[] = {
static const char *help_msg_di[] = {
"Usage: di", "", "Debugger target information",
"di", "", "Show debugger target information",
"di*", "", "Same as above, but in r2 commands",
"dir", "", "Alias for 'ls'",
"diq", "", "Same as above, but in one line",
"dij", "", "Same as above, but in JSON format",
"dif", " [$a] [$b]", "Compare two files (or $alias files)",
"di", "", "show debugger target information",
"di*", "", "same as above, but in r2 commands",
"dir", "", "alias for 'ls'",
"diq", "", "same as above, but in one line",
"dij", "", "same as above, but in JSON format",
"dif", " [$a] [$b]", "compare two files (or $alias files)",
NULL
};
static const char *help_msg_dk[] = {
"Usage: dk", "", "Signal commands",
"dk", "", "List all signal handlers of child process",
"dk", " <signal>", "Send KILL signal to child",
"dk", " <signal>=1", "Set signal handler for <signal> in child",
"dk?", "<signal>", "Name/signum resolver",
"dk", "", "list all signal handlers of child process",
"dk", " <signal>", "send KILL signal to child",
"dk", " <signal>=1", "set signal handler for <signal> in child",
"dk?", "<signal>", "name/signum resolver",
"dko", "[?] <signal>", "Reset skip or cont options for given signal",
"dko", " <signal> [|skip|cont]", "On signal SKIP handler or CONT into",
"dkj", "", "List all signal handlers in JSON",
"dko", " <signal> [|skip|cont]", "on signal SKIP handler or CONT into",
"dkj", "", "list all signal handlers in JSON",
NULL
};
static const char *help_msg_dko[] = {
"Usage:", "dko", " # Signal handling commands",
"dko", "", "List existing signal handling",
"dko", " [signal]", "Clear handling for a signal",
"dko", " [signal] [skip|cont]", "Set handling for a signal",
"dko", "", "list existing signal handling",
"dko", " [signal]", "clear handling for a signal",
"dko", " [signal] [skip|cont]", "set handling for a signal",
NULL
};
static const char *help_msg_dm[] = {
"Usage:", "dm", " # Memory maps commands",
"dm", "", "List memory maps of target process",
"dm", " address size", "Allocate <size> bytes at <address> (anywhere if address is -1) in child process",
"dm=", "", "List memory maps of target process (ascii-art bars)",
"dm.", "", "Show map name of current address",
"dm*", "", "List memmaps in radare commands",
"dm-", " address", "Deallocate memory map of <address>",
"dmd", "[a] [file]", "Dump current (all) debug map region to a file (from-to.dmp) (see Sd)",
"dmh", "[?]", "Show map of heap",
"dmi", " [addr|libname] [symname]", "List symbols of target lib",
"dmi*", " [addr|libname] [symname]", "List symbols of target lib in radare commands",
"dmi.", "", "List closest symbol to the current address",
"dmis", " [libname]", "Same as .dmi* - import all symbols from given lib as flags",
"dmiv", "", "Show address of given symbol for given lib",
"dmj", "", "List memmaps in JSON format",
"dml", " <file>", "Load contents of file into the current map region",
"dmm", "[?][j*]", "List modules (libraries, binaries loaded in memory)",
"dmp", "[?] <address> <size> <perms>", "Change page at <address> with <size>, protection <perms> (perm)",
"dms", "[?] <id> <mapaddr>", "Take memory snapshot",
"dm", "", "list memory maps of target process",
"dm", " address size", "allocate <size> bytes at <address> (anywhere if address is -1) in child process",
"dm=", "", "list memory maps of target process (ascii-art bars)",
"dm.", "", "show map name of current address",
"dm*", "", "list memmaps in radare commands",
"dm-", " address", "deallocate memory map of <address>",
"dmd", "[a] [file]", "dump current (all) debug map region to a file (from-to.dmp) (see Sd)",
"dmh", "[?]", "show map of heap",
"dmi", " [addr|libname] [symname]", "list symbols of target lib",
"dmi*", " [addr|libname] [symname]", "list symbols of target lib in radare commands",
"dmi.", "", "list closest symbol to the current address",
"dmis", " [libname]", "same as .dmi* - import all symbols from given lib as flags",
"dmiv", "", "show address of given symbol for given lib",
"dmj", "", "list memmaps in JSON format",
"dml", " <file>", "load contents of file into the current map region",
"dmm", "[?][j*]", "list modules (libraries, binaries loaded in memory)",
"dmp", "[?] <address> <size> <perms>", "change page at <address> with <size>, protection <perms> (perm)",
"dms", "[?] <id> <mapaddr>", "take memory snapshot",
"dms-", " <id> <mapaddr>", "Restore memory snapshot",
"dmS", " [addr|libname] [sectname]", "List sections of target lib",
"dmS*", " [addr|libname] [sectname]", "List sections of target lib in radare commands",
"dmL", " address size", "Allocate <size> bytes at <address> and promote to huge page",
"dmS", " [addr|libname] [sectname]", "list sections of target lib",
"dmS*", " [addr|libname] [sectname]", "list sections of target lib in radare commands",
"dmL", " address size", "allocate <size> bytes at <address> and promote to huge page",
//"dm, " rw- esp 9K", "set 9KB of the stack as read+write (no exec)",
"TODO:", "", "map files in process memory. (dmf file @ [addr])",
NULL
};
static const char *help_msg_dmi[] = {
"Usage: dmi", "", " # List/Load Symbols",
"dmi", "[j|q|*] [libname] [symname]", "List symbols of target lib",
"dmia", "[j|q|*] [libname]", "List all info of target lib",
"dmi*", "", "List symbols of target lib in radare commands",
"dmi.", "", "List closest symbol to the current address",
"dmiv", "", "Show address of given symbol for given lib",
"Usage: dmi", "", " # List/load Symbols",
"dmi", "[j|q|*] [libname] [symname]", "list symbols of target lib",
"dmia", "[j|q|*] [libname]", "list all info of target lib",
"dmi*", "", "list symbols of target lib in radare commands",
"dmi.", "", "list closest symbol to the current address",
"dmiv", "", "show address of given symbol for given lib",
NULL
};
static const char *help_msg_dmm[] = {
"Usage:", "dmm", " # Module memory maps commands",
"dmm", "", "List modules of target process",
"dmm*", "", "List modules of target process (r2 commands)",
"dmm.", "", "List memory map of current module",
"dmmj", "", "List modules of target process (JSON)",
"dmm", "", "list modules of target process",
"dmm*", "", "list modules of target process (r2 commands)",
"dmm.", "", "list memory map of current module",
"dmmj", "", "list modules of target process (JSON)",
NULL
};
static const char *help_msg_dxe[] = {
"Usage:", "dxe", " egg-program # see ragg2 and the 'g' command for more details",
"dxe", " sym.imp.puts(\"foo\")", "Call puts with a string argument",
"dxe", " sym.imp.puts(\"foo\")", "call puts with a string argument",
NULL
};
static const char *help_msg_dmp[] = {
"Usage:", "dmp", " Change page permissions",
"dmp", " [addr] [size] [perms]", "Change permissions",
"dmp", " [perms]", "Change dbg.map permissions",
"dmp", " [addr] [size] [perms]", "change permissions",
"dmp", " [perms]", "change dbg.map permissions",
NULL
};
static const char *help_msg_do[] = {
"Usage:", "do", " # Debug (re)open commands",
"do", "", "Open process (reload, alias for 'oo')",
"dor", " [rarun2]", "Comma separated list of k=v rarun2 profile options (e dbg.profile)",
"doe", "", "Show rarun2 startup profile",
"doe!", "", "Edit rarun2 startup profile with $EDITOR",
"do", "", "open process (reload, alias for 'oo')",
"dor", " [rarun2]", "comma separated list of k=v rarun2 profile options (e dbg.profile)",
"doe", "", "show rarun2 startup profile",
"doe!", "", "edit rarun2 startup profile with $EDITOR",
"doo", " [args]", "Reopen in debug mode with args (alias for 'ood')",
"doof", " [args]", "Reopen in debug mode from file (alias for 'oodf')",
"doc", "", "Close debug session",
"doc", "", "close debug session",
NULL
};
static const char *help_msg_dp[] = {
"Usage:", "dp", " # Process commands",
"dp", "", "List current pid and children",
"dp", " <pid>", "List children of pid",
"dpj", " <pid>", "List children of pid in JSON format",
"dpl", "", "List all attachable pids",
"dplj", "", "List all attachable pids in JSON format",
"dp-", " <pid>", "Detach select pid",
"dp=", "<pid>", "Select pid",
"dpa", " <pid>", "Attach and select pid",
"dpc", "", "Select forked pid (see dbg.forks)",
"dpc*", "", "Display forked pid (see dbg.forks)",
"dpe", "", "Show path to executable",
"dpf", "", "Attach to pid like file fd // HACK",
"dpk", " <pid> [<signal>]", "Send signal to process (default 0)",
"dpn", "", "Create new process (fork)",
"dptn", "", "Create new thread (clone)",
"dpt", "", "List threads of current pid",
"dptj", "", "List threads of current pid in JSON format",
"dpt", " <pid>", "List threads of process",
"dptj", " <pid>", "List threads of process in JSON format",
"dpt=", "<thread>", "Attach to thread",
"dp", "", "list current pid and children",
"dp", " <pid>", "list children of pid",
"dpj", " <pid>", "list children of pid in JSON format",
"dpl", "", "list all attachable pids",
"dplj", "", "list all attachable pids in JSON format",
"dp-", " <pid>", "detach select pid",
"dp=", "<pid>", "select pid",
"dpa", " <pid>", "attach and select pid",
"dpc", "", "select forked pid (see dbg.forks)",
"dpc*", "", "display forked pid (see dbg.forks)",
"dpe", "", "show path to executable",
"dpf", "", "attach to pid like file fd // HACK",
"dpk", " <pid> [<signal>]", "send signal to process (default 0)",
"dpn", "", "create new process (fork)",
"dptn", "", "create new thread (clone)",
"dpt", "", "list threads of current pid",
"dptj", "", "list threads of current pid in JSON format",
"dpt", " <pid>", "list threads of process",
"dptj", " <pid>", "list threads of process in JSON format",
"dpt=", "<thread>", "attach to thread",
NULL
};
static const char *help_msg_dr[] = {
"Usage: dr", "", "Registers commands",
"dr", "", "Show 'gpr' registers",
"dr", " <register>=<val>", "Set register value",
"dr.", " >$snapshot", "Capture current register values in r2 alias file",
"dr,", " [table-query]", "Enumerate registers in table format",
"dr8", "[1|2|4|8] [type]", "Display hexdump of gpr arena (WIP)",
"dr=", "", "Show registers in columns",
"dr?", "<register>", "Show value of given register",
"dr??", "", "Same as dr?`drp~=[0]+` # list all reg roles alias names and values",
"dra", "[?]", "Manage register arenas. see ara?",
"drb", "[1|2|4|8] [type]", "Display hexdump of gpr arena (WIP)",
"drc", " [name]", "Related to conditional flag registers",
"drC", " [register]", "Show register comments",
"drd", "", "Show only different registers",
"drf", "", "Show fpu registers (80 bit long double)",
"dri", "", "Show inverse registers dump (sorted by value)",
"drl", "[j]", "List all register names",
"drm", "[?]", "Show multimedia packed registers",
"dr", "", "show 'gpr' registers",
"dr", " <register>=<val>", "set register value",
"dr.", " >$snapshot", "capture current register values in r2 alias file",
"dr,", " [table-query]", "enumerate registers in table format",
"dr8", "[1|2|4|8] [type]", "display hexdump of gpr arena (WIP)",
"dr=", "", "show registers in columns",
"dr?", "<register>", "show value of given register",
"dr??", "", "same as dr?`drp~=[0]+` # list all reg roles alias names and values",
"dra", "[?]", "manage register arenas. see ara?",
"drb", "[1|2|4|8] [type]", "display hexdump of gpr arena (WIP)",
"drc", " [name]", "related to conditional flag registers",
"drC", " [register]", "show register comments",
"drd", "", "show only different registers",
"drf", "", "show fpu registers (80 bit long double)",
"dri", "", "show inverse registers dump (sorted by value)",
"drl", "[j]", "list all register names",
"drm", "[?]", "show multimedia packed registers",
// "drm", " xmm0 0 32 = 12", "Set the first 32 bit word of the xmm0 reg to 12", // Do not advertise - broken
"dro", "", "Show previous (old) values of registers",
"drp", "[?] ", "Display current register profile",
"drr", "", "Show registers references (telescoping)",
"drrj", "", "Show registers references (telescoping) in JSON format",
"dro", "", "show previous (old) values of registers",
"drp", "[?] ", "display current register profile",
"drr", "", "show registers references (telescoping)",
"drrj", "", "show registers references (telescoping) in JSON format",
// TODO: 'drs' to swap register arenas and display old register valuez
"drs", "[?]", "Stack register states",
"drS", "", "Show the size of the register profile",
"drt", "[?]", "Show all register types",
"drw"," <hexnum>", "Set contents of the register arena",
"drx", "[?]", "Show debug registers",
".dr", "*", "Include common register values in flags",
".dr", "-", "Unflag all registers",
"drs", "[?]", "stack register states",
"drS", "", "show the size of the register profile",
"drt", "[?]", "show all register types",
"drw"," <hexnum>", "set contents of the register arena",
"drx", "[?]", "show debug registers",
".dr", "*", "include common register values in flags",
".dr", "-", "unflag all registers",
NULL
};
static const char *help_msg_drp[] = {
"Usage:", "drp", " # Register profile commands",
"drp", "", "Show the current register profile",
"drp", " [regprofile-file]", "Set the current register profile",
"drp", " [gdb] [regprofile-file]", "Parse gdb register profile and dump an r2 profile string",
"drpc", "", "Show register profile comments",
"drpi", "", "Show internal representation of the register profile",
"drp.", "", "Show the current fake size",
"drpj", "", "Show the current register profile (JSON)",
"drps", " [new fake size]", "Set the fake size",
"drp", "", "show the current register profile",
"drp", " [regprofile-file]", "set the current register profile",
"drp", " [gdb] [regprofile-file]", "parse gdb register profile and dump an r2 profile string",
"drpc", "", "show register profile comments",
"drpi", "", "show internal representation of the register profile",
"drp.", "", "show the current fake size",
"drpj", "", "show the current register profile (JSON)",
"drps", " [new fake size]", "set the fake size",
NULL
};
@ -386,137 +386,137 @@ static const char *help_msg_drs[] = {
static const char *help_msg_drt[] = {
"Usage:", "drt", " [type] [size] # debug register types",
"drt", "", "List all available register types",
"drt", " [size]", "Show all regs in the profile of size",
"drt", " 16", "Show 16 bit registers",
"drt", " [type]", "Show all regs in the profile of this type",
"drt", " all", "Show all registers",
"drt", " fpu", "Show fpu registers",
"drt", " [type] [size]", "Same as above for type and size",
"drt", " [type] [size]", "Same as above for type and size",
"drt*", "", "List flags in r commands",
"drt", "", "list all available register types",
"drt", " [size]", "show all regs in the profile of size",
"drt", " 16", "show 16 bit registers",
"drt", " [type]", "show all regs in the profile of this type",
"drt", " all", "show all registers",
"drt", " fpu", "show fpu registers",
"drt", " [type] [size]", "same as above for type and size",
"drt", " [type] [size]", "same as above for type and size",
"drt*", "", "list flags in r commands",
NULL
};
static const char *help_msg_drx[] = {
"Usage: drx", "", "Hardware breakpoints commands",
"drx", "", "List all (x86?) hardware breakpoints",
"drx", " <number> <address> <length> <perms>", "Modify hardware breakpoint",
"drx-", "<number>", "Clear hardware breakpoint",
"drx", "", "list all (x86?) hardware breakpoints",
"drx", " <number> <address> <length> <perms>", "modify hardware breakpoint",
"drx-", "<number>", "clear hardware breakpoint",
NULL
};
static const char *help_msg_drm[] = {
"Usage: drm", " [reg] [idx] [wordsize] [= value]", "Show multimedia packed registers",
"drm", "", "Show XMM registers",
"drm", " xmm0", "Show all packings of xmm0",
"drm", " xmm0 0 32 = 12", "Set the first 32 bit word of the xmm0 reg to 12",
"drmb", " [reg]", "Show registers as bytes",
"drmw", " [reg]", "Show registers as words",
"drmd", " [reg]", "Show registers as doublewords",
"drmq", " [reg]", "Show registers as quadwords",
"drmq", " xmm0~[0]", "Show first quadword of xmm0",
"drmf", " [reg]", "Show registers as 32-bit floating point",
"drml", " [reg]", "Show registers as 64-bit floating point",
"drmyb", " [reg]", "Show YMM registers as bytes",
"drmyw", " [reg]", "Show YMM registers as words",
"drmyd", " [reg]", "Show YMM registers as doublewords",
"drmyq", " [reg]", "Show YMM registers as quadwords",
"drmq", " ymm0~[3]", "Show fourth quadword of ymm0",
"drmyf", " [reg]", "Show YMM registers as 32-bit floating point",
"drmyl", " [reg]", "Show YMM registers as 64-bit floating point",
"drm", "", "show XMM registers",
"drm", " xmm0", "show all packings of xmm0",
"drm", " xmm0 0 32 = 12", "set the first 32 bit word of the xmm0 reg to 12",
"drmb", " [reg]", "show registers as bytes",
"drmw", " [reg]", "show registers as words",
"drmd", " [reg]", "show registers as doublewords",
"drmq", " [reg]", "show registers as quadwords",
"drmq", " xmm0~[0]", "show first quadword of xmm0",
"drmf", " [reg]", "show registers as 32-bit floating point",
"drml", " [reg]", "show registers as 64-bit floating point",
"drmyb", " [reg]", "show YMM registers as bytes",
"drmyw", " [reg]", "show YMM registers as words",
"drmyd", " [reg]", "show YMM registers as doublewords",
"drmyq", " [reg]", "show YMM registers as quadwords",
"drmq", " ymm0~[3]", "show fourth quadword of ymm0",
"drmyf", " [reg]", "show YMM registers as 32-bit floating point",
"drmyl", " [reg]", "show YMM registers as 64-bit floating point",
NULL
};
static const char *help_msg_ds[] = {
"Usage: ds", "", "Step commands",
"ds", "", "Step one instruction",
"ds", " <num>", "Step <num> instructions",
"dsb", "", "Step back one instruction",
"dsf", "", "Step until end of frame",
"dsi", " <cond>", "Continue until condition matches",
"dsl", "", "Step one source line",
"dsl", " <num>", "Step <num> source lines",
"dso", " <num>", "Step over <num> instructions",
"dsp", "", "Step into program (skip libs)",
"dss", " <num>", "Skip <num> step instructions",
"dsu", "[?] <address>", "Step until <address>. See 'dsu?' for other step until cmds.",
"ds", "", "step one instruction",
"ds", " <num>", "step <num> instructions",
"dsb", "", "step back one instruction",
"dsf", "", "step until end of frame",
"dsi", " <cond>", "continue until condition matches",
"dsl", "", "step one source line",
"dsl", " <num>", "step <num> source lines",
"dso", " <num>", "step over <num> instructions",
"dsp", "", "step into program (skip libs)",
"dss", " <num>", "skip <num> step instructions",
"dsu", "[?] <address>", "step until <address>. See 'dsu?' for other step until cmds.",
NULL
};
static const char *help_msg_dsu[] = {
"Usage: dsu", "", "Step until commands",
"dsu", " <address>", "Step until <address>",
"dsui", " <instr>", "Step until an instruction disasm matches",
"dsu", " <address>", "step until <address>",
"dsui", " <instr>", "step until an instruction disasm matches",
"dsuir", " <regex>", "like dsui, but using a regexp",
"dsuo", " <optype> [<optype> ...]", "Step until an instr matches one of the <optype>s.",
"dsue", " <esil>", "Step until <esil> expression matches",
"dsuf", " <flag>", "Step until pc == <flag> matching name",
"dsuo", " <optype> [<optype> ...]", "step until an instr matches one of the <optype>s.",
"dsue", " <esil>", "step until <esil> expression matches",
"dsuf", " <flag>", "step until pc == <flag> matching name",
NULL
};
static const char *help_msg_dt[] = {
"Usage: dt", "", "Trace commands",
"dt", "", "List all traces ",
"dt", " [addr]", "Show trace info at address",
"dt", "", "list all traces ",
"dt", " [addr]", "show trace info at address",
"dt%", "", "TODO",
"dt*", "", "List all traced opcode offsets",
"dt+"," [addr] [times]", "Add trace for address N times",
"dt-", "", "Reset traces (instruction/calls)",
"dt=", "", "Show ascii-art color bars with the debug trace ranges",
"dta", " 0x804020 ...", "Only trace given addresses",
"dtc[?][addr]|([from] [to] [addr])", "", "Trace call/ret",
"dtd", "[qi] [nth-start]", "List all traced disassembled (quiet, instructions)",
"dte", "[?]", "Show esil trace logs",
"dtg", "", "Graph call/ret trace",
"dtg*", "", "Graph in agn/age commands. use .dtg*;aggi for visual",
"dtgi", "", "Interactive debug trace",
"dts", "[?]", "Trace sessions",
"dtt", " [tag]", "Select trace tag (no arg unsets)",
"dt*", "", "list all traced opcode offsets",
"dt+"," [addr] [times]", "add trace for address N times",
"dt-", "", "reset traces (instruction/calls)",
"dt=", "", "show ascii-art color bars with the debug trace ranges",
"dta", " 0x804020 ...", "only trace given addresses",
"dtc[?][addr]|([from] [to] [addr])", "", "trace call/ret",
"dtd", "[qi] [nth-start]", "list all traced disassembled (quiet, instructions)",
"dte", "[?]", "show esil trace logs",
"dtg", "", "graph call/ret trace",
"dtg*", "", "graph in agn/age commands. use .dtg*;aggi for visual",
"dtgi", "", "interactive debug trace",
"dts", "[?]", "trace sessions",
"dtt", " [tag]", "select trace tag (no arg unsets)",
NULL
};
static const char *help_msg_dte[] = {
"Usage:", "dte", " Show esil trace logs",
"dte", "", "Esil trace log for a single instruction",
"dte", " [idx]", "Show commands for that index log",
"dte", "-*", "Delete all esil traces",
"dtei", "", "Esil trace log single instruction",
"dtek", " [sdb query]", "Esil trace log single instruction from sdb",
"dte", "", "esil trace log for a single instruction",
"dte", " [idx]", "show commands for that index log",
"dte", "-*", "delete all esil traces",
"dtei", "", "esil trace log single instruction",
"dtek", " [sdb query]", "esil trace log single instruction from sdb",
NULL
};
static const char *help_msg_dts[] = {
"Usage:", "dts[*]", "",
"dts+", "", "Start trace session",
"dts-", "", "Stop trace session",
"dtst", " [dir] ", "Save trace sessions to disk",
"dtsf", " [dir] ", "Read trace sessions from disk",
"dtsm", "", "List current memory map and hash",
"dts+", "", "start trace session",
"dts-", "", "stop trace session",
"dtst", " [dir] ", "save trace sessions to disk",
"dtsf", " [dir] ", "read trace sessions from disk",
"dtsm", "", "list current memory map and hash",
NULL
};
static const char *help_msg_dx[] = {
"Usage: dx", "", " # Code injection commands",
"dx", " <opcode>...", "Inject opcodes",
"dxa", " nop", "Assemble code and inject",
"dxc", " addr arg1 arg2 arg3", "Compile egg expression and inject it",
"dxe", " egg-expr", "Compile egg expression and inject it",
"dxr", " <opcode>...", "Inject opcodes and restore state",
"dxs", " write 1, 0x8048, 12", "Syscall injection (see gs)",
"dx", " <opcode>...", "inject opcodes",
"dxa", " nop", "assemble code and inject",
"dxc", " addr arg1 arg2 arg3", "compile egg expression and inject it",
"dxe", " egg-expr", "compile egg expression and inject it",
"dxr", " <opcode>...", "inject opcodes and restore state",
"dxs", " write 1, 0x8048, 12", "syscall injection (see gs)",
"\nExamples:", "", "",
"dx", " 9090", "Inject two x86 nop",
"\"dxa mov eax,6;mov ebx,0;int 0x80\"", "", "Inject and restore state",
"dx", " 9090", "inject two x86 nop",
"\"dxa mov eax,6;mov ebx,0;int 0x80\"", "", "inject and restore state",
NULL
};
static const char *help_msg_dL[] = {
"Usage: dL", "", " # List or set debugger handler",
"dL", "", "List debugger handlers",
"dLq", "", "List debugger handlers in quiet mode",
"dLj", "", "List debugger handlers in json mode",
"dL", " <handler>", "Set debugger handler",
"dL", "", "list debugger handlers",
"dLq", "", "list debugger handlers in quiet mode",
"dLj", "", "list debugger handlers in json mode",
"dL", " <handler>", "set debugger handler",
NULL
};

26
libr/core/cmd_egg.c
View File

@ -6,19 +6,19 @@
static const char *help_msg_g[] = {
"Usage:", "g[wcilper] [arg]", "Go compile shellcodes",
"g", " ", "Compile the shellcode",
"g", " foo.r", "Compile r_egg source file",
"gw", "", "Compile and write",
"gc", " cmd=/bin/ls", "Set config option for shellcodes and encoders",
"gc", "", "List all config options",
"gL", "[?]", "List plugins (shellcodes, encoders)",
"gs", " name args", "Compile syscall name(args)",
"gi", " [type]", "Define the shellcode type",
"git", " [...]", "Your favourite version control",
"gp", " padding", "Define padding for command",
"ge", " [encoder] [key]", "Specify an encoder and a key",
"gr", "", "Reset r_egg",
"gS", "", "Show the current configuration",
"g", " ", "compile the shellcode",
"g", " foo.r", "compile r_egg source file",
"gw", "", "compile and write",
"gc", " cmd=/bin/ls", "set config option for shellcodes and encoders",
"gc", "", "list all config options",
"gL", "[?]", "list plugins (shellcodes, encoders)",
"gs", " name args", "compile syscall name(args)",
"gi", " [type]", "define the shellcode type",
"git", " [...]", "your favourite version control",
"gp", " padding", "define padding for command",
"ge", " [encoder] [key]", "specify an encoder and a key",
"gr", "", "reset r_egg",
"gS", "", "show the current configuration",
"EVAL VARS:", "", "asm.arch, asm.bits, asm.os",
NULL
};

18
libr/core/cmd_flag.c
View File

@ -72,15 +72,15 @@ static const char *help_msg_f[] = {
static const char *help_msg_fc[] = {
"Usage: fc", "<flagname> [color]", " # List colors with 'ecs'",
"fc", "", "Same as fc.",
"fc", " color", "Set color to all flags in current offset",
"fc", " flag=color", "Set color to given flag. Same as 'fc color@flag'",
"fc.", "", "Get color of all flags in current offset",
"fc-", "", "Remove color from current offset",
"fc-", "flagname", "Remove color from given flag",
"fc-*", "", "Reset all color flags",
"fc*", "", "List all flags colors in r2 commands",
"fc.*", "", "Set color to all flags in current offset",
"fc", "", "same as fc.",
"fc", " color", "set color to all flags in current offset",
"fc", " flag=color", "set color to given flag. Same as 'fc color@flag'",
"fc.", "", "get color of all flags in current offset",
"fc-", "", "remove color from current offset",
"fc-", "flagname", "remove color from given flag",
"fc-*", "", "reset all color flags",
"fc*", "", "list all flags colors in r2 commands",
"fc.*", "", "set color to all flags in current offset",
NULL
};

2
libr/core/cmd_help.c
View File

@ -301,7 +301,7 @@ static const char *help_msg_question_v[] = {
"$e", "", "1 if end of block, else 0",
"$e", "{flag}", "end of flag (flag->offset + flag->size)",
"$f", "", "jump fail address (e.g. jz 0x10 => next instruction)",
"$F", "", "Same as $FB",
"$F", "", "same as $FB",
"$Fb", "", "begin of basic block",
"$FB", "", "begin of function",
"$Fe", "", "end of basic block",

100
libr/core/cmd_info.c
View File

@ -6,68 +6,68 @@
static const char *help_msg_i[] = {
"Usage: i", "", "Get info from opened file (see rabin2's manpage)",
"Output mode:", "", "",
"'*'", "", "Output in radare commands",
"'j'", "", "Output in json",
"'q'", "", "Simple quiet output",
"'*'", "", "output in radare commands",
"'j'", "", "output in json",
"'q'", "", "simple quiet output",
"Actions:", "", "",
"i|ij", "", "Show info of current file (in JSON)",
"iA", "", "List archs",
"ia", "", "Show all info (imports, exports, sections..)",
"ib", "", "Reload the current buffer for setting of the bin (use once only)",
"i|ij", "", "show info of current file (in JSON)",
"iA", "", "list archs",
"ia", "", "show all info (imports, exports, sections..)",
"ib", "", "reload the current buffer for setting of the bin (use once only)",
"ic", "", "List classes, methods and fields",
"icc", "", "List classes, methods and fields in Header Format",
"icg", "", "List classes as agn/age commands to create class hirearchy graphs",
"icq", "", "List classes, in quiet mode (just the classname)",
"icqq", "", "List classes, in quieter mode (only show non-system classnames)",
"iC", "[j]", "Show signature info (entitlements, ...)",
"id", "[?]", "Show DWARF source lines information",
"iD", " lang sym", "Demangle symbolname for given language",
"ie", "", "Entrypoint",
"iee", "", "Show Entry and Exit (preinit, init and fini)",
"iE", "", "Exports (global symbols)",
"iE.", "", "Current export",
"ih", "", "Headers (alias for iH)",
"iHH", "", "Verbose Headers in raw text",
"ii", "", "Imports",
"iI", "", "Binary info",
"ik", " [query]", "Key-value database from RBinObject",
"il", "", "Libraries",
"iL ", "[plugin]", "List all RBin plugins loaded or plugin details",
"im", "", "Show info about predefined memory allocation",
"iM", "", "Show main address",
"io", " [file]", "Load info from file (or last opened) use bin.baddr",
"iO", "[?]", "Perform binary operation (dump, resize, change sections, ...)",
"ir", "", "List the Relocations",
"iR", "", "List the Resources",
"is", "", "List the Symbols",
"is,", "[table-query]", "List symbols in table using given expression",
"is.", "", "Current symbol",
"iS ", "[entropy,sha1]", "Sections (choose which hash algorithm to use)",
"iS.", "", "Current section",
"iS,", "[table-query]", "List sections in table using given expression",
"iS=", "", "Show ascii-art color bars with the section ranges",
"iSS", "", "List memory segments (maps with om)",
"it", "", "File hashes",
"iT", "", "File signature",
"iV", "", "Display file version info",
"iw", "", "Show try/catch blocks",
"iX", "", "Display source files used (via dwarf)",
"iz", "[?][j]", "Strings in data sections (in JSON/Base64)",
"izz", "", "Search for Strings in the whole binary",
"izzz", "", "Dump Strings from whole binary to r2 shell (for huge files)",
"iz-", " [addr]", "Purge string via bin.str.purge",
"iZ", "", "Guess size of binary program",
"iC", "[j]", "show signature info (entitlements, ...)",
"id", "[?]", "show DWARF source lines information",
"iD", " lang sym", "demangle symbolname for given language",
"ie", "", "entrypoint",
"iee", "", "show Entry and Exit (preinit, init and fini)",
"iE", "", "exports (global symbols)",
"iE.", "", "current export",
"ih", "", "headers (alias for iH)",
"iHH", "", "verbose Headers in raw text",
"ii", "", "imports",
"iI", "", "binary info",
"ik", " [query]", "key-value database from RBinObject",
"il", "", "libraries",
"iL ", "[plugin]", "list all RBin plugins loaded or plugin details",
"im", "", "show info about predefined memory allocation",
"iM", "", "show main address",
"io", " [file]", "load info from file (or last opened) use bin.baddr",
"iO", "[?]", "perform binary operation (dump, resize, change sections, ...)",
"ir", "", "list the Relocations",
"iR", "", "list the Resources",
"is", "", "list the Symbols",
"is,", "[table-query]", "list symbols in table using given expression",
"is.", "", "current symbol",
"iS ", "[entropy,sha1]", "sections (choose which hash algorithm to use)",
"iS.", "", "current section",
"iS,", "[table-query]", "list sections in table using given expression",
"iS=", "", "show ascii-art color bars with the section ranges",
"iSS", "", "list memory segments (maps with om)",
"it", "", "file hashes",
"iT", "", "file signature",
"iV", "", "display file version info",
"iw", "", "show try/catch blocks",
"iX", "", "display source files used (via dwarf)",
"iz", "[?][j]", "strings in data sections (in JSON/Base64)",
"izz", "", "search for Strings in the whole binary",
"izzz", "", "dump Strings from whole binary to r2 shell (for huge files)",
"iz-", " [addr]", "purge string via bin.str.purge",
"iZ", "", "guess size of binary program",
NULL
};
// TODO: this command needs a refactoring
static const char *help_msg_id[] = {
"Usage: idp", "", "Debug information",
"id", "", "Show DWARF source lines information",
"idp", " [file.pdb]", "Load pdb file information",
"idpi", " [file.pdb]", "Show pdb file information",
"idpi*", "", "Show symbols from pdb as flags (prefix with dot to import)",
"idpd", "", "Download pdb file on remote server",
"id", "", "show DWARF source lines information",
"idp", " [file.pdb]", "load pdb file information",
"idpi", " [file.pdb]", "show pdb file information",
"idpi*", "", "show symbols from pdb as flags (prefix with dot to import)",
"idpd", "", "download pdb file on remote server",
NULL
};

4
libr/core/cmd_log.c
View File

@ -42,8 +42,8 @@ static const char *help_msg_T[] = {
"Tm", " [idx]", "display log messages without index",
"Ts", "", "list files in current directory (see pwd, cd)",
"TT", "", "enter into the text log chat console",
"T=", "[.]", "Pull logs from remote r2 instance specified by http.sync",
"T=&", "", "Start background thread syncing with the remote server",
"T=", "[.]", "pull logs from remote r2 instance specified by http.sync",
"T=&", "", "start background thread syncing with the remote server",
NULL
};

18
libr/core/cmd_meta.c
View File

@ -67,12 +67,12 @@ static const char *help_msg_CC[] = {
static const char *help_msg_CL[] = {
"Usage: CL", ".j-", "@addr - manage code-line references (loaded via bin.dbginfo and shown when asm.dwarf)",
"CL", "", "list all code line information (virtual address <-> source file:line)",
"CLj", "", "Same as above but in JSON format (See dir.source to change the path to find the referenced lines)",
"CL*", "", "Same as above but in r2 commands format",
"CL.", "", "Show list all code line information (virtual address <-> source file:line)",
"CL-", "*", "Remove all the cached codeline information",
"CL", " addr file:line", "Register new file:line source details, r2 will slurp the line",
"CL", " addr base64:text", "Register new source details for given address using base64",
"CLj", "", "same as above but in JSON format (See dir.source to change the path to find the referenced lines)",
"CL*", "", "same as above but in r2 commands format",
"CL.", "", "show list all code line information (virtual address <-> source file:line)",
"CL-", "*", "remove all the cached codeline information",
"CL", " addr file:line", "register new file:line source details, r2 will slurp the line",
"CL", " addr base64:text", "register new source details for given address using base64",
NULL
};
@ -123,7 +123,7 @@ static const char *help_msg_Cvb[] = {
"Cvb", "", "list all base pointer args/vars comments in human friendly format",
"Cvb*", "", "list all base pointer args/vars comments in r2 format",
"Cvb-", "[name]", "delete comments for var/arg at current offset for base pointer",
"Cvb", " [name]", "Show comments for var/arg at current offset for base pointer",
"Cvb", " [name]", "show comments for var/arg at current offset for base pointer",
"Cvb", " [name] [comment]", "add/append comment for the variable with the current name",
"Cvb!", "[name]", "edit comment using cfg editor",
NULL
@ -135,7 +135,7 @@ static const char *help_msg_Cvr[] = {
"Cvr", "", "list all register based args comments in human friendly format",
"Cvr*", "", "list all register based args comments in r2 format",
"Cvr-", "[name]", "delete comments for register based arg for that name",
"Cvr", "[name]", "Show comments for register based arg for that name",
"Cvr", "[name]", "show comments for register based arg for that name",
"Cvr", "[name] [comment]", "add/append comment for the variable",
"Cvr!", "[name]", "edit comment using cfg editor",
NULL
@ -146,7 +146,7 @@ static const char *help_msg_Cvs[] = {
"Cvs!", "[name]", "edit comment using cfg editor",
"Cvs", "", "list all stack based args/vars comments in human friendly format",
"Cvs", "[name] [comment]", "add/append comment for the variable",
"Cvs", "[name]", "Show comments for stack pointer var/arg with that name",
"Cvs", "[name]", "show comments for stack pointer var/arg with that name",
"Cvs*", "", "list all stack based args/vars comments in r2 format",
"Cvs-", "[name]", "delete comments for stack pointer var/arg with that name",
"Cvs?", "", "show this help",

38
libr/core/cmd_mount.c
View File

@ -2,25 +2,25 @@
static const char *help_msg_m[] = {
"Usage:", "m[-?*dgy] [...] ", "Mountpoints management",
"m", " /mnt ext2 0", "Mount ext2 fs at /mnt with delta 0 on IO",
"m", " /mnt", "Mount fs at /mnt with autodetect fs and current offset",
"m", "", "List all mountpoints in human readable format",
"m*", "", "Same as above, but in r2 commands",
"m-/", "", "Umount given path (/)",
"mL", "", "List filesystem plugins (Same as Lm)",
"mc", " [file]", "Cat: Show the contents of the given file",
"md", " /", "List directory contents for path",
"mf", "[?] [o|n]", "Search files for given filename or for offset",
"mg", " /foo [offset size]", "Get fs file/dir and dump to disk (support base64:)",
"mi", " /foo/bar", "Get offset and size of given file",
"mj", "", "List mounted filesystems in JSON",
"mo", " /foo/bar", "Open given file into a malloc://",
"mp", " msdos 0", "Show partitions in msdos format at offset 0",
"mp", "", "List all supported partition types",
"ms", " /mnt", "Open filesystem prompt at /mnt",
"mw", " [file] [data]", "Write data into file", // TODO: add mwf
"mwf", " [diskfile] [r2filepath]", "Write contents of local diskfile into r2fs mounted path",
"my", "", "Yank contents of file into clipboard",
"m", " /mnt ext2 0", "mount ext2 fs at /mnt with delta 0 on IO",
"m", " /mnt", "mount fs at /mnt with autodetect fs and current offset",
"m", "", "list all mountpoints in human readable format",
"m*", "", "same as above, but in r2 commands",
"m-/", "", "umount given path (/)",
"mL", "", "list filesystem plugins (Same as Lm)",
"mc", " [file]", "cat: Show the contents of the given file",
"md", " /", "list directory contents for path",
"mf", "[?] [o|n]", "search files for given filename or for offset",
"mg", " /foo [offset size]", "get fs file/dir and dump to disk (support base64:)",
"mi", " /foo/bar", "get offset and size of given file",
"mj", "", "list mounted filesystems in JSON",
"mo", " /foo/bar", "open given file into a malloc://",
"mp", " msdos 0", "show partitions in msdos format at offset 0",
"mp", "", "list all supported partition types",
"ms", " /mnt", "open filesystem prompt at /mnt",
"mw", " [file] [data]", "write data into file", // TODO: add mwf
"mwf", " [diskfile] [r2filepath]", "write contents of local diskfile into r2fs mounted path",
"my", "", "yank contents of file into clipboard",
//"TODO: support multiple mountpoints and RFile IO's (need io+core refactorn",
NULL
};

44
libr/core/cmd_open.c
View File

@ -17,7 +17,7 @@ static const char *help_msg_o[] = {
"o:"," [len]","open a malloc://[len] copying the bytes from current offset",
"o=","","list opened files (ascii-art bars)",
"oL","","list all IO plugins registered",
"oa","[?][-] [A] [B] [filename]","Specify arch and bits for given file",
"oa","[?][-] [A] [B] [filename]","specify arch and bits for given file",
"ob","[?] [lbdos] [...]","list opened binary files backed by fd",
"oc"," [file]","open core file, like relaunching r2",
"of","[?] [file]","open file and map it at addr 0 as read-only",
@ -47,7 +47,7 @@ static const char *help_msg_on[] = {
static const char *help_msg_oa[] = {
"Usage: oa","[-][arch] [bits] ([file])", "Specify arch and bits for given file",
"oa"," arm 32","Force arm32 for the current open file",
"oa"," arm 32","force arm32 for the current open file",
NULL
};
@ -97,31 +97,31 @@ static const char *help_msg_o_star[] = {
static const char *help_msg_oba[] = {
"Usage:", "oba [addr] ([filename])", " # load bininfo and update flags",
"oba", " [addr]", "Open bin info from the given address",
"oba", " [addr] [baddr]", "Open file and load bin info at given address",
"oba", " [addr] [/abs/filename]", "Open file and load bin info at given address",
"oba", " [addr]", "open bin info from the given address",
"oba", " [addr] [baddr]", "open file and load bin info at given address",
"oba", " [addr] [/abs/filename]", "open file and load bin info at given address",
NULL
};
static const char *help_msg_ob[] = {
"Usage:", "ob", " # List open binary files backed by fd",
"ob", " [bfid]", "Switch to open given objid",
"ob", "", "List opened binary files and objid",
"ob*", "", "List opened binary files and objid (r2 commands)",
"ob", " *", "Select all bins (use 'ob bfid' to pick one)",
"ob-", "*", "Delete all binfiles",
"ob-", "[objid]", "Delete binfile by binobjid",
"ob.", " ([addr])", "Show bfid at current address",
"ob=", "", "Show ascii art table having the list of open files",
"obL", "", "Same as iL or Li",
"oba", " [addr] [baddr]", "Open file and load bin info at given address",
"oba", " [addr] [filename]", "Open file and load bin info at given address",
"oba", " [addr]", "Open bin info from the given address",
"obf", " ([file])", "Load bininfo for current file (useful for r2 -n)",
"obj", "", "List opened binary files and objid (JSON format)",
"obn", " [name]", "Select binfile by name",
"obo", " [fd]", "Switch to open binfile by fd number",
"obr", " [baddr]", "Rebase current bin object",
"ob", " [bfid]", "switch to open given objid",
"ob", "", "list opened binary files and objid",
"ob*", "", "list opened binary files and objid (r2 commands)",
"ob", " *", "select all bins (use 'ob bfid' to pick one)",
"ob-", "*", "delete all binfiles",
"ob-", "[objid]", "delete binfile by binobjid",
"ob.", " ([addr])", "show bfid at current address",
"ob=", "", "show ascii art table having the list of open files",
"obL", "", "same as iL or Li",
"oba", " [addr] [baddr]", "open file and load bin info at given address",
"oba", " [addr] [filename]", "open file and load bin info at given address",
"oba", " [addr]", "open bin info from the given address",
"obf", " ([file])", "load bininfo for current file (useful for r2 -n)",
"obj", "", "list opened binary files and objid (JSON format)",
"obn", " [name]", "select binfile by name",
"obo", " [fd]", "switch to open binfile by fd number",
"obr", " [baddr]", "rebase current bin object",
NULL
};

82
libr/core/cmd_print.c
View File

@ -261,7 +261,7 @@ static const char *help_msg_pd[] = {
static const char *help_msg_pda[] = {
"Usage:", "pda[j]", "Print disassembly of all possbile opcodes",
"pdaj", "", "Display the disassembly of all possbile opcodes (byte per byte) in JSON",
"pdaj", "", "display the disassembly of all possbile opcodes (byte per byte) in JSON",
NULL
};
@ -294,8 +294,8 @@ static const char *help_msg_pdr[] = {
static const char *help_msg_pds[] = {
"Usage:", "pds[bf]", "Summarize N bytes or function",
"pdsf", "", "Summarize the current function",
"pdsb", "", "Summarize N bytes",
"pdsf", "", "summarize the current function",
"pdsb", "", "summarize N bytes",
NULL
};
@ -313,26 +313,26 @@ static const char *help_msg_pdu[] = {
static const char *help_msg_pf[] = {
"Usage:", PF_USAGE_STR, "",
"Commands:", "", "",
"pf", " fmt", "Show data using the given format-string. See 'pf\?\?' and 'pf\?\?\?'.",
"pf", "?", "Help on commands",
"pf", "??", "Help on format characters",
"pf", "???", "Show usage examples",
"pf* ", "fmt_name|fmt", "Show data using (named) format as r2 flag create commands",
"pf.", "", "List all format definitions",
"pf.", "fmt_name", "Show data using named format",
"pf.", "fmt_name.field_name", "Show specific data field using named format",
"pf.", "fmt_name.field_name=33", "Set new value for the specified field in named format",
"pf.", "fmt_name.field_name[i]", "Show element i of array field_name",
"pf.", "fmt_name [0|cnt]fmt", "Define a new named format",
"pf?", "fmt_name", "Show the definition of a named format",
"pfc ", "fmt_name|fmt", "Show data using (named) format as C string",
"pfd.", "fmt_name", "Show data using named format as graphviz commands",
"pfj ", "fmt_name|fmt", "Show data using (named) format in JSON",
"pfo", " fdf_name", "Load a Format Definition File (fdf)",
"pfo", "", "List all format definition files (fdf)",
"pfq", " fmt ...", "Quiet print format (do now show address)",
"pfs", "[.fmt_name| fmt]", "Print the size of (named) format in bytes",
"pfv.", "fmt_name[.field]", "Print value(s) only for named format. Useful for one-liners",
"pf", " fmt", "show data using the given format-string. See 'pf\?\?' and 'pf\?\?\?'.",
"pf", "?", "help on commands",
"pf", "??", "help on format characters",
"pf", "???", "show usage examples",
"pf* ", "fmt_name|fmt", "show data using (named) format as r2 flag create commands",
"pf.", "", "list all format definitions",
"pf.", "fmt_name", "show data using named format",
"pf.", "fmt_name.field_name", "show specific data field using named format",
"pf.", "fmt_name.field_name=33", "set new value for the specified field in named format",
"pf.", "fmt_name.field_name[i]", "show element i of array field_name",
"pf.", "fmt_name [0|cnt]fmt", "define a new named format",
"pf?", "fmt_name", "show the definition of a named format",
"pfc ", "fmt_name|fmt", "show data using (named) format as C string",
"pfd.", "fmt_name", "show data using named format as graphviz commands",
"pfj ", "fmt_name|fmt", "show data using (named) format in JSON",
"pfo", " fdf_name", "load a Format Definition File (fdf)",
"pfo", "", "list all format definition files (fdf)",
"pfq", " fmt ...", "quiet print format (do now show address)",
"pfs", "[.fmt_name| fmt]", "print the size of (named) format in bytes",
"pfv.", "fmt_name[.field]", "print value(s) only for named format. Useful for one-liners",
NULL
};
@ -384,25 +384,25 @@ static const char *help_detail2_pf[] = {
"pf", " 3xi foo bar", "3-array of struct, each with named fields: 'foo' as hex, and 'bar' as int",
"pf", " B (BitFldType)arg_name`", "bitfield type",
"pf", " E (EnumType)arg_name`", "enum type",
"pf", " obj=xxdz prev next size name", "Same as above",
"pf", " *z*i*w nb name blob", "Print the pointers with given labels",
"pf", " iwq foo bar troll", "Print the iwq format with foo, bar, troll as the respective names for the fields",
"pf", " 0iwq foo bar troll", "Same as above, but considered as a union (all fields at offset 0)",
"pf.", "obj xxdz prev next size name", "Define the obj format as xxdz",
"pf.", "plop ? (troll)mystruct", "Use structure troll previously defined",
"pfj.", "plop @ 0x14", "Apply format object at the given offset",
"pf", " 10xiz pointer length string", "Print a size 10 array of the xiz struct with its field names",
"pf", " 5sqw string quad word", "Print an array with sqw struct along with its field names",
"pf", " {integer}? (bifc)", "Print integer times the following format (bifc)",
"pf", " [4]w[7]i", "Print an array of 4 words and then an array of 7 integers",
"pf", " ic...?i foo bar \"(pf xw yo foo)troll\" yo", "Print nested anonymous structures",
"pf", " ;..x", "Print value located 6 bytes from current offset",
"pf", " [10]z[3]i[10]Zb", "Print an fixed size str, widechar, and var",
"pfj", " +F @ 0x14","Print the content at given offset with flag",
"pf", " obj=xxdz prev next size name", "same as above",
"pf", " *z*i*w nb name blob", "print the pointers with given labels",
"pf", " iwq foo bar troll", "print the iwq format with foo, bar, troll as the respective names for the fields",
"pf", " 0iwq foo bar troll", "same as above, but considered as a union (all fields at offset 0)",
"pf.", "obj xxdz prev next size name", "define the obj format as xxdz",
"pf.", "plop ? (troll)mystruct", "use structure troll previously defined",
"pfj.", "plop @ 0x14", "apply format object at the given offset",
"pf", " 10xiz pointer length string", "print a size 10 array of the xiz struct with its field names",
"pf", " 5sqw string quad word", "print an array with sqw struct along with its field names",
"pf", " {integer}? (bifc)", "print integer times the following format (bifc)",
"pf", " [4]w[7]i", "print an array of 4 words and then an array of 7 integers",
"pf", " ic...?i foo bar \"(pf xw yo foo)troll\" yo", "print nested anonymous structures",
"pf", " ;..x", "print value located 6 bytes from current offset",
"pf", " [10]z[3]i[10]Zb", "print an fixed size str, widechar, and var",
"pfj", " +F @ 0x14","print the content at given offset with flag",
"pf", " n2", "print signed short (2 bytes) value. Use N instead of n for printing unsigned values",
"pf", " [2]? (plop)structname @ 0", "Prints an array of structs",
"pf", " eqew bigWord beef", "Swap endianness and print with given labels",
"pf", ".foo rr (eax)reg1 (eip)reg2", "Create object referencing to register values ",
"pf", " [2]? (plop)structname @ 0", "prints an array of structs",
"pf", " eqew bigWord beef", "swap endianness and print with given labels",
"pf", ".foo rr (eax)reg1 (eip)reg2", "create object referencing to register values ",
"pf", " tt troll plop", "print time stamps with labels troll and plop",
NULL
};

4
libr/core/cmd_project.c
View File

@ -16,8 +16,8 @@ static const char *help_msg_P[] = {
"Ps", " [file]", "save project",
"PS", " [file]", "save script file",
"P-", " [file]", "delete project (alias for Pd)",
"NOTE:", "", "The 'e prj.name' evar can save/open/rename/list projects.",
"NOTE:", "", "See the other 'e??prj.' evars for more options.",
"NOTE:", "", "the 'e prj.name' evar can save/open/rename/list projects.",
"NOTE:", "", "see the other 'e??prj.' evars for more options.",
"NOTE:", "", "project are stored in " R_JOIN_2_PATHS ("~", R2_HOME_PROJECTS),
NULL
};

80
libr/core/cmd_search.c
View File

@ -147,35 +147,35 @@ static const char *help_msg_slash[] = {
static const char *help_msg_slash_a[] = {
"Usage:", "/a[?] [arg]", "Search for assembly instructions matching given properties",
"/a", " push rbp", "Assemble given instruction and search the bytes",
"/a1", " [number]", "Find valid assembly generated by changing only the nth byte",
"/aI", "", "Search for infinite loop instructions (jmp $$)",
"/aa", " mov eax", "Linearly find aproximated assembly (case insensitive strstr)",
"/ab", " [delta]", "Search for backward jumps (usually loops)",
"/ac", " mov eax", "Same as /aa, but case-sensitive",
"/ad", "[/*j] push;mov", "Match ins1 followed by ins2 in linear disasm",
"/ad/", " ins1;ins2", "Search for regex instruction 'ins1' followed by regex 'ins2'",
"/ad/a", " instr", "Search for every byte instruction that matches regexp 'instr'",
"/ae", " esil", "Search for esil expressions matching substring",
"/af", "[l] family", "Search for instruction of specific family (afl=list",
"/a", " push rbp", "assemble given instruction and search the bytes",
"/a1", " [number]", "find valid assembly generated by changing only the nth byte",
"/aI", "", "search for infinite loop instructions (jmp $$)",
"/aa", " mov eax", "linearly find aproximated assembly (case insensitive strstr)",
"/ab", " [delta]", "search for backward jumps (usually loops)",
"/ac", " mov eax", "same as /aa, but case-sensitive",
"/ad", "[/*j] push;mov", "match ins1 followed by ins2 in linear disasm",
"/ad/", " ins1;ins2", "search for regex instruction 'ins1' followed by regex 'ins2'",
"/ad/a", " instr", "search for every byte instruction that matches regexp 'instr'",
"/ae", " esil", "search for esil expressions matching substring",
"/af", "[l] family", "search for instruction of specific family (afl=list",
"/aF", " opstr", "find instructions matching given opstr only in analyzed code",
"/ai", "[j] 0x300 [0x500]", "Find all the instructions using that immediate (in range)",
"/al", "", "Same as aoml, list all opcodes",
"/am", " opcode", "Search for specific instructions of specific mnemonic",
"/ao", " instr", "Search for instruction 'instr' (in all offsets)",
"/as", "[l] ([type])", "Search for syscalls (See /at swi and /af priv)",
"/at", "[l] ([type])", "Search for instructions of given type",
"/ai", "[j] 0x300 [0x500]", "find all the instructions using that immediate (in range)",
"/al", "", "same as aoml, list all opcodes",
"/am", " opcode", "search for specific instructions of specific mnemonic",
"/ao", " instr", "search for instruction 'instr' (in all offsets)",
"/as", "[l] ([type])", "search for syscalls (See /at swi and /af priv)",
"/at", "[l] ([type])", "search for instructions of given type",
NULL
};
static const char *help_msg_slash_c[] = {
"Usage: /c", "", "Search for crypto materials",
"/ca", "", "Search for AES keys expanded in memory",
"/cc", "[algo] [digest]", "Find collisions (bruteforce block length values until given checksum is found)",
"/cd", "", "Search for ASN1/DER certificates",
"/cg", "", "Search for GPG/PGP keys and signatures (Plaintext and binary form)",
"/ck", "", "Find well known constant tables from different hash and crypto algorithms",
"/cr", "", "Search for ASN1/DER private keys (RSA and ECC)",
"/ca", "", "search for AES keys expanded in memory",
"/cc", "[algo] [digest]", "find collisions (bruteforce block length values until given checksum is found)",
"/cd", "", "search for ASN1/DER certificates",
"/cg", "", "search for GPG/PGP keys and signatures (Plaintext and binary form)",
"/ck", "", "find well known constant tables from different hash and crypto algorithms",
"/cr", "", "search for ASN1/DER private keys (RSA and ECC)",
NULL
};
@ -191,35 +191,35 @@ static const char *help_msg_slash_r[] = {
"/ra", "", "search all references",
"/rc", "", "search for call references",
"/re", " [addr]", "search references using esil",
"/rr", "", "Find read references",
"/ru", "[*qj]", "Search for UDS CAN database tables (binbloom)",
"/rw", "", "Find write references",
"/rx", "", "Find exec references",
"/rr", "", "find read references",
"/ru", "[*qj]", "search for UDS CAN database tables (binbloom)",
"/rw", "", "find write references",
"/rx", "", "find exec references",
NULL
};
static const char *help_msg_slash_R[] = {
"Usage: /R", "", "Search for ROP gadgets",
"/R", " [filter-by-string]", "Show gadgets",
"/R/", " [filter-by-regexp]", "Show gadgets [regular expression]",
"/R/j", " [filter-by-regexp]", "JSON output [regular expression]",
"/R/q", " [filter-by-regexp]", "Show gadgets in a quiet manner [regular expression]",
"/Rj", " [filter-by-string]", "JSON output",
"/Rk", " [select-by-class]", "Query stored ROP gadgets",
"/Rq", " [filter-by-string]", "Show gadgets in a quiet manner",
"Usage: /R", "", "search for ROP gadgets",
"/R", " [filter-by-string]", "show gadgets",
"/R/", " [filter-by-regexp]", "show gadgets [regular expression]",
"/R/j", " [filter-by-regexp]", "json output [regular expression]",
"/R/q", " [filter-by-regexp]", "show gadgets in a quiet manner [regular expression]",
"/Rj", " [filter-by-string]", "json output",
"/Rk", " [select-by-class]", "query stored ROP gadgets",
"/Rq", " [filter-by-string]", "show gadgets in a quiet manner",
NULL
};
static const char *help_msg_slash_Rk[] = {
"Usage: /Rk", "", "Query stored ROP gadgets",
"/Rk", " [nop|mov|const|arithm|arithm_ct]", "Show gadgets",
"/Rkj", "", "JSON output",
"/Rkq", "", "List Gadgets offsets",
"Usage: /Rk", "", "query stored ROP gadgets",
"/Rk", " [nop|mov|const|arithm|arithm_ct]", "show gadgets",
"/Rkj", "", "json output",
"/Rkq", "", "list Gadgets offsets",
NULL
};
static const char *help_msg_slash_x[] = {
"Usage:", "/x [hexpairs]:[binmask]", "Search in memory",
"Usage:", "/x [hexpairs]:[binmask]", "search in memory",
"/x ", "9090cd80", "search for those bytes",
"/x ", "9090cd80:ffff7ff0", "search with binary mask",
NULL

86
libr/core/cmd_seek.c
View File

@ -11,79 +11,79 @@ static void __core_cmd_search_backward_prelude(RCore *core, bool doseek, bool fo
static const char *help_msg_s[] = {
"Usage: s", "", " # Help for the seek commands. See ?$? to see all variables",
"s", "", "Print current address",
"s.", "[?]hexoff", "Seek honoring a base from core->offset",
"s:", "pad", "Print current address with N padded zeros (defaults to 8)",
"s", " addr", "Seek to address",
"s-", "", "Undo seek",
"s-*", "", "Reset undo seek history",
"s-", " n", "Seek n bytes backward",
"s--", "[n]", "Seek blocksize bytes backward (/=n)",
"s+", "", "Redo seek",
"s+", " n", "Seek n bytes forward",
"s++", "[n]", "Seek blocksize bytes forward (/=n)",
"s[j*=!]", "", "List undo seek history (JSON, =list, *r2, !=names, s==)",
"s/", " DATA", "Search for next occurrence of 'DATA'",
"s/x", " 9091", "Search for next occurrence of \\x90\\x91",
"sa", " [[+-]a] [asz]", "Seek asz (or bsize) aligned to addr",
"sb", "", "Seek aligned to bb start",
"sC", "[?] string", "Seek to comment matching given string",
"sf", "", "Seek to next function (f->addr+f->size)",
"sf", " function", "Seek to address of specified function",
"sf.", "", "Seek to the beginning of current function",
"sg/sG", "", "Seek begin (sg) or end (sG) of section or file",
"sl", "[?] [+-]line", "Seek to line",
"sn/sp", " ([nkey])", "Seek to next/prev location, as specified by scr.nkey",
"snp", "", "Seek to next function prelude",
"spp", "", "Seek to prev function prelude",
"so", " [N]", "Seek to N next opcode(s)",
"sr", " pc", "Seek to register",
"ss", "[?]", "Seek silently (without adding an entry to the seek history)",
"s", "", "print current address",
"s.", "[?]hexoff", "seek honoring a base from core->offset",
"s:", "pad", "print current address with N padded zeros (defaults to 8)",
"s", " addr", "seek to address",
"s-", "", "undo seek",
"s-*", "", "reset undo seek history",
"s-", " n", "seek n bytes backward",
"s--", "[n]", "seek blocksize bytes backward (/=n)",
"s+", "", "redo seek",
"s+", " n", "seek n bytes forward",
"s++", "[n]", "seek blocksize bytes forward (/=n)",
"s[j*=!]", "", "list undo seek history (JSON, =list, *r2, !=names, s==)",
"s/", " DATA", "search for next occurrence of 'DATA'",
"s/x", " 9091", "search for next occurrence of \\x90\\x91",
"sa", " [[+-]a] [asz]", "seek asz (or bsize) aligned to addr",
"sb", "", "seek aligned to bb start",
"sC", "[?] string", "seek to comment matching given string",
"sf", "", "seek to next function (f->addr+f->size)",
"sf", " function", "seek to address of specified function",
"sf.", "", "seek to the beginning of current function",
"sg/sG", "", "seek begin (sg) or end (sG) of section or file",
"sl", "[?] [+-]line", "seek to line",
"sn/sp", " ([nkey])", "seek to next/prev location, as specified by scr.nkey",
"snp", "", "seek to next function prelude",
"spp", "", "seek to prev function prelude",
"so", " [N]", "seek to N next opcode(s)",
"sr", " pc", "seek to register",
"ss", "[?]", "seek silently (without adding an entry to the seek history)",
// "sp [page] seek page N (page = block)",
NULL
};
static const char *help_msg_sdot[] = {
"Usage:", "s.", "seek here or there (near seeks)",
"s.", "", "Seek here, same as 's $$'",
"s..", "32a8", "Seek to the same address but replacing the lower nibbles",
"Usage:", "s.", "Seek here or there (near seeks)",
"s.", "", "seek here, same as 's $$'",
"s..", "32a8", "seek to the same address but replacing the lower nibbles",
NULL
};
static const char *help_msg_sC[] = {
"Usage:", "sC", "Comment grep",
"sC", "*", "List all comments",
"sC", " str", "Seek to the first comment matching 'str'",
"sC", "*", "list all comments",
"sC", " str", "seek to the first comment matching 'str'",
NULL
};
static const char *help_msg_sn[] = {
"Usage:", "sn[p]", "",
"sn", " [line]", "Seek to next address",
"snp", "", "Seek to next prelude",
"sn", " [line]", "seek to next address",
"snp", "", "seek to next prelude",
NULL
};
static const char *help_msg_sp[] = {
"Usage:", "sp[p]", "",
"sp", " [line]", "Seek to previous address",
"spp", "", "Seek to previous prelude",
"sp", " [line]", "seek to previous address",
"spp", "", "seek to previous prelude",
NULL
};
static const char *help_msg_sl[] = {
"Usage:", "sl+ or sl- or slc", "",
"sl", " [line]", "Seek to absolute line",
"sl", "[+-][line]", "Seek to relative line",
"slc", "", "Clear line cache",
"sll", "", "Show total number of lines",
"sleep", " [seconds]", "Sleep for an specific amount of time (support decimal values)",
"sl", " [line]", "seek to absolute line",
"sl", "[+-][line]", "seek to relative line",
"slc", "", "clear line cache",
"sll", "", "show total number of lines",
"sleep", " [seconds]", "sleep for an specific amount of time (support decimal values)",
NULL
};
static const char *help_msg_ss[] = {
"Usage: ss", "", " # Seek silently (not recorded in the seek history)",
"s?", "", "Works with all s subcommands",
"s?", "", "works with all s subcommands",
NULL
};

152
libr/core/cmd_type.c
View File

@ -8,45 +8,45 @@
static const char *help_msg_t[] = {
"Usage: t", "", "# cparse types commands",
"t", "", "List all loaded types",
"t", "", "list all loaded types",
"tj", "", "List all loaded types as json",
"t", " <type>", "Show type in 'pf' syntax",
"t*", "", "List types info in r2 commands",
"t-", " <name>", "Delete types by its name",
"t-*", "", "Remove all types",
"tail", " [filename]", "Output the last part of files",
"tc", " [type.name]", "List all/given types in C output format",
"te", "[?]", "List all loaded enums",
"td", "[?] <string>", "Load types from string",
"tf", "", "List all loaded functions signatures",
"tk", " <sdb-query>", "Perform sdb query",
"tl", "[?]", "Show/Link type to an address",
"t", " <type>", "show type in 'pf' syntax",
"t*", "", "list types info in r2 commands",
"t-", " <name>", "delete types by its name",
"t-*", "", "remove all types",
"tail", " [filename]", "output the last part of files",
"tc", " [type.name]", "list all/given types in C output format",
"te", "[?]", "list all loaded enums",
"td", "[?] <string>", "load types from string",
"tf", "", "list all loaded functions signatures",
"tk", " <sdb-query>", "perform sdb query",
"tl", "[?]", "show/Link type to an address",
"tn", "[?] [-][addr]", "manage noreturn function attributes and marks",
"to", " -", "Open cfg.editor to load types",
"to", " <path>", "Load types from C header file",
"toe", " [type.name]", "Open cfg.editor to edit types",
"tos", " <path>", "Load types from parsed Sdb database",
"touch", " <file>", "Create or update timestamp in file",
"to", " -", "open cfg.editor to load types",
"to", " <path>", "load types from C header file",
"toe", " [type.name]", "open cfg.editor to edit types",
"tos", " <path>", "load types from parsed Sdb database",
"touch", " <file>", "create or update timestamp in file",
"tp", " <type> [addr|varname]", "cast data at <address> to <type> and print it (XXX: type can contain spaces)",
"tpv", " <type> @ [value]", "Show offset formatted for given type",
"tpx", " <type> <hexpairs>", "Show value for type with specified byte sequence (XXX: type can contain spaces)",
"ts", "[?]", "Print loaded struct types",
"tu", "[?]", "Print loaded union types",
"tx", "[f?]", "Type xrefs",
"tt", "[?]", "List all loaded typedefs",
"tpv", " <type> @ [value]", "show offset formatted for given type",
"tpx", " <type> <hexpairs>", "show value for type with specified byte sequence (XXX: type can contain spaces)",
"ts", "[?]", "print loaded struct types",
"tu", "[?]", "print loaded union types",
"tx", "[f?]", "type xrefs",
"tt", "[?]", "list all loaded typedefs",
NULL
};
static const char *help_msg_tcc[] = {
"Usage: tcc", "[-name]", "# type function calling conventions (see also afc? and arcc)",
"tcc", "", "List all calling convcentions",
"tcc", " r0 pascal(r0,r1,r2)", "Define signature for pascall cc (see also arcc)",
"tcc", "-pascal", "Remove the pascal cc",
"tcc-*", "", "Unregister all the calling conventions",
"tcck", "", "List calling conventions in k=v",
"tccl", "", "List cc signatures (return ccname (arg0, arg1, ..) err;)",
"tccj", "", "List them in JSON",
"tcc*", "", "List them as r2 commands",
"tcc", "", "list all calling convcentions",
"tcc", " r0 pascal(r0,r1,r2)", "define signature for pascall cc (see also arcc)",
"tcc", "-pascal", "remove the pascal cc",
"tcc-*", "", "unregister all the calling conventions",
"tcck", "", "list calling conventions in k=v",
"tccl", "", "list cc signatures (return ccname (arg0, arg1, ..) err;)",
"tccj", "", "list them in JSON",
"tcc*", "", "list them as r2 commands",
NULL
};
@ -57,67 +57,67 @@ static const char *help_msg_t_minus[] = {
static const char *help_msg_tf[] = {
"Usage: tf[...]", "", "",
"tf", "", "List all function definitions loaded",
"tf", " <name>", "Show function signature",
"tfc", " <name>", "Show function signature in C syntax",
"tfcj", " <name>", "Same as above but in JSON",
"tfj", "", "List all function definitions in JSON",
"tfj", " <name>", "Show function signature in JSON",
"tf", "", "list all function definitions loaded",
"tf", " <name>", "show function signature",
"tfc", " <name>", "show function signature in C syntax",
"tfcj", " <name>", "same as above but in JSON",
"tfj", "", "list all function definitions in JSON",
"tfj", " <name>", "show function signature in JSON",
NULL
};
static const char *help_msg_to[] = {
"Usage: to[...]", "", "",
"to", " -", "Open cfg.editor to load types",
"to", " <path>", "Load types from C header file",
"tos", " <path>", "Load types from parsed Sdb database",
"touch", " <file>", "Create or update timestamp in file",
"to", " -", "open cfg.editor to load types",
"to", " <path>", "load types from C header file",
"tos", " <path>", "load types from parsed Sdb database",
"touch", " <file>", "create or update timestamp in file",
NULL
};
static const char *help_msg_tp[] = {
"Usage: tp[...]", "", "",
"tp", " <type> [addr|varname]", "cast data at <address> to <type> and print it (XXX: type can contain spaces)",
"tpv", " <type> @ [value]", "Show offset formatted for given type",
"tpx", " <type> <hexpairs>", "Show value for type with specified byte sequence (XXX: type can contain spaces)",
"tpv", " <type> @ [value]", "show offset formatted for given type",
"tpx", " <type> <hexpairs>", "show value for type with specified byte sequence (XXX: type can contain spaces)",
NULL
};
static const char *help_msg_tc[] = {
"Usage: tc[...]", " [cctype]", "",
"tc", " [type.name]", "List all/given loaded types in C output format with newlines",
"tcd", "", "List all loaded types in C output format without newlines",
"tcc", "?", "Manage calling conventions types",
"tc", " [type.name]", "list all/given loaded types in C output format with newlines",
"tcd", "", "list all loaded types in C output format without newlines",
"tcc", "?", "manage calling conventions types",
"tc?", "", "show this help",
NULL
};
static const char *help_msg_td[] = {
"Usage:", "\"td [...]\"", "",
"td", "[string]", "Load types from string",
"td", "[string]", "load types from string",
NULL
};
static const char *help_msg_te[] = {
"Usage: te[...]", "", "",
"te", "", "List all loaded enums",
"te", " <enum>", "Print all values of enum for given name",
"tej", "", "List all loaded enums in json",
"tej", " <enum>", "Show enum in json",
"te", " <enum> <value>", "Show name for given enum number",
"teb", " <enum> <name>", "Show matching enum bitfield for given name",
"tec", "<name>", "List all/given loaded enums in C output format with newlines",
"ted", "", "List all loaded enums in C output format without newlines",
"te", "", "list all loaded enums",
"te", " <enum>", "print all values of enum for given name",
"tej", "", "list all loaded enums in json",
"tej", " <enum>", "show enum in json",
"te", " <enum> <value>", "show name for given enum number",
"teb", " <enum> <name>", "show matching enum bitfield for given name",
"tec", "<name>", "list all/given loaded enums in C output format with newlines",
"ted", "", "list all loaded enums in C output format without newlines",
"te?", "", "show this help",
NULL
};
static const char *help_msg_tt[] = {
"Usage: tt[...]", "", "",
"tt", "", "List all loaded typedefs",
"tt", " <typename>", "Show name for given type alias",
"ttj", "", "Show typename and type alias in json",
"ttc", "<name>", "Show typename and type alias in C output format",
"tt", "", "list all loaded typedefs",
"tt", " <typename>", "show name for given type alias",
"ttj", "", "show typename and type alias in json",
"ttc", "<name>", "show typename and type alias in C output format",
"tt?", "", "show this help",
NULL
};
@ -149,29 +149,29 @@ static const char *help_msg_tn[] = {
static const char *help_msg_ts[] = {
"Usage: ts[...]", " [type]", "",
"ts", "", "List all loaded structs",
"ts", " [type]", "Show pf format string for given struct",
"tsj", "", "List all loaded structs in json",
"tsj", " [type]", "Show pf format string for given struct in json",
"ts*", "", "Show pf.<name> format string for all loaded structs",
"ts*", " [type]", "Show pf.<name> format string for given struct",
"tsc", "<name>", "List all/given loaded structs in C output format with newlines",
"tsd", "", "List all loaded structs in C output format without newlines",
"tss", " [type]", "Display size of struct",
"ts", "", "list all loaded structs",
"ts", " [type]", "show pf format string for given struct",
"tsj", "", "list all loaded structs in json",
"tsj", " [type]", "show pf format string for given struct in json",
"ts*", "", "show pf.<name> format string for all loaded structs",
"ts*", " [type]", "show pf.<name> format string for given struct",
"tsc", "<name>", "list all/given loaded structs in C output format with newlines",
"tsd", "", "list all loaded structs in C output format without newlines",
"tss", " [type]", "display size of struct",
"ts?", "", "show this help",
NULL
};
static const char *help_msg_tu[] = {
"Usage: tu[...]", "", "",
"tu", "", "List all loaded unions",
"tu", " [type]", "Show pf format string for given union",
"tuj", "", "List all loaded unions in json",
"tuj", " [type]", "Show pf format string for given union in json",
"tu*", "", "Show pf.<name> format string for all loaded unions",
"tu*", " [type]", "Show pf.<name> format string for given union",
"tuc", "<name>", "List all/given loaded unions in C output format with newlines",
"tud", "", "List all loaded unions in C output format without newlines",
"tu", "", "list all loaded unions",
"tu", " [type]", "show pf format string for given union",
"tuj", "", "list all loaded unions in json",
"tuj", " [type]", "show pf format string for given union in json",
"tu*", "", "show pf.<name> format string for all loaded unions",
"tu*", " [type]", "show pf.<name> format string for given union",
"tuc", "<name>", "list all/given loaded unions in C output format with newlines",
"tud", "", "list all loaded unions in C output format without newlines",
"tu?", "", "show this help",
NULL
};

6
libr/core/cmd_write.c
View File

@ -126,9 +126,9 @@ static const char *help_msg_wo[] = {
static const char *help_msg_wop[] = {
"Usage:","wop[DO]"," len @ addr | value",
"wopD"," len [@ addr]","Write a De Bruijn Pattern of length 'len' at address 'addr'",
"wopD*"," len [@ addr]","Show wx command that creates a debruijn pattern of a specific length",
"wopO"," value", "Finds the given value into a De Bruijn Pattern at current offset",
"wopD"," len [@ addr]","write a De Bruijn Pattern of length 'len' at address 'addr'",
"wopD*"," len [@ addr]","show wx command that creates a debruijn pattern of a specific length",
"wopO"," value", "finds the given value into a De Bruijn Pattern at current offset",
NULL
};