pkzipvfs.cpp@ 72437

Last change on this file since 72437 was 69111, checked in by vboxsync, 7 years ago
(C) year
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 40.8 KB

Line
1	/* $Id: pkzipvfs.cpp 69111 2017-10-17 14:26:02Z vboxsync $ */
2	/** @file
3	* IPRT - PKZIP Virtual Filesystem.
4	*/
5
6	/*
7	* Copyright (C) 2014-2017 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27
28	/*********************************************************************************************************************************
29	* Header Files *
30	*********************************************************************************************************************************/
31	#include <iprt/zip.h>
32	#include <iprt/assert.h>
33	#include <iprt/err.h>
34	#include <iprt/file.h>
35	#include <iprt/mem.h>
36	#include <iprt/poll.h>
37	#include <iprt/string.h>
38	#include <iprt/vfs.h>
39	#include <iprt/vfslowlevel.h>
40	#include <iprt/stream.h>
41
42
43	/*********************************************************************************************************************************
44	* Structures and Typedefs *
45	*********************************************************************************************************************************/
46	/* See http://www.pkware.com/documents/casestudies/APPNOTE.TXT */
47
48	/**
49	* PKZip Local File Header.
50	*/
51	#pragma pack(1)
52	typedef struct RTZIPPKZIPLOCALFILEHDR
53	{
54	/** Magic value, see RTZIPPKZIPLOCALFILEHDR_MAGIC. */
55	uint32_t u32Magic;
56	/** Minimum version needed to extract. */
57	uint16_t u16Version;
58	/** General purpose bit flag. */
59	uint16_t fFlags;
60	/** Compression method. See RTZIPPKZIP_COMP_METHOD_XXX. */
61	uint16_t u16ComprMethod;
62	/** Last modified time, MS-DOS format: HHHHHMMM MMMSSSSS, multiply seconds by 2 */
63	uint16_t u16LastModifiedTime;
64	/** Last modified date, MS-DOS format: YYYYYYYM MMMDDDDD, year starts at 1980 */
65	uint16_t u16LastModifiedDate;
66	/** Checksum. */
67	uint32_t u32Crc;
68	/** Compressed size. */
69	uint32_t cbCompressed;
70	/** Uncompressed size. */
71	uint32_t cbUncompressed;
72	/** Length of the file name. */
73	uint16_t cbFilename;
74	/** Length of the extra field. */
75	uint16_t cbExtra;
76	/** Start of the file name. */
77	uint8_t u8Filename;
78	} RTZIPPKZIPLOCALFILEHDR;
79	#pragma pack()
80	AssertCompileSize(RTZIPPKZIPLOCALFILEHDR, 30+1);
81	/** Pointer to PKZip Local File Header. */
82	typedef RTZIPPKZIPLOCALFILEHDR *PRTZIPPKZIPLOCALFILEHDR;
83
84	#define RTZIPPKZIPLOCALFILEHDR_MAGIC RT_MAKE_U32_FROM_U8('P','K','\003','\004')
85
86	/**
87	* PKZip compression method.
88	*/
89	typedef enum RTZIPPKZIP_COMP_METHOD
90	{
91	/** No compression */
92	RTZIPPKZIP_COMP_METHOD_STORED = 0,
93	/** Shrunk */
94	RTZIPPKZIP_COMP_METHOD_SHRUNK = 1,
95	/** Reduced with compression factor 1 */
96	RTZIPPKZIP_COMP_METHOD_REDUCED1 = 2,
97	/** Reduced with compression factor 2 */
98	RTZIPPKZIP_COMP_METHOD_REDUCED2 = 3,
99	/** Reduced with compression factor 3 */
100	RTZIPPKZIP_COMP_METHOD_REDUCED3 = 4,
101	/** Reduced with compression factor 4 */
102	RTZIPPKZIP_COMP_METHOD_REDUCED4 = 5,
103	/** Imploded */
104	RTZIPPKZIP_COMP_METHOD_IMPLODED = 6,
105	/** Deflated */
106	RTZIPPKZIP_COMP_METHOD_DEFLATED = 8,
107	/** Deflated64 */
108	RTZIPPKZIP_COMP_METHOD_DEFLATED64 = 9,
109	/* Compressed using bzip2 */
110	RTZIPPKZIP_COMP_METHOD_BZIP2 = 12,
111	/** Compressed using LZMA */
112	RTZIPPKZIP_COMP_METHOD_LZMA = 14
113	} RTZIPPKZIP_COMP_METHOD;
114
115	/**
116	* PKZip Central Directory Header.
117	*/
118	#pragma pack(1)
119	typedef struct RTZIPPKZIPCENTRDIRHDR
120	{
121	/** The magic value. See RTZIPPKZIPCENTRDIRHDR_MAGIC. */
122	uint32_t u32Magic;
123	/** The version used for creating the item. */
124	uint16_t u16VerMade;
125	/** The minimum version required for extracting the item. */
126	uint16_t u16VerRequired;
127	/** General purpose flags. */
128	uint16_t fFlags;
129	/** Compresstion method. See RTZIPPKZIP_COMP_METHOD_XXX */
130	uint16_t u16ComprMethod;
131	/** Last modified time, MS-DOS format: HHHHHMMM MMMSSSSS, multiply seconds by 2 */
132	uint16_t u16LastModifiedTime;
133	/** Last modified date, MS-DOS format: YYYYYYYM MMMDDDDD, year starts at 1980 */
134	uint16_t u16LastModifiedDate;
135	/** Checksum. */
136	uint32_t u32Crc;
137	/** Compressed size. */
138	uint32_t cbCompressed;
139	/** Uncompressed size. */
140	uint32_t cbUncompressed;
141	/** Length of the object file name. */
142	uint16_t cbFilename;
143	/** Length of the extra field. */
144	uint16_t cbExtra;
145	/** Length of the object comment. */
146	uint16_t cbComment;
147	/** The number of the disk on which this file begins. */
148	uint16_t iDiskStart;
149	/** Internal attributes. */
150	uint16_t u16IntAttrib;
151	/** External attributes. */
152	uint32_t u32ExtAttrib;
153	/** Offset from the start of the first disk on which this file appears to
154	* where the local file header should be found. */
155	uint32_t offLocalFileHeader;
156	/** Start of the file name. */
157	uint8_t u8Filename;
158	} RTZIPPKZIPCENTRDIRHDR;
159	#pragma pack()
160	AssertCompileSize(RTZIPPKZIPCENTRDIRHDR, 46+1);
161	/** Pointer to the PKZip Central Directory Header. */
162	typedef RTZIPPKZIPCENTRDIRHDR *PRTZIPPKZIPCENTRDIRHDR;
163
164	#define RTZIPPKZIPCENTRDIRHDR_MAGIC RT_MAKE_U32_FROM_U8('P','K','\001','\002')
165
166	/**
167	* PKZip End of Central Directory Record.
168	*/
169	#pragma pack(1)
170	typedef struct RTZIPPKZIPENDOFCENTRDIRREC
171	{
172	/** The magic value. See RTZIPPKZIPENDOFCENTRDIRREC_MAGIC. */
173	uint32_t u32Magic;
174	/** Number of this disk. */
175	uint16_t iThisDisk;
176	/** Number of the disk with the start of the Central Directory. */
177	uint16_t iDiskStartCentrDirectory;
178	/** Number of Central Directory entries on this disk. */
179	uint16_t cCentrDirRecordsThisDisk;
180	/** Number of Central Directory records. */
181	uint16_t cCentrDirRecords;
182	/** Size of the Central Directory in bytes. */
183	uint32_t cbCentrDir;
184	/** Offset of the Central Directory. */
185	uint32_t offCentrDir;
186	/** Size of the comment in bytes. */
187	uint16_t cbComment;
188	/** Start of the comment. */
189	uint8_t u8Comment;
190	} RTZIPPKZIPENDOFCENTRDIRREC;
191	#pragma pack()
192	AssertCompileSize(RTZIPPKZIPENDOFCENTRDIRREC, 22+1);
193	/** Pointer to the PKZip End of Central Directory Record. */
194	typedef RTZIPPKZIPENDOFCENTRDIRREC const *PCRTZIPPKZIPENDOFCENTRDIRREC;
195
196	#define RTZIPPKZIPENDOFCENTRDIRREC_MAGIC RT_MAKE_U32_FROM_U8('P','K','\005','\006')
197
198	/**
199	* PKZip ZIP64 End of Central Directory Record.
200	*/
201	#pragma pack(1)
202	typedef struct RTZIPPKZIP64ENDOFCENTRDIRREC
203	{
204	/** The magic value. See RTZIPPKZIP64ENDOFCENTRDIRREC_MAGIC. */
205	uint32_t u32Magic;
206	/** Size of Zip64 end of Central Directory Record. */
207	uint64_t cbSizeEocdr;
208	/** The version used for creating the item. */
209	uint16_t u16VerMade;
210	/** The minimum version required for extracting the item. */
211	uint16_t u16VerRequired;
212	/** Number of this disk. */
213	uint32_t iThisDisk;
214	/** Number of the disk with the start of the Central Directory. */
215	uint32_t iDiskStartCentrDirectory;
216	/** Number of Central Directory entries on this disk. */
217	uint64_t cCentrDirRecordsThisDisk;
218	/** Number of Central Directory records. */
219	uint64_t cCentrDirRecords;
220	/** Size of the Central Directory in bytes. */
221	uint64_t cbCentrDir;
222	/** Offset of the Central Directory. */
223	uint64_t offCentrDir;
224	} RTZIPPKZIP64ENDOFCENTRDIRREC;
225	#pragma pack()
226	AssertCompileSize(RTZIPPKZIP64ENDOFCENTRDIRREC, 56);
227	/** Pointer to the 64-bit PKZip End of Central Directory Record. */
228	typedef RTZIPPKZIP64ENDOFCENTRDIRREC *PRTZIPPKZIP64ENDOFCENTRDIRREC;
229
230	#define RTZIPPKZIP64ENDOFCENTRDIRREC_MAGIC RT_MAKE_U32_FROM_U8('P','K','\006','\006')
231
232	/**
233	* PKZip ZIP64 End of Central Directory Locator.
234	*/
235	#pragma pack(1)
236	typedef struct RTZIPPKZIP64ENDOFCENTRDIRLOC
237	{
238	/** The magic value. See RTZIPPKZIP64ENDOFCENTRDIRLOC_MAGIC. */
239	uint32_t u32Magic;
240	/** Number of the disk with the start of the ZIP64 End of Central Directory. */
241	uint32_t iDiskStartCentrDir;
242	/** Relative offset of the ZIP64 End of Central Directory Record. */
243	uint64_t offEndOfCentrDirRec;
244	/** Total number of disks. */
245	uint32_t cDisks;
246	} RTZIPPKZIP64ENDOFCENTRDIRLOC;
247	#pragma pack()
248	AssertCompileSize(RTZIPPKZIP64ENDOFCENTRDIRLOC, 20);
249
250	#define RTZIPPKZIP64ENDOFCENTRDIRLOC_MAGIC RT_MAKE_U32_FROM_U8('P','K','\006','\007')
251
252	/**
253	* PKZip ZIP64 Extended Information Extra Field.
254	*/
255	#pragma pack(1)
256	typedef struct RTZIPPKZIP64EXTRAFIELD
257	{
258	/** Uncompressed size. */
259	uint64_t cbUncompressed;
260	/** Compressed size. */
261	uint64_t cbCompressed;
262	/** Offset from the start of the first disk on which this file appears to
263	* where the local file header should be found. */
264	uint64_t offLocalFileHeader;
265	/** The number of the disk on which this file begins. */
266	uint32_t iDiskStart;
267	} RTZIPPKZIP64EXTRAFIELD;
268	#pragma pack()
269	/** Pointer to the ZIP64 Extended Information Extra Field. */
270	typedef RTZIPPKZIP64EXTRAFIELD *PRTZIPPKZIP64EXTRAFIELD;
271	AssertCompileSize(RTZIPPKZIP64EXTRAFIELD, 28);
272
273	/**
274	* PKZip reader instance data.
275	*/
276	typedef struct RTZIPPKZIPREADER
277	{
278	/** Set if we have the End of Central Directory record. */
279	bool fHaveEocd;
280	/** The Central Directory header. */
281	RTZIPPKZIPCENTRDIRHDR cdh;
282	/** ZIP64 extended information. */
283	RTZIPPKZIP64EXTRAFIELD cd64ex;
284	/** Set if ZIP64 End of Central Directory Locator is present (archive setting). */
285	bool fZip64Eocd;
286	/** Set if cd64ex is valid for the current file header (object setting). */
287	bool fZip64Ex;
288	/* The name of the current object. */
289	char szName[RTPATH_MAX];
290	} RTZIPPKZIPREADER;
291	/** Pointer to the PKZip reader instance data. */
292	typedef RTZIPPKZIPREADER *PRTZIPPKZIPREADER;
293
294	/**
295	* Pkzip object (directory).
296	*/
297	typedef struct RTZIPPKZIPBASEOBJ
298	{
299	/** Pointer to the reader instance data (resides in the filesystem
300	* stream). */
301	PRTZIPPKZIPREADER pPkzipReader;
302	/** The object info with unix attributes. */
303	RTFSOBJINFO ObjInfo;
304	} RTZIPPKZIPBASEOBJ;
305	/** Pointer to a PKZIP filesystem stream base object. */
306	typedef RTZIPPKZIPBASEOBJ *PRTZIPPKZIPBASEOBJ;
307
308	/**
309	* Pkzip object (file) represented as a VFS I/O stream.
310	*/
311	typedef struct RTZIPPKZIPIOSTREAM
312	{
313	/** The basic PKZIP object data. */
314	RTZIPPKZIPBASEOBJ BaseObj;
315	/** The number of (uncompressed) bytes in the file. */
316	uint64_t cbFile;
317	/** The current file position at uncompressed file data. */
318	uint64_t offFile;
319	/** The start position of the compressed data in the hVfsIos. */
320	uint64_t offCompStart;
321	/** The current position for decompressing bytes in the hVfsIos. */
322	uint64_t offComp;
323	/** The number of compressed bytes starting at offCompStart. */
324	uint64_t cbComp;
325	/** Set if we have to pass the type function the next time the input
326	* function is called. */
327	bool fPassZipType;
328	/** Set if we've reached the end of the file. */
329	bool fEndOfStream;
330	/** Pkzip compression method for this object. */
331	RTZIPPKZIP_COMP_METHOD enmCompMethod;
332	/** Zip compression method. */
333	RTZIPTYPE enmZipType;
334	/** The decompressor instance. */
335	PRTZIPDECOMP pZip;
336	/** The input I/O stream. */
337	RTVFSIOSTREAM hVfsIos;
338	} RTZIPPKZIPIOSTREAM;
339	/** Pointer to a the private data of a PKZIP file I/O stream. */
340	typedef RTZIPPKZIPIOSTREAM *PRTZIPPKZIPIOSTREAM;
341
342
343	/**
344	* PKZip filesystem stream private data. The stream must be seekable!
345	*/
346	typedef struct RTZIPPKZIPFSSTREAM
347	{
348	/** The input I/O stream. */
349	RTVFSIOSTREAM hVfsIos;
350
351	/** The current object (referenced). */
352	RTVFSOBJ hVfsCurObj;
353	/** Pointer to the private data if hVfsCurObj is representing a file. */
354	PRTZIPPKZIPIOSTREAM pCurIosData;
355
356	/** The offset of the first Central Directory header. */
357	uint64_t offFirstCdh;
358	/** The offset of the next Central Directory header. */
359	uint64_t offNextCdh;
360
361	/** Size of the central directory. */
362	uint64_t cbCentrDir;
363	/** Current central directory entry. */
364	uint64_t iCentrDirEntry;
365	/** Number of central directory entries. */
366	uint64_t cCentrDirEntries;
367
368	/** Set if we have the End of Central Directory Record. */
369	bool fHaveEocd;
370	/** Set if we've reached the end of the stream. */
371	bool fEndOfStream;
372	/** Set if we've encountered a fatal error. */
373	int rcFatal;
374
375	/** The PKZIP reader instance data. */
376	RTZIPPKZIPREADER PkzipReader;
377	} RTZIPPKZIPFSSTREAM;
378	/** Pointer to a the private data of a PKZIP filesystem stream. */
379	typedef RTZIPPKZIPFSSTREAM *PRTZIPPKZIPFSSTREAM;
380
381
382
383	/**
384	* Decode date/time from DOS format as used in PKZip.
385	*/
386	static int rtZipPkzipReaderDecodeDosTime(PRTTIMESPEC pTimeSpec, uint16_t u16Time, uint16_t u16Date)
387	{
388	RTTIME time;
389	RT_ZERO(time);
390	time.i32Year = ((u16Date & 0xfe00) >> 9) + 1980;
391	time.u8Month = (u16Date & 0x01e0) >> 5;
392	time.u8MonthDay = u16Date & 0x001f;
393	time.u8Hour = (u16Time & 0xf800) >> 11;
394	time.u8Minute = (u16Time & 0x07e0) >> 5;
395	time.u8Second = u16Time & 0x001f;
396	RTTimeNormalize(&time);
397	RTTimeImplode(pTimeSpec, &time);
398	return VINF_SUCCESS;
399	}
400
401
402	/**
403	* Parse the Local File Header.
404	* Just skip the data as we trust the Central Directory.
405	*/
406	static int rtZipPkzipParseLocalFileHeader(PRTZIPPKZIPREADER pThis, PRTZIPPKZIPLOCALFILEHDR pLfh, size_t *pcbExtra)
407	{
408	RT_NOREF_PV(pThis);
409
410	if (pLfh->cbFilename >= sizeof(pThis->szName))
411	return VERR_PKZIP_NAME_TOO_LONG;
412
413	*pcbExtra = pLfh->cbFilename + pLfh->cbExtra;
414	return VINF_SUCCESS;
415	}
416
417
418	/**
419	* Parse the Central Directory Header.
420	*/
421	static int rtZipPkzipParseCentrDirHeader(PRTZIPPKZIPREADER pThis, PRTZIPPKZIPCENTRDIRHDR pCdh, size_t *pcbExtra)
422	{
423	if (pCdh->u32Magic != RTZIPPKZIPCENTRDIRHDR_MAGIC)
424	return VERR_PKZIP_BAD_CDF_HEADER;
425
426	if (pCdh->cbFilename >= sizeof(pThis->szName))
427	return VERR_PKZIP_NAME_TOO_LONG;
428
429	*pcbExtra = pCdh->cbFilename + pCdh->cbExtra + pCdh->cbComment;
430
431	pThis->cdh = *pCdh;
432	pThis->fZip64Ex = false;
433	return VINF_SUCCESS;
434	}
435
436
437	/**
438	* Return the offset of the Local File Header.
439	*/
440	static uint64_t rtZipPkzipReaderOffLocalHeader(PRTZIPPKZIPREADER pThis)
441	{
442	if (pThis->fZip64Ex && pThis->cdh.offLocalFileHeader == (uint32_t)-1)
443	return pThis->cd64ex.offLocalFileHeader;
444
445	return pThis->cdh.offLocalFileHeader;
446	}
447
448
449	/**
450	* Return the uncompressed object size.
451	*/
452	static uint64_t rtZipPkzipReaderUncompressed(PRTZIPPKZIPREADER pThis)
453	{
454	if (pThis->fZip64Ex && pThis->cdh.cbUncompressed == (uint32_t)-1)
455	return pThis->cd64ex.cbUncompressed;
456
457	return pThis->cdh.cbUncompressed;
458	}
459
460
461	/**
462	* Return the compressed object size.
463	*/
464	static uint64_t rtZipPkzipReaderCompressed(PRTZIPPKZIPREADER pThis)
465	{
466	if (pThis->fZip64Ex && pThis->cdh.cbCompressed == (uint32_t)-1)
467	return pThis->cd64ex.cbCompressed;
468
469	return pThis->cdh.cbCompressed;
470	}
471
472
473	/**
474	* Parse the extra part of the Central Directory Header.
475	*/
476	static int rtZipPkzipParseCentrDirHeaderExtra(PRTZIPPKZIPREADER pThis, uint8_t *pu8Buf, size_t cb,
477	RTZIPPKZIP_COMP_METHOD penmCompMethod, uint64_t pcbCompressed)
478	{
479	int rc = RTStrCopyEx(pThis->szName, sizeof(pThis->szName), (const char*)pu8Buf, pThis->cdh.cbFilename);
480	if (RT_SUCCESS(rc))
481	{
482	pu8Buf += pThis->cdh.cbFilename;
483	cb = pThis->cdh.cbExtra;
484	while (cb >= 4)
485	{
486	uint16_t idExtra = (uint16_t)pu8Buf;
487	pu8Buf += 2;
488	uint16_t cbExtra = (uint16_t)pu8Buf;
489	pu8Buf += 2;
490	cb -= 4;
491
492	if (cb >= cbExtra)
493	{
494	switch (idExtra)
495	{
496	case 0x0001:
497	/*
498	* ZIP64 Extended Information Extra Field.
499	*/
500	if (!pThis->fZip64Eocd)
501	return VERR_PKZIP_ZIP64EX_IN_ZIP32;
502	/* Not all fields are really used. */
503	RT_ZERO(pThis->cd64ex);
504	memcpy(&pThis->cd64ex, pu8Buf, cbExtra);
505	pThis->fZip64Ex = true;
506	break;
507
508	default:
509	/* unknown, just skip */
510	break;
511	}
512	pu8Buf += cbExtra;
513	cb -= cbExtra;
514	}
515	else
516	{
517	rc = VERR_PKZIP_BAD_CDF_HEADER;
518	break;
519	}
520	}
521
522	*penmCompMethod = (RTZIPPKZIP_COMP_METHOD)pThis->cdh.u16ComprMethod;
523	*pcbCompressed = rtZipPkzipReaderCompressed(pThis);
524	}
525	return VINF_SUCCESS;
526	}
527
528
529	/**
530	* Translate a PKZip header to an IPRT object info structure.
531	*/
532	static int rtZipPkzipReaderGetFsObjInfo(PRTZIPPKZIPREADER pThis, PRTFSOBJINFO pObjInfo)
533	{
534	/*
535	* Zap the whole structure, this takes care of unused space in the union.
536	*/
537	RT_ZERO(*pObjInfo);
538	pObjInfo->cbObject = rtZipPkzipReaderUncompressed(pThis);
539	pObjInfo->cbAllocated = rtZipPkzipReaderUncompressed(pThis); /* XXX */
540	RTTIMESPEC ts;
541	rtZipPkzipReaderDecodeDosTime(&ts, pThis->cdh.u16LastModifiedTime, pThis->cdh.u16LastModifiedDate);
542	pObjInfo->ChangeTime = ts;
543	pObjInfo->ModificationTime = ts;
544	pObjInfo->AccessTime = ts;
545	pObjInfo->BirthTime = ts;
546	const char *pszEnd = strchr(pThis->szName, '\0');
547	if (pszEnd == &pThis->szName[0] \|\| pszEnd[-1] != '/')
548	pObjInfo->Attr.fMode = RTFS_TYPE_FILE \
549	\| RTFS_UNIX_IRUSR \| RTFS_UNIX_IWUSR \
550	\| RTFS_UNIX_IRGRP \
551	\| RTFS_UNIX_IROTH;
552	else
553	pObjInfo->Attr.fMode = RTFS_TYPE_DIRECTORY \
554	\| RTFS_UNIX_IRWXU \
555	\| RTFS_UNIX_IRGRP \| RTFS_UNIX_IXGRP \
556	\| RTFS_UNIX_IROTH \| RTFS_UNIX_IXOTH;
557	pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX;
558	pObjInfo->Attr.u.Unix.cHardlinks = 1;
559
560	return VINF_SUCCESS;
561	}
562
563
564	/**
565	* Search the magic value of the End Of Central Directory Record.
566	*
567	* @returns true if found, false otherwise.
568	* @param pu8Buf buffer.
569	* @param cb size of buffer.
570	* @param piPos where to store the position of the magic value.
571	*/
572	static bool rtZipPkzipReaderScanEocd(const uint8_t pu8Buf, size_t cb, int piPos)
573	{
574	if (cb < 4)
575	return false;
576	ssize_t i;
577	for (i = (ssize_t)cb - 4; i >= 0; --i)
578	if ((uint32_t)(pu8Buf + i) == RTZIPPKZIPENDOFCENTRDIRREC_MAGIC)
579	{
580	*piPos = i;
581	return true;
582	}
583	return false;
584	}
585
586
587	/**
588	* Read the Local File Header. We ignore the content -- we trust the Central
589	* Directory.
590	*/
591	static int rtZipPkzipFssIosReadLfh(PRTZIPPKZIPFSSTREAM pThis, uint64_t *poffStartData)
592	{
593	RTZIPPKZIPLOCALFILEHDR lfh;
594	uint64_t offLocalFileHeader = rtZipPkzipReaderOffLocalHeader(&pThis->PkzipReader);
595	int rc = RTVfsIoStrmReadAt(pThis->hVfsIos, offLocalFileHeader,
596	&lfh, sizeof(lfh) - 1, true /fBlocking/, NULL);
597	if (RT_SUCCESS(rc))
598	{
599	if (lfh.u32Magic == RTZIPPKZIPLOCALFILEHDR_MAGIC)
600	{
601	size_t cbExtra = 0;
602	rc = rtZipPkzipParseLocalFileHeader(&pThis->PkzipReader, &lfh, &cbExtra);
603	if (RT_SUCCESS(rc))
604	{
605	/* Just skip the file name and and extra field. We use the data
606	* from the Central Directory Header. */
607	rc = RTVfsIoStrmSkip(pThis->hVfsIos, cbExtra);
608	if (RT_SUCCESS(rc))
609	*poffStartData = offLocalFileHeader + sizeof(lfh) - 1 + cbExtra;
610	}
611	}
612	else
613	rc = VERR_PKZIP_BAD_LF_HEADER;
614	}
615
616	return rc;
617	}
618
619
620	/**
621	* Scan the current Central Directory Header.
622	*/
623	static int rtZipPkzipFssIosReadCdh(PRTZIPPKZIPFSSTREAM pThis, uint64_t *poffStartData,
624	RTZIPPKZIP_COMP_METHOD penmCompMethod, uint64_t pcbCompressed)
625	{
626	int rc;
627
628	uint64_t offCd = pThis->offNextCdh - pThis->offFirstCdh;
629	if ( pThis->iCentrDirEntry < pThis->cCentrDirEntries
630	\|\| offCd + sizeof(RTZIPPKZIPCENTRDIRHDR) - 1 <= pThis->cbCentrDir)
631	{
632	RTZIPPKZIPCENTRDIRHDR cdh;
633	rc = RTVfsIoStrmReadAt(pThis->hVfsIos, pThis->offNextCdh,
634	&cdh, sizeof(cdh) - 1, true /fBlocking/, NULL);
635	if (RT_SUCCESS(rc))
636	{
637	pThis->offNextCdh += sizeof(cdh) - 1;
638	pThis->iCentrDirEntry++;
639	size_t cbExtra = 0;
640	rc = rtZipPkzipParseCentrDirHeader(&pThis->PkzipReader, &cdh, &cbExtra);
641	if (RT_SUCCESS(rc))
642	{
643	if (offCd + sizeof(RTZIPPKZIPCENTRDIRHDR) - 1 + cbExtra <= pThis->cbCentrDir)
644	{
645	/* extra data up to 64k */
646	uint8_t pu8Buf = (uint8_t)RTMemTmpAlloc(cbExtra);
647	if (pu8Buf)
648	{
649	rc = RTVfsIoStrmRead(pThis->hVfsIos, pu8Buf, cbExtra, true /fBlocking/, NULL);
650	if (RT_SUCCESS(rc))
651	{
652	rc = rtZipPkzipParseCentrDirHeaderExtra(&pThis->PkzipReader, pu8Buf, cbExtra,
653	penmCompMethod, pcbCompressed);
654	if (RT_SUCCESS(rc))
655	rc = rtZipPkzipFssIosReadLfh(pThis, poffStartData);
656	}
657	pThis->offNextCdh += cbExtra;
658	RTMemTmpFree(pu8Buf);
659	}
660	else
661	rc = VERR_NO_MEMORY;
662	}
663	else
664	rc = VERR_EOF;
665	}
666	}
667	}
668	else
669	rc = VERR_EOF;
670
671	return rc;
672	}
673
674
675	/**
676	* Scan for the End of Central Directory Record. Of course this works not if
677	* the stream is non-seekable (i.e. a pipe).
678	*/
679	static int rtZipPkzipFssIosReadEocb(PRTZIPPKZIPFSSTREAM pThis)
680	{
681	RTFSOBJINFO Info;
682	int rc = RTVfsIoStrmQueryInfo(pThis->hVfsIos, &Info, RTFSOBJATTRADD_UNIX);
683	if (RT_FAILURE(rc))
684	return rc;
685
686	uint64_t cbFile = Info.cbObject;
687	if (cbFile < sizeof(RTZIPPKZIPENDOFCENTRDIRREC)-1)
688	return VERR_PKZIP_NO_EOCB;
689
690	/* search for start of the 'end of Central Directory Record' */
691	size_t cbBuf = RT_MIN(_1K, cbFile);
692	uint8_t pu8Buf = (uint8_t)RTMemTmpAlloc(cbBuf);
693	if (!pu8Buf)
694	return VERR_NO_MEMORY;
695
696	/* maximum size of EOCD comment 2^16-1 */
697	const size_t cbHdrMax = 0xffff + sizeof(RTZIPPKZIPENDOFCENTRDIRREC) - 1;
698	uint64_t offMin = cbFile >= cbHdrMax ? cbFile - cbHdrMax : 0;
699
700	uint64_t off = cbFile - cbBuf;
701	while (off >= offMin)
702	{
703	rc = RTVfsIoStrmReadAt(pThis->hVfsIos, off, pu8Buf, cbBuf, true /fBlocking/, NULL);
704	if (RT_FAILURE(rc))
705	break;
706	int offMagic;
707	if (rtZipPkzipReaderScanEocd(pu8Buf, cbBuf, &offMagic))
708	{
709	off += offMagic;
710	RTZIPPKZIPENDOFCENTRDIRREC eocd;
711	rc = RTVfsIoStrmReadAt(pThis->hVfsIos, off, &eocd, sizeof(eocd) - 1,
712	true /fBlocking/, NULL);
713	if (RT_SUCCESS(rc))
714	{
715	/* well, this shouldn't fail if the content didn't change */
716	if (eocd.u32Magic == RTZIPPKZIPENDOFCENTRDIRREC_MAGIC)
717	{
718	/* sanity check */
719	if (off + RT_OFFSETOF(RTZIPPKZIPENDOFCENTRDIRREC, u8Comment) + eocd.cbComment == cbFile)
720	{
721	pThis->offFirstCdh = eocd.offCentrDir;
722	pThis->offNextCdh = eocd.offCentrDir;
723	pThis->iCentrDirEntry = 0;
724	pThis->cCentrDirEntries = eocd.cCentrDirRecords;
725	pThis->cbCentrDir = eocd.cbCentrDir;
726	pThis->PkzipReader.fHaveEocd = true;
727	}
728	else
729	rc = VERR_PKZIP_NO_EOCB;
730	}
731	else
732	rc = VERR_PKZIP_NO_EOCB;
733	}
734	if (rc != VERR_PKZIP_NO_EOCB)
735	break;
736	}
737	else
738	rc = VERR_PKZIP_NO_EOCB;
739	/* overlap the following read */
740	off -= cbBuf - 4;
741	}
742
743	RTMemTmpFree(pu8Buf);
744
745	/*
746	* Now check for the presence of the Zip64 End of Central Directory Locator.
747	*/
748	if ( RT_SUCCESS(rc)
749	&& off > (unsigned)sizeof(RTZIPPKZIP64ENDOFCENTRDIRLOC))
750	{
751	off -= sizeof(RTZIPPKZIP64ENDOFCENTRDIRLOC);
752
753	RTZIPPKZIP64ENDOFCENTRDIRLOC eocd64loc;
754	rc = RTVfsIoStrmReadAt(pThis->hVfsIos, off, &eocd64loc, sizeof(eocd64loc), true /fBlocking/, NULL);
755	if (RT_SUCCESS(rc))
756	{
757	if (eocd64loc.u32Magic == RTZIPPKZIP64ENDOFCENTRDIRLOC_MAGIC)
758	pThis->PkzipReader.fZip64Eocd = true;
759	}
760	}
761	return rc;
762	}
763
764
765	/**
766	* @interface_method_impl{RTVFSOBJOPS,pfnClose}
767	*/
768	static DECLCALLBACK(int) rtZipPkzipFssBaseObj_Close(void *pvThis)
769	{
770	NOREF(pvThis);
771	return VINF_SUCCESS;
772	}
773
774
775	/**
776	* @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
777	*/
778	static DECLCALLBACK(int) rtZipPkzipFssBaseObj_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
779	{
780	PRTZIPPKZIPBASEOBJ pThis = (PRTZIPPKZIPBASEOBJ)pvThis;
781
782	/*
783	* Copy the desired data.
784	*/
785	switch (enmAddAttr)
786	{
787	case RTFSOBJATTRADD_NOTHING:
788	case RTFSOBJATTRADD_UNIX:
789	*pObjInfo = pThis->ObjInfo;
790	break;
791
792	case RTFSOBJATTRADD_UNIX_OWNER:
793	*pObjInfo = pThis->ObjInfo;
794	break;
795
796	case RTFSOBJATTRADD_UNIX_GROUP:
797	*pObjInfo = pThis->ObjInfo;
798	break;
799
800	case RTFSOBJATTRADD_EASIZE:
801	*pObjInfo = pThis->ObjInfo;
802	break;
803
804	default:
805	return VERR_NOT_SUPPORTED;
806	}
807
808	return VINF_SUCCESS;
809	}
810
811
812	/**
813	* PKZip filesystem base object operations (directory objects).
814	*/
815	static const RTVFSOBJOPS g_rtZipPkzipFssBaseObjOps =
816	{
817	RTVFSOBJOPS_VERSION,
818	RTVFSOBJTYPE_BASE,
819	"PkzipFsStream::Obj",
820	rtZipPkzipFssBaseObj_Close,
821	rtZipPkzipFssBaseObj_QueryInfo,
822	RTVFSOBJOPS_VERSION
823	};
824
825
826	/**
827	* @interface_method_impl{RTVFSOBJOPS,pfnClose}
828	*/
829	static DECLCALLBACK(int) rtZipPkzipFssIos_Close(void *pvThis)
830	{
831	PRTZIPPKZIPIOSTREAM pThis = (PRTZIPPKZIPIOSTREAM)pvThis;
832
833	RTVfsIoStrmRelease(pThis->hVfsIos);
834	pThis->hVfsIos = NIL_RTVFSIOSTREAM;
835
836	if (pThis->pZip)
837	{
838	RTZipDecompDestroy(pThis->pZip);
839	pThis->pZip = NULL;
840	}
841
842	return rtZipPkzipFssBaseObj_Close(&pThis->BaseObj);
843	}
844
845
846	/**
847	* @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
848	*/
849	static DECLCALLBACK(int) rtZipPkzipFssIos_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
850	{
851	PRTZIPPKZIPIOSTREAM pThis = (PRTZIPPKZIPIOSTREAM)pvThis;
852	return rtZipPkzipFssBaseObj_QueryInfo(&pThis->BaseObj, pObjInfo, enmAddAttr);
853	}
854
855
856	/**
857	* Callback function for rtZipPkzipFssIos_Read. For feeding compressed data
858	* into the decompressor function.
859	*/
860	static DECLCALLBACK(int) rtZipPkzipFssIosReadHelper(void pvThis, void pvBuf, size_t cbToRead, size_t *pcbRead)
861	{
862	PRTZIPPKZIPIOSTREAM pThis = (PRTZIPPKZIPIOSTREAM)pvThis;
863	int rc = VINF_SUCCESS;
864	if (!cbToRead)
865	return rc;
866	if ( pThis->fPassZipType
867	&& cbToRead > 0)
868	{
869	uint8_t pu8Buf = (uint8_t)pvBuf;
870	pu8Buf[0] = pThis->enmZipType;
871	pvBuf = &pu8Buf[1];
872	cbToRead--;
873	pThis->fPassZipType = false;
874	}
875	if (cbToRead > 0)
876	{
877	size_t cbRead = 0;
878	const size_t cbAvail = pThis->cbComp;
879	rc = RTVfsIoStrmReadAt(pThis->hVfsIos, pThis->offComp, pvBuf,
880	RT_MIN(cbToRead, cbAvail), true /fBlocking/, &cbRead);
881	if ( RT_SUCCESS(rc)
882	&& cbToRead > cbAvail)
883	rc = pcbRead ? VINF_EOF : VERR_EOF;
884	if ( rc == VINF_EOF
885	&& !pcbRead)
886	rc = VERR_EOF;
887	pThis->offComp += cbRead;
888	if (pcbRead)
889	*pcbRead = cbRead;
890	}
891	return rc;
892	}
893
894
895	/**
896	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead}
897	*/
898	static DECLCALLBACK(int) rtZipPkzipFssIos_Read(void pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t pcbRead)
899	{
900	PRTZIPPKZIPIOSTREAM pThis = (PRTZIPPKZIPIOSTREAM)pvThis;
901	Assert(pSgBuf->cSegs == 1);
902	RT_NOREF_PV(fBlocking);
903
904	if (off < 0)
905	off = pThis->offFile;
906	if (off >= (RTFOFF)pThis->cbFile)
907	return pcbRead ? VINF_EOF : VERR_EOF;
908
909	Assert(pThis->cbFile >= pThis->offFile);
910	uint64_t cbLeft = (uint64_t)(pThis->cbFile - pThis->offFile);
911	size_t cbToRead = pSgBuf->paSegs[0].cbSeg;
912	if (cbToRead > cbLeft)
913	{
914	if (!pcbRead)
915	return VERR_EOF;
916	cbToRead = (size_t)cbLeft;
917	}
918
919	/*
920	* Restart decompression at start of stream or on backward seeking.
921	*/
922	if ( !pThis->pZip
923	\|\| !off
924	\|\| off < (RTFOFF)pThis->offFile)
925	{
926	switch (pThis->enmCompMethod)
927	{
928	case RTZIPPKZIP_COMP_METHOD_STORED:
929	pThis->enmZipType = RTZIPTYPE_STORE;
930	break;
931
932	case RTZIPPKZIP_COMP_METHOD_DEFLATED:
933	pThis->enmZipType = RTZIPTYPE_ZLIB_NO_HEADER;
934	break;
935
936	default:
937	pThis->enmZipType = RTZIPTYPE_INVALID;
938	break;
939	}
940
941	if (pThis->pZip)
942	{
943	RTZipDecompDestroy(pThis->pZip);
944	pThis->pZip = NULL;
945	}
946	int rc = RTZipDecompCreate(&pThis->pZip, (void*)pThis, rtZipPkzipFssIosReadHelper);
947	if (RT_FAILURE(rc))
948	return rc;
949	}
950
951	/*
952	* Skip bytes if necessary.
953	*/
954	if (off > (RTFOFF)pThis->offFile)
955	{
956	uint8_t u8Buf[_1K];
957	while (off > (RTFOFF)pThis->offFile)
958	{
959	size_t cbSkip = off - pThis->offFile;
960	if (cbSkip > sizeof(u8Buf))
961	cbSkip = sizeof(u8Buf);
962	int rc = RTZipDecompress(pThis->pZip, u8Buf, cbSkip, NULL);
963	if (RT_FAILURE(rc))
964	return rc;
965	pThis->offFile += cbSkip;
966	}
967	}
968
969	/*
970	* Do the actual reading.
971	*/
972	size_t cbReadStack = 0;
973	if (!pcbRead)
974	pcbRead = &cbReadStack;
975	int rc = RTZipDecompress(pThis->pZip, pSgBuf->paSegs[0].pvSeg, cbToRead, pcbRead);
976	pThis->offFile = off + *pcbRead;
977	if (pThis->offFile >= pThis->cbFile)
978	{
979	Assert(pThis->offFile == pThis->cbFile);
980	pThis->fEndOfStream = true;
981	}
982
983	return rc;
984	}
985
986	static DECLCALLBACK(int) rtZipPkzipFssIos_Write(void pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t pcbWritten)
987	{
988	RT_NOREF_PV(pvThis); RT_NOREF_PV(off); RT_NOREF_PV(pSgBuf); RT_NOREF_PV(fBlocking); RT_NOREF_PV(pcbWritten);
989	return VERR_NOT_IMPLEMENTED;
990	}
991
992	static DECLCALLBACK(int) rtZipPkzipFssIos_Flush(void *pvThis)
993	{
994	RT_NOREF_PV(pvThis);
995	return VERR_NOT_IMPLEMENTED;
996	}
997
998	/**
999	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnPollOne}
1000	*/
1001	static DECLCALLBACK(int) rtZipPkzipFssIos_PollOne(void *pvThis, uint32_t fEvents, RTMSINTERVAL cMillies,
1002	bool fIntr, uint32_t *pfRetEvents)
1003	{
1004	PRTZIPPKZIPIOSTREAM pThis = (PRTZIPPKZIPIOSTREAM)pvThis;
1005
1006	/* When we've reached the end, read will be set to indicate it. */
1007	if ( (fEvents & RTPOLL_EVT_READ)
1008	&& pThis->fEndOfStream)
1009	{
1010	int rc = RTVfsIoStrmPoll(pThis->hVfsIos, fEvents, 0, fIntr, pfRetEvents);
1011	if (RT_SUCCESS(rc))
1012	*pfRetEvents \|= RTPOLL_EVT_READ;
1013	else
1014	*pfRetEvents = RTPOLL_EVT_READ;
1015	return VINF_SUCCESS;
1016	}
1017
1018	return RTVfsIoStrmPoll(pThis->hVfsIos, fEvents, cMillies, fIntr, pfRetEvents);
1019	}
1020
1021
1022	/**
1023	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell}
1024	*/
1025	static DECLCALLBACK(int) rtZipPkzipFssIos_Tell(void *pvThis, PRTFOFF poffActual)
1026	{
1027	PRTZIPPKZIPIOSTREAM pThis = (PRTZIPPKZIPIOSTREAM)pvThis;
1028	*poffActual = pThis->offFile;
1029	return VINF_SUCCESS;
1030	}
1031
1032
1033	/**
1034	* Pkzip I/O object stream operations.
1035	*/
1036	static const RTVFSIOSTREAMOPS g_rtZipPkzipFssIosOps =
1037	{
1038	{ /* Obj */
1039	RTVFSOBJOPS_VERSION,
1040	RTVFSOBJTYPE_IO_STREAM,
1041	"PkzipFsStream::IoStream",
1042	rtZipPkzipFssIos_Close,
1043	rtZipPkzipFssIos_QueryInfo,
1044	RTVFSOBJOPS_VERSION
1045	},
1046	RTVFSIOSTREAMOPS_VERSION,
1047	RTVFSIOSTREAMOPS_FEAT_NO_SG,
1048	rtZipPkzipFssIos_Read,
1049	rtZipPkzipFssIos_Write,
1050	rtZipPkzipFssIos_Flush,
1051	rtZipPkzipFssIos_PollOne,
1052	rtZipPkzipFssIos_Tell,
1053	NULL /Skip/,
1054	NULL /ZeroFill/,
1055	RTVFSIOSTREAMOPS_VERSION
1056	};
1057
1058	/**
1059	* @interface_method_impl{RTVFSOBJOPS,pfnClose}
1060	*/
1061	static DECLCALLBACK(int) rtZipPkzipFss_Close(void *pvThis)
1062	{
1063	PRTZIPPKZIPFSSTREAM pThis = (PRTZIPPKZIPFSSTREAM)pvThis;
1064
1065	RTVfsObjRelease(pThis->hVfsCurObj);
1066	pThis->hVfsCurObj = NIL_RTVFSOBJ;
1067	pThis->pCurIosData = NULL;
1068
1069	RTVfsIoStrmRelease(pThis->hVfsIos);
1070	pThis->hVfsIos = NIL_RTVFSIOSTREAM;
1071
1072	return VINF_SUCCESS;
1073	}
1074
1075
1076	/**
1077	* @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
1078	*/
1079	static DECLCALLBACK(int) rtZipPkzipFss_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
1080	{
1081	PRTZIPPKZIPFSSTREAM pThis = (PRTZIPPKZIPFSSTREAM)pvThis;
1082	/* Take the lazy approach here, with the sideffect of providing some info
1083	that is actually kind of useful. */
1084	return RTVfsIoStrmQueryInfo(pThis->hVfsIos, pObjInfo, enmAddAttr);
1085	}
1086
1087
1088	/**
1089	* @interface_method_impl{RTVFSFSSTREAMOPS,pfnNext}
1090	*/
1091	static DECLCALLBACK(int) rtZipPkzipFss_Next(void pvThis, char ppszName, RTVFSOBJTYPE penmType, PRTVFSOBJ phVfsObj)
1092	{
1093	PRTZIPPKZIPFSSTREAM pThis = (PRTZIPPKZIPFSSTREAM)pvThis;
1094
1095	/*
1096	* Dispense with the current object.
1097	*/
1098	if (pThis->hVfsCurObj != NIL_RTVFSOBJ)
1099	{
1100	if (pThis->pCurIosData)
1101	{
1102	pThis->pCurIosData->fEndOfStream = true;
1103	pThis->pCurIosData->offFile = pThis->pCurIosData->cbFile;
1104	pThis->pCurIosData = NULL;
1105	}
1106
1107	RTVfsObjRelease(pThis->hVfsCurObj);
1108	pThis->hVfsCurObj = NIL_RTVFSOBJ;
1109	}
1110
1111	/*
1112	* Check if we've already reached the end in some way.
1113	*/
1114	if (pThis->fEndOfStream)
1115	return VERR_EOF;
1116	if (pThis->rcFatal != VINF_SUCCESS)
1117	return pThis->rcFatal;
1118
1119	int rc = VINF_SUCCESS;
1120
1121	/*
1122	* Read the end of Central Directory Record once.
1123	*/
1124	if (!pThis->PkzipReader.fHaveEocd)
1125	rc = rtZipPkzipFssIosReadEocb(pThis);
1126	uint64_t offData = 0;
1127
1128	/*
1129	* Parse the current Central Directory Header.
1130	*/
1131	RTZIPPKZIP_COMP_METHOD enmCompMethod = RTZIPPKZIP_COMP_METHOD_STORED;
1132	uint64_t cbCompressed = 0;
1133	if (RT_SUCCESS(rc))
1134	rc = rtZipPkzipFssIosReadCdh(pThis, &offData, &enmCompMethod, &cbCompressed);
1135	if (RT_FAILURE(rc))
1136	return pThis->rcFatal = rc;
1137
1138	/*
1139	* Fill an object info structure from the current Pkzip state.
1140	*/
1141	RTFSOBJINFO Info;
1142	rc = rtZipPkzipReaderGetFsObjInfo(&pThis->PkzipReader, &Info);
1143	if (RT_FAILURE(rc))
1144	return pThis->rcFatal = rc;
1145
1146	/*
1147	* Create an object of the appropriate type.
1148	*/
1149	RTVFSOBJTYPE enmType;
1150	RTVFSOBJ hVfsObj;
1151	RTFMODE fType = Info.Attr.fMode & RTFS_TYPE_MASK;
1152	switch (fType)
1153	{
1154	case RTFS_TYPE_FILE:
1155	RTVFSIOSTREAM hVfsIos;
1156	PRTZIPPKZIPIOSTREAM pIosData;
1157	rc = RTVfsNewIoStream(&g_rtZipPkzipFssIosOps,
1158	sizeof(*pIosData),
1159	RTFILE_O_READ \| RTFILE_O_DENY_NONE \| RTFILE_O_OPEN,
1160	NIL_RTVFS,
1161	NIL_RTVFSLOCK,
1162	&hVfsIos,
1163	(void **)&pIosData);
1164	if (RT_FAILURE(rc))
1165	return pThis->rcFatal = rc;
1166
1167	pIosData->BaseObj.pPkzipReader = &pThis->PkzipReader;
1168	pIosData->BaseObj.ObjInfo = Info;
1169	pIosData->cbFile = Info.cbObject;
1170	pIosData->offFile = 0;
1171	pIosData->offComp = offData;
1172	pIosData->offCompStart = offData;
1173	pIosData->cbComp = cbCompressed;
1174	pIosData->enmCompMethod = enmCompMethod;
1175	pIosData->fPassZipType = true;
1176	pIosData->hVfsIos = pThis->hVfsIos;
1177	RTVfsIoStrmRetain(pThis->hVfsIos);
1178	pThis->pCurIosData = pIosData;
1179	enmType = RTVFSOBJTYPE_IO_STREAM;
1180	hVfsObj = RTVfsObjFromIoStream(hVfsIos);
1181	RTVfsIoStrmRelease(hVfsIos);
1182	break;
1183
1184	case RTFS_TYPE_DIRECTORY:
1185	PRTZIPPKZIPBASEOBJ pBaseObjData;
1186	rc = RTVfsNewBaseObj(&g_rtZipPkzipFssBaseObjOps,
1187	sizeof(*pBaseObjData),
1188	NIL_RTVFS,
1189	NIL_RTVFSLOCK,
1190	&hVfsObj,
1191	(void **)&pBaseObjData);
1192	if (RT_FAILURE(rc))
1193	return pThis->rcFatal = rc;
1194
1195	pBaseObjData->pPkzipReader = &pThis->PkzipReader;
1196	pBaseObjData->ObjInfo = Info;
1197	enmType = RTVFSOBJTYPE_BASE;
1198	break;
1199
1200	default:
1201	return pThis->rcFatal = VERR_PKZIP_UNKNOWN_TYPE_FLAG;
1202	}
1203	pThis->hVfsCurObj = hVfsObj;
1204
1205	if (ppszName)
1206	{
1207	rc = RTStrDupEx(ppszName, pThis->PkzipReader.szName);
1208	if (RT_FAILURE(rc))
1209	return pThis->rcFatal = rc;
1210	}
1211
1212	if (phVfsObj)
1213	{
1214	RTVfsObjRetain(hVfsObj);
1215	*phVfsObj = hVfsObj;
1216	}
1217
1218	if (penmType)
1219	*penmType = enmType;
1220
1221	return VINF_SUCCESS;
1222	}
1223
1224
1225	/**
1226	* PKZip filesystem stream operations.
1227	*/
1228	static const RTVFSFSSTREAMOPS rtZipPkzipFssOps =
1229	{
1230	{ /* Obj */
1231	RTVFSOBJOPS_VERSION,
1232	RTVFSOBJTYPE_FS_STREAM,
1233	"PkzipFsStream",
1234	rtZipPkzipFss_Close,
1235	rtZipPkzipFss_QueryInfo,
1236	RTVFSOBJOPS_VERSION
1237	},
1238	RTVFSFSSTREAMOPS_VERSION,
1239	0,
1240	rtZipPkzipFss_Next,
1241	NULL,
1242	NULL,
1243	NULL,
1244	RTVFSFSSTREAMOPS_VERSION
1245	};
1246
1247
1248	RTDECL(int) RTZipPkzipFsStreamFromIoStream(RTVFSIOSTREAM hVfsIosIn, uint32_t fFlags, PRTVFSFSSTREAM phVfsFss)
1249	{
1250	/*
1251	* Input validation.
1252	*/
1253	AssertPtrReturn(phVfsFss, VERR_INVALID_HANDLE);
1254	*phVfsFss = NIL_RTVFSFSSTREAM;
1255	AssertPtrReturn(hVfsIosIn, VERR_INVALID_HANDLE);
1256	AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
1257
1258	uint32_t cRefs = RTVfsIoStrmRetain(hVfsIosIn);
1259	AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE);
1260
1261	/*
1262	* Retain the input stream and create a new filesystem stream handle.
1263	*/
1264	PRTZIPPKZIPFSSTREAM pThis;
1265	RTVFSFSSTREAM hVfsFss;
1266	int rc = RTVfsNewFsStream(&rtZipPkzipFssOps, sizeof(pThis), NIL_RTVFS, NIL_RTVFSLOCK, true /fReadOnly*/,
1267	&hVfsFss, (void **)&pThis);
1268	if (RT_SUCCESS(rc))
1269	{
1270	pThis->hVfsIos = hVfsIosIn;
1271	pThis->hVfsCurObj = NIL_RTVFSOBJ;
1272	pThis->pCurIosData = NULL;
1273	pThis->fEndOfStream = false;
1274	pThis->rcFatal = VINF_SUCCESS;
1275	pThis->fHaveEocd = false;
1276
1277	*phVfsFss = hVfsFss;
1278	return VINF_SUCCESS;
1279	}
1280
1281	RTVfsIoStrmRelease(hVfsIosIn);
1282	return rc;
1283	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/common/zip/pkzipvfs.cpp@ 72437

Download in other formats: