doxygen/html/unistd_8h_source.html

/*

 * Copyright (c) The Zephyr Project Contributors

 *

 * SPDX-License-Identifier: Apache-2.0

 */


#ifndef ZEPHYR_INCLUDE_POSIX_UNISTD_H_

#define ZEPHYR_INCLUDE_POSIX_UNISTD_H_


#if defined(_POSIX_C_SOURCE) || defined(__DOXYGEN__)


#include "posix_features.h"


#include <stddef.h>

#include <stdint.h>


#include <zephyr/posix/sys/confstr.h>

#include <zephyr/posix/sys/pathconf.h>

#include <zephyr/posix/sys/sysconf.h>

#include <zephyr/toolchain.h>


#ifdef __cplusplus

extern "C" {

#endif


/* Version test macros _POSIX_VERSION, _XOPEN_VERSION, etc, defined in posix_features.h */

/* Constants for Options and Option Groups defined in posix_features.h */


/* Execution-Time Symbolic Constants defined in posix_features.h */

/* TODO: define _POSIX_ASYNC_IO, _POSIX_PRIO_IO, _POSIX_SYNC_IO */

/* TODO: define _POSIX_TIMESTAMP_RESOLUTION, _POSIX2_SYMLINKS */


/* _POSIX2_VERSION defined by posix_features.h */

/* _XOPEN_VERSION defined by posix_features.h */


/* NULL must be defined by the libc stddef.h */


#define F_OK 0

#define R_OK 4

#define W_OK 2

#define X_OK 1


/* confstr() constants in zephyr/posix/sys/confstr.h */


/* SEEK_CUR, SEEK_END, SEEK_SET nominally defined in <stdio.h> */

#ifndef SEEK_CUR

#define SEEK_CUR 1

#endif


#ifndef SEEK_END

#define SEEK_END 2

#endif


#ifndef SEEK_SET

#define SEEK_SET 0

#endif


#if defined(_XOPEN_SOURCE) || defined(__DOXYGEN__)

#define F_LOCK  1

#define F_TEST  3

#define F_TLOCK 2

#define F_ULOCK 0

#endif


/* pathconf() constants in zephyr/posix/sys/pathconf.h  */

/* sysconf() constants in zephyr/posix/sys/sysconf.h  */


#define STDERR_FILENO 2

#define STDIN_FILENO  0

#define STDOUT_FILENO 1


#define _POSIX_VDISABLE ('\0')


#if !defined(_GID_T_DECLARED) && !defined(__gid_t_defined)

typedef unsigned short gid_t;

#define _GID_T_DECLARED

#define __gid_t_defined

#endif


#if !defined(_OFF_T_DECLARED) && !defined(__off_t_defined)

typedef long off_t;

#define _OFF_T_DECLARED

#define __off_t_defined

#endif


#if !defined(_PID_T_DECLARED) && !defined(__pid_t_defined)

/* TODO: it would be nice to convert this to a long */

typedef int pid_t;

#define _PID_T_DECLARED

#define __pid_t_defined

#endif


/* size_t must be defined by the libc stddef.h */


#if !defined(_SSIZE_T_DECLARED) && !defined(__ssize_t_defined)

#ifndef __SIZE_TYPE__

#define __SIZE_TYPE__ unsigned long

#endif

#define unsigned signed /* parasoft-suppress MISRAC2012-RULE_20_4-a MISRAC2012-RULE_20_4-b */

typedef __SIZE_TYPE__ ssize_t;

#undef unsigned

#define _SSIZE_T_DECLARED

#define __ssize_t_defined

#endif


#if !defined(_UID_T_DECLARED) && !defined(__uid_t_defined)

typedef unsigned short uid_t;

#define _UID_T_DECLARED

#define __uid_t_defined

#endif


#if !defined(_USECONDS_T_DECLARED) && !defined(__useconds_t_defined)

typedef unsigned long useconds_t;

#define _USECONDS_T_DECLARED

#define __useconds_t_defined

#endif


/* intptr_t is optionally defined by the libc stdint.h and we assume it is defined there */


int access(const char *path, int amode);

unsigned int alarm(unsigned int seconds);

int chdir(const char *path);

int chown(const char *path, uid_t owner, gid_t group);

int close(int fildes);

size_t confstr(int name, char *buf, size_t len);

#if defined(_XOPEN_SOURCE) || defined(__DOXYGEN__)

char *crypt(const char *key, const char *salt);

#endif

int dup(int fildes);

int dup2(int fildes, int fildes2);

FUNC_NORETURN void _exit(int status);

#if defined(_XOPEN_SOURCE) || defined(__DOXYGEN__)

void encrypt(char block[64], int edflag);

#endif

int execl(const char *path, const char *arg0, ...);

int execle(const char *path, const char *arg0, ...);

int execlp(const char *file, const char *arg0, ...);

int execv(const char *path, char *const argv[]);

int execve(const char *path, char *const argv[], char *const envp[]);

int execvp(const char *file, char *const argv[]);

int faccessat(int fd, const char *path, int amode, int flag);

int fchdir(int fildes);

int fchown(int fildes, uid_t owner, gid_t group);

int fchownat(int fd, const char *path, uid_t owner, gid_t group, int flag);

#if defined(_POSIX_SYNCHRONIZED_IO) || defined(__DOXYGEN__)

int fdatasync(int fildes);

#endif

int fexecve(int fd, char *const argv[], char *const envp[]);

pid_t fork(void);

long fpathconf(int fildes, int name);

#if defined(_POSIX_FSYNC) || defined(__DOXYGEN__)

int fsync(int fd);

#endif

int ftruncate(int fildes, off_t length);

char *getcwd(char *buf, size_t size);

gid_t getegid(void);

#if (_POSIX_C_SOURCE >= 202405L) || defined(__DOXYGEN__)

int getentropy(void *buffer, size_t length);

#endif

uid_t geteuid(void);

gid_t getgid(void);

int getgroups(int gidsetsize, gid_t grouplist[]);

#if defined(_XOPEN_SOURCE) || defined(__DOXYGEN__)

long gethostid(void);

#endif

int gethostname(char *name, size_t namelen);

char *getlogin(void);

int getlogin_r(char *name, size_t namesize);

int getopt(int argc, char *const argv[], const char *optstring);

pid_t getpgid(pid_t pid);

pid_t getpgrp(void);

pid_t getpid(void);

pid_t getppid(void);

pid_t getsid(pid_t pid);

uid_t getuid(void);

int isatty(int fildes);

int lchown(const char *path, uid_t owner, gid_t group);

int link(const char *path1, const char *path2);

int linkat(int fd1, const char *path1, int fd2, const char *path2, int flag);

#if defined(_XOPEN_SOURCE) || defined(__DOXYGEN__)

int lockf(int fildes, int function, off_t size);

#endif

off_t lseek(int fildes, off_t offset, int whence);

#if defined(_XOPEN_SOURCE) || defined(__DOXYGEN__)

int nice(int incr);

#endif

long pathconf(const char *path, int name);

int pause(void);

int pipe(int fildes[2]);

ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset);

ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);

ssize_t read(int fildes, void *buf, size_t nbyte);

ssize_t readlink(const char *restrict path, char *restrict buf, size_t bufsize);

ssize_t readlinkat(int fd, const char *restrict path, char *restrict buf, size_t bufsize);

int rmdir(const char *path);

int setegid(gid_t gid);

int seteuid(uid_t uid);

int setgid(gid_t gid);

int setpgid(pid_t pid, pid_t pgid);

#if (defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE >= 500 && _XOPEN_SOURCE < 800)) ||                   \

    defined(__DOXYGEN__)

pid_t setpgrp(void);

#endif

#if defined(_XOPEN_SOURCE) || defined(__DOXYGEN__)

int setregid(gid_t rgid, gid_t egid);

int setreuid(uid_t ruid, uid_t euid);

#endif

pid_t setsid(void);

int setuid(uid_t uid);

unsigned int sleep(unsigned int seconds);

#if defined(_XOPEN_SOURCE) || defined(__DOXYGEN__)

void swab(const void *ZRESTRICT src, void *ZRESTRICT dest, ssize_t nbytes);

#endif

int symlink(const char *path1, const char *path2);

int symlinkat(const char *path1, int fd, const char *path2);

#if defined(_XOPEN_SOURCE) || defined(__DOXYGEN__)

void sync(void);

#endif

#ifdef CONFIG_POSIX_SYSCONF_IMPL_MACRO

#define sysconf(x) (long)CONCAT(__z_posix_sysconf, x)

#else

long sysconf(int opt);

#endif /* CONFIG_POSIX_SYSCONF_IMPL_FULL */

pid_t tcgetpgrp(int fildes);

int tcsetpgrp(int fildes, pid_t pgid_id);

int truncate(const char *path, off_t length);

char *ttyname(int fildes);

int ttyname_r(int fildes, char *name, size_t namesize);

int unlink(const char *path);

int unlinkat(int fd, const char *path, int flag);

#if (defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE < 700)) || defined(__DOXYGEN__)

int usleep(useconds_t useconds);

#endif

ssize_t write(int fildes, const void *buf, size_t nbyte);


extern char *optarg;

extern int opterr;

extern int optind;

extern int optopt;


#ifdef __cplusplus

}

#endif


#endif /* defined(_POSIX_C_SOURCE) || defined(__DOXYGEN__) */


#endif  /* ZEPHYR_INCLUDE_POSIX_UNISTD_H_ */

confstr.h
POSIX configuration string constants (<sys/confstr.h>)

pid_t
int pid_t
Process ID type.
Definition fcntl.h:192

fsync
int fsync(int fd)
Synchronise an open file's data and metadata to storage.

optopt
int optopt
Unrecognised option character from getopt().

getentropy
int getentropy(void *buffer, size_t length)
Fill a buffer with cryptographically secure random bytes.

getopt
int getopt(int argc, char *const argv[], const char *optstring)
Parse command-line options.

optind
int optind
Index of the next element to be processed by getopt().

optarg
char * optarg
Argument for the current option from getopt().

opterr
int opterr
Error flag for getopt() (non-zero enables error messages).

pwrite
ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset)
Write to a file at a given offset without changing the file offset.

pread
ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset)
Read from a file at a given offset without changing the file offset.

write
ssize_t write(int fildes, const void *buf, size_t nbyte)
Write to a file descriptor.

close
int close(int fildes)
Close a file descriptor.

read
ssize_t read(int fildes, void *buf, size_t nbyte)
Read from a file descriptor.

ttyname_r
int ttyname_r(int fildes, char *name, size_t namesize)
Get the name of the terminal into a caller-supplied buffer.

ttyname
char * ttyname(int fildes)
Get the name of the terminal associated with a file descriptor.

isatty
int isatty(int fildes)
Determine whether a file descriptor refers to a terminal.

dup2
int dup2(int fildes, int fildes2)
Duplicate an open file descriptor to a specific descriptor number.

ftruncate
int ftruncate(int fildes, off_t length)
Truncate an open file to a specified length.

lseek
off_t lseek(int fildes, off_t offset, int whence)
Reposition the file offset of an open file descriptor.

dup
int dup(int fildes)
Duplicate an open file descriptor to the lowest available descriptor.

chdir
int chdir(const char *path)
Change the current working directory.

chown
int chown(const char *path, uid_t owner, gid_t group)
Change the owner and group of a file.

unlink
int unlink(const char *path)
Remove a directory entry.

readlink
ssize_t readlink(const char *restrict path, char *restrict buf, size_t bufsize)
Read the value of a symbolic link.

symlink
int symlink(const char *path1, const char *path2)
Create a symbolic link.

readlinkat
ssize_t readlinkat(int fd, const char *restrict path, char *restrict buf, size_t bufsize)
Read the value of a symbolic link relative to a directory descriptor.

fchownat
int fchownat(int fd, const char *path, uid_t owner, gid_t group, int flag)
Change owner and group of a file relative to a directory descriptor.

truncate
int truncate(const char *path, off_t length)
Truncate a file on the filesystem to a specified length.

link
int link(const char *path1, const char *path2)
Create a hard link.

fchown
int fchown(int fildes, uid_t owner, gid_t group)
Change the owner and group of an open file.

symlinkat
int symlinkat(const char *path1, int fd, const char *path2)
Create a symbolic link relative to a directory file descriptor.

unlinkat
int unlinkat(int fd, const char *path, int flag)
Remove a directory entry relative to a directory file descriptor.

pathconf
long pathconf(const char *path, int name)
Determine the value of a configurable limit for a file path.

access
int access(const char *path, int amode)
Determine accessibility of a file.

rmdir
int rmdir(const char *path)
Remove an empty directory.

fchdir
int fchdir(int fildes)
Change the current working directory to the directory named by a file descriptor.

getcwd
char * getcwd(char *buf, size_t size)
Get the pathname of the current working directory.

fpathconf
long fpathconf(int fildes, int name)
Determine the value of a configurable limit for an open file.

linkat
int linkat(int fd1, const char *path1, int fd2, const char *path2, int flag)
Create a hard link relative to directory file descriptors.

lchown
int lchown(const char *path, uid_t owner, gid_t group)
Change the owner and group of a symbolic link.

faccessat
int faccessat(int fd, const char *path, int amode, int flag)
Determine accessibility of a file relative to a directory descriptor.

tcsetpgrp
int tcsetpgrp(int fildes, pid_t pgid_id)
Set the foreground process group ID of a terminal.

setpgrp
pid_t setpgrp(void)
Set the process group ID to the process ID of the calling process (obsolescent).

tcgetpgrp
pid_t tcgetpgrp(int fildes)
Get the process group ID of the foreground process group of the terminal.

setpgid
int setpgid(pid_t pid, pid_t pgid)
Set the process group ID for a process.

getpgrp
pid_t getpgrp(void)
Get the process group ID of the calling process.

_exit
FUNC_NORETURN void _exit(int status)
Terminate the calling process without calling atexit() handlers.

getsid
pid_t getsid(pid_t pid)
Get the session ID of a process.

execle
int execle(const char *path, const char *arg0,...)
Replace process image with a new program plus environment (argument list form).

setsid
pid_t setsid(void)
Create a new session and set the process group ID.

getpgid
pid_t getpgid(pid_t pid)
Get the process group ID of a process.

usleep
int usleep(useconds_t useconds)
Suspend execution for at least the specified number of microseconds (obsolescent).

sleep
unsigned int sleep(unsigned int seconds)
Suspend execution for at least the specified number of seconds.

execve
int execve(const char *path, char *const argv[], char *const envp[])
Replace process image with a new program plus environment (vector form).

execl
int execl(const char *path, const char *arg0,...)
Replace the process image with a new program (argument list form).

execlp
int execlp(const char *file, const char *arg0,...)
Replace process image using PATH search (argument list form).

execvp
int execvp(const char *file, char *const argv[])
Replace process image using PATH search (vector form).

fork
pid_t fork(void)
Create a child process.

fexecve
int fexecve(int fd, char *const argv[], char *const envp[])
Replace process image using an open file descriptor (vector form).

getpid
pid_t getpid(void)
Get the process ID of the calling process.

getppid
pid_t getppid(void)
Get the process ID of the parent of the calling process.

execv
int execv(const char *path, char *const argv[])
Replace process image with a new program (vector form).

gethostname
int gethostname(char *name, size_t namelen)
Get the name of the current host.

pipe
int pipe(int fildes[2])
Create a pipe — a pair of connected file descriptors.

pause
int pause(void)
Suspend process execution until a signal is received.

alarm
unsigned int alarm(unsigned int seconds)
Schedule an alarm signal (SIGALRM) after a given number of seconds.

confstr
size_t confstr(int name, char *buf, size_t len)
Determine the value of a configurable system variable by name string.

sysconf
long sysconf(int opt)
Get a configurable system variable.

getlogin_r
int getlogin_r(char *name, size_t namesize)
Get the login name of the user into a caller-supplied buffer.

seteuid
int seteuid(uid_t uid)
Set the effective user ID of the calling process.

getgroups
int getgroups(int gidsetsize, gid_t grouplist[])
Get the supplementary group IDs of the calling process.

getuid
uid_t getuid(void)
Get the real user ID of the calling process.

setgid
int setgid(gid_t gid)
Set the real group ID of the calling process.

getegid
gid_t getegid(void)
Get the effective group ID of the calling process.

getgid
gid_t getgid(void)
Get the real group ID of the calling process.

geteuid
uid_t geteuid(void)
Get the effective user ID of the calling process.

setuid
int setuid(uid_t uid)
Set the real user ID of the calling process.

setegid
int setegid(gid_t gid)
Set the effective group ID of the calling process.

getlogin
char * getlogin(void)
Get the login name of the user.

swab
void swab(const void *ZRESTRICT src, void *ZRESTRICT dest, ssize_t nbytes)
Swap bytes in a block of memory (XSI extension).

lockf
int lockf(int fildes, int function, off_t size)
Apply, test, or remove an advisory file lock (XSI extension).

sync
void sync(void)
Schedule outstanding writes to all file systems (XSI extension).

nice
int nice(int incr)
Change the scheduling priority of the calling process (XSI extension).

encrypt
void encrypt(char block[64], int edflag)
Encrypt or decrypt a 64-bit block using DES (XSI extension).

crypt
char * crypt(const char *key, const char *salt)
Encrypt a password string (XSI extension, not recommended for new code).

gethostid
long gethostid(void)
Get a unique identifier for the host system (XSI extension).

setreuid
int setreuid(uid_t ruid, uid_t euid)
Set the real and effective user IDs (XSI extension).

setregid
int setregid(gid_t rgid, gid_t egid)
Set the real and effective group IDs (XSI extension).

fdatasync
int fdatasync(int fildes)
Synchronise the data of an open file to storage (without metadata).

pathconf.h
POSIX pathname configuration constants (<sys/pathconf.h>)

group
POSIX group database entry.
Definition grp.h:32

sysconf.h
POSIX runtime system configuration (<sys/sysconf.h>)

useconds_t
unsigned long useconds_t
Used for time in microseconds (obsolescent).
Definition types.h:183