ossp-pkg/sio/sio_fd.c
/*
** OSSP sio - Stream I/O
** Copyright (c) 2002-2005 Cable & Wireless <http://www.cw.com/>
** Copyright (c) 2002-2005 The OSSP Project <http://www.ossp.org/>
** Copyright (c) 2002-2005 Ralf S. Engelschall <rse@engelschall.com>
**
** This file is part of OSSP sio, a layered stream I/O library
** which can be found at http://www.ossp.org/pkg/lib/sio/.
**
** Permission to use, copy, modify, and distribute this software for
** any purpose with or without fee is hereby granted, provided that
** the above copyright notice and this permission notice appear in all
** copies.
**
** THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 AUTHORS AND COPYRIGHT HOLDERS AND THEIR
** 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.
**
** sio_fd.h: filedescriptor stage
*/
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <unistd.h>
#include "al.h"
#include "sio.h"
typedef struct {
char *mem;
size_t size;
} buffer_t;
typedef struct {
int fd;
buffer_t input;
size_t written;
al_label_t data_label;
al_label_t error_label;
al_label_t eof_label;
char eof, error;
} private_t;
/*
* create stage
*
* allocate private instance data
*/
static
sio_rc_t fd_init(sio_t *sio, void **up)
{
private_t *my;
my = (private_t *)malloc(sizeof(private_t));
if (my == NULL)
return SIO_ERR_MEM;
my->fd = -1;
my->input.mem = NULL;
my->input.size = 0;
sio_label(sio, SIO_LN_DATA, &my->data_label);
sio_label(sio, SIO_LN_ERROR, &my->error_label);
sio_label(sio, SIO_LN_EOF, &my->eof_label);
my->eof = '\0';
my->error = '\0';
*up = my;
return SIO_OK;
}
/*
* configure stage
*
*/
static
sio_rc_t fd_configure(sio_t *sio, void *u, void *obj, void *val)
{
private_t *my = (private_t *)u;
const char *name = (const char *)obj;
if (!strcmp(name, "fd")) {
my->fd = *(int *)val;
} else if (!strcmp(name, "buflen")) {
my->input.size = *(size_t *)val;
} else {
return SIO_ERR_ARG;
}
return SIO_OK;
}
/*
* destroy stage
*/
static
sio_rc_t fd_cleanup(sio_t *sio, void *u)
{
private_t *my = (private_t *)u;
free(my);
return SIO_OK;
}
static
sio_rc_t fd_openr(sio_t *sio, al_t *al, void *u)
{
private_t *my = (private_t *)u;
buffer_t *buf = &my->input;
char *p;
size_t n;
n = buf->size;
if (n == 0)
return SIO_ERR_ARG;
p = realloc(buf->mem, n);
if (p != NULL)
buf->mem = p;
if (buf->mem == NULL)
return SIO_ERR_MEM;
return SIO_OK;
}
static
sio_rc_t fd_closer(sio_t *sio, al_t *al, void *u)
{
private_t *my = (private_t *)u;
buffer_t *buf = &my->input;
if (buf->mem != NULL) {
free(buf->mem);
buf->mem = NULL;
}
return SIO_OK;
}
static
sio_rc_t fd_openw(sio_t *sio, al_t *al, void *u)
{
return SIO_OK;
}
static
sio_rc_t fd_closew(sio_t *sio, al_t *al, void *u)
{
return SIO_OK;
}
static
sio_rc_t fd_input(sio_t *sio, al_t *al, void *u, sio_rc_t orc)
{
private_t *my = (private_t *)u;
buffer_t *buf = &my->input;
int actual;
actual = read(my->fd, buf->mem, buf->size);
if (actual < 0) {
al_append_bytes(al, &my->error, sizeof(my->error), my->error_label);
return SIO_SCHED_DOWN;
} else if (actual == 0) {
al_append_bytes(al, &my->eof, sizeof(my->eof), my->eof_label);
return SIO_SCHED_DOWN;
}
al_append_bytes(al, buf->mem, actual, my->data_label);
return SIO_SCHED_DOWN;
}
static
al_rc_t fd_output_chunk(al_chunk_t *alc, void *u)
{
private_t *my = (private_t *)u;
char *p;
size_t n;
int actual;
p = al_chunk_ptr(alc, 0);
n = al_chunk_len(alc);
actual = write(my->fd, p, n);
if (actual < 0)
return AL_ERR_EOF;
my->written += actual;
return AL_OK;
}
static
sio_rc_t fd_output(sio_t *sio, al_t *al, void *u, sio_rc_t orc)
{
private_t *my = (private_t *)u;
al_rc_t arc;
size_t n = al_bytes(al);
my->written = 0;
arc = al_traverse_cb(al, 0, n, AL_FORWARD, my->data_label,
fd_output_chunk, u);
if (arc != AL_OK)
return SIO_SCHED_DOWN;
arc = al_splice(al, 0, al_bytes(al), NULL, NULL);
if (arc != AL_OK)
return SIO_SCHED_DOWN;
return SIO_SCHED_DOWN;
}
sio_module_t sio_module_fd = {
"fd",
fd_init,
fd_configure,
fd_cleanup,
fd_openr,
fd_closer,
fd_openw,
fd_closew,
fd_input,
fd_output,
NULL
};
