Crash_Override/OVMS3
2
0
Fork 0
Code Issues 5 Pull requests Projects Releases 4 Wiki Activity
OVMS3/OVMS.V3/main/ovms_vfs.cpp

606 lines
17 KiB
C++
Raw Blame History

/*
; Project: Open Vehicle Monitor System
; Date: 14th March 2017
;
; Changes:
; 1.0 Initial release
;
; (C) 2011 Michael Stegen / Stegen Electronics
; (C) 2011-2017 Mark Webb-Johnson
; (C) 2011 Sonny Chen @ EPRO/DX
;
; Permission is hereby granted, free of charge, to any person obtaining a copy
; of this software and associated documentation files (the "Software"), to deal
; in the Software without restriction, including without limitation the rights
; to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
; copies of the Software, and to permit persons to whom the Software is
; furnished to do so, subject to the following conditions:
;
; The above copyright notice and this permission notice shall be included in
; all copies or substantial portions of the Software.
;
; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
; AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
; THE SOFTWARE.
*/
#include "ovms_log.h"
static const char *TAG = "vfs";
#include <string>
#include <string.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <fcntl.h>
#include <dirent.h>
#include <unistd.h>
#include <libgen.h>
#include "ovms_vfs.h"
#include "ovms_config.h"
#include "ovms_command.h"
#include "ovms_peripherals.h"
#include "crypt_md5.h"
#ifdef CONFIG_OVMS_COMP_EDITOR
#include "vfsedit.h"
#endif // #ifdef CONFIG_OVMS_COMP_EDITOR
/**
* This class is a kind of wrapper around dirent
*/
class Direntry {
public:
std::string basepath; // base path of the file / directory (parent dir) - always ending with '/'
std::string name; // name of the file / dirctory
bool is_dir; // `true`: is a directory, `false`: is a file
bool is_protected; // `true`: this path is protected
bool is_skip; // `true`: we should not analyze this entry
int64_t size; // size
time_t mtime; // modification time
/**
* Default constructor, calls stat() on the file.
*/
Direntry(std::string basepath, struct dirent *direntry) {
struct stat st;
this->basepath = basepath + '/';
name = direntry->d_name;
is_protected = MyConfig.ProtectedPath(path());
stat(path().c_str(), &st);
is_dir = S_ISDIR(st.st_mode);
is_skip = (!S_ISDIR(st.st_mode) && !S_ISREG(st.st_mode)) || (direntry->d_name[0] == '.');
size = st.st_size;
mtime = st.st_mtime;
}
std::string path() const {
return basepath + name;
}
bool operator<(const Direntry &other) const {
static std::less<std::string> const less;
return less(path(), other.path());
}
void display(OvmsWriter* writer, bool show_full_path) {
char bufsize[64], mod[64];
if (is_dir) {
if (is_protected) {
strcpy(bufsize, "[P][DIR]");
} else {
strcpy(bufsize, "[DIR] ");
}
} else {
if (is_protected) {
strcpy(bufsize, "[P] ");
} else {
if (size < 1024) {
snprintf(bufsize, sizeof(bufsize), "%d ", (int) size);
} else if (size < 0x100000) {
snprintf(bufsize, sizeof(bufsize), "%.1fk", (double) size / 1024.0);
} else if (size < 0x40000000) {
snprintf(bufsize, sizeof(bufsize), "%.1fM", (double) size / 1048576);
} else {
snprintf(bufsize, sizeof(bufsize), "%.1fG", (double) size / 1073741824);
}
}
}
strftime(mod, sizeof(mod), "%d-%b-%Y %H:%M", localtime(&mtime));
const char *slash = is_dir ? "/" : "";
writer->printf("%8.8s %17.17s %s%s\n", bufsize, mod, show_full_path ? path().c_str() : name.c_str(), slash);
}
};
/**
* Fills a `std::set<Direntry>` with all possible entries starting at `startpath`.
* if `recurse` is `true`, then all possible directories are recursively entered.
*/
static void read_entries(std::set<Direntry> &entries, std::string startpath, bool recurse = true) {
DIR *dir;
struct dirent *dp;
if ((dir = opendir(startpath.c_str())) != NULL) {
while ((dp = readdir(dir)) != NULL) {
Direntry dirent(startpath, dp);
if (dirent.is_skip) {
continue;
}
entries.insert(dirent);
if (recurse && dirent.is_dir && !dirent.is_protected) {
read_entries(entries, dirent.path());
}
}
closedir(dir);
}
}
/**
* Fills a `std::set<Direntry>` with all possible entries, and display the sorted result.
* if `recurse` is `true`:
* - all possible directories are recursively entered,
* - the display shows the full file path
* if `recurse` is `false`:
* - only `startpath` is listed,
* - the display shows only file / directory name
*/
static void list_entries(OvmsWriter* writer, std::string startpath, bool recurse = true) {
std::set<Direntry> entries;
while((startpath.back() == '/') || (startpath.back() == '.')) {
startpath.pop_back();
}
if (MyConfig.ProtectedPath(startpath)) {
writer->puts("Error: protected path");
return;
}
read_entries(entries, startpath, recurse);
for (auto it = entries.begin(); it != entries.end(); it++) {
Direntry dirent = *it;
dirent.display(writer, recurse);
}
}
/**
* Recursive listing of the files and directories starting at `argv[0]` (or '.')
* - all possible directories are recursively entered,
* - the display shows the full file / directory path
* - protected directories are identified and not entered
*/
void vfs_rls(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv) {
list_entries(writer, (argc==0) ? "." : argv[0], true);
}
/**
* Listing of the files and directories at `argv[0]` (or '.')
* - the display shows only the file / directory name
* - protected directories are identified
*/
void vfs_ls(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv) {
list_entries(writer, (argc==0) ? "." : argv[0], false);
}
void vfs_cat(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
if (MyConfig.ProtectedPath(argv[0]))
{
writer->puts("Error: protected path");
return;
}
FILE* f = fopen(argv[0], "r");
if (f == NULL)
{
writer->puts("Error: VFS file cannot be opened");
return;
}
char buf[512];
while(size_t n = fread(buf, sizeof(char), sizeof(buf), f))
{
writer->write(buf, n);
}
fclose(f);
}
void vfs_head(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
const char *filename = NULL;
int nrlines = 20;
for (int i=0; i<argc; i++)
{
if (argv[i][0] == '-')
{
char* ep;
int32_t v = strtol(argv[i] + 1, &ep, 10);
if (*ep != '\0')
{
cmd->PutUsage(writer);
return;
}
nrlines = v;
}
else
filename = argv[i];
}
if (!filename)
{
writer->puts("Error: no filename given");
return;
}
if (MyConfig.ProtectedPath(filename))
{
writer->puts("Error: protected path");
return;
}
FILE* f = fopen(filename, "r");
if (f == NULL)
{
writer->puts("Error: VFS file cannot be opened");
return;
}
char buf[512];
int k =0;
while (fgets(buf,sizeof(buf),f)!=NULL)
{
writer->write(buf,strlen(buf));
if (++k >= nrlines) break;
}
fclose(f);
}
void vfs_stat(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
if (MyConfig.ProtectedPath(argv[0]))
{
writer->puts("Error: protected path");
return;
}
FILE* f = fopen(argv[0], "r");
if (f == NULL)
{
writer->puts("Error: VFS file cannot be opened");
return;
}
OVMS_MD5_CTX* md5 = new OVMS_MD5_CTX;
OVMS_MD5_Init(md5);
int filesize = 0;
uint8_t *buf = new uint8_t[512];
while(size_t n = fread(buf, sizeof(char), 512, f))
{
filesize += n;
OVMS_MD5_Update(md5, buf, n);
}
uint8_t* rmd5 = new uint8_t[16];
OVMS_MD5_Final(rmd5, md5);
char dchecksum[33];
sprintf(dchecksum,"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
rmd5[0],rmd5[1],rmd5[2],rmd5[3],rmd5[4],rmd5[5],rmd5[6],rmd5[7],
rmd5[8],rmd5[9],rmd5[10],rmd5[11],rmd5[12],rmd5[13],rmd5[14],rmd5[15]);
writer->printf("File %s size is %d and digest %s\n",
argv[0],filesize,dchecksum);
delete [] rmd5;
delete [] buf;
fclose(f);
}
void vfs_rm(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
if (MyConfig.ProtectedPath(argv[0]))
{
writer->puts("Error: protected path");
return;
}
if (unlink(argv[0]) == 0)
{ writer->puts("VFS File deleted"); }
else
{ writer->puts("Error: Could not delete VFS file"); }
}
void vfs_mv(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
if (MyConfig.ProtectedPath(argv[0]))
{
writer->puts("Error: protected path");
return;
}
if (MyConfig.ProtectedPath(argv[1]))
{
writer->puts("Error: protected path");
return;
}
if (rename(argv[0],argv[1]) == 0)
{ writer->puts("VFS File renamed"); }
else
{ writer->puts("Error: Could not rename VFS file"); }
}
void vfs_mkdir(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
if (MyConfig.ProtectedPath(argv[0]))
{
writer->puts("Error: protected path");
return;
}
if (mkdir(argv[0],0) == 0)
{ writer->puts("VFS directory created"); }
else
{ writer->puts("Error: Could not create VFS directory"); }
}
void vfs_rmdir(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
if (MyConfig.ProtectedPath(argv[0]))
{
writer->puts("Error: protected path");
return;
}
if (rmdir(argv[0]) == 0)
{ writer->puts("VFS directory removed"); }
else
{ writer->puts("Error: Could not remove VFS directory"); }
}
void vfs_cp(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
if (MyConfig.ProtectedPath(argv[0]))
{
writer->puts("Error: protected path");
return;
}
if (MyConfig.ProtectedPath(argv[1]))
{
writer->puts("Error: protected path");
return;
}
FILE* f = fopen(argv[0], "r");
if (f == NULL)
{
writer->puts("Error: VFS source file cannot be opened");
return;
}
FILE* w = fopen(argv[1], "w");
if (w == NULL)
{
writer->puts("Error: VFS target file cannot be opened");
fclose(f);
return;
}
char buf[512];
while(size_t n = fread(buf, sizeof(char), sizeof(buf), f))
{
fwrite(buf,n,1,w);
}
fclose(w);
fclose(f);
writer->puts("VFS copy complete");
}
void vfs_append(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
if (MyConfig.ProtectedPath(argv[1]))
{
writer->puts("Error: protected path");
return;
}
FILE* w = fopen(argv[1], "a");
if (w == NULL)
{
writer->puts("Error: VFS target file cannot be opened");
return;
}
int len = strlen(argv[0]);
fwrite(argv[0], len, 1, w);
fwrite("\n", 1, 1, w);
fclose(w);
}
class VfsTailCommand : public OvmsCommandTask
{
using OvmsCommandTask::OvmsCommandTask;
public:
char* filename = NULL;
int nrlines = 0;
int fd = -1;
char buf[128];
off_t fpos;
ssize_t len;
OvmsCommandState_t Prepare()
{
// parse args:
for (int i=0; i<argc; i++)
{
if (argv[i][0] == '-')
{
char* ep;
int32_t v = strtol(argv[i] + 1, &ep, 10);
if (*ep != '\0')
{
cmd->PutUsage(writer);
return OCS_Error;
}
nrlines = v;
}
else
filename = argv[i];
}
// check file:
if (!filename || !*filename || MyConfig.ProtectedPath(filename))
{
writer->puts("Error: invalid/protected path");
return OCS_Error;
}
fd = open(filename, O_RDONLY|O_NONBLOCK);
if (fd == -1)
{
writer->puts("Error: VFS file cannot be opened");
return OCS_Error;
}
// seek nrlines back from end of file:
fpos = lseek(fd, 0, SEEK_END);
int lcnt = ((nrlines > 0) ? nrlines : 10) + 1;
while (fpos > 0 && lcnt > 0)
{
ssize_t rlen = MIN(fpos, sizeof(buf));
fpos = lseek(fd, fpos-rlen, SEEK_SET);
len = read(fd, buf, rlen);
for (int i=len-1; i>=0; i--)
{
if (buf[i] == '\n' && (--lcnt == 0))
{
fpos += i + 1;
break;
}
}
}
// determine run mode:
if (nrlines <= 0 && writer->IsInteractive())
{
writer->puts("[tail: in follow mode, press Ctrl-C to abort]");
return OCS_RunLoop;
}
return OCS_RunOnce;
}
void Service()
{
while (true)
{
// Note: the esp-idf libs do currently not provide read/seek into
// data appended by other tasks, we need to reopen for each check
if (fd == -1)
fd = open(filename, O_RDONLY|O_NONBLOCK);
if (fd == -1)
{
writer->puts("[tail: file lost, abort]");
break;
}
lseek(fd, fpos, SEEK_SET);
while ((len = read(fd, buf, sizeof buf)) > 0)
writer->write(buf, len);
fpos = lseek(fd, 0, SEEK_CUR);
close(fd);
fd = -1;
// done/abort?
if (m_state != OCS_RunLoop)
break;
vTaskDelay(pdMS_TO_TICKS(250));
}
}
static void Execute(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
VfsTailCommand* me = new VfsTailCommand(verbosity, writer, cmd, argc, argv);
if (me) me->Run();
}
};
void vfs_df(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
FATFS *fs;
DWORD fre_clust;
uint64_t fre_sect, tot_sect;
int sector_size;
uint64_t size, free;
// drive "0:" = /store
if (f_getfree("0:", &fre_clust, &fs) == FR_OK)
{
tot_sect = (fs->n_fatent - 2) * fs->csize;
fre_sect = fre_clust * fs->csize;
#if FF_MAX_SS != FF_MIN_SS
sector_size = fs->ssize;
#else
sector_size = 512;
#endif
size = ((uint64_t) tot_sect) * sector_size / 1024;
free = ((uint64_t) fre_sect) * sector_size / 1024;
writer->printf("/store: Size: %6llu kB Avail: %6llu kB Used: %3d%%\n",
size, free, (int)(100 - fre_sect * 100 / tot_sect));
}
else
{
writer->puts("ERROR: can't get df info for /store");
}
#ifdef CONFIG_OVMS_COMP_SDCARD
// drive "1:" = /sd
sdmmc_card_t* card = MyPeripherals->m_sdcard->m_card;
if (card && f_getfree("1:", &fre_clust, &fs) == FR_OK)
{
tot_sect = (fs->n_fatent - 2) * fs->csize;
fre_sect = fre_clust * fs->csize;
sector_size = card->csd.sector_size;
size = ((uint64_t) tot_sect) * sector_size / (1024 * 1024);
free = ((uint64_t) fre_sect) * sector_size / (1024 * 1024);
writer->printf("/sd : Size: %6llu MB Avail: %6llu MB Used: %3d%%\n",
size, free, (int)(100 - fre_sect * 100 / tot_sect));
}
#endif // #ifdef CONFIG_OVMS_COMP_SDCARD
}
class VfsInit
{
public: VfsInit();
} MyVfsInit __attribute__ ((init_priority (5200)));
VfsInit::VfsInit()
{
ESP_LOGI(TAG, "Initialising VFS (5200)");
OvmsCommand* cmd_vfs = MyCommandApp.RegisterCommand("vfs","Virtual File System framework");
cmd_vfs->RegisterCommand("ls","VFS Directory Listing",vfs_ls, "[<file>]", 0, 1);
cmd_vfs->RegisterCommand("rls","VFS Recursive Directory Listing",vfs_rls, "[<file>]", 0, 1);
cmd_vfs->RegisterCommand("cat","VFS Display a file",vfs_cat, "<file>", 1, 1);
cmd_vfs->RegisterCommand("head","VFS Display first 20 lines of a file",vfs_head, "[-nrlines] <file>", 1, 2);
cmd_vfs->RegisterCommand("stat","VFS Status of a file",vfs_stat, "<file>", 1, 1);
cmd_vfs->RegisterCommand("mkdir","VFS Create a directory",vfs_mkdir, "<path>", 1, 1);
cmd_vfs->RegisterCommand("rmdir","VFS Delete a directory",vfs_rmdir, "<path>", 1, 1);
cmd_vfs->RegisterCommand("rm","VFS Delete a file",vfs_rm, "<file>", 1, 1);
cmd_vfs->RegisterCommand("mv","VFS Rename a file",vfs_mv, "<source> <target>", 2, 2);
cmd_vfs->RegisterCommand("cp","VFS Copy a file",vfs_cp, "<source> <target>", 2, 2);
cmd_vfs->RegisterCommand("append","VFS Append a line to a file",vfs_append, "<quoted line> <file>", 2, 2);
cmd_vfs->RegisterCommand("tail","VFS output tail of a file",VfsTailCommand::Execute, "[-nrlines] <file>", 1, 2);
cmd_vfs->RegisterCommand("df","VFS show disk usage", vfs_df, "", 0, 0);
#ifdef CONFIG_OVMS_COMP_EDITOR
cmd_vfs->RegisterCommand("edit","VFS edit a file",vfs_edit, "<path>", 1, 1);
#endif // #ifdef CONFIG_OVMS_COMP_EDITOR
}
Reference in a new issue View git blame Copy permalink