void *ice_load(istream_t *is, int *ulen)
{
char header[12], *inbuf = 0, * outbuf = 0;
int dsize, csize;
const char * fname;
fname = istream_filename(is);
if (istream_read(is,header,12) != 12) {
SC68error_add("ice_load(%s) : no header", fname);
goto error;
}
csize = 0;
dsize = unice68_get_depacked_size(header, &csize);
if (dsize < 0) {
SC68error_add("ice_load(%s) : not ICE!", fname);
goto error;
}
inbuf = SC68alloc(csize + 12);
if (!inbuf) {
SC68error_add("ice_load(%s) : alloc input buffer failed", fname);
goto error;
}
memcpy(inbuf,header,12);
if (istream_read(is,inbuf+12,csize) != csize) {
SC68error_add("ice_load(%s) : read failed", fname);
goto error;
}
outbuf = SC68alloc(dsize);
if (!outbuf) {
SC68error_add("ice_load(%s) : alloc output buffer failed", fname);
goto error;
}
if (!unice68_depacker(outbuf, inbuf)) {
goto success;
}
error:
SC68free(outbuf);
outbuf = 0;
dsize = 0;
success:
SC68free(inbuf);
if (ulen) {
*ulen = dsize;
}
return outbuf;
}
istream_t * istream_file_create(const char * fname, int mode)
{
istream_file_t *isf;
int len;
if (!fname || !fname[0]) {
return 0;
}
/* Don't need 0, because 1 byte already allocated in the
* istream_file_t::fname.
*/
len = strlen(fname);
isf = SC68alloc(sizeof(istream_file_t) + len);
if (!isf) {
return 0;
}
/* Copy istream functions. */
memcpy(&isf->istream, &istream_file, sizeof(istream_file));
/* Clean file handle. */
isf->f = 0;
isf->mode = mode & (ISTREAM_OPEN_READ|ISTREAM_OPEN_WRITE);
/* Copy filename. */
/* $$$ May be later, we should add a check for relative path and add
* CWD ... */
strcpy(isf->name, fname);
return &isf->istream;
}
istream_t * istream_null_create(const char * name)
{
istream_null_t *ism;
int size;
static const char hd[] = "null://";
if (!name) {
name = "default";
}
size = sizeof(istream_null_t) + sizeof(hd)-1 + strlen(name);
ism = SC68alloc(size);
if (!ism) {
return 0;
}
ism->istream = istream_null;
ism->size = 0;
ism->pos = 0;
ism->open = 0;
strcpy(ism->name,hd);
strcat(ism->name,name);
return &ism->istream;
}
istream_t * istream_mem_create(const void * addr, int len, int mode)
{
istream_mem_t *ism;
if (len < 0 || (!addr && len)) {
return 0;
}
ism = (istream_mem_t*)SC68alloc(sizeof(istream_mem_t));
if (!ism) {
return 0;
}
ism->istream = istream_mem;
ism->buffer = (char *)addr;
ism->size = len;
ism->mode = mode & (ISTREAM_OPEN_READ|ISTREAM_OPEN_WRITE);
ism->open = 0;
ism->pos = 0;
sprintf(ism->name,"mem://%p:%p", addr, (char *)addr+len);
return &ism->istream;
}
void *gzip_load(const char *fname, int *ptr_ulen)
{
int fd, err;
gzFile f = 0;
int ulen = 0;
void * uncompr = 0;
off_t len;
const int omode = O_RDONLY | _O_BINARY;
fd = open(fname, omode);
if (fd == -1) {
//SC68error_add("gzip_load(%s) : %s", fname, strerror(errno));
goto error;
}
len = lseek(fd, 0, SEEK_END);
if (len == (off_t) -1) {
//SC68error_add("gzip_load(%s) : %s", fname, strerror(errno));
goto error;
}
if (lseek(fd, 0, SEEK_SET) != 0) {
//SC68error_add("gzip_load(%s) : %s", fname, strerror(errno));
goto error;
}
ulen = is_gz(fd, len);
if (ulen == -1) {
ulen = len;
}
f = gzdopen(fd, "rb");
if (!f) {
//SC68error_add("gzip_load(%s) : %s", fname, gzerror(f, &err));
goto error;
}
fd = 0; /* $$$ Closed by gzclose(). Verify fdopen() rules. */
uncompr = SC68alloc(ulen);
if (!uncompr) {
//SC68error_add("gzip_load(%s) : alloc (%d) failed", fname, ulen);
goto error;
}
len = gzread(f, uncompr, ulen);
if (len != ulen) {
//SC68error_add("gzip_load(%s) : read : %s",fname, gzerror (f, &err));
goto error;
}
goto end;
error:
if (uncompr) {
SC68free(uncompr);
uncompr = 0;
ulen = 0;
}
end:
if (fd) {
close(fd);
}
if (f) {
gzclose(f);
}
if (ptr_ulen) {
*ptr_ulen = ulen;
}
return uncompr;
}
