491 lines
10 KiB
C
491 lines
10 KiB
C
/* Interface to stdio buffered FILE io */
|
|
/* author: klacke@kaja.klacke.net */
|
|
/* Created : 22 Nov 1999 by Claes Wikstrom <klacke@kaja.klacke.net> */
|
|
|
|
#include <string.h>
|
|
|
|
#define USE_STDIO
|
|
|
|
#ifdef WIN32
|
|
#define USE_STDIO
|
|
#include <windows.h>
|
|
|
|
#else
|
|
|
|
#include <errno.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <ctype.h>
|
|
#endif
|
|
|
|
#include "erl_driver.h"
|
|
#ifndef ERL_DRV_NIL
|
|
#include "erl_driver_compat.h"
|
|
#endif
|
|
|
|
#ifdef USE_STDIO
|
|
# include <stdio.h>
|
|
#else
|
|
|
|
# define malloc(s) driver_alloc(s)
|
|
# define realloc(p, s) driver_realloc(p, s)
|
|
# define free(p) driver_free(p)
|
|
|
|
# define BINTERFACE static
|
|
# include "bbio.c"
|
|
# define FILE bFILE
|
|
# define clearerr bclearerr
|
|
# define fclose bfclose
|
|
# define feof bfeof
|
|
# define ferror bferror
|
|
# define fflush bfflush
|
|
# define fgets bfgets
|
|
# define fileno bfileno
|
|
# define fopen bfopen
|
|
# define fread bfread
|
|
# define fseek bfseek
|
|
# define ftell bftell
|
|
# define fwrite bfwrite
|
|
# define getc bgetc
|
|
# define ungetc bungetc
|
|
#endif
|
|
|
|
|
|
#define get_int32(s) ((((unsigned char*) (s))[0] << 24) | \
|
|
(((unsigned char*) (s))[1] << 16) | \
|
|
(((unsigned char*) (s))[2] << 8) | \
|
|
(((unsigned char*) (s))[3]))
|
|
|
|
#define put_int32(i, s) {((char*)(s))[0] = (char)((i) >> 24) & 0xff; \
|
|
((char*)(s))[1] = (char)((i) >> 16) & 0xff; \
|
|
((char*)(s))[2] = (char)((i) >> 8) & 0xff; \
|
|
((char*)(s))[3] = (char)((i) & 0xff);}
|
|
/* op codes */
|
|
|
|
#define XX_OPEN 'o'
|
|
#define XX_CLOSE 'c'
|
|
#define XX_READ 'r'
|
|
#define XX_WRITE 'w'
|
|
#define XX_SEEK 's'
|
|
#define XX_TELL 't'
|
|
#define XX_TRUNCATE 'T'
|
|
#define XX_FLUSH 'f'
|
|
#define XX_OEOF 'e'
|
|
#define XX_ERROR 'E'
|
|
#define XX_GETC 'g'
|
|
#define XX_GETS 'G'
|
|
#define XX_GETS2 '2'
|
|
#define XX_SET_LINEBUF_SIZE 'S'
|
|
#define XX_UNGETC 'u'
|
|
|
|
|
|
|
|
/* return codes */
|
|
#define XX_VALUE 'v'
|
|
#define XX_FLINE 'L'
|
|
#define XX_OK 'o'
|
|
#define XX_I32 'O'
|
|
#define XX_NOLINE 'N'
|
|
#define XX_FERROR 'E'
|
|
#define XX_REOF 'x'
|
|
|
|
|
|
#ifdef WIN32
|
|
#define XX_EINVAL WSAEINVAL
|
|
|
|
|
|
#else
|
|
#define XX_EINVAL EINVAL
|
|
|
|
#endif
|
|
|
|
|
|
static ErlDrvData FILE_start(ErlDrvPort port, char *buf);
|
|
static void FILE_stop(ErlDrvData drv_data);
|
|
|
|
static ErlDrvEntry FILE_driver_entry;
|
|
|
|
typedef struct _desc {
|
|
ErlDrvPort port;
|
|
FILE *fp;
|
|
int linebuf_size;
|
|
} Desc;
|
|
|
|
|
|
static ErlDrvData FILE_start(ErlDrvPort port, char *buf)
|
|
{
|
|
Desc *d = (Desc*) driver_alloc(sizeof (Desc));
|
|
|
|
if (d == NULL)
|
|
return (ErlDrvData) -1;
|
|
d->fp = NULL;
|
|
d->port = port;
|
|
d->linebuf_size = 255; /* default line size */
|
|
|
|
set_port_control_flags(port, PORT_CONTROL_FLAG_BINARY);
|
|
|
|
return (ErlDrvData) d;
|
|
}
|
|
|
|
|
|
static void FILE_stop(ErlDrvData drv_data)
|
|
{
|
|
Desc *d = (Desc*) drv_data;
|
|
if (d->fp)
|
|
fclose(d->fp);
|
|
driver_free(d);
|
|
}
|
|
|
|
|
|
static char *driver_error(ErlDrvPort port, int err)
|
|
{
|
|
char response[256]; /* Response buffer. */
|
|
char* s;
|
|
char* t;
|
|
ErlDrvBinary* bin;
|
|
|
|
bin = driver_alloc_binary(1);
|
|
bin->orig_bytes[0] = XX_FERROR;
|
|
|
|
response[0] = XX_FERROR;
|
|
for (s = erl_errno_id(err), t = bin->orig_bytes + 1; *s; s++, t++)
|
|
*t = tolower(*s);
|
|
return (char *)bin;
|
|
}
|
|
|
|
static char *driver_ret32(ErlDrvPort port, unsigned int r)
|
|
{
|
|
char ch = XX_I32;
|
|
ErlDrvBinary* bin;
|
|
|
|
bin = driver_alloc_binary(1);
|
|
bin->orig_bytes[0] = ch;
|
|
put_int32(r, bin->orig_bytes + 1);
|
|
return (char *)bin;
|
|
}
|
|
|
|
static char *driver_ok(ErlDrvPort port)
|
|
{
|
|
char ch = XX_OK;
|
|
ErlDrvBinary* bin;
|
|
bin = driver_alloc_binary(1);
|
|
bin->orig_bytes[0] = ch;
|
|
return (char *)bin;
|
|
}
|
|
|
|
static char *driver_eof(ErlDrvPort port)
|
|
{
|
|
char ch = XX_REOF;
|
|
ErlDrvBinary* bin;
|
|
bin = driver_alloc_binary(1);
|
|
bin->orig_bytes[0] = ch;
|
|
return (char *)bin;
|
|
}
|
|
|
|
|
|
static int FILE_control(ErlDrvData drv_data,
|
|
unsigned int command,
|
|
char *buf, int len,
|
|
char **rbuf, int rlen)
|
|
{
|
|
Desc *desc = (Desc*) drv_data;
|
|
ErlDrvBinary* bin;
|
|
|
|
switch (command) {
|
|
|
|
case XX_OPEN: {
|
|
char file[BUFSIZ]; /* should be FILENAME_MAX */
|
|
char flags[4]; /* at most someething like rb+ */
|
|
char* src;
|
|
char* dst;
|
|
char* src_end;
|
|
char* dst_end;
|
|
|
|
if (desc->fp != NULL) {
|
|
*rbuf = driver_error(desc->port, XX_EINVAL);
|
|
return 1;
|
|
}
|
|
|
|
/* play it safe ? */
|
|
src = buf;
|
|
src_end = buf + len;
|
|
|
|
/* get file name */
|
|
dst = file;
|
|
dst_end = dst + BUFSIZ; /* make room for a '\0' */
|
|
while((src < src_end) && (dst < dst_end) && (*src != '\0'))
|
|
*dst++ = *src++;
|
|
if ((src == src_end) || (dst == dst_end)) {
|
|
driver_error(desc->port, XX_EINVAL);
|
|
}
|
|
*dst = *src++;
|
|
/* get flags */
|
|
dst = flags;
|
|
dst_end = dst + 4;
|
|
while((src < src_end) && (dst < dst_end) && (*src != '\0'))
|
|
*dst++ = *src++;
|
|
if (dst == dst_end) {
|
|
*rbuf = driver_error(desc->port, XX_EINVAL);
|
|
return 1;
|
|
}
|
|
*dst = '\0';
|
|
|
|
if (src + 1 != src_end) {
|
|
*rbuf = driver_error(desc->port, XX_EINVAL);
|
|
return 1;
|
|
}
|
|
|
|
if ((desc->fp = fopen(file, flags))==NULL) {
|
|
*rbuf = driver_error(desc->port, errno);
|
|
return 1;
|
|
}
|
|
*rbuf = driver_ok(desc->port);
|
|
return 1;
|
|
break;
|
|
}
|
|
|
|
case XX_WRITE: {
|
|
if (fwrite(buf, 1, len, desc->fp) != len) {
|
|
*rbuf = driver_error(desc->port, errno);
|
|
return 1;
|
|
}
|
|
*rbuf = driver_ok(desc->port);
|
|
return 1;
|
|
break;
|
|
}
|
|
|
|
case XX_READ: {
|
|
char ch = XX_VALUE;
|
|
int rval;
|
|
int sz = get_int32(buf);
|
|
|
|
if ((bin = driver_alloc_binary(sz + 1)) == NULL) {
|
|
*rbuf = driver_error(desc->port, -1);
|
|
return 1;
|
|
}
|
|
|
|
bin->orig_bytes[0] = ch;
|
|
if ((rval = fread(bin->orig_bytes + 1, 1, sz, desc->fp)) != sz) {
|
|
if (feof(desc->fp)) {
|
|
if (rval == 0) {
|
|
driver_free_binary(bin);
|
|
*rbuf = driver_eof(desc->port);
|
|
return 1;
|
|
}
|
|
bin = driver_realloc_binary(bin, rval + 1);
|
|
*rbuf = (char *)bin;
|
|
return 1;
|
|
}
|
|
driver_free_binary(bin);
|
|
*rbuf = driver_error(desc->port, errno);
|
|
return 1;
|
|
}
|
|
*rbuf = (char *)bin;
|
|
return 1;
|
|
}
|
|
|
|
case XX_SEEK: {
|
|
int offs = get_int32(buf);
|
|
int w = (int) buf[4];
|
|
int whence;
|
|
switch (w) {
|
|
case 1: whence = SEEK_SET; break;
|
|
case 2: whence = SEEK_CUR; break;
|
|
case 3: whence = SEEK_END; break;
|
|
}
|
|
if ((w = fseek(desc->fp, offs, whence)) != 0) {
|
|
*rbuf = driver_error(desc->port, errno);
|
|
return 1;
|
|
}
|
|
*rbuf = driver_ok(desc->port);
|
|
return 1;
|
|
}
|
|
|
|
case XX_TELL: {
|
|
int offs;
|
|
if ((offs = ftell(desc->fp)) == -1) {
|
|
*rbuf = driver_error(desc->port, errno);
|
|
return 1;
|
|
}
|
|
*rbuf = driver_ret32(desc->port, offs);
|
|
return 1;
|
|
break;
|
|
}
|
|
|
|
case XX_TRUNCATE: {
|
|
int fno;
|
|
int offs;
|
|
/* is this really safe? */
|
|
if (fflush(desc->fp) != 0) {
|
|
*rbuf = driver_error(desc->port, errno);
|
|
return 1;
|
|
}
|
|
if ((offs = ftell(desc->fp)) == -1) {
|
|
*rbuf = driver_error(desc->port, errno);
|
|
return 1;
|
|
}
|
|
fno = fileno(desc->fp);
|
|
#ifdef WIN32
|
|
if (SetEndOfFile((HANDLE)fno) != 0) {
|
|
*rbuf = driver_error(desc->port, GetLastError());
|
|
return 1;
|
|
}
|
|
#else
|
|
if (ftruncate(fno, offs) == -1) {
|
|
*rbuf = driver_error(desc->port, errno);
|
|
return 1;
|
|
}
|
|
#endif
|
|
*rbuf = driver_ok(desc->port);
|
|
return 1;
|
|
}
|
|
|
|
case XX_FLUSH:
|
|
if (fflush(desc->fp) != 0)
|
|
*rbuf = driver_error(desc->port, errno);
|
|
else
|
|
*rbuf = driver_ok(desc->port);
|
|
return 1;
|
|
break;
|
|
|
|
case XX_OEOF:
|
|
if (feof(desc->fp))
|
|
*rbuf = driver_ret32(desc->port, 1);
|
|
else
|
|
*rbuf = driver_ret32(desc->port, 0);
|
|
return 1;
|
|
break;
|
|
|
|
case XX_ERROR:
|
|
if (ferror(desc->fp))
|
|
*rbuf = driver_ret32(desc->port, 1);
|
|
else
|
|
*rbuf = driver_ret32(desc->port,0);
|
|
return 1;
|
|
break;
|
|
|
|
case XX_GETC: {
|
|
int ch;
|
|
if ((ch = getc(desc->fp)) == EOF) {
|
|
if (feof(desc->fp)) {
|
|
*rbuf = driver_eof(desc->port);
|
|
return 1;
|
|
}
|
|
*rbuf = driver_error(desc->port, errno);
|
|
return 1;
|
|
}
|
|
*rbuf = driver_ret32(desc->port, ch);
|
|
return 1;
|
|
break;
|
|
}
|
|
|
|
case XX_SET_LINEBUF_SIZE: {
|
|
int sz = get_int32(buf);
|
|
desc->linebuf_size = sz;
|
|
*rbuf = driver_ok(desc->port);
|
|
return 1;
|
|
break;
|
|
}
|
|
|
|
case XX_GETS:
|
|
case XX_GETS2: {
|
|
int rval;
|
|
long cpos1, cpos2;
|
|
char header;
|
|
|
|
if ((bin = driver_alloc_binary(desc->linebuf_size + 1)) == NULL) {
|
|
*rbuf = driver_error(desc->port, -1);
|
|
return 1;
|
|
}
|
|
|
|
if ((cpos1 = ftell(desc->fp)) == -1) {
|
|
driver_free_binary(bin);
|
|
*rbuf = driver_error(desc->port, errno);
|
|
return 1;
|
|
}
|
|
|
|
if ((fgets(bin->orig_bytes + 1, desc->linebuf_size,
|
|
desc->fp)) == NULL) {
|
|
driver_free_binary(bin);
|
|
if (feof(desc->fp)) {
|
|
*rbuf = driver_eof(desc->port);
|
|
return 1;
|
|
}
|
|
*rbuf = driver_error(desc->port, errno);
|
|
return 1;
|
|
}
|
|
if ((cpos2 = ftell(desc->fp)) == -1) {
|
|
driver_free_binary(bin);
|
|
*rbuf = driver_error(desc->port, errno);
|
|
return 1;
|
|
}
|
|
rval = cpos2 - cpos1;
|
|
|
|
if (bin->orig_bytes[rval] == '\n' &&
|
|
bin->orig_bytes[rval + 1] == 0) {
|
|
header = XX_FLINE;
|
|
/* GETS keep newline, GETS2 remove newline */
|
|
rval = rval - (command == XX_GETS ? 0 : 1);
|
|
}
|
|
else
|
|
header = XX_NOLINE;
|
|
bin->orig_bytes[0] = header;
|
|
bin = driver_realloc_binary(bin, rval + 1);
|
|
*rbuf = (char *)bin;
|
|
return 1;
|
|
}
|
|
|
|
case XX_UNGETC: {
|
|
int ch = buf[0];
|
|
if (ungetc(ch, desc->fp) == EOF)
|
|
*rbuf = driver_error(desc->port, errno);
|
|
else
|
|
*rbuf = driver_ok(desc->port);
|
|
return 1;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
#ifdef DEBUG
|
|
fprintf(stderr, "Unknown opcode %c\n\r", command);
|
|
#endif
|
|
*rbuf = driver_error(desc->port, XX_EINVAL);
|
|
return 1;
|
|
break;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
static void FILE_finish()
|
|
{
|
|
#ifndef USE_STDIO
|
|
/*
|
|
* Make sure any remaining buffers are flushed (this is done on exit() by
|
|
* the normal stdio).
|
|
*/
|
|
bbio_cleanup();
|
|
#endif
|
|
}
|
|
|
|
|
|
/*
|
|
* Initialize and return a driver entry struct
|
|
*/
|
|
|
|
DRIVER_INIT(FILE_drv)
|
|
{
|
|
FILE_driver_entry.init = NULL; /* Not used */
|
|
FILE_driver_entry.start = FILE_start;
|
|
FILE_driver_entry.stop = FILE_stop;
|
|
FILE_driver_entry.output = NULL;
|
|
FILE_driver_entry.ready_input = NULL;
|
|
FILE_driver_entry.ready_output = NULL;
|
|
FILE_driver_entry.driver_name = "FILE_drv";
|
|
FILE_driver_entry.finish = FILE_finish;
|
|
FILE_driver_entry.outputv = NULL;
|
|
FILE_driver_entry.control = FILE_control;
|
|
return &FILE_driver_entry;
|
|
}
|
|
|