int
_fstat_current(int fd, struct stat* stat)
{
int status = _kern_read_stat(fd, NULL, false, stat, sizeof(struct stat));
RETURN_AND_SET_ERRNO(status);
}
int
_lstat_current(const char* path, struct stat* stat)
{
int status = _kern_read_stat(-1, path, false, stat, sizeof(struct stat));
RETURN_AND_SET_ERRNO(status);
}
int
msgsnd(int messageQueueID, const void *messagePointer, size_t messageSize,
int messageFlags)
{
RETURN_AND_SET_ERRNO(_kern_xsi_msgsnd(messageQueueID, messagePointer,
messageSize, messageFlags));
}
ssize_t
msgrcv(int messageQueueID, void *messagePointer, size_t messageSize,
long messageType, int messageFlags)
{
RETURN_AND_SET_ERRNO(_kern_xsi_msgrcv(messageQueueID, messagePointer,
messageSize, messageType, messageFlags));
}
ssize_t
read(int fd, void* buffer, size_t bufferSize)
{
ssize_t status = _kern_read(fd, -1, buffer, bufferSize);
RETURN_AND_SET_ERRNO(status);
}
pid_t
getsid(pid_t process)
{
pid_t session = _kern_process_info(process, SESSION_ID);
RETURN_AND_SET_ERRNO(session);
}
int
fs_stat_dev(dev_t device, fs_info *info)
{
status_t status = _kern_read_fs_info(device, info);
RETURN_AND_SET_ERRNO(status);
}
pid_t
getpgid(pid_t process)
{
pid_t group = _kern_process_info(process, GROUP_ID);
RETURN_AND_SET_ERRNO(group);
}
int
fs_create_index(dev_t device, const char *name, uint32 type, uint32 flags)
{
status_t status = _kern_create_index(device, name, type, flags);
RETURN_AND_SET_ERRNO(status);
}
pid_t
setsid(void)
{
status_t status = _kern_setsid();
RETURN_AND_SET_ERRNO(status);
}
int
socketpair(int family, int type, int protocol, int socketVector[2])
{
SyscallFlagUnsetter _;
RETURN_AND_SET_ERRNO(common_socketpair(family, type, protocol,
socketVector, true));
}
int
getsockname(int socket, struct sockaddr *address, socklen_t *_addressLength)
{
SyscallFlagUnsetter _;
RETURN_AND_SET_ERRNO(common_getsockname(socket, address, _addressLength,
true));
}
int
getsockopt(int socket, int level, int option, void *value, socklen_t *_length)
{
SyscallFlagUnsetter _;
RETURN_AND_SET_ERRNO(common_getsockopt(socket, level, option, value,
_length, true));
}
ssize_t
writev(int fd, const struct iovec *vecs, size_t count)
{
ssize_t bytes = _kern_writev(fd, -1, vecs, count);
RETURN_AND_SET_ERRNO(bytes);
}
int
fs_remove_index(dev_t device, const char *name)
{
status_t status = _kern_remove_index(device, name);
RETURN_AND_SET_ERRNO(status);
}
ssize_t
sendto(int socket, const void *data, size_t length, int flags,
const struct sockaddr *address, socklen_t addressLength)
{
SyscallFlagUnsetter _;
RETURN_AND_SET_ERRNO(common_sendto(socket, data, length, flags, address,
addressLength, true));
}
int
fstatat(int fd, const char *path, struct stat *st, int flag)
{
int status = _kern_read_stat(fd, path, (flag & AT_SYMLINK_NOFOLLOW) == 0,
st, sizeof(struct stat));
RETURN_AND_SET_ERRNO(status);
}
ssize_t
recvfrom(int socket, void *data, size_t length, int flags,
struct sockaddr *address, socklen_t *_addressLength)
{
SyscallFlagUnsetter _;
RETURN_AND_SET_ERRNO(common_recvfrom(socket, data, length, flags, address,
_addressLength, true));
}
int
setpgid(pid_t process, pid_t group)
{
pid_t result = _kern_setpgid(process, group);
if (result >= 0)
return 0;
RETURN_AND_SET_ERRNO(result);
}
dev_t
dev_for_path(const char *path)
{
struct stat stat;
int status = _kern_read_stat(-1, path, true, &stat, sizeof(struct stat));
if (status == B_OK)
return stat.st_dev;
RETURN_AND_SET_ERRNO(status);
}
int
shm_open(const char* name, int openMode, mode_t permissions)
{
char path[PATH_MAX];
status_t error = shm_name_to_path(name, path, sizeof(path));
if (error != B_OK)
RETURN_AND_SET_ERRNO(error);
return open(path, openMode, permissions);
}
int
sigqueue(pid_t pid, int signal, const union sigval userValue)
{
if (signal < 0)
RETURN_AND_SET_ERRNO(EINVAL);
if (pid <= 0)
RETURN_AND_SET_ERRNO(ESRCH);
status_t error = _kern_send_signal(pid, signal, &userValue,
SIGNAL_FLAG_QUEUING_REQUIRED);
if (error != B_OK) {
// translate B_BAD_THREAD_ID/B_BAD_TEAM_ID to ESRCH
if (error == B_BAD_THREAD_ID || error == B_BAD_TEAM_ID)
error = ESRCH;
}
RETURN_AND_SET_ERRNO(error);
}
int
shm_unlink(const char* name)
{
char path[PATH_MAX];
status_t error = shm_name_to_path(name, path, sizeof(path));
if (error != B_OK)
RETURN_AND_SET_ERRNO(error);
return unlink(path);
}
ssize_t
pread(int fd, void* buffer, size_t bufferSize, off_t pos)
{
ssize_t status;
if (pos < 0) {
errno = B_BAD_VALUE;
return -1;
}
status = _kern_read(fd, pos, buffer, bufferSize);
RETURN_AND_SET_ERRNO(status);
}
ssize_t
writev_pos(int fd, off_t pos, const struct iovec *vecs, size_t count)
{
ssize_t bytes;
if (pos < 0) {
__set_errno(B_BAD_VALUE);
return -1;
}
bytes = _kern_writev(fd, pos, vecs, count);
RETURN_AND_SET_ERRNO(bytes);
}
int
chmod(const char *path, mode_t mode)
{
struct stat stat;
status_t status;
stat.st_mode = mode;
status = _kern_write_stat(-1, path, true, &stat, sizeof(struct stat),
B_STAT_MODE);
RETURN_AND_SET_ERRNO(status);
}
int
fchmodat(int fd, const char* path, mode_t mode, int flag)
{
struct stat stat;
status_t status;
stat.st_mode = mode;
status = _kern_write_stat(fd, path, (flag & AT_SYMLINK_NOFOLLOW) == 0, &stat,
sizeof(struct stat), B_STAT_MODE);
RETURN_AND_SET_ERRNO(status);
}
int
fchmod(int fd, mode_t mode)
{
struct stat stat;
status_t status;
stat.st_mode = mode;
status = _kern_write_stat(fd, NULL, false, &stat, sizeof(struct stat),
B_STAT_MODE);
RETURN_AND_SET_ERRNO(status);
}
int
closedir(DIR* dir)
{
int status;
if (dir == NULL) {
__set_errno(B_BAD_VALUE);
return -1;
}
status = _kern_close(dir->fd);
free(dir);
RETURN_AND_SET_ERRNO(status);
}
int
setenv(const char *name, const char *value, int overwrite)
{
status_t status;
if (name == NULL || name[0] == '\0' || strchr(name, '=') != NULL) {
errno = B_BAD_VALUE;
return -1;
}
lock_variables();
status = update_variable(name, strlen(name), value, overwrite);
unlock_variables();
RETURN_AND_SET_ERRNO(status);
}
