/*
|
* Copyright (C) 2005 Heikki Lindholm <holindho@cs.helsinki.fi>.
|
*
|
* This library is free software; you can redistribute it and/or
|
* modify it under the terms of the GNU Lesser General Public
|
* License as published by the Free Software Foundation; either
|
* version 2 of the License, or (at your option) any later version.
|
*
|
* This library is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
* Lesser General Public License for more details.
|
|
* You should have received a copy of the GNU Lesser General Public
|
* License along with this library; if not, write to the Free Software
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
|
*/
|
|
/*
|
* NOTE: functions in dynamically linked libraries aren't
|
* wrapped. These are fallback functions for __real* functions used by
|
* the library itself.
|
*/
|
#include <xeno_config.h>
|
#include <sys/types.h>
|
#include <sys/stat.h>
|
#include <sys/ioctl.h>
|
#include <sys/select.h>
|
#include <sys/socket.h>
|
#include <sys/time.h>
|
#include <sys/mman.h>
|
#include <stdio.h>
|
#include <stdarg.h>
|
#include <stdlib.h>
|
#include <signal.h>
|
#include <syslog.h>
|
#include <pthread.h>
|
#include <semaphore.h>
|
#include <limits.h>
|
#include <fcntl.h>
|
#include <sched.h>
|
#include <memory.h>
|
#include <unistd.h>
|
#include <malloc.h>
|
#include <boilerplate/compiler.h>
|
|
/* support for very old c libraries not supporting O_TMPFILE */
|
#ifndef O_TMPFILE
|
#define O_TMPFILE (020000000 | 0200000)
|
#endif
|
|
/* sched */
|
__weak
|
int __real_pthread_setschedparam(pthread_t thread,
|
int policy, const struct sched_param *param)
|
{
|
return pthread_setschedparam(thread, policy, param);
|
}
|
|
__weak
|
int __real_pthread_getschedparam(pthread_t thread,
|
int *policy, struct sched_param *param)
|
{
|
return pthread_getschedparam(thread, policy, param);
|
}
|
|
__weak
|
int __real_pthread_setschedprio(pthread_t thread, int prio)
|
{
|
return pthread_setschedprio(thread, prio);
|
}
|
|
__weak
|
int __real_sched_yield(void)
|
{
|
return sched_yield();
|
}
|
|
__weak
|
int __real_sched_get_priority_min(int policy)
|
{
|
return sched_get_priority_min(policy);
|
}
|
|
__weak
|
int __real_sched_get_priority_max(int policy)
|
{
|
return sched_get_priority_max(policy);
|
}
|
|
__weak
|
int __real_sched_setscheduler(pid_t pid, int policy,
|
const struct sched_param *param)
|
{
|
return sched_setscheduler(pid, policy, param);
|
}
|
|
__weak
|
int __real_sched_getscheduler(pid_t pid)
|
{
|
return sched_getscheduler(pid);
|
}
|
|
/* pthread */
|
__weak
|
int __real_pthread_create(pthread_t *ptid_r,
|
const pthread_attr_t * attr,
|
void *(*start) (void *), void *arg)
|
{
|
return pthread_create(ptid_r, attr, start, arg);
|
}
|
|
__weak
|
int __real_pthread_kill(pthread_t ptid, int sig)
|
{
|
return pthread_kill(ptid, sig);
|
}
|
|
__weak
|
int __real_pthread_join(pthread_t ptid, void **retval)
|
{
|
return pthread_join(ptid, retval);
|
}
|
|
/* attr */
|
__weak
|
int __real_pthread_attr_init(pthread_attr_t *attr)
|
{
|
return pthread_attr_init(attr);
|
}
|
|
/* semaphores */
|
__weak
|
int __real_sem_init(sem_t * sem, int pshared, unsigned value)
|
{
|
return sem_init(sem, pshared, value);
|
}
|
|
__weak
|
int __real_sem_destroy(sem_t * sem)
|
{
|
return sem_destroy(sem);
|
}
|
|
__weak
|
int __real_sem_post(sem_t * sem)
|
{
|
return sem_post(sem);
|
}
|
|
__weak
|
int __real_sem_wait(sem_t * sem)
|
{
|
return sem_wait(sem);
|
}
|
|
__weak
|
int __real_sem_trywait(sem_t * sem)
|
{
|
return sem_trywait(sem);
|
}
|
|
__weak
|
int __real_sem_timedwait(sem_t * sem, const struct timespec *abs_timeout)
|
{
|
return sem_timedwait(sem, abs_timeout);
|
}
|
|
__weak
|
int __real_sem_getvalue(sem_t * sem, int *sval)
|
{
|
return sem_getvalue(sem, sval);
|
}
|
|
/* rtdm */
|
__weak
|
int __real_open(const char *path, int oflag, ...)
|
{
|
mode_t mode = 0;
|
va_list ap;
|
|
if ((oflag & O_CREAT) || (oflag & O_TMPFILE) == O_TMPFILE) {
|
va_start(ap, oflag);
|
mode = va_arg(ap, mode_t);
|
va_end(ap);
|
}
|
|
return open(path, oflag, mode);
|
}
|
|
#if open64 != open
|
__weak
|
int __real_open64(const char *path, int oflag, ...)
|
{
|
mode_t mode = 0;
|
va_list ap;
|
|
if ((oflag & O_CREAT) || (oflag & O_TMPFILE) == O_TMPFILE) {
|
va_start(ap, oflag);
|
mode = va_arg(ap, mode_t);
|
va_end(ap);
|
}
|
|
return open64(path, oflag, mode);
|
}
|
#endif
|
|
#if __USE_FORTIFY_LEVEL > 0
|
__weak int __real___open_2(const char *path, int oflag)
|
{
|
return __open_2(path, oflag);
|
}
|
|
__weak int __real___open64_2(const char *path, int oflag)
|
{
|
return __open64_2(path, oflag);
|
}
|
#endif // __USE_FORTIFY_LEVEL > 0
|
|
__weak
|
int __real_socket(int protocol_family, int socket_type, int protocol)
|
{
|
return socket(protocol_family, socket_type, protocol);
|
}
|
|
__weak
|
int __real_close(int fd)
|
{
|
return close(fd);
|
}
|
|
__weak
|
int __real_fcntl(int fd, int cmd, ...)
|
{
|
va_list ap;
|
long arg;
|
|
va_start(ap, cmd);
|
arg = va_arg(ap, long);
|
va_end(ap);
|
|
return fcntl(fd, cmd, arg);
|
}
|
|
__weak
|
int __real_ioctl(int fd, unsigned int request, ...)
|
{
|
va_list ap;
|
void *arg;
|
|
va_start(ap, request);
|
arg = va_arg(ap, void *);
|
va_end(ap);
|
|
return ioctl(fd, request, arg);
|
}
|
|
__weak
|
ssize_t __real_read(int fd, void *buf, size_t nbyte)
|
{
|
return read(fd, buf, nbyte);
|
}
|
|
__weak
|
ssize_t __real_write(int fd, const void *buf, size_t nbyte)
|
{
|
return write(fd, buf, nbyte);
|
}
|
|
__weak
|
ssize_t __real_recvmsg(int fd, struct msghdr * msg, int flags)
|
{
|
return recvmsg(fd, msg, flags);
|
}
|
|
__weak
|
int __real_recvmmsg(int fd, struct mmsghdr *msgvec, unsigned int vlen,
|
unsigned int flags, struct timespec *timeout)
|
{
|
return recvmmsg(fd, msgvec, vlen, flags, timeout);
|
}
|
|
__weak
|
ssize_t __real_sendmsg(int fd, const struct msghdr * msg, int flags)
|
{
|
return sendmsg(fd, msg, flags);
|
}
|
|
__weak
|
int __real_sendmmsg(int fd, struct mmsghdr *msgvec, unsigned int vlen,
|
unsigned int flags)
|
{
|
return sendmmsg(fd, msgvec, vlen, flags);
|
}
|
|
__weak
|
ssize_t __real_recvfrom(int fd, void *buf, size_t len, int flags,
|
struct sockaddr * from, socklen_t * fromlen)
|
{
|
return recvfrom(fd, buf, len, flags, from, fromlen);
|
}
|
|
__weak
|
ssize_t __real_sendto(int fd, const void *buf, size_t len, int flags,
|
const struct sockaddr * to, socklen_t tolen)
|
{
|
return sendto(fd, buf, len, flags, to, tolen);
|
}
|
|
__weak
|
ssize_t __real_recv(int fd, void *buf, size_t len, int flags)
|
{
|
return recv(fd, buf, len, flags);
|
}
|
|
__weak
|
ssize_t __real_send(int fd, const void *buf, size_t len, int flags)
|
{
|
return send(fd, buf, len, flags);
|
}
|
|
__weak
|
int __real_getsockopt(int fd, int level, int optname, void *optval,
|
socklen_t * optlen)
|
{
|
return getsockopt(fd, level, optname, optval, optlen);
|
}
|
|
__weak
|
int __real_setsockopt(int fd, int level, int optname, const void *optval,
|
socklen_t optlen)
|
{
|
return setsockopt(fd, level, optname, optval, optlen);
|
}
|
|
__weak
|
int __real_bind(int fd, const struct sockaddr *my_addr, socklen_t addrlen)
|
{
|
return bind(fd, my_addr, addrlen);
|
}
|
|
__weak
|
int __real_connect(int fd, const struct sockaddr *serv_addr, socklen_t addrlen)
|
{
|
return connect(fd, serv_addr, addrlen);
|
}
|
|
__weak
|
int __real_listen(int fd, int backlog)
|
{
|
return listen(fd, backlog);
|
}
|
|
__weak
|
int __real_accept(int fd, struct sockaddr *addr, socklen_t * addrlen)
|
{
|
return accept(fd, addr, addrlen);
|
}
|
|
__weak
|
int __real_getsockname(int fd, struct sockaddr *name, socklen_t * namelen)
|
{
|
return getsockname(fd, name, namelen);
|
}
|
|
__weak
|
int __real_getpeername(int fd, struct sockaddr *name, socklen_t * namelen)
|
{
|
return getpeername(fd, name, namelen);
|
}
|
|
__weak
|
int __real_shutdown(int fd, int how)
|
{
|
return shutdown(fd, how);
|
}
|
|
__weak
|
int __real_select (int __nfds, fd_set *__restrict __readfds,
|
fd_set *__restrict __writefds,
|
fd_set *__restrict __exceptfds,
|
struct timeval *__restrict __timeout)
|
{
|
return select(__nfds, __readfds, __writefds, __exceptfds, __timeout);
|
}
|
|
__weak
|
void *__real_mmap(void *addr, size_t length, int prot, int flags,
|
int fd, off_t offset)
|
{
|
return mmap(addr, length, prot, flags, fd, offset);
|
}
|
|
#if mmap64 != mmap
|
__weak
|
void *__real_mmap64(void *addr, size_t length, int prot, int flags,
|
int fd, off64_t offset)
|
{
|
return mmap64(addr, length, prot, flags, fd, offset);
|
}
|
#endif
|
|
__weak
|
int __real_vfprintf(FILE *stream, const char *fmt, va_list args)
|
{
|
return vfprintf(stream, fmt, args);
|
}
|
|
__weak
|
int __real_vprintf(const char *fmt, va_list args)
|
{
|
return vprintf(fmt, args);
|
}
|
|
__weak
|
int __real_fprintf(FILE *stream, const char *fmt, ...)
|
{
|
va_list args;
|
int rc;
|
|
va_start(args, fmt);
|
rc = vfprintf(stream, fmt, args);
|
va_end(args);
|
|
return rc;
|
}
|
|
__weak
|
int __real_printf(const char *fmt, ...)
|
{
|
va_list args;
|
int rc;
|
|
va_start(args, fmt);
|
rc = vprintf(fmt, args);
|
va_end(args);
|
|
return rc;
|
}
|
|
#ifdef CONFIG_XENO_FORTIFY
|
|
__weak
|
int __real___vfprintf_chk(FILE *stream, int level, const char *fmt, va_list ap)
|
{
|
return __vfprintf_chk(stream, level, fmt, ap);
|
}
|
|
__weak
|
void __real___vsyslog_chk(int priority, int level, const char *fmt, va_list ap)
|
{
|
extern void __vsyslog_chk(int, int, const char *, va_list);
|
|
__vsyslog_chk(priority, level, fmt, ap);
|
}
|
|
#endif
|
|
__weak
|
int __real_puts(const char *s)
|
{
|
return puts(s);
|
}
|
|
__weak
|
int __real_fputs(const char *s, FILE *stream)
|
{
|
return fputs(s, stream);
|
}
|
|
#ifndef fputc
|
__weak
|
int __real_fputc(int c, FILE *stream)
|
{
|
return fputc(c, stream);
|
}
|
#endif
|
|
#ifndef putchar
|
__weak
|
int __real_putchar(int c)
|
{
|
return putchar(c);
|
}
|
#endif
|
|
__weak
|
size_t __real_fwrite(const void *ptr, size_t sz, size_t nmemb, FILE *stream)
|
{
|
return fwrite(ptr, sz, nmemb, stream);
|
}
|
|
__weak
|
int __real_fclose(FILE *stream)
|
{
|
return fclose(stream);
|
}
|
|
__weak
|
void __real_syslog(int priority, const char *fmt, ...)
|
{
|
va_list args;
|
|
va_start(args, fmt);
|
vsyslog(priority, fmt, args);
|
va_end(args);
|
}
|
|
__weak
|
void __real_vsyslog(int priority, const char *fmt, va_list ap)
|
{
|
vsyslog(priority, fmt, ap);
|
}
|
|
__weak
|
int __real_gettimeofday(struct timeval *tv, struct timezone *tz)
|
{
|
return gettimeofday(tv, tz);
|
}
|
|
__weak
|
int __real_clock_gettime(clockid_t clk_id, struct timespec *tp)
|
{
|
return clock_gettime(clk_id, tp);
|
}
|
|
__weak
|
int __real_clock_settime(clockid_t clk_id, const struct timespec *tp)
|
{
|
return clock_settime(clk_id, tp);
|
}
|
|
__weak
|
int __real_sigwait(const sigset_t *set, int *sig)
|
{
|
return sigwait(set, sig);
|
}
|
|
__weak
|
int __real_sigwaitinfo(const sigset_t *set, siginfo_t *si)
|
{
|
return sigwaitinfo(set, si);
|
}
|
|
__weak
|
int __real_sigtimedwait(const sigset_t *set, siginfo_t *si,
|
const struct timespec *timeout)
|
{
|
return sigtimedwait(set, si, timeout);
|
}
|
|
__weak
|
int __real_sigpending(sigset_t *set)
|
{
|
return sigpending(set);
|
}
|
|
__weak
|
int __real_kill(pid_t pid, int sig)
|
{
|
return kill(pid, sig);
|
}
|
|
__weak
|
unsigned int __real_sleep(unsigned int seconds)
|
{
|
return sleep(seconds);
|
}
|
|
__weak
|
int __real_usleep(useconds_t usec)
|
{
|
return usleep(usec);
|
}
|
