587 lines
15 KiB
C
587 lines
15 KiB
C
/*
|
|
--------------------------------------------------------------------------------
|
|
- Module : mem_file.c
|
|
- Description : A general purpose library for manipulating a memory area
|
|
- as if it were a file.
|
|
- mfs_ stands for memory file system.
|
|
- Author : Mike Johnson - Banctec AB 03/07/96
|
|
-
|
|
--------------------------------------------------------------------------------
|
|
*/
|
|
|
|
/*
|
|
|
|
Copyright (c) 1996 Mike Johnson
|
|
Copyright (c) 1996 BancTec AB
|
|
|
|
Permission to use, copy, modify, distribute, and sell this software
|
|
for any purpose is hereby granted without fee, provided
|
|
that (i) the above copyright notices and this permission notice appear in
|
|
all copies of the software and related documentation, and (ii) the names of
|
|
Mike Johnson and BancTec may not be used in any advertising or
|
|
publicity relating to the software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
|
|
EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
|
|
WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
IN NO EVENT SHALL MIKE JOHNSON OR BANCTEC BE LIABLE FOR
|
|
ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
|
|
OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
|
WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
|
|
LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
|
|
OF THIS SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
|
/*
|
|
--------------------------------------------------------------------------------
|
|
- Includes
|
|
--------------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
/*
|
|
--------------------------------------------------------------------------------
|
|
- Definitions
|
|
--------------------------------------------------------------------------------
|
|
*/
|
|
|
|
#define MAX_BUFFS 20
|
|
#define FALSE 0
|
|
#define TRUE 1
|
|
|
|
/*
|
|
--------------------------------------------------------------------------------
|
|
- Globals
|
|
--------------------------------------------------------------------------------
|
|
*/
|
|
|
|
static char *buf[MAX_BUFFS]; /* Memory for each open buf */
|
|
static long buf_off[MAX_BUFFS]; /* File pointer for each buf */
|
|
static long buf_size[MAX_BUFFS]; /* Count of bytes allocated for each buf */
|
|
static long fds[MAX_BUFFS]; /* File descriptor status */
|
|
static int buf_mode[MAX_BUFFS]; /* Mode of buffer (r, w, a) */
|
|
|
|
static int library_init_done = FALSE;
|
|
|
|
|
|
/*
|
|
--------------------------------------------------------------------------------
|
|
- Function prototypes
|
|
--------------------------------------------------------------------------------
|
|
*/
|
|
|
|
int mfs_open (void *ptr, int size, char *mode);
|
|
int mfs_lseek (int fd, int offset, int whence);
|
|
int mfs_read (int fd, void *buf, int size);
|
|
int mfs_write (int fd, void *buf, int size);
|
|
int mfs_size (int fd);
|
|
int mfs_map (int fd, char **addr, size_t *len);
|
|
int mfs_unmap (int fd);
|
|
int mfs_close (int fd);
|
|
static int extend_mem_file (int fd, int size);
|
|
static void mem_init ();
|
|
|
|
/*
|
|
--------------------------------------------------------------------------------
|
|
- Function code
|
|
--------------------------------------------------------------------------------
|
|
*/
|
|
|
|
/*
|
|
--------------------------------------------------------------------------------
|
|
- Function : mfs_open ()
|
|
-
|
|
- Arguments : Pointer to allocated buffer, initial size of buffer,
|
|
- mode spec (r, w, a)
|
|
-
|
|
- Returns : File descriptor or -1 if error.
|
|
-
|
|
- Description : Register this area of memory (which has been allocated
|
|
- and has a file read into it) under the mem_file library.
|
|
- A file descriptor is returned which can the be passed
|
|
- back to TIFFClientOpen and used as if it was a disk
|
|
- based fd.
|
|
- If the call is for mode 'w' then pass (void *)NULL as
|
|
- the buffer and zero size and the library will
|
|
- allocate memory for you.
|
|
- If the mode is append then pass (void *)NULL and size
|
|
- zero or with a valid address.
|
|
-
|
|
--------------------------------------------------------------------------------
|
|
*/
|
|
|
|
int mfs_open (void *buffer, int size, char *mode)
|
|
{
|
|
int ret, i;
|
|
void *tmp;
|
|
|
|
if (library_init_done == FALSE)
|
|
{
|
|
mem_init ();
|
|
library_init_done = TRUE;
|
|
}
|
|
|
|
ret = -1;
|
|
|
|
/* Find a free fd */
|
|
|
|
for (i = 0; i < MAX_BUFFS; i++)
|
|
{
|
|
if (fds[i] == -1)
|
|
{
|
|
ret = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i == MAX_BUFFS) /* No more free descriptors */
|
|
{
|
|
ret = -1;
|
|
errno = EMFILE;
|
|
}
|
|
|
|
if (ret >= 0 && *mode == 'r')
|
|
{
|
|
if (buffer == (void *)NULL)
|
|
{
|
|
ret = -1;
|
|
errno = EINVAL;
|
|
}
|
|
else
|
|
{
|
|
buf[ret] = (char *)buffer;
|
|
buf_size[ret] = size;
|
|
buf_off[ret] = 0;
|
|
}
|
|
}
|
|
else if (ret >= 0 && *mode == 'w')
|
|
{
|
|
|
|
if (buffer != (void *)NULL)
|
|
{
|
|
ret = -1;
|
|
errno = EINVAL;
|
|
}
|
|
|
|
else
|
|
{
|
|
tmp = malloc (0); /* Get a pointer */
|
|
if (tmp == (void *)NULL)
|
|
{
|
|
ret = -1;
|
|
errno = EDQUOT;
|
|
}
|
|
else
|
|
{
|
|
buf[ret] = (char *)tmp;
|
|
buf_size[ret] = 0;
|
|
buf_off[ret] = 0;
|
|
}
|
|
}
|
|
}
|
|
else if (ret >= 0 && *mode == 'a')
|
|
{
|
|
if (buffer == (void *) NULL) /* Create space for client */
|
|
{
|
|
tmp = malloc (0); /* Get a pointer */
|
|
if (tmp == (void *)NULL)
|
|
{
|
|
ret = -1;
|
|
errno = EDQUOT;
|
|
}
|
|
else
|
|
{
|
|
buf[ret] = (char *)tmp;
|
|
buf_size[ret] = 0;
|
|
buf_off[ret] = 0;
|
|
}
|
|
}
|
|
else /* Client has file read in already */
|
|
{
|
|
buf[ret] = (char *)buffer;
|
|
buf_size[ret] = size;
|
|
buf_off[ret] = 0;
|
|
}
|
|
}
|
|
else /* Some other invalid combination of parameters */
|
|
{
|
|
ret = -1;
|
|
errno = EINVAL;
|
|
}
|
|
|
|
if (ret != -1)
|
|
{
|
|
fds[ret] = 0;
|
|
buf_mode[ret] = *mode;
|
|
}
|
|
|
|
return (ret);
|
|
}
|
|
|
|
/*
|
|
--------------------------------------------------------------------------------
|
|
- Function : mfs_lseek ()
|
|
-
|
|
- Arguments : File descriptor, offset, whence
|
|
-
|
|
- Returns : as per man lseek (2)
|
|
-
|
|
- Description : Does the same as lseek (2) except on a memory based file.
|
|
- Note: the memory area will be extended if the caller
|
|
- attempts to seek past the current end of file (memory).
|
|
-
|
|
--------------------------------------------------------------------------------
|
|
*/
|
|
|
|
int mfs_lseek (int fd, int offset, int whence)
|
|
{
|
|
int ret;
|
|
long test_off;
|
|
|
|
if (fds[fd] == -1) /* Not open */
|
|
{
|
|
ret = -1;
|
|
errno = EBADF;
|
|
}
|
|
else if (offset < 0 && whence == SEEK_SET)
|
|
{
|
|
ret = -1;
|
|
errno = EINVAL;
|
|
}
|
|
else
|
|
{
|
|
switch (whence)
|
|
{
|
|
case SEEK_SET:
|
|
if (offset > buf_size[fd])
|
|
extend_mem_file (fd, offset);
|
|
buf_off[fd] = offset;
|
|
ret = offset;
|
|
break;
|
|
|
|
case SEEK_CUR:
|
|
test_off = buf_off[fd] + offset;
|
|
|
|
if (test_off < 0)
|
|
{
|
|
ret = -1;
|
|
errno = EINVAL;
|
|
}
|
|
else
|
|
{
|
|
if (test_off > buf_size[fd])
|
|
extend_mem_file (fd, test_off);
|
|
buf_off[fd] = test_off;
|
|
ret = test_off;
|
|
}
|
|
break;
|
|
|
|
case SEEK_END:
|
|
test_off = buf_size[fd] + offset;
|
|
|
|
if (test_off < 0)
|
|
{
|
|
ret = -1;
|
|
errno = EINVAL;
|
|
}
|
|
else
|
|
{
|
|
if (test_off > buf_size[fd])
|
|
extend_mem_file (fd, test_off);
|
|
buf_off[fd] = test_off;
|
|
ret = test_off;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
errno = EINVAL;
|
|
ret = -1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return (ret);
|
|
}
|
|
|
|
/*
|
|
--------------------------------------------------------------------------------
|
|
- Function : mfs_read ()
|
|
-
|
|
- Arguments : File descriptor, buffer, size
|
|
-
|
|
- Returns : as per man read (2)
|
|
-
|
|
- Description : Does the same as read (2) except on a memory based file.
|
|
- Note: An attempt to read past the end of memory currently
|
|
- allocated to the file will return 0 (End Of File)
|
|
-
|
|
--------------------------------------------------------------------------------
|
|
*/
|
|
|
|
int mfs_read (int fd, void *clnt_buf, int size)
|
|
{
|
|
int ret;
|
|
|
|
if (fds[fd] == -1 || buf_mode[fd] != 'r')
|
|
{
|
|
/* File is either not open, or not opened for read */
|
|
|
|
ret = -1;
|
|
errno = EBADF;
|
|
}
|
|
else if (buf_off[fd] + size > buf_size[fd])
|
|
{
|
|
ret = 0; /* EOF */
|
|
}
|
|
else
|
|
{
|
|
memcpy (clnt_buf, (void *) (buf[fd] + buf_off[fd]), size);
|
|
buf_off[fd] = buf_off[fd] + size;
|
|
ret = size;
|
|
}
|
|
|
|
return (ret);
|
|
}
|
|
|
|
/*
|
|
--------------------------------------------------------------------------------
|
|
- Function : mfs_write ()
|
|
-
|
|
- Arguments : File descriptor, buffer, size
|
|
-
|
|
- Returns : as per man write (2)
|
|
-
|
|
- Description : Does the same as write (2) except on a memory based file.
|
|
- Note: the memory area will be extended if the caller
|
|
- attempts to write past the current end of file (memory).
|
|
-
|
|
--------------------------------------------------------------------------------
|
|
*/
|
|
|
|
int mfs_write (int fd, void *clnt_buf, int size)
|
|
{
|
|
int ret;
|
|
|
|
if (fds[fd] == -1 || buf_mode[fd] == 'r')
|
|
{
|
|
/* Either the file is not open or it is opened for reading only */
|
|
|
|
ret = -1;
|
|
errno = EBADF;
|
|
}
|
|
else if (buf_mode[fd] == 'w')
|
|
{
|
|
/* Write */
|
|
|
|
if (buf_off[fd] + size > buf_size[fd])
|
|
{
|
|
extend_mem_file (fd, buf_off[fd] + size);
|
|
buf_size[fd] = (buf_off[fd] + size);
|
|
}
|
|
|
|
memcpy ((buf[fd] + buf_off[fd]), clnt_buf, size);
|
|
buf_off[fd] = buf_off[fd] + size;
|
|
|
|
ret = size;
|
|
}
|
|
else
|
|
{
|
|
/* Append */
|
|
|
|
if (buf_off[fd] != buf_size[fd])
|
|
buf_off[fd] = buf_size[fd];
|
|
|
|
extend_mem_file (fd, buf_off[fd] + size);
|
|
buf_size[fd] += size;
|
|
|
|
memcpy ((buf[fd] + buf_off[fd]), clnt_buf, size);
|
|
buf_off[fd] = buf_off[fd] + size;
|
|
|
|
ret = size;
|
|
}
|
|
|
|
return (ret);
|
|
}
|
|
|
|
/*
|
|
--------------------------------------------------------------------------------
|
|
- Function : mfs_size ()
|
|
-
|
|
- Arguments : File descriptor
|
|
-
|
|
- Returns : integer file size
|
|
-
|
|
- Description : This function returns the current size of the file in bytes.
|
|
-
|
|
--------------------------------------------------------------------------------
|
|
*/
|
|
|
|
int mfs_size (int fd)
|
|
{
|
|
int ret;
|
|
|
|
if (fds[fd] == -1) /* Not open */
|
|
{
|
|
ret = -1;
|
|
errno = EBADF;
|
|
}
|
|
else
|
|
ret = buf_size[fd];
|
|
|
|
return (ret);
|
|
}
|
|
|
|
/*
|
|
--------------------------------------------------------------------------------
|
|
- Function : mfs_map ()
|
|
-
|
|
- Arguments : File descriptor, ptr to address, ptr to length
|
|
-
|
|
- Returns : Map status (succeeded or otherwise)
|
|
-
|
|
- Description : This function tells the client where the file is mapped
|
|
- in memory and what size the mapped area is. It is provided
|
|
- to satisfy the MapProc function in libtiff. It pretends
|
|
- that the file has been mmap (2)ped.
|
|
-
|
|
--------------------------------------------------------------------------------
|
|
*/
|
|
|
|
int mfs_map (int fd, char **addr, size_t *len)
|
|
{
|
|
int ret;
|
|
|
|
if (fds[fd] == -1) /* Not open */
|
|
{
|
|
ret = -1;
|
|
errno = EBADF;
|
|
}
|
|
else
|
|
{
|
|
*addr = buf[fd];
|
|
*len = buf_size[fd];
|
|
ret = 0;
|
|
}
|
|
|
|
return (ret);
|
|
}
|
|
|
|
/*
|
|
--------------------------------------------------------------------------------
|
|
- Function : mfs_unmap ()
|
|
-
|
|
- Arguments : File descriptor
|
|
-
|
|
- Returns : UnMap status (succeeded or otherwise)
|
|
-
|
|
- Description : This function does nothing as the file is always
|
|
- in memory.
|
|
-
|
|
--------------------------------------------------------------------------------
|
|
*/
|
|
|
|
int mfs_unmap (int fd)
|
|
{
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
--------------------------------------------------------------------------------
|
|
- Function : mfs_close ()
|
|
-
|
|
- Arguments : File descriptor
|
|
-
|
|
- Returns : close status (succeeded or otherwise)
|
|
-
|
|
- Description : Close the open memory file. (Make fd available again.)
|
|
-
|
|
--------------------------------------------------------------------------------
|
|
*/
|
|
|
|
int mfs_close (int fd)
|
|
{
|
|
int ret;
|
|
|
|
if (fds[fd] == -1) /* Not open */
|
|
{
|
|
ret = -1;
|
|
errno = EBADF;
|
|
}
|
|
else
|
|
{
|
|
fds[fd] = -1;
|
|
ret = 0;
|
|
}
|
|
|
|
return (ret);
|
|
}
|
|
|
|
/*
|
|
--------------------------------------------------------------------------------
|
|
- Function : extend_mem_file ()
|
|
-
|
|
- Arguments : File descriptor, length to extend to.
|
|
-
|
|
- Returns : 0 - All OK, -1 - realloc () failed.
|
|
-
|
|
- Description : Increase the amount of memory allocated to a file.
|
|
-
|
|
--------------------------------------------------------------------------------
|
|
*/
|
|
|
|
static int extend_mem_file (int fd, int size)
|
|
{
|
|
void *new_mem;
|
|
int ret;
|
|
|
|
if ((new_mem = realloc (buf[fd], size)) == (void *) NULL)
|
|
ret = -1;
|
|
else
|
|
{
|
|
buf[fd] = (char *) new_mem;
|
|
ret = 0;
|
|
}
|
|
|
|
return (ret);
|
|
}
|
|
|
|
/*
|
|
--------------------------------------------------------------------------------
|
|
- Function : mem_init ()
|
|
-
|
|
- Arguments : None
|
|
-
|
|
- Returns : void
|
|
-
|
|
- Description : Initialise the library.
|
|
-
|
|
--------------------------------------------------------------------------------
|
|
*/
|
|
|
|
static void mem_init ()
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < MAX_BUFFS; i++)
|
|
{
|
|
fds[i] = -1;
|
|
buf[i] = (char *)NULL;
|
|
buf_size[i] = 0;
|
|
buf_off[i] = 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Local Variables:
|
|
* mode: c
|
|
* c-basic-offset: 8
|
|
* fill-column: 78
|
|
* End:
|
|
*/
|