557 lines
9.5 KiB
C
557 lines
9.5 KiB
C
#include "sys_config.h"
|
|
#include "typesdef.h"
|
|
#include "errno.h"
|
|
#include "osal/sleep.h"
|
|
#include "osal/string.h"
|
|
#include "lib/posix/stdio.h"
|
|
#include "lwip/sockets.h"
|
|
|
|
#ifdef TXWSDK_POSIX
|
|
|
|
#if FS_EN
|
|
#include "fatfs/osal_file.h"
|
|
#include "fatfs/ff.h"
|
|
#endif
|
|
|
|
|
|
#define FILE void
|
|
|
|
#define FS_PSRAM_BUFF 1
|
|
|
|
/* sram slice buffer size, usr for psram slice write to sd */
|
|
#define STDIO_RWBUF_SIZE 10000
|
|
|
|
extern int osal_open(const char *filename, int oflags, int mode);
|
|
int read(int fd, void *buf, size_t nbytes);
|
|
int write(int fd, const void *buf, size_t nbytes);
|
|
|
|
|
|
#define ENV_MAX_CNT (8)
|
|
static const char *_env_list_[ENV_MAX_CNT][2];
|
|
|
|
char *getenv(const char *name)
|
|
{
|
|
int32 i = 0;
|
|
for (i = 0; i < ENV_MAX_CNT; i++) {
|
|
if (_env_list_[i][0] == name) {
|
|
return (char *)_env_list_[i][1];
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
int setenv(const char *name, const char *value, int overwrite)
|
|
{
|
|
int32 i = 0;
|
|
int32 j = -1;
|
|
|
|
for (i = 0; i < ENV_MAX_CNT; i++) {
|
|
if (_env_list_[i][0] == name) {
|
|
break;
|
|
}
|
|
if (j == -1 && _env_list_[i][0] == NULL) {
|
|
j = i;
|
|
}
|
|
}
|
|
|
|
if (i < ENV_MAX_CNT && (overwrite || _env_list_[i][1] == NULL)) {
|
|
_env_list_[i][1] = value;
|
|
} else if (i >= ENV_MAX_CNT && j != -1) {
|
|
_env_list_[j][0] = name;
|
|
_env_list_[j][1] = value;
|
|
} else {
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int unsetenv(const char *name)
|
|
{
|
|
int32 i = 0;
|
|
for (i = 0; i < ENV_MAX_CNT; i++) {
|
|
if (_env_list_[i][0] == name) {
|
|
_env_list_[i][0] = NULL;
|
|
_env_list_[i][1] = NULL;
|
|
break;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int usleep(unsigned long usec)
|
|
{
|
|
os_sleep_us(usec);
|
|
return 0;
|
|
}
|
|
|
|
unsigned int sleep(unsigned int seconds)
|
|
{
|
|
os_sleep(seconds);
|
|
return 0;
|
|
}
|
|
|
|
int access(const char *pathname, int mode)
|
|
{
|
|
#if FS_EN
|
|
return osal_fexist(pathname);
|
|
#else
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
int fclose(FILE *stream)
|
|
{
|
|
#if FS_EN
|
|
return osal_fclose((F_FILE *)stream);
|
|
#else
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
int feof(FILE *stream)
|
|
{
|
|
#if FS_EN
|
|
return f_eof((F_FILE *)stream);
|
|
#else
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
int ferror(FILE *stream)
|
|
{
|
|
#if FS_EN
|
|
return f_error((F_FILE *)stream);
|
|
#else
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
int fflush(FILE *stream)
|
|
{
|
|
#if FS_EN
|
|
return fsync((int)stream);
|
|
#else
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
FILE *fopen(const char *filename, const char *mode)
|
|
{
|
|
#if FS_EN
|
|
return (FILE *)osal_fopen(filename, mode);
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)
|
|
{
|
|
#if FS_EN
|
|
return read((int)stream, ptr, size * nmemb);
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
int fseek(FILE *stream, long int offset, int whence)
|
|
{
|
|
// TODO: not support whence now
|
|
#if FS_EN
|
|
return osal_fseek((F_FILE *)stream, offset);
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
// FIXME: 仅支持获取文件大小, 不支持从指针位置开始
|
|
long ftell(FILE *stream)
|
|
{
|
|
#if FS_EN
|
|
return f_size((FIL *)stream);
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
|
|
{
|
|
#if FS_EN
|
|
return write((int)stream, ptr, size *nmemb);
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
// ADD truncate
|
|
int fileno(FILE *stream)
|
|
{
|
|
return (int)stream;
|
|
}
|
|
|
|
int ftruncate(int fd, off_t length)
|
|
{
|
|
#if FS_EN
|
|
return f_truncate((F_FILE *)fd);
|
|
#else
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
int remove(char *filename)
|
|
{
|
|
#if FS_EN
|
|
return osal_unlink(filename);
|
|
#else
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
int rename(const char *old_filename, const char *new_filename)
|
|
{
|
|
#if FS_EN
|
|
return osal_rename(old_filename, new_filename);
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
void rewind(FILE *stream)
|
|
{
|
|
#if FS_EN
|
|
f_rewind((FIL*)stream);
|
|
#else
|
|
return;
|
|
#endif
|
|
}
|
|
|
|
|
|
|
|
int vfprintf(FILE *stream, const char *format, va_list arg)
|
|
{
|
|
#if FS_EN
|
|
int f_vprintf (FIL* fp,const TCHAR* fmt,va_list arp);
|
|
return f_vprintf((FIL*)stream, format, arg);
|
|
#else
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
int fgetc(FILE *stream)
|
|
{
|
|
uint8 val = 0;
|
|
osal_fread(val, 1, 1, stream);
|
|
return val;
|
|
}
|
|
*/
|
|
|
|
char *fgets(char *str, int n, FILE *stream)
|
|
{
|
|
#if FS_EN
|
|
return f_gets(str, n, (FIL*)stream);
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
int fputc(int c, FILE *stream)
|
|
{
|
|
return f_putc(c, stream);
|
|
}
|
|
|
|
int fputs(const char *str, FILE *stream)
|
|
{
|
|
return f_puts(str, stream);
|
|
}
|
|
*/
|
|
|
|
int fsync(int fd)
|
|
{
|
|
#if FS_EN
|
|
return f_sync((F_FILE *)fd) == FR_OK ? 0 : -1;
|
|
#else
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
int getc(FILE *stream)
|
|
{
|
|
uint8 val = 0;
|
|
#if FS_EN
|
|
osal_fread(&val, 1, 1, (F_FILE *)stream);
|
|
#endif
|
|
return val;
|
|
}
|
|
|
|
/*
|
|
int putc(int c, FILE *stream)
|
|
{
|
|
return f_putc(c, stream);
|
|
}
|
|
*/
|
|
|
|
int stat(const char *path, struct stat *buf)
|
|
{
|
|
#if FS_EN
|
|
FILINFO *file_info = (FILINFO *)os_malloc(sizeof(FILINFO));
|
|
f_stat(path, file_info);
|
|
buf->st_size = file_info->fsize;
|
|
buf->st_mtime = file_info->ftime;
|
|
buf->fattrib = file_info->fattrib;
|
|
buf->st_mode = (file_info->fattrib & AM_DIR) ? S_IFDIR : S_IFREG;
|
|
buf->fname = NULL;
|
|
os_free(file_info);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
// TODO: just support file size for now
|
|
int fstat(int fd, struct stat *statbuf)
|
|
{
|
|
#if FS_EN
|
|
F_FILE *file = (F_FILE *)fd;
|
|
statbuf->st_size = f_size(file);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
#if FS_EN && FS_PSRAM_BUFF
|
|
int write_from_psram(int fd, const char *psram_buf, size_t nbytes)
|
|
{
|
|
int left_len = nbytes;
|
|
int write_len = 0;
|
|
int wlen = 0;
|
|
int len = -1;
|
|
char *sram_buf = os_malloc(STDIO_RWBUF_SIZE);
|
|
if(sram_buf == NULL){
|
|
return -ENOMEM;
|
|
}
|
|
|
|
while (left_len) {
|
|
wlen = left_len < STDIO_RWBUF_SIZE ? left_len : STDIO_RWBUF_SIZE;
|
|
hw_memcpy(sram_buf, psram_buf + write_len, wlen);
|
|
len = (int)osal_fwrite(sram_buf, wlen, 1, (F_FILE *)fd);
|
|
if (len < wlen) {
|
|
os_free(sram_buf);
|
|
return write_len + len;
|
|
}
|
|
left_len -= wlen;
|
|
write_len += wlen;
|
|
}
|
|
|
|
os_free(sram_buf);
|
|
return write_len;
|
|
}
|
|
#endif
|
|
|
|
int write(int fd, const void *buf, size_t nbytes)
|
|
{
|
|
if (fd > 0 && fd < 256) {
|
|
return lwip_write(fd, buf, nbytes);
|
|
} else {
|
|
#if FS_EN
|
|
#if FS_PSRAM_BUFF
|
|
return write_from_psram(fd, buf, nbytes);
|
|
#else
|
|
return osal_fwrite(buf, nbytes, 1, (F_FILE *)fd);
|
|
#endif
|
|
#else
|
|
return -1;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
#if FS_EN && FS_PSRAM_BUFF
|
|
int read_to_psram(int fd, char *psram_buf, size_t nbytes)
|
|
{
|
|
int left_len = nbytes;
|
|
int read_len = 0;
|
|
int rlen = 0;
|
|
int len = -1;
|
|
char *sram_buff = os_malloc(STDIO_RWBUF_SIZE);
|
|
if(sram_buff == NULL){
|
|
return -ENOMEM;
|
|
}
|
|
|
|
while (left_len) {
|
|
rlen = left_len < STDIO_RWBUF_SIZE ? left_len : STDIO_RWBUF_SIZE;
|
|
len = (int)osal_fread(sram_buff, rlen, 1, (F_FILE *)fd);
|
|
hw_memcpy(psram_buf + read_len, sram_buff, len);
|
|
|
|
if (len < rlen) {
|
|
os_free(sram_buff);
|
|
return read_len + len;
|
|
}
|
|
|
|
left_len -= rlen;
|
|
read_len += rlen;
|
|
}
|
|
|
|
os_free(sram_buff);
|
|
return read_len;
|
|
}
|
|
#endif
|
|
|
|
int read(int fd, void *buf, size_t nbytes)
|
|
{
|
|
if (fd > 0 && fd < 256) {
|
|
return lwip_read(fd, buf, nbytes);
|
|
} else {
|
|
#if FS_EN
|
|
#if FS_PSRAM_BUFF
|
|
return read_to_psram(fd, buf, nbytes);
|
|
#else
|
|
return osal_fread(buf, nbytes, 1, (F_FILE *)fd);
|
|
#endif
|
|
#else
|
|
return -1;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
off_t lseek(int fd, off_t offset, int whence)
|
|
{
|
|
// TODO: whence not support now
|
|
#if FS_EN
|
|
return osal_fseek((F_FILE *)fd, offset) == FR_OK ? offset : -1;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
int open(const char *path, int oflags, ...)
|
|
{
|
|
int handler = 0;
|
|
#if FS_EN
|
|
int flags = 0;
|
|
|
|
#if 0
|
|
/* mode is not use */
|
|
int mode = 0;
|
|
va_list arg;
|
|
|
|
va_start(arg, oflags);
|
|
mode = va_arg(arg, int);
|
|
va_end(arg);
|
|
#endif
|
|
|
|
if (ACC_MODE(oflags) == O_RDWR) {
|
|
flags = (FA_READ | FA_WRITE);
|
|
} else if (ACC_MODE(oflags) == O_RDONLY) {
|
|
flags = FA_READ;
|
|
} else {
|
|
flags = FA_WRITE;
|
|
}
|
|
|
|
if (oflags & O_CREAT) {
|
|
flags |= FA_CREATE_ALWAYS;
|
|
}
|
|
|
|
handler = (int)osal_open(path, 0, flags);
|
|
#endif
|
|
return handler == 0 ? -1 : handler;
|
|
}
|
|
|
|
int close(int fd)
|
|
{
|
|
if (fd > 0 && fd < 256) {
|
|
return lwip_close(fd);
|
|
} else {
|
|
#if FS_EN
|
|
return osal_fclose((F_FILE *)fd);
|
|
#else
|
|
return -1;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
int unlink(const char *path)
|
|
{
|
|
#if FS_EN
|
|
return osal_unlink(path);
|
|
#else
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
int fcntl(int fd, int cmd, ...)
|
|
{
|
|
int arg = 0;
|
|
va_list ap;
|
|
|
|
va_start(ap, cmd);
|
|
arg = va_arg(ap, int);
|
|
va_end(ap);
|
|
|
|
if (fd > 0 && fd < 256) {
|
|
return lwip_fcntl(fd, cmd, arg);
|
|
} else {
|
|
#if FS_EN
|
|
return f_cntl((FIL *)fd, cmd, arg);
|
|
#else
|
|
return -1;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
int ioctl(int fd, long cmd, void *argp)
|
|
{
|
|
if (fd > 0 && fd < 256) {
|
|
return lwip_ioctl(fd, cmd, argp);
|
|
} else {
|
|
#if FS_EN
|
|
return f_ioctl((FIL *)fd, cmd, argp);
|
|
#else
|
|
return -1;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
ssize_t readv(int fd, const struct iovec *iov, int iovcnt)
|
|
{
|
|
if (fd > 0 && fd < 256) {
|
|
return lwip_readv(fd, iov, iovcnt);
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
ssize_t writev(int fd, const struct iovec *iov, int iovcnt)
|
|
{
|
|
if (fd > 0 && fd < 256) {
|
|
return lwip_writev(fd, iov, iovcnt);
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int fputs(const char *str, FILE *stream)
|
|
{
|
|
#if FS_EN
|
|
return fwrite(str, 1, os_strlen(str), stream);
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
int _fclose_r (void *rptr, FILE * fp)
|
|
{
|
|
return fclose(fp);
|
|
}
|
|
int _fflush_r (void *rptr, FILE *fp)
|
|
{
|
|
return fflush(fp);
|
|
}
|
|
#else
|
|
int _fclose_r (void *rptr, void * fp)
|
|
{
|
|
return 0;
|
|
}
|
|
int _fflush_r (void *rptr, void *fp)
|
|
{
|
|
return 0;
|
|
}
|
|
#endif
|
|
|