#include "sysdep.h"
#include "bfd.h"
#include "libbfd.h"
#include <limits.h>
#ifndef S_IXUSR
#define S_IXUSR 0100
#endif
#ifndef S_IXGRP
#define S_IXGRP 0010
#endif
#ifndef S_IXOTH
#define S_IXOTH 0001
#endif
file_ptr
real_ftell (FILE *file)
{
#if defined (HAVE_FTELLO64)
return ftello64 (file);
#elif defined (HAVE_FTELLO)
return ftello (file);
#else
return ftell (file);
#endif
}
int
real_fseek (FILE *file, file_ptr offset, int whence)
{
#if defined (HAVE_FSEEKO64)
return fseeko64 (file, offset, whence);
#elif defined (HAVE_FSEEKO)
return fseeko (file, offset, whence);
#else
return fseek (file, offset, whence);
#endif
}
static size_t
real_read (void *where, size_t a, size_t b, FILE *file)
{
if (a == 0 || b == 0)
return 0;
#if defined (__VAX) && defined (VMS)
return read (fileno (file), where, a * b);
#else
return fread (where, a, b, file);
#endif
}
bfd_size_type
bfd_bread (void *ptr, bfd_size_type size, bfd *abfd)
{
while (abfd->my_archive != NULL)
abfd = abfd->my_archive;
if ((abfd->flags & BFD_IN_MEMORY) != 0)
{
struct bfd_in_memory *bim;
bfd_size_type get;
bim = abfd->iostream;
get = size;
if (abfd->where + get > bim->size)
{
if (bim->size < (bfd_size_type) abfd->where)
get = 0;
else
get = bim->size - abfd->where;
bfd_set_error (bfd_error_file_truncated);
}
memcpy (ptr, bim->buffer + abfd->where, (size_t) get);
abfd->where += get;
return get;
}
else if ((abfd->flags & BFD_IO_FUNCS) != 0)
{
struct bfd_io_functions *bif;
bif = (struct bfd_io_functions *) abfd->iostream;
return (*bif->read_func) (bif->iodata, ptr, 1, size, abfd, abfd->where);
}
else
{
int nread;
nread = real_read (ptr, 1, (size_t) (size), bfd_cache_lookup (abfd));
if (nread > 0)
abfd->where += nread;
if (nread < (int) (size))
{
if (ferror (bfd_cache_lookup (abfd)))
bfd_set_error (bfd_error_system_call);
else
bfd_set_error (bfd_error_file_truncated);
}
return nread;
}
}
bfd_size_type
bfd_bwrite (const void *ptr, bfd_size_type size, bfd *abfd)
{
while (abfd->my_archive != NULL)
abfd = abfd->my_archive;
if (abfd->flags & BFD_IN_MEMORY)
{
struct bfd_in_memory *bim = abfd->iostream;
size = (size_t) size;
if (abfd->where + size > bim->size)
{
long newsize, oldsize = (bim->size + 127) & ~127;
bim->size = abfd->where + size;
newsize = (bim->size + 127) & ~127;
if (newsize > oldsize)
{
bim->buffer = bfd_realloc (bim->buffer, newsize);
if (bim->buffer == 0)
{
bim->size = 0;
return 0;
}
}
}
memcpy (bim->buffer + abfd->where, ptr, (size_t) size);
abfd->where += size;
return size;
}
else if ((abfd->flags & BFD_IO_FUNCS) != 0)
{
struct bfd_io_functions *bif;
bif = (struct bfd_io_functions *) abfd->iostream;
return (*bif->write_func) (bif->iodata, ptr, 1, size, abfd, abfd->where);
}
else
{
long nwrote;
nwrote = fwrite (ptr, 1, (size_t) (size),
bfd_cache_lookup (abfd));
if (nwrote > 0)
abfd->where += nwrote;
if ((bfd_size_type) nwrote != size)
{
#ifdef ENOSPC
if (nwrote >= 0)
errno = ENOSPC;
#endif
bfd_set_error (bfd_error_system_call);
}
return nwrote;
}
}
file_ptr
bfd_tell (bfd *abfd)
{
file_ptr ptr = 0;
bfd *cur = abfd;
while (cur->my_archive) {
ptr -= cur->origin;
cur = cur->my_archive;
}
if ((cur->flags & BFD_IN_MEMORY) != 0)
{
ptr += cur->where;
}
else if ((abfd->flags & BFD_IO_FUNCS) != 0)
{
ptr += cur->where;
}
else
{
cur->where = real_ftell (bfd_cache_lookup (cur));
ptr += cur->where;
}
return ptr;
}
int
bfd_flush (bfd *abfd)
{
while (abfd->my_archive)
abfd = abfd->my_archive;
if ((abfd->flags & BFD_IN_MEMORY) != 0)
{
return 0;
}
else if ((abfd->flags & BFD_IO_FUNCS) != 0)
{
struct bfd_io_functions *bif;
bif = (struct bfd_io_functions *) abfd->iostream;
return (*bif->flush_func) (bif->iodata, abfd);
}
else
{
return fflush (bfd_cache_lookup (abfd));
}
}
int
bfd_stat (bfd *abfd, struct stat *statbuf)
{
FILE *f;
int result;
while (abfd->my_archive)
abfd = abfd->my_archive;
if ((abfd->flags & BFD_IN_MEMORY) != 0)
{
struct bfd_in_memory *b = (struct bfd_in_memory *) abfd->iostream;
memset (statbuf, 0, sizeof (struct stat));
statbuf->st_size = b->size;
return 0;
}
else if ((abfd->flags & BFD_IO_FUNCS) != 0)
{
struct bfd_io_functions *bif = (struct bfd_io_functions *) abfd->iostream;
return (*bif->stat_func) (bif->iodata, abfd, statbuf);
}
else
{
f = bfd_cache_lookup (abfd);
if (f == NULL)
{
bfd_set_error (bfd_error_system_call);
return -1;
}
result = fstat (fileno (f), statbuf);
if (result < 0)
bfd_set_error (bfd_error_system_call);
return result;
}
}
int
bfd_seek (bfd *abfd, file_ptr position, int direction)
{
#if 0
int result;
FILE *f;
file_ptr file_position;
#endif
BFD_ASSERT (direction == SEEK_SET || direction == SEEK_CUR);
if (direction == SEEK_CUR && position == 0)
return 0;
while (abfd->my_archive != NULL)
{
if (direction == SEEK_SET)
position += abfd->origin;
abfd = abfd->my_archive;
}
if ((direction == SEEK_SET) && ((ufile_ptr) position == abfd->where))
return 0;
if ((position < 0) && (direction != SEEK_CUR)) {
bfd_set_error (bfd_error_system_call);
return -1;
}
if (((abfd->flags & BFD_IN_MEMORY) != 0)
|| (abfd->flags & BFD_IO_FUNCS) != 0)
{
if (direction == SEEK_SET) {
abfd->where = position;
} else {
abfd->where += position;
}
return 0;
}
else
{
int result;
BFD_ASSERT ((ufile_ptr) ftell (bfd_cache_lookup (abfd)) == abfd->where);
result = real_fseek (bfd_cache_lookup (abfd), position, direction);
if (result != 0)
{
int hold_errno = errno;
bfd_tell (abfd);
if (hold_errno == EINVAL)
bfd_set_error (bfd_error_file_truncated);
else
{
bfd_set_error (bfd_error_system_call);
errno = hold_errno;
}
}
else
{
if (direction == SEEK_SET)
abfd->where = position;
else
abfd->where += position;
}
return result;
}
}
bfd_boolean
_bfd_io_close (bfd *abfd)
{
if (abfd->flags & BFD_IN_MEMORY)
{
int ret = 0;
struct bfd_in_memory *b = (struct bfd_in_memory *) abfd->iostream;
BFD_ASSERT (b != NULL);
#if 0
ret = munmap (b->buffer, b->size);
#endif
abfd->iostream = NULL;
BFD_ASSERT (ret == 0);
return TRUE;
}
else if (abfd->flags & BFD_IO_FUNCS)
{
struct bfd_io_functions *bif;
bif = (struct bfd_io_functions *) abfd->iostream;
return (*bif->close_func) (bif->iodata, abfd);
}
else
{
bfd_boolean ret = TRUE;
ret = bfd_cache_close (abfd);
if (ret
&& abfd->direction == write_direction
&& abfd->flags & EXEC_P)
{
struct stat buf;
if (stat (abfd->filename, &buf) == 0)
{
unsigned int mask = umask (0);
umask (mask);
chmod (abfd->filename,
(0x777
& (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
}
}
return (ret);
}
}
long
bfd_get_mtime (bfd *abfd)
{
while (abfd->my_archive)
abfd = abfd->my_archive;
if (abfd->flags & (BFD_IO_FUNCS | BFD_IN_MEMORY))
{
return 0;
}
else
{
FILE *fp;
struct stat buf;
fp = bfd_cache_lookup_null (abfd);
if (fp == NULL)
return 0;
if (0 != fstat (fileno (fp), &buf))
return 0;
abfd->mtime = buf.st_mtime;
return abfd->mtime;
}
}
long
bfd_get_size (bfd *abfd)
{
while (abfd->my_archive)
abfd = abfd->my_archive;
if (abfd->flags & BFD_IN_MEMORY)
{
return ((struct bfd_in_memory *) abfd->iostream)->size;
}
else if (abfd->flags & BFD_IO_FUNCS)
{
return LONG_MAX;
}
else
{
FILE *fp;
struct stat buf;
fp = bfd_cache_lookup (abfd);
if (0 != fstat (fileno (fp), &buf))
return 0;
return buf.st_size;
}
}