VirtualBox

source: vbox/trunk/src/VBox/Runtime/common/checksum/manifest2.cpp@ 45047

Last change on this file since 45047 was 44529, checked in by vboxsync, 12 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette