c-syscalls-posix.cpp

Go to the documentation of this file.

/*
 * This file is part of the µOS++ project (https://micro-os-plus.github.io/).
 * Copyright (c) 2015-2025 Liviu Ionescu. All rights reserved.
 *
 * Permission to use, copy, modify, and/or distribute this software
 * for any purpose is hereby granted, under the terms of the MIT license.
 *
 * If a copy of the license was not distributed with this file, it can
 * be obtained from https://opensource.org/licenses/mit.
 */
 
#if defined(OS_USE_OS_APP_CONFIG_H)
#include <cmsis-plus/os-app-config.h>
#endif
 
#if !defined(OS_USE_SEMIHOSTING_SYSCALLS)
 
#include <cmsis-plus/rtos/os.h>
#include <cmsis-plus/posix-io/types.h>
#include <cmsis-plus/posix-io/file-descriptors-manager.h>
#include <cmsis-plus/posix-io/io.h>
#include <cmsis-plus/posix-io/char-device.h>
#include <cmsis-plus/posix-io/tty.h>
#include <cmsis-plus/posix-io/file.h>
#include <cmsis-plus/posix-io/file-system.h>
#include <cmsis-plus/posix-io/directory.h>
#include <cmsis-plus/posix-io/socket.h>
#include <cmsis-plus/posix-io/net-stack.h>
 
#include <cmsis-plus/posix/sys/uio.h>
 
#include <cmsis-plus/diag/trace.h>
 
#include <cstdarg>
#include <cerrno>
 
// ----------------------------------------------------------------------------
 
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wc++98-compat"
#endif
 
// ----------------------------------------------------------------------------
 
// Notes: Function prefix.
//
// To facilitate testing on POSIX platforms, and also to allow
// integration on custom platforms, all function names are prefixed
// with '__posix_'.
// For embedded environments it is possible to also add aliases to the
// standard, non-prefixed names, by adding the following preprocessor
// definition: OS_INCLUDE_STANDARD_POSIX_FUNCTIONS
 
// Notes: Reentrancy and 'errno'.
//
// The standard headers define errno as '*(__errno())';
// If you use a multi-threaded environment, be sure you
// redefine __errno() to return a thread specific pointer.
 
// ----------------------------------------------------------------------------
 
extern "C"
{
  void
  initialise_monitor_handles (void);
}
 
// ----------------------------------------------------------------------------
// ---- POSIX IO functions ----------------------------------------------------
 
using namespace os;
 
// ----------------------------------------------------------------------------
 
int
__posix_open (const char* path, int oflag, ...)
{
  va_list args;
  va_start (args, oflag);
  auto* const io = posix::vopen (path, oflag, args);
  va_end (args);
 
  if (io == nullptr)
    {
      // Return POSIX style error indicator.
      return -1;
    }
 
  // Return non-negative POSIX file descriptor.
  return io->file_descriptor ();
}
 
int
__posix_close (int fildes)
{
  // The flow is identical for all POSIX functions: identify the C++
  // object and call the corresponding C++ method.
  auto* const io = posix::file_descriptors_manager::io (fildes);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
  return io->close ();
}
 
// ----------------------------------------------------------------------------
 
ssize_t
__posix_read (int fildes, void* buf, size_t nbyte)
{
  auto* const io = posix::file_descriptors_manager::io (fildes);
  if (io == nullptr)
    {
      // STDIN
      if (fildes == 0)
        {
          return 0; // Default empty input (EOF).
        }
      errno = EBADF;
      return -1;
    }
  return io->read (buf, nbyte);
}
 
ssize_t
__posix_write (int fildes, const void* buf, size_t nbyte)
{
  auto* const io = posix::file_descriptors_manager::io (fildes);
  if (io == nullptr)
    {
      // STDOUT & STDERR
      if (fildes == 1 || fildes == 2)
        {
          return trace_write (buf, nbyte); // Default output on trace.
        }
      errno = EBADF;
      return -1;
    }
  return io->write (buf, nbyte);
}
 
ssize_t
__posix_writev (int fildes, const /* struct */ iovec* iov, int iovcnt)
{
  auto* const io = posix::file_descriptors_manager::io (fildes);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
  return io->writev (iov, iovcnt);
}
 
int
__posix_ioctl (int fildes, int request, ...)
{
  auto* const io = posix::file_descriptors_manager::io (fildes);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
 
  // Works only on STREAMS (CherDevices, in this implementation)
  if ((io->get_type ()
       & static_cast<posix::io::type_t> (posix::io::type::char_device))
      == 0)
    {
      errno = ENOTTY; // Not a stream.
      return -1;
    }
 
  va_list args;
  va_start (args, request);
  int ret = (static_cast<posix::char_device*> (io))->vioctl (request, args);
  va_end (args);
 
  return ret;
}
 
off_t
__posix_lseek (int fildes, off_t offset, int whence)
{
  auto* const io = posix::file_descriptors_manager::io (fildes);
  if (io == nullptr)
    {
      errno = EBADF; // Fildes is not an open file descriptor.
      return -1;
    }
 
  // Works only on files (Does not work on sockets, pipes or FIFOs...)
  if ((io->get_type ()
       & static_cast<posix::io::type_t> (posix::io::type::file))
      == 0)
    {
      errno = ESPIPE; // Not a file.
      return -1;
    }
 
  return (static_cast<posix::file*> (io))->lseek (offset, whence);
}
 
int
__posix_isatty (int fildes)
{
  auto* const io = posix::file_descriptors_manager::io (fildes);
  if (io == nullptr)
    {
      if (fildes <= 2)
        {
          return true; // Default TTY for STDIN/OUT/ERR.
        }
      errno = EBADF;
      return -1;
    }
  return io->isatty ();
}
 
int
__posix_tcdrain (int fildes)
{
  auto* const io = posix::file_descriptors_manager::io (fildes);
  if (io == nullptr)
    {
      errno = EBADF; // Fildes is not an open file descriptor.
      return -1;
    }
 
  // Works only on tty...)
  if ((io->get_type () & static_cast<posix::io::type_t> (posix::io::type::tty))
      == 0)
    {
      errno = ESPIPE; // Not a tty.
      return -1;
    }
 
  return (static_cast<posix::tty*> (io))->tcdrain ();
}
 
int
__posix_tcgetattr (int fildes, /* struct */ termios* termios_p)
{
  auto* const io = posix::file_descriptors_manager::io (fildes);
  if (io == nullptr)
    {
      errno = EBADF; // Fildes is not an open file descriptor.
      return -1;
    }
 
  // Works only on tty...)
  if ((io->get_type () & static_cast<posix::io::type_t> (posix::io::type::tty))
      == 0)
    {
      errno = ESPIPE; // Not a tty.
      return -1;
    }
 
  return (static_cast<posix::tty*> (io))->tcgetattr (termios_p);
}
 
int
__posix_tcsetattr (int fildes, int optional_actions,
                   const /* struct */ termios* termios_p)
{
  auto* const io = posix::file_descriptors_manager::io (fildes);
  if (io == nullptr)
    {
      errno = EBADF; // Fildes is not an open file descriptor.
      return -1;
    }
 
  // Works only on tty...)
  if ((io->get_type () & static_cast<posix::io::type_t> (posix::io::type::tty))
      == 0)
    {
      errno = ESPIPE; // Not a tty.
      return -1;
    }
 
  return (static_cast<posix::tty*> (io))
      ->tcsetattr (optional_actions, termios_p);
}
 
int
__posix_tcflush (int fildes, int queue_selector)
{
  auto* const io = posix::file_descriptors_manager::io (fildes);
  if (io == nullptr)
    {
      errno = EBADF; // Fildes is not an open file descriptor.
      return -1;
    }
 
  // Works only on tty...)
  if ((io->get_type () & static_cast<posix::io::type_t> (posix::io::type::tty))
      == 0)
    {
      errno = ESPIPE; // Not a tty.
      return -1;
    }
 
  return (static_cast<posix::tty*> (io))->tcflush (queue_selector);
}
 
int
__posix_tcsendbreak (int fildes, int duration)
{
  auto* const io = posix::file_descriptors_manager::io (fildes);
  if (io == nullptr)
    {
      errno = EBADF; // Fildes is not an open file descriptor.
      return -1;
    }
 
  // Works only on tty...)
  if ((io->get_type () & static_cast<posix::io::type_t> (posix::io::type::tty))
      == 0)
    {
      errno = ESPIPE; // Not a tty.
      return -1;
    }
 
  return (static_cast<posix::tty*> (io))->tcsendbreak (duration);
}
 
int
__posix_fcntl (int fildes, int cmd, ...)
{
  auto* const io = posix::file_descriptors_manager::io (fildes);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
 
  va_list args;
  va_start (args, cmd);
  int ret = io->vfcntl (cmd, args);
  va_end (args);
 
  return ret;
}
 
int
__posix_fstat (int fildes, struct stat* buf)
{
  auto* const io = posix::file_descriptors_manager::io (fildes);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
  return io->fstat (buf);
}
 
int
__posix_fstatvfs (int fildes, struct statvfs* buf)
{
  auto* const io = posix::file_descriptors_manager::io (fildes);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
 
  // Works only on files (Does not work on sockets, pipes or FIFOs...)
  if ((io->get_type ()
       & static_cast<posix::io::type_t> (posix::io::type::file))
      == 0)
    {
      errno = EINVAL; // Not a file.
      return -1;
    }
 
  return (static_cast<posix::file*> (io))->fstatvfs (buf);
}
 
int
__posix_ftruncate (int fildes, off_t length)
{
  auto* const io = posix::file_descriptors_manager::io (fildes);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
 
  // Works only on files (Does not work on sockets, pipes or FIFOs...)
  if ((io->get_type ()
       & static_cast<posix::io::type_t> (posix::io::type::file))
      == 0)
    {
      errno = EINVAL; // Not a file.
      return -1;
    }
 
  return (static_cast<posix::file*> (io))->ftruncate (length);
}
 
int
__posix_fsync (int fildes)
{
  auto* const io = posix::file_descriptors_manager::io (fildes);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
 
  // Works only on files (Does not work on sockets, pipes or FIFOs...)
  if ((io->get_type ()
       & static_cast<posix::io::type_t> (posix::io::type::file))
      == 0)
    {
      errno = EINVAL; // Not a file.
      return -1;
    }
 
  return (static_cast<posix::file*> (io))->fsync ();
}
 
// ----------------------------------------------------------------------------
// ----- POSIX file functions -----
 
int
__posix_chmod (const char* path, mode_t mode)
{
  return posix::chmod (path, mode);
}
 
int
__posix_stat (const char* path, struct stat* buf)
{
  return posix::stat (path, buf);
}
 
int
__posix_truncate (const char* path, off_t length)
{
  return posix::truncate (path, length);
}
 
int
__posix_rename (const char* existing, const char* _new)
{
  return posix::rename (existing, _new);
}
 
int
__posix_unlink (const char* path)
{
  return posix::unlink (path);
}
 
int
__posix_utime (const char* path, const /* struct */ utimbuf* times)
{
  return posix::utime (path, times);
}
 
int
__posix_statvfs (const char* path, struct statvfs* buf)
{
  return posix::statvfs (path, buf);
}
 
// ----------------------------------------------------------------------------
// ----- POSIX file_system functions -----
 
int
__posix_mkdir (const char* path, mode_t mode)
{
  return posix::mkdir (path, mode);
}
 
int
__posix_rmdir (const char* path)
{
  return posix::rmdir (path);
}
 
void
__posix_sync (void)
{
  return posix::sync ();
}
 
// ----------------------------------------------------------------------------
// ----- Directories functions -----
 
DIR*
__posix_opendir (const char* dirpath)
{
  return reinterpret_cast<DIR*> (posix::opendir (dirpath));
}
 
/* struct */ dirent*
__posix_readdir (DIR* dirp)
{
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-align"
  auto* const dir = reinterpret_cast<posix::directory*> (dirp);
#pragma GCC diagnostic pop
  if (dir == nullptr)
    {
      errno = ENOENT;
      return nullptr;
    }
  return dir->read ();
}
 
#if 0
int
__posix_readdir_r (DIR* dirp, struct dirent* entry, struct dirent** result)
  {
    errno = ENOSYS; // Not implemented
    return ((ssize_t) -1);
  }
#endif
 
void
__posix_rewinddir (DIR* dirp)
{
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-align"
  auto* const dir = reinterpret_cast<posix::directory*> (dirp);
#pragma GCC diagnostic pop
  if (dir == nullptr)
    {
      errno = ENOENT;
      return;
    }
  return dir->rewind ();
}
 
int
__posix_closedir (DIR* dirp)
{
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-align"
  auto* const dir = reinterpret_cast<posix::directory*> (dirp);
#pragma GCC diagnostic pop
  if (dir == nullptr)
    {
      errno = ENOENT;
      return -1;
    }
  return dir->close ();
}
 
// ----------------------------------------------------------------------------
// Socket functions
 
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
 
// socket() and socketpair() are the fuctions creating sockets.
// The other are socket specific functions.
 
// In addition, the following IO functions should work on sockets:
// close(), read(), write(), writev(), ioctl(), fcntl(), select().
 
int
__posix_socket (int domain, int type, int protocol)
{
  auto* const sock = posix::socket (domain, type, protocol);
  if (sock == nullptr)
    {
      errno = EBADF;
      return -1;
    }
  return sock->file_descriptor ();
}
 
#if 0
int
__posix_socketpair (int domain, int type, int protocol, int socket_vector[2])
  {
    errno = ENOSYS; // Not implemented
    return -1;
  }
#endif
 
int
__posix_accept (int socket, /* struct */ sockaddr* address,
                socklen_t* address_len)
{
  auto* const io = posix::file_descriptors_manager::socket (socket);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
  auto* const new_socket = io->accept (address, address_len);
  return new_socket->file_descriptor ();
}
 
int
__posix_bind (int socket, const /* struct */ sockaddr* address,
              socklen_t address_len)
{
  auto* const io = posix::file_descriptors_manager::socket (socket);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
  return io->bind (address, address_len);
}
 
int
__posix_connect (int socket, const /* struct */ sockaddr* address,
                 socklen_t address_len)
{
  auto* const io = posix::file_descriptors_manager::socket (socket);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
  return io->connect (address, address_len);
}
 
int
__posix_getpeername (int socket, /* struct */ sockaddr* address,
                     socklen_t* address_len)
{
  auto* const io = posix::file_descriptors_manager::socket (socket);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
  return io->getpeername (address, address_len);
}
 
int
__posix_getsockname (int socket, /* struct */ sockaddr* address,
                     socklen_t* address_len)
{
  auto* const io = posix::file_descriptors_manager::socket (socket);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
  return io->getsockname (address, address_len);
}
 
int
__posix_getsockopt (int socket, int level, int option_name, void* option_value,
                    socklen_t* option_len)
{
  auto* const io = posix::file_descriptors_manager::socket (socket);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
  return io->getsockopt (level, option_name, option_value, option_len);
}
 
int
__posix_listen (int socket, int backlog)
{
  auto* const io = posix::file_descriptors_manager::socket (socket);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
  return io->listen (backlog);
}
 
ssize_t
__posix_recv (int socket, void* buffer, size_t length, int flags)
{
  auto* const io = posix::file_descriptors_manager::socket (socket);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
  return io->recv (buffer, length, flags);
}
 
ssize_t
__posix_recvfrom (int socket, void* buffer, size_t length, int flags,
                  /* struct */ sockaddr* address, socklen_t* address_len)
{
  auto* const io = posix::file_descriptors_manager::socket (socket);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
  return io->recvfrom (buffer, length, flags, address, address_len);
}
 
ssize_t
__posix_recvmsg (int socket, /* struct */ msghdr* message, int flags)
{
  auto* const io = posix::file_descriptors_manager::socket (socket);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
  return io->recvmsg (message, flags);
}
 
ssize_t
__posix_send (int socket, const void* buffer, size_t length, int flags)
{
  auto* const io = posix::file_descriptors_manager::socket (socket);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
  return io->send (buffer, length, flags);
}
 
ssize_t
__posix_sendmsg (int socket, const /* struct */ msghdr* message, int flags)
{
  auto* const io = posix::file_descriptors_manager::socket (socket);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
  return io->sendmsg (message, flags);
}
 
ssize_t
__posix_sendto (int socket, const void* message, size_t length, int flags,
                const /* struct */ sockaddr* dest_addr, socklen_t dest_len)
{
  auto* const io = posix::file_descriptors_manager::socket (socket);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
  return io->sendto (message, length, flags, dest_addr, dest_len);
}
 
int
__posix_setsockopt (int socket, int level, int option_name,
                    const void* option_value, socklen_t option_len)
{
  auto* const io = posix::file_descriptors_manager::socket (socket);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
  return io->setsockopt (level, option_name, option_value, option_len);
}
 
int
__posix_shutdown (int socket, int how)
{
  auto* const io = posix::file_descriptors_manager::socket (socket);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
  return io->shutdown (how);
}
 
int
__posix_sockatmark (int socket)
{
  auto* const io = posix::file_descriptors_manager::socket (socket);
  if (io == nullptr)
    {
      errno = EBADF;
      return -1;
    }
  return io->sockatmark ();
}
 
#pragma GCC diagnostic pop
 
// ----------------------------------------------------------------------------
 
// These functions are defined here to avoid linker errors in free
// standing applications. They might be called in some error cases
// from library code.
//
// If you detect other functions needed, just let us know
// and we'll add them.
 
// ----------------------------------------------------------------------------
 
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunused-parameter"
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
 
// ----------------------------------------------------------------------------
// Not yet implemented.
 
int __attribute__ ((weak))
__posix_readdir_r (DIR* dirp, /* struct */ dirent* entry,
                   /* struct */ dirent** result)
{
  errno = ENOSYS; // Not implemented
  return -1;
}
 
int __attribute__ ((weak))
__posix_socketpair (int domain, int type, int protocol, int socket_vector[2])
{
  errno = ENOSYS; // Not implemented
  return -1;
}
 
int
__posix_gettimeofday (/* struct */ timeval* ptimeval, void* ptimezone)
{
  ptimeval->tv_sec = static_cast<time_t> (os::rtos::rtclock.now ());
  ptimeval->tv_usec = 0;
 
  return 0;
}
 
int
__posix_select (int nfds, fd_set* readfds, fd_set* writefds, fd_set* errorfds,
                /* struct */ timeval* timeout)
{
  errno = ENOSYS; // Not implemented
  return -1;
}
 
clock_t
__posix_times (/* struct */ tms* buf)
{
  errno = ENOSYS; // Not implemented
  return static_cast<clock_t> (-1);
}
 
int
__posix_chdir (const char* path)
{
  errno = ENOSYS; // Not implemented
  return -1;
}
 
char*
__posix_getcwd (char* buf, size_t size)
{
  errno = ENOSYS; // Not implemented
  return nullptr;
}
 
// ----------------------------------------------------------------------------
// Unavailable in non-Unix embedded environments.
 
clock_t
__posix_clock (void)
{
  errno = ENOSYS; // Not implemented
  return static_cast<clock_t> (-1);
}
 
int
__posix_execve (const char* path, char* const argv[], char* const envp[])
{
  errno = ENOSYS; // Not implemented
  return -1;
}
 
pid_t
__posix_fork (void)
{
  errno = ENOSYS; // Not implemented
 
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wuseless-cast"
#endif
 
  return static_cast<pid_t> (-1);
 
#pragma GCC diagnostic push
}
 
pid_t
__posix_getpid (void)
{
  errno = ENOSYS; // Not implemented
 
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wuseless-cast"
#endif
 
  return static_cast<pid_t> (-1);
 
#pragma GCC diagnostic pop
}
 
int
__posix_kill (pid_t pid, int sig)
{
  errno = ENOSYS; // Not implemented
  return -1;
}
 
int
__posix_raise (int sig)
{
  errno = ENOSYS; // Not implemented
  return -1;
}
 
int
__posix_system (const char* command)
{
  errno = ENOSYS; // Not implemented
  return -1;
}
 
pid_t
__posix_wait (int* stat_loc)
{
  errno = ENOSYS; // Not implemented
 
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wuseless-cast"
#endif
 
  return static_cast<pid_t> (-1);
 
#pragma GCC diagnostic pop
}
 
int
__posix_chown (const char* path, uid_t owner, gid_t group)
{
  errno = ENOSYS; // Not implemented
  return -1;
}
 
int
__posix_link (const char* existing, const char* _new)
{
  errno = ENOSYS; // Not implemented
  return -1;
}
 
int
__posix_symlink (const char* existing, const char* _new)
{
  errno = ENOSYS; // Not implemented
  return -1;
}
 
ssize_t
__posix_readlink (const char* path, char* buf, size_t bufsize)
{
  errno = ENOSYS; // Not implemented
  return static_cast<ssize_t> (-1);
}
 
#pragma GCC diagnostic pop
 
// `initialise_monitor_handles()` is a newlib libgloss function used to prepare
// the stdio files when using semihosting. Better keep the name the same.
 
void
initialise_monitor_handles (void)
{
  // Default STDIN, STDOUT, STDERR not required, the  __posix_write()
  // implementation defaults STDOUT/ERR to trace_write().
}
 
// ----------------------------------------------------------------------------
 
#if defined(__ARM_EABI__) && (__STDC_HOSTED__ != 0)
 
// The aliases must be in the same compilation unit as the names
// they alias.
 
#if defined(OS_INCLUDE_NEWLIB_POSIX_FUNCTIONS)
 
// For special embedded environment that use POSIX system calls
// with the newlib reentrant code, redefine
// some functions with _name(), others directly with name().
 
#include <cmsis-plus/posix-io/c-syscalls-aliases-newlib.h>
 
#else
 
// For regular embedded environment that use POSIX system calls,
// redefine **all** functions without the '__posix_' prefix.
 
#include <cmsis-plus/posix-io/c-syscalls-aliases-standard.h>
 
#endif
 
#endif /* defined(__ARM_EABI__) && (__STDC_HOSTED__ != 0) */
 
#endif /* !defined(OS_USE_SEMIHOSTING_SYSCALLS) */
 
// ----------------------------------------------------------------------------