libc
/* $Id$ */
/* Copyright (c) 2004-2020 Pierre Pronchery <khorben@defora.org> */
/* This file is part of DeforaOS System libc */
/* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
#include "sys/stat.h"
#include "sys/sysctl.h"
#include "sys/types.h"
#include "sys/utsname.h"
#include "inttypes.h"
#include "stdarg.h"
#include "stddef.h"
#include "stdlib.h"
#include "stdio.h"
#include "dirent.h"
#include "errno.h"
#include "string.h"
#include "termios.h"
#include "time.h"
#include "limits.h"
#include "signal.h"
#include "syscalls.h"
#include "unistd.h"
/* variables */
char * optarg = NULL;
int optind = 1;
int opterr = 1;
int optopt = -1;
char ** environ;
/* functions */
/* access */
/* XXX when wrongly used this is a potential security flaw */
#ifndef SYS_access
# warning Unsupported platform: access() is missing
int access(char const * filename, int mode)
{
errno = ENOSYS;
return -1;
}
#endif
/* alarm */
#ifndef SYS_alarm
# ifdef SYS_setitimer
# include "sys/time.h"
unsigned int alarm(unsigned int seconds)
{
struct itimerval cur;
struct itimerval old;
memset(&cur, 0, sizeof(cur));
cur.it_interval.tv_sec = seconds;
memset(&old, 0, sizeof(old));
if(setitimer(ITIMER_REAL, &cur, &old) != 0)
return -1;
return old.it_interval.tv_sec;
}
# else
# warning Unsupported platform: alarm() is missing
unsigned int alarm(unsigned int seconds)
{
errno = ENOSYS;
return -1;
}
# endif
#endif
/* brk */
#if defined(SYS_brk)
extern int _brk(void * addr); /* XXX in-kernel prototype */
int brk(void * addr)
{
return _brk(addr);
}
#elif defined(SYS_sbrk) /* !SYS_brk && SYS_sbrk */
int brk(void * addr)
{
void * cur;
if((cur = sbrk(0)) == (void *)-1)
return -1;
return (sbrk(addr - cur) != (void *)-1) ? 0 : -1;
}
#else /* !SYS_brk && !SYS_sbrk */
# warning Unsupported platform: brk() is missing
#endif
/* chdir */
#ifndef SYS_chdir
# warning Unsupported platform: chdir() is missing
int chdir(char const * filename)
{
errno = ENOSYS;
return -1;
}
#endif
/* chown */
#ifndef SYS_chown
# warning Unsupported platform: chown() is missing
int chown(char const * filename, uid_t owner, gid_t group)
{
errno = ENOSYS;
return -1;
}
#endif
/* chroot */
#ifndef SYS_chroot
# warning Unsupported platform: chroot() is missing
int chroot(char const * filename)
{
errno = ENOSYS;
return -1;
}
#endif
/* close */
#ifndef SYS_close
# warning Unsupported platform: close() is missing
int close(int fildes)
{
errno = ENOSYS;
return -1;
}
#endif
/* dup */
#ifndef SYS_dup
# warning Unsupported platform: dup() is missing
int dup(int fildes)
{
errno = ENOSYS;
return -1;
}
#endif
/* dup2 */
#ifndef SYS_dup2
# warning Unsupported platform: dup2() is missing
int dup2(int fildes1, int fildes2)
{
errno = ENOSYS;
return -1;
}
#endif
/* execl */
int execl(char const * filename, char * const arg, ...)
{
int ret = 0;
va_list ap;
char const ** argv = NULL;
size_t argv_cnt = 0;
char * p = arg;
char const ** q;
va_start(ap, arg);
do
{
if((q = realloc(argv, sizeof(*argv) * (argv_cnt + 2))) == NULL)
{
free(argv);
va_end(ap);
return -1;
}
argv = q;
argv[argv_cnt++] = p;
}
while((p = va_arg(ap, char *)) != NULL);
va_end(ap);
argv[argv_cnt] = NULL;
ret = execv(filename, argv);
free(argv);
return ret;
}
/* execle */
int execle(char const * filename, char * const arg, ...)
{
int ret = 0;
va_list ap;
char const ** argv = NULL;
size_t argv_cnt = 0;
char * p = arg;
char const ** q;
char ** envp;
va_start(ap, arg);
do
{
if((q = realloc(argv, sizeof(*argv) * (argv_cnt + 1))) == NULL)
{
free(argv);
va_end(ap);
return -1;
}
argv = q;
argv[argv_cnt++] = p;
}
while((p = va_arg(ap, char *)) != NULL);
va_end(ap);
envp = (char **)argv[--argv_cnt];
argv[argv_cnt] = NULL;
ret = execve(filename, argv, envp);
free(argv);
return ret;
}
/* execlp */
int execlp(char const * filename, char * const arg, ...)
{
int ret = 0;
va_list ap;
char const ** argv = NULL;
size_t argv_cnt = 0;
char * p = arg;
char const ** q;
va_start(ap, arg);
do
{
if((q = realloc(argv, sizeof(*argv) * (argv_cnt + 2))) == NULL)
{
free(argv);
va_end(ap);
return -1;
}
argv = q;
argv[argv_cnt++] = p;
}
while((p = va_arg(ap, char *)) != NULL);
va_end(ap);
argv[argv_cnt] = NULL;
ret = execvp(filename, argv);
free(argv);
return ret;
}
/* execv */
int execv(char const * filename, char * const argv[])
{
return execve(filename, argv, environ);
}
/* execve */
#ifndef SYS_execve
# warning Unsupported platform: execve() is missing
int execve(char const * filename, char * const argv[], char * const envp[])
{
errno = ENOSYS;
return -1;
}
#endif
/* execvp */
static void _execvp_do(char const * filename, char * const argv[]);
int execvp(char const * filename, char * const argv[])
{
char const * path;
size_t i = 0;
size_t oldi = 0;
char * buf = NULL;
size_t buf_cnt = 0;
size_t len;
char * p;
if(strchr(filename, '/') != NULL)
return execve(filename, argv, environ);
if((path = getenv("PATH")) == NULL
|| path[0] == '\0')
{
errno = ENOENT;
return -1;
}
len = strlen(filename) + 2;
do
{
if(path[i] != ':' && path[i] != '\0')
continue;
if(i - oldi + len > buf_cnt)
{
buf_cnt = i - oldi + len;
if((p = realloc(buf, buf_cnt)) == NULL)
{
free(buf);
return -1;
}
buf = p;
}
strncpy(buf, &path[oldi], i - oldi);
buf[i - oldi] = '/';
strcpy(&buf[i - oldi + 1], filename);
_execvp_do(buf, argv);
oldi = i + 1;
}
while(path[i++] != '\0');
free(buf);
return -1;
}
static void _execvp_do(char const * filename, char * const argv[])
{
size_t i;
size_t len;
char const ** arg;
execve(filename, argv, environ);
if(errno != ENOEXEC)
return;
/* try with a shell instead */
for(i = 0; argv[i] != NULL; i++);
len = (i + 2) * sizeof(char *);
if((arg = malloc(len)) == NULL)
return;
arg[0] = argv[0];
arg[1] = filename;
for(i = 0; argv[i++] != NULL;)
arg[i + 1] = argv[i];
execv("/bin/sh", (char * const *)arg);
free(arg);
}
/* exit */
#ifndef SYS_exit
# warning Unsupported platform: exit() is missing
void _exit(int status)
{
char ** p = NULL;
/* XXX make it crash */
p = *p;
}
#endif
/* fchdir */
#ifndef SYS_fchdir
# warning Unsupported platform: fchdir() is missing
int fchdir(int fildes)
{
errno = ENOSYS;
return -1;
}
#endif
/* fchown */
#ifndef SYS_fchown
# warning Unsupported platform: fchown() is missing
int fchown(int fildes, uid_t uid, gid_t gid)
{
errno = ENOSYS;
return -1;
}
#endif
/* fork */
#ifndef SYS_fork
# warning Unsupported platform: fork() is missing
pid_t fork(void)
{
errno = ENOSYS;
return -1;
}
#endif
/* fsync */
#ifndef SYS_fsync
# warning Unsupported platform: fsync() is missing
int fsync(int fildes)
{
errno = ENOSYS;
return -1;
}
#endif
/* ftruncate */
#ifndef SYS_ftruncate
# warning Unsupported platform: ftruncate() is missing
int ftruncate(int fildes, off_t offset)
{
errno = ENOSYS;
return -1;
}
#endif
/* getcwd */
#ifdef SYS__getcwd
int _getcwd(char * buf, size_t size);
char * getcwd(char * buf, size_t size)
{
if(buf == NULL)
{
if((buf = malloc(PATH_MAX)) == NULL)
return NULL;
size = PATH_MAX;
}
if(_getcwd(buf, size) < 0)
return NULL;
return buf;
}
#else
# warning Unsupported platform: getcwd() is missing
char * getcwd(char * buf, size_t size)
{
errno = ENOSYS;
return NULL;
}
#endif
/* getegid */
#ifndef SYS_getegid
# warning Unsupported platform: getegid() is missing
#endif
/* geteuid */
#ifndef SYS_geteuid
# warning Unsupported platform: geteuid() is missing
#endif
/* getgid */
#ifndef SYS_getgid
# warning Unsupported platform: getgid() is missing
gid_t getgid(void)
{
/* XXX not allowed to fail */
return 0;
}
#endif
/* getgroups */
#ifndef SYS_getgroups
# warning Unsupported platform: getgroups() is missing
int getgroups(int gidsetsize, gid_t grouplist[])
{
(void) gidsetsize;
(void) grouplist;
errno = ENOSYS;
return -1;
}
#endif
/* gethostname */
int gethostname(char * name, size_t size)
{
#if defined(SYS_sysctl) && defined(CTL_KERN) && defined(KERN_HOSTNAME)
int mib[2] = { CTL_KERN, KERN_HOSTNAME };
if(sysctl(mib, 2, name, &size, NULL, 0) != 0)
return -1;
return 0;
#elif defined(SYS_uname)
struct utsname u;
if(uname(&u) != 0)
return -1;
snprintf(name, size, "%s", u.nodename);
return 0;
#else
# warning Unsupported platform: gethostname() is missing
errno = ENOSYS;
return -1;
#endif
}
/* getlogin */
char * getlogin(void)
{
static char login[LOGIN_NAME_MAX + 1];
if(getlogin_r(login, sizeof(login)) != 0)
return NULL;
return login;
}
/* getlogin_r */
#ifndef SYS_getlogin_r
# include "pwd.h"
int getlogin_r(char * buf, size_t size)
{
struct passwd * pw;
if((pw = getpwuid(getuid())) == NULL) /* FIXME maybe not re-entrant */
return 1;
if(strlen(pw->pw_name) + 1 > size)
{
errno = ERANGE;
return 1;
}
strcpy(buf, pw->pw_name);
return 0;
}
#endif
/* getopt */
static void _getopt_reset(char * const ** oldargv, char * const * argv,
int * i);
int getopt(int argc, char * const argv[], char const * optstring)
{
static char * const * oldargv = NULL;
static int i = 0;
size_t j;
if(argv == NULL)
{
_getopt_reset(&oldargv, NULL, &i);
errno = EINVAL;
return -1;
}
if(argv != oldargv) /* reset state */
_getopt_reset(&oldargv, argv, &i);
if(optind == argc || (i == 0 && argv[optind][0] != '-'))
{
oldargv = NULL;
return -1; /* there is nothing to parse */
}
if(argv[optind][++i] == '\0')
{
if(++optind == argc) /* every argument had options */
return -1;
if(argv[optind][0] != '-' /* next argument has no options */
|| argv[optind][1] == '\0')
return -1;
if(argv[optind][0] == '-' && argv[optind][1] == '-'
&& argv[optind][2] == '\0') /* "--" stops */
{
optind++;
return -1;
}
i = 1;
}
optopt = argv[optind][i];
for(j = 0; optstring[j] != '\0'; j++)
{
if(optstring[j] == ':')
continue;
if(optopt == optstring[j])
break;
}
if(optstring[j] == '\0')
return optstring[0] != ':' ? '?' : ':';
if(optstring[j+1] == ':')
{
if(argv[optind][i+1] != '\0')
{
optarg = &argv[optind][i+1];
optind++;
i = 0;
return optopt;
}
optarg = argv[optind+1];
optind+=2;
i = 0;
}
return optopt;
}
static void _getopt_reset(char * const ** oldargv, char * const * argv,
int * i)
{
optarg = NULL;
optind = 1;
opterr = 1;
optopt = -1;
*oldargv = argv;
*i = 0;
}
/* getpgrp */
#ifndef SYS_getpgrp
# warning Unsupported platform: getpgrp() is missing
pid_t getpgrp(void)
{
/* XXX not allowed to fail */
errno = ENOSYS;
return -1;
}
#endif
/* getpid */
#ifndef SYS_getpid
# warning Unsupported platform: getpid() is missing
pid_t getpid(void)
{
/* XXX not allowed to fail */
errno = ENOSYS;
return -1;
}
#endif
/* getppid */
#ifndef SYS_getppid
# warning Unsupported platform: getppid() is missing
pid_t getppid(void)
{
/* XXX not allowed to fail */
return 1;
}
#endif
/* getuid */
#ifndef SYS_getuid
# warning Unsupported platform: getuid() is missing
uid_t getuid(void)
{
/* XXX not allowed to fail */
return 0;
}
#endif
/* getwd */
char * getwd(char * buf)
{
/* XXX this is a potential security flaw */
return getcwd(buf, PATH_MAX);
}
/* isatty */
int isatty(int fildes)
{
struct termios t;
return tcgetattr(fildes, &t) == 0 ? 1 : 0;
}
/* lchown */
#ifndef SYS_lchown
# warning Unsupported platform: lchown() is missing
int lchown(char const * filename, uid_t owner, gid_t group)
{
errno = ENOSYS;
return -1;
}
#endif
/* link */
#ifndef SYS_link
# warning Unsupported platform: link() is missing
int link(char const * from, char const * to)
{
errno = ENOSYS;
return -1;
}
#endif
/* linkat */
#ifndef SYS_linkat
# warning Unsupported platform: linkat() is missing
int linkat(int fromfd, char const * from, int tofd, char const * to)
{
errno = ENOSYS;
return -1;
}
#endif
/* lseek */
#ifndef SYS_lseek
# warning Unsupported platform: lseek() is missing
off_t lseek(int fildes, off_t offset, int whence)
{
errno = ENOSYS;
return -1;
}
#endif
/* nice */
#if !defined(SYS_nice)
# if defined(SYS_setpriority)
# include "sys/resource.h"
int nice(int inc)
{
int prio;
errno = 0;
if((prio = getpriority(PRIO_PROCESS, 0)) == -1 && errno != 0)
return -1;
return setpriority(PRIO_PROCESS, 0, prio + inc);
}
# else
# warning Unsupported platform: nice() is missing
# endif
#endif /* !SYS_nice */
/* pipe */
#ifndef SYS_pipe
# warning Unsupported platform: pipe() is missing
int pipe(int fildes[2])
{
errno = ENOSYS;
return -1;
}
#endif
/* read */
#ifndef SYS_read
# warning Unsupported platform: read() is missing
ssize_t read(int fildes, void * buf, size_t count)
{
errno = ENOSYS;
return -1;
}
#endif
/* readlink */
#ifndef SYS_readlink
# warning Unsupported platform: readlink() is missing
ssize_t readlink(char const * filename, char * buf, size_t bufsiz)
{
errno = ENOSYS;
return -1;
}
#endif
/* readlinkat */
#ifndef SYS_readlinkat
# warning Unsupported platform: readlinkat() is missing
ssize_t readlinkat(int fd, char const * filename, char * buf, size_t bufsiz)
{
errno = ENOSYS;
return -1;
}
#endif
/* rmdir */
#ifndef SYS_rmdir
# warning Unsupported platform: rmdir() is missing
int rmdir(char const * filename)
{
errno = ENOSYS;
return -1;
}
#endif
/* sbrk */
#if defined(SYS_sbrk)
extern void * _sbrk(intptr_t increment); /* XXX in-kernel prototype */
# if defined(SYS_brk) /* SYS_sbrk && SYS_brk */
extern int _brk(void * addr); /* XXX in-kernel prototype */
void * sbrk(intptr_t increment) /* _brk is used to actually allocate memory */
{
void * cur;
if((cur = _sbrk(0)) == (void *)-1 || increment == 0)
return cur;
return (_brk(cur + increment) != (void *)-1) ? cur : (void *)-1;
}
# else /* SYS_sbrk && !SYS_brk */
void * sbrk(intptr_t increment)
{
return _sbrk(increment);
}
# endif
#elif defined(SYS_brk) /* !SYS_sbrk && SYS_brk */
extern int _brk(void * addr); /* XXX in-kernel prototype */
extern void * end;
void * sbrk(intptr_t increment)
{
static void * cur = &end;
void * ptr;
if(increment == 0)
return cur;
if(_brk(cur + increment) == -1)
return (void *)-1;
ptr = cur;
cur += increment;
return ptr;
}
#else /* !SYS_sbrk && !SYS_brk */
# warning Unsupported platform: sbrk() is missing
void * sbrk(intptr_t increment)
{
errno = ENOSYS;
return (void *)-1;
}
#endif
/* setgid */
#ifndef SYS_setgid
# warning Unsupported platform: setgid() is missing
int setgid(gid_t gid)
{
errno = ENOSYS;
return -1;
}
#endif
/* sethostname */
#ifndef SYS_sethostname
int sethostname(char const * name, size_t size)
{
# if defined(SYS_sysctl) && defined(CTL_KERN) && defined(KERN_HOSTNAME)
int mib[2] = { CTL_KERN, KERN_HOSTNAME };
if(sysctl(mib, 2, NULL, 0, name, size) != 0)
return -1;
return 0;
# else
# warning Unsupported platform: sethostname() is missing
errno = ENOSYS;
return -1;
# endif
}
#endif
/* setpgid */
#ifndef SYS_setpgid
# warning Unsupported platform: setpgid() is missing
int setpgid(pid_t pid, pid_t pgid)
{
errno = ENOSYS;
return -1;
}
#endif
/* setpgrp */
#ifndef SYS_setpgrp
pid_t setpgrp(void)
{
# ifdef SYS_setpgid
return setpgid(0, 0);
# else
# warning Unsupported platform: setpgrp() is missing
/* XXX not allowed to fail */
errno = ENOSYS;
return -1;
# endif
}
#endif
/* setregid */
#ifndef SYS_setregid
# warning Unsupported platform: setregid() is missing
int setregid(gid_t rgid, gid_t egid)
{
errno = ENOSYS;
return -1;
}
#endif
/* setreuid */
#ifndef SYS_setreuid
# warning Unsupported platform: setreuid() is missing
int setreuid(uid_t ruid, uid_t euid)
{
errno = ENOSYS;
return -1;
}
#endif
/* setsid */
#ifndef SYS_setsid
# warning Unsupported platform: setsid() is missing
int setsid(void)
{
errno = ENOSYS;
return -1;
}
#endif
/* setuid */
#ifndef SYS_setuid
# warning Unsupported platform: setuid() is missing
int setuid(uid_t uid)
{
errno = ENOSYS;
return -1;
}
#endif
/* sleep */
unsigned int sleep(unsigned int seconds)
{
struct timespec ts;
ts.tv_sec = seconds;
ts.tv_nsec = 0;
if(nanosleep(&ts, &ts) == 0)
return 0;
return ts.tv_sec;
}
/* strsignal */
char * strsignal(int sig)
{
static const struct
{
int signal;
const char * name;
} names[] = {
{ SIGABRT, "SIGABRT" },
{ SIGCONT, "SIGCONT" },
{ SIGHUP, "SIGHUP" },
{ SIGILL, "SIGILL" },
{ SIGINT, "SIGINT" },
{ SIGKILL, "SIGKILL" },
{ SIGPIPE, "SIGPIPE" },
{ SIGQUIT, "SIGQUIT" },
{ SIGSEGV, "SIGSEGV" },
{ SIGSTOP, "SIGSTOP" },
{ SIGTRAP, "SIGTRAP" },
{ SIGUSR1, "SIGUSR1" },
{ SIGUSR2, "SIGUSR2" },
{ 0, NULL }
};
static char buf[8];
size_t i;
for(i = 0; names[i].name != NULL; i++)
if(names[i].signal == sig)
{
snprintf(buf, sizeof(buf), "%s", names[i].name);
return buf;
}
return NULL;
}
/* symlink */
#ifndef SYS_symlink
# warning Unsupported platform: symlink() is missing
int symlink(char const * from, char const * to)
{
errno = -ENOSYS;
return -1;
}
#endif
/* symlinkat */
#ifndef SYS_symlinkat
# warning Unsupported platform: symlinkat() is missing
int symlinkat(char const * from, int fd, char const * to)
{
errno = -ENOSYS;
return -1;
}
#endif
/* sync */
#ifndef SYS_sync
# warning Unsupported platform: sync() is missing
#endif
/* sysconf */
long sysconf(int name)
{
#if defined(__linux__)
switch(name)
{
case _SC_CLK_TCK:
return 100;
case _SC_PAGESIZE:
return 4096;
}
#elif defined(CTL_KERN) && defined(KERN_CLOCKRATE) && \
defined(CTL_HW) && defined(HW_PAGESIZE)
int mib[2];
size_t len;
struct clockinfo ci;
switch(name)
{
case _SC_CLK_TCK:
mib[0] = CTL_KERN;
mib[1] = KERN_CLOCKRATE;
len = sizeof(ci);
return sysctl(mib, 2, &ci, &len, NULL, 0) != -1
? ci.hz : -1;
case _SC_PAGESIZE:
mib[0] = CTL_HW;
mib[1] = HW_PAGESIZE;
len = sizeof(name);
return sysctl(mib, 2, &name, &len, NULL, 0) != -1
? name : -1;
}
#else
# warning Unsupported platform: sysconf() is missing
#endif
errno = ENOSYS;
return -1;
}
/* truncate */
#ifndef SYS_truncate
# warning Unsupported platform: truncate() is missing
int truncate(char const * filename, off_t offset)
{
errno = ENOSYS;
return -1;
}
#endif
/* ttyname */
char * ttyname(int fildes)
{
static char buf[260]; /* XXX strlen(_PATH_DEV) + NAME_MAX + 2 */
struct stat st;
dev_t rdev;
DIR * dir;
struct dirent * de;
if(isatty(fildes) != 1)
return NULL;
if(fstat(fildes, &st) != 0)
return NULL;
if(!S_ISCHR(st.st_mode))
{
errno = ENOTTY;
return NULL;
}
if((dir = opendir("/dev")) == NULL)
return NULL;
rdev = st.st_rdev;
strcpy(buf, "/dev/");
while((de = readdir(dir)) != NULL)
{
strcpy(&buf[5], de->d_name);
if(stat(buf, &st) != 0)
continue;
if(!S_ISCHR(st.st_mode) || rdev != st.st_rdev)
continue;
closedir(dir);
return buf;
}
closedir(dir);
errno = ENOTTY;
return NULL;
}
/* unlink */
#ifndef SYS_unlink
# warning Unsupported platform: unlink() is missing
int unlink(char const * filename)
{
errno = ENOSYS;
return -1;
}
#endif
/* unlinkat */
#ifndef SYS_unlinkat
# warning Unsupported platform: unlinkat() is missing
int unlinkat(int fd, char const * filename, int flags)
{
errno = ENOSYS;
return -1;
}
#endif
/* usleep */
int usleep(useconds_t useconds)
{
struct timespec tv;
tv.tv_sec = 0;
tv.tv_nsec = useconds * 1000;
return nanosleep(&tv, NULL);
}
/* vfork */
#ifndef SYS_vfork
# warning Unsupported platform: vfork() is missing
pid_t vfork(void)
{
errno = ENOSYS;
return -1;
}
#endif
/* write */
#ifndef SYS_write
# warning Unsupported platform: write() is missing
ssize_t write(int fildes, const void * buf, size_t count)
{
errno = ENOSYS;
return -1;
}
#endif