void SG_vfile__reread(
SG_context* pCtx,
SG_vfile * pvf,
SG_vhash** ppvh)
{
SG_vhash* pvh = NULL;
SG_uint64 len64;
SG_uint32 len32;
SG_byte* p = NULL;
SG_ERR_CHECK( SG_file__seek_end(pCtx, pvf->pFile, &len64) );
SG_ERR_CHECK( SG_file__seek(pCtx, pvf->pFile, 0) );
// TODO "len64" is uint64 because we can have huge files, but
// TODO our buffer is limited to uint32 (on 32bit systems).
// TODO verify that len will fit in uint32.
len32 = (SG_uint32)len64;
if (len32 > 0)
{
SG_ERR_CHECK( SG_alloc(pCtx, 1,len32+1,&p) );
SG_ERR_CHECK( SG_file__read(pCtx, pvf->pFile, len32, p, NULL) );
p[len32] = 0;
SG_ERR_CHECK( SG_VHASH__ALLOC__FROM_JSON(pCtx, &pvh, (const char*) p) );
*ppvh = pvh;
}
fail:
SG_NULLFREE(pCtx, p);
}
void sg_unzip__get_uint16(SG_context* pCtx, SG_file* pFile, SG_uint16* pX)
{
SG_uint16 x = 0;
SG_uint8 b = 0;
SG_ERR_CHECK( SG_file__read(pCtx, pFile, 1, &b, NULL) );
x = (SG_uint16) b;
SG_ERR_CHECK( SG_file__read(pCtx, pFile, 1, &b, NULL) );
x |= (((SG_uint16)b)<<8);
*pX = x;
fail:
return;
}
static void sg_unzip__currentfile__get_info(SG_context* pCtx, SG_unzip* s)
{
SG_uint32 uMagic;
SG_NULLARGCHECK_RETURN( s );
SG_ERR_CHECK( SG_file__seek(pCtx, s->pFile, s->pos_in_central_dir + s->byte_before_the_zipfile) );
/* we check the magic */
SG_ERR_CHECK( sg_unzip__get_uint32(pCtx, s->pFile,&uMagic) );
if (uMagic != 0x02014b50)
{
SG_ERR_THROW( SG_ERR_ZIP_BAD_FILE );
}
SG_ERR_CHECK( sg_unzip__get_uint16(pCtx, s->pFile,&s->cur_file_info.version) );
SG_ERR_CHECK( sg_unzip__get_uint16(pCtx, s->pFile,&s->cur_file_info.version_needed) );
SG_ERR_CHECK( sg_unzip__get_uint16(pCtx, s->pFile,&s->cur_file_info.flag) );
SG_ERR_CHECK( sg_unzip__get_uint16(pCtx, s->pFile,&s->cur_file_info.compression_method) );
SG_ERR_CHECK( sg_unzip__get_uint32(pCtx, s->pFile,&s->cur_file_info.dosDate) );
SG_ERR_CHECK( sg_unzip__get_uint32(pCtx, s->pFile,&s->cur_file_info.crc) );
SG_ERR_CHECK( sg_unzip__get_uint32(pCtx, s->pFile,&s->cur_file_info.compressed_size) );
SG_ERR_CHECK( sg_unzip__get_uint32(pCtx, s->pFile,&s->cur_file_info.uncompressed_size) );
SG_ERR_CHECK( sg_unzip__get_uint16(pCtx, s->pFile,&s->cur_file_info.size_filename) );
SG_ERR_CHECK( sg_unzip__get_uint16(pCtx, s->pFile,&s->cur_file_info.size_file_extra) );
SG_ERR_CHECK( sg_unzip__get_uint16(pCtx, s->pFile,&s->cur_file_info.size_file_comment) );
SG_ERR_CHECK( sg_unzip__get_uint16(pCtx, s->pFile,&s->cur_file_info.disk_num_start) );
SG_ERR_CHECK( sg_unzip__get_uint16(pCtx, s->pFile,&s->cur_file_info.internal_fa) );
SG_ERR_CHECK( sg_unzip__get_uint32(pCtx, s->pFile,&s->cur_file_info.external_fa) );
SG_ERR_CHECK( sg_unzip__get_uint32(pCtx, s->pFile,&s->cur_file_info_internal.offset_curfile) );
SG_ASSERT (s->cur_file_info.size_filename < UNZ_MAXFILENAMEINZIP);
SG_ERR_CHECK( SG_file__read(pCtx, s->pFile, s->cur_file_info.size_filename, (SG_byte*) s->cur_file_name, NULL) );
s->cur_file_name[s->cur_file_info.size_filename] = 0;
fail:
return;
}
void _read_template_file(
SG_context *pCtx,
const char *templateFn,
SG_string **pContent, /**< we allocate, we free on error, else caller owns it */
const _request_headers *pRequestHeaders,
_replacer_cb replacer)
{
SG_pathname *tpath = NULL;
SG_file *pFile = NULL;
SG_uint32 got = 0;
char tbuf[1024];
//todo: make this thread-safe:
if(_sg_uridispatch__templatePath==NULL)
SG_ERR_CHECK( _sgui_set_templatePath(pCtx) );
SG_ERR_CHECK( SG_PATHNAME__ALLOC__COPY(pCtx, &tpath, _sg_uridispatch__templatePath) );
SG_ERR_CHECK( SG_pathname__append__from_sz(pCtx, tpath, templateFn) );
SG_ERR_CHECK( SG_file__open__pathname(pCtx, tpath, SG_FILE_RDONLY|SG_FILE_OPEN_EXISTING, 0644, &pFile) );
SG_PATHNAME_NULLFREE(pCtx, tpath);
SG_ERR_CHECK( SG_STRING__ALLOC(pCtx, pContent) );
do
{
SG_file__read(pCtx, pFile, sizeof(tbuf), (SG_byte *)tbuf, &got);
if (SG_context__err_equals(pCtx, SG_ERR_EOF))
{
SG_context__err_reset(pCtx);
break;
}
SG_ERR_CHECK_CURRENT;
SG_ERR_CHECK( SG_string__append__buf_len(pCtx, *pContent, (const SG_byte *)tbuf, got) );
} while (got > 0);
SG_ERR_CHECK( SG_file__close(pCtx, &pFile) );
SG_ERR_CHECK( _templatize(pCtx, *pContent, pRequestHeaders, replacer) );
return;
fail:
SG_STRING_NULLFREE(pCtx, *pContent);
SG_FILE_NULLCLOSE(pCtx, pFile);
SG_PATHNAME_NULLFREE(pCtx, tpath);
}
static void _read_file_chunk(SG_context* pCtx, SG_curl* pCurl, char* buffer, SG_uint32 bufLen, void* pVoidState, SG_uint32* pLenHandled)
{
struct _sg_curl__file_read_state* pReadState = (struct _sg_curl__file_read_state*)pVoidState;
SG_UNUSED(pCurl);
if (pReadState->finished)
{
SG_ERR_THROW2_RETURN(SG_ERR_UNSPECIFIED, (pCtx, "An unknown error occurred interfacing with libcurl. Please try again."));
}
else if (pReadState->pos == pReadState->len)
{
pReadState->finished = SG_TRUE;
*pLenHandled = 0;
}
else
{
SG_ERR_CHECK_RETURN( SG_file__read(pCtx, pReadState->pFile, bufLen, (SG_byte*)buffer, pLenHandled) );
pReadState->pos += *pLenHandled;
}
}
void SG_vfile__begin(
SG_context* pCtx,
const SG_pathname* pPath, /**< The path of the file containing the JSON text */
SG_file_flags mode,
SG_vhash** ppvh, /**< If there are no errors, the resulting vhash table will be returned here. */
SG_vfile** ppvf
)
{
SG_vfile* pvf = NULL;
SG_vhash* pvh = NULL;
SG_uint32 len32;
SG_fsobj_type t;
SG_byte* p = NULL;
SG_bool bExists;
SG_fsobj_type FsObjType;
SG_fsobj_perms FsObjPerms;
SG_ERR_CHECK( SG_fsobj__exists__pathname(pCtx, pPath, &bExists, &FsObjType, &FsObjPerms) );
if (
bExists
&& (SG_FSOBJ_TYPE__REGULAR != FsObjType)
)
{
SG_ERR_THROW_RETURN(SG_ERR_NOTAFILE);
}
if (bExists)
{
SG_uint64 len64;
SG_ERR_CHECK( SG_fsobj__length__pathname(pCtx, pPath, &len64, &t) );
// TODO "len" is uint64 because we can have huge files, but
// TODO our buffer is limited to uint32 (on 32bit systems).
// TODO verify that len will fit in uint32.
len32 = (SG_uint32)len64;
}
else
{
len32 = 0;
}
SG_ERR_CHECK_RETURN( SG_alloc1(pCtx, pvf) );
SG_ERR_CHECK( SG_file__open__pathname(pCtx, pPath, mode | SG_FILE_LOCK, SG_FSOBJ_PERMS__UNUSED, &pvf->pFile) );
pvf->mode = mode;
#if TRACE_VFILE
SG_ERR_IGNORE( SG_console(pCtx, SG_CS_STDERR, "VFileBegin: Reading %d bytes from %s\n", len32, SG_pathname__sz(pPath)) );
#endif
if (len32 > 0)
{
SG_ERR_CHECK( SG_alloc(pCtx, 1,len32+1,&p) );
SG_ERR_CHECK( SG_file__read(pCtx, pvf->pFile, len32, p, NULL) );
p[len32] = 0;
SG_ERR_CHECK( SG_VHASH__ALLOC__FROM_JSON(pCtx, &pvh, (const char*) p) );
SG_NULLFREE(pCtx, p);
p = NULL;
}
else
{
pvh = NULL;
}
*ppvf = pvf;
*ppvh = pvh;
return;
fail:
SG_FILE_NULLCLOSE(pCtx, pvf->pFile);
SG_NULLFREE(pCtx, p);
SG_NULLFREE(pCtx, pvf);
}
static void sg_read_entire_file(
SG_context* pCtx,
const SG_pathname* pPath,
char** ppbuf,
SG_uint32* plen
)
{
SG_uint32 len32;
SG_fsobj_type t;
SG_byte* p = NULL;
SG_bool bExists;
SG_fsobj_type FsObjType;
SG_fsobj_perms FsObjPerms;
SG_file* pFile = NULL;
SG_ERR_CHECK( SG_fsobj__exists__pathname(pCtx, pPath, &bExists, &FsObjType, &FsObjPerms) );
if (
bExists
&& (SG_FSOBJ_TYPE__REGULAR != FsObjType)
)
{
SG_ERR_IGNORE( SG_log__report_error(pCtx, "Unable to open file: %s.", SG_pathname__sz(pPath)) );
SG_ERR_THROW_RETURN(SG_ERR_NOTAFILE);
}
if (bExists)
{
SG_uint64 len64;
SG_ERR_CHECK( SG_fsobj__length__pathname(pCtx, pPath, &len64, &t) );
// TODO "len" is uint64 because we can have huge files, but
// TODO our buffer is limited to uint32 (on 32bit systems).
// TODO verify that len will fit in uint32.
len32 = (SG_uint32)len64;
SG_ERR_CHECK( SG_file__open__pathname(pCtx, pPath, SG_FILE_RDONLY | SG_FILE_OPEN_EXISTING, SG_FSOBJ_PERMS__UNUSED, &pFile) );
}
else
{
SG_ERR_THROW_RETURN(SG_ERR_NOTAFILE);
//len32 = 0;
}
if (len32 > 0)
{
SG_ERR_CHECK( SG_alloc(pCtx, 1,len32+1,&p) );
SG_ERR_CHECK( SG_file__read(pCtx, pFile, len32, p, NULL) );
p[len32] = 0;
*ppbuf = (char*) p;
p = NULL;
*plen = len32;
}
else
{
*ppbuf = NULL;
*plen = 0;
}
fail:
SG_FILE_NULLCLOSE(pCtx, pFile);
SG_NULLFREE(pCtx, p);
}
void SG_unzip__currentfile__read(SG_context* pCtx, SG_unzip* s, SG_byte* pBuf, SG_uint32 iLenBuf, SG_uint32* piBytesRead)
{
int zerr=Z_OK;
SG_uint32 iRead = 0;
file_in_zip_read_info_s* pfile_in_zip_read_info;
SG_NULLARGCHECK_RETURN( s );
pfile_in_zip_read_info = s->pfile_in_zip_read;
SG_NULLARGCHECK_RETURN( pfile_in_zip_read_info );
if (!pfile_in_zip_read_info->read_buffer)
{
SG_ERR_THROW_RETURN( SG_ERR_UNSPECIFIED );
}
if (!iLenBuf)
{
return;
}
pfile_in_zip_read_info->stream.next_out = pBuf;
pfile_in_zip_read_info->stream.avail_out = iLenBuf;
if (iLenBuf > pfile_in_zip_read_info->rest_read_uncompressed)
{
pfile_in_zip_read_info->stream.avail_out = (SG_uint32)pfile_in_zip_read_info->rest_read_uncompressed;
}
while (pfile_in_zip_read_info->stream.avail_out>0)
{
if ((pfile_in_zip_read_info->stream.avail_in==0) &&
(pfile_in_zip_read_info->rest_read_compressed>0))
{
SG_uint32 uReadThis = UNZ_BUFSIZE;
if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
{
uReadThis = (SG_uint32)pfile_in_zip_read_info->rest_read_compressed;
}
if (uReadThis == 0)
{
//TODO - maybe we should change this
SG_ERR_THROW( SG_ERR_EOF );
}
SG_ERR_CHECK( SG_file__seek(pCtx, s->pFile, pfile_in_zip_read_info->pos_in_zipfile + pfile_in_zip_read_info->byte_before_the_zipfile) );
SG_ERR_CHECK( SG_file__read(pCtx, s->pFile, uReadThis, (SG_byte*) pfile_in_zip_read_info->read_buffer, NULL) );
pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
pfile_in_zip_read_info->stream.next_in = (Bytef*)pfile_in_zip_read_info->read_buffer;
pfile_in_zip_read_info->stream.avail_in = (SG_uint32)uReadThis;
}
if (pfile_in_zip_read_info->compression_method==0)
{
SG_uint32 uDoCopy,i ;
if ((pfile_in_zip_read_info->stream.avail_in == 0) &&
(pfile_in_zip_read_info->rest_read_compressed == 0))
{
if (iRead == 0)
{
SG_ERR_THROW( SG_ERR_EOF );
}
goto done;
}
if (pfile_in_zip_read_info->stream.avail_out <
pfile_in_zip_read_info->stream.avail_in)
{
uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
}
else
{
uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
}
for (i=0;i<uDoCopy;i++)
{
*(pfile_in_zip_read_info->stream.next_out+i) =
*(pfile_in_zip_read_info->stream.next_in+i);
}
pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
pfile_in_zip_read_info->stream.next_out,
uDoCopy);
pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
pfile_in_zip_read_info->stream.next_out += uDoCopy;
pfile_in_zip_read_info->stream.next_in += uDoCopy;
pfile_in_zip_read_info->stream.total_out += uDoCopy;
iRead += uDoCopy;
}
else
{
SG_uint32 uTotalOutBefore,uTotalOutAfter;
const Bytef *bufBefore;
SG_uint32 uOutThis;
int flush=Z_SYNC_FLUSH;
uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
bufBefore = pfile_in_zip_read_info->stream.next_out;
/*
if ((pfile_in_zip_read_info->rest_read_uncompressed ==
pfile_in_zip_read_info->stream.avail_out) &&
(pfile_in_zip_read_info->rest_read_compressed == 0))
flush = Z_FINISH;
*/
zerr = inflate(&pfile_in_zip_read_info->stream,flush);
if ((zerr>=0) && (pfile_in_zip_read_info->stream.msg))
{
SG_ERR_THROW( SG_ERR_ZLIB(zerr) );
}
uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
uOutThis = uTotalOutAfter-uTotalOutBefore;
pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,bufBefore, (SG_uint32)(uOutThis));
pfile_in_zip_read_info->rest_read_uncompressed -= uOutThis;
iRead += (SG_uint32)(uTotalOutAfter - uTotalOutBefore);
if (zerr == Z_STREAM_END)
{
// return (iRead==0) ? UNZ_EOF : iRead;
// break;
}
}
}
done:
*piBytesRead = iRead;
fail:
return;
}
static void sg_unzip__locate_central_dir(SG_context* pCtx, SG_file* pFile, SG_uint64* piPosition)
{
unsigned char* buf = NULL;
SG_uint64 uSizeFile;
SG_uint32 uBackRead;
SG_uint32 uMaxBack=0xffff; /* maximum size of global comment */
SG_uint64 uPosFound=0;
SG_ERR_CHECK( SG_file__seek_end(pCtx, pFile, &uSizeFile) );
if (uMaxBack > uSizeFile)
{
uMaxBack = (SG_uint32) uSizeFile;
}
SG_ERR_CHECK( SG_malloc(pCtx, BUFREADCOMMENT+4, &buf) );
uBackRead = 4;
while (uBackRead<uMaxBack)
{
SG_uint32 uReadSize;
SG_uint64 uReadPos;
int i;
if (uBackRead+BUFREADCOMMENT>uMaxBack)
{
uBackRead = uMaxBack;
}
else
{
uBackRead += BUFREADCOMMENT;
}
uReadPos = uSizeFile-uBackRead ;
uReadSize = (SG_uint32) (((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
(BUFREADCOMMENT+4) : (uSizeFile-uReadPos));
SG_ERR_CHECK( SG_file__seek(pCtx, pFile, uReadPos) );
SG_ERR_CHECK( SG_file__read(pCtx, pFile, uReadSize, buf, NULL) );
for (i=(int)uReadSize-3; (i--)>0;)
{
if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
{
uPosFound = uReadPos+i;
break;
}
}
if (uPosFound!=0)
{
break;
}
}
*piPosition = uPosFound;
fail:
SG_NULLFREE(pCtx, buf);
}
