static _fpos_t
funseeker (struct _reent *ptr,
void *cookie,
_fpos_t off,
int whence)
{
funcookie *c = (funcookie *) cookie;
#ifndef __LARGE64_FILES
fpos_t result;
errno = 0;
if ((result = c->seekfn (c->cookie, (fpos_t) off, whence)) < 0 && errno)
__errno_r(ptr) = errno;
#else /* __LARGE64_FILES */
_fpos64_t result;
errno = 0;
if ((result = c->seekfn (c->cookie, (_fpos64_t) off, whence)) < 0 && errno)
__errno_r(ptr) = errno;
else if ((_fpos_t)result != result)
{
__errno_r(ptr) = EOVERFLOW;
result = -1;
}
#endif /* __LARGE64_FILES */
return result;
}
int
_raise_r (struct _reent *ptr,
int sig)
{
_sig_func_ptr func;
if (sig < 0 || sig >= NSIG)
{
__errno_r(ptr) = EINVAL;
return -1;
}
if (ptr->_sig_func == NULL)
func = SIG_DFL;
else
func = ptr->_sig_func[sig];
if (func == SIG_DFL)
return _kill_r (ptr, _getpid_r (ptr), sig);
else if (func == SIG_IGN)
return 0;
else if (func == SIG_ERR)
{
__errno_r(ptr) = EINVAL;
return 1;
}
else
{
ptr->_sig_func[sig] = SIG_DFL;
func (sig);
return 0;
}
}
FILE *
_tmpfile_r (struct _reent *ptr)
{
FILE *fp;
int e;
char *f;
char buf[L_tmpnam];
int fd;
do
{
if ((f = _tmpnam_r (ptr, buf)) == NULL)
return NULL;
fd = _open_r (ptr, f, O_RDWR | O_CREAT | O_EXCL | O_BINARY,
S_IRUSR | S_IWUSR);
}
while (fd < 0 && __errno_r(ptr) == EEXIST);
if (fd < 0)
return NULL;
fp = _fdopen_r (ptr, fd, "wb+");
e = __errno_r(ptr);
if (!fp)
_close_r (ptr, fd);
(void) _remove_r (ptr, f);
__errno_r(ptr) = e;
return fp;
}
int _write_r(struct _reent *r, int file, char * ptr, int len)
{
int n;
(void)r;
//(void)file;
(void)ptr;
#if defined(STDOUT_SD)
if (file != 1) {
__errno_r(r) = EINVAL;
return -1;
}
sdWrite(&STDOUT_SD, (uint8_t *)ptr, (size_t)len);
#endif
switch (file) {
case 1: /*stdout*/
case 2: /* stderr */
for (n = 0; n < len; n++) {
chprintf((BaseSequentialStream *)&itm_port, "%c", *ptr++);
}
break;
default:
errno = EBADF;
return -1;
}
return len;
}
size_t
_mbrtowc_r (struct _reent *ptr,
wchar_t *pwc,
const char *s,
size_t n,
mbstate_t *ps)
{
int retval = 0;
#ifdef _MB_CAPABLE
if (ps == NULL)
{
_REENT_CHECK_MISC(ptr);
ps = &(_REENT_MBRTOWC_STATE(ptr));
}
#endif
if (s == NULL)
retval = __MBTOWC (ptr, NULL, "", 1, ps);
else
retval = __MBTOWC (ptr, pwc, s, n, ps);
if (retval == -1)
{
ps->__count = 0;
__errno_r(ptr) = EILSEQ;
return (size_t)(-1);
}
else
return (size_t)retval;
}
int _read_r(struct _reent *r, int file, char * ptr, int len)
{
(void)r;
(void)file;
(void)ptr;
(void)len;
__errno_r(r) = EINVAL;
return -1;
}
int esp_vfs_rename(struct _reent *r, const char *src, const char *dst)
{
const vfs_entry_t* vfs = get_vfs_for_path(src);
if (vfs == NULL) {
__errno_r(r) = ENOENT;
return -1;
}
const vfs_entry_t* vfs_dst = get_vfs_for_path(dst);
if (vfs != vfs_dst) {
__errno_r(r) = EXDEV;
return -1;
}
const char* src_within_vfs = translate_path(vfs, src);
const char* dst_within_vfs = translate_path(vfs, dst);
int ret;
CHECK_AND_CALL(ret, r, vfs, rename, src_within_vfs, dst_within_vfs);
return ret;
}
caddr_t _sbrk(struct _reent *r, int incr)
{
#if CH_CFG_USE_MEMCORE
void *p;
chDbgCheck(incr >= 0);
p = chHeapAlloc(NULL, (size_t)incr);
if (p == NULL) {
__errno_r(r) = ENOMEM;
return (caddr_t)-1;
}
return (caddr_t)p;
#else
(void)incr;
__errno_r(r) = ENOMEM;
return (caddr_t)-1;
#endif
}
int _read_r(struct _reent *r, int file, char * ptr, int len)
{
(void)r;
#if defined(STDIN_SD)
if (!len || (file != 0)) {
__errno_r(r) = EINVAL;
return -1;
}
len = sdRead(&STDIN_SD, (uint8_t *)ptr, (size_t)len);
return len;
#else
(void)file;
(void)ptr;
(void)len;
__errno_r(r) = EINVAL;
return -1;
#endif
}
int esp_vfs_link(struct _reent *r, const char* n1, const char* n2)
{
const vfs_entry_t* vfs = get_vfs_for_path(n1);
if (vfs == NULL) {
__errno_r(r) = ENOENT;
return -1;
}
const vfs_entry_t* vfs2 = get_vfs_for_path(n2);
if (vfs != vfs2) {
__errno_r(r) = EXDEV;
return -1;
}
const char* path1_within_vfs = translate_path(vfs, n1);
const char* path2_within_vfs = translate_path(vfs, n2);
int ret;
CHECK_AND_CALL(ret, r, vfs, link, path1_within_vfs, path2_within_vfs);
return ret;
}
int
_fstat_r (struct _reent *r, int fd, struct stat *buf)
{
int rc,err;
SYSCALL (SYS_fstat, rc, err, fd, buf, 0);
if (err)
__errno_r (r) = err;
return rc;
}
int
_kill_r (struct _reent *r, int pid, int sig)
{
int rc,err;
SYSCALL (SYS_kill, rc, err, pid, sig, 0);
if (err)
__errno_r (r) = err;
return rc;
}
int
_close_r (struct _reent *r, int fd)
{
int rc,err;
SYSCALL (SYS_close, rc, err, fd, 0, 0);
if (err)
__errno_r (r) = err;
return rc;
}
caddr_t _sbrk_r(struct _reent *r, int incr)
{
#if CH_USE_MEMCORE
void *p;
chDbgCheck(incr > 0, "_sbrk_r");
(void)r;
p = chCoreAlloc((size_t)incr);
if (p == NULL) {
__errno_r(r) = ENOMEM;
return (caddr_t)-1;
}
return (caddr_t)p;
#else
__errno_r(r) = ENOMEM;
return (caddr_t)-1;
#endif
}
off_t __lseek(struct _reent *r, int fd, off_t offset, int whence) {
register struct filedesc *fdp = p_fd;
register struct file *fp;
int error;
mtx_lock(&fd_mtx);
if ((u_int)fd >= fdp->fd_nfiles ||
(fp = fdp->fd_ofiles[fd]) == NULL) {
mtx_unlock(&fd_mtx);
__errno_r(r) = EBADF;
return -1;
}
mtx_unlock(&fd_mtx);
if (fp->f_type != DTYPE_VNODE) {
__errno_r(r) = ESPIPE;
return -1;
}
switch (whence) {
case L_INCR:
fp->f_offset += offset;
break;
case L_XTND:
// fp->f_offset = offset + ((FIL *)fp->f_fs)->fsize;
break;
case L_SET:
fp->f_offset = offset;
break;
default:
__errno_r(r) = EINVAL;
return -1;
}
error = (*fp->f_ops->fo_seek)(fp, offset, whence);
if (error){
__errno_r(r) = error;
return -1;
}
return fp->f_offset;
}
_ssize_t
_read_r (struct _reent *r, int fd, void *buf, size_t nbytes)
{
int err;
_ssize_t rc;
SYSCALL (SYS_read, rc, err, fd, buf, nbytes);
if (err)
__errno_r (r) = err;
return rc;
}
off_t
_lseek_r (struct _reent *r, int fd, off_t offset, int whence)
{
int err;
off_t rc;
SYSCALL (SYS_lseek, rc, err, fd, offset, whence);
if (err)
__errno_r (r) = err;
return rc;
}
struct dirent* readdir(DIR* pdir)
{
const vfs_entry_t* vfs = get_vfs_for_fd(pdir->dd_vfs_idx);
struct _reent* r = __getreent();
if (vfs == NULL) {
__errno_r(r) = EBADF;
return NULL;
}
struct dirent* ret;
CHECK_AND_CALLP(ret, r, vfs, readdir, pdir);
return ret;
}
off_t esp_vfs_lseek(struct _reent *r, int fd, off_t size, int mode)
{
const vfs_entry_t* vfs = get_vfs_for_fd(fd);
if (vfs == NULL) {
__errno_r(r) = EBADF;
return -1;
}
int local_fd = translate_fd(vfs, fd);
int ret;
CHECK_AND_CALL(ret, r, vfs, lseek, local_fd, size, mode);
return ret;
}
int esp_vfs_unlink(struct _reent *r, const char *path)
{
const vfs_entry_t* vfs = get_vfs_for_path(path);
if (vfs == NULL) {
__errno_r(r) = ENOENT;
return -1;
}
const char* path_within_vfs = translate_path(vfs, path);
int ret;
CHECK_AND_CALL(ret, r, vfs, unlink, path_within_vfs);
return ret;
}
ssize_t esp_vfs_read(struct _reent *r, int fd, void * dst, size_t size)
{
const vfs_entry_t* vfs = get_vfs_for_fd(fd);
if (vfs == NULL) {
__errno_r(r) = EBADF;
return -1;
}
int local_fd = translate_fd(vfs, fd);
int ret;
CHECK_AND_CALL(ret, r, vfs, read, local_fd, dst, size);
return ret;
}
int esp_vfs_fstat(struct _reent *r, int fd, struct stat * st)
{
const vfs_entry_t* vfs = get_vfs_for_fd(fd);
if (vfs == NULL) {
__errno_r(r) = EBADF;
return -1;
}
int local_fd = translate_fd(vfs, fd);
int ret;
CHECK_AND_CALL(ret, r, vfs, fstat, local_fd, st);
return ret;
}
void *
_sbrk_r (struct _reent *ptr,
ptrdiff_t incr)
{
char *ret;
void *_sbrk(ptrdiff_t);
errno = 0;
if ((ret = (char *)(_sbrk (incr))) == (void *) -1 && errno != 0)
__errno_r(ptr) = errno;
return ret;
}
int _read_r(struct _reent *r, int file, char *ptr, int len)
{
char i = 0;
uint8_t buffersize = len;
//char ascii;
(void)r;
#if defined(STDIN_SD)
if (!len || (file != 0)) {
__errno_r(r) = EINVAL;
return -1;
}
len = sdRead(&STDIN_SD, (uint8_t *)ptr, (size_t)len);
return len;
#else
//chprintf((BaseSequentialStream *)&itm_port, "file descript: %i\n", file);
if (!len || (file == -1)) {
__errno_r(r) = EBADF;
return -1;
}else {
do{
if(lcfg_table[file].data[i] != EOF){
*ptr = lcfg_table[file].data[i++];
//ascii = *ptr;
//chprintf((BaseSequentialStream *)&itm_port, "character: %c in file: %i with len: %i\n", ascii, file, len);
ptr++;
}
len--;
}while((len > 0) && (lcfg_table[file].data[i] != EOF));
return buffersize - len;
}
__errno_r(r) = EINVAL;
return -1;
#endif
}
void *_sbrk_r(struct _reent *r, ptrdiff_t incr) {
#if CH_USE_MEMCORE
void *p = chCoreAlloc((size_t) incr);
if (p == NULL) {
r->_errno = ENOMEM;
return (void*) -1;
}
return (void*) p;
#else
__errno_r(r) = ENOMEM;
return (caddr_t)-1;
#endif
}
int rmdir(const char* name)
{
const vfs_entry_t* vfs = get_vfs_for_path(name);
struct _reent* r = __getreent();
if (vfs == NULL) {
__errno_r(r) = ENOENT;
return -1;
}
const char* path_within_vfs = translate_path(vfs, name);
int ret;
CHECK_AND_CALL(ret, r, vfs, rmdir, path_within_vfs);
return ret;
}
_off_t
_lseek_r (struct _reent *ptr,
int fd,
_off_t pos,
int whence)
{
_off_t ret;
errno = 0;
if ((ret = _lseek (fd, pos, whence)) == (_off_t) -1 && errno != 0)
__errno_r(ptr) = errno;
return ret;
}
int __fstat(struct _reent *r, int fd, struct stat *sb) {
register struct file *fp;
register struct filedesc *fdp = p_fd;
int res;
mtx_lock(&fd_mtx);
if ((u_int)fd >= fdp->fd_nfiles ||
(fp = fdp->fd_ofiles[fd]) == NULL) {
mtx_unlock(&fd_mtx);
__errno_r(r) = EBADF;
return -1;
}
mtx_unlock(&fd_mtx);
res = (fp->f_ops->fo_stat)(fp, sb);
if (res > 0) {
__errno_r(r) = res;
return -1;
}
return (0);
}
static _READ_WRITE_RETURN_TYPE
funwriter (struct _reent *ptr,
void *cookie,
const char *buf,
_READ_WRITE_BUFSIZE_TYPE n)
{
int result;
funcookie *c = (funcookie *) cookie;
errno = 0;
if ((result = c->writefn (c->cookie, buf, n)) < 0 && errno)
__errno_r(ptr) = errno;
return result;
}
static _fpos64_t
funseeker64 (struct _reent *ptr,
void *cookie,
_fpos64_t off,
int whence)
{
_fpos64_t result;
funcookie *c = (funcookie *) cookie;
errno = 0;
if ((result = c->seekfn (c->cookie, off, whence)) < 0 && errno)
__errno_r(ptr) = errno;
return result;
}
