manifest2.cpp revision 666edc71e2906904545617ad6fae769f7d0bbf08
/* $Id$ */
/** @file
* IPRT - Manifest, the core.
*/
/*
* Copyright (C) 2010 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*
* The contents of this file may alternatively be used under the terms
* of the Common Development and Distribution License Version 1.0
* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
* VirtualBox OSE distribution, in which case the provisions of the
* CDDL are applicable instead of those of the GPL.
*
* You may elect to license modified versions of this file under the
* terms and conditions of either the GPL or the CDDL or both.
*/
/*******************************************************************************
* Header Files *
*******************************************************************************/
#include <iprt/manifest.h>
/*******************************************************************************
* Structures and Typedefs *
*******************************************************************************/
/**
* Manifest attribute.
*
* Used both for entries and manifest attributes.
*/
typedef struct RTMANIFESTATTR
{
/** The string space core (szName). */
/** The property value. */
char *pszValue;
/** The attribute type if applicable, RTMANIFEST_ATTR_UNKNOWN if not. */
/** The normalized property name that StrCore::pszString points at. */
char szName[1];
/** Pointer to a manifest attribute. */
typedef RTMANIFESTATTR *PRTMANIFESTATTR;
/**
* Manifest entry.
*/
typedef struct RTMANIFESTENTRY
{
/** The string space core (szName). */
/** The entry attributes (hashes, checksums, size, etc) -
* RTMANIFESTATTR. */
/** The normalized entry name that StrCore::pszString points at. */
char szName[1];
/** Pointer to a manifest entry. */
typedef RTMANIFESTENTRY *PRTMANIFESTENTRY;
/**
* Manifest handle data.
*/
typedef struct RTMANIFESTINT
{
/** Magic value (RTMANIFEST_MAGIC). */
/** The number of references to this manifest. */
/** Manifest attributes - RTMANIFESTATTR. */
/** String space of the entries covered by this manifest -
* RTMANIFESTENTRY. */
/** The value of RTMANIFESTINT::u32Magic. */
/**
* Creates an empty manifest.
*
* @returns IPRT status code.
* @param fFlags Flags, MBZ.
* @param phManifest Where to return the handle to the manifest.
*/
{
if (!pThis)
return VERR_NO_MEMORY;
*phManifest = pThis;
return VINF_SUCCESS;
}
/**
* Retains a reference to the manifest handle.
*
* @returns The new reference count, UINT32_MAX if the handle is invalid.
* @param hManifest The handle to retain.
*/
{
return cRefs;
}
/**
* @callback_method_impl{FNRTSTRSPACECALLBACK, Destroys RTMANIFESTATTR.}
*/
{
return 0;
}
/**
* @callback_method_impl{FNRTSTRSPACECALLBACK, Destroys RTMANIFESTENTRY.}
*/
{
return 0;
}
/**
* Releases a reference to the manifest handle.
*
* @returns The new reference count, 0 if free. UINT32_MAX is returned if the
* handle is invalid.
* @param hManifest The handle to release.
* NIL is quietly ignored (returns 0).
*/
{
if (pThis == NIL_RTMANIFEST)
return 0;
if (!cRefs)
{
}
return cRefs;
}
/**
* Creates a duplicate of the specified manifest.
*
* @returns IPRT status code
* @param hManifestSrc The manifest to clone.
* @param phManifestDst Where to store the handle to the duplicate.
*/
{
/** @todo implement cloning. */
return VERR_NOT_IMPLEMENTED;
}
/**
* Compares two manifests for equality.
*
* @returns true if equals, false if not.
* @param hManifest1 The first manifest.
* @param hManifest2 The second manifest.
* @param papszIgnoreEntries Entries to ignore. Ends with a NULL entry.
* @param papszIgnoreAttrs Attributes to ignore. Ends with a NULL entry.
*/
RTDECL(int) RTManifestEqualsEx(RTMANIFEST hManifest1, RTMANIFEST hManifest2, const char * const *papszIgnoreEntries,
const char * const *papszIgnoreAttr)
{
if (pThis1 != NIL_RTMANIFEST)
{
AssertPtrReturn(pThis1, false);
}
if (pThis2 != NIL_RTMANIFEST)
{
AssertPtrReturn(pThis2, false);
}
/*
* The simple cases.
*/
return true;
return false;
/*
*
*/
/** @todo implement comparing. */
return VERR_NOT_IMPLEMENTED;
}
/**
* Compares two manifests for equality.
*
* @returns true if equals, false if not.
* @param hManifest1 The first manifest.
* @param hManifest2 The second manifest.
*/
{
return RTManifestEqualsEx(hManifest1, hManifest2, NULL /*papszIgnoreEntries*/, NULL /*papszIgnoreAttrs*/);
}
/**
* Worker common to RTManifestSetAttr and RTManifestEntrySetAttr.
*
* @returns IPRT status code.
* @param pAttributes The attribute container.
* @param pszAttr The name of the attribute to add.
* @param pszValue The value string.
* @param fType The attribute type type.
*/
static int rtManifestSetAttrWorker(PRTSTRSPACE pAttributes, const char *pszAttr, const char *pszValue, uint32_t fType)
{
char *pszValueCopy;
if (RT_FAILURE(rc))
return rc;
/*
* Does the attribute exist already?
*/
if (pAttr)
{
}
else
{
if (!pAttr)
{
return VERR_NO_MEMORY;
}
{
AssertFailed();
return VERR_INTERNAL_ERROR_4;
}
}
return VINF_SUCCESS;
}
/**
* Sets a manifest attribute.
*
* @returns IPRT status code.
* @param hManifest The manifest handle.
* @param pszAttr The attribute name. If this already exists,
* its value will be replaced.
* @param pszValue The value string.
* @param fType The attribute type, pass
* RTMANIFEST_ATTR_UNKNOWN if not known.
*/
RTDECL(int) RTManifestSetAttr(RTMANIFEST hManifest, const char *pszAttr, const char *pszValue, uint32_t fType)
{
}
/**
* Worker common to RTManifestUnsetAttr and RTManifestEntryUnsetAttr.
*
* @returns IPRT status code.
* @param pAttributes The attribute container.
* @param pszAttr The name of the attribute to remove.
*/
{
if (!pStrCore)
return VWRN_NOT_FOUND;
return VINF_SUCCESS;
}
/**
* Unsets (removes) a manifest attribute if it exists.
*
* @returns IPRT status code.
* @retval VWRN_NOT_FOUND if not found.
*
* @param hManifest The manifest handle.
* @param pszAttr The attribute name.
*/
{
}
/**
* Validates the name entry.
*
* @returns IPRT status code.
* @param pszEntry The entry name to validate.
* @param pfNeedNormalization Where to return whether it needs normalization
* or not. Optional.
* @param pcchEntry Where to return the length. Optional.
*/
static int rtManifestValidateNameEntry(const char *pszEntry, bool *pfNeedNormalization, size_t *pcchEntry)
{
int rc;
bool fNeedNormalization = false;
for (;;)
{
if (RT_FAILURE(rc))
break;
if (!uc)
break;
if (uc == '\\')
fNeedNormalization = true;
{
break;
}
}
if (pfNeedNormalization)
if (pcchEntry)
return rc;
}
/**
* Normalizes a entry name.
*
* @param pszEntry The entry name to normalize.
*/
static void rtManifestNormalizeEntry(char *pszEntry)
{
char ch;
{
if (ch == '\\')
*pszEntry = '/';
pszEntry++;
}
}
/**
* Gets an entry.
*
* @returns IPRT status code.
* @param pThis The manifest to work with.
* @param pszEntry The entry name.
* @param fNeedNormalization Whether rtManifestValidateNameEntry said it
* needed normalization.
* @param cchEntry The length of the name.
* @param ppEntry Where to return the entry pointer on success.
*/
static int rtManifestGetEntry(RTMANIFESTINT *pThis, const char *pszEntry, bool fNeedNormalization, size_t cchEntry,
{
if (!fNeedNormalization)
else
{
if (RT_UNLIKELY(!pszCopy))
return VERR_NO_TMP_MEMORY;
}
}
/**
* Sets an attribute of a manifest entry.
*
* @returns IPRT status code.
* @param hManifest The manifest handle.
* @param pszEntry The entry name. This will automatically be
* added if there was no previous call to
* RTManifestEntryAdd for this name. See
* RTManifestEntryAdd for the entry name rules.
* @param pszAttr The attribute name. If this already exists,
* its value will be replaced.
* @param pszValue The value string.
* @param fType The attribute type, pass
* RTMANIFEST_ATTR_UNKNOWN if not known.
*/
{
bool fNeedNormalization;
/*
* Resolve the entry, adding one if necessary.
*/
if (rc == VERR_NOT_FOUND)
{
if (!pEntry)
return VERR_NO_MEMORY;
if (fNeedNormalization)
{
return VERR_INTERNAL_ERROR_4;
}
}
else if (RT_FAILURE(rc))
return rc;
}
/**
* Unsets (removes) an attribute of a manifest entry if they both exist.
*
* @returns IPRT status code.
* @retval VWRN_NOT_FOUND if not found.
*
* @param hManifest The manifest handle.
* @param pszEntry The entry name.
* @param pszAttr The attribute name.
*/
RTDECL(int) RTManifestEntryUnsetAttr(RTMANIFEST hManifest, const char *pszEntry, const char *pszAttr)
{
bool fNeedNormalization;
/*
* Resolve the entry and hand it over to the worker.
*/
if (RT_SUCCESS(rc))
return rc;
}
/**
* Adds a new entry to a manifest.
*
* The entry name rules:
* - The entry name can contain any character defined by unicode, except
* control characters, ':', '(' and ')'. The exceptions are mainly there
* because of uncertainty around how various formats handles these.
* - It is considered case sensitive.
* - Forward (unix) and backward (dos) slashes are considered path
* separators and converted to forward slashes.
*
* @returns IPRT status code.
* @retval VWRN_ALREADY_EXISTS if the entry already exists.
*
* @param hManifest The manifest handle.
* @param pszEntry The entry name (UTF-8).
*
* @remarks Some manifest formats will not be able to store an entry without
* any attributes. So, this is just here in case it comes in handy
* when dealing with formats which can.
*/
{
bool fNeedNormalization;
/*
* Only add one if it does not already exist.
*/
if (rc == VERR_NOT_FOUND)
{
if (pEntry)
{
if (fNeedNormalization)
rc = VINF_SUCCESS;
else
{
}
}
else
rc = VERR_NO_MEMORY;
}
else if (RT_SUCCESS(rc))
return rc;
}
/**
* Removes an entry.
*
* @returns IPRT status code.
* @param hManifest The manifest handle.
* @param pszEntry The entry name.
*/
{
bool fNeedNormalization;
/*
* Only add one if it does not already exist.
*/
if (RT_SUCCESS(rc))
{
}
return rc;
}
/**
* Reads in a "standard" manifest.
*
* This reads the format used by OVF, the distinfo in FreeBSD ports, and
* others.
*
* @returns IPRT status code.
* @param hManifest The handle to the manifest where to add the
* manifest that's read in.
* @param hVfsIos The I/O stream to read the manifest from.
*/
{
return VERR_NOT_IMPLEMENTED;
}
/**
* Writes a "standard" manifest.
*
* This writes the format used by OVF, the distinfo in FreeBSD ports, and
* others.
*
* @returns IPRT status code.
* @param hManifest The handle to the manifest where to add the
* manifest that's read in.
* @param hVfsIos The I/O stream to read the manifest from.
*/
{
return VERR_NOT_IMPLEMENTED;
}