VirtualBox

source: vbox/trunk/src/VBox/Runtime/common/zip/pkzip.cpp

Last change on this file was 100908, checked in by vboxsync, 9 months ago

IPRT,Storage,Puel: Changed the pfnRead and pfnWrite VFS methods and the RTVfsIoStrmSgRead, RTVfsIoStrmSgWrite, RTVfsFileSgRead and RTVfsFileSgWrite APIs to advance pSgBuf and respect the incoming position just like RTFileSgRead & RTFileSgWrite.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 8.3 KB
Line 
1/* $Id: pkzip.cpp 100908 2023-08-19 02:57:05Z vboxsync $ */
2/** @file
3 * IPRT - PKZIP archive I/O.
4 */
5
6/*
7 * Copyright (C) 2014-2023 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * The contents of this file may alternatively be used under the terms
26 * of the Common Development and Distribution License Version 1.0
27 * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28 * in the VirtualBox distribution, in which case the provisions of the
29 * CDDL are applicable instead of those of the GPL.
30 *
31 * You may elect to license modified versions of this file under the
32 * terms and conditions of either the GPL or the CDDL or both.
33 *
34 * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35 */
36
37
38/*********************************************************************************************************************************
39* Header Files *
40*********************************************************************************************************************************/
41#include <iprt/zip.h>
42
43#include <iprt/file.h>
44#include <iprt/err.h>
45#include <iprt/fs.h>
46#include <iprt/mem.h>
47#include <iprt/string.h>
48#include <iprt/vfs.h>
49#include <iprt/vfslowlevel.h>
50
51
52/*********************************************************************************************************************************
53* Structures and Typedefs *
54*********************************************************************************************************************************/
55/**
56 * Memory stream private data.
57 */
58typedef struct MEMIOSTREAM
59{
60 /** Size of the memory buffer. */
61 size_t cbBuf;
62 /** Pointer to the memory buffer. */
63 uint8_t *pu8Buf;
64 /** Current offset. */
65 size_t off;
66} MEMIOSTREAM;
67typedef MEMIOSTREAM *PMEMIOSTREAM;
68
69
70/**
71 * @interface_method_impl{RTVFSOBJOPS,pfnClose}
72 */
73static DECLCALLBACK(int) memFssIos_Close(void *pvThis)
74{
75 NOREF(pvThis);
76 return VINF_SUCCESS;
77}
78
79/**
80 * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
81 */
82static DECLCALLBACK(int) memFssIos_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
83{
84 PMEMIOSTREAM pThis = (PMEMIOSTREAM)pvThis;
85 switch (enmAddAttr)
86 {
87 case RTFSOBJATTRADD_NOTHING:
88 case RTFSOBJATTRADD_UNIX:
89 RT_ZERO(*pObjInfo);
90 pObjInfo->cbObject = pThis->cbBuf;
91 break;
92 default:
93 return VERR_NOT_SUPPORTED;
94 }
95 return VINF_SUCCESS;
96}
97
98/**
99 * @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead}
100 */
101static DECLCALLBACK(int) memFssIos_Read(void *pvThis, RTFOFF off, PRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead)
102{
103 PMEMIOSTREAM pThis = (PMEMIOSTREAM)pvThis;
104 Assert(pSgBuf->cSegs == 1);
105 RT_NOREF_PV(fBlocking);
106
107 if (off < 0)
108 off = pThis->off;
109 if (off >= (RTFOFF)pThis->cbBuf)
110 return pcbRead ? VINF_EOF : VERR_EOF;
111
112 size_t cbLeft = pThis->cbBuf - off;
113 size_t cbToRead = pSgBuf->paSegs[0].cbSeg;
114 if (cbToRead > cbLeft)
115 {
116 if (!pcbRead)
117 return VERR_EOF;
118 cbToRead = (size_t)cbLeft;
119 }
120
121 memcpy(pSgBuf->paSegs[0].pvSeg, pThis->pu8Buf + off, cbToRead);
122 pThis->off = off + cbToRead;
123 if (pcbRead)
124 *pcbRead = cbToRead;
125 RTSgBufAdvance(pSgBuf, cbToRead);
126
127 return VINF_SUCCESS;
128}
129
130/**
131 * @interface_method_impl{RTVFSIOSTREAMOPS,pfnWrite}
132 */
133static DECLCALLBACK(int) memFssIos_Write(void *pvThis, RTFOFF off, PRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten)
134{
135 RT_NOREF_PV(pvThis); RT_NOREF_PV(off); RT_NOREF_PV(pSgBuf); RT_NOREF_PV(fBlocking); RT_NOREF_PV(pcbWritten);
136 return VERR_NOT_IMPLEMENTED;
137}
138
139/**
140 * @interface_method_impl{RTVFSIOSTREAMOPS,pfnFlush}
141 */
142static DECLCALLBACK(int) memFssIos_Flush(void *pvThis)
143{
144 RT_NOREF_PV(pvThis);
145 return VERR_NOT_IMPLEMENTED;
146}
147
148/**
149 * @interface_method_impl{RTVFSIOSTREAMOPS,pfnPollOne}
150 */
151static DECLCALLBACK(int) memFssIos_PollOne(void *pvThis, uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr, uint32_t *pfRetEvents)
152{
153 RT_NOREF_PV(pvThis); RT_NOREF_PV(fEvents); RT_NOREF_PV(cMillies); RT_NOREF_PV(fIntr); RT_NOREF_PV(pfRetEvents);
154 return VERR_NOT_IMPLEMENTED;
155}
156
157/**
158 * @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell}
159 */
160static DECLCALLBACK(int) memFssIos_Tell(void *pvThis, PRTFOFF poffActual)
161{
162 PMEMIOSTREAM pThis = (PMEMIOSTREAM)pvThis;
163 *poffActual = pThis->off;
164 return VINF_SUCCESS;
165}
166
167/**
168 * Memory I/O object stream operations.
169 */
170static const RTVFSIOSTREAMOPS g_memFssIosOps =
171{
172 { /* Obj */
173 RTVFSOBJOPS_VERSION,
174 RTVFSOBJTYPE_IO_STREAM,
175 "MemFsStream::IoStream",
176 memFssIos_Close,
177 memFssIos_QueryInfo,
178 NULL,
179 RTVFSOBJOPS_VERSION
180 },
181 RTVFSIOSTREAMOPS_VERSION,
182 RTVFSIOSTREAMOPS_FEAT_NO_SG,
183 memFssIos_Read,
184 memFssIos_Write,
185 memFssIos_Flush,
186 memFssIos_PollOne,
187 memFssIos_Tell,
188 NULL /*Skip*/,
189 NULL /*ZeroFill*/,
190 RTVFSIOSTREAMOPS_VERSION
191};
192
193RTDECL(int) RTZipPkzipMemDecompress(void **ppvDst, size_t *pcbDst, const void *pvSrc, size_t cbSrc, const char *pszObject)
194{
195 PMEMIOSTREAM pIosData;
196 RTVFSIOSTREAM hVfsIos;
197 int rc = RTVfsNewIoStream(&g_memFssIosOps,
198 sizeof(*pIosData),
199 RTFILE_O_READ | RTFILE_O_DENY_WRITE | RTFILE_O_OPEN,
200 NIL_RTVFS,
201 NIL_RTVFSLOCK,
202 &hVfsIos,
203 (void **)&pIosData);
204 if (RT_SUCCESS(rc))
205 {
206 pIosData->pu8Buf = (uint8_t*)pvSrc;
207 pIosData->cbBuf = cbSrc;
208 pIosData->off = 0;
209 RTVFSFSSTREAM hVfsFss;
210 rc = RTZipPkzipFsStreamFromIoStream(hVfsIos, 0 /*fFlags*/, &hVfsFss);
211 RTVfsIoStrmRelease(hVfsIos);
212 if (RT_SUCCESS(rc))
213 {
214 /*
215 * Loop through all objects. Actually this wouldn't be required
216 * for .zip files but we opened it as I/O stream.
217 */
218 for (bool fFound = false; !fFound;)
219 {
220 char *pszName;
221 RTVFSOBJ hVfsObj;
222 rc = RTVfsFsStrmNext(hVfsFss, &pszName, NULL /*penmType*/, &hVfsObj);
223 if (RT_FAILURE(rc))
224 break;
225 fFound = !strcmp(pszName, pszObject);
226 if (fFound)
227 {
228 RTFSOBJINFO UnixInfo;
229 rc = RTVfsObjQueryInfo(hVfsObj, &UnixInfo, RTFSOBJATTRADD_UNIX);
230 if (RT_SUCCESS(rc))
231 {
232 size_t cb = UnixInfo.cbObject;
233 void *pv = RTMemAlloc(cb);
234 if (pv)
235 {
236 RTVFSIOSTREAM hVfsIosObj = RTVfsObjToIoStream(hVfsObj);
237 if (hVfsIos != NIL_RTVFSIOSTREAM)
238 {
239 rc = RTVfsIoStrmRead(hVfsIosObj, pv, cb, true /*fBlocking*/, NULL);
240 if (RT_SUCCESS(rc))
241 {
242 *ppvDst = pv;
243 *pcbDst = cb;
244 }
245 }
246 else
247 rc = VERR_INTERNAL_ERROR_4;
248 if (RT_FAILURE(rc))
249 RTMemFree(pv);
250 }
251 }
252 }
253 RTVfsObjRelease(hVfsObj);
254 RTStrFree(pszName);
255 }
256 RTVfsFsStrmRelease(hVfsFss);
257 }
258 }
259 return rc;
260}
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use