1
0
mirror of git://projects.qi-hardware.com/wernermisc.git synced 2024-11-15 08:50:38 +02:00
wernermisc/fakefile/slave.c

306 lines
5.4 KiB
C
Raw Normal View History

/*
* slave.c - Fakefile slave library
*
* Copyright 2012 by Werner Almesberger
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*/
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/stat.h>
#define __USE_GNU /* for RTLD_NEXT */
#include <dlfcn.h>
#include "util.h"
#include "fakefile.h"
#include "comm.h"
#define DUMMY_FILE "/dev/null"
#define master NULL
static struct fd_entry {
int fd;
struct fd_entry *next;
} *fake_fds = NULL;
static int (*libc_close)(int fd);
static int (*libc_dup)(int oldfd);
static int (*libc_dup2)(int oldfd, int newfd);
static int (*libc_open)(const char *pathname, int flags, mode_t mode);
static ssize_t (*libc_read)(int fd, void *buf, size_t count);
static FILE *(*libc_fopen)(const char *path, const char *mode);
static void init_self(void)
{
static int initialized = 0;
if (initialized)
return;
libc_close = dlsym(RTLD_NEXT, "close");
libc_dup = dlsym(RTLD_NEXT, "dup");
libc_dup2 = dlsym(RTLD_NEXT, "dup2");
libc_open = dlsym(RTLD_NEXT, "open");
libc_read = dlsym(RTLD_NEXT, "read");
libc_fopen = dlsym(RTLD_NEXT, "fopen");
if (!libc_close || !libc_dup || !libc_dup2 || !libc_open ||
!libc_read) {
perror("dlsym");
_exit(1);
}
initialized = 1;
}
static int get_fd(void)
{
int fd;
fd = libc_open(DUMMY_FILE, O_RDONLY, 0);
if (fd < 0) {
perror(DUMMY_FILE);
exit(1);
}
assert(fd);
return fd;
}
static void add_fake_fd(int fd)
{
struct fd_entry *e;
e = alloc_type(struct fd_entry);
e->fd = fd;
e->next = fake_fds;
fake_fds =e;
}
static int is_fake_fd(int fd)
{
const struct fd_entry *e;
for (e = fake_fds; e && e->fd != fd; e = e->next);
return !!e;
}
static int del_fake_fd(int fd)
{
struct fd_entry **e, *next;
for (e = &fake_fds; *e; e = &(*e)->next)
if ((*e)->fd == fd)
break;
if (!*e)
return 0;
next = (*e)->next;
free(*e);
*e = next;
(void) libc_close(fd);
return 1;
}
int open(const char *pathname, int flags, ...)
{
va_list ap;
struct fakefile_msg *msg;
size_t len;
int mode = 0;
int fd, res;
init_self();
if (flags & O_CREAT) {
va_start(ap, flags);
mode = va_arg(ap, int);
va_end(ap);
}
fd = get_fd();
len = strlen(pathname);
msg = fakefile_msg_new(master, len+5*sizeof(int));
fakefile_msg_add_int(msg, ff_et_open);
fakefile_msg_add_int(msg, flags);
fakefile_msg_add_int(msg, mode);
fakefile_msg_add_int(msg, fd);
fakefile_msg_add_int(msg, len);
fakefile_msg_add(msg, pathname, len);
fakefile_msg_end(msg);
msg = fakefile_msg_recv(master);
res = fakefile_msg_get_int(msg);
fakefile_msg_end(msg);
//fprintf(stderr, "res %d\n", (int) res);
if (res <= 0) {
(void) close(fd);
if (res < 0) {
errno = -res;
return -1;
}
}
if (res)
add_fake_fd(fd);
else
res = libc_open(pathname, flags, mode);
return res;
}
ssize_t read(int fd, void *buf, size_t count)
{
struct fakefile_msg *msg;
ssize_t res;
init_self();
if (!is_fake_fd(fd))
return libc_read(fd, buf, count);
msg = fakefile_msg_new(master, 2*sizeof(int)+sizeof(size_t));
fakefile_msg_add_int(msg, ff_et_read);
fakefile_msg_add_int(msg, fd);
fakefile_msg_add_size_t(msg, count);
fakefile_msg_end(msg);
msg = fakefile_msg_recv(master);
res = fakefile_msg_get_size_t(msg);
if (res > 0) {
assert((size_t) res <= count);
fakefile_msg_get(msg, buf, res);
} else if (res < 0) {
errno = -res;
res = -1;
}
fakefile_msg_end(msg);
//fprintf(stderr, "READ %d\n", (int) res);
return res;
}
int fstat(int fd, struct stat *buf)
{
struct fakefile_msg *msg;
int res;
init_self();
msg = fakefile_msg_new(master, 2*sizeof(int));
fakefile_msg_add_int(msg, ff_et_fstat);
fakefile_msg_add_int(msg, fd);
fakefile_msg_end(msg);
msg = fakefile_msg_recv(master);
res = fakefile_msg_get_size_t(msg);
if (res < 0) {
errno = -res;
res = -1;
} else {
fakefile_msg_get(msg, buf, sizeof(struct stat));
}
fakefile_msg_end(msg);
return res;
}
int stat(const char *path, struct stat *buf)
{
int fd, res;
fd = open(path, O_RDONLY);
if (fd < 0)
return fd;
res = fstat(fd, buf);
(void) close(fd);
return res;
}
int lstat(const char *path, struct stat *buf)
{
return stat(path, buf);
}
int close(int fd)
{
struct fakefile_msg *msg;
int res;
init_self();
if (!del_fake_fd(fd))
return libc_close(fd);
msg = fakefile_msg_new(master, 2*sizeof(int));
fakefile_msg_add_int(msg, ff_et_close);
fakefile_msg_add_int(msg, fd);
fakefile_msg_end(msg);
msg = fakefile_msg_recv(master);
res = fakefile_msg_get_int(msg);
fakefile_msg_end(msg);
if (res < 0) {
errno = -res;
return -1;
}
return res;
}
FILE *fopen(const char *path, const char *mode)
{
init_self();
fprintf(stderr, "fopen \"%s\"\n", path);
return libc_fopen(path, mode);
}
int dup(int oldfd)
{
init_self();
if (is_fake_fd(oldfd)) {
fprintf(stderr, "not supporting \"dup\" yet\n");
exit(1);
}
return libc_dup(oldfd);
}
int dup2(int oldfd, int newfd)
{
int res;
init_self();
if (oldfd == newfd)
return 0;
if (is_fake_fd(oldfd)) {
fprintf(stderr, "not supporting \"dup2\" yet\n");
exit(1);
}
if (is_fake_fd(newfd)) {
res = close(newfd);
if (res < 0)
return res;
}
return libc_dup2(oldfd, newfd);
}