/**
* @brief write date into a the sdcard file.
* @param
*data: pointer to the date to be writen.
cnt : length of the data.
*filename: the name of saving file.
* @retval None
*/
void Write_Warn_Date(void *data)
{
int warn_count = 0;
block_size = 8;
if(f_mount(0, &fs) != FR_OK) return;
if(f_open(&warn_fdst, "warn.dat", /*FA_CREATE_ALWAYS |*/ FA_WRITE) != FR_OK){
f_open(&warn_fdst, "warn.dat", FA_CREATE_NEW | FA_WRITE);
f_chmod("warn.dat", AM_MASK, AM_HID);
}else{
warn_count = (warn_fdst.fsize)/block_size - 1;
}
if(warn_count >= ALARM_MESSAGE_CAP){
f_lseek(&warn_fdst, block_size*(warn_ops + 1));
warn_ops++;
if(ALARM_MESSAGE_CAP == warn_ops) warn_ops = 0;
}else{
f_lseek(&warn_fdst, block_size*(warn_count + 1));
warn_ops = 0;
}
f_write(&warn_fdst, (void*)(data), block_size, &bw);
f_lseek(&warn_fdst, 0);
f_write(&warn_fdst, (void*)(&warn_ops), 1, &bw);
f_close(&warn_fdst);
f_mount(0, NULL);
}
bool TestExtFile::test_chown() {
Variant f = f_fopen("test/test_ext_file.tmp", "w");
f_fputs(f, "testing\nchown\n");
f_fclose(f);
VERIFY(f_chmod("test/test_ext_file.txt", 0777));
//VERIFY(f_chown("test/test_ext_file.tmp", "hzhao"));
f_unlink("test/test_ext_file.tmp");
return Count(true);
}
void OnChangeAttribute(nwazetMessageContext_t* nmc){
uint8_t res = (uint8_t) FR_OK;
uint8_t attribute = 0;
uint8_t attributeMask = 0;
uint8_t isTextASCII = 0;
uint16_t textLength = 0;
const char* objName = (const char*)GetStringReference(nmc->cmdContext, &textLength, &isTextASCII);
Get(nmc->cmdContext, (void*)&attribute, sizeof(attribute));
Get(nmc->cmdContext, (void*)&attributeMask, sizeof(attributeMask));
if(objName && isTextASCII){
res = fsCheckSuccess(__func__, "f_chmod", f_chmod(objName, attribute, attributeMask), objName);
StartResponse(nmc, res, true);
return;
}
res = FR_INVALID_NAME;
fsCheckSuccess(__func__, "objName", res, objName);
StartResponse(nmc, res, true);
}
/**
* @brief fatfs_attrib set the attribs on a file
* @param fc the current FAT session
* @param filename an existing file
* @param attrib a string with the attributes. i.e., "RHS"
* @return 0 on success
*/
int fatfs_attrib(struct block_cache *output, off_t block_offset, const char *filename, const char *attrib)
{
MAYBE_MOUNT(output, block_offset);
BYTE mode = 0;
while (*attrib) {
switch (*attrib++) {
case 'S':
case 's':
mode |= AM_SYS;
break;
case 'H':
case 'h':
mode |= AM_HID;
break;
case 'R':
case 'r':
mode |= AM_RDO;
break;
}
}
CHECK("fat_attrib", filename, f_chmod(filename, mode, AM_RDO | AM_HID | AM_SYS));
return 0;
}
long rod_CreateFile_edit (void)
{
s32 i = 0;
FIL Fil;
FIL Fil2;
FRESULT result;
FATFS fls;
FILINFO fno;
long res = 0;
char t_str[25];
__disable_irq();
__disable_fiq();
IWDG_ReloadCounter();
res = f_mount(&fls, "0:", 1);
res = f_open(&Fil,"0:Road.0", FA_CREATE_ALWAYS | FA_WRITE);
f_printf(&Fil,"%s", "без маршрута ");
f_putc(0,&Fil);
// f_open(&Fil,"0:Road.000", FA_OPEN_ALWAYS | FA_WRITE);
// f_lseek(&Fil, 16);
for(i=1;i<500;i++)
{
{
f_printf(&Fil,"%s %03u ","точка",i);
f_putc(i,&Fil);
}
}
//Получаем размер
res = f_size(&Fil);
f_close(&Fil);
IWDG_ReloadCounter();
//Только чтение
f_chmod("0:Road.0", AM_RDO, AM_RDO | AM_ARC);
f_open(&Fil,"0:Road.log", FA_CREATE_ALWAYS | FA_WRITE);
f_printf(&Fil,"%s", "Road.0");
f_close(&Fil);
f_open(&Fil2,"0:Roads.txt", FA_CREATE_ALWAYS | FA_WRITE);
f_printf(&Fil2,"%s", "Road.0");
f_close(&Fil2);
// //Проверяем размер
// f_open(&Fil,"0:Road.100", FA_OPEN_ALWAYS);
// //if (f_size(&Fil) == 16000) res = 1;
// res = f_size(&Fil);
// f_close(&Fil);
f_mount(0,"0:", 0);
__enable_irq();
__enable_fiq();
return res;
}
/*******************************************************************************
* FUNCTION: xFSSetReadOnlyFlag
*
* PARAMETERS:
* ~ szFileName - The path to the file that we want to check.
* ~ ucReadOnlyFlag - The read only flag.
*
* RETURN:
* ~ Error code.
*
* DESCRIPTIONS:
* Set the read only flag of a file.
*
*******************************************************************************/
FRESULT xFSSetReadOnlyFlag(const char *szFileName, unsigned char ucReadOnlyFlag)
{
return f_chmod(szFileName, ucReadOnlyFlag, AM_RDO);
}
bool TestExtFile::test_is_executable() {
VERIFY(f_chmod("test/test_ext_file.txt", 0777));
VERIFY(f_is_executable("test/test_ext_file.txt"));
return Count(true);
}
bool TestExtFile::test_chmod() {
VERIFY(f_chmod("test/test_ext_file.txt", 0777));
return Count(true);
}
int InstallData(char* drive){
FIL firmfile;
char* progressbar = "[ ]";
char* progress = progressbar+1;
print("%s", progressbar); ConsolePrevLine();
//Create the workdir
sprintf(tmpstr, "%s:%s", drive, DATAFOLDER);
f_mkdir(tmpstr);
f_chmod(tmpstr, AM_HID, AM_HID);
//Read firmware data
if(f_open(&firmfile, "firmware.bin", FA_READ | FA_OPEN_EXISTING) == FR_OK){
//... We'll see
}else return CONF_NOFIRMBIN;
*progress++ = '.'; DrawString(BOT_SCREEN, progressbar, 130, 50, ConsoleGetTextColor(), ConsoleGetBackgroundColor());
//Create patched native_firm
f_read(&firmfile, WORKBUF, NAT_SIZE, &tmpu32);
u8* n_firm = decryptFirmTitle(WORKBUF, NAT_SIZE, 0x00000002);
u8* n_firm_patch = GetFilePack("nat_patch.bin");
applyPatch(n_firm, n_firm_patch);
u8 keyx[16] = {0};
if(GetSystemVersion() < 3){
FileOpen(&tempfile, KEYFILENAME, 0);
FileRead(&tempfile, &keyx[0], 16, 0);
FileClose(&tempfile);
}
*progress++ = '.'; DrawString(BOT_SCREEN, progressbar, 130, 50, ConsoleGetTextColor(), ConsoleGetBackgroundColor());
for(int i = 0; i < NAT_SIZE; i+=0x4){
if(!strcmp((char*)n_firm + i, "Shit")){
if(1){
memcpy((char*)n_firm + i, rxmode_emu_label, 4);
}else{
memcpy((char*)n_firm + i, rxmode_sys_label , 4);
}
}
if(!strcmp((char*)n_firm + i, "InsertKeyXHere!") && keyx[0] != 0){
memcpy(n_firm + i, keyx, 16);
}
if(*((unsigned int*)(n_firm + i)) == 0xAAAABBBB){
*((unsigned int*)(n_firm + i)) = (checkEmuNAND() / 0x200) - 1;
}
}
*progress++ = '.'; DrawString(BOT_SCREEN, progressbar, 130, 50, ConsoleGetTextColor(), ConsoleGetBackgroundColor());
sprintf(tmpstr, "%s:%s/0004013800000002.bin", drive, DATAFOLDER);
if(FileOpen(&tempfile, tmpstr, 1)){
FileWrite(&tempfile, n_firm, NAT_SIZE, 0);
FileClose(&tempfile);
//FileCopy("0004013800000002.bin", tmpstr);
}else return CONF_ERRNFIRM;
*progress++ = '.'; DrawString(BOT_SCREEN, progressbar, 130, 50, ConsoleGetTextColor(), ConsoleGetBackgroundColor());
//Create AGB patched firmware
f_read(&firmfile, WORKBUF, AGB_SIZE, &tmpu32);
u8* a_firm = decryptFirmTitle(WORKBUF, AGB_SIZE, 0x00000202);
u8* a_firm_patch = GetFilePack("agb_patch.bin");
if(a_firm){
applyPatch(a_firm, a_firm_patch);
sprintf(tmpstr, "%s:%s/0004013800000202.bin", drive, DATAFOLDER);
if(FileOpen(&tempfile, tmpstr, 1)){
FileWrite(&tempfile, a_firm, AGB_SIZE, 0);
FileClose(&tempfile);
}else return CONF_ERRNFIRM;
*progress++ = '.';
}else{
//If we cannot decrypt it from firmware.bin becouse of titlekey messed up, it probably means that AGB has been modified in some way.
//So we read it from his installed ncch...
FindApp(0x00040138, 0x00000202, 1);
char* path = getContentAppPath();
FileOpen(&tempfile, path, 0);
FileRead(&tempfile, WORKBUF, AGB_SIZE, 0);
FileClose(&tempfile);
a_firm = decryptFirmTitleNcch(WORKBUF, AGB_SIZE);
if(a_firm){
applyPatch(a_firm, a_firm_patch);
sprintf(tmpstr, "%s:%s/0004013800000202.bin", drive, DATAFOLDER);
if(FileOpen(&tempfile, tmpstr, 1)){
FileWrite(&tempfile, a_firm, AGB_SIZE, 0);
FileClose(&tempfile);
}else return CONF_ERRNFIRM;
*progress++ = '.';
}else{
*progress++ = 'x'; //If we get here, then we'll play without AGB, lol
}
}
DrawString(BOT_SCREEN, progressbar, 130, 50, ConsoleGetTextColor(), ConsoleGetBackgroundColor());
//Create TWL patched firmware
f_read(&firmfile, WORKBUF, TWL_SIZE, &tmpu32);
u8* t_firm = decryptFirmTitle(WORKBUF, TWL_SIZE, 0x00000102);
u8* t_firm_patch = GetFilePack("twl_patch.bin");
if(t_firm){
applyPatch(t_firm, t_firm_patch);
sprintf(tmpstr, "%s:%s/0004013800000102.bin", drive, DATAFOLDER);
if(FileOpen(&tempfile, tmpstr, 1)){
FileWrite(&tempfile, t_firm, TWL_SIZE, 0);
FileClose(&tempfile);
//FileCopy("0004013800000102.bin", tmpstr);
}else return CONF_ERRNFIRM;
*progress++ = '.';
}else{
*progress++ = 'x';
}
DrawString(BOT_SCREEN, progressbar, 130, 50, ConsoleGetTextColor(), ConsoleGetBackgroundColor());
sprintf(tmpstr, "%s:%s/data.bin", drive, DATAFOLDER);
if(FileOpen(&tempfile, tmpstr, 1)){
FileWrite(&tempfile, __DATE__, 12, 0);
FileWrite(&tempfile, __TIME__, 9, 12);
FileClose(&tempfile);
}else return CONF_CANTOPENFILE;
*progress++ = '.'; DrawString(BOT_SCREEN, progressbar, 130, 50, ConsoleGetTextColor(), ConsoleGetBackgroundColor());
f_close(&firmfile);
return 0;
}
FRESULT DFATFS::fschmod(const char* path, uint8_t value, uint8_t mask)
{
return(f_chmod(path, value, mask));
}
static msg_t ThreadFatFSWorker(void *arg) {
(void)arg;
Thread* p;
chRegSetThreadName("fatfsWorker");
while (!chThdShouldTerminate()) {
/* Wait for msg with work to do. */
p = chMsgWait();
struct wrapper_msg_base* msg = (struct wrapper_msg_base*) chMsgGet(p);
msg->result = FR_INVALID_PARAMETER;
switch(msg->action) {
case eTERMINATE: {
break;
}
#if HAS_MOUNT
case eFMOUNT: {
const struct wrapper_msg_vBYTEpFATFS* exmsg = \
(const struct wrapper_msg_vBYTEpFATFS*) msg;
msg->result = f_mount(exmsg->byte, exmsg->fatfsp);
break;
}
#endif /* HAS_MOUNT */
#if HAS_OPEN
case eFOPEN: {
const struct wrapper_msg_pFILpTCHARvBYTE* exmsg = \
(const struct wrapper_msg_pFILpTCHARvBYTE*) msg;
msg->result = f_open(exmsg->filep, exmsg->string, exmsg->byte);
break;
}
#endif /* HAS_OPEN */
#if HAS_READ
case eFREAD: {
const struct wrapper_msg_pFILpVOIDvUINTpUINT* exmsg = \
(const struct wrapper_msg_pFILpVOIDvUINTpUINT*) msg;
msg->result = f_read(exmsg->filep, exmsg->voidp, exmsg->uint,
exmsg->uintp);
break;
}
#endif /* HAS_READ */
#if HAS_WRITE
case eFWRITE: {
const struct wrapper_msg_pFILpVOIDvUINTpUINT* exmsg = \
(const struct wrapper_msg_pFILpVOIDvUINTpUINT*) msg;
msg->result = f_write(exmsg->filep, exmsg->voidp, exmsg->uint,
exmsg->uintp);
break;
}
#endif /* HAD_WRITE */
#if HAS_SYNC
case eFSYNC: {
const struct wrapper_msg_pFIL* exmsg = \
(const struct wrapper_msg_pFIL*) msg;
msg->result = f_sync(exmsg->filep);
break;
}
#endif /* HAS_SYNC */
#if HAS_CHDRIVE
case eFCHDRIVE: {
const struct wrapper_msg_vBYTE* exmsg = \
(const struct wrapper_msg_vBYTE*) msg;
msg->result = f_chdrive(exmsg->byte);
break;
}
#endif
#if HAS_CHDIR
case eFCHDIR: {
const struct wrapper_msg_pTCHAR* exmsg = \
(const struct wrapper_msg_pTCHAR*) msg;
msg->result = f_chdir(exmsg->string);
break;
}
#endif /* HAS_CHDIR */
#if HAS_GETCWD
case eFGETCWD: {
const struct wrapper_msg_pTCHARvUINT* exmsg = \
(const struct wrapper_msg_pTCHARvUINT*) msg;
msg->result = f_getcwd(exmsg->string, exmsg->uint);
break;
}
#endif
#if HAS_LSEEK
case eFLSEEK: {
const struct wrapper_msg_pFILvDWORD* exmsg = \
(const struct wrapper_msg_pFILvDWORD*) msg;
msg->result = f_lseek(exmsg->filep, exmsg->dword);
break;
}
#endif /* HAS_LSEEK */
#if HAS_CLOSE
case eFCLOSE: {
const struct wrapper_msg_pFIL* exmsg = \
(const struct wrapper_msg_pFIL*) msg;
msg->result = f_close(exmsg->filep);
break;
}
#endif /* HAS_CLOSE */
#if HAS_OPENDIR
case eFOPENDIR: {
const struct wrapper_msg_pDIRpTCHAR* exmsg = \
(const struct wrapper_msg_pDIRpTCHAR*) msg;
msg->result = f_opendir(exmsg->dirp, exmsg->string);
break;
}
#endif /* HAD_OPENDIR */
#if HAS_READDIR
case eFREADDIR: {
const struct wrapper_msg_pDIRpFILINFO* exmsg = \
(const struct wrapper_msg_pDIRpFILINFO*) msg;
msg->result = f_readdir(exmsg->dirp, exmsg->filinfop);
break;
}
#endif /* HAS_READDIR */
#if HAS_STAT
case eFSTAT: {
const struct wrapper_msg_pTCHARpFILINFO* exmsg = \
(const struct wrapper_msg_pTCHARpFILINFO*) msg;
msg->result = f_stat(exmsg->string, exmsg->filinfop);
break;
}
#endif /* HAS_STAT */
#if HAS_GETFREE
case eFGETFREE: {
const struct wrapper_msg_pTCHARpDWORDppFATFS* exmsg = \
(const struct wrapper_msg_pTCHARpDWORDppFATFS*) msg;
msg->result = f_getfree(exmsg->string, exmsg->dwordp, exmsg->fatfspp);
break;
}
#endif /* HAS_GETFREE */
#if HAS_TRUNCATE
case eFTRUNCATE: {
const struct wrapper_msg_pFIL* exmsg = \
(const struct wrapper_msg_pFIL*) msg;
msg->result = f_truncate(exmsg->filep);
break;
}
#endif /* HAS_TRUNCATE */
#if HAS_UNLINK
case eFUNLINK: {
const struct wrapper_msg_pTCHAR* exmsg = \
(const struct wrapper_msg_pTCHAR*) msg;
msg->result = f_unlink(exmsg->string);
break;
}
#endif /* HAS_UNLINK */
#if HAS_MKDIR
case eFMKDIR: {
const struct wrapper_msg_pTCHAR* exmsg = \
(const struct wrapper_msg_pTCHAR*) msg;
msg->result = f_mkdir(exmsg->string);
break;
}
#endif /* HAS_MKDIR */
#if HAS_CHMOD
case eFCHMOD: {
const struct wrapper_msg_pTCHARvBYTEvBYTE* exmsg = \
(const struct wrapper_msg_pTCHARvBYTEvBYTE*) msg;
msg->result = f_chmod(exmsg->string, exmsg->byte1, exmsg->byte2);
break;
}
#endif /* HAS_CHMOD */
#if HAS_UTIME
case eFUTIME: {
const struct wrapper_msg_pTCHARpFILINFO* exmsg = \
(const struct wrapper_msg_pTCHARpFILINFO*) msg;
msg->result = f_utime(exmsg->string, exmsg->filinfop);
break;
}
#endif /* HAD_UTIME */
#if HAS_RENAME
case eFRENAME: {
const struct wrapper_msg_pTCHARpTCHAR* exmsg = \
(const struct wrapper_msg_pTCHARpTCHAR*) msg;
msg->result = f_rename(exmsg->string1, exmsg->string2);
break;
}
#endif /* HAS_RENAME */
#if HAS_MKFS
case eFMKFS: {
const struct wrapper_msg_vBYTEvBYTEvUINT* exmsg = \
(const struct wrapper_msg_vBYTEvBYTEvUINT*) msg;
msg->result = f_mkfs(exmsg->byte1, exmsg->byte2, exmsg->uint);
break;
}
#endif /* HAS_MKFS */
#if HAS_FDISK
case eFFDISK: {
const struct wrapper_msg_vBYTEpDWORDpVOID* exmsg = \
(const struct wrapper_msg_vBYTEpDWORDpVOID*) msg;
msg->result = f_fdisk(exmsg->byte, exmsg->dwordp, exmsg->voidp);
break;
}
#endif /* HAS_FDISK */
#if HAS_GETS
case eFGETS: {
struct wrapper_msg_pTCHARvINTpFILpTCHAR* exmsg = \
(struct wrapper_msg_pTCHARvINTpFILpTCHAR*) msg;
exmsg->string2 = f_gets(exmsg->string, exmsg->n, exmsg->filep);
break;
}
#endif /* HAS_GETS */
#if HAS_PUTC
case eFPUTC: {
const struct wrapper_msg_vTCHARpFIL* exmsg = \
(const struct wrapper_msg_vTCHARpFIL*) msg;
msg->result = f_putc(exmsg->tchar, exmsg->filep);
break;
}
#endif /* HAS_PUTC */
#if HAS_PUTS
case eFPUTS: {
const struct wrapper_msg_pTCHARpFIL* exmsg = \
(const struct wrapper_msg_pTCHARpFIL*) msg;
msg->result = f_puts(exmsg->string, exmsg->filep);
break;
}
#endif /* HAS_PUTS */
}
/* Done, release msg again. */
chMsgRelease(p, 0);
}
return 0;
}
static int runCommand(int argc, char ** argv)
{
int i, sectors;
DIR rootDir;
FILINFO info;
char * filename;
FIL intFileObj;
FILE * extFileObj;
UINT bytesRead, bytesWritten;
// What command?
if (strcmp(argv[2], "mkfs") == 0)
{
// Get sector count
if (argc != 4)
return printUsage();
sectors = atoi(argv[3]);
// Validate sector count
if (sectors <= 0)
{
fputs("Sector Count must be > 0\n", stderr);
return 1;
}
sectorCount = (DWORD) sectors;
// Write 0s for the image
memset(buffer, 0, SECTOR_SIZE);
for (i = 0; i < sectors; i++)
{
if (disk_write(0, buffer, i, 1) != RES_OK)
return 1;
}
// Make filesystem
if (f_mkfs(0, 1, 0) != FR_OK)
{
fputs("mkfs failed\n", stderr);
return 1;
}
}
else if (strcmp(argv[2], "ls") == 0)
{
// Get directory to list
if (argc > 4)
return printUsage();
// Open directory
if (f_opendir(&rootDir, (argc == 4) ? argv[3] : "") != FR_OK)
{
fputs("opendir failed (directory exists?)\n", stderr);
return 1;
}
// Set long file name buffer
info.lfname = (char *) buffer;
info.lfsize = BUFFER_SIZE;
// List contents
while (f_readdir(&rootDir, &info) == FR_OK && info.fname[0] != 0)
{
// Get filename
filename = *info.lfname ? info.lfname : info.fname;
// Print attributes
printf((info.fattrib & AM_RDO) ? "r" : " ");
printf((info.fattrib & AM_HID) ? "h" : " ");
printf((info.fattrib & AM_SYS) ? "s" : " ");
printf((info.fattrib & AM_DIR) ? "d" : " ");
printf((info.fattrib & AM_ARC) ? "a" : " ");
// Print filename
printf(" %s\n", filename);
}
}
else if (strcmp(argv[2], "rm") == 0)
{
// Get filename
if (argc != 4)
return printUsage();
filename = argv[3];
// Make file writable
f_chmod(filename, 0, AM_RDO);
// Remove file
if (f_unlink(filename) != FR_OK)
{
fputs("unlink failed (file exists?)\n", stderr);
return 1;
}
}
else if (strcmp(argv[2], "mkdir") == 0)
{
// Get filename
if (argc != 4)
return printUsage();
filename = argv[3];
// Create directory
if (f_mkdir(filename) != FR_OK)
{
fputs("mkdir failed\n", stderr);
return 1;
}
}
else if (strcmp(argv[2], "read") == 0)
{
// Get both files
if (argc != 5)
return printUsage();
// Open both files
if (f_open(&intFileObj, argv[3], FA_READ) != FR_OK)
{
fputs("internal open failed (file exists?)\n", stderr);
return 1;
}
extFileObj = fopen(argv[4], "wb");
if (extFileObj == NULL)
{
perror("external open failed\n");
f_close(&intFileObj);
return 1;
}
// Copy data
do
{
// Internal read
if (f_read(&intFileObj, buffer, BUFFER_SIZE, &bytesRead) != FR_OK)
{
fputs("internal read failed\n", stderr);
fclose(extFileObj);
f_close(&intFileObj);
return 1;
}
// External write
if (fwrite(buffer, 1, bytesRead, extFileObj) != bytesRead)
{
perror("external write failed\n");
fclose(extFileObj);
f_close(&intFileObj);
return 1;
}
}
while (bytesRead == BUFFER_SIZE);
// Close files
fclose(extFileObj);
f_close(&intFileObj);
}
else if (strcmp(argv[2], "write") == 0)
{
// Get both files
if (argc != 5)
return printUsage();
// Open both files
if (f_open(&intFileObj, argv[3], FA_WRITE | FA_CREATE_ALWAYS) != FR_OK)
{
fputs("internal open failed\n", stderr);
return 1;
}
extFileObj = fopen(argv[4], "rb");
if (extFileObj == NULL)
{
perror("external open failed (file exists?)");
f_close(&intFileObj);
return 1;
}
// Copy data
do
{
// External read
bytesRead = fread(buffer, 1, BUFFER_SIZE, extFileObj);
if (bytesRead != BUFFER_SIZE && !feof(extFileObj))
{
fputs("external read failed\n", stderr);
fclose(extFileObj);
f_close(&intFileObj);
return 1;
}
// Internal write
if (f_write(&intFileObj, buffer, bytesRead, &bytesWritten) != FR_OK ||
bytesRead != bytesWritten)
{
fputs("internal write failed\n", stderr);
fclose(extFileObj);
f_close(&intFileObj);
return 1;
}
}
while (bytesRead == BUFFER_SIZE);
// Close files
fclose(extFileObj);
f_close(&intFileObj);
}
else
{
// Bad command
return printUsage();
}
return 0;
}
int fatfs_stat(vnode_t * vnode, struct stat * buf)
{
struct fatfs_sb * ffsb = get_ffsb_of_sb(vnode->sb);
struct fatfs_inode * in = get_inode_of_vnode(vnode);
FILINFO fno;
struct stat mp_stat = { .st_uid = 0, .st_gid = 0 };
size_t blksize = ffsb->ff_fs.ssize;
int err;
memset(&fno, 0, sizeof(fno));
err = get_mp_stat(vnode, &mp_stat);
if (err) {
if (err == -EINPROGRESS) {
#ifdef configFATFS_DEBUG
KERROR(KERROR_WARN, "vnode->sb->mountpoint should be set\n");
#endif
} else {
#ifdef configFATFS_DEBUG
KERROR(KERROR_WARN,
"get_mp_stat() returned error (%d)\n",
err);
#endif
return err;
}
}
/* Can't stat FAT root */
if (vnode == vnode->sb->root) {
memcpy(buf, &mp_stat, sizeof(struct stat));
return 0;
}
err = f_stat(&ffsb->ff_fs, in->in_fpath, &fno);
if (err) {
#ifdef configFATFS_DEBUG
KERROR(KERROR_DEBUG,
"f_stat(fs %p, fpath \"%s\", fno %p) failed\n",
&ffsb->ff_fs, in->in_fpath, &fno);
#endif
return fresult2errno(err);
}
buf->st_dev = vnode->sb->vdev_id;
buf->st_ino = vnode->vn_num;
buf->st_mode = vnode->vn_mode;
buf->st_nlink = 1; /* Always one link on FAT. */
buf->st_uid = mp_stat.st_uid;
buf->st_gid = mp_stat.st_gid;
buf->st_size = fno.fsize;
/* TODO Times */
#if 0
buf->st_atim;
buf->st_mtim;
buf->st_ctim;
buf->st_birthtime;
#endif
buf->st_flags = fattrib2uflags(fno.fattrib);
buf->st_blksize = blksize;
buf->st_blocks = fno.fsize / blksize + 1; /* Best guess. */
return 0;
}
int fatfs_chmod(vnode_t * vnode, mode_t mode)
{
struct fatfs_sb * ffsb = get_ffsb_of_sb(vnode->sb);
struct fatfs_inode * in = get_inode_of_vnode(vnode);
uint8_t attr = 0;
const uint8_t mask = AM_RDO;
int err;
if (!(mode & (S_IWUSR | S_IWGRP | S_IWOTH)))
attr |= AM_RDO;
err = fresult2errno(f_chmod(&ffsb->ff_fs, in->in_fpath, attr, mask));
if (!err)
vnode->vn_mode = mode;
return err;
}
/*
* Note: Thre is practically two ways to set AM_RDO, either
* by using chmod() or by this chflags().
*/
int fatfs_chflags(vnode_t * vnode, fflags_t flags)
{
struct fatfs_sb * ffsb = get_ffsb_of_sb(vnode->sb);
struct fatfs_inode * in = get_inode_of_vnode(vnode);
uint8_t attr = 0;
const uint8_t mask = AM_RDO | AM_ARC | AM_SYS | AM_HID;
FRESULT fresult;
if (flags & UF_SYSTEM)
attr |= AM_SYS;
if (flags & UF_ARCHIVE)
attr |= AM_ARC;
if (flags & UF_READONLY)
attr |= AM_RDO;
if (flags & UF_HIDDEN)
attr |= AM_HID;
fresult = f_chmod(&ffsb->ff_fs, in->in_fpath, attr, mask);
return fresult2errno(fresult);
}
/**
* Initialize fatfs vnode data.
* @param vnode is the target vnode to be initialized.
*/
static void init_fatfs_vnode(vnode_t * vnode, ino_t inum, mode_t mode,
long vn_hash, struct fs_superblock * sb)
{
struct stat stat;
#ifdef configFATFS_DEBUG
KERROR(KERROR_DEBUG,
"init_fatfs_vnode(vnode %p, inum %l, mode %o, vn_hash %u, sb %p)\n",
vnode, (uint64_t)inum, mode, (uint32_t)vn_hash, sb);
#endif
fs_vnode_init(vnode, inum, sb, &fatfs_vnode_ops);
vnode->vn_hash = vn_hash;
if (S_ISDIR(mode))
mode |= S_IRWXU | S_IXGRP | S_IXOTH;
vnode->vn_mode = mode | S_IRUSR | S_IRGRP | S_IROTH;
fatfs_stat(vnode, &stat);
vnode->vn_len = stat.st_size;
if ((stat.st_flags & UF_READONLY) == 0)
vnode->vn_mode |= S_IWUSR | S_IWGRP | S_IWOTH;
}
/**
* Get mountpoint stat.
*/
static int get_mp_stat(vnode_t * vnode, struct stat * st)
{
struct fs_superblock * sb;
vnode_t * mp;
#ifdef configFATFS_DEBUG
KASSERT(vnode, "Vnode was given");
KASSERT(vnode->sb, "Superblock is set");
#endif
sb = vnode->sb;
mp = sb->mountpoint;
if (!mp) {
/* We are probably mounting and mountpoint is not yet set. */
#ifdef configFATFS_DEBUG
KERROR(KERROR_DEBUG, "mp not set\n");
#endif
return -EINPROGRESS;
}
#ifdef configFATFS_DEBUG
KASSERT(mp->vnode_ops->stat, "stat() is defined");
#endif
return mp->vnode_ops->stat(mp, st);
}
static int fresult2errno(int fresult)
{
switch (fresult) {
case FR_DISK_ERR:
case FR_INVALID_OBJECT:
case FR_INT_ERR:
return -EIO;
case FR_NOT_ENABLED:
return -ENODEV;
case FR_NO_FILESYSTEM:
return -ENXIO;
case FR_NO_FILE:
case FR_NO_PATH:
return -ENOENT;
case FR_DENIED:
return -EACCES;
case FR_EXIST:
return -EEXIST;
case FR_WRITE_PROTECTED:
return -EPERM;
case FR_NOT_READY:
return -EBUSY;
case FR_INVALID_NAME:
case FR_INVALID_DRIVE:
case FR_MKFS_ABORTED:
case FR_INVALID_PARAMETER:
return -EINVAL;
case FR_TIMEOUT:
return -EWOULDBLOCK;
case FR_NOT_ENOUGH_CORE:
return -ENOMEM;
case FR_TOO_MANY_OPEN_FILES:
return -ENFILE;
default:
if (fresult != 0) /* Unknown error */
return -EIO;
}
return 0;
}
FRESULT FatFs::chmod(const char* path, uint8_t value, uint8_t mask)
{
return f_chmod(path, value, mask);
}
