ossp-pkg/sio/sio_sa.c
1.1
#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"
#include "sio_module.h"
#include "sa.h"
typedef struct {
char *mem;
size_t size;
} buffer_t;
typedef struct {
sa_t *sa;
buffer_t input;
size_t written;
void *label_data;
void *label_error;
void *label_eof;
char eof;
char error;
} private_t;
/*
* create stage
*
* allocate private instance data
*/
static
sio_rc_t sa_init(sio_t *sio, void **u)
{
private_t *my;
my = (private_t *)malloc(sizeof(private_t));
if (my == NULL)
return SIO_ERR_MEM;
my->sa = NULL;
my->input.mem = NULL;
my->input.size = 0;
sio_label(sio, SIO_LN_DATA, &my->label_data);
sio_label(sio, SIO_LN_ERROR, &my->label_error);
sio_label(sio, SIO_LN_EOF, &my->label_eof);
my->eof = '\0';
my->error = '\0';
*u = my;
return SIO_OK;
}
/*
* configure stage
*
*/
static
sio_rc_t sa_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, "sa")) {
my->sa = (sa_t *)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 sa_cleanup(sio_t *sio, void *u)
{
return SIO_OK;
}
static
sio_rc_t sa_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;
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 sa_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 sa_openw(sio_t *sio, al_t *al, void *u)
{
return SIO_OK;
}
static
sio_rc_t sa_closew(sio_t *sio, al_t *al, void *u)
{
return SIO_OK;
}
static
void sa_writeeof(al_t *al, private_t *my)
{
al_splice(al, 0, al_bytes(al), NULL, NULL);
al_append_bytes(al, &my->eof, sizeof(my->eof), my->label_eof);
}
static
void sa_writeerror(al_t *al, private_t *my)
{
al_splice(al, 0, al_bytes(al), NULL, NULL);
al_append_bytes(al, &my->error, sizeof(my->error), my->label_error);
}
static
sio_rc_t sa_input(sio_t *sio, al_t *al, void *u)
{
private_t *my = (private_t *)u;
buffer_t *buf = &my->input;
size_t actual;
sa_rc_t src;
src = sa_read(my->sa, buf->mem, buf->size, &actual);
if (src != SA_OK) {
sa_writeerror(al, my);
return SIO_DOWNSTREAM;
} else if (src == SA_ERR_EOF) {
sa_writeeof(al, my);
return SIO_DOWNSTREAM;
}
al_append_bytes(al, buf->mem, actual, my->label_data);
return SIO_DOWNSTREAM;
}
static
al_rc_t sa_output_chunk(al_chunk_t *alc, void *u)
{
private_t *my = (private_t *)u;
char *p;
size_t n, actual;
sa_rc_t src;
p = al_chunk_ptr(alc, 0);
n = al_chunk_len(alc);
src = sa_write(my->sa, p, n, &actual);
if (src != SA_OK)
return AL_ERR_EOF;
my->written += actual; /* XXX not used */
return AL_OK;
}
static
sio_rc_t sa_output(sio_t *sio, al_t *al, void *u)
{
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->label_data,
sa_output_chunk, u);
if (arc != AL_OK) return SIO_ERR_INT;
arc = al_splice(al, 0, al_bytes(al), NULL, NULL);
if (arc != AL_OK) return SIO_ERR_INT;
return SIO_DOWNSTREAM;
}
sio_module_t sio_module_sa = {
"sa",
sa_init,
sa_configure,
sa_cleanup,
sa_openr,
sa_closer,
sa_openw,
sa_closew,
sa_input,
sa_output
};