1 | /* $Id: manifest2.cpp 76553 2019-01-01 01:45:53Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * IPRT - Manifest, the core.
|
---|
4 | */
|
---|
5 |
|
---|
6 | /*
|
---|
7 | * Copyright (C) 2010-2019 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 "internal/iprt.h"
|
---|
32 | #include <iprt/manifest.h>
|
---|
33 |
|
---|
34 | #include <iprt/asm.h>
|
---|
35 | #include <iprt/assert.h>
|
---|
36 | #include <iprt/ctype.h>
|
---|
37 | #include <iprt/err.h>
|
---|
38 | #include <iprt/mem.h>
|
---|
39 | #include <iprt/param.h>
|
---|
40 | #include <iprt/md5.h>
|
---|
41 | #include <iprt/sha.h>
|
---|
42 | #include <iprt/string.h>
|
---|
43 | #include <iprt/vfs.h>
|
---|
44 |
|
---|
45 | #include "internal/magics.h"
|
---|
46 |
|
---|
47 |
|
---|
48 | /*********************************************************************************************************************************
|
---|
49 | * Structures and Typedefs *
|
---|
50 | *********************************************************************************************************************************/
|
---|
51 | /**
|
---|
52 | * Manifest attribute.
|
---|
53 | *
|
---|
54 | * Used both for entries and manifest attributes.
|
---|
55 | */
|
---|
56 | typedef struct RTMANIFESTATTR
|
---|
57 | {
|
---|
58 | /** The string space core (szName). */
|
---|
59 | RTSTRSPACECORE StrCore;
|
---|
60 | /** The property value. */
|
---|
61 | char *pszValue;
|
---|
62 | /** The attribute type if applicable, RTMANIFEST_ATTR_UNKNOWN if not. */
|
---|
63 | uint32_t fType;
|
---|
64 | /** Whether it was visited by the equals operation or not. */
|
---|
65 | bool fVisited;
|
---|
66 | /** The normalized property name that StrCore::pszString points at. */
|
---|
67 | char szName[RT_FLEXIBLE_ARRAY];
|
---|
68 | } RTMANIFESTATTR;
|
---|
69 | /** Pointer to a manifest attribute. */
|
---|
70 | typedef RTMANIFESTATTR *PRTMANIFESTATTR;
|
---|
71 |
|
---|
72 |
|
---|
73 | /**
|
---|
74 | * Manifest entry.
|
---|
75 | */
|
---|
76 | typedef struct RTMANIFESTENTRY
|
---|
77 | {
|
---|
78 | /** The string space core (szName). */
|
---|
79 | RTSTRSPACECORE StrCore;
|
---|
80 | /** The entry attributes (hashes, checksums, size, etc) -
|
---|
81 | * RTMANIFESTATTR. */
|
---|
82 | RTSTRSPACE Attributes;
|
---|
83 | /** The number of attributes. */
|
---|
84 | uint32_t cAttributes;
|
---|
85 | /** Whether it was visited by the equals operation or not. */
|
---|
86 | bool fVisited;
|
---|
87 | /** The normalized entry name that StrCore::pszString points at. */
|
---|
88 | char szName[RT_FLEXIBLE_ARRAY_NESTED];
|
---|
89 | } RTMANIFESTENTRY;
|
---|
90 | /** Pointer to a manifest entry. */
|
---|
91 | typedef RTMANIFESTENTRY *PRTMANIFESTENTRY;
|
---|
92 |
|
---|
93 |
|
---|
94 | /**
|
---|
95 | * Manifest handle data.
|
---|
96 | */
|
---|
97 | typedef struct RTMANIFESTINT
|
---|
98 | {
|
---|
99 | /** Magic value (RTMANIFEST_MAGIC). */
|
---|
100 | uint32_t u32Magic;
|
---|
101 | /** The number of references to this manifest. */
|
---|
102 | uint32_t volatile cRefs;
|
---|
103 | /** String space of the entries covered by this manifest -
|
---|
104 | * RTMANIFESTENTRY. */
|
---|
105 | RTSTRSPACE Entries;
|
---|
106 | /** The number of entries. */
|
---|
107 | uint32_t cEntries;
|
---|
108 | /** The entry for the manifest itself. */
|
---|
109 | RTMANIFESTENTRY SelfEntry;
|
---|
110 | } RTMANIFESTINT;
|
---|
111 |
|
---|
112 | /** The value of RTMANIFESTINT::u32Magic. */
|
---|
113 | #define RTMANIFEST_MAGIC UINT32_C(0x99998866)
|
---|
114 |
|
---|
115 | /**
|
---|
116 | * Argument package passed to rtManifestWriteStdAttr by rtManifestWriteStdEntry
|
---|
117 | * and RTManifestWriteStandard.
|
---|
118 | */
|
---|
119 | typedef struct RTMANIFESTWRITESTDATTR
|
---|
120 | {
|
---|
121 | /** The entry name. */
|
---|
122 | const char *pszEntry;
|
---|
123 | /** The output I/O stream. */
|
---|
124 | RTVFSIOSTREAM hVfsIos;
|
---|
125 | } RTMANIFESTWRITESTDATTR;
|
---|
126 |
|
---|
127 |
|
---|
128 | /**
|
---|
129 | * Argument package used by RTManifestEqualsEx to pass its arguments to the
|
---|
130 | * enumeration callback functions.
|
---|
131 | */
|
---|
132 | typedef struct RTMANIFESTEQUALS
|
---|
133 | {
|
---|
134 | /** Name of entries to ignore. */
|
---|
135 | const char * const *papszIgnoreEntries;
|
---|
136 | /** Name of attributes to ignore. */
|
---|
137 | const char * const *papszIgnoreAttrs;
|
---|
138 | /** Flags governing the comparision. */
|
---|
139 | uint32_t fFlags;
|
---|
140 | /** Where to return an error message (++) on failure. Can be NULL. */
|
---|
141 | char *pszError;
|
---|
142 | /** The size of the buffer pszError points to. Can be 0. */
|
---|
143 | size_t cbError;
|
---|
144 |
|
---|
145 | /** Pointer to the 2nd manifest. */
|
---|
146 | RTMANIFESTINT *pThis2;
|
---|
147 |
|
---|
148 | /** The number of ignored entries from the 1st manifest. */
|
---|
149 | uint32_t cIgnoredEntries2;
|
---|
150 | /** The number of entries processed from the 2nd manifest. */
|
---|
151 | uint32_t cEntries2;
|
---|
152 |
|
---|
153 | /** The number of ignored attributes from the 1st manifest. */
|
---|
154 | uint32_t cIgnoredAttributes1;
|
---|
155 | /** The number of ignored attributes from the 1st manifest. */
|
---|
156 | uint32_t cIgnoredAttributes2;
|
---|
157 | /** The number of attributes processed from the 2nd manifest. */
|
---|
158 | uint32_t cAttributes2;
|
---|
159 | /** Pointer to the string space to get matching attributes from. */
|
---|
160 | PRTSTRSPACE pAttributes2;
|
---|
161 | /** The name of the current entry.
|
---|
162 | * Points to an empty string it's the manifest attributes. */
|
---|
163 | const char *pszCurEntry;
|
---|
164 | } RTMANIFESTEQUALS;
|
---|
165 | /** Pointer to an RTManifestEqualEx argument packet. */
|
---|
166 | typedef RTMANIFESTEQUALS *PRTMANIFESTEQUALS;
|
---|
167 |
|
---|
168 | /**
|
---|
169 | * Argument package used by rtManifestQueryAttrWorker to pass its search
|
---|
170 | * criteria to rtManifestQueryAttrEnumCallback and get a result back.
|
---|
171 | */
|
---|
172 | typedef struct RTMANIFESTQUERYATTRARGS
|
---|
173 | {
|
---|
174 | /** The attribute types we're hunting for. */
|
---|
175 | uint32_t fType;
|
---|
176 | /** What we've found. */
|
---|
177 | PRTMANIFESTATTR pAttr;
|
---|
178 | } RTMANIFESTQUERYATTRARGS;
|
---|
179 | /** Pointer to a rtManifestQueryAttrEnumCallback argument packet. */
|
---|
180 | typedef RTMANIFESTQUERYATTRARGS *PRTMANIFESTQUERYATTRARGS;
|
---|
181 |
|
---|
182 |
|
---|
183 | /**
|
---|
184 | * Creates an empty manifest.
|
---|
185 | *
|
---|
186 | * @returns IPRT status code.
|
---|
187 | * @param fFlags Flags, MBZ.
|
---|
188 | * @param phManifest Where to return the handle to the manifest.
|
---|
189 | */
|
---|
190 | RTDECL(int) RTManifestCreate(uint32_t fFlags, PRTMANIFEST phManifest)
|
---|
191 | {
|
---|
192 | AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
|
---|
193 | AssertPtr(phManifest);
|
---|
194 |
|
---|
195 | RTMANIFESTINT *pThis = (RTMANIFESTINT *)RTMemAlloc(RT_UOFFSETOF(RTMANIFESTINT, SelfEntry.szName[1]));
|
---|
196 | if (!pThis)
|
---|
197 | return VERR_NO_MEMORY;
|
---|
198 |
|
---|
199 | pThis->u32Magic = RTMANIFEST_MAGIC;
|
---|
200 | pThis->cRefs = 1;
|
---|
201 | pThis->Entries = NULL;
|
---|
202 | pThis->cEntries = 0;
|
---|
203 | pThis->SelfEntry.StrCore.pszString = "main";
|
---|
204 | pThis->SelfEntry.StrCore.cchString = 4;
|
---|
205 | pThis->SelfEntry.Attributes = NULL;
|
---|
206 | pThis->SelfEntry.cAttributes = 0;
|
---|
207 | pThis->SelfEntry.fVisited = false;
|
---|
208 | pThis->SelfEntry.szName[0] = '\0';
|
---|
209 |
|
---|
210 | *phManifest = pThis;
|
---|
211 | return VINF_SUCCESS;
|
---|
212 | }
|
---|
213 |
|
---|
214 | /**
|
---|
215 | * Retains a reference to the manifest handle.
|
---|
216 | *
|
---|
217 | * @returns The new reference count, UINT32_MAX if the handle is invalid.
|
---|
218 | * @param hManifest The handle to retain.
|
---|
219 | */
|
---|
220 | RTDECL(uint32_t) RTManifestRetain(RTMANIFEST hManifest)
|
---|
221 | {
|
---|
222 | RTMANIFESTINT *pThis = hManifest;
|
---|
223 | AssertPtrReturn(pThis, UINT32_MAX);
|
---|
224 | AssertReturn(pThis->u32Magic == RTMANIFEST_MAGIC, UINT32_MAX);
|
---|
225 |
|
---|
226 | uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs);
|
---|
227 | Assert(cRefs > 1 && cRefs < _1M);
|
---|
228 |
|
---|
229 | return cRefs;
|
---|
230 | }
|
---|
231 |
|
---|
232 |
|
---|
233 | /**
|
---|
234 | * @callback_method_impl{FNRTSTRSPACECALLBACK, Destroys RTMANIFESTATTR.}
|
---|
235 | */
|
---|
236 | static DECLCALLBACK(int) rtManifestDestroyAttribute(PRTSTRSPACECORE pStr, void *pvUser)
|
---|
237 | {
|
---|
238 | PRTMANIFESTATTR pAttr = RT_FROM_MEMBER(pStr, RTMANIFESTATTR, StrCore);
|
---|
239 | RTStrFree(pAttr->pszValue);
|
---|
240 | pAttr->pszValue = NULL;
|
---|
241 | RTMemFree(pAttr);
|
---|
242 | NOREF(pvUser);
|
---|
243 | return 0;
|
---|
244 | }
|
---|
245 |
|
---|
246 |
|
---|
247 | /**
|
---|
248 | * @callback_method_impl{FNRTSTRSPACECALLBACK, Destroys RTMANIFESTENTRY.}
|
---|
249 | */
|
---|
250 | static DECLCALLBACK(int) rtManifestDestroyEntry(PRTSTRSPACECORE pStr, void *pvUser)
|
---|
251 | {
|
---|
252 | PRTMANIFESTENTRY pEntry = RT_FROM_MEMBER(pStr, RTMANIFESTENTRY, StrCore);
|
---|
253 | RTStrSpaceDestroy(&pEntry->Attributes, rtManifestDestroyAttribute, pvUser);
|
---|
254 | RTMemFree(pEntry);
|
---|
255 | return 0;
|
---|
256 | }
|
---|
257 |
|
---|
258 |
|
---|
259 | /**
|
---|
260 | * Releases a reference to the manifest handle.
|
---|
261 | *
|
---|
262 | * @returns The new reference count, 0 if free. UINT32_MAX is returned if the
|
---|
263 | * handle is invalid.
|
---|
264 | * @param hManifest The handle to release.
|
---|
265 | * NIL is quietly ignored (returns 0).
|
---|
266 | */
|
---|
267 | RTDECL(uint32_t) RTManifestRelease(RTMANIFEST hManifest)
|
---|
268 | {
|
---|
269 | RTMANIFESTINT *pThis = hManifest;
|
---|
270 | if (pThis == NIL_RTMANIFEST)
|
---|
271 | return 0;
|
---|
272 | AssertPtrReturn(pThis, UINT32_MAX);
|
---|
273 | AssertReturn(pThis->u32Magic == RTMANIFEST_MAGIC, UINT32_MAX);
|
---|
274 |
|
---|
275 | uint32_t cRefs = ASMAtomicDecU32(&pThis->cRefs);
|
---|
276 | Assert(cRefs < _1M);
|
---|
277 | if (!cRefs)
|
---|
278 | {
|
---|
279 | ASMAtomicWriteU32(&pThis->u32Magic, ~RTMANIFEST_MAGIC);
|
---|
280 | RTStrSpaceDestroy(&pThis->Entries, rtManifestDestroyEntry,pThis);
|
---|
281 | RTStrSpaceDestroy(&pThis->SelfEntry.Attributes, rtManifestDestroyAttribute, pThis);
|
---|
282 | RTMemFree(pThis);
|
---|
283 | }
|
---|
284 |
|
---|
285 | return cRefs;
|
---|
286 | }
|
---|
287 |
|
---|
288 |
|
---|
289 | /**
|
---|
290 | * Creates a duplicate of the specified manifest.
|
---|
291 | *
|
---|
292 | * @returns IPRT status code
|
---|
293 | * @param hManifestSrc The manifest to clone.
|
---|
294 | * @param phManifestDst Where to store the handle to the duplicate.
|
---|
295 | */
|
---|
296 | RTDECL(int) RTManifestDup(RTMANIFEST hManifestSrc, PRTMANIFEST phManifestDst)
|
---|
297 | {
|
---|
298 | RTMANIFESTINT *pThis = hManifestSrc;
|
---|
299 | AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
|
---|
300 | AssertReturn(pThis->u32Magic == RTMANIFEST_MAGIC, VERR_INVALID_HANDLE);
|
---|
301 | AssertPtr(phManifestDst);
|
---|
302 |
|
---|
303 | RT_NOREF_PV(phManifestDst); /** @todo implement cloning. */
|
---|
304 |
|
---|
305 | return VERR_NOT_IMPLEMENTED;
|
---|
306 | }
|
---|
307 |
|
---|
308 |
|
---|
309 | /**
|
---|
310 | * @callback_method_impl{FNRTSTRSPACECALLBACK, Prepare equals operation}
|
---|
311 | */
|
---|
312 | static DECLCALLBACK(int) rtManifestAttributeClearVisited(PRTSTRSPACECORE pStr, void *pvUser)
|
---|
313 | {
|
---|
314 | PRTMANIFESTATTR pAttr = RT_FROM_MEMBER(pStr, RTMANIFESTATTR, StrCore);
|
---|
315 | pAttr->fVisited = false;
|
---|
316 | NOREF(pvUser);
|
---|
317 | return 0;
|
---|
318 | }
|
---|
319 |
|
---|
320 |
|
---|
321 | /**
|
---|
322 | * @callback_method_impl{FNRTSTRSPACECALLBACK, Prepare equals operation}
|
---|
323 | */
|
---|
324 | static DECLCALLBACK(int) rtManifestEntryClearVisited(PRTSTRSPACECORE pStr, void *pvUser)
|
---|
325 | {
|
---|
326 | PRTMANIFESTENTRY pEntry = RT_FROM_MEMBER(pStr, RTMANIFESTENTRY, StrCore);
|
---|
327 | RTStrSpaceEnumerate(&pEntry->Attributes, rtManifestAttributeClearVisited, NULL);
|
---|
328 | pEntry->fVisited = false;
|
---|
329 | NOREF(pvUser);
|
---|
330 | return 0;
|
---|
331 | }
|
---|
332 |
|
---|
333 |
|
---|
334 | /**
|
---|
335 | * @callback_method_impl{FNRTSTRSPACECALLBACK, Finds the first missing}
|
---|
336 | */
|
---|
337 | static DECLCALLBACK(int) rtManifestAttributeFindMissing2(PRTSTRSPACECORE pStr, void *pvUser)
|
---|
338 | {
|
---|
339 | PRTMANIFESTEQUALS pEquals = (PRTMANIFESTEQUALS)pvUser;
|
---|
340 | PRTMANIFESTATTR pAttr = RT_FROM_MEMBER(pStr, RTMANIFESTATTR, StrCore);
|
---|
341 |
|
---|
342 | /*
|
---|
343 | * Already visited?
|
---|
344 | */
|
---|
345 | if (pAttr->fVisited)
|
---|
346 | return 0;
|
---|
347 |
|
---|
348 | /*
|
---|
349 | * Ignore this entry?
|
---|
350 | */
|
---|
351 | char const * const *ppsz = pEquals->papszIgnoreAttrs;
|
---|
352 | if (ppsz)
|
---|
353 | {
|
---|
354 | while (*ppsz)
|
---|
355 | {
|
---|
356 | if (!strcmp(*ppsz, pAttr->szName))
|
---|
357 | return 0;
|
---|
358 | ppsz++;
|
---|
359 | }
|
---|
360 | }
|
---|
361 |
|
---|
362 | /*
|
---|
363 | * Gotcha!
|
---|
364 | */
|
---|
365 | if (*pEquals->pszCurEntry)
|
---|
366 | RTStrPrintf(pEquals->pszError, pEquals->cbError,
|
---|
367 | "Attribute '%s' on '%s' was not found in the 1st manifest",
|
---|
368 | pAttr->szName, pEquals->pszCurEntry);
|
---|
369 | else
|
---|
370 | RTStrPrintf(pEquals->pszError, pEquals->cbError, "Attribute '%s' was not found in the 1st manifest", pAttr->szName);
|
---|
371 | return VERR_NOT_EQUAL;
|
---|
372 | }
|
---|
373 |
|
---|
374 |
|
---|
375 | /**
|
---|
376 | * @callback_method_impl{FNRTSTRSPACECALLBACK, Finds the first missing}
|
---|
377 | */
|
---|
378 | static DECLCALLBACK(int) rtManifestEntryFindMissing2(PRTSTRSPACECORE pStr, void *pvUser)
|
---|
379 | {
|
---|
380 | PRTMANIFESTEQUALS pEquals = (PRTMANIFESTEQUALS)pvUser;
|
---|
381 | PRTMANIFESTENTRY pEntry = RT_FROM_MEMBER(pStr, RTMANIFESTENTRY, StrCore);
|
---|
382 |
|
---|
383 | /*
|
---|
384 | * Already visited?
|
---|
385 | */
|
---|
386 | if (pEntry->fVisited)
|
---|
387 | return 0;
|
---|
388 |
|
---|
389 | /*
|
---|
390 | * Ignore this entry?
|
---|
391 | */
|
---|
392 | char const * const *ppsz = pEquals->papszIgnoreEntries;
|
---|
393 | if (ppsz)
|
---|
394 | {
|
---|
395 | while (*ppsz)
|
---|
396 | {
|
---|
397 | if (!strcmp(*ppsz, pEntry->StrCore.pszString))
|
---|
398 | return 0;
|
---|
399 | ppsz++;
|
---|
400 | }
|
---|
401 | }
|
---|
402 |
|
---|
403 | /*
|
---|
404 | * Gotcha!
|
---|
405 | */
|
---|
406 | RTStrPrintf(pEquals->pszError, pEquals->cbError, "'%s' was not found in the 1st manifest", pEntry->StrCore.pszString);
|
---|
407 | return VERR_NOT_EQUAL;
|
---|
408 | }
|
---|
409 |
|
---|
410 |
|
---|
411 | /**
|
---|
412 | * @callback_method_impl{FNRTSTRSPACECALLBACK, Compares attributes}
|
---|
413 | */
|
---|
414 | static DECLCALLBACK(int) rtManifestAttributeCompare(PRTSTRSPACECORE pStr, void *pvUser)
|
---|
415 | {
|
---|
416 | PRTMANIFESTEQUALS pEquals = (PRTMANIFESTEQUALS)pvUser;
|
---|
417 | PRTMANIFESTATTR pAttr1 = RT_FROM_MEMBER(pStr, RTMANIFESTATTR, StrCore);
|
---|
418 | PRTMANIFESTATTR pAttr2;
|
---|
419 |
|
---|
420 | Assert(!pAttr1->fVisited);
|
---|
421 | pAttr1->fVisited = true;
|
---|
422 |
|
---|
423 | /*
|
---|
424 | * Ignore this entry?
|
---|
425 | */
|
---|
426 | char const * const *ppsz = pEquals->papszIgnoreAttrs;
|
---|
427 | if (ppsz)
|
---|
428 | {
|
---|
429 | while (*ppsz)
|
---|
430 | {
|
---|
431 | if (!strcmp(*ppsz, pAttr1->szName))
|
---|
432 | {
|
---|
433 | pAttr2 = (PRTMANIFESTATTR)RTStrSpaceGet(pEquals->pAttributes2, pAttr1->szName);
|
---|
434 | if (pAttr2)
|
---|
435 | {
|
---|
436 | Assert(!pAttr2->fVisited);
|
---|
437 | pAttr2->fVisited = true;
|
---|
438 | pEquals->cIgnoredAttributes2++;
|
---|
439 | }
|
---|
440 | pEquals->cIgnoredAttributes1++;
|
---|
441 | return 0;
|
---|
442 | }
|
---|
443 | ppsz++;
|
---|
444 | }
|
---|
445 | }
|
---|
446 |
|
---|
447 | /*
|
---|
448 | * Find the matching attribute.
|
---|
449 | */
|
---|
450 | pAttr2 = (PRTMANIFESTATTR)RTStrSpaceGet(pEquals->pAttributes2, pAttr1->szName);
|
---|
451 | if (!pAttr2)
|
---|
452 | {
|
---|
453 | if (pEquals->fFlags & RTMANIFEST_EQUALS_IGN_MISSING_ATTRS)
|
---|
454 | return 0;
|
---|
455 |
|
---|
456 | if (*pEquals->pszCurEntry)
|
---|
457 | RTStrPrintf(pEquals->pszError, pEquals->cbError,
|
---|
458 | "Attribute '%s' on '%s' was not found in the 2nd manifest",
|
---|
459 | pAttr1->szName, pEquals->pszCurEntry);
|
---|
460 | else
|
---|
461 | RTStrPrintf(pEquals->pszError, pEquals->cbError, "Attribute '%s' was not found in the 2nd manifest", pAttr1->szName);
|
---|
462 | return VERR_NOT_EQUAL;
|
---|
463 | }
|
---|
464 |
|
---|
465 | Assert(!pAttr2->fVisited);
|
---|
466 | pAttr2->fVisited = true;
|
---|
467 | pEquals->cAttributes2++;
|
---|
468 |
|
---|
469 | /*
|
---|
470 | * Compare them.
|
---|
471 | */
|
---|
472 | if (RTStrICmp(pAttr1->pszValue, pAttr2->pszValue))
|
---|
473 | {
|
---|
474 | if (*pEquals->pszCurEntry)
|
---|
475 | RTStrPrintf(pEquals->pszError, pEquals->cbError,
|
---|
476 | "Attribute '%s' on '%s' does not match ('%s' vs. '%s')",
|
---|
477 | pAttr1->szName, pEquals->pszCurEntry, pAttr1->pszValue, pAttr2->pszValue);
|
---|
478 | else
|
---|
479 | RTStrPrintf(pEquals->pszError, pEquals->cbError,
|
---|
480 | "Attribute '%s' does not match ('%s' vs. '%s')",
|
---|
481 | pAttr1->szName, pAttr1->pszValue, pAttr2->pszValue);
|
---|
482 | return VERR_NOT_EQUAL;
|
---|
483 | }
|
---|
484 |
|
---|
485 | return 0;
|
---|
486 | }
|
---|
487 |
|
---|
488 |
|
---|
489 | /**
|
---|
490 | * @callback_method_impl{FNRTSTRSPACECALLBACK, Prepare equals operation}
|
---|
491 | */
|
---|
492 | DECLINLINE (int) rtManifestEntryCompare2(PRTMANIFESTEQUALS pEquals, PRTMANIFESTENTRY pEntry1, PRTMANIFESTENTRY pEntry2)
|
---|
493 | {
|
---|
494 | /*
|
---|
495 | * Compare the attributes. It's a bit ugly with all this counting, but
|
---|
496 | * how else to efficiently implement RTMANIFEST_EQUALS_IGN_MISSING_ATTRS?
|
---|
497 | */
|
---|
498 | pEquals->cIgnoredAttributes1 = 0;
|
---|
499 | pEquals->cIgnoredAttributes2 = 0;
|
---|
500 | pEquals->cAttributes2 = 0;
|
---|
501 | pEquals->pszCurEntry = &pEntry2->szName[0];
|
---|
502 | pEquals->pAttributes2 = &pEntry2->Attributes;
|
---|
503 | int rc = RTStrSpaceEnumerate(&pEntry1->Attributes, rtManifestAttributeCompare, pEquals);
|
---|
504 | if (RT_SUCCESS(rc))
|
---|
505 | {
|
---|
506 | /*
|
---|
507 | * Check that we matched all that is required.
|
---|
508 | */
|
---|
509 | if ( pEquals->cAttributes2 + pEquals->cIgnoredAttributes2 != pEntry2->cAttributes
|
---|
510 | && ( !(pEquals->fFlags & RTMANIFEST_EQUALS_IGN_MISSING_ATTRS)
|
---|
511 | || pEquals->cIgnoredAttributes1 == pEntry1->cAttributes))
|
---|
512 | rc = RTStrSpaceEnumerate(&pEntry2->Attributes, rtManifestAttributeFindMissing2, pEquals);
|
---|
513 | }
|
---|
514 | return rc;
|
---|
515 | }
|
---|
516 |
|
---|
517 |
|
---|
518 | /**
|
---|
519 | * @callback_method_impl{FNRTSTRSPACECALLBACK, Prepare equals operation}
|
---|
520 | */
|
---|
521 | static DECLCALLBACK(int) rtManifestEntryCompare(PRTSTRSPACECORE pStr, void *pvUser)
|
---|
522 | {
|
---|
523 | PRTMANIFESTEQUALS pEquals = (PRTMANIFESTEQUALS)pvUser;
|
---|
524 | PRTMANIFESTENTRY pEntry1 = RT_FROM_MEMBER(pStr, RTMANIFESTENTRY, StrCore);
|
---|
525 | PRTMANIFESTENTRY pEntry2;
|
---|
526 |
|
---|
527 | /*
|
---|
528 | * Ignore this entry?
|
---|
529 | */
|
---|
530 | char const * const *ppsz = pEquals->papszIgnoreEntries;
|
---|
531 | if (ppsz)
|
---|
532 | {
|
---|
533 | while (*ppsz)
|
---|
534 | {
|
---|
535 | if (!strcmp(*ppsz, pStr->pszString))
|
---|
536 | {
|
---|
537 | pEntry2 = (PRTMANIFESTENTRY)RTStrSpaceGet(&pEquals->pThis2->Entries, pStr->pszString);
|
---|
538 | if (pEntry2)
|
---|
539 | {
|
---|
540 | pEntry2->fVisited = true;
|
---|
541 | pEquals->cIgnoredEntries2++;
|
---|
542 | }
|
---|
543 | pEntry1->fVisited = true;
|
---|
544 | return 0;
|
---|
545 | }
|
---|
546 | ppsz++;
|
---|
547 | }
|
---|
548 | }
|
---|
549 |
|
---|
550 | /*
|
---|
551 | * Try find the entry in the other manifest.
|
---|
552 | */
|
---|
553 | pEntry2 = (PRTMANIFESTENTRY)RTStrSpaceGet(&pEquals->pThis2->Entries, pEntry1->StrCore.pszString);
|
---|
554 | if (!pEntry2)
|
---|
555 | {
|
---|
556 | if (!(pEquals->fFlags & RTMANIFEST_EQUALS_IGN_MISSING_ENTRIES_2ND))
|
---|
557 | {
|
---|
558 | RTStrPrintf(pEquals->pszError, pEquals->cbError, "'%s' not found in the 2nd manifest", pEntry1->StrCore.pszString);
|
---|
559 | return VERR_NOT_EQUAL;
|
---|
560 | }
|
---|
561 | pEntry1->fVisited = true;
|
---|
562 | return VINF_SUCCESS;
|
---|
563 | }
|
---|
564 |
|
---|
565 | Assert(!pEntry1->fVisited);
|
---|
566 | Assert(!pEntry2->fVisited);
|
---|
567 | pEntry1->fVisited = true;
|
---|
568 | pEntry2->fVisited = true;
|
---|
569 | pEquals->cEntries2++;
|
---|
570 |
|
---|
571 | return rtManifestEntryCompare2(pEquals, pEntry1, pEntry2);
|
---|
572 | }
|
---|
573 |
|
---|
574 |
|
---|
575 |
|
---|
576 | RTDECL(int) RTManifestEqualsEx(RTMANIFEST hManifest1, RTMANIFEST hManifest2, const char * const *papszIgnoreEntries,
|
---|
577 | const char * const *papszIgnoreAttrs, uint32_t fFlags, char *pszError, size_t cbError)
|
---|
578 | {
|
---|
579 | /*
|
---|
580 | * Validate input.
|
---|
581 | */
|
---|
582 | AssertPtrNullReturn(pszError, VERR_INVALID_POINTER);
|
---|
583 | if (pszError && cbError)
|
---|
584 | *pszError = '\0';
|
---|
585 | RTMANIFESTINT *pThis1 = hManifest1;
|
---|
586 | RTMANIFESTINT *pThis2 = hManifest2;
|
---|
587 | if (pThis1 != NIL_RTMANIFEST)
|
---|
588 | {
|
---|
589 | AssertPtrReturn(pThis1, VERR_INVALID_HANDLE);
|
---|
590 | AssertReturn(pThis1->u32Magic == RTMANIFEST_MAGIC, VERR_INVALID_HANDLE);
|
---|
591 | }
|
---|
592 | if (pThis2 != NIL_RTMANIFEST)
|
---|
593 | {
|
---|
594 | AssertPtrReturn(pThis2, VERR_INVALID_HANDLE);
|
---|
595 | AssertReturn(pThis2->u32Magic == RTMANIFEST_MAGIC, VERR_INVALID_HANDLE);
|
---|
596 | }
|
---|
597 | AssertReturn(!(fFlags & ~RTMANIFEST_EQUALS_VALID_MASK), VERR_INVALID_PARAMETER);
|
---|
598 |
|
---|
599 | /*
|
---|
600 | * The simple cases.
|
---|
601 | */
|
---|
602 | if (pThis1 == pThis2)
|
---|
603 | return VINF_SUCCESS;
|
---|
604 | if (pThis1 == NIL_RTMANIFEST || pThis2 == NIL_RTMANIFEST)
|
---|
605 | return VERR_NOT_EQUAL;
|
---|
606 |
|
---|
607 | /*
|
---|
608 | * Since we have to use callback style enumeration, we have to mark the
|
---|
609 | * entries and attributes to make sure we've covered them all.
|
---|
610 | */
|
---|
611 | RTStrSpaceEnumerate(&pThis1->Entries, rtManifestEntryClearVisited, NULL);
|
---|
612 | RTStrSpaceEnumerate(&pThis2->Entries, rtManifestEntryClearVisited, NULL);
|
---|
613 | RTStrSpaceEnumerate(&pThis1->SelfEntry.Attributes, rtManifestAttributeClearVisited, NULL);
|
---|
614 | RTStrSpaceEnumerate(&pThis2->SelfEntry.Attributes, rtManifestAttributeClearVisited, NULL);
|
---|
615 |
|
---|
616 | RTMANIFESTEQUALS Equals;
|
---|
617 | Equals.pThis2 = pThis2;
|
---|
618 | Equals.fFlags = fFlags;
|
---|
619 | Equals.papszIgnoreEntries = papszIgnoreEntries;
|
---|
620 | Equals.papszIgnoreAttrs = papszIgnoreAttrs;
|
---|
621 | Equals.pszError = pszError;
|
---|
622 | Equals.cbError = cbError;
|
---|
623 |
|
---|
624 | Equals.cIgnoredEntries2 = 0;
|
---|
625 | Equals.cEntries2 = 0;
|
---|
626 | Equals.cIgnoredAttributes1 = 0;
|
---|
627 | Equals.cIgnoredAttributes2 = 0;
|
---|
628 | Equals.cAttributes2 = 0;
|
---|
629 | Equals.pAttributes2 = NULL;
|
---|
630 | Equals.pszCurEntry = NULL;
|
---|
631 |
|
---|
632 | int rc = rtManifestEntryCompare2(&Equals, &pThis1->SelfEntry, &pThis2->SelfEntry);
|
---|
633 | if (RT_SUCCESS(rc))
|
---|
634 | rc = RTStrSpaceEnumerate(&pThis1->Entries, rtManifestEntryCompare, &Equals);
|
---|
635 | if (RT_SUCCESS(rc))
|
---|
636 | {
|
---|
637 | /*
|
---|
638 | * Did we cover all entries of the 2nd manifest?
|
---|
639 | */
|
---|
640 | if (Equals.cEntries2 + Equals.cIgnoredEntries2 != pThis2->cEntries)
|
---|
641 | rc = RTStrSpaceEnumerate(&pThis1->Entries, rtManifestEntryFindMissing2, &Equals);
|
---|
642 | }
|
---|
643 |
|
---|
644 | return rc;
|
---|
645 | }
|
---|
646 |
|
---|
647 |
|
---|
648 | RTDECL(int) RTManifestEquals(RTMANIFEST hManifest1, RTMANIFEST hManifest2)
|
---|
649 | {
|
---|
650 | return RTManifestEqualsEx(hManifest1, hManifest2,
|
---|
651 | NULL /*papszIgnoreEntries*/, NULL /*papszIgnoreAttrs*/,
|
---|
652 | 0 /*fFlags*/, NULL, 0);
|
---|
653 | }
|
---|
654 |
|
---|
655 |
|
---|
656 | /**
|
---|
657 | * Translates a attribyte type to a attribute name.
|
---|
658 | *
|
---|
659 | * @returns Attribute name for fFlags, NULL if not translatable.
|
---|
660 | * @param fType The type flags. Only one bit should be set.
|
---|
661 | */
|
---|
662 | static const char *rtManifestTypeToAttrName(uint32_t fType)
|
---|
663 | {
|
---|
664 | switch (fType)
|
---|
665 | {
|
---|
666 | case RTMANIFEST_ATTR_SIZE: return "SIZE";
|
---|
667 | case RTMANIFEST_ATTR_MD5: return "MD5";
|
---|
668 | case RTMANIFEST_ATTR_SHA1: return "SHA1";
|
---|
669 | case RTMANIFEST_ATTR_SHA256: return "SHA256";
|
---|
670 | case RTMANIFEST_ATTR_SHA512: return "SHA512";
|
---|
671 | default: return NULL;
|
---|
672 | }
|
---|
673 | }
|
---|
674 |
|
---|
675 |
|
---|
676 | /**
|
---|
677 | * Worker common to RTManifestSetAttr and RTManifestEntrySetAttr.
|
---|
678 | *
|
---|
679 | * @returns IPRT status code.
|
---|
680 | * @param pEntry Pointer to the entry.
|
---|
681 | * @param pszAttr The name of the attribute to add.
|
---|
682 | * @param pszValue The value string.
|
---|
683 | * @param fType The attribute type type.
|
---|
684 | */
|
---|
685 | static int rtManifestSetAttrWorker(PRTMANIFESTENTRY pEntry, const char *pszAttr, const char *pszValue, uint32_t fType)
|
---|
686 | {
|
---|
687 | char *pszValueCopy;
|
---|
688 | int rc = RTStrDupEx(&pszValueCopy, pszValue);
|
---|
689 | if (RT_FAILURE(rc))
|
---|
690 | return rc;
|
---|
691 |
|
---|
692 | /*
|
---|
693 | * Does the attribute exist already?
|
---|
694 | */
|
---|
695 | AssertCompileMemberOffset(RTMANIFESTATTR, StrCore, 0);
|
---|
696 | PRTMANIFESTATTR pAttr = (PRTMANIFESTATTR)RTStrSpaceGet(&pEntry->Attributes, pszAttr);
|
---|
697 | if (pAttr)
|
---|
698 | {
|
---|
699 | RTStrFree(pAttr->pszValue);
|
---|
700 | pAttr->pszValue = pszValueCopy;
|
---|
701 | pAttr->fType = fType;
|
---|
702 | }
|
---|
703 | else
|
---|
704 | {
|
---|
705 | size_t const cbName = strlen(pszAttr) + 1;
|
---|
706 | pAttr = (PRTMANIFESTATTR)RTMemAllocVar(RT_UOFFSETOF_DYN(RTMANIFESTATTR, szName[cbName]));
|
---|
707 | if (!pAttr)
|
---|
708 | {
|
---|
709 | RTStrFree(pszValueCopy);
|
---|
710 | return VERR_NO_MEMORY;
|
---|
711 | }
|
---|
712 | memcpy(pAttr->szName, pszAttr, cbName);
|
---|
713 | pAttr->StrCore.pszString = pAttr->szName;
|
---|
714 | pAttr->StrCore.cchString = cbName - 1;
|
---|
715 | pAttr->pszValue = pszValueCopy;
|
---|
716 | pAttr->fType = fType;
|
---|
717 | if (RT_UNLIKELY(!RTStrSpaceInsert(&pEntry->Attributes, &pAttr->StrCore)))
|
---|
718 | {
|
---|
719 | AssertFailed();
|
---|
720 | RTStrFree(pszValueCopy);
|
---|
721 | RTMemFree(pAttr);
|
---|
722 | return VERR_INTERNAL_ERROR_4;
|
---|
723 | }
|
---|
724 | pEntry->cAttributes++;
|
---|
725 | }
|
---|
726 |
|
---|
727 | return VINF_SUCCESS;
|
---|
728 | }
|
---|
729 |
|
---|
730 |
|
---|
731 | /**
|
---|
732 | * Sets a manifest attribute.
|
---|
733 | *
|
---|
734 | * @returns IPRT status code.
|
---|
735 | * @param hManifest The manifest handle.
|
---|
736 | * @param pszAttr The attribute name. If this already exists,
|
---|
737 | * its value will be replaced.
|
---|
738 | * @param pszValue The value string.
|
---|
739 | * @param fType The attribute type, pass
|
---|
740 | * RTMANIFEST_ATTR_UNKNOWN if not known.
|
---|
741 | */
|
---|
742 | RTDECL(int) RTManifestSetAttr(RTMANIFEST hManifest, const char *pszAttr, const char *pszValue, uint32_t fType)
|
---|
743 | {
|
---|
744 | RTMANIFESTINT *pThis = hManifest;
|
---|
745 | AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
|
---|
746 | AssertReturn(pThis->u32Magic == RTMANIFEST_MAGIC, VERR_INVALID_HANDLE);
|
---|
747 | AssertPtr(pszValue);
|
---|
748 | AssertReturn(RT_IS_POWER_OF_TWO(fType) && fType < RTMANIFEST_ATTR_END, VERR_INVALID_PARAMETER);
|
---|
749 | if (!pszAttr)
|
---|
750 | pszAttr = rtManifestTypeToAttrName(fType);
|
---|
751 | AssertPtr(pszAttr);
|
---|
752 |
|
---|
753 | return rtManifestSetAttrWorker(&pThis->SelfEntry, pszAttr, pszValue, fType);
|
---|
754 | }
|
---|
755 |
|
---|
756 |
|
---|
757 | /**
|
---|
758 | * Worker common to RTManifestUnsetAttr and RTManifestEntryUnsetAttr.
|
---|
759 | *
|
---|
760 | * @returns IPRT status code.
|
---|
761 | * @param pEntry Pointer to the entry.
|
---|
762 | * @param pszAttr The name of the attribute to remove.
|
---|
763 | */
|
---|
764 | static int rtManifestUnsetAttrWorker(PRTMANIFESTENTRY pEntry, const char *pszAttr)
|
---|
765 | {
|
---|
766 | PRTSTRSPACECORE pStrCore = RTStrSpaceRemove(&pEntry->Attributes, pszAttr);
|
---|
767 | if (!pStrCore)
|
---|
768 | return VWRN_NOT_FOUND;
|
---|
769 | pEntry->cAttributes--;
|
---|
770 | rtManifestDestroyAttribute(pStrCore, NULL);
|
---|
771 | return VINF_SUCCESS;
|
---|
772 | }
|
---|
773 |
|
---|
774 |
|
---|
775 | /**
|
---|
776 | * Unsets (removes) a manifest attribute if it exists.
|
---|
777 | *
|
---|
778 | * @returns IPRT status code.
|
---|
779 | * @retval VWRN_NOT_FOUND if not found.
|
---|
780 | *
|
---|
781 | * @param hManifest The manifest handle.
|
---|
782 | * @param pszAttr The attribute name.
|
---|
783 | */
|
---|
784 | RTDECL(int) RTManifestUnsetAttr(RTMANIFEST hManifest, const char *pszAttr)
|
---|
785 | {
|
---|
786 | RTMANIFESTINT *pThis = hManifest;
|
---|
787 | AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
|
---|
788 | AssertReturn(pThis->u32Magic == RTMANIFEST_MAGIC, VERR_INVALID_HANDLE);
|
---|
789 | AssertPtr(pszAttr);
|
---|
790 |
|
---|
791 | return rtManifestUnsetAttrWorker(&pThis->SelfEntry, pszAttr);
|
---|
792 | }
|
---|
793 |
|
---|
794 |
|
---|
795 | /**
|
---|
796 | * Callback employed by rtManifestQueryAttrWorker to search by attribute type.
|
---|
797 | *
|
---|
798 | * @returns VINF_SUCCESS or VINF_CALLBACK_RETURN.
|
---|
799 | * @param pStr The attribute string node.
|
---|
800 | * @param pvUser The argument package.
|
---|
801 | */
|
---|
802 | static DECLCALLBACK(int) rtManifestQueryAttrEnumCallback(PRTSTRSPACECORE pStr, void *pvUser)
|
---|
803 | {
|
---|
804 | PRTMANIFESTATTR pAttr = (PRTMANIFESTATTR)pStr;
|
---|
805 | PRTMANIFESTQUERYATTRARGS pArgs = (PRTMANIFESTQUERYATTRARGS)pvUser;
|
---|
806 |
|
---|
807 | if (pAttr->fType & pArgs->fType)
|
---|
808 | {
|
---|
809 | pArgs->pAttr = pAttr;
|
---|
810 | return VINF_CALLBACK_RETURN;
|
---|
811 | }
|
---|
812 | return VINF_SUCCESS;
|
---|
813 | }
|
---|
814 |
|
---|
815 |
|
---|
816 | /**
|
---|
817 | * Worker common to RTManifestQueryAttr and RTManifestEntryQueryAttr.
|
---|
818 | *
|
---|
819 | * @returns IPRT status code.
|
---|
820 | * @param pEntry The entry.
|
---|
821 | * @param pszAttr The attribute name. If NULL, it will be
|
---|
822 | * selected by @a fType alone.
|
---|
823 | * @param fType The attribute types the entry should match. Pass
|
---|
824 | * Pass RTMANIFEST_ATTR_ANY match any. If more
|
---|
825 | * than one is given, the first matching one is
|
---|
826 | * returned.
|
---|
827 | * @param pszValue Where to return value.
|
---|
828 | * @param cbValue The size of the buffer @a pszValue points to.
|
---|
829 | * @param pfType Where to return the attribute type value.
|
---|
830 | */
|
---|
831 | static int rtManifestQueryAttrWorker(PRTMANIFESTENTRY pEntry, const char *pszAttr, uint32_t fType,
|
---|
832 | char *pszValue, size_t cbValue, uint32_t *pfType)
|
---|
833 | {
|
---|
834 | /*
|
---|
835 | * Find the requested attribute.
|
---|
836 | */
|
---|
837 | PRTMANIFESTATTR pAttr;
|
---|
838 | if (pszAttr)
|
---|
839 | {
|
---|
840 | /* By name. */
|
---|
841 | pAttr = (PRTMANIFESTATTR)RTStrSpaceGet(&pEntry->Attributes, pszAttr);
|
---|
842 | if (!pAttr)
|
---|
843 | return VERR_MANIFEST_ATTR_NOT_FOUND;
|
---|
844 | if (!(pAttr->fType & fType))
|
---|
845 | return VERR_MANIFEST_ATTR_TYPE_MISMATCH;
|
---|
846 | }
|
---|
847 | else
|
---|
848 | {
|
---|
849 | /* By type. */
|
---|
850 | RTMANIFESTQUERYATTRARGS Args;
|
---|
851 | Args.fType = fType;
|
---|
852 | Args.pAttr = NULL;
|
---|
853 | int rc = RTStrSpaceEnumerate(&pEntry->Attributes, rtManifestQueryAttrEnumCallback, &Args);
|
---|
854 | AssertRCReturn(rc, rc);
|
---|
855 | pAttr = Args.pAttr;
|
---|
856 | if (!pAttr)
|
---|
857 | return VERR_MANIFEST_ATTR_TYPE_NOT_FOUND;
|
---|
858 | }
|
---|
859 |
|
---|
860 | /*
|
---|
861 | * Set the return values.
|
---|
862 | */
|
---|
863 | if (cbValue || pszValue)
|
---|
864 | {
|
---|
865 | size_t cbNeeded = strlen(pAttr->pszValue) + 1;
|
---|
866 | if (cbNeeded > cbValue)
|
---|
867 | return VERR_BUFFER_OVERFLOW;
|
---|
868 | memcpy(pszValue, pAttr->pszValue, cbNeeded);
|
---|
869 | }
|
---|
870 |
|
---|
871 | if (pfType)
|
---|
872 | *pfType = pAttr->fType;
|
---|
873 |
|
---|
874 | return VINF_SUCCESS;
|
---|
875 | }
|
---|
876 |
|
---|
877 |
|
---|
878 | RTDECL(int) RTManifestQueryAttr(RTMANIFEST hManifest, const char *pszAttr, uint32_t fType,
|
---|
879 | char *pszValue, size_t cbValue, uint32_t *pfType)
|
---|
880 | {
|
---|
881 | RTMANIFESTINT *pThis = hManifest;
|
---|
882 | AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
|
---|
883 | AssertReturn(pThis->u32Magic == RTMANIFEST_MAGIC, VERR_INVALID_HANDLE);
|
---|
884 | AssertPtrNull(pszAttr);
|
---|
885 | AssertPtr(pszValue);
|
---|
886 |
|
---|
887 | return rtManifestQueryAttrWorker(&pThis->SelfEntry, pszAttr, fType, pszValue, cbValue, pfType);
|
---|
888 | }
|
---|
889 |
|
---|
890 |
|
---|
891 | /**
|
---|
892 | * Callback employed by RTManifestQueryAllAttrTypes to collect attribute types.
|
---|
893 | *
|
---|
894 | * @returns VINF_SUCCESS.
|
---|
895 | * @param pStr The attribute string node.
|
---|
896 | * @param pvUser Pointer to type flags (uint32_t).
|
---|
897 | */
|
---|
898 | static DECLCALLBACK(int) rtManifestQueryAllAttrTypesEnumAttrCallback(PRTSTRSPACECORE pStr, void *pvUser)
|
---|
899 | {
|
---|
900 | PRTMANIFESTATTR pAttr = (PRTMANIFESTATTR)pStr;
|
---|
901 | uint32_t *pfTypes = (uint32_t *)pvUser;
|
---|
902 | *pfTypes |= pAttr->fType;
|
---|
903 | return VINF_SUCCESS;
|
---|
904 | }
|
---|
905 |
|
---|
906 |
|
---|
907 | /**
|
---|
908 | * Callback employed by RTManifestQueryAllAttrTypes to collect attribute types
|
---|
909 | * for an entry.
|
---|
910 | *
|
---|
911 | * @returns VINF_SUCCESS.
|
---|
912 | * @param pStr The attribute string node.
|
---|
913 | * @param pvUser Pointer to type flags (uint32_t).
|
---|
914 | */
|
---|
915 | static DECLCALLBACK(int) rtManifestQueryAllAttrTypesEnumEntryCallback(PRTSTRSPACECORE pStr, void *pvUser)
|
---|
916 | {
|
---|
917 | PRTMANIFESTENTRY pEntry = RT_FROM_MEMBER(pStr, RTMANIFESTENTRY, StrCore);
|
---|
918 | return RTStrSpaceEnumerate(&pEntry->Attributes, rtManifestQueryAllAttrTypesEnumAttrCallback, pvUser);
|
---|
919 | }
|
---|
920 |
|
---|
921 |
|
---|
922 | RTDECL(int) RTManifestQueryAllAttrTypes(RTMANIFEST hManifest, bool fEntriesOnly, uint32_t *pfTypes)
|
---|
923 | {
|
---|
924 | RTMANIFESTINT *pThis = hManifest;
|
---|
925 | AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
|
---|
926 | AssertReturn(pThis->u32Magic == RTMANIFEST_MAGIC, VERR_INVALID_HANDLE);
|
---|
927 | AssertPtr(pfTypes);
|
---|
928 |
|
---|
929 | *pfTypes = 0;
|
---|
930 | int rc = RTStrSpaceEnumerate(&pThis->Entries, rtManifestQueryAllAttrTypesEnumEntryCallback, pfTypes);
|
---|
931 | if (RT_SUCCESS(rc) && fEntriesOnly)
|
---|
932 | rc = rtManifestQueryAllAttrTypesEnumAttrCallback(&pThis->SelfEntry.StrCore, pfTypes);
|
---|
933 | return VINF_SUCCESS;
|
---|
934 | }
|
---|
935 |
|
---|
936 |
|
---|
937 | /**
|
---|
938 | * Validates the name entry.
|
---|
939 | *
|
---|
940 | * @returns IPRT status code.
|
---|
941 | * @param pszEntry The entry name to validate.
|
---|
942 | * @param pfNeedNormalization Where to return whether it needs normalization
|
---|
943 | * or not. Optional.
|
---|
944 | * @param pcchEntry Where to return the length. Optional.
|
---|
945 | */
|
---|
946 | static int rtManifestValidateNameEntry(const char *pszEntry, bool *pfNeedNormalization, size_t *pcchEntry)
|
---|
947 | {
|
---|
948 | int rc;
|
---|
949 | bool fNeedNormalization = false;
|
---|
950 | const char *pszCur = pszEntry;
|
---|
951 |
|
---|
952 | for (;;)
|
---|
953 | {
|
---|
954 | RTUNICP uc;
|
---|
955 | rc = RTStrGetCpEx(&pszCur, &uc);
|
---|
956 | if (RT_FAILURE(rc))
|
---|
957 | return rc;
|
---|
958 | if (!uc)
|
---|
959 | break;
|
---|
960 | if (uc == '\\')
|
---|
961 | fNeedNormalization = true;
|
---|
962 | else if (uc < 32 || uc == ':' || uc == '(' || uc == ')')
|
---|
963 | return VERR_INVALID_NAME;
|
---|
964 | }
|
---|
965 |
|
---|
966 | if (pfNeedNormalization)
|
---|
967 | *pfNeedNormalization = fNeedNormalization;
|
---|
968 |
|
---|
969 | size_t cchEntry = pszCur - pszEntry - 1;
|
---|
970 | if (!cchEntry)
|
---|
971 | rc = VERR_INVALID_NAME;
|
---|
972 | if (pcchEntry)
|
---|
973 | *pcchEntry = cchEntry;
|
---|
974 |
|
---|
975 | return rc;
|
---|
976 | }
|
---|
977 |
|
---|
978 |
|
---|
979 | /**
|
---|
980 | * Normalizes a entry name.
|
---|
981 | *
|
---|
982 | * @param pszEntry The entry name to normalize.
|
---|
983 | */
|
---|
984 | static void rtManifestNormalizeEntry(char *pszEntry)
|
---|
985 | {
|
---|
986 | char ch;
|
---|
987 | while ((ch = *pszEntry))
|
---|
988 | {
|
---|
989 | if (ch == '\\')
|
---|
990 | *pszEntry = '/';
|
---|
991 | pszEntry++;
|
---|
992 | }
|
---|
993 | }
|
---|
994 |
|
---|
995 |
|
---|
996 | /**
|
---|
997 | * Gets an entry.
|
---|
998 | *
|
---|
999 | * @returns IPRT status code.
|
---|
1000 | * @param pThis The manifest to work with.
|
---|
1001 | * @param pszEntry The entry name.
|
---|
1002 | * @param fNeedNormalization Whether rtManifestValidateNameEntry said it
|
---|
1003 | * needed normalization.
|
---|
1004 | * @param cchEntry The length of the name.
|
---|
1005 | * @param ppEntry Where to return the entry pointer on success.
|
---|
1006 | */
|
---|
1007 | static int rtManifestGetEntry(RTMANIFESTINT *pThis, const char *pszEntry, bool fNeedNormalization, size_t cchEntry,
|
---|
1008 | PRTMANIFESTENTRY *ppEntry)
|
---|
1009 | {
|
---|
1010 | PRTMANIFESTENTRY pEntry;
|
---|
1011 |
|
---|
1012 | AssertCompileMemberOffset(RTMANIFESTATTR, StrCore, 0);
|
---|
1013 | if (!fNeedNormalization)
|
---|
1014 | pEntry = (PRTMANIFESTENTRY)RTStrSpaceGet(&pThis->Entries, pszEntry);
|
---|
1015 | else
|
---|
1016 | {
|
---|
1017 | char *pszCopy = (char *)RTMemTmpAlloc(cchEntry + 1);
|
---|
1018 | if (RT_UNLIKELY(!pszCopy))
|
---|
1019 | return VERR_NO_TMP_MEMORY;
|
---|
1020 | memcpy(pszCopy, pszEntry, cchEntry + 1);
|
---|
1021 | rtManifestNormalizeEntry(pszCopy);
|
---|
1022 |
|
---|
1023 | pEntry = (PRTMANIFESTENTRY)RTStrSpaceGet(&pThis->Entries, pszCopy);
|
---|
1024 | RTMemTmpFree(pszCopy);
|
---|
1025 | }
|
---|
1026 |
|
---|
1027 | *ppEntry = pEntry;
|
---|
1028 | return pEntry ? VINF_SUCCESS : VERR_NOT_FOUND;
|
---|
1029 | }
|
---|
1030 |
|
---|
1031 |
|
---|
1032 | /**
|
---|
1033 | * Sets an attribute of a manifest entry.
|
---|
1034 | *
|
---|
1035 | * @returns IPRT status code.
|
---|
1036 | * @param hManifest The manifest handle.
|
---|
1037 | * @param pszEntry The entry name. This will automatically be
|
---|
1038 | * added if there was no previous call to
|
---|
1039 | * RTManifestEntryAdd for this name. See
|
---|
1040 | * RTManifestEntryAdd for the entry name rules.
|
---|
1041 | * @param pszAttr The attribute name. If this already exists,
|
---|
1042 | * its value will be replaced.
|
---|
1043 | * @param pszValue The value string.
|
---|
1044 | * @param fType The attribute type, pass
|
---|
1045 | * RTMANIFEST_ATTR_UNKNOWN if not known.
|
---|
1046 | */
|
---|
1047 | RTDECL(int) RTManifestEntrySetAttr(RTMANIFEST hManifest, const char *pszEntry, const char *pszAttr,
|
---|
1048 | const char *pszValue, uint32_t fType)
|
---|
1049 | {
|
---|
1050 | RTMANIFESTINT *pThis = hManifest;
|
---|
1051 | AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
|
---|
1052 | AssertReturn(pThis->u32Magic == RTMANIFEST_MAGIC, VERR_INVALID_HANDLE);
|
---|
1053 | AssertPtr(pszEntry);
|
---|
1054 | AssertPtr(pszValue);
|
---|
1055 | AssertReturn(RT_IS_POWER_OF_TWO(fType) && fType < RTMANIFEST_ATTR_END, VERR_INVALID_PARAMETER);
|
---|
1056 | if (!pszAttr)
|
---|
1057 | pszAttr = rtManifestTypeToAttrName(fType);
|
---|
1058 | AssertPtr(pszAttr);
|
---|
1059 |
|
---|
1060 | bool fNeedNormalization;
|
---|
1061 | size_t cchEntry;
|
---|
1062 | int rc = rtManifestValidateNameEntry(pszEntry, &fNeedNormalization, &cchEntry);
|
---|
1063 | AssertRCReturn(rc, rc);
|
---|
1064 |
|
---|
1065 | /*
|
---|
1066 | * Resolve the entry, adding one if necessary.
|
---|
1067 | */
|
---|
1068 | PRTMANIFESTENTRY pEntry;
|
---|
1069 | rc = rtManifestGetEntry(pThis, pszEntry, fNeedNormalization, cchEntry, &pEntry);
|
---|
1070 | if (rc == VERR_NOT_FOUND)
|
---|
1071 | {
|
---|
1072 | pEntry = (PRTMANIFESTENTRY)RTMemAlloc(RT_UOFFSETOF_DYN(RTMANIFESTENTRY, szName[cchEntry + 1]));
|
---|
1073 | if (!pEntry)
|
---|
1074 | return VERR_NO_MEMORY;
|
---|
1075 |
|
---|
1076 | pEntry->StrCore.cchString = cchEntry;
|
---|
1077 | pEntry->StrCore.pszString = pEntry->szName;
|
---|
1078 | pEntry->Attributes = NULL;
|
---|
1079 | pEntry->cAttributes = 0;
|
---|
1080 | memcpy(pEntry->szName, pszEntry, cchEntry + 1);
|
---|
1081 | if (fNeedNormalization)
|
---|
1082 | rtManifestNormalizeEntry(pEntry->szName);
|
---|
1083 |
|
---|
1084 | if (!RTStrSpaceInsert(&pThis->Entries, &pEntry->StrCore))
|
---|
1085 | {
|
---|
1086 | RTMemFree(pEntry);
|
---|
1087 | return VERR_INTERNAL_ERROR_4;
|
---|
1088 | }
|
---|
1089 | pThis->cEntries++;
|
---|
1090 | }
|
---|
1091 | else if (RT_FAILURE(rc))
|
---|
1092 | return rc;
|
---|
1093 |
|
---|
1094 | return rtManifestSetAttrWorker(pEntry, pszAttr, pszValue, fType);
|
---|
1095 | }
|
---|
1096 |
|
---|
1097 |
|
---|
1098 | /**
|
---|
1099 | * Unsets (removes) an attribute of a manifest entry if they both exist.
|
---|
1100 | *
|
---|
1101 | * @returns IPRT status code.
|
---|
1102 | * @retval VWRN_NOT_FOUND if not found.
|
---|
1103 | *
|
---|
1104 | * @param hManifest The manifest handle.
|
---|
1105 | * @param pszEntry The entry name.
|
---|
1106 | * @param pszAttr The attribute name.
|
---|
1107 | */
|
---|
1108 | RTDECL(int) RTManifestEntryUnsetAttr(RTMANIFEST hManifest, const char *pszEntry, const char *pszAttr)
|
---|
1109 | {
|
---|
1110 | RTMANIFESTINT *pThis = hManifest;
|
---|
1111 | AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
|
---|
1112 | AssertReturn(pThis->u32Magic == RTMANIFEST_MAGIC, VERR_INVALID_HANDLE);
|
---|
1113 | AssertPtr(pszEntry);
|
---|
1114 | AssertPtr(pszAttr);
|
---|
1115 |
|
---|
1116 | bool fNeedNormalization;
|
---|
1117 | size_t cchEntry;
|
---|
1118 | int rc = rtManifestValidateNameEntry(pszEntry, &fNeedNormalization, &cchEntry);
|
---|
1119 | AssertRCReturn(rc, rc);
|
---|
1120 |
|
---|
1121 | /*
|
---|
1122 | * Resolve the entry and hand it over to the worker.
|
---|
1123 | */
|
---|
1124 | PRTMANIFESTENTRY pEntry;
|
---|
1125 | rc = rtManifestGetEntry(pThis, pszEntry, fNeedNormalization, cchEntry, &pEntry);
|
---|
1126 | if (RT_SUCCESS(rc))
|
---|
1127 | rc = rtManifestUnsetAttrWorker(pEntry, pszAttr);
|
---|
1128 | return rc;
|
---|
1129 | }
|
---|
1130 |
|
---|
1131 |
|
---|
1132 | RTDECL(int) RTManifestEntryQueryAttr(RTMANIFEST hManifest, const char *pszEntry, const char *pszAttr, uint32_t fType,
|
---|
1133 | char *pszValue, size_t cbValue, uint32_t *pfType)
|
---|
1134 | {
|
---|
1135 | RTMANIFESTINT *pThis = hManifest;
|
---|
1136 | AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
|
---|
1137 | AssertReturn(pThis->u32Magic == RTMANIFEST_MAGIC, VERR_INVALID_HANDLE);
|
---|
1138 | AssertPtr(pszEntry);
|
---|
1139 | AssertPtrNull(pszAttr);
|
---|
1140 | AssertPtr(pszValue);
|
---|
1141 |
|
---|
1142 | /*
|
---|
1143 | * Look up the entry.
|
---|
1144 | */
|
---|
1145 | bool fNeedNormalization;
|
---|
1146 | size_t cchEntry;
|
---|
1147 | int rc = rtManifestValidateNameEntry(pszEntry, &fNeedNormalization, &cchEntry);
|
---|
1148 | AssertRCReturn(rc, rc);
|
---|
1149 |
|
---|
1150 | PRTMANIFESTENTRY pEntry;
|
---|
1151 | rc = rtManifestGetEntry(pThis, pszEntry, fNeedNormalization, cchEntry, &pEntry);
|
---|
1152 | if (RT_SUCCESS(rc))
|
---|
1153 | rc = rtManifestQueryAttrWorker(pEntry, pszAttr, fType, pszValue, cbValue, pfType);
|
---|
1154 | return rc;
|
---|
1155 | }
|
---|
1156 |
|
---|
1157 |
|
---|
1158 | /**
|
---|
1159 | * Adds a new entry to a manifest.
|
---|
1160 | *
|
---|
1161 | * The entry name rules:
|
---|
1162 | * - The entry name can contain any character defined by unicode, except
|
---|
1163 | * control characters, ':', '(' and ')'. The exceptions are mainly there
|
---|
1164 | * because of uncertainty around how various formats handles these.
|
---|
1165 | * - It is considered case sensitive.
|
---|
1166 | * - Forward (unix) and backward (dos) slashes are considered path
|
---|
1167 | * separators and converted to forward slashes.
|
---|
1168 | *
|
---|
1169 | * @returns IPRT status code.
|
---|
1170 | * @retval VWRN_ALREADY_EXISTS if the entry already exists.
|
---|
1171 | *
|
---|
1172 | * @param hManifest The manifest handle.
|
---|
1173 | * @param pszEntry The entry name (UTF-8).
|
---|
1174 | *
|
---|
1175 | * @remarks Some manifest formats will not be able to store an entry without
|
---|
1176 | * any attributes. So, this is just here in case it comes in handy
|
---|
1177 | * when dealing with formats which can.
|
---|
1178 | */
|
---|
1179 | RTDECL(int) RTManifestEntryAdd(RTMANIFEST hManifest, const char *pszEntry)
|
---|
1180 | {
|
---|
1181 | RTMANIFESTINT *pThis = hManifest;
|
---|
1182 | AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
|
---|
1183 | AssertReturn(pThis->u32Magic == RTMANIFEST_MAGIC, VERR_INVALID_HANDLE);
|
---|
1184 | AssertPtr(pszEntry);
|
---|
1185 |
|
---|
1186 | bool fNeedNormalization;
|
---|
1187 | size_t cchEntry;
|
---|
1188 | int rc = rtManifestValidateNameEntry(pszEntry, &fNeedNormalization, &cchEntry);
|
---|
1189 | AssertRCReturn(rc, rc);
|
---|
1190 |
|
---|
1191 | /*
|
---|
1192 | * Only add one if it does not already exist.
|
---|
1193 | */
|
---|
1194 | PRTMANIFESTENTRY pEntry;
|
---|
1195 | rc = rtManifestGetEntry(pThis, pszEntry, fNeedNormalization, cchEntry, &pEntry);
|
---|
1196 | if (rc == VERR_NOT_FOUND)
|
---|
1197 | {
|
---|
1198 | pEntry = (PRTMANIFESTENTRY)RTMemAlloc(RT_UOFFSETOF_DYN(RTMANIFESTENTRY, szName[cchEntry + 1]));
|
---|
1199 | if (pEntry)
|
---|
1200 | {
|
---|
1201 | pEntry->StrCore.cchString = cchEntry;
|
---|
1202 | pEntry->StrCore.pszString = pEntry->szName;
|
---|
1203 | pEntry->Attributes = NULL;
|
---|
1204 | pEntry->cAttributes = 0;
|
---|
1205 | memcpy(pEntry->szName, pszEntry, cchEntry + 1);
|
---|
1206 | if (fNeedNormalization)
|
---|
1207 | rtManifestNormalizeEntry(pEntry->szName);
|
---|
1208 |
|
---|
1209 | if (RTStrSpaceInsert(&pThis->Entries, &pEntry->StrCore))
|
---|
1210 | {
|
---|
1211 | pThis->cEntries++;
|
---|
1212 | rc = VINF_SUCCESS;
|
---|
1213 | }
|
---|
1214 | else
|
---|
1215 | {
|
---|
1216 | RTMemFree(pEntry);
|
---|
1217 | rc = VERR_INTERNAL_ERROR_4;
|
---|
1218 | }
|
---|
1219 | }
|
---|
1220 | else
|
---|
1221 | rc = VERR_NO_MEMORY;
|
---|
1222 | }
|
---|
1223 | else if (RT_SUCCESS(rc))
|
---|
1224 | rc = VWRN_ALREADY_EXISTS;
|
---|
1225 |
|
---|
1226 | return rc;
|
---|
1227 | }
|
---|
1228 |
|
---|
1229 |
|
---|
1230 | /**
|
---|
1231 | * Removes an entry.
|
---|
1232 | *
|
---|
1233 | * @returns IPRT status code.
|
---|
1234 | * @param hManifest The manifest handle.
|
---|
1235 | * @param pszEntry The entry name.
|
---|
1236 | */
|
---|
1237 | RTDECL(int) RTManifestEntryRemove(RTMANIFEST hManifest, const char *pszEntry)
|
---|
1238 | {
|
---|
1239 | RTMANIFESTINT *pThis = hManifest;
|
---|
1240 | AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
|
---|
1241 | AssertReturn(pThis->u32Magic == RTMANIFEST_MAGIC, VERR_INVALID_HANDLE);
|
---|
1242 | AssertPtr(pszEntry);
|
---|
1243 |
|
---|
1244 | bool fNeedNormalization;
|
---|
1245 | size_t cchEntry;
|
---|
1246 | int rc = rtManifestValidateNameEntry(pszEntry, &fNeedNormalization, &cchEntry);
|
---|
1247 | AssertRCReturn(rc, rc);
|
---|
1248 |
|
---|
1249 | /*
|
---|
1250 | * Look it up before removing it.
|
---|
1251 | */
|
---|
1252 | PRTMANIFESTENTRY pEntry;
|
---|
1253 | rc = rtManifestGetEntry(pThis, pszEntry, fNeedNormalization, cchEntry, &pEntry);
|
---|
1254 | if (RT_SUCCESS(rc))
|
---|
1255 | {
|
---|
1256 | PRTSTRSPACECORE pStrCore = RTStrSpaceRemove(&pThis->Entries, pEntry->StrCore.pszString);
|
---|
1257 | AssertReturn(pStrCore, VERR_INTERNAL_ERROR_3);
|
---|
1258 | pThis->cEntries--;
|
---|
1259 | rtManifestDestroyEntry(pStrCore, pThis);
|
---|
1260 | }
|
---|
1261 |
|
---|
1262 | return rc;
|
---|
1263 | }
|
---|
1264 |
|
---|
1265 |
|
---|
1266 | RTDECL(bool) RTManifestEntryExists(RTMANIFEST hManifest, const char *pszEntry)
|
---|
1267 | {
|
---|
1268 | RTMANIFESTINT *pThis = hManifest;
|
---|
1269 | AssertPtrReturn(pThis, false);
|
---|
1270 | AssertReturn(pThis->u32Magic == RTMANIFEST_MAGIC, false);
|
---|
1271 | AssertPtr(pszEntry);
|
---|
1272 |
|
---|
1273 | bool fNeedNormalization;
|
---|
1274 | size_t cchEntry;
|
---|
1275 | int rc = rtManifestValidateNameEntry(pszEntry, &fNeedNormalization, &cchEntry);
|
---|
1276 | AssertRCReturn(rc, false);
|
---|
1277 |
|
---|
1278 | /*
|
---|
1279 | * Check if it exists.
|
---|
1280 | */
|
---|
1281 | PRTMANIFESTENTRY pEntry;
|
---|
1282 | rc = rtManifestGetEntry(pThis, pszEntry, fNeedNormalization, cchEntry, &pEntry);
|
---|
1283 | return RT_SUCCESS_NP(rc);
|
---|
1284 | }
|
---|
1285 |
|
---|
1286 |
|
---|
1287 | /**
|
---|
1288 | * Reads a line from a VFS I/O stream.
|
---|
1289 | *
|
---|
1290 | * @todo Replace this with a buffered I/O stream layer.
|
---|
1291 | *
|
---|
1292 | * @returns IPRT status code. VERR_EOF when trying to read beyond the stream
|
---|
1293 | * end.
|
---|
1294 | * @param hVfsIos The I/O stream to read from.
|
---|
1295 | * @param pszLine Where to store what we've read.
|
---|
1296 | * @param cbLine The number of bytes to read.
|
---|
1297 | */
|
---|
1298 | static int rtManifestReadLine(RTVFSIOSTREAM hVfsIos, char *pszLine, size_t cbLine)
|
---|
1299 | {
|
---|
1300 | /* This is horribly slow right now, but it's not a biggy as the input is
|
---|
1301 | usually cached in memory somewhere... */
|
---|
1302 | *pszLine = '\0';
|
---|
1303 | while (cbLine > 1)
|
---|
1304 | {
|
---|
1305 | char ch;
|
---|
1306 | int rc = RTVfsIoStrmRead(hVfsIos, &ch, 1, true /*fBLocking*/, NULL);
|
---|
1307 | if (RT_FAILURE(rc))
|
---|
1308 | return rc;
|
---|
1309 |
|
---|
1310 | /* \r\n */
|
---|
1311 | if (ch == '\r')
|
---|
1312 | {
|
---|
1313 | if (cbLine <= 2)
|
---|
1314 | {
|
---|
1315 | pszLine[0] = ch;
|
---|
1316 | pszLine[1] = '\0';
|
---|
1317 | return VINF_BUFFER_OVERFLOW;
|
---|
1318 | }
|
---|
1319 |
|
---|
1320 | rc = RTVfsIoStrmRead(hVfsIos, &ch, 1, true /*fBLocking*/, NULL);
|
---|
1321 | if (RT_SUCCESS(rc) && ch == '\n')
|
---|
1322 | return VINF_SUCCESS;
|
---|
1323 | pszLine[0] = '\r';
|
---|
1324 | pszLine[1] = ch;
|
---|
1325 | pszLine[2] = '\0';
|
---|
1326 | if (RT_FAILURE(rc))
|
---|
1327 | return rc == VERR_EOF ? VINF_EOF : rc;
|
---|
1328 | }
|
---|
1329 |
|
---|
1330 | /* \n */
|
---|
1331 | if (ch == '\n')
|
---|
1332 | return VINF_SUCCESS;
|
---|
1333 |
|
---|
1334 | /* add character. */
|
---|
1335 | pszLine[0] = ch;
|
---|
1336 | pszLine[1] = '\0';
|
---|
1337 |
|
---|
1338 | /* advance */
|
---|
1339 | pszLine++;
|
---|
1340 | cbLine--;
|
---|
1341 | }
|
---|
1342 |
|
---|
1343 | return VINF_BUFFER_OVERFLOW;
|
---|
1344 | }
|
---|
1345 |
|
---|
1346 |
|
---|
1347 | RTDECL(int) RTManifestReadStandardEx(RTMANIFEST hManifest, RTVFSIOSTREAM hVfsIos, char *pszErr, size_t cbErr)
|
---|
1348 | {
|
---|
1349 | /*
|
---|
1350 | * Validate input.
|
---|
1351 | */
|
---|
1352 | AssertPtrNull(pszErr);
|
---|
1353 | if (pszErr && cbErr)
|
---|
1354 | *pszErr = '\0';
|
---|
1355 | RTMANIFESTINT *pThis = hManifest;
|
---|
1356 | AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
|
---|
1357 | AssertReturn(pThis->u32Magic == RTMANIFEST_MAGIC, VERR_INVALID_HANDLE);
|
---|
1358 |
|
---|
1359 | /*
|
---|
1360 | * Process the stream line by line.
|
---|
1361 | */
|
---|
1362 | uint32_t iLine = 0;
|
---|
1363 | for (;;)
|
---|
1364 | {
|
---|
1365 | /*
|
---|
1366 | * Read a line from the input stream.
|
---|
1367 | */
|
---|
1368 | iLine++;
|
---|
1369 | char szLine[RTPATH_MAX + RTSHA512_DIGEST_LEN + 32];
|
---|
1370 | int rc = rtManifestReadLine(hVfsIos, szLine, sizeof(szLine));
|
---|
1371 | if (RT_FAILURE(rc))
|
---|
1372 | {
|
---|
1373 | if (rc == VERR_EOF)
|
---|
1374 | return VINF_SUCCESS;
|
---|
1375 | RTStrPrintf(pszErr, cbErr, "Error reading line #%u: %Rrc", iLine, rc);
|
---|
1376 | return rc;
|
---|
1377 | }
|
---|
1378 | if (rc != VINF_SUCCESS)
|
---|
1379 | {
|
---|
1380 | RTStrPrintf(pszErr, cbErr, "Line number %u is too long", iLine);
|
---|
1381 | return VERR_OUT_OF_RANGE;
|
---|
1382 | }
|
---|
1383 |
|
---|
1384 | /*
|
---|
1385 | * Strip it and skip if empty.
|
---|
1386 | */
|
---|
1387 | char *psz = RTStrStrip(szLine);
|
---|
1388 | if (!*psz)
|
---|
1389 | continue;
|
---|
1390 |
|
---|
1391 | /*
|
---|
1392 | * Read the attribute name.
|
---|
1393 | */
|
---|
1394 | char ch;
|
---|
1395 | const char * const pszAttr = psz;
|
---|
1396 | do
|
---|
1397 | psz++;
|
---|
1398 | while (!RT_C_IS_BLANK((ch = *psz)) && ch && ch != '(');
|
---|
1399 | if (ch)
|
---|
1400 | *psz++ = '\0';
|
---|
1401 |
|
---|
1402 | /*
|
---|
1403 | * The entry name is enclosed in parenthesis and followed by a '='.
|
---|
1404 | */
|
---|
1405 | if (ch != '(')
|
---|
1406 | {
|
---|
1407 | psz = RTStrStripL(psz);
|
---|
1408 | ch = *psz++;
|
---|
1409 | if (ch != '(')
|
---|
1410 | {
|
---|
1411 | RTStrPrintf(pszErr, cbErr, "Expected '(' after %zu on line %u", psz - szLine - 1, iLine);
|
---|
1412 | return VERR_PARSE_ERROR;
|
---|
1413 | }
|
---|
1414 | }
|
---|
1415 | const char * const pszName = psz;
|
---|
1416 | while ((ch = *psz) != '\0')
|
---|
1417 | {
|
---|
1418 | if (ch == ')')
|
---|
1419 | {
|
---|
1420 | char *psz2 = RTStrStripL(psz + 1);
|
---|
1421 | if (*psz2 == '=')
|
---|
1422 | {
|
---|
1423 | *psz = '\0';
|
---|
1424 | psz = psz2;
|
---|
1425 | break;
|
---|
1426 | }
|
---|
1427 | }
|
---|
1428 | psz++;
|
---|
1429 | }
|
---|
1430 |
|
---|
1431 | if (*psz != '=')
|
---|
1432 | {
|
---|
1433 | RTStrPrintf(pszErr, cbErr, "Expected ')=' at %zu on line %u", psz - szLine, iLine);
|
---|
1434 | return VERR_PARSE_ERROR;
|
---|
1435 | }
|
---|
1436 |
|
---|
1437 | /*
|
---|
1438 | * The value.
|
---|
1439 | */
|
---|
1440 | psz = RTStrStrip(psz + 1);
|
---|
1441 | const char * const pszValue = psz;
|
---|
1442 | if (!*psz)
|
---|
1443 | {
|
---|
1444 | RTStrPrintf(pszErr, cbErr, "Expected value at %zu on line %u", psz - szLine, iLine);
|
---|
1445 | return VERR_PARSE_ERROR;
|
---|
1446 | }
|
---|
1447 |
|
---|
1448 | /*
|
---|
1449 | * Detect attribute type and sanity check the value.
|
---|
1450 | */
|
---|
1451 | uint32_t fType = RTMANIFEST_ATTR_UNKNOWN;
|
---|
1452 | static const struct
|
---|
1453 | {
|
---|
1454 | const char *pszAttr;
|
---|
1455 | uint32_t fType;
|
---|
1456 | unsigned cBits;
|
---|
1457 | unsigned uBase;
|
---|
1458 | } s_aDecAttrs[] =
|
---|
1459 | {
|
---|
1460 | { "SIZE", RTMANIFEST_ATTR_SIZE, 64, 10}
|
---|
1461 | };
|
---|
1462 | for (unsigned i = 0; i < RT_ELEMENTS(s_aDecAttrs); i++)
|
---|
1463 | if (!strcmp(s_aDecAttrs[i].pszAttr, pszAttr))
|
---|
1464 | {
|
---|
1465 | fType = s_aDecAttrs[i].fType;
|
---|
1466 | rc = RTStrToUInt64Full(pszValue, s_aDecAttrs[i].uBase, NULL);
|
---|
1467 | if (rc != VINF_SUCCESS)
|
---|
1468 | {
|
---|
1469 | RTStrPrintf(pszErr, cbErr, "Malformed value ('%s') at %zu on line %u: %Rrc", pszValue, psz - szLine, iLine, rc);
|
---|
1470 | return VERR_PARSE_ERROR;
|
---|
1471 | }
|
---|
1472 | break;
|
---|
1473 | }
|
---|
1474 |
|
---|
1475 | if (fType == RTMANIFEST_ATTR_UNKNOWN)
|
---|
1476 | {
|
---|
1477 | static const struct
|
---|
1478 | {
|
---|
1479 | const char *pszAttr;
|
---|
1480 | uint32_t fType;
|
---|
1481 | unsigned cchHex;
|
---|
1482 | } s_aHexAttrs[] =
|
---|
1483 | {
|
---|
1484 | { "MD5", RTMANIFEST_ATTR_MD5, RTMD5_DIGEST_LEN },
|
---|
1485 | { "SHA1", RTMANIFEST_ATTR_SHA1, RTSHA1_DIGEST_LEN },
|
---|
1486 | { "SHA256", RTMANIFEST_ATTR_SHA256, RTSHA256_DIGEST_LEN },
|
---|
1487 | { "SHA512", RTMANIFEST_ATTR_SHA512, RTSHA512_DIGEST_LEN }
|
---|
1488 | };
|
---|
1489 | for (unsigned i = 0; i < RT_ELEMENTS(s_aHexAttrs); i++)
|
---|
1490 | if (!strcmp(s_aHexAttrs[i].pszAttr, pszAttr))
|
---|
1491 | {
|
---|
1492 | fType = s_aHexAttrs[i].fType;
|
---|
1493 | for (unsigned off = 0; off < s_aHexAttrs[i].cchHex; off++)
|
---|
1494 | if (!RT_C_IS_XDIGIT(pszValue[off]))
|
---|
1495 | {
|
---|
1496 | RTStrPrintf(pszErr, cbErr, "Expected hex digit at %zu on line %u (value '%s', pos %u)",
|
---|
1497 | pszValue - szLine + off, iLine, pszValue, off);
|
---|
1498 | return VERR_PARSE_ERROR;
|
---|
1499 | }
|
---|
1500 | break;
|
---|
1501 | }
|
---|
1502 | }
|
---|
1503 |
|
---|
1504 | /*
|
---|
1505 | * Finally, add it.
|
---|
1506 | */
|
---|
1507 | rc = RTManifestEntrySetAttr(hManifest, pszName, pszAttr, pszValue, fType);
|
---|
1508 | if (RT_FAILURE(rc))
|
---|
1509 | {
|
---|
1510 | RTStrPrintf(pszErr, cbErr, "RTManifestEntrySetAttr(,'%s','%s', '%s', %#x) failed on line %u: %Rrc",
|
---|
1511 | pszName, pszAttr, pszValue, fType, iLine, rc);
|
---|
1512 | return rc;
|
---|
1513 | }
|
---|
1514 | }
|
---|
1515 | }
|
---|
1516 |
|
---|
1517 | RTDECL(int) RTManifestReadStandard(RTMANIFEST hManifest, RTVFSIOSTREAM hVfsIos)
|
---|
1518 | {
|
---|
1519 | return RTManifestReadStandardEx(hManifest, hVfsIos, NULL, 0);
|
---|
1520 | }
|
---|
1521 |
|
---|
1522 |
|
---|
1523 | /**
|
---|
1524 | * @callback_method_impl{FNRTSTRSPACECALLBACK, Writes RTMANIFESTATTR.}
|
---|
1525 | */
|
---|
1526 | static DECLCALLBACK(int) rtManifestWriteStdAttr(PRTSTRSPACECORE pStr, void *pvUser)
|
---|
1527 | {
|
---|
1528 | PRTMANIFESTATTR pAttr = RT_FROM_MEMBER(pStr, RTMANIFESTATTR, StrCore);
|
---|
1529 | RTMANIFESTWRITESTDATTR *pArgs = (RTMANIFESTWRITESTDATTR *)pvUser;
|
---|
1530 | char szLine[RTPATH_MAX + RTSHA512_DIGEST_LEN + 32];
|
---|
1531 | size_t cchLine = RTStrPrintf(szLine, sizeof(szLine), "%s (%s) = %s\n", pAttr->szName, pArgs->pszEntry, pAttr->pszValue);
|
---|
1532 | if (cchLine >= sizeof(szLine) - 1)
|
---|
1533 | return VERR_BUFFER_OVERFLOW;
|
---|
1534 | return RTVfsIoStrmWrite(pArgs->hVfsIos, szLine, cchLine, true /*fBlocking*/, NULL);
|
---|
1535 | }
|
---|
1536 |
|
---|
1537 |
|
---|
1538 | /**
|
---|
1539 | * @callback_method_impl{FNRTSTRSPACECALLBACK, Writes RTMANIFESTENTRY.}
|
---|
1540 | */
|
---|
1541 | static DECLCALLBACK(int) rtManifestWriteStdEntry(PRTSTRSPACECORE pStr, void *pvUser)
|
---|
1542 | {
|
---|
1543 | PRTMANIFESTENTRY pEntry = RT_FROM_MEMBER(pStr, RTMANIFESTENTRY, StrCore);
|
---|
1544 |
|
---|
1545 | RTMANIFESTWRITESTDATTR Args;
|
---|
1546 | Args.hVfsIos = (RTVFSIOSTREAM)pvUser;
|
---|
1547 | Args.pszEntry = pStr->pszString;
|
---|
1548 | return RTStrSpaceEnumerate(&pEntry->Attributes, rtManifestWriteStdAttr, &Args);
|
---|
1549 | }
|
---|
1550 |
|
---|
1551 |
|
---|
1552 | RTDECL(int) RTManifestWriteStandard(RTMANIFEST hManifest, RTVFSIOSTREAM hVfsIos)
|
---|
1553 | {
|
---|
1554 | RTMANIFESTINT *pThis = hManifest;
|
---|
1555 | AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
|
---|
1556 | AssertReturn(pThis->u32Magic == RTMANIFEST_MAGIC, VERR_INVALID_HANDLE);
|
---|
1557 |
|
---|
1558 | RTMANIFESTWRITESTDATTR Args;
|
---|
1559 | Args.hVfsIos = hVfsIos;
|
---|
1560 | Args.pszEntry = "main";
|
---|
1561 | int rc = RTStrSpaceEnumerate(&pThis->SelfEntry.Attributes, rtManifestWriteStdAttr, &Args);
|
---|
1562 | if (RT_SUCCESS(rc))
|
---|
1563 | rc = RTStrSpaceEnumerate(&pThis->Entries, rtManifestWriteStdEntry, hVfsIos);
|
---|
1564 | return rc;
|
---|
1565 | }
|
---|
1566 |
|
---|