[pcsx_rearmed.git] / deps / libretro-common / file / archive_file_7z.c

/* Copyright  (C) 2010-2020 The RetroArch team
 *
 * ---------------------------------------------------------------------------------------
 * The following license statement only applies to this file (archive_file_sevenzip.c).
 * ---------------------------------------------------------------------------------------
 *
 * Permission is hereby granted, free of charge,
 * to any person obtaining a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include <stdlib.h>

#include <boolean.h>
#include <file/archive_file.h>
#include <streams/file_stream.h>
#include <retro_miscellaneous.h>
#include <encodings/utf.h>
#include <encodings/crc32.h>
#include <string/stdstring.h>
#include <lists/string_list.h>
#include <file/file_path.h>
#include <compat/strl.h>
#include <7zip/7z.h>
#include <7zip/7zCrc.h>
#include <7zip/7zFile.h>

#define SEVENZIP_MAGIC "7z\xBC\xAF\x27\x1C"
#define SEVENZIP_MAGIC_LEN 6
#define SEVENZIP_LOOKTOREAD_BUF_SIZE (1 << 14)

/* Assume W-functions do not work below Win2K and Xbox platforms */
#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0500 || defined(_XBOX)
#ifndef LEGACY_WIN32
#define LEGACY_WIN32
#endif
#endif

struct sevenzip_context_t
{
   uint8_t *output;
   CFileInStream archiveStream;
   CLookToRead2 lookStream;
   ISzAlloc allocImp;
   ISzAlloc allocTempImp;
   CSzArEx db;
   size_t temp_size;
   uint32_t parse_index;
   uint32_t decompress_index;
   uint32_t packIndex;
   uint32_t   block_index;
};

static void *sevenzip_stream_alloc_impl(ISzAllocPtr p, size_t size)
{
   if (size == 0)
      return 0;
   return malloc(size);
}

static void sevenzip_stream_free_impl(ISzAllocPtr p, void *address)
{
   (void)p;

   if (address)
      free(address);
}

static void *sevenzip_stream_alloc_tmp_impl(ISzAllocPtr p, size_t size)
{
   (void)p;
   if (size == 0)
      return 0;
   return malloc(size);
}

static void* sevenzip_stream_new(void)
{
   struct sevenzip_context_t *sevenzip_context =
         (struct sevenzip_context_t*)calloc(1, sizeof(struct sevenzip_context_t));

   /* These are the allocation routines - currently using
    * the non-standard 7zip choices. */
   sevenzip_context->allocImp.Alloc     = sevenzip_stream_alloc_impl;
   sevenzip_context->allocImp.Free      = sevenzip_stream_free_impl;
   sevenzip_context->allocTempImp.Alloc = sevenzip_stream_alloc_tmp_impl;
   sevenzip_context->allocTempImp.Free  = sevenzip_stream_free_impl;
   sevenzip_context->block_index        = 0xFFFFFFFF;
   sevenzip_context->output             = NULL;

   sevenzip_context->lookStream.bufSize = SEVENZIP_LOOKTOREAD_BUF_SIZE * sizeof(Byte);
   sevenzip_context->lookStream.buf     = (Byte*)malloc(sevenzip_context->lookStream.bufSize);

   if (!sevenzip_context->lookStream.buf)
      sevenzip_context->lookStream.bufSize = 0;

   return sevenzip_context;
}

static void sevenzip_parse_file_free(void *context)
{
   struct sevenzip_context_t *sevenzip_context = (struct sevenzip_context_t*)context;

   if (!sevenzip_context)
      return;

   if (sevenzip_context->output)
   {
      IAlloc_Free(&sevenzip_context->allocImp, sevenzip_context->output);
      sevenzip_context->output       = NULL;
   }

   SzArEx_Free(&sevenzip_context->db, &sevenzip_context->allocImp);
   File_Close(&sevenzip_context->archiveStream.file);

   if (sevenzip_context->lookStream.buf)
      free(sevenzip_context->lookStream.buf);

   free(sevenzip_context);
}

/* Extract the relative path (needle) from a 7z archive
 * (path) and allocate a buf for it to write it in.
 * If optional_outfile is set, extract to that instead
 * and don't allocate buffer.
 */
static int64_t sevenzip_file_read(
      const char *path,
      const char *needle, void **buf,
      const char *optional_outfile)
{
   CFileInStream archiveStream;
   CLookToRead2 lookStream;
   ISzAlloc allocImp;
   ISzAlloc allocTempImp;
   CSzArEx db;
   uint8_t *output      = 0;
   int64_t outsize      = -1;

   /*These are the allocation routines.
    * Currently using the non-standard 7zip choices. */
   allocImp.Alloc       = sevenzip_stream_alloc_impl;
   allocImp.Free        = sevenzip_stream_free_impl;
   allocTempImp.Alloc   = sevenzip_stream_alloc_tmp_impl;
   allocTempImp.Free    = sevenzip_stream_free_impl;

   lookStream.bufSize   = SEVENZIP_LOOKTOREAD_BUF_SIZE * sizeof(Byte);
   lookStream.buf       = (Byte*)malloc(lookStream.bufSize);

   if (!lookStream.buf)
      lookStream.bufSize = 0;

#if defined(_WIN32) && defined(USE_WINDOWS_FILE) && !defined(LEGACY_WIN32)
   if (!string_is_empty(path))
   {
      wchar_t *pathW = utf8_to_utf16_string_alloc(path);

      if (pathW)
      {
         /* Could not open 7zip archive? */
         if (InFile_OpenW(&archiveStream.file, pathW))
         {
            free(pathW);
            return -1;
         }

         free(pathW);
      }
   }
#else
   /* Could not open 7zip archive? */
   if (InFile_Open(&archiveStream.file, path))
      return -1;
#endif

   FileInStream_CreateVTable(&archiveStream);
   LookToRead2_CreateVTable(&lookStream, false);
   lookStream.realStream = &archiveStream.vt;
   LookToRead2_Init(&lookStream);
   CrcGenerateTable();

   memset(&db, 0, sizeof(db));

   SzArEx_Init(&db);

   if (SzArEx_Open(&db, &lookStream.vt, &allocImp, &allocTempImp) == SZ_OK)
   {
      uint32_t i;
      bool file_found      = false;
      uint16_t *temp       = NULL;
      size_t temp_size     = 0;
      uint32_t block_index   = 0xFFFFFFFF;
      SRes res             = SZ_OK;

      for (i = 0; i < db.NumFiles; i++)
      {
         size_t len;
         char infile[PATH_MAX_LENGTH];
         size_t offset                = 0;
         size_t outSizeProcessed      = 0;

         /* We skip over everything which is not a directory.
          * FIXME: Why continue then if IsDir is true?*/
         if (SzArEx_IsDir(&db, i))
            continue;

         len = SzArEx_GetFileNameUtf16(&db, i, NULL);

         if (len > temp_size)
         {
            if (temp)
               free(temp);
            temp_size = len;
            temp = (uint16_t *)malloc(temp_size * sizeof(temp[0]));

            if (temp == 0)
            {
               res = SZ_ERROR_MEM;
               break;
            }
         }

         SzArEx_GetFileNameUtf16(&db, i, temp);
         res       = SZ_ERROR_FAIL;
         infile[0] = '\0';

         if (temp)
            res = utf16_to_char_string(temp, infile, sizeof(infile))
               ? SZ_OK : SZ_ERROR_FAIL;

         if (string_is_equal(infile, needle))
         {
            size_t output_size   = 0;

            /* C LZMA SDK does not support chunked extraction - see here:
             * sourceforge.net/p/sevenzip/discussion/45798/thread/6fb59aaf/
             * */
            file_found = true;
            res = SzArEx_Extract(&db, &lookStream.vt, i, &block_index,
                  &output, &output_size, &offset, &outSizeProcessed,
                  &allocImp, &allocTempImp);

            if (res != SZ_OK)
               break; /* This goes to the error section. */

            outsize = (int64_t)outSizeProcessed;

            if (optional_outfile)
            {
               const void *ptr = (const void*)(output + offset);

               if (!filestream_write_file(optional_outfile, ptr, outsize))
               {
                  res        = SZ_OK;
                  file_found = true;
                  outsize    = -1;
               }
            }
            else
            {
               /*We could either use the 7Zip allocated buffer,
                * or create our own and use it.
                * We would however need to realloc anyways, because RetroArch
                * expects a \0 at the end, therefore we allocate new,
                * copy and free the old one. */
               *buf = malloc((size_t)(outsize + 1));
               ((char*)(*buf))[outsize] = '\0';
               memcpy(*buf,output + offset,outsize);
            }
            break;
         }
      }

      if (temp)
         free(temp);
      IAlloc_Free(&allocImp, output);

      if (!(file_found && res == SZ_OK))
      {
         /* Error handling
          *
          * Failed to open compressed file inside 7zip archive.
          */

         outsize    = -1;
      }
   }

   SzArEx_Free(&db, &allocImp);
   File_Close(&archiveStream.file);

   if (lookStream.buf)
      free(lookStream.buf);

   return outsize;
}

static bool sevenzip_stream_decompress_data_to_file_init(
      void *context, file_archive_file_handle_t *handle,
      const uint8_t *cdata, unsigned cmode, uint32_t csize, uint32_t size)
{
   struct sevenzip_context_t *sevenzip_context =
         (struct sevenzip_context_t*)context;

   if (!sevenzip_context)
      return false;

   sevenzip_context->decompress_index = (uint32_t)(size_t)cdata;

   return true;
}

static int sevenzip_stream_decompress_data_to_file_iterate(
      void *context, file_archive_file_handle_t *handle)
{
   struct sevenzip_context_t *sevenzip_context =
         (struct sevenzip_context_t*)context;

   SRes res                = SZ_ERROR_FAIL;
   size_t output_size      = 0;
   size_t offset           = 0;
   size_t outSizeProcessed = 0;

   res = SzArEx_Extract(&sevenzip_context->db,
         &sevenzip_context->lookStream.vt, sevenzip_context->decompress_index,
         &sevenzip_context->block_index, &sevenzip_context->output,
         &output_size, &offset, &outSizeProcessed,
         &sevenzip_context->allocImp, &sevenzip_context->allocTempImp);

   if (res != SZ_OK)
      return 0;

   if (handle)
      handle->data = sevenzip_context->output + offset;

   return 1;
}

static int sevenzip_parse_file_init(file_archive_transfer_t *state,
      const char *file)
{
   uint8_t magic_buf[SEVENZIP_MAGIC_LEN];
   struct sevenzip_context_t *sevenzip_context = NULL;

   if (state->archive_size < SEVENZIP_MAGIC_LEN)
      goto error;

   filestream_seek(state->archive_file, 0, SEEK_SET);
   if (filestream_read(state->archive_file, magic_buf, SEVENZIP_MAGIC_LEN) != SEVENZIP_MAGIC_LEN)
      goto error;

   if (string_is_not_equal_fast(magic_buf, SEVENZIP_MAGIC, SEVENZIP_MAGIC_LEN))
      goto error;

   sevenzip_context = (struct sevenzip_context_t*)sevenzip_stream_new();
   state->context = sevenzip_context;

#if defined(_WIN32) && defined(USE_WINDOWS_FILE) && !defined(LEGACY_WIN32)
   if (!string_is_empty(file))
   {
      wchar_t *fileW = utf8_to_utf16_string_alloc(file);

      if (fileW)
      {
         /* could not open 7zip archive? */
         if (InFile_OpenW(&sevenzip_context->archiveStream.file, fileW))
         {
            free(fileW);
            goto error;
         }

         free(fileW);
      }
   }
#else
   /* could not open 7zip archive? */
   if (InFile_Open(&sevenzip_context->archiveStream.file, file))
      goto error;
#endif

   FileInStream_CreateVTable(&sevenzip_context->archiveStream);
   LookToRead2_CreateVTable(&sevenzip_context->lookStream, false);
   sevenzip_context->lookStream.realStream = &sevenzip_context->archiveStream.vt;
   LookToRead2_Init(&sevenzip_context->lookStream);
   CrcGenerateTable();
   SzArEx_Init(&sevenzip_context->db);

   if (SzArEx_Open(&sevenzip_context->db, &sevenzip_context->lookStream.vt,
         &sevenzip_context->allocImp, &sevenzip_context->allocTempImp) != SZ_OK)
      goto error;

   state->step_total = sevenzip_context->db.NumFiles;

   return 0;

error:
   if (sevenzip_context)
      sevenzip_parse_file_free(sevenzip_context);
   return -1;
}

static int sevenzip_parse_file_iterate_step_internal(
      struct sevenzip_context_t *sevenzip_context, char *filename,
      const uint8_t **cdata, unsigned *cmode,
      uint32_t *size, uint32_t *csize, uint32_t *checksum,
      unsigned *payback, struct archive_extract_userdata *userdata)
{
   if (sevenzip_context->parse_index < sevenzip_context->db.NumFiles)
   {
      size_t len = SzArEx_GetFileNameUtf16(&sevenzip_context->db,
            sevenzip_context->parse_index, NULL);
      uint64_t compressed_size = 0;

      if (sevenzip_context->packIndex < sevenzip_context->db.db.NumPackStreams)
      {
         compressed_size = sevenzip_context->db.db.PackPositions[sevenzip_context->packIndex + 1] -
               sevenzip_context->db.db.PackPositions[sevenzip_context->packIndex];

         sevenzip_context->packIndex++;
      }

      if (len < PATH_MAX_LENGTH &&
          !SzArEx_IsDir(&sevenzip_context->db, sevenzip_context->parse_index))
      {
         char infile[PATH_MAX_LENGTH];
         SRes res                     = SZ_ERROR_FAIL;
         uint16_t *temp               = (uint16_t*)malloc(len * sizeof(uint16_t));

         if (!temp)
            return -1;

         infile[0] = '\0';

         SzArEx_GetFileNameUtf16(&sevenzip_context->db, sevenzip_context->parse_index,
               temp);

         if (temp)
         {
            res  = utf16_to_char_string(temp, infile, sizeof(infile))
               ? SZ_OK : SZ_ERROR_FAIL;
            free(temp);
         }

         if (res != SZ_OK)
            return -1;

         strlcpy(filename, infile, PATH_MAX_LENGTH);

         *cmode    = 0; /* unused for 7zip */
         *checksum = sevenzip_context->db.CRCs.Vals[sevenzip_context->parse_index];
         *size     = (uint32_t)SzArEx_GetFileSize(&sevenzip_context->db, sevenzip_context->parse_index);
         *csize    = (uint32_t)compressed_size;

         *cdata    = (uint8_t *)(size_t)sevenzip_context->parse_index;
      }
   }
   else
      return 0;

   *payback = 1;

   return 1;
}

static int sevenzip_parse_file_iterate_step(void *context,
      const char *valid_exts,
      struct archive_extract_userdata *userdata, file_archive_file_cb file_cb)
{
   const uint8_t *cdata = NULL;
   uint32_t checksum    = 0;
   uint32_t size        = 0;
   uint32_t csize       = 0;
   unsigned cmode       = 0;
   unsigned payload     = 0;
   struct sevenzip_context_t *sevenzip_context = (struct sevenzip_context_t*)context;
   int ret;

   userdata->current_file_path[0] = '\0';

   ret = sevenzip_parse_file_iterate_step_internal(sevenzip_context,
         userdata->current_file_path,
         &cdata, &cmode, &size, &csize,
         &checksum, &payload, userdata);

   if (ret != 1)
      return ret;

   userdata->crc                 = checksum;

   if (file_cb && !file_cb(userdata->current_file_path, valid_exts,
            cdata, cmode,
            csize, size, checksum, userdata))
      return 0;

   sevenzip_context->parse_index += payload;

   return 1;
}

static uint32_t sevenzip_stream_crc32_calculate(uint32_t crc,
      const uint8_t *data, size_t length)
{
   return encoding_crc32(crc, data, length);
}

const struct file_archive_file_backend sevenzip_backend = {
   sevenzip_parse_file_init,
   sevenzip_parse_file_iterate_step,
   sevenzip_parse_file_free,
   sevenzip_stream_decompress_data_to_file_init,
   sevenzip_stream_decompress_data_to_file_iterate,
   sevenzip_stream_crc32_calculate,
   sevenzip_file_read,
   "7z"
};
Commit	Line	Data
3719602c PC	1	/* Copyright (C) 2010-2020 The RetroArch team
	2	*
	3	* ---------------------------------------------------------------------------------------
	4	* The following license statement only applies to this file (archive_file_sevenzip.c).
	5	* ---------------------------------------------------------------------------------------
	6	*
	7	* Permission is hereby granted, free of charge,
	8	* to any person obtaining a copy of this software and associated documentation files (the "Software"),
	9	* to deal in the Software without restriction, including without limitation the rights to
	10	* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
	11	* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
	12	*
	13	* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
	14	*
	15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
	16	* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	18	* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
	19	* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	20	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	21	*/
	22
	23	#include <stdlib.h>
	24
	25	#include <boolean.h>
	26	#include <file/archive_file.h>
	27	#include <streams/file_stream.h>
	28	#include <retro_miscellaneous.h>
	29	#include <encodings/utf.h>
	30	#include <encodings/crc32.h>
	31	#include <string/stdstring.h>
	32	#include <lists/string_list.h>
	33	#include <file/file_path.h>
	34	#include <compat/strl.h>
	35	#include <7zip/7z.h>
	36	#include <7zip/7zCrc.h>
	37	#include <7zip/7zFile.h>
	38
	39	#define SEVENZIP_MAGIC "7z\xBC\xAF\x27\x1C"
	40	#define SEVENZIP_MAGIC_LEN 6
	41	#define SEVENZIP_LOOKTOREAD_BUF_SIZE (1 << 14)
	42
	43	/* Assume W-functions do not work below Win2K and Xbox platforms */
	44	#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0500 \|\| defined(_XBOX)
	45	#ifndef LEGACY_WIN32
	46	#define LEGACY_WIN32
	47	#endif
	48	#endif
	49
	50	struct sevenzip_context_t
	51	{
	52	uint8_t *output;
	53	CFileInStream archiveStream;
	54	CLookToRead2 lookStream;
	55	ISzAlloc allocImp;
	56	ISzAlloc allocTempImp;
	57	CSzArEx db;
	58	size_t temp_size;
	59	uint32_t parse_index;
	60	uint32_t decompress_index;
	61	uint32_t packIndex;
	62	uint32_t block_index;
	63	};
	64
65	static void *sevenzip_stream_alloc_impl(ISzAllocPtr p, size_t size)
66	{
67	if (size == 0)
68	return 0;
69	return malloc(size);
70	}
71
72	static void sevenzip_stream_free_impl(ISzAllocPtr p, void *address)
73	{
74	(void)p;
75
76	if (address)
77	free(address);
78	}
79
80	static void *sevenzip_stream_alloc_tmp_impl(ISzAllocPtr p, size_t size)
81	{
82	(void)p;
83	if (size == 0)
84	return 0;
85	return malloc(size);
86	}
87
88	static void* sevenzip_stream_new(void)
89	{
90	struct sevenzip_context_t *sevenzip_context =
91	(struct sevenzip_context_t*)calloc(1, sizeof(struct sevenzip_context_t));
92
93	/* These are the allocation routines - currently using
94	* the non-standard 7zip choices. */
95	sevenzip_context->allocImp.Alloc = sevenzip_stream_alloc_impl;
96	sevenzip_context->allocImp.Free = sevenzip_stream_free_impl;
97	sevenzip_context->allocTempImp.Alloc = sevenzip_stream_alloc_tmp_impl;
98	sevenzip_context->allocTempImp.Free = sevenzip_stream_free_impl;
99	sevenzip_context->block_index = 0xFFFFFFFF;
100	sevenzip_context->output = NULL;
101
102	sevenzip_context->lookStream.bufSize = SEVENZIP_LOOKTOREAD_BUF_SIZE * sizeof(Byte);
103	sevenzip_context->lookStream.buf = (Byte*)malloc(sevenzip_context->lookStream.bufSize);
104
105	if (!sevenzip_context->lookStream.buf)
106	sevenzip_context->lookStream.bufSize = 0;
107
108	return sevenzip_context;
109	}
110
111	static void sevenzip_parse_file_free(void *context)
112	{
113	struct sevenzip_context_t sevenzip_context = (struct sevenzip_context_t)context;
114
115	if (!sevenzip_context)
116	return;
117
118	if (sevenzip_context->output)
119	{
120	IAlloc_Free(&sevenzip_context->allocImp, sevenzip_context->output);
121	sevenzip_context->output = NULL;
122	}
123
124	SzArEx_Free(&sevenzip_context->db, &sevenzip_context->allocImp);
125	File_Close(&sevenzip_context->archiveStream.file);
126
127	if (sevenzip_context->lookStream.buf)
128	free(sevenzip_context->lookStream.buf);
129
130	free(sevenzip_context);
131	}
132
133	/* Extract the relative path (needle) from a 7z archive
134	* (path) and allocate a buf for it to write it in.
135	* If optional_outfile is set, extract to that instead
136	* and don't allocate buffer.
137	*/
138	static int64_t sevenzip_file_read(
139	const char *path,
140	const char needle, void *buf,
141	const char *optional_outfile)
142	{
143	CFileInStream archiveStream;
144	CLookToRead2 lookStream;
145	ISzAlloc allocImp;
146	ISzAlloc allocTempImp;
147	CSzArEx db;
148	uint8_t *output = 0;
149	int64_t outsize = -1;
150
151	/*These are the allocation routines.
152	* Currently using the non-standard 7zip choices. */
153	allocImp.Alloc = sevenzip_stream_alloc_impl;
154	allocImp.Free = sevenzip_stream_free_impl;
155	allocTempImp.Alloc = sevenzip_stream_alloc_tmp_impl;
156	allocTempImp.Free = sevenzip_stream_free_impl;
157
158	lookStream.bufSize = SEVENZIP_LOOKTOREAD_BUF_SIZE * sizeof(Byte);
159	lookStream.buf = (Byte*)malloc(lookStream.bufSize);
160
161	if (!lookStream.buf)
162	lookStream.bufSize = 0;
163
164	#if defined(_WIN32) && defined(USE_WINDOWS_FILE) && !defined(LEGACY_WIN32)
165	if (!string_is_empty(path))
166	{
167	wchar_t *pathW = utf8_to_utf16_string_alloc(path);
168
169	if (pathW)
170	{
171	/* Could not open 7zip archive? */
172	if (InFile_OpenW(&archiveStream.file, pathW))
173	{
174	free(pathW);
175	return -1;
176	}
177
178	free(pathW);
179	}
180	}
181	#else
182	/* Could not open 7zip archive? */
183	if (InFile_Open(&archiveStream.file, path))
184	return -1;
185	#endif
186
187	FileInStream_CreateVTable(&archiveStream);
188	LookToRead2_CreateVTable(&lookStream, false);
189	lookStream.realStream = &archiveStream.vt;
190	LookToRead2_Init(&lookStream);
191	CrcGenerateTable();
192
193	memset(&db, 0, sizeof(db));
194
195	SzArEx_Init(&db);
196
197	if (SzArEx_Open(&db, &lookStream.vt, &allocImp, &allocTempImp) == SZ_OK)
198	{
199	uint32_t i;
200	bool file_found = false;
201	uint16_t *temp = NULL;
202	size_t temp_size = 0;
203	uint32_t block_index = 0xFFFFFFFF;
204	SRes res = SZ_OK;
205
206	for (i = 0; i < db.NumFiles; i++)
207	{
208	size_t len;
209	char infile[PATH_MAX_LENGTH];
210	size_t offset = 0;
211	size_t outSizeProcessed = 0;
212
213	/* We skip over everything which is not a directory.
214	* FIXME: Why continue then if IsDir is true?*/
215	if (SzArEx_IsDir(&db, i))
216	continue;
217
218	len = SzArEx_GetFileNameUtf16(&db, i, NULL);
219
220	if (len > temp_size)
221	{
222	if (temp)
223	free(temp);
224	temp_size = len;
225	temp = (uint16_t )malloc(temp_size sizeof(temp[0]));
226
227	if (temp == 0)
228	{
229	res = SZ_ERROR_MEM;
230	break;
231	}
232	}
233
234	SzArEx_GetFileNameUtf16(&db, i, temp);
235	res = SZ_ERROR_FAIL;
236	infile[0] = '\0';
237
238	if (temp)
239	res = utf16_to_char_string(temp, infile, sizeof(infile))
240	? SZ_OK : SZ_ERROR_FAIL;
241
242	if (string_is_equal(infile, needle))
243	{
244	size_t output_size = 0;
245
246	/* C LZMA SDK does not support chunked extraction - see here:
247	* sourceforge.net/p/sevenzip/discussion/45798/thread/6fb59aaf/
248	* */
249	file_found = true;
250	res = SzArEx_Extract(&db, &lookStream.vt, i, &block_index,
251	&output, &output_size, &offset, &outSizeProcessed,
252	&allocImp, &allocTempImp);
253
254	if (res != SZ_OK)
255	break; /* This goes to the error section. */
256
257	outsize = (int64_t)outSizeProcessed;
258
259	if (optional_outfile)
260	{
261	const void ptr = (const void)(output + offset);
262
263	if (!filestream_write_file(optional_outfile, ptr, outsize))
264	{
265	res = SZ_OK;
266	file_found = true;
267	outsize = -1;
268	}
269	}
270	else
271	{
272	/*We could either use the 7Zip allocated buffer,
273	* or create our own and use it.
274	* We would however need to realloc anyways, because RetroArch
275	* expects a \0 at the end, therefore we allocate new,
276	* copy and free the old one. */
277	*buf = malloc((size_t)(outsize + 1));
278	((char)(buf))[outsize] = '\0';
279	memcpy(*buf,output + offset,outsize);
280	}
281	break;
282	}
283	}
284
285	if (temp)
286	free(temp);
287	IAlloc_Free(&allocImp, output);
288
289	if (!(file_found && res == SZ_OK))
290	{
291	/* Error handling
292	*
293	* Failed to open compressed file inside 7zip archive.
294	*/
295
296	outsize = -1;
297	}
298	}
299
300	SzArEx_Free(&db, &allocImp);
301	File_Close(&archiveStream.file);
302
303	if (lookStream.buf)
304	free(lookStream.buf);
305
306	return outsize;
307	}
308
309	static bool sevenzip_stream_decompress_data_to_file_init(
310	void context, file_archive_file_handle_t handle,
311	const uint8_t *cdata, unsigned cmode, uint32_t csize, uint32_t size)
312	{
313	struct sevenzip_context_t *sevenzip_context =
314	(struct sevenzip_context_t*)context;
315
316	if (!sevenzip_context)
317	return false;
318
319	sevenzip_context->decompress_index = (uint32_t)(size_t)cdata;
320
321	return true;
322	}
323
324	static int sevenzip_stream_decompress_data_to_file_iterate(
325	void context, file_archive_file_handle_t handle)
326	{
327	struct sevenzip_context_t *sevenzip_context =
328	(struct sevenzip_context_t*)context;
329
330	SRes res = SZ_ERROR_FAIL;
331	size_t output_size = 0;
332	size_t offset = 0;
333	size_t outSizeProcessed = 0;
334
335	res = SzArEx_Extract(&sevenzip_context->db,
336	&sevenzip_context->lookStream.vt, sevenzip_context->decompress_index,
337	&sevenzip_context->block_index, &sevenzip_context->output,
338	&output_size, &offset, &outSizeProcessed,
339	&sevenzip_context->allocImp, &sevenzip_context->allocTempImp);
340
341	if (res != SZ_OK)
342	return 0;
343
344	if (handle)
345	handle->data = sevenzip_context->output + offset;
346
347	return 1;
348	}
349
350	static int sevenzip_parse_file_init(file_archive_transfer_t *state,
351	const char *file)
352	{
353	uint8_t magic_buf[SEVENZIP_MAGIC_LEN];
354	struct sevenzip_context_t *sevenzip_context = NULL;
355
356	if (state->archive_size < SEVENZIP_MAGIC_LEN)
357	goto error;
358
359	filestream_seek(state->archive_file, 0, SEEK_SET);
360	if (filestream_read(state->archive_file, magic_buf, SEVENZIP_MAGIC_LEN) != SEVENZIP_MAGIC_LEN)
361	goto error;
362
363	if (string_is_not_equal_fast(magic_buf, SEVENZIP_MAGIC, SEVENZIP_MAGIC_LEN))
364	goto error;
365
366	sevenzip_context = (struct sevenzip_context_t*)sevenzip_stream_new();
367	state->context = sevenzip_context;
368
369	#if defined(_WIN32) && defined(USE_WINDOWS_FILE) && !defined(LEGACY_WIN32)
370	if (!string_is_empty(file))
371	{
372	wchar_t *fileW = utf8_to_utf16_string_alloc(file);
373
374	if (fileW)
375	{
376	/* could not open 7zip archive? */
377	if (InFile_OpenW(&sevenzip_context->archiveStream.file, fileW))
378	{
379	free(fileW);
380	goto error;
381	}
382
383	free(fileW);
384	}
385	}
386	#else
387	/* could not open 7zip archive? */
388	if (InFile_Open(&sevenzip_context->archiveStream.file, file))
389	goto error;
390	#endif
391
392	FileInStream_CreateVTable(&sevenzip_context->archiveStream);
393	LookToRead2_CreateVTable(&sevenzip_context->lookStream, false);
394	sevenzip_context->lookStream.realStream = &sevenzip_context->archiveStream.vt;
395	LookToRead2_Init(&sevenzip_context->lookStream);
396	CrcGenerateTable();
397	SzArEx_Init(&sevenzip_context->db);
398
399	if (SzArEx_Open(&sevenzip_context->db, &sevenzip_context->lookStream.vt,
400	&sevenzip_context->allocImp, &sevenzip_context->allocTempImp) != SZ_OK)
401	goto error;
402
403	state->step_total = sevenzip_context->db.NumFiles;
404
405	return 0;
406
407	error:
408	if (sevenzip_context)
409	sevenzip_parse_file_free(sevenzip_context);
410	return -1;
411	}
412
413	static int sevenzip_parse_file_iterate_step_internal(
414	struct sevenzip_context_t sevenzip_context, char filename,
415	const uint8_t *cdata, unsigned cmode,
416	uint32_t size, uint32_t csize, uint32_t *checksum,
417	unsigned payback, struct archive_extract_userdata userdata)
418	{
419	if (sevenzip_context->parse_index < sevenzip_context->db.NumFiles)
420	{
421	size_t len = SzArEx_GetFileNameUtf16(&sevenzip_context->db,
422	sevenzip_context->parse_index, NULL);
423	uint64_t compressed_size = 0;
424
425	if (sevenzip_context->packIndex < sevenzip_context->db.db.NumPackStreams)
426	{
427	compressed_size = sevenzip_context->db.db.PackPositions[sevenzip_context->packIndex + 1] -
428	sevenzip_context->db.db.PackPositions[sevenzip_context->packIndex];
429
430	sevenzip_context->packIndex++;
431	}
432
433	if (len < PATH_MAX_LENGTH &&
434	!SzArEx_IsDir(&sevenzip_context->db, sevenzip_context->parse_index))
435	{
436	char infile[PATH_MAX_LENGTH];
437	SRes res = SZ_ERROR_FAIL;
438	uint16_t temp = (uint16_t)malloc(len * sizeof(uint16_t));
439
440	if (!temp)
441	return -1;
442
443	infile[0] = '\0';
444
445	SzArEx_GetFileNameUtf16(&sevenzip_context->db, sevenzip_context->parse_index,
446	temp);
447
448	if (temp)
449	{
450	res = utf16_to_char_string(temp, infile, sizeof(infile))
451	? SZ_OK : SZ_ERROR_FAIL;
452	free(temp);
453	}
454
455	if (res != SZ_OK)
456	return -1;
457
458	strlcpy(filename, infile, PATH_MAX_LENGTH);
459
460	cmode = 0; / unused for 7zip */
461	*checksum = sevenzip_context->db.CRCs.Vals[sevenzip_context->parse_index];
462	*size = (uint32_t)SzArEx_GetFileSize(&sevenzip_context->db, sevenzip_context->parse_index);
463	*csize = (uint32_t)compressed_size;
464
465	cdata = (uint8_t )(size_t)sevenzip_context->parse_index;
466	}
467	}
468	else
469	return 0;
470
471	*payback = 1;
472
473	return 1;
474	}
475
476	static int sevenzip_parse_file_iterate_step(void *context,
477	const char *valid_exts,
478	struct archive_extract_userdata *userdata, file_archive_file_cb file_cb)
479	{
480	const uint8_t *cdata = NULL;
481	uint32_t checksum = 0;
482	uint32_t size = 0;
483	uint32_t csize = 0;
484	unsigned cmode = 0;
485	unsigned payload = 0;
486	struct sevenzip_context_t sevenzip_context = (struct sevenzip_context_t)context;
487	int ret;
488
489	userdata->current_file_path[0] = '\0';
490
491	ret = sevenzip_parse_file_iterate_step_internal(sevenzip_context,
492	userdata->current_file_path,
493	&cdata, &cmode, &size, &csize,
494	&checksum, &payload, userdata);
495
496	if (ret != 1)
497	return ret;
498
499	userdata->crc = checksum;
500
501	if (file_cb && !file_cb(userdata->current_file_path, valid_exts,
502	cdata, cmode,
503	csize, size, checksum, userdata))
504	return 0;
505
506	sevenzip_context->parse_index += payload;
507
508	return 1;
509	}
510
511	static uint32_t sevenzip_stream_crc32_calculate(uint32_t crc,
512	const uint8_t *data, size_t length)
513	{
514	return encoding_crc32(crc, data, length);
515	}
516
517	const struct file_archive_file_backend sevenzip_backend = {
518	sevenzip_parse_file_init,
519	sevenzip_parse_file_iterate_step,
520	sevenzip_parse_file_free,
521	sevenzip_stream_decompress_data_to_file_init,
522	sevenzip_stream_decompress_data_to_file_iterate,
523	sevenzip_stream_crc32_calculate,
524	sevenzip_file_read,
525	"7z"
526	};