1574 lines
44 KiB
C
1574 lines
44 KiB
C
/**
|
|
* MojoSetup; a portable, flexible installation application.
|
|
*
|
|
* Please see the file LICENSE.txt in the source's root directory.
|
|
*
|
|
* This file written by Ryan C. Gordon.
|
|
*
|
|
Copyright (c) 2006-2010 Ryan C. Gordon and others.
|
|
|
|
This software is provided 'as-is', without any express or implied warranty.
|
|
In no event will the authors be held liable for any damages arising from
|
|
the use of this software.
|
|
|
|
Permission is granted to anyone to use this software for any purpose,
|
|
including commercial applications, and to alter it and redistribute it
|
|
freely, subject to the following restrictions:
|
|
|
|
1. The origin of this software must not be misrepresented; you must not
|
|
claim that you wrote the original software. If you use this software in a
|
|
product, an acknowledgment in the product documentation would be
|
|
appreciated but is not required.
|
|
|
|
2. Altered source versions must be plainly marked as such, and must not be
|
|
misrepresented as being the original software.
|
|
|
|
3. This notice may not be removed or altered from any source distribution.
|
|
|
|
Ryan C. Gordon <icculus@icculus.org>
|
|
*
|
|
*/
|
|
|
|
#include "fileio.h"
|
|
#include "platform.h"
|
|
|
|
typedef MojoArchive* (*MojoArchiveCreateEntryPoint)(MojoInput *io);
|
|
|
|
MojoArchive *MojoArchive_createZIP(MojoInput *io);
|
|
MojoArchive *MojoArchive_createTAR(MojoInput *io);
|
|
MojoArchive *MojoArchive_createUZ2(MojoInput *io);
|
|
MojoArchive *MojoArchive_createPCK(MojoInput *io);
|
|
MojoArchive *MojoArchive_createPKG(MojoInput *io);
|
|
|
|
typedef struct
|
|
{
|
|
const char *ext;
|
|
MojoArchiveCreateEntryPoint create;
|
|
boolean hasMagic; // can determine file type from contents?
|
|
} MojoArchiveType;
|
|
|
|
// !!! FIXME: order by archiver, not extension, since most of this is
|
|
// !!! FIXME: duplicates for .tar
|
|
static const MojoArchiveType archives[] =
|
|
{
|
|
{ "zip", MojoArchive_createZIP, true },
|
|
{ "tar", MojoArchive_createTAR, true },
|
|
{ "tar.gz", MojoArchive_createTAR, true },
|
|
{ "tar.xz", MojoArchive_createTAR, true },
|
|
{ "tar.bz2", MojoArchive_createTAR, true },
|
|
{ "tgz", MojoArchive_createTAR, true },
|
|
{ "tbz2", MojoArchive_createTAR, true },
|
|
{ "tb2", MojoArchive_createTAR, true },
|
|
{ "tbz", MojoArchive_createTAR, true },
|
|
{ "txz", MojoArchive_createTAR, true },
|
|
{ "uz2", MojoArchive_createUZ2, false },
|
|
{ "pck", MojoArchive_createPCK, true },
|
|
{ "pkg", MojoArchive_createPKG, true },
|
|
};
|
|
|
|
|
|
#if SUPPORT_GZIP
|
|
|
|
#include "miniz.h"
|
|
|
|
#define GZIP_READBUFSIZE (128 * 1024)
|
|
|
|
static MojoInput *make_gzip_input(MojoInput *origio);
|
|
|
|
typedef struct GZIPinfo
|
|
{
|
|
MojoInput *origio;
|
|
uint64 uncompressed_position;
|
|
uint8 buffer[GZIP_READBUFSIZE];
|
|
z_stream stream;
|
|
} GZIPinfo;
|
|
|
|
static voidpf mojoZlibAlloc(voidpf opaque, uInt items, uInt size)
|
|
{
|
|
return xmalloc(items * size);
|
|
} // mojoZlibAlloc
|
|
|
|
static void mojoZlibFree(voidpf opaque, voidpf address)
|
|
{
|
|
free(address);
|
|
} // mojoZlibFree
|
|
|
|
static void initializeZStream(z_stream *pstr)
|
|
{
|
|
memset(pstr, '\0', sizeof (z_stream));
|
|
pstr->zalloc = mojoZlibAlloc;
|
|
pstr->zfree = mojoZlibFree;
|
|
} // initializeZStream
|
|
|
|
static boolean MojoInput_gzip_ready(MojoInput *io)
|
|
{
|
|
return true; // !!! FIXME: ready if there are bytes uncompressed.
|
|
} // MojoInput_gzip_ready
|
|
|
|
static boolean MojoInput_gzip_seek(MojoInput *io, uint64 offset)
|
|
{
|
|
// This is all really expensive.
|
|
GZIPinfo *info = (GZIPinfo *) io->opaque;
|
|
|
|
/*
|
|
* If seeking backwards, we need to redecode the file
|
|
* from the start and throw away the compressed bits until we hit
|
|
* the offset we need. If seeking forward, we still need to
|
|
* decode, but we don't rewind first.
|
|
*/
|
|
if (offset < info->uncompressed_position)
|
|
{
|
|
if (!info->origio->seek(info->origio, 0))
|
|
return false;
|
|
inflateEnd(&info->stream);
|
|
initializeZStream(&info->stream);
|
|
if (inflateInit2(&info->stream, 31) != Z_OK)
|
|
return false;
|
|
info->uncompressed_position = 0;
|
|
} // if
|
|
|
|
while (info->uncompressed_position != offset)
|
|
{
|
|
uint8 buf[512];
|
|
uint32 maxread;
|
|
int64 br;
|
|
|
|
maxread = (uint32) (offset - info->uncompressed_position);
|
|
if (maxread > sizeof (buf))
|
|
maxread = sizeof (buf);
|
|
|
|
br = io->read(io, buf, maxread);
|
|
if (br != maxread)
|
|
return false;
|
|
} /* while */
|
|
|
|
return true;
|
|
} // MojoInput_gzip_seek
|
|
|
|
static int64 MojoInput_gzip_tell(MojoInput *io)
|
|
{
|
|
return (((GZIPinfo *) io->opaque)->uncompressed_position);
|
|
} // MojoInput_gzip_tell
|
|
|
|
static int64 MojoInput_gzip_length(MojoInput *io)
|
|
{
|
|
return -1;
|
|
} // MojoInput_gzip_length
|
|
|
|
static int64 MojoInput_gzip_read(MojoInput *io, void *buf, uint32 bufsize)
|
|
{
|
|
GZIPinfo *info = (GZIPinfo *) io->opaque;
|
|
MojoInput *origio = info->origio;
|
|
int64 retval = 0;
|
|
|
|
if (bufsize == 0)
|
|
return 0; // quick rejection.
|
|
|
|
info->stream.next_out = buf;
|
|
info->stream.avail_out = bufsize;
|
|
|
|
while (retval < ((int64) bufsize))
|
|
{
|
|
const uint32 before = info->stream.total_out;
|
|
int rc;
|
|
|
|
if (info->stream.avail_in == 0)
|
|
{
|
|
int64 br = origio->length(origio) - origio->tell(origio);
|
|
if (br > 0)
|
|
{
|
|
if (br > GZIP_READBUFSIZE)
|
|
br = GZIP_READBUFSIZE;
|
|
|
|
br = origio->read(origio, info->buffer, (uint32) br);
|
|
if (br <= 0)
|
|
return -1;
|
|
|
|
info->stream.next_in = info->buffer;
|
|
info->stream.avail_in = (uint32) br;
|
|
} // if
|
|
} // if
|
|
|
|
rc = inflate(&info->stream, Z_SYNC_FLUSH);
|
|
retval += (info->stream.total_out - before);
|
|
|
|
if ((rc == Z_STREAM_END) && (retval == 0))
|
|
return 0;
|
|
else if ((rc != Z_OK) && (rc != Z_STREAM_END))
|
|
return -1;
|
|
} // while
|
|
|
|
assert(retval >= 0);
|
|
info->uncompressed_position += (uint32) retval;
|
|
|
|
return retval;
|
|
} // MojoInput_gzip_read
|
|
|
|
static MojoInput* MojoInput_gzip_duplicate(MojoInput *io)
|
|
{
|
|
GZIPinfo *info = (GZIPinfo *) io->opaque;
|
|
MojoInput *retval = NULL;
|
|
MojoInput *newio = info->origio->duplicate(info->origio);
|
|
if (newio != NULL)
|
|
{
|
|
retval = make_gzip_input(newio);
|
|
if (retval != NULL)
|
|
retval->seek(retval, io->tell(io)); // slow, slow, slow...
|
|
} // if
|
|
return retval;
|
|
} // MojoInput_gzip_duplicate
|
|
|
|
static void MojoInput_gzip_close(MojoInput *io)
|
|
{
|
|
GZIPinfo *info = (GZIPinfo *) io->opaque;
|
|
if (info->origio != NULL)
|
|
info->origio->close(info->origio);
|
|
inflateEnd(&info->stream);
|
|
free(info);
|
|
free(io);
|
|
} // MojoInput_gzip_close
|
|
|
|
static MojoInput *make_gzip_input(MojoInput *origio)
|
|
{
|
|
MojoInput *io = NULL;
|
|
GZIPinfo *info = (GZIPinfo *) xmalloc(sizeof (GZIPinfo));
|
|
|
|
initializeZStream(&info->stream);
|
|
if (inflateInit2(&info->stream, 31) != Z_OK)
|
|
{
|
|
free(info);
|
|
return NULL;
|
|
} // if
|
|
|
|
info->origio = origio;
|
|
|
|
io = (MojoInput *) xmalloc(sizeof (MojoInput));
|
|
io->ready = MojoInput_gzip_ready;
|
|
io->read = MojoInput_gzip_read;
|
|
io->seek = MojoInput_gzip_seek;
|
|
io->tell = MojoInput_gzip_tell;
|
|
io->length = MojoInput_gzip_length;
|
|
io->duplicate = MojoInput_gzip_duplicate;
|
|
io->close = MojoInput_gzip_close;
|
|
io->opaque = info;
|
|
return io;
|
|
} // make_gzip_input
|
|
|
|
#endif // SUPPORT_GZIP
|
|
|
|
|
|
#if SUPPORT_BZIP2
|
|
|
|
#include "bzip2/bzlib.h"
|
|
|
|
#define BZIP2_READBUFSIZE (128 * 1024)
|
|
|
|
static MojoInput *make_bzip2_input(MojoInput *origio);
|
|
|
|
typedef struct BZIP2info
|
|
{
|
|
MojoInput *origio;
|
|
uint64 uncompressed_position;
|
|
uint8 buffer[BZIP2_READBUFSIZE];
|
|
bz_stream stream;
|
|
} BZIP2info;
|
|
|
|
static void *mojoBzlib2Alloc(void *opaque, int items, int size)
|
|
{
|
|
return xmalloc(items * size);
|
|
} // mojoBzlib2Alloc
|
|
|
|
static void mojoBzlib2Free(void *opaque, void *address)
|
|
{
|
|
free(address);
|
|
} // mojoBzlib2Free
|
|
|
|
static void initializeBZ2Stream(bz_stream *pstr)
|
|
{
|
|
memset(pstr, '\0', sizeof (bz_stream));
|
|
pstr->bzalloc = mojoBzlib2Alloc;
|
|
pstr->bzfree = mojoBzlib2Free;
|
|
} // initializeBZ2Stream
|
|
|
|
static boolean MojoInput_bzip2_ready(MojoInput *io)
|
|
{
|
|
return true; // !!! FIXME: ready if there are bytes uncompressed.
|
|
} // MojoInput_bzip2_ready
|
|
|
|
static boolean MojoInput_bzip2_seek(MojoInput *io, uint64 offset)
|
|
{
|
|
// This is all really expensive.
|
|
BZIP2info *info = (BZIP2info *) io->opaque;
|
|
|
|
/*
|
|
* If seeking backwards, we need to redecode the file
|
|
* from the start and throw away the compressed bits until we hit
|
|
* the offset we need. If seeking forward, we still need to
|
|
* decode, but we don't rewind first.
|
|
*/
|
|
if (offset < info->uncompressed_position)
|
|
{
|
|
#if 0
|
|
/* we do a copy so state is sane if inflateInit2() fails. */
|
|
bz_stream str;
|
|
initializeBZ2Stream(&str);
|
|
if (BZ2_bzDecompressInit(&str, 0, 0) != BZ_OK)
|
|
return false;
|
|
|
|
if (!info->origio->seek(info->origio, 0))
|
|
return false; // !!! FIXME: leaking (str)?
|
|
|
|
BZ2_bzDecompressEnd(&info->stream);
|
|
memcpy(&info->stream, &str, sizeof (bz_stream));
|
|
#endif
|
|
|
|
if (!info->origio->seek(info->origio, 0))
|
|
return false;
|
|
BZ2_bzDecompressEnd(&info->stream);
|
|
initializeBZ2Stream(&info->stream);
|
|
if (BZ2_bzDecompressInit(&info->stream, 0, 0) != BZ_OK)
|
|
return false;
|
|
info->uncompressed_position = 0;
|
|
} // if
|
|
|
|
while (info->uncompressed_position != offset)
|
|
{
|
|
uint8 buf[512];
|
|
uint32 maxread;
|
|
int64 br;
|
|
|
|
maxread = (uint32) (offset - info->uncompressed_position);
|
|
if (maxread > sizeof (buf))
|
|
maxread = sizeof (buf);
|
|
|
|
br = io->read(io, buf, maxread);
|
|
if (br != maxread)
|
|
return false;
|
|
} /* while */
|
|
|
|
return true;
|
|
} // MojoInput_bzip2_seek
|
|
|
|
static int64 MojoInput_bzip2_tell(MojoInput *io)
|
|
{
|
|
return (((BZIP2info *) io->opaque)->uncompressed_position);
|
|
} // MojoInput_bzip2_tell
|
|
|
|
static int64 MojoInput_bzip2_length(MojoInput *io)
|
|
{
|
|
return -1;
|
|
} // MojoInput_bzip2_length
|
|
|
|
static int64 MojoInput_bzip2_read(MojoInput *io, void *buf, uint32 bufsize)
|
|
{
|
|
BZIP2info *info = (BZIP2info *) io->opaque;
|
|
MojoInput *origio = info->origio;
|
|
int64 retval = 0;
|
|
|
|
if (bufsize == 0)
|
|
return 0; // quick rejection.
|
|
|
|
info->stream.next_out = buf;
|
|
info->stream.avail_out = bufsize;
|
|
|
|
while (retval < ((int64) bufsize))
|
|
{
|
|
const uint32 before = info->stream.total_out_lo32;
|
|
int rc;
|
|
|
|
if (info->stream.avail_in == 0)
|
|
{
|
|
int64 br = origio->length(origio) - origio->tell(origio);
|
|
if (br > 0)
|
|
{
|
|
if (br > BZIP2_READBUFSIZE)
|
|
br = BZIP2_READBUFSIZE;
|
|
|
|
br = origio->read(origio, info->buffer, (uint32) br);
|
|
if (br <= 0)
|
|
return -1;
|
|
|
|
info->stream.next_in = (char *) info->buffer;
|
|
info->stream.avail_in = (uint32) br;
|
|
} // if
|
|
} // if
|
|
|
|
rc = BZ2_bzDecompress(&info->stream);
|
|
retval += (info->stream.total_out_lo32 - before);
|
|
if (rc != BZ_OK)
|
|
return -1;
|
|
} // while
|
|
|
|
assert(retval >= 0);
|
|
info->uncompressed_position += (uint32) retval;
|
|
|
|
return retval;
|
|
} // MojoInput_bzip2_read
|
|
|
|
static MojoInput* MojoInput_bzip2_duplicate(MojoInput *io)
|
|
{
|
|
BZIP2info *info = (BZIP2info *) io->opaque;
|
|
MojoInput *retval = NULL;
|
|
MojoInput *newio = info->origio->duplicate(info->origio);
|
|
if (newio != NULL)
|
|
{
|
|
retval = make_bzip2_input(newio);
|
|
if (retval != NULL)
|
|
retval->seek(retval, io->tell(io)); // slow, slow, slow...
|
|
} // if
|
|
return retval;
|
|
} // MojoInput_bzip2_duplicate
|
|
|
|
static void MojoInput_bzip2_close(MojoInput *io)
|
|
{
|
|
BZIP2info *info = (BZIP2info *) io->opaque;
|
|
if (info->origio != NULL)
|
|
info->origio->close(info->origio);
|
|
BZ2_bzDecompressEnd(&info->stream);
|
|
free(info);
|
|
free(io);
|
|
} // MojoInput_bzip2_close
|
|
|
|
static MojoInput *make_bzip2_input(MojoInput *origio)
|
|
{
|
|
MojoInput *io = NULL;
|
|
BZIP2info *info = (BZIP2info *) xmalloc(sizeof (BZIP2info));
|
|
|
|
initializeBZ2Stream(&info->stream);
|
|
if (BZ2_bzDecompressInit(&info->stream, 0, 0) != BZ_OK)
|
|
{
|
|
free(info);
|
|
return NULL;
|
|
} // if
|
|
|
|
info->origio = origio;
|
|
|
|
io = (MojoInput *) xmalloc(sizeof (MojoInput));
|
|
io->ready = MojoInput_bzip2_ready;
|
|
io->read = MojoInput_bzip2_read;
|
|
io->seek = MojoInput_bzip2_seek;
|
|
io->tell = MojoInput_bzip2_tell;
|
|
io->length = MojoInput_bzip2_length;
|
|
io->duplicate = MojoInput_bzip2_duplicate;
|
|
io->close = MojoInput_bzip2_close;
|
|
io->opaque = info;
|
|
return io;
|
|
} // make_bzip2_input
|
|
|
|
#endif // SUPPORT_BZIP2
|
|
|
|
|
|
#if SUPPORT_XZ
|
|
|
|
#include "lzma.h"
|
|
|
|
#define XZ_READBUFSIZE (128 * 1024)
|
|
|
|
static MojoInput *make_xz_input(MojoInput *origio);
|
|
|
|
typedef struct XZinfo
|
|
{
|
|
MojoInput *origio;
|
|
uint64 uncompressed_position;
|
|
uint8 buffer[XZ_READBUFSIZE];
|
|
lzma_stream stream;
|
|
} XZinfo;
|
|
|
|
static void *mojoLzmaAlloc(void *opaque, size_t items, size_t size)
|
|
{
|
|
return xmalloc(items * size);
|
|
} // mojoLzmaAlloc
|
|
|
|
static void mojoLzmaFree(void *opaque, void *address)
|
|
{
|
|
free(address);
|
|
} // mojoZlibFree
|
|
|
|
static void initializeXZStream(lzma_stream *pstr)
|
|
{
|
|
static lzma_allocator lzmaAlloc = { mojoLzmaAlloc, mojoLzmaFree };
|
|
memset(pstr, '\0', sizeof (lzma_stream));
|
|
pstr->allocator = &lzmaAlloc;
|
|
} // initializeXZStream
|
|
|
|
static boolean MojoInput_xz_ready(MojoInput *io)
|
|
{
|
|
return true; // !!! FIXME: ready if there are bytes uncompressed.
|
|
} // MojoInput_xz_ready
|
|
|
|
static boolean MojoInput_xz_seek(MojoInput *io, uint64 offset)
|
|
{
|
|
// This is all really expensive.
|
|
XZinfo *info = (XZinfo *) io->opaque;
|
|
|
|
/*
|
|
* If seeking backwards, we need to redecode the file
|
|
* from the start and throw away the compressed bits until we hit
|
|
* the offset we need. If seeking forward, we still need to
|
|
* decode, but we don't rewind first.
|
|
*/
|
|
if (offset < info->uncompressed_position)
|
|
{
|
|
lzma_stream *strm = &info->stream;
|
|
if (!info->origio->seek(info->origio, 0))
|
|
return false;
|
|
lzma_end(strm);
|
|
initializeXZStream(strm);
|
|
if (lzma_stream_decoder(strm, UINT64_MAX, LZMA_CONCATENATED) != LZMA_OK)
|
|
return false;
|
|
info->uncompressed_position = 0;
|
|
} // if
|
|
|
|
while (info->uncompressed_position != offset)
|
|
{
|
|
uint8 buf[512];
|
|
uint32 maxread;
|
|
int64 br;
|
|
|
|
maxread = (uint32) (offset - info->uncompressed_position);
|
|
if (maxread > sizeof (buf))
|
|
maxread = sizeof (buf);
|
|
|
|
br = io->read(io, buf, maxread);
|
|
if (br != maxread)
|
|
return false;
|
|
} /* while */
|
|
|
|
return true;
|
|
} // MojoInput_xz_seek
|
|
|
|
static int64 MojoInput_xz_tell(MojoInput *io)
|
|
{
|
|
return (((XZinfo *) io->opaque)->uncompressed_position);
|
|
} // MojoInput_xz_tell
|
|
|
|
static int64 MojoInput_xz_length(MojoInput *io)
|
|
{
|
|
return -1;
|
|
} // MojoInput_xz_length
|
|
|
|
static int64 MojoInput_xz_read(MojoInput *io, void *buf, uint32 bufsize)
|
|
{
|
|
XZinfo *info = (XZinfo *) io->opaque;
|
|
MojoInput *origio = info->origio;
|
|
int64 retval = 0;
|
|
|
|
if (bufsize == 0)
|
|
return 0; // quick rejection.
|
|
|
|
info->stream.next_out = buf;
|
|
info->stream.avail_out = bufsize;
|
|
|
|
while (retval < ((int64) bufsize))
|
|
{
|
|
const uint32 before = info->stream.total_out;
|
|
lzma_ret rc;
|
|
|
|
if (info->stream.avail_in == 0)
|
|
{
|
|
int64 br = origio->length(origio) - origio->tell(origio);
|
|
if (br > 0)
|
|
{
|
|
if (br > XZ_READBUFSIZE)
|
|
br = XZ_READBUFSIZE;
|
|
|
|
br = origio->read(origio, info->buffer, (uint32) br);
|
|
if (br <= 0)
|
|
return -1;
|
|
|
|
info->stream.next_in = info->buffer;
|
|
info->stream.avail_in = (uint32) br;
|
|
} // if
|
|
} // if
|
|
|
|
rc = lzma_code(&info->stream, LZMA_RUN);
|
|
retval += (info->stream.total_out - before);
|
|
|
|
if (rc != LZMA_OK)
|
|
return -1;
|
|
} // while
|
|
|
|
assert(retval >= 0);
|
|
info->uncompressed_position += (uint32) retval;
|
|
|
|
return retval;
|
|
} // MojoInput_xz_read
|
|
|
|
static MojoInput* MojoInput_xz_duplicate(MojoInput *io)
|
|
{
|
|
XZinfo *info = (XZinfo *) io->opaque;
|
|
MojoInput *retval = NULL;
|
|
MojoInput *newio = info->origio->duplicate(info->origio);
|
|
if (newio != NULL)
|
|
{
|
|
retval = make_xz_input(newio);
|
|
if (retval != NULL)
|
|
retval->seek(retval, io->tell(io)); // slow, slow, slow...
|
|
} // if
|
|
return retval;
|
|
} // MojoInput_xz_duplicate
|
|
|
|
static void MojoInput_xz_close(MojoInput *io)
|
|
{
|
|
XZinfo *info = (XZinfo *) io->opaque;
|
|
if (info->origio != NULL)
|
|
info->origio->close(info->origio);
|
|
lzma_end(&info->stream);
|
|
free(info);
|
|
free(io);
|
|
} // MojoInput_xz_close
|
|
|
|
static MojoInput *make_xz_input(MojoInput *origio)
|
|
{
|
|
MojoInput *io = NULL;
|
|
XZinfo *info = (XZinfo *) xmalloc(sizeof (XZinfo));
|
|
lzma_stream *strm = &info->stream;
|
|
|
|
// UINT64_MAX is the memory usage limit (so basically, no artificial
|
|
// limit here). Internally, this holds its entire dictionary in
|
|
// RAM (8 megabytes by default), plus a few other structures, so we
|
|
// shouldn't eat tons of memory in the normal case. Note that the
|
|
// dictionary can max out at _four gigabytes_, but obviously no one does
|
|
// that.
|
|
initializeXZStream(strm);
|
|
if (lzma_stream_decoder(strm, UINT64_MAX, LZMA_CONCATENATED) != LZMA_OK)
|
|
{
|
|
free(info);
|
|
return NULL;
|
|
} // if
|
|
|
|
info->origio = origio;
|
|
|
|
io = (MojoInput *) xmalloc(sizeof (MojoInput));
|
|
io->ready = MojoInput_xz_ready;
|
|
io->read = MojoInput_xz_read;
|
|
io->seek = MojoInput_xz_seek;
|
|
io->tell = MojoInput_xz_tell;
|
|
io->length = MojoInput_xz_length;
|
|
io->duplicate = MojoInput_xz_duplicate;
|
|
io->close = MojoInput_xz_close;
|
|
io->opaque = info;
|
|
return io;
|
|
} // make_xz_input
|
|
|
|
#endif // SUPPORT_XZ
|
|
|
|
|
|
MojoInput *MojoInput_newCompressedStream(MojoInput *origio)
|
|
{
|
|
#if SUPPORT_GZIP || SUPPORT_BZIP2 || SUPPORT_XZ
|
|
// Look at the first piece of the file to decide if it is compressed
|
|
// by a general compression algorithm, and if so, wrap the MojoInput
|
|
// in a decompressor.
|
|
uint8 magic[6];
|
|
const int64 br = origio->read(origio, magic, sizeof (magic));
|
|
if ((origio->seek(origio, 0)) && (br == sizeof (magic)))
|
|
{
|
|
#if SUPPORT_GZIP
|
|
{
|
|
static const uint8 gzip_sig[] = { 0x1F, 0x8B, 0x08 };
|
|
if (memcmp(magic, gzip_sig, sizeof (gzip_sig)) == 0)
|
|
return make_gzip_input(origio);
|
|
}
|
|
#endif
|
|
|
|
#if SUPPORT_BZIP2
|
|
{
|
|
static const uint8 bzip2_sig[] = { 0x42, 0x5A };
|
|
if (memcmp(magic, bzip2_sig, sizeof (bzip2_sig)) == 0)
|
|
return make_bzip2_input(origio);
|
|
}
|
|
#endif
|
|
|
|
#if SUPPORT_XZ
|
|
{
|
|
static const uint8 xz_sig[] = { 0xFD, '7', 'z', 'X', 'Z', 0x00 };
|
|
if (memcmp(magic, xz_sig, sizeof (xz_sig)) == 0)
|
|
return make_xz_input(origio);
|
|
}
|
|
#endif
|
|
} // if
|
|
#endif
|
|
|
|
return NULL;
|
|
} // MojoInput_newCompressedStream
|
|
|
|
|
|
MojoArchive *MojoArchive_newFromInput(MojoInput *_io, const char *origfname)
|
|
{
|
|
int i;
|
|
MojoArchive *retval = NULL;
|
|
const char *ext = NULL;
|
|
MojoInput *io = MojoInput_newCompressedStream(_io);
|
|
if (io == NULL)
|
|
io = _io;
|
|
|
|
if (origfname != NULL)
|
|
{
|
|
ext = strrchr(origfname, '/');
|
|
if (ext == NULL)
|
|
ext = strchr(origfname, '.');
|
|
else
|
|
ext = strchr(ext+1, '.');
|
|
} // if
|
|
|
|
while (ext != NULL)
|
|
{
|
|
// Try for an exact match by filename extension.
|
|
ext++; // skip that '.'
|
|
for (i = 0; i < STATICARRAYLEN(archives); i++)
|
|
{
|
|
const MojoArchiveType *arc = &archives[i];
|
|
if (strcasecmp(ext, arc->ext) == 0)
|
|
return arc->create(io);
|
|
} // for
|
|
ext = strchr(ext, '.');
|
|
} // while
|
|
|
|
// Try any that could be determined without the file extension...
|
|
for (i = 0; i < STATICARRAYLEN(archives); i++)
|
|
{
|
|
const MojoArchiveType *arc = &archives[i];
|
|
if ((arc->hasMagic) && ((retval = arc->create(io)) != NULL))
|
|
return retval;
|
|
} // for
|
|
|
|
io->close(io);
|
|
return NULL; // nothing can handle this data.
|
|
} // MojoArchive_newFromInput
|
|
|
|
|
|
void MojoArchive_resetEntry(MojoArchiveEntry *info)
|
|
{
|
|
free(info->filename);
|
|
free(info->linkdest);
|
|
memset(info, '\0', sizeof (MojoArchiveEntry));
|
|
} // MojoArchive_resetEntry
|
|
|
|
|
|
// !!! FIXME: I'd rather not use a callback here, but I can't see a cleaner
|
|
// !!! FIXME: way right now...
|
|
boolean MojoInput_toPhysicalFile(MojoInput *in, const char *fname, uint16 perms,
|
|
MojoChecksums *checksums, int64 maxbytes,
|
|
MojoInput_FileCopyCallback cb, void *data)
|
|
{
|
|
boolean retval = false;
|
|
uint32 start = MojoPlatform_ticks();
|
|
void *out = NULL;
|
|
boolean iofailure = false;
|
|
int64 flen = 0;
|
|
int64 bw = 0;
|
|
MojoChecksumContext sumctx;
|
|
|
|
if (in == NULL)
|
|
return false;
|
|
|
|
if (checksums != NULL)
|
|
{
|
|
memset(checksums, '\0', sizeof (MojoChecksums));
|
|
MojoChecksum_init(&sumctx);
|
|
} // if
|
|
|
|
// Wait for a ready(), so length() can be meaningful on network streams.
|
|
while ((!in->ready(in)) && (!iofailure))
|
|
{
|
|
MojoPlatform_sleep(100);
|
|
if (cb != NULL)
|
|
{
|
|
if (!cb(MojoPlatform_ticks() - start, 0, 0, -1, data))
|
|
iofailure = true;
|
|
} // if
|
|
} // while
|
|
|
|
flen = in->length(in);
|
|
if ((maxbytes >= 0) && (flen > maxbytes))
|
|
flen = maxbytes;
|
|
|
|
MojoPlatform_unlink(fname);
|
|
if (!iofailure)
|
|
{
|
|
const uint32 flags = MOJOFILE_WRITE|MOJOFILE_CREATE|MOJOFILE_TRUNCATE;
|
|
const uint16 mode = MojoPlatform_defaultFilePerms();
|
|
out = MojoPlatform_open(fname, flags, mode);
|
|
} // if
|
|
|
|
if (out != NULL)
|
|
{
|
|
while (!iofailure)
|
|
{
|
|
int64 br = 0;
|
|
int64 maxread = sizeof (scratchbuf_128k);
|
|
|
|
// see if we need to clamp to eof or maxbytes...
|
|
if (flen >= 0)
|
|
{
|
|
const int64 avail = flen - bw;
|
|
if (avail < maxread)
|
|
{
|
|
maxread = avail;
|
|
if (maxread == 0)
|
|
break; // nothing left to do, break out.
|
|
} // if
|
|
} // if
|
|
|
|
// If there's a callback, then poll. Otherwise, just block on
|
|
// the reads from the MojoInput.
|
|
if ((cb != NULL) && (!in->ready(in)))
|
|
MojoPlatform_sleep(100);
|
|
else
|
|
{
|
|
br = in->read(in, scratchbuf_128k, (uint32) maxread);
|
|
if (br == 0) // we're done!
|
|
break;
|
|
else if (br < 0)
|
|
iofailure = true;
|
|
else
|
|
{
|
|
if (MojoPlatform_write(out, scratchbuf_128k, (uint32) br) != br)
|
|
iofailure = true;
|
|
else
|
|
{
|
|
if (checksums != NULL)
|
|
MojoChecksum_append(&sumctx, scratchbuf_128k, (uint32) br);
|
|
bw += br;
|
|
} // else
|
|
} // else
|
|
} // else
|
|
|
|
if (cb != NULL)
|
|
{
|
|
if (!cb(MojoPlatform_ticks() - start, br, bw, flen, data))
|
|
iofailure = true;
|
|
} // if
|
|
} // while
|
|
|
|
if (MojoPlatform_close(out) != 0)
|
|
iofailure = true;
|
|
else if (bw != flen)
|
|
iofailure = true;
|
|
|
|
if (iofailure)
|
|
MojoPlatform_unlink(fname);
|
|
else
|
|
{
|
|
MojoPlatform_chmod(fname, perms);
|
|
if (checksums != NULL)
|
|
MojoChecksum_finish(&sumctx, checksums);
|
|
retval = true;
|
|
} // else
|
|
} // if
|
|
|
|
in->close(in);
|
|
return retval;
|
|
} // MojoInput_toPhysicalFile
|
|
|
|
|
|
MojoInput *MojoInput_newFromArchivePath(MojoArchive *ar, const char *fname)
|
|
{
|
|
MojoInput *retval = NULL;
|
|
if (ar->enumerate(ar))
|
|
{
|
|
const MojoArchiveEntry *entinfo;
|
|
while ((entinfo = ar->enumNext(ar)) != NULL)
|
|
{
|
|
if (strcmp(entinfo->filename, fname) == 0)
|
|
{
|
|
if (entinfo->type == MOJOARCHIVE_ENTRY_FILE)
|
|
retval = ar->openCurrentEntry(ar);
|
|
break;
|
|
} // if
|
|
} // while
|
|
} // if
|
|
|
|
return retval;
|
|
} // MojoInput_newFromArchivePath
|
|
|
|
|
|
|
|
// MojoInputs from files on the OS filesystem.
|
|
|
|
typedef struct
|
|
{
|
|
void *handle;
|
|
char *path;
|
|
} MojoInputFileInstance;
|
|
|
|
static boolean MojoInput_file_ready(MojoInput *io)
|
|
{
|
|
// !!! FIXME: select()? Does that help with network filesystems?
|
|
return true;
|
|
} // MojoInput_file_ready
|
|
|
|
static int64 MojoInput_file_read(MojoInput *io, void *buf, uint32 bufsize)
|
|
{
|
|
MojoInputFileInstance *inst = (MojoInputFileInstance *) io->opaque;
|
|
return MojoPlatform_read(inst->handle, buf, bufsize);
|
|
} // MojoInput_file_read
|
|
|
|
static boolean MojoInput_file_seek(MojoInput *io, uint64 pos)
|
|
{
|
|
MojoInputFileInstance *inst = (MojoInputFileInstance *) io->opaque;
|
|
return (MojoPlatform_seek(inst->handle, pos, MOJOSEEK_SET) == pos);
|
|
} // MojoInput_file_seek
|
|
|
|
static int64 MojoInput_file_tell(MojoInput *io)
|
|
{
|
|
MojoInputFileInstance *inst = (MojoInputFileInstance *) io->opaque;
|
|
return MojoPlatform_tell(inst->handle);
|
|
} // MojoInput_file_tell
|
|
|
|
static int64 MojoInput_file_length(MojoInput *io)
|
|
{
|
|
MojoInputFileInstance *inst = (MojoInputFileInstance *) io->opaque;
|
|
return MojoPlatform_flen(inst->handle);
|
|
} // MojoInput_file_length
|
|
|
|
static MojoInput *MojoInput_file_duplicate(MojoInput *io)
|
|
{
|
|
MojoInputFileInstance *inst = (MojoInputFileInstance *) io->opaque;
|
|
return MojoInput_newFromFile(inst->path);
|
|
} // MojoInput_file_duplicate
|
|
|
|
static void MojoInput_file_close(MojoInput *io)
|
|
{
|
|
MojoInputFileInstance *inst = (MojoInputFileInstance *) io->opaque;
|
|
MojoPlatform_close(inst->handle);
|
|
free(inst->path);
|
|
free(inst);
|
|
free(io);
|
|
} // MojoInput_file_close
|
|
|
|
MojoInput *MojoInput_newFromFile(const char *path)
|
|
{
|
|
MojoInput *io = NULL;
|
|
void *f = NULL;
|
|
|
|
f = MojoPlatform_open(path, MOJOFILE_READ, 0);
|
|
if (f != NULL)
|
|
{
|
|
MojoInputFileInstance *inst;
|
|
inst = (MojoInputFileInstance *) xmalloc(sizeof (MojoInputFileInstance));
|
|
inst->path = xstrdup(path);
|
|
inst->handle = f;
|
|
|
|
io = (MojoInput *) xmalloc(sizeof (MojoInput));
|
|
io->ready = MojoInput_file_ready;
|
|
io->read = MojoInput_file_read;
|
|
io->seek = MojoInput_file_seek;
|
|
io->tell = MojoInput_file_tell;
|
|
io->length = MojoInput_file_length;
|
|
io->duplicate = MojoInput_file_duplicate;
|
|
io->close = MojoInput_file_close;
|
|
io->opaque = inst;
|
|
} // if
|
|
|
|
return io;
|
|
} // MojoInput_newFromFile
|
|
|
|
|
|
|
|
// MojoInputs from blocks of memory.
|
|
|
|
typedef struct
|
|
{
|
|
void *ptr; // original pointer from xmalloc()
|
|
uint32 *refcount; // address in xmalloc()'d block for reference count.
|
|
const uint8 *data; // base of actual "file" data in xmalloc()'d block.
|
|
uint32 len; // size, in bytes, of "file" data.
|
|
uint32 pos; // current read position.
|
|
} MojoInputMemInstance;
|
|
|
|
static boolean MojoInput_memory_ready(MojoInput *io)
|
|
{
|
|
return true; // always ready!
|
|
} // MojoInput_memory_ready
|
|
|
|
static int64 MojoInput_memory_read(MojoInput *io, void *buf, uint32 bufsize)
|
|
{
|
|
MojoInputMemInstance *inst = (MojoInputMemInstance *) io->opaque;
|
|
const uint32 avail = inst->len - inst->pos;
|
|
if (bufsize > avail)
|
|
bufsize = avail;
|
|
memcpy(buf, inst->data + inst->pos, bufsize);
|
|
inst->pos += bufsize;
|
|
return bufsize;
|
|
} // MojoInput_memory_read
|
|
|
|
static boolean MojoInput_memory_seek(MojoInput *io, uint64 pos)
|
|
{
|
|
MojoInputMemInstance *inst = (MojoInputMemInstance *) io->opaque;
|
|
if (pos > (uint64) inst->len)
|
|
return false;
|
|
inst->pos = (uint32) pos;
|
|
return true;
|
|
} // MojoInput_memory_seek
|
|
|
|
static int64 MojoInput_memory_tell(MojoInput *io)
|
|
{
|
|
MojoInputMemInstance *inst = (MojoInputMemInstance *) io->opaque;
|
|
return (int64) inst->pos;
|
|
} // MojoInput_memory_tell
|
|
|
|
static int64 MojoInput_memory_length(MojoInput *io)
|
|
{
|
|
MojoInputMemInstance *inst = (MojoInputMemInstance *) io->opaque;
|
|
return (int64) inst->len;
|
|
} // MojoInput_memory_length
|
|
|
|
static MojoInput *MojoInput_memory_duplicate(MojoInput *io)
|
|
{
|
|
MojoInputMemInstance *srcinst = (MojoInputMemInstance *) io->opaque;
|
|
MojoInput *retval = NULL;
|
|
MojoInputMemInstance *inst = NULL;
|
|
|
|
if (srcinst->refcount != NULL)
|
|
{
|
|
// we don't copy the data for each duplicate; we just bump a reference
|
|
// counter. We free the data when all referencers are closed.
|
|
(*srcinst->refcount)++; // !!! FIXME: not thread safe!
|
|
} // if
|
|
|
|
inst = (MojoInputMemInstance*) xmalloc(sizeof (MojoInputMemInstance));
|
|
memcpy(inst, srcinst, sizeof (MojoInputMemInstance));
|
|
inst->pos = 0;
|
|
|
|
retval = (MojoInput *) xmalloc(sizeof (MojoInput));
|
|
memcpy(retval, io, sizeof (MojoInput));
|
|
retval->opaque = inst;
|
|
|
|
return retval;
|
|
} // MojoInput_memory_duplicate
|
|
|
|
static void MojoInput_memory_close(MojoInput *io)
|
|
{
|
|
MojoInputMemInstance *inst = (MojoInputMemInstance *) io->opaque;
|
|
|
|
if (inst->refcount != NULL) // memory we have to free?
|
|
{
|
|
assert(*inst->refcount > 0);
|
|
if (--(*inst->refcount) == 0) // !!! FIXME: not thread safe!
|
|
free(inst->ptr);
|
|
} // if
|
|
|
|
free(inst);
|
|
free(io);
|
|
} // MojoInput_memory_close
|
|
|
|
MojoInput *MojoInput_newFromMemory(const uint8 *ptr, uint32 len, int constant)
|
|
{
|
|
MojoInput *io = (MojoInput *) xmalloc(sizeof (MojoInput));
|
|
MojoInputMemInstance *inst = (MojoInputMemInstance*)
|
|
xmalloc(sizeof (MojoInputMemInstance));
|
|
|
|
if (constant)
|
|
inst->data = ptr;
|
|
else
|
|
{
|
|
inst->ptr = xmalloc(len + sizeof (uint32));
|
|
inst->refcount = (uint32 *) inst->ptr;
|
|
inst->data = ((const uint8 *) inst->ptr) + sizeof (uint32);
|
|
*inst->refcount = 1;
|
|
memcpy((void *) inst->data, ptr, len);
|
|
} // else
|
|
|
|
inst->len = len;
|
|
|
|
io->ready = MojoInput_memory_ready;
|
|
io->read = MojoInput_memory_read;
|
|
io->seek = MojoInput_memory_seek;
|
|
io->tell = MojoInput_memory_tell;
|
|
io->length = MojoInput_memory_length;
|
|
io->duplicate = MojoInput_memory_duplicate;
|
|
io->close = MojoInput_memory_close;
|
|
io->opaque = inst;
|
|
|
|
return io;
|
|
} // MojoInput_newFromMemory
|
|
|
|
|
|
// Put a limit on the range of an existing MojoInput.
|
|
|
|
typedef struct
|
|
{
|
|
MojoInput *io; // original io we're a subset of.
|
|
uint64 pos;
|
|
uint64 start;
|
|
uint64 end;
|
|
} MojoInputSubsetInstance;
|
|
|
|
static boolean MojoInput_subset_ready(MojoInput *io)
|
|
{
|
|
MojoInputSubsetInstance *inst = (MojoInputSubsetInstance *) io->opaque;
|
|
return inst->io->ready(inst->io);
|
|
} // MojoInput_subset_ready
|
|
|
|
static int64 MojoInput_subset_read(MojoInput *io, void *buf, uint32 bufsize)
|
|
{
|
|
MojoInputSubsetInstance *inst = (MojoInputSubsetInstance *) io->opaque;
|
|
const uint32 avail = inst->end - inst->pos;
|
|
int64 rc;
|
|
|
|
assert(inst->pos < inst->end);
|
|
if (bufsize > avail)
|
|
bufsize = avail;
|
|
rc = inst->io->read(inst->io, buf, bufsize);
|
|
if (rc > 0)
|
|
inst->pos += rc;
|
|
return rc;
|
|
} // MojoInput_subset_read
|
|
|
|
static boolean MojoInput_subset_seek(MojoInput *io, uint64 pos)
|
|
{
|
|
MojoInputSubsetInstance *inst = (MojoInputSubsetInstance *) io->opaque;
|
|
if (pos > (inst->end - inst->start))
|
|
return false;
|
|
else if (!inst->io->seek(inst->io, pos + inst->start))
|
|
return false;
|
|
inst->pos = pos;
|
|
return true;
|
|
} // MojoInput_subset_seek
|
|
|
|
static int64 MojoInput_subset_tell(MojoInput *io)
|
|
{
|
|
MojoInputSubsetInstance *inst = (MojoInputSubsetInstance *) io->opaque;
|
|
return (int64) inst->pos;
|
|
} // MojoInput_subset_tell
|
|
|
|
static int64 MojoInput_subset_length(MojoInput *io)
|
|
{
|
|
MojoInputSubsetInstance *inst = (MojoInputSubsetInstance *) io->opaque;
|
|
return (int64) (inst->end - inst->start);
|
|
} // MojoInput_subset_length
|
|
|
|
static MojoInput *MojoInput_subset_duplicate(MojoInput *io)
|
|
{
|
|
MojoInputSubsetInstance *srcinst = (MojoInputSubsetInstance *) io->opaque;
|
|
MojoInput *dupio = io->duplicate(io);
|
|
MojoInput *retval = NULL;
|
|
MojoInputSubsetInstance *inst = NULL;
|
|
|
|
if (dupio == NULL)
|
|
return NULL;
|
|
|
|
if (!dupio->seek(dupio, 0))
|
|
{
|
|
dupio->close(dupio);
|
|
return NULL;
|
|
} // if
|
|
|
|
inst = (MojoInputSubsetInstance*) xmalloc(sizeof (MojoInputSubsetInstance));
|
|
memcpy(inst, srcinst, sizeof (MojoInputSubsetInstance));
|
|
inst->io = dupio;
|
|
inst->pos = 0;
|
|
|
|
retval = (MojoInput *) xmalloc(sizeof (MojoInput));
|
|
memcpy(retval, io, sizeof (MojoInput));
|
|
retval->opaque = inst;
|
|
|
|
return retval;
|
|
} // MojoInput_subset_duplicate
|
|
|
|
static void MojoInput_subset_close(MojoInput *io)
|
|
{
|
|
MojoInputSubsetInstance *inst = (MojoInputSubsetInstance *) io->opaque;
|
|
inst->io->close(inst->io);
|
|
free(inst);
|
|
free(io);
|
|
} // MojoInput_subset_close
|
|
|
|
MojoInput *MojoInput_newFromSubset(MojoInput *_io, const uint64 start,
|
|
const uint64 end)
|
|
{
|
|
MojoInput *io;
|
|
MojoInputSubsetInstance *inst;
|
|
|
|
assert(end > start);
|
|
if (!_io->seek(_io, start))
|
|
return NULL;
|
|
|
|
io = (MojoInput *) xmalloc(sizeof (MojoInput));
|
|
inst = (MojoInputSubsetInstance*)xmalloc(sizeof (MojoInputSubsetInstance));
|
|
|
|
inst->io = _io;
|
|
inst->pos = 0;
|
|
inst->start = start;
|
|
inst->end = end;
|
|
|
|
io->ready = MojoInput_subset_ready;
|
|
io->read = MojoInput_subset_read;
|
|
io->seek = MojoInput_subset_seek;
|
|
io->tell = MojoInput_subset_tell;
|
|
io->length = MojoInput_subset_length;
|
|
io->duplicate = MojoInput_subset_duplicate;
|
|
io->close = MojoInput_subset_close;
|
|
io->opaque = inst;
|
|
|
|
return io;
|
|
} // MojoInput_newFromSubset
|
|
|
|
|
|
// MojoArchives from directories on the OS filesystem.
|
|
|
|
typedef struct DirStack
|
|
{
|
|
void *dir;
|
|
char *basepath;
|
|
struct DirStack *next;
|
|
} DirStack;
|
|
|
|
static void pushDirStack(DirStack **_stack, const char *basepath, void *dir)
|
|
{
|
|
DirStack *stack = (DirStack *) xmalloc(sizeof (DirStack));
|
|
stack->dir = dir;
|
|
stack->basepath = xstrdup(basepath);
|
|
stack->next = *_stack;
|
|
*_stack = stack;
|
|
} // pushDirStack
|
|
|
|
static void popDirStack(DirStack **_stack)
|
|
{
|
|
DirStack *stack = *_stack;
|
|
if (stack != NULL)
|
|
{
|
|
DirStack *next = stack->next;
|
|
if (stack->dir)
|
|
MojoPlatform_closedir(stack->dir);
|
|
free(stack->basepath);
|
|
free(stack);
|
|
*_stack = next;
|
|
} // if
|
|
} // popDirStack
|
|
|
|
static void freeDirStack(DirStack **_stack)
|
|
{
|
|
while (*_stack)
|
|
popDirStack(_stack);
|
|
} // freeDirStack
|
|
|
|
|
|
typedef struct
|
|
{
|
|
DirStack *dirs;
|
|
char *base;
|
|
} MojoArchiveDirInstance;
|
|
|
|
static boolean MojoArchive_dir_enumerate(MojoArchive *ar)
|
|
{
|
|
MojoArchiveDirInstance *inst = (MojoArchiveDirInstance *) ar->opaque;
|
|
void *dir = NULL;
|
|
|
|
freeDirStack(&inst->dirs);
|
|
MojoArchive_resetEntry(&ar->prevEnum);
|
|
|
|
dir = MojoPlatform_opendir(inst->base);
|
|
if (dir != NULL)
|
|
pushDirStack(&inst->dirs, inst->base, dir);
|
|
|
|
return (dir != NULL);
|
|
} // MojoArchive_dir_enumerate
|
|
|
|
|
|
static const MojoArchiveEntry *MojoArchive_dir_enumNext(MojoArchive *ar)
|
|
{
|
|
uint16 perms = 0644; //(S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
|
|
char *fullpath = NULL;
|
|
char *dent = NULL; // "dent" == "directory entry"
|
|
MojoArchiveDirInstance *inst = (MojoArchiveDirInstance *) ar->opaque;
|
|
const char *basepath;
|
|
|
|
MojoArchive_resetEntry(&ar->prevEnum);
|
|
|
|
if (inst->dirs == NULL)
|
|
return NULL;
|
|
|
|
basepath = inst->dirs->basepath;
|
|
|
|
// if readdir fails, it's end of dir (!!! FIXME: what about i/o failures?)
|
|
dent = MojoPlatform_readdir(inst->dirs->dir);
|
|
if (dent == NULL) // end of dir?
|
|
{
|
|
popDirStack(&inst->dirs);
|
|
return MojoArchive_dir_enumNext(ar); // try higher level in tree.
|
|
} // if
|
|
|
|
// MojoPlatform layer shouldn't return "." or ".." paths.
|
|
assert((strcmp(dent, ".") != 0) && (strcmp(dent, "..") != 0));
|
|
|
|
fullpath = (char *) xmalloc(strlen(basepath) + strlen(dent) + 2);
|
|
sprintf(fullpath, "%s/%s", basepath, dent);
|
|
free(dent);
|
|
|
|
ar->prevEnum.filename = xstrdup(fullpath + strlen(inst->base) + 1);
|
|
ar->prevEnum.filesize = 0;
|
|
ar->prevEnum.type = MOJOARCHIVE_ENTRY_UNKNOWN;
|
|
|
|
// We currently force the perms from physical files, since CDs on
|
|
// Linux tend to mark every files as executable and read-only. If you
|
|
// want to install something with specific permissions, wrap it in a
|
|
// tarball, or use Setup.File.permissions, or return a permissions
|
|
// string from Setup.File.filter.
|
|
//MojoPlatform_perms(fullpath, &perms);
|
|
ar->prevEnum.perms = perms;
|
|
|
|
if (MojoPlatform_isfile(fullpath))
|
|
{
|
|
ar->prevEnum.type = MOJOARCHIVE_ENTRY_FILE;
|
|
ar->prevEnum.filesize = MojoPlatform_filesize(fullpath);
|
|
} // if
|
|
|
|
else if (MojoPlatform_issymlink(fullpath))
|
|
{
|
|
ar->prevEnum.type = MOJOARCHIVE_ENTRY_SYMLINK;
|
|
ar->prevEnum.linkdest = MojoPlatform_readlink(fullpath);
|
|
if (ar->prevEnum.linkdest == NULL)
|
|
{
|
|
free(fullpath);
|
|
return MojoArchive_dir_enumNext(ar);
|
|
} // if
|
|
} // else if
|
|
|
|
else if (MojoPlatform_isdir(fullpath))
|
|
{
|
|
void *dir = MojoPlatform_opendir(fullpath);
|
|
ar->prevEnum.type = MOJOARCHIVE_ENTRY_DIR;
|
|
if (dir == NULL)
|
|
{
|
|
free(fullpath);
|
|
return MojoArchive_dir_enumNext(ar);
|
|
} // if
|
|
|
|
// push this dir on the stack. Next enum will start there.
|
|
pushDirStack(&inst->dirs, fullpath, dir);
|
|
} // else if
|
|
|
|
else
|
|
{
|
|
assert(false && "possible file i/o error?");
|
|
} // else
|
|
|
|
free(fullpath);
|
|
return &ar->prevEnum;
|
|
} // MojoArchive_dir_enumNext
|
|
|
|
|
|
static MojoInput *MojoArchive_dir_openCurrentEntry(MojoArchive *ar)
|
|
{
|
|
MojoInput *retval = NULL;
|
|
MojoArchiveDirInstance *inst = (MojoArchiveDirInstance *) ar->opaque;
|
|
|
|
if ((inst->dirs != NULL) && (ar->prevEnum.type == MOJOARCHIVE_ENTRY_FILE))
|
|
{
|
|
char *fullpath = (char *) xmalloc(strlen(inst->base) +
|
|
strlen(ar->prevEnum.filename) + 2);
|
|
sprintf(fullpath, "%s/%s", inst->base, ar->prevEnum.filename);
|
|
retval = MojoInput_newFromFile(fullpath);
|
|
free(fullpath);
|
|
} // if
|
|
|
|
return retval;
|
|
} // MojoArchive_dir_openCurrentEntry
|
|
|
|
|
|
static void MojoArchive_dir_close(MojoArchive *ar)
|
|
{
|
|
MojoArchiveDirInstance *inst = (MojoArchiveDirInstance *) ar->opaque;
|
|
freeDirStack(&inst->dirs);
|
|
free(inst->base);
|
|
free(inst);
|
|
MojoArchive_resetEntry(&ar->prevEnum);
|
|
free(ar);
|
|
} // MojoArchive_dir_close
|
|
|
|
|
|
MojoArchive *MojoArchive_newFromDirectory(const char *dirname)
|
|
{
|
|
MojoArchive *ar = NULL;
|
|
MojoArchiveDirInstance *inst;
|
|
char *real = MojoPlatform_realpath(dirname);
|
|
|
|
if (real == NULL)
|
|
return NULL;
|
|
|
|
if (!MojoPlatform_exists(real, NULL))
|
|
return NULL;
|
|
|
|
if (!MojoPlatform_isdir(real))
|
|
return NULL;
|
|
|
|
inst = (MojoArchiveDirInstance *) xmalloc(sizeof (MojoArchiveDirInstance));
|
|
inst->base = real;
|
|
ar = (MojoArchive *) xmalloc(sizeof (MojoArchive));
|
|
ar->enumerate = MojoArchive_dir_enumerate;
|
|
ar->enumNext = MojoArchive_dir_enumNext;
|
|
ar->openCurrentEntry = MojoArchive_dir_openCurrentEntry;
|
|
ar->close = MojoArchive_dir_close;
|
|
ar->offsetOfStart = -1; // doesn't mean anything here.
|
|
ar->opaque = inst;
|
|
return ar;
|
|
} // MojoArchive_newFromDirectory
|
|
|
|
|
|
boolean MojoInput_readui16(MojoInput *io, uint16 *ui16)
|
|
{
|
|
uint8 buf[sizeof (uint16)];
|
|
if (io->read(io, buf, sizeof (buf)) != sizeof (buf))
|
|
return false;
|
|
|
|
*ui16 = ( (((uint16) buf[0]) << 0) |
|
|
(((uint16) buf[1]) << 8) );
|
|
return true;
|
|
} // MojoInput_readui16
|
|
|
|
|
|
boolean MojoInput_readui32(MojoInput *io, uint32 *ui32)
|
|
{
|
|
uint8 buf[sizeof (uint32)];
|
|
if (io->read(io, buf, sizeof (buf)) != sizeof (buf))
|
|
return false;
|
|
|
|
*ui32 = ( (((uint32) buf[0]) << 0) |
|
|
(((uint32) buf[1]) << 8) |
|
|
(((uint32) buf[2]) << 16) |
|
|
(((uint32) buf[3]) << 24) );
|
|
|
|
return true;
|
|
} // MojoInput_readui32
|
|
|
|
boolean MojoInput_readui64(MojoInput *io, uint64 *ui64)
|
|
{
|
|
uint8 buf[sizeof (uint64)];
|
|
if (io->read(io, buf, sizeof (buf)) != sizeof (buf))
|
|
return false;
|
|
|
|
*ui64 = ( (((uint64) buf[0]) << 0) |
|
|
(((uint64) buf[1]) << 8) |
|
|
(((uint64) buf[2]) << 16) |
|
|
(((uint64) buf[3]) << 24) |
|
|
(((uint64) buf[4]) << 32) |
|
|
(((uint64) buf[5]) << 40) |
|
|
(((uint64) buf[6]) << 48) |
|
|
(((uint64) buf[7]) << 56) );
|
|
|
|
return true;
|
|
} // MojoInput_readui64
|
|
|
|
|
|
MojoArchive *GBaseArchive = NULL;
|
|
const char *GBaseArchivePath = NULL;
|
|
|
|
MojoArchive *MojoArchive_initBaseArchive(void)
|
|
{
|
|
char *basepath = NULL;
|
|
const char *cmd = NULL;
|
|
MojoInput *io = NULL;
|
|
|
|
if (GBaseArchive != NULL)
|
|
return GBaseArchive; // already initialized.
|
|
|
|
if ((cmd = cmdlinestr("base", "MOJOSETUP_BASE", NULL)) != NULL)
|
|
{
|
|
char *real = MojoPlatform_realpath(cmd);
|
|
if (real != NULL)
|
|
{
|
|
if (MojoPlatform_isdir(real))
|
|
GBaseArchive = MojoArchive_newFromDirectory(real);
|
|
else
|
|
{
|
|
io = MojoInput_newFromFile(real);
|
|
if (io != NULL)
|
|
GBaseArchive = MojoArchive_newFromInput(io, real);
|
|
} // else
|
|
|
|
if (GBaseArchive != NULL)
|
|
basepath = real;
|
|
else
|
|
free(real);
|
|
} // if
|
|
} // else if
|
|
|
|
else
|
|
{
|
|
basepath = MojoPlatform_appBinaryPath();
|
|
if (basepath != NULL)
|
|
{
|
|
io = MojoInput_newFromFile(basepath);
|
|
|
|
if (io != NULL)
|
|
{
|
|
// See if there's a MOJOBASE signature at the end of the
|
|
// file. This means we appended an archive to the executable,
|
|
// for a self-extracting installer. This method works with
|
|
// any archive type, even if it wasn't specifically designed
|
|
// to be appended.
|
|
uint8 buf[8];
|
|
uint64 size = 0;
|
|
const int64 flen = io->length(io) - 16;
|
|
if ( (flen > 0) && (io->seek(io, flen)) &&
|
|
(io->read(io, buf, 8) == 8) &&
|
|
(memcmp(buf, "MOJOBASE", 8) == 0) &&
|
|
(MojoInput_readui64(io, &size)) &&
|
|
(size < flen) )
|
|
{
|
|
MojoInput *newio;
|
|
newio = MojoInput_newFromSubset(io, flen - size, flen);
|
|
if (newio != NULL)
|
|
io = newio;
|
|
} // if
|
|
|
|
GBaseArchive = MojoArchive_newFromInput(io, basepath);
|
|
} // if
|
|
|
|
if (GBaseArchive == NULL)
|
|
{
|
|
// Just use the same directory as the binary instead.
|
|
char *ptr = strrchr(basepath, '/');
|
|
if (ptr != NULL)
|
|
*ptr = '\0';
|
|
else
|
|
{
|
|
free(basepath); // oh well, try cwd.
|
|
basepath = MojoPlatform_currentWorkingDir();
|
|
} // else
|
|
GBaseArchive = MojoArchive_newFromDirectory(basepath);
|
|
|
|
// !!! FIXME: failing this, maybe default.mojosetup?
|
|
} // if
|
|
} // if
|
|
} // else
|
|
|
|
if (GBaseArchive == NULL)
|
|
{
|
|
free(basepath);
|
|
basepath = NULL;
|
|
} // if
|
|
GBaseArchivePath = basepath;
|
|
|
|
return GBaseArchive;
|
|
} // MojoArchive_initBaseArchive
|
|
|
|
|
|
void MojoArchive_deinitBaseArchive(void)
|
|
{
|
|
if (GBaseArchive != NULL)
|
|
{
|
|
GBaseArchive->close(GBaseArchive);
|
|
GBaseArchive = NULL;
|
|
} // if
|
|
|
|
free((void *) GBaseArchivePath);
|
|
GBaseArchivePath = NULL;
|
|
} // MojoArchive_deinitBaseArchive
|
|
|
|
|
|
// This stub is here if we didn't compile in libfetch...
|
|
#if !SUPPORT_URL_HTTP && !SUPPORT_URL_FTP
|
|
MojoInput *MojoInput_newFromURL(const char *url)
|
|
{
|
|
logError("No networking support in this build.");
|
|
return NULL;
|
|
} // MojoInput_newFromURL
|
|
#endif
|
|
|
|
// end of fileio.c ...
|
|
|