dandri/proxmark3
1
0
Fork 0
mirror of https://github.com/RfidResearchGroup/proxmark3.git synced 2026-06-06 13:22:02 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
94c0fc2edd7e56f6e6e01cbd0ff5ed11829f0c33
proxmark3/client/src/cmdscript.c
T
Shawn Hoffman 148e5ed2d1 python fixes 
now, one can do "script run mything.py" multiple times without
crashing, and exit codes are correct.

Pm3PyRun_SimpleFileNoExit:
* use XDECREF instead of DECREF (handles possible nullptr).
* don't double-free "er".
* print exit status correctly.

CmdScriptRun:
* allow invoking scripts multiple times.
* fix memleak of argtable contents if help path not triggered.
* configure_c_stdio should be 0 or 1, not < 0.
* py_conf: don't explicitly set options to their default values, it's confusing.
* Call Py_Finalize only when exiting pm3.

main_loop:
* cleanup cmdscript from main_loop. Important to call
  Py_Finalize from here in case Qt is used (in which case
  main_loop is on Qt thread).

ProxGuiQT::MainLoop:
* reduce timer delay to 0 - there isn't a need to wait here.
2026-05-22 16:38:59 -07:00

710 lines
24 KiB
C
Raw Blame History

//-----------------------------------------------------------------------------
// Copyright (C) Proxmark3 contributors. See AUTHORS.md for details.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// See LICENSE.txt for the text of the license.
//-----------------------------------------------------------------------------
// Some Lua and Python scripting glue to proxmark core.
//-----------------------------------------------------------------------------
#include <stdlib.h>
#include <string.h>
#ifdef HAVE_PYTHON
#ifdef _POSIX_C_SOURCE
#undef _POSIX_C_SOURCE
#endif
//#define PY_SSIZE_T_CLEAN
#include <Python.h>
#include <ctype.h>
#include <wchar.h>
#endif
#include "cmdparser.h" // command_t
#include "scripting.h"
#include "comms.h"
#include "cmdscript.h"
#include "cmdhfmf.h"
#include "pm3_binlib.h"
#include "pm3_bitlib.h"
#include "lualib.h"
#include "lauxlib.h"
#include "proxmark3.h"
#include "ui.h"
#include "fileutils.h"
#include "cliparser.h" // cliparsing
#ifdef HAVE_LUA_SWIG
extern int luaopen_pm3(lua_State *L);
#endif
#ifdef HAVE_PYTHON
#ifdef HAVE_PYTHON_SWIG
extern PyObject *PyInit__pm3(void);
#endif // HAVE_PYTHON_SWIG
static void Pm3Py_FlushStream(const char *stream_name) {
PyObject *flush_stream = PySys_GetObject(stream_name);
if (!flush_stream) {
return;
}
PyObject *fr = PyObject_CallMethod(flush_stream, "flush", NULL);
if (fr) {
Py_DECREF(fr);
} else {
PyErr_Clear();
}
}
// Partly ripped from PyRun_SimpleFileExFlags
// but does not terminate client on sys.exit
// and print exit code only if != 0
static int Pm3PyRun_SimpleFileNoExit(FILE *fp, const char *filename) {
PyObject *m, *d, *v;
int set_file_name = 0, ret = -1;
m = PyImport_AddModule("__main__");
if (m == NULL) {
return -1;
}
Py_INCREF(m);
d = PyModule_GetDict(m);
if (PyDict_GetItemString(d, "__file__") == NULL) {
PyObject *f;
f = PyUnicode_DecodeFSDefault(filename);
if (f == NULL) {
goto done;
}
if (PyDict_SetItemString(d, "__file__", f) < 0) {
Py_DECREF(f);
goto done;
}
if (PyDict_SetItemString(d, "__cached__", Py_None) < 0) {
Py_DECREF(f);
goto done;
}
set_file_name = 1;
Py_DECREF(f);
}
v = PyRun_FileExFlags(fp, filename, Py_file_input, d, d, 1, NULL);
if (v == NULL) {
Py_CLEAR(m);
if (PyErr_ExceptionMatches(PyExc_SystemExit)) {
// PyErr_Print() exits on SystemExit, so we handle it ourselves.
// Normalize first so `er` is a proper SystemExit instance with .code.
// CPython exit-code semantics: None -> 0, int -> int, other -> 1.
PyObject *ty = NULL, *er = NULL, *tr = NULL;
PyErr_Fetch(&ty, &er, &tr);
PyErr_NormalizeException(&ty, &er, &tr);
long err = 0;
if (er != NULL) {
PyObject *code = PyObject_GetAttrString(er, "code");
if (code != NULL && code != Py_None) {
if (PyLong_Check(code)) {
err = PyLong_AsLong(code);
} else {
err = 1;
}
}
Py_XDECREF(code);
}
if (err) {
PrintAndLogEx(WARNING, "\nScript terminated by " _YELLOW_("SystemExit %li"), err);
} else {
ret = 0;
}
Py_XDECREF(ty);
Py_XDECREF(er);
Py_XDECREF(tr);
PyErr_Clear();
goto done;
} else {
PyErr_Print();
}
goto done;
}
Py_DECREF(v);
ret = 0;
done:
// Flush sys.stdout / sys.stderr explicitly. Since we run with buffering,
// they would not otherwise be flushed until Py_Finalize.
Pm3Py_FlushStream("stdout");
Pm3Py_FlushStream("stderr");
if (set_file_name && PyDict_DelItemString(d, "__file__")) {
PyErr_Clear();
}
Py_XDECREF(m);
return ret;
}
#endif // HAVE_PYTHON
typedef enum {
PM3_UNSPECIFIED,
PM3_LUA,
PM3_CMD,
#ifdef HAVE_PYTHON
PM3_PY
#endif
} pm3_scriptfile_t;
static int CmdHelp(const char *Cmd);
#ifdef HAVE_PYTHON
#define PYTHON_LIBRARIES_WILDCARD "?.py"
static int split(char *str, char **arr) {
int begin_index = 0;
int word_cnt = 0;
while (1) {
while (isspace(str[begin_index])) {
++begin_index;
}
if (str[begin_index] == '\0') {
break;
}
int end_index = begin_index;
while (str[end_index] && !isspace(str[end_index])) {
++end_index;
}
int len = end_index - begin_index;
char *tmp = calloc(len + 1, sizeof(char));
if (tmp == NULL) {
PrintAndLogEx(ERR, "Memory allocation failed");
return -1;
}
memcpy(tmp, &str[begin_index], len);
arr[word_cnt++] = tmp;
begin_index = end_index;
}
return word_cnt;
}
static void set_python_path(const char *path) {
PyObject *syspath = PySys_GetObject("path");
if (syspath == 0) {
PrintAndLogEx(WARNING, "Python failed to getobject");
}
PyObject *pName = PyUnicode_FromString(path);
if (PyList_Insert(syspath, 0, pName)) {
PrintAndLogEx(WARNING, "Error inserting extra path into sys.path list");
}
if (PySys_SetObject("path", syspath)) {
PrintAndLogEx(WARNING, "Error setting sys.path object");
}
}
static void set_python_paths(void) {
// Prepending to sys.path so we can load scripts from various places.
// This means the following directories are in reverse order of
// priority for search python modules.
// Allow current working directory because it seems that's what users want.
// But put it with lower search priority than the typical pm3 scripts directories
// but still with a higher priority than the pip installed libraries to mimic
// Python interpreter behavior. That should be confusing the users the least.
set_python_path(".");
const char *exec_path = get_my_executable_directory();
if (exec_path != NULL) {
// from the ./pyscripts/ directory
char scripts_path[strlen(exec_path) + strlen(PYTHON_SCRIPTS_SUBDIR) + strlen(PYTHON_LIBRARIES_WILDCARD) + 1];
strcpy(scripts_path, exec_path);
strcat(scripts_path, PYTHON_SCRIPTS_SUBDIR);
// strcat(scripts_path, PYTHON_LIBRARIES_WILDCARD);
set_python_path(scripts_path);
}
const char *user_path = get_my_user_directory();
if (user_path != NULL) {
// from the $HOME/.proxmark3/pyscripts/ directory
char scripts_path[strlen(user_path) + strlen(PM3_USER_DIRECTORY) + strlen(PYTHON_SCRIPTS_SUBDIR) + strlen(PYTHON_LIBRARIES_WILDCARD) + 1];
strcpy(scripts_path, user_path);
strcat(scripts_path, PM3_USER_DIRECTORY);
strcat(scripts_path, PYTHON_SCRIPTS_SUBDIR);
// strcat(scripts_path, PYTHON_LIBRARIES_WILDCARD);
set_python_path(scripts_path);
}
if (exec_path != NULL) {
// from the $PREFIX/share/proxmark3/pyscripts/ directory
char scripts_path[strlen(exec_path) + strlen(PM3_SHARE_RELPATH) + strlen(PYTHON_SCRIPTS_SUBDIR) + strlen(PYTHON_LIBRARIES_WILDCARD) + 1];
strcpy(scripts_path, exec_path);
strcat(scripts_path, PM3_SHARE_RELPATH);
strcat(scripts_path, PYTHON_SCRIPTS_SUBDIR);
// strcat(scripts_path, PYTHON_LIBRARIES_WILDCARD);
set_python_path(scripts_path);
}
}
#endif
/**
* Generate a sorted list of available commands, what it does is
* generate a file listing of the script-directory for files
* ending with .lua
*/
static int CmdScriptList(const char *Cmd) {
CLIParserContext *ctx;
CLIParserInit(&ctx, "script list",
"List available Lua, Cmd and Python scripts",
"script list"
);
void *argtable[] = {
arg_param_begin,
arg_param_end
};
CLIExecWithReturn(ctx, Cmd, argtable, true);
CLIParserFree(ctx);
PrintAndLogEx(NORMAL, "\n" _YELLOW_("[ Lua scripts ]"));
int ret = searchAndList(LUA_SCRIPTS_SUBDIR, ".lua");
if (ret != PM3_SUCCESS) {
return ret;
}
PrintAndLogEx(NORMAL, "\n" _YELLOW_("[ Cmd scripts ]"));
ret = searchAndList(CMD_SCRIPTS_SUBDIR, ".cmd");
if (ret != PM3_SUCCESS) {
return ret;
}
#ifdef HAVE_PYTHON
PrintAndLogEx(NORMAL, "\n" _YELLOW_("[ Python scripts ]"));
return searchAndList(PYTHON_SCRIPTS_SUBDIR, ".py");
#else
return ret;
#endif
}
/**
* @brief CmdScriptRun - executes a script file.
* @param argc
* @param argv
* @return
*/
static int CmdScriptRun(const char *Cmd) {
CLIParserContext *ctx;
CLIParserInit(&ctx, "script run",
"Run a Lua, Cmd or Python script. "
"If no extension it will search for lua/cmd/py extensions\n"
"Use `script list` to see available scripts",
"script run my_script -h\n"
);
void *argtable[] = {
arg_param_begin,
arg_file1(NULL, NULL, "<filename>", "name of script to run"),
arg_strx0(NULL, NULL, "<params>", "script parameters"),
arg_param_end
};
ctx->argtable = argtable;
ctx->argtableLen = arg_getsize(argtable);
int fnlen = 0;
char filename[FILE_PATH_SIZE] = {0};
int arg_len = 0;
char arguments[1025] = {0};
sscanf(Cmd, "%999s%n %1024[^\n\r]%n", filename, &fnlen, arguments, &arg_len);
// hack
// since we don't want to use "-f" for script filename,
// and be able to send in parameters into script meanwhile
// being able to "-h" here too.
if ((strlen(filename) == 0) ||
(strcmp(filename, "-h") == 0) ||
(strcmp(filename, "--help") == 0)) {
CLIParserPrintHelp(ctx);
CLIParserFree(ctx);
return PM3_ESOFT;
}
CLIParserFree(ctx);
// try to detect a valid script file extension, case-insensitive
char *extension_chk;
extension_chk = str_dup(filename);
str_lower(extension_chk);
pm3_scriptfile_t ext = PM3_UNSPECIFIED;
if (str_endswith(extension_chk, ".lua")) {
ext = PM3_LUA;
} else if (str_endswith(extension_chk, ".cmd")) {
ext = PM3_CMD;
}
#ifdef HAVE_PYTHON
else if (str_endswith(extension_chk, ".py")) {
ext = PM3_PY;
}
#endif
free(extension_chk);
static uint8_t luascriptfile_idx = 0;
char *script_path = NULL;
if (((ext == PM3_LUA) || (ext == PM3_UNSPECIFIED)) && (searchFile(&script_path, LUA_SCRIPTS_SUBDIR, filename, ".lua", true) == PM3_SUCCESS)) {
int error;
if (luascriptfile_idx == MAX_NESTED_LUASCRIPT) {
PrintAndLogEx(ERR, "too many nested scripts, skipping %s\n", script_path);
free(script_path);
return PM3_EMALLOC;
}
PrintAndLogEx(SUCCESS, "executing lua " _YELLOW_("%s"), script_path);
PrintAndLogEx(SUCCESS, "args " _YELLOW_("'%s'"), arguments);
luascriptfile_idx++;
// create new Lua state
lua_State *lua_state;
lua_state = luaL_newstate();
// load Lua libraries
luaL_openlibs(lua_state);
//Sets the pm3 core libraries, that go a bit 'under the hood'
set_pm3_libraries(lua_state);
//Add the 'bin' library
set_bin_library(lua_state);
//Add the 'bit' library
set_bit_library(lua_state);
#ifdef HAVE_LUA_SWIG
luaL_requiref(lua_state, "pm3", luaopen_pm3, 1);
#endif
error = luaL_loadfile(lua_state, script_path);
free(script_path);
if (!error) {
lua_pushstring(lua_state, arguments);
lua_setglobal(lua_state, "args");
//Call it with 0 arguments
error = lua_pcall(lua_state, 0, LUA_MULTRET, 0); // once again, returns non-0 on error,
}
if (error) { // if non-0, then an error
// the top of the stack should be the error string
if (!lua_isstring(lua_state, lua_gettop(lua_state)))
PrintAndLogEx(FAILED, "error - but no error (?!)");
// get the top of the stack as the error and pop it off
const char *str = lua_tostring(lua_state, lua_gettop(lua_state));
lua_pop(lua_state, 1);
PrintAndLogEx(FAILED, _RED_("error") " - %s", str);
}
//luaL_dofile(lua_state, buf);
// close the Lua state
lua_close(lua_state);
luascriptfile_idx--;
PrintAndLogEx(SUCCESS, "\nfinished " _YELLOW_("%s"), filename);
return PM3_SUCCESS;
}
if (((ext == PM3_CMD) || (ext == PM3_UNSPECIFIED)) && (searchFile(&script_path, CMD_SCRIPTS_SUBDIR, filename, ".cmd", true) == PM3_SUCCESS)) {
PrintAndLogEx(SUCCESS, "executing Cmd " _YELLOW_("%s"), script_path);
PrintAndLogEx(SUCCESS, "args " _YELLOW_("'%s'"), arguments);
int ret = push_cmdscriptfile(script_path, true);
if (ret != PM3_SUCCESS)
PrintAndLogEx(ERR, "could not open " _YELLOW_("%s") "...", script_path);
free(script_path);
return ret;
}
/*
For apt (Ubuntu, Debian...):
sudo apt-get install python3-dev # for python3.x installs
For yum (CentOS, RHEL...):
sudo yum install python3-devel # for python3.x installs
For dnf (Fedora...):
sudo dnf install python3-devel # for python3.x installs
For zypper (openSUSE...):
sudo zypper in python3-devel # for python3.x installs
For apk (Alpine...):
# This is a departure from the normal Alpine naming
# scheme, which uses py2- and py3- prefixes
sudo apk add python3-dev # for python3.x installs
For apt-cyg (Cygwin...):
apt-cyg install python3-devel # for python3.x installs
*/
#ifdef HAVE_PYTHON
if (((ext == PM3_PY) || (ext == PM3_UNSPECIFIED)) && (searchFile(&script_path, PYTHON_SCRIPTS_SUBDIR, filename, ".py", true) == PM3_SUCCESS)) {
PrintAndLogEx(SUCCESS, "executing python " _YELLOW_("%s"), script_path);
PrintAndLogEx(SUCCESS, "args " _YELLOW_("'%s'"), arguments);
// Python interpreter must be initialized ONCE per client session.
// Cycling Py_Initialize / Py_Finalize across script runs is documented
// as fragile in CPython because C extension modules (our SWIG-built
// _pm3 included) retain static state across the cycle and crash on
// re-init. So we init lazily on the first script and leave Python
// alive; between runs we just refresh sys.argv and clear __main__'s
// globals so each script starts from a clean namespace.
static bool s_py_initialized = false;
//int argc, char ** argv
char *argv[FILE_PATH_SIZE];
argv[0] = script_path;
int argc = split(arguments, &argv[1]);
if (argc < 0) {
PrintAndLogEx(ERR, "Failed to parse script arguments");
free(script_path);
return PM3_ESOFT;
}
#if PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION < 10
wchar_t *py_args[argc + 1];
for (int i = 0; i <= argc; i++) {
py_args[i] = Py_DecodeLocale(argv[i], NULL);
}
#endif
#if PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION >= 10
// Declared at this scope so the `pyexception` label below can reach
// them after a goto from inside the init block.
PyConfig py_conf;
PyStatus status;
#endif
if (!s_py_initialized) {
#ifdef HAVE_PYTHON_SWIG
// hook Proxmark3 API
PyImport_AppendInittab("_pm3", PyInit__pm3);
#endif
#if PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION < 10
Py_Initialize();
PySys_SetArgv(argc + 1, py_args);
#else
// We need to use Python mode instead of isolated to avoid breaking stuff.
PyConfig_InitPythonConfig(&py_conf);
// Let's still make things bit safer by being as close as possible to isolated mode.
py_conf.faulthandler = 0;
py_conf.use_hash_seed = 0;
py_conf.install_signal_handlers = 0;
py_conf.parse_argv = 0;
py_conf.use_environment = 0;
// The following line will implicitly pre-initialize Python
status = PyConfig_SetBytesArgv(&py_conf, argc + 1, argv);
if (PyStatus_Exception(status)) {
goto pyexception;
}
// We disallowed in py_conf environment variables interfering with python interpreter's behavior.
// Let's manually enable the ones we truly need.
const char *virtual_env = getenv("VIRTUAL_ENV");
if (virtual_env != NULL) {
size_t length = strlen(virtual_env) + strlen("/bin/python3") + 1;
char python_executable_path[length];
snprintf(python_executable_path, length, "%s/bin/python3", virtual_env);
status = PyConfig_SetBytesString(&py_conf, &py_conf.executable, python_executable_path);
if (PyStatus_Exception(status)) {
goto pyexception;
}
} else {
// This is required by Proxspace to work with an isolated Python configuration
status = PyConfig_SetBytesString(&py_conf, &py_conf.home, getenv("PYTHONHOME"));
if (PyStatus_Exception(status)) {
goto pyexception;
}
}
// This is required for allowing `import pm3` in python scripts
status = PyConfig_SetBytesString(&py_conf, &py_conf.pythonpath_env, getenv("PYTHONPATH"));
if (PyStatus_Exception(status)) {
goto pyexception;
}
status = Py_InitializeFromConfig(&py_conf);
if (PyStatus_Exception(status)) {
goto pyexception;
}
// clean up
PyConfig_Clear(&py_conf);
#endif
// setup search paths (only once - PySys_GetObject("path") is
// prepended each call, so repeating would grow sys.path).
set_python_paths();
s_py_initialized = true;
} else {
// Already initialized. Refresh sys.argv for this run and wipe
// __main__ globals so the new script doesn't see leftovers.
PyObject *argv_list = PyList_New(argc + 1);
for (int i = 0; i <= argc; i++) {
PyList_SET_ITEM(argv_list, i, PyUnicode_DecodeFSDefault(argv[i]));
}
PySys_SetObject("argv", argv_list);
Py_DECREF(argv_list);
PyObject *main_module = PyImport_AddModule("__main__");
if (main_module != NULL) {
PyObject *main_dict = PyModule_GetDict(main_module);
// Wipe leftover user globals from the previous run but preserve
// the module attributes Python itself put there at init
// (without these, e.g. `if __name__ == '__main__':` raises
// NameError and the script silently aborts).
// __file__/__cached__ are re-set per-run in Pm3PyRun_SimpleFileNoExit.
static const char *const KEEP_KEYS[] = {
"__name__", "__doc__", "__package__",
"__loader__", "__spec__", "__builtins__",
NULL,
};
PyObject *keys = PyDict_Keys(main_dict);
if (keys != NULL) {
Py_ssize_t n = PyList_GET_SIZE(keys);
for (Py_ssize_t i = 0; i < n; i++) {
PyObject *key = PyList_GET_ITEM(keys, i);
const char *k = PyUnicode_AsUTF8(key);
if (k == NULL) {
PyErr_Clear();
continue;
}
bool keep = false;
for (const char *const *kk = KEEP_KEYS; *kk != NULL; kk++) {
if (strcmp(k, *kk) == 0) { keep = true; break; }
}
if (!keep) {
PyDict_DelItem(main_dict, key);
}
}
Py_DECREF(keys);
}
}
}
for (int i = 0; i < argc; ++i) {
free(argv[i + 1]);
}
FILE *f = fopen(script_path, "r");
if (f == NULL) {
PrintAndLogEx(ERR, "Could open file " _YELLOW_("%s"), script_path);
free(script_path);
return PM3_ESOFT;
}
int ret = Pm3PyRun_SimpleFileNoExit(f, filename);
#if PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION < 10
// Py_DecodeLocale() allocates memory that needs to be free'd
for (int i = 0; i < argc + 1; i++) {
PyMem_RawFree(py_args[i]);
}
#endif
free(script_path);
if (ret) {
PrintAndLogEx(WARNING, "\nfinished " _YELLOW_("%s") " with exception", filename);
return PM3_ESOFT;
} else {
PrintAndLogEx(SUCCESS, "\nfinished " _YELLOW_("%s"), filename);
return PM3_SUCCESS;
}
#if PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION >= 10
pyexception:
PyConfig_Clear(&py_conf);
if (PyStatus_IsExit(status)) {
PrintAndLogEx(WARNING, "\nPython initialization failed with exitcode=%i", status.exitcode);
}
if (PyStatus_IsError(status)) {
PrintAndLogEx(WARNING, "\nPython initialization failed with exception: %s", status.err_msg);
}
return PM3_ESOFT;
#endif
}
#endif
// file not found, let's search again to display the error messages
int ret = PM3_EUNDEF;
if (ext == PM3_LUA)
ret = searchFile(&script_path, LUA_SCRIPTS_SUBDIR, filename, ".lua", false);
else if (ext == PM3_CMD)
ret = searchFile(&script_path, CMD_SCRIPTS_SUBDIR, filename, ".cmd", false);
#ifdef HAVE_PYTHON
else if (ext == PM3_PY)
ret = searchFile(&script_path, PYTHON_SCRIPTS_SUBDIR, filename, ".py", false);
else if (ext == PM3_UNSPECIFIED)
PrintAndLogEx(FAILED, "Error - can't find %s.[lua|cmd|py]", filename);
#else
else if (ext == PM3_UNSPECIFIED)
PrintAndLogEx(FAILED, "Error - can't find %s.[lua|cmd]", filename);
#endif
free(script_path);
return ret;
}
static command_t CommandTable[] = {
{"help", CmdHelp, AlwaysAvailable, "This help"},
{"list", CmdScriptList, AlwaysAvailable, "List available scripts"},
{"run", CmdScriptRun, AlwaysAvailable, "<name> - execute a script"},
{NULL, NULL, NULL, NULL}
};
/**
* Shows some basic help
* @brief CmdHelp
* @param Cmd
* @return
*/
static int CmdHelp(const char *Cmd) {
(void)Cmd; // Cmd is not used so far
#ifdef HAVE_PYTHON
PrintAndLogEx(NORMAL, "This is a feature to run Lua/Cmd/Python scripts. You can place scripts within the luascripts/cmdscripts/pyscripts folders. ");
#else
PrintAndLogEx(NORMAL, "This is a feature to run Lua/Cmd scripts. You can place scripts within the luascripts/cmdscripts folders. ");
#endif
return PM3_SUCCESS;
}
/**
* Finds a matching script-file
* @brief CmdScript
* @param Cmd
* @return
*/
int CmdScript(const char *Cmd) {
clearCommandBuffer();
return CmdsParse(CommandTable, Cmd);
}
void CmdScriptCleanup(void) {
#ifdef HAVE_PYTHON
Py_Finalize();
#endif
}
Reference in New Issue View Git Blame Copy Permalink