FSStatus
FSGetStatFileAsync(FSClient *client, FSCmdBlock *block, FSFileHandle handle, FSStat *stat, uint32_t flags, FSAsyncData *asyncData)
{
assert(asyncData->callback);
auto result = FSGetStatFile(client, block, handle, stat, flags);
FSAsyncCallback cb = static_cast<uint32_t>(asyncData->callback);
cb(client, block, result, asyncData->param);
return result;
}
static int FSDrvFStat(struct _reent* r, int fd, struct stat* st) {
FSFileHandle* handle = (FSFileHandle*) fd;
FSStat stat;
FSStatus err = FSGetStatFile(fsClient, fsCmdBlock, *handle, &stat, FS_RET_ALL_ERROR);
if(err == FS_STATUS_OK) {
FSDrvConvertStat(st, &stat);
} else {
FSDrvReportError(r);
return -1;
}
return 0;
}
static off_t FSDrvSeek(struct _reent* r, int fd, off_t pos, int dir) {
FSFileHandle* handle = (FSFileHandle*) fd;
FSStatus err = FS_STATUS_OK;
switch(dir) {
case SEEK_SET:
break;
case SEEK_CUR: {
u32 currPos = 0;
if((err = FSGetPosFile(fsClient, fsCmdBlock, *handle, &currPos, FS_RET_ALL_ERROR)) == FS_STATUS_OK) {
pos += currPos;
}
break;
}
case SEEK_END: {
FSStat stat;
if((err = FSGetStatFile(fsClient, fsCmdBlock, *handle, &stat, FS_RET_ALL_ERROR)) == FS_STATUS_OK) {
pos += stat.size;
}
break;
}
default:
r->_errno = EINVAL;
return -1;
}
if(err == FS_STATUS_OK) {
if(pos < 0) {
r->_errno = EINVAL;
return -1;
}
err = FSSetPosFile(fsClient, fsCmdBlock, *handle, (u32) pos, FS_RET_ALL_ERROR);
}
if(err != FS_ERROR_OK) {
FSDrvReportError(r);
return -1;
}
return 0;
}
static int sd_fat_fstat_r (struct _reent *r, int fd, struct stat *st)
{
sd_fat_file_state_t *file = (sd_fat_file_state_t *)fd;
if(!file->dev) {
r->_errno = ENODEV;
return -1;
}
OSLockMutex(file->dev->pMutex);
// Zero out the stat buffer
memset(st, 0, sizeof(struct stat));
FSStat__ stats;
int result = FSGetStatFile(file->dev->pClient, file->dev->pCmd, file->fd, (FSStat*)&stats, -1);
if(result != 0) {
r->_errno = result;
OSUnlockMutex(file->dev->pMutex);
return -1;
}
st->st_mode = S_IFREG;
st->st_size = stats.size;
st->st_blocks = (stats.size + 511) >> 9;
st->st_nlink = 1;
// Fill in the generic entry stats
st->st_dev = stats.ent_id;
st->st_uid = stats.owner_id;
st->st_gid = stats.group_id;
st->st_ino = stats.ent_id;
st->st_atime = stats.mtime;
st->st_ctime = stats.ctime;
st->st_mtime = stats.mtime;
OSUnlockMutex(file->dev->pMutex);
return 0;
}
static int sd_fat_open_r (struct _reent *r, void *fileStruct, const char *path, int flags, int mode)
{
sd_fat_private_t *dev = sd_fat_get_device_data(path);
if(!dev) {
r->_errno = ENODEV;
return -1;
}
sd_fat_file_state_t *file = (sd_fat_file_state_t *)fileStruct;
file->dev = dev;
// Determine which mode the file is opened for
file->flags = flags;
const char *mode_str;
if ((flags & 0x03) == O_RDONLY) {
file->read = true;
file->write = false;
file->append = false;
mode_str = "r";
} else if ((flags & 0x03) == O_WRONLY) {
file->read = false;
file->write = true;
file->append = (flags & O_APPEND);
mode_str = file->append ? "a" : "w";
} else if ((flags & 0x03) == O_RDWR) {
file->read = true;
file->write = true;
file->append = (flags & O_APPEND);
mode_str = file->append ? "a+" : "r+";
} else {
r->_errno = EACCES;
return -1;
}
int fd = -1;
OSLockMutex(dev->pMutex);
char *real_path = sd_fat_real_path(path, dev);
if(!path) {
r->_errno = ENOMEM;
OSUnlockMutex(dev->pMutex);
return -1;
}
int result = FSOpenFile(dev->pClient, dev->pCmd, real_path, mode_str, (FSFileHandle*)&fd, -1);
free(real_path);
if(result == 0)
{
FSStat stats;
result = FSGetStatFile(dev->pClient, dev->pCmd, fd, &stats, -1);
if(result != 0) {
FSCloseFile(dev->pClient, dev->pCmd, fd, -1);
r->_errno = result;
OSUnlockMutex(dev->pMutex);
return -1;
}
file->fd = fd;
file->pos = 0;
file->len = stats.size;
OSUnlockMutex(dev->pMutex);
return (int)file;
}
r->_errno = result;
OSUnlockMutex(dev->pMutex);
return -1;
}
