{"id":13000,"date":"2026-08-03T07:31:39","date_gmt":"2026-08-03T07:31:39","guid":{"rendered":"https:\/\/developer.rdkcentral.com\/documentation\/?page_id=13000"},"modified":"2026-08-03T07:32:42","modified_gmt":"2026-08-03T07:32:42","slug":"libpackage","status":"publish","type":"page","link":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/libpackage\/","title":{"rendered":"libpackage"},"content":{"rendered":"\n

Libpackage<\/code> is a shared library that implements the IPackageImpl<\/code> interface, providing the package management abstraction layer for DAC (Downloadable Application Container) applications in RDK. It handles the complete lifecycle of DAC application packages in the RALF (.ralf<\/code>) format: installation to persistent storage, dependency resolution, cryptographic signature verification, on-demand mounting, and removal.<\/p>\n\n\n\n

The library sits between the app management layer above \u2014 which drives install, launch, and remove workflows \u2014 and the libralf<\/code> package-format library below, which provides the underlying mechanics for opening, verifying, and mounting RALF package archives. libpackage<\/code> adds the coordination logic on top: resolving and recursively handling package dependencies, managing mount reference counts, serialising mount metadata as JSON for consumers, and building the certificate verification bundle from the device certificate store.<\/p>\n\n\n\n

At the device level, libpackage<\/code> enables an app management stack that installs and runs containerised DAC applications directly from signed RALF packages. Packages are stored persistently on the filesystem, re-discovered at each library initialisation, and mounted on-demand into isolated directories under \/tmp\/mounts\/<\/code> so that the app runtime can locate and execute application content. Dependency packages are resolved and co-mounted in the same operation, ensuring all shared assets are available before the application is launched.<\/p>\n\n\n\n

At the module level, libpackage<\/code> exposes six operations through the IPackageImpl<\/code> interface: Initialize<\/code>, Install<\/code>, Uninstall<\/code>, Lock<\/code>, Unlock<\/code>, and GetFileMetadata<\/code>. These map directly to the stages of a DAC application lifecycle, and the library is obtained via the IPackageImpl::instance()<\/code> factory, which returns the RalfPackageImpl<\/code> implementation.<\/p>\n\n\n\n

flowchart LR\n\n%% Styles\nclassDef Apps stroke:#00B9F1,fill:#E6F7FD,stroke-width:2px;\nclassDef RDKMW stroke:#75D701,fill:#F1FFE6,stroke-width:2px;\nclassDef VL stroke:#808080,fill:#F2F2F2,stroke-width:2px;\n\n%% Apps Layer\n    subgraph Apps[\"Apps & Runtimes\"]\n        RDKUI[\"UI\"]\n        FBApps[\"Firebolt Apps\"]\n        WPE_RT[\"WPE Runtime\"]\n    end\n\n%% Middleware\n    subgraph RDKMW[\"RDK Core Middleware\"]\n        AM[\"App Manager\"]\n        libpkg[\"libpackage\"]\n        Westeros[\"Westeros\"]\n        Thunder[\"WPEFramework (Thunder)\"]\n    end\n\n%% Vendor Layer\n    subgraph VL[\"Vendor Layer\"]\n        ralflib[\"libralf\"]\n        PkgStore[\"Package Storage\"]\n    end\n\n    Apps -->|\"Firebolt APIs\"| RDKMW\n    AM -->|\"IPackageImpl API\"| libpkg\n    libpkg -->|\"Package open \/ verify \/ mount\"| ralflib\n    libpkg -->|\"R\/W package files\"| PkgStore\n    ralflib --> PkgStore\n\n    class RDKUI,FBApps,WPE_RT Apps\n    class AM,libpkg,Westeros,Thunder RDKMW\n    class ralflib,PkgStore VL<\/pre><\/div>\n\n\n\n
Key Features & Responsibilities:<\/strong><\/p>\n\n\n\n
    \n
  • Package Installation<\/strong>: Accepts a RALF package file locator, performs full cryptographic verification against the device certificate bundle, resolves declared dependencies against the set of already-installed packages, and copies the package to the persistent installation path under DAC_APP_PATH<\/code>.<\/li>\n\n\n\n
  • Dependency Resolution<\/strong>: Before installing or locking a package, reads the package’s embedded metadata to enumerate declared dependencies and verifies that each dependency is already installed in a version that satisfies the declared version constraint.<\/li>\n\n\n\n
  • Certificate-Based Package Verification<\/strong>: Loads all certificate files from RDK_PACKAGE_CERT_PATH<\/code> at initialisation to build a VerificationBundle<\/code>, which is subsequently used by libralf<\/code> to verify package signatures on every open and mount operation.<\/li>\n\n\n\n
  • Package Locking (Mount Management)<\/strong>: Mounts a requested package and all of its transitive dependencies into dedicated directories under \/tmp\/mounts\/<\/code>. Maintains a reference count per mounted package so that shared dependency packages are not prematurely unmounted when they are in use by more than one application.<\/li>\n\n\n\n
  • Mount Metadata Serialisation<\/strong>: After a successful lock, serialises the list of all mounted packages \u2014 including their mount paths and config JSON paths \u2014 into a temporary JSON file, which is returned via ConfigMetaData.ralfPkgPath<\/code> for use by the runtime.<\/li>\n\n\n\n
  • Package Unlocking<\/strong>: Decrements the mount reference count for each package in the dependency tree and unmounts those packages whose count reaches zero.<\/li>\n\n\n\n
  • Installed Package Discovery<\/strong>: On Initialize()<\/code>, scans DAC_APP_PATH<\/code> recursively to discover all packages already present on the filesystem and populates the initial installed-package list and configuration metadata for the caller.<\/li>\n<\/ul>\n\n\n\n
    \n\n\n\n
    Design<\/h2>\n\n\n\n
    libpackage<\/code> is designed as a single-class shared library that implements a well-defined interface contract (IPackageImpl<\/code>) driven by the app management layer above. The design separates the public API surface \u2014 Initialize<\/code>, Install<\/code>, Uninstall<\/code>, Lock<\/code>, Unlock<\/code>, and GetFileMetadata<\/code> \u2014 from the private coordination logic in RalfPackageImpl<\/code>, which handles certificate loading, dependency graph traversal, mount lifecycle, and JSON metadata serialisation. All operations guard against use before initialisation by checking mIsInitialized<\/code> at entry, ensuring that callers receive a deterministic FAILED<\/code> result rather than undefined behaviour if the initialisation sequence is incomplete.<\/p>\n\n\n\n
    Dependency handling uses a recursive descent strategy: the lockPackage()<\/code> function resolves and mounts each dependency before mounting the package itself, matching the order in which the package metadata enumerates dependencies. Mount reference counting in mMountedPackages<\/code> \u2014 a std::map<\/code> keyed on packageId + \"_\" + version<\/code> \u2014 ensures that a dependency shared by multiple applications is mounted once and only unmounted when the last consumer releases it. This design avoids redundant mounts while still allowing independent lock and unlock calls from multiple callers.<\/p>\n\n\n\n
    The northbound interaction with the app management layer is entirely through the IPackageImpl<\/code> interface. The IPackageImpl::instance()<\/code> factory in RalfPackageHandler.cpp<\/code> constructs a RalfPackageImpl<\/code> instance, which is returned as a std::shared_ptr<IPackageImpl><\/code>. This keeps the caller decoupled from the concrete implementation class.<\/p>\n\n\n\n
    The southbound interaction is with the libralf<\/code> library, which handles the RALF archive format. libpackage<\/code> calls ralf::Package::open()<\/code> to parse and validate a package file against the verification bundle, ralf::Package::verify()<\/code> for full signature verification, ralf::Package::mount()<\/code> to mount the archive filesystem, and ralf::Package::metaData()<\/code> to read embedded metadata including dependencies and permissions. libpackage<\/code> holds the resulting ralf::PackageMount<\/code> objects inside the MountedPackageInfo<\/code> structure to ensure they remain live for the duration of the lock.<\/p>\n\n\n\n
    Communication with the app management layer is entirely through the IPackageImpl<\/code> interface via direct in-process function calls. JSON serialisation via jsoncpp<\/code> is scoped to writing mount metadata to the temporary file whose path is returned to the caller via ConfigMetaData.ralfPkgPath<\/code>.<\/p>\n\n\n\n
    Package files are stored persistently on the filesystem at DAC_APP_PATH\/{packageId}\/{version}\/package.ralf<\/code>. Mount points are created transiently under \/tmp\/mounts\/{packageId}_{version}\/rootfs\/<\/code> and are unmounted on Unlock()<\/code> (the mount directories themselves are not removed by libpackage<\/code>). Configuration metadata files (config.json<\/code>) are written alongside each mount point and are re-used on subsequent lock requests to avoid redundant extraction from the archive.<\/p>\n\n\n\n
    graph TD\n\n    subgraph Boundary[\"libpackage (Shared Library \u2014 C++)\"]\n        IFACE[\"IPackageImpl Interface\\nInitialize \u00b7 Install \u00b7 Uninstall\\nLock \u00b7 Unlock \u00b7 GetFileMetadata\"]\n        CertLoader[\"Certificate Loader\\ninitializeVerificationBundle\"]\n        DepCheck[\"Dependency Checker\\ncheckPackageDependencies\"]\n        MountMgr[\"Mount Manager\\nlockPackage \u00b7 unmountDependentPackages\\nmMountedPackages map\"]\n        JsonSer[\"JSON Serialiser\\nserializeToJson \u00b7 dumpPackageInfo\"]\n    end\n\n    ExtRalf[\"libralf\"]\n    ExtJson[\"jsoncpp\"]\n    FS[(\"Filesystem\\nDAC_APP_PATH \/ \/tmp\/mounts\/ \/ RDK_PACKAGE_CERT_PATH\")]\n\n    IFACE --> CertLoader\n    IFACE --> DepCheck\n    IFACE --> MountMgr\n    IFACE --> JsonSer\n    CertLoader -->|\"Certificate::loadFromFile()\"| ExtRalf\n    DepCheck -->|\"Package::metaData() \/ VersionConstraint\"| ExtRalf\n    MountMgr -->|\"Package::open() \/ verify() \/ mount()\"| ExtRalf\n    JsonSer -->|\"toStyledString()\"| ExtJson\n    CertLoader --> FS\n    MountMgr --> FS\n    JsonSer --> FS<\/pre><\/div>\n\n\n\n
    Threading Model<\/h4>\n\n\n\n
      \n
    • Threading Architecture<\/strong>: Single-threaded. All operations execute synchronously on the calling thread.<\/li>\n\n\n\n
    • Main Thread<\/strong>: All IPackageImpl<\/code> operations \u2014 including recursive dependency traversal in lockPackage()<\/code> and filesystem enumeration in Initialize()<\/code> \u2014 run to completion on the caller’s thread before returning.<\/li>\n\n\n\n
    • Synchronization<\/strong>: All operations are synchronous. Thread safety for concurrent access to the same instance is the caller’s responsibility.<\/li>\n<\/ul>\n\n\n\n
      Prerequisites and Dependencies<\/h3>\n\n\n\n
      Platform and Integration Requirements<\/h4>\n\n\n\n
        \n
      • Build Dependencies<\/strong>: packager-headers<\/code> (provides the IPackageImpl<\/code> interface and associated types); ralf-utils<\/code> (provides the libralf<\/code> package format library); jsoncpp<\/code> (JSON value construction and serialisation).<\/li>\n\n\n\n
      • Device Services \/ HAL<\/strong>: libralf<\/code> is the package-format library acting as the abstraction layer below libpackage<\/code>. The full API surface used is: ralf::Package::open()<\/code> (parse and validate a package file with certificate expiry check), ralf::Package::verify()<\/code> (full cryptographic signature verification), ralf::Package::mount()<\/code> (mount the RALF archive rootfs into a directory), ralf::Package::metaData()<\/code> (read embedded package metadata including dependencies, type, and application info), ralf::PackageMount::isMounted()<\/code> \/ ralf::PackageMount::unmount()<\/code> (mount lifecycle control), ralf::Certificate::loadFromFile()<\/code> (load a certificate from a PEM\/DER file), ralf::VersionNumber::fromString()<\/code> (parse a version string), ralf::VersionConstraint::isSatisfiedBy()<\/code> (evaluate whether an installed version satisfies a declared constraint).<\/li>\n\n\n\n
      • Configuration Files<\/strong>: Certificate files located in RDK_PACKAGE_CERT_PATH<\/code> (default \/etc\/rdk\/certs<\/code>) are loaded during Initialize()<\/code> to build the package signature verification bundle.<\/li>\n<\/ul>\n\n\n\n
        \n\n\n\n
        Component State Flow<\/h3>\n\n\n\n
        Initialization to Active State<\/h4>\n\n\n\n
        libpackage<\/code> begins in an uninitialised state immediately after the RalfPackageImpl<\/code> instance is created via IPackageImpl::instance()<\/code>. The Initialize()<\/code> call drives the library through its setup sequence: it first resolves the UID and GID of the designated package-management user via getpwnam()<\/code>, then builds the verification bundle by loading all certificate files found in RDK_PACKAGE_CERT_PATH<\/code>. If either step fails, Initialize()<\/code> returns FAILED<\/code> and mIsInitialized<\/code> remains false<\/code>. When DAC_APP_PATH<\/code> does not yet exist it is created; if it already exists, all package.ralf<\/code> files are discovered recursively and the caller’s ConfigMetadataArray<\/code> is populated with their identifiers, versions, and user\/group ownership. On success, mIsInitialized<\/code> is set to true<\/code>.<\/p>\n\n\n\n
        The component transitions through the following states: Uninitialised<\/strong> (instance created, no operations permitted) \u2192 Initialising<\/strong> (user info lookup, certificate loading, package discovery) \u2192 Active<\/strong> (all six IPackageImpl<\/code> operations available) \u2192 Torn Down<\/strong> (instance destroyed, all PackageMount<\/code> RAII objects released).<\/p>\n\n\n\n
        sequenceDiagram\n    participant AM as App Manager\n    participant LP as libpackage (RalfPackageImpl)\n    participant FS as Filesystem\n    participant RL as libralf\n\n    AM->>LP: IPackageImpl::instance()\n    AM->>LP: Initialize(configStr, configMetadata)\n\n    LP->>FS: getpwnam(\"ralf\") \u2014 resolve UID\/GID\n    FS-->>LP: UID \/ GID\n\n    LP->>FS: Iterate RDK_PACKAGE_CERT_PATH\n    loop Per certificate file\n        LP->>RL: Certificate::loadFromFile(certPath)\n        RL-->>LP: Certificate added to VerificationBundle\n    end\n\n    LP->>FS: Check \/ create DAC_APP_PATH\n    LP->>FS: Recursive scan for package.ralf files\n    FS-->>LP: Installed package paths\n\n    LP-->>AM: Initialize() returns SUCCESS\n    note over LP: mIsInitialized = true<\/pre><\/div>\n\n\n\n
        Runtime State Changes<\/h4>\n\n\n\n
        Once active, libpackage<\/code> responds exclusively to direct API calls. Its internal state evolves only through those calls: the mInstalledPackages<\/code> list grows on Install()<\/code>. Uninstall()<\/code> removes package files from DAC_APP_PATH<\/code> but does not currently remove entries from mInstalledPackages<\/code>, and the mMountedPackages<\/code> map grows on Lock()<\/code> and shrinks on Unlock()<\/code>.<\/p>\n\n\n\n
        State Change Triggers:<\/strong><\/p>\n\n\n\n
          \n
        • Install()<\/code> called with a valid, verified package causes the package to be added to mInstalledPackages<\/code> and its file to be copied to DAC_APP_PATH<\/code>.<\/li>\n\n\n\n
        • Lock()<\/code> called for an already-mounted package increments that package’s mount count rather than performing a new mount, ensuring idempotent behaviour for repeated lock calls for the same app.<\/li>\n\n\n\n
        • Uninstall()<\/code> removes the package files from DAC_APP_PATH<\/code>. When a package has active mounts, Unlock()<\/code> should be called prior to Uninstall()<\/code> to cleanly release the mount.<\/li>\n<\/ul>\n\n\n\n
          Context Switching Scenarios:<\/strong><\/p>\n\n\n\n
            \n
          • A second call to Initialize()<\/code> on the same instance triggers the full setup sequence again, reloading user\/group and certificate information.<\/li>\n<\/ul>\n\n\n\n
            \n\n\n\n
            Call Flows<\/h3>\n\n\n\n
            Initialization Call Flow<\/h4>\n\n\n\n
            sequenceDiagram\n    participant AM as App Manager\n    participant LP as libpackage (RalfPackageImpl)\n    participant FS as Filesystem\n    participant RL as libralf\n\n    AM->>LP: Initialize(configStr, configMetadata)\n    LP->>FS: getpwnam(\"ralf\")\n    FS-->>LP: UID \/ GID resolved\n    LP->>FS: Iterate certificate directory (RDK_PACKAGE_CERT_PATH)\n    loop Per certificate file\n        LP->>RL: Certificate::loadFromFile()\n        RL-->>LP: Certificate loaded into VerificationBundle\n    end\n    LP->>FS: Check \/ create DAC_APP_PATH\n    LP->>FS: Recursive scan for package.ralf\n    loop Per installed package\n        LP->>LP: Extract appId and version from directory path\n        LP->>AM: Populate configMetadata entry\n    end\n    LP-->>AM: Result::SUCCESS<\/pre><\/div>\n\n\n\n
            Request Processing Call Flow<\/h4>\n\n\n\n
            The Lock operation is the most representative call flow, as it combines package opening, dependency resolution, recursive mounting, config extraction, and JSON serialisation into a single synchronous operation.<\/p>\n\n\n\n
            When Lock()<\/code> is called, the package file is opened and validated against the certificate bundle without performing full signature verification (full verification is deferred to explicit verify()<\/code> calls at install time and during the lock mount step). The lockPackage()<\/code> function then recurses into each declared dependency \u2014 opening, mounting, and reference-counting each \u2014 before mounting the requested package itself. On completion, the full list of mounted packages and their metadata paths is serialised to a temporary JSON file, whose path is returned via configMetadata.ralfPkgPath<\/code>.<\/p>\n\n\n\n
            sequenceDiagram\n    participant AM as App Manager\n    participant LP as libpackage (RalfPackageImpl)\n    participant RL as libralf\n    participant FS as Filesystem\n\n    AM->>LP: Lock(packageId, version, unpackedPath, configMetadata, additionalLocks)\n    LP->>FS: Locate DAC_APP_PATH\/packageId\/version\/package.ralf\n    LP->>RL: Package::open(packagePath, verificationBundle)\n    RL-->>LP: Package object\n\n    LP->>LP: lockPackage() \u2014 read metadata, get dependencies\n    loop Per dependency (recursive)\n        LP->>LP: identifyDependencyVersion()\n        LP->>RL: Package::open(depPackagePath, verificationBundle)\n        LP->>RL: Package::verify()\n        RL-->>LP: Verification result\n        LP->>FS: Create mount directory (\/tmp\/mounts\/depId_ver\/rootfs)\n        LP->>RL: Package::mount(mountPath)\n        RL-->>LP: PackageMount object\n        LP->>FS: Write config.json to mount directory\n        LP->>LP: Store in mMountedPackages (or increment mountCount)\n    end\n\n    LP->>RL: Package::verify() \u2014 main package\n    LP->>RL: Package::mount(mountPath)\n    RL-->>LP: PackageMount object\n    LP->>FS: Write config.json\n    LP->>FS: Serialize mount list to temp JSON (pkgId_ver_metadata.json)\n    LP-->>AM: Lock() returns SUCCESS + unpackedPath + configMetadata.ralfPkgPath<\/pre><\/div>\n\n\n\n
            \n\n\n\n
            Internal Modules<\/h2>\n\n\n\n
            Module \/ Class<\/th>Description<\/th>Key Files<\/th><\/tr><\/thead>
            RalfPackageImpl<\/code><\/td>Primary implementation class. Implements all six IPackageImpl<\/code> operations. Owns the verification bundle, the installed-package list, and the mounted-package map. Receives package file paths and serialised configuration strings from the app management layer.<\/td>RalfPackageHandler.cpp<\/code>, RalfPackageImpl.h<\/code><\/td><\/tr>
            IPackageImpl::instance()<\/code><\/td>Factory function that constructs and returns a std::shared_ptr<IPackageImpl><\/code> pointing to a new RalfPackageImpl<\/code>. Acts as the sole entry point for callers obtaining a library instance.<\/td>RalfPackageHandler.cpp<\/code><\/td><\/tr>
            MountedPackageInfo<\/code><\/td>Internal bookkeeping structure. Holds the ralf::PackageMount<\/code> RAII object, the path to the extracted config.json<\/code>, and a reference count for tracking how many concurrent locks hold a given package mounted.<\/td>RalfPackageImpl.h<\/code><\/td><\/tr>
            RalfPackageInfo<\/code><\/td>Plain data structure used during a lock operation to accumulate the mount path and metadata JSON path for each package in the dependency tree before they are serialised to the output JSON file.<\/td>RalfPackageImpl.h<\/code><\/td><\/tr>
            PackageImplTestApp<\/code><\/td>Interactive command-line test utility that exercises all IPackageImpl<\/code> operations. Built only when BUILD_TEST_APP=ON<\/code>. Not included in the production library.<\/td>PackageImplTestApp.cpp<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
            \n\n\n\n
            Component Interactions<\/h2>\n\n\n\n
            All interactions are in-process: the app management layer invokes library operations through the IPackageImpl<\/code> interface, and libpackage<\/code> in turn calls libralf<\/code> and jsoncpp<\/code> as direct shared-library dependencies.<\/p>\n\n\n\n
            Interaction Matrix<\/h3>\n\n\n\n
            Target Component \/ Layer<\/th>Interaction Purpose<\/th>Key APIs<\/th><\/tr><\/thead>
            Libraries<\/strong><\/td><\/td><\/td><\/tr>
            libralf<\/code><\/td>Open, verify, mount, and read metadata from RALF package archives; load X.509 certificates for the verification bundle<\/td>Package::open()<\/code>, Package::verify()<\/code>, Package::mount()<\/code>, Package::metaData()<\/code>, PackageMount::isMounted()<\/code>, PackageMount::unmount()<\/code>, Certificate::loadFromFile()<\/code>, VersionNumber::fromString()<\/code>, VersionConstraint::isSatisfiedBy()<\/code><\/td><\/tr>
            jsoncpp<\/code><\/td>Serialise the list of mounted packages (mount paths and metadata paths) to a JSON file<\/td>Json::Value<\/code>, Json::arrayValue<\/code>, Value::toStyledString()<\/code><\/td><\/tr>
            Filesystem<\/strong><\/td><\/td><\/td><\/tr>
            DAC_APP_PATH<\/code><\/td>Persistent storage for installed RALF package files; enumerated on Initialize()<\/code><\/td>std::filesystem::copy_file()<\/code>, create_directories()<\/code>, remove_all()<\/code>, recursive_directory_iterator()<\/code><\/td><\/tr>
            \/tmp\/mounts\/<\/code><\/td>Transient mount points for locked packages and their dependencies<\/td>std::filesystem::create_directories()<\/code><\/td><\/tr>
            RDK_PACKAGE_CERT_PATH<\/code><\/td>Certificate store read at initialisation to build the VerificationBundle<\/code><\/td>std::filesystem::directory_iterator()<\/code>, Certificate::loadFromFile()<\/code><\/td><\/tr>
            POSIX System<\/strong><\/td><\/td><\/td><\/tr>
            User\/group lookup<\/td>Resolve the UID and GID of the package-management user to set ownership on installed and mounted package directories<\/td>getpwnam()<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
            IPC Flow Patterns<\/h3>\n\n\n\n
            The app management layer accesses libpackage<\/code> through direct in-process function calls via the IPackageImpl<\/code> interface obtained from IPackageImpl::instance()<\/code>.<\/p>\n\n\n\n
            Primary Request \/ Response Flow:<\/strong><\/p>\n\n\n\n
            All operations follow a synchronous call-and-return pattern. The app management layer calls an IPackageImpl<\/code> method, which executes synchronously (including any libralf<\/code> calls and filesystem operations) and returns a Result<\/code> enum (SUCCESS<\/code> or FAILED<\/code>) directly to the caller.<\/p>\n\n\n\n
            sequenceDiagram\n    participant AM as App Manager\n    participant LP as libpackage (RalfPackageImpl)\n    participant RL as libralf\n    participant FS as Filesystem\n\n    AM->>LP: IPackageImpl method call (Install \/ Lock \/ Unlock \/ Uninstall \/ GetFileMetadata)\n    LP->>RL: libralf API call (open \/ verify \/ mount \/ metaData)\n    RL-->>LP: Result\n    LP->>FS: Filesystem operation (read \/ write \/ copy \/ remove)\n    FS-->>LP: Result\n    LP-->>AM: Result::SUCCESS or Result::FAILED<\/pre><\/div>\n\n\n\n
            \n\n\n\n
            Implementation Details<\/h2>\n\n\n\n
            Major HAL APIs Integration<\/h3>\n\n\n\n
            HAL \/ Library API<\/th>Purpose<\/th>Implementation File<\/th><\/tr><\/thead>
            ralf::Package::open()<\/code><\/td>Parse a .ralf<\/code> package archive, validate its certificate against the verification bundle (with expiry check), and return a Package<\/code> object<\/td>RalfPackageHandler.cpp<\/code><\/td><\/tr>
            ralf::Package::verify()<\/code><\/td>Perform full cryptographic signature verification on an opened package<\/td>RalfPackageHandler.cpp<\/code><\/td><\/tr>
            ralf::Package::mount()<\/code><\/td>Mount the package’s rootfs archive into a specified directory path<\/td>RalfPackageHandler.cpp<\/code><\/td><\/tr>
            ralf::Package::metaData()<\/code><\/td>Read the embedded PackageMetaData<\/code> from the package, which includes declared dependencies, package type, and application permissions<\/td>RalfPackageHandler.cpp<\/code><\/td><\/tr>
            ralf::Package::auxMetaDataFile()<\/code><\/td>Extract the embedded auxiliary metadata file matching a given MIME type (application\/vnd.rdk.package.config.v1+json<\/code>)<\/td>RalfPackageHandler.cpp<\/code><\/td><\/tr>
            ralf::PackageMount::isMounted()<\/code><\/td>Query whether a PackageMount<\/code> instance’s filesystem mount is still active<\/td>RalfPackageHandler.cpp<\/code><\/td><\/tr>
            ralf::PackageMount::unmount()<\/code><\/td>Tear down the filesystem mount associated with a PackageMount<\/code> instance<\/td>RalfPackageHandler.cpp<\/code><\/td><\/tr>
            ralf::Certificate::loadFromFile()<\/code><\/td>Load an X.509 certificate from a filesystem path and return it for addition to the VerificationBundle<\/code><\/td>RalfPackageHandler.cpp<\/code><\/td><\/tr>
            ralf::VersionNumber::fromString()<\/code><\/td>Parse a version string into a structured VersionNumber<\/code> for comparison<\/td>RalfPackageHandler.cpp<\/code><\/td><\/tr>
            ralf::VersionConstraint::isSatisfiedBy()<\/code><\/td>Evaluate whether an installed package’s version number satisfies a dependency’s declared version constraint<\/td>RalfPackageHandler.cpp<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
            Key Implementation Logic<\/h3>\n\n\n\n
              \n
            • State \/ Lifecycle Management<\/strong>: The mIsInitialized<\/code> boolean in RalfPackageImpl<\/code> acts as the sole lifecycle guard. All five non-Initialize<\/code> operations check it at entry and return Result::FAILED<\/code> immediately if false<\/code>. State transition logic is confined to Initialize()<\/code> in RalfPackageHandler.cpp<\/code>.<\/li>\n\n\n\n
            • Core implementation: RalfPackageHandler.cpp<\/code><\/li>\n\n\n\n
            • Error Handling Strategy<\/strong>: Errors from libralf<\/code> (returned as ralf::Result<\/code> types with embedded ralf::Error<\/code>) are checked at each call site via the bool<\/code> conversion of the result object. On failure, the specific error message is extracted via .error().what()<\/code> and logged to std::cerr<\/code> with the [libPackage]<\/code> prefix before returning Result::FAILED<\/code> or false<\/code> to the caller. Filesystem errors from std::filesystem<\/code> operations are caught as std::filesystem::filesystem_error<\/code> exceptions in Install()<\/code> and Uninstall()<\/code> and translated to Result::FAILED<\/code>. No retry logic is present; all failures are terminal for that operation.<\/li>\n\n\n\n
            • Logging & Diagnostics<\/strong>: All log output is written to std::cout<\/code> (informational) or std::cerr<\/code> (errors and warnings) using the [libPackage]<\/code> prefix. The build revision string injected via the BUILD_REFERENCE<\/code> compile-time define is logged to std::cout<\/code> at construction time. Dependency check operations are additionally tagged with [DEPENDENCY_CHECK]<\/code>, and mount failures with [RALFMOUNT]<\/code>, to aid log filtering.<\/li>\n<\/ul>\n\n\n\n
              \n\n\n\n
              Configuration<\/h2>\n\n\n\n
              Key Configuration Parameters<\/h3>\n\n\n\n
              All configuration parameters are compile-time constants injected as preprocessor definitions. They cannot be changed at runtime without rebuilding the library.<\/p>\n\n\n\n
              Parameter<\/th>Type<\/th>Default<\/th>Description<\/th><\/tr><\/thead>
              DAC_APP_PATH<\/code><\/td>string (filesystem path)<\/td>\/opt\/media\/apps\/<\/code><\/td>Root directory under which DAC application packages are installed. Created if absent on Initialize()<\/code>.<\/td><\/tr>
              RDK_PACKAGE_CERT_PATH<\/code><\/td>string (filesystem path)<\/td>\/etc\/rdk\/certs<\/code><\/td>Directory from which signing certificates are loaded to build the package VerificationBundle<\/code> used for all package open and verification operations.<\/td><\/tr>
              DISABLE_DEPENDENCY_CHECK<\/code><\/td>bool (compile flag)<\/td>false<\/code> (check enabled)<\/td>When defined, sets RalfPackageImpl::enableDependencyCheck<\/code> to false<\/code>, causing Install()<\/code> and Lock()<\/code> to skip dependency resolution against the installed-package list.<\/td><\/tr>
              BUILD_REFERENCE<\/code><\/td>string<\/td>\"undefined\"<\/code><\/td>Build revision identifier (populated from SRCREV<\/code> by the Yocto recipe). Logged to std::cout<\/code> at library construction time.<\/td><\/tr>
              BUILD_TEST_APP<\/code><\/td>bool (cmake option)<\/td>OFF<\/code><\/td>When ON<\/code>, the PackageImplTestApp<\/code> interactive test executable is compiled and installed. Has no effect on the production libPackage<\/code> shared library.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
              Configuration Persistence<\/h3>\n\n\n\n
              Installed DAC application package files are persisted on the filesystem under DAC_APP_PATH\/{packageId}\/{version}\/package.ralf<\/code> and are re-discovered on each call to Initialize()<\/code>. Mount directories under \/tmp\/mounts\/<\/code> and temporary JSON metadata files written during Lock()<\/code> are transient and re-created on each lock operation.<\/p>\n","protected":false},"excerpt":{"rendered":"
              Libpackage is a shared library that implements the IPackageImpl interface, providing the package management abstraction […]<\/p>\n","protected":false},"author":659,"featured_media":0,"parent":9844,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"_bbp_topic_count":0,"_bbp_reply_count":0,"_bbp_total_topic_count":0,"_bbp_total_reply_count":0,"_bbp_voice_count":0,"_bbp_anonymous_reply_count":0,"_bbp_topic_count_hidden":0,"_bbp_reply_count_hidden":0,"_bbp_forum_subforum_count":0,"footnotes":""},"class_list":["post-13000","page","type-page","status-publish","hentry"],"yoast_head":"\nlibpackage - RDK Documentation Portal | Documentation<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/libpackage\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"libpackage - RDK Documentation Portal | Documentation\" \/>\n<meta property=\"og:description\" content=\"Libpackage is a shared library that implements the IPackageImpl interface, providing the package management abstraction […]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/libpackage\/\" \/>\n<meta property=\"og:site_name\" content=\"RDK Documentation Portal | Documentation\" \/>\n<meta property=\"article:modified_time\" content=\"2026-08-03T07:32:42+00:00\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data1\" content=\"10 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/libpackage\/\",\"url\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/libpackage\/\",\"name\":\"libpackage - RDK Documentation Portal | Documentation\",\"isPartOf\":{\"@id\":\"https:\/\/developer.rdkcentral.com\/documentation\/#website\"},\"datePublished\":\"2026-08-03T07:31:39+00:00\",\"dateModified\":\"2026-08-03T07:32:42+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/libpackage\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/libpackage\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/libpackage\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/developer.rdkcentral.com\/documentation\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Documentation\",\"item\":\"https:\/\/developer.rdkcentral.com\/documentation\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"RDK Video\",\"item\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Components\",\"item\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/\"},{\"@type\":\"ListItem\",\"position\":5,\"name\":\"libpackage\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/developer.rdkcentral.com\/documentation\/#website\",\"url\":\"https:\/\/developer.rdkcentral.com\/documentation\/\",\"name\":\"RDK Documentation Portal | Documentation\",\"description\":\"\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/developer.rdkcentral.com\/documentation\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"libpackage - RDK Documentation Portal | Documentation","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/libpackage\/","og_locale":"en_US","og_type":"article","og_title":"libpackage - RDK Documentation Portal | Documentation","og_description":"Libpackage is a shared library that implements the IPackageImpl interface, providing the package management abstraction […]","og_url":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/libpackage\/","og_site_name":"RDK Documentation Portal | Documentation","article_modified_time":"2026-08-03T07:32:42+00:00","twitter_card":"summary_large_image","twitter_misc":{"Est. reading time":"10 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/libpackage\/","url":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/libpackage\/","name":"libpackage - RDK Documentation Portal | Documentation","isPartOf":{"@id":"https:\/\/developer.rdkcentral.com\/documentation\/#website"},"datePublished":"2026-08-03T07:31:39+00:00","dateModified":"2026-08-03T07:32:42+00:00","breadcrumb":{"@id":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/libpackage\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/libpackage\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/libpackage\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/developer.rdkcentral.com\/documentation\/"},{"@type":"ListItem","position":2,"name":"Documentation","item":"https:\/\/developer.rdkcentral.com\/documentation\/"},{"@type":"ListItem","position":3,"name":"RDK Video","item":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/"},{"@type":"ListItem","position":4,"name":"Components","item":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/"},{"@type":"ListItem","position":5,"name":"libpackage"}]},{"@type":"WebSite","@id":"https:\/\/developer.rdkcentral.com\/documentation\/#website","url":"https:\/\/developer.rdkcentral.com\/documentation\/","name":"RDK Documentation Portal | Documentation","description":"","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/developer.rdkcentral.com\/documentation\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"}]}},"_links":{"self":[{"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/pages\/13000","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/users\/659"}],"replies":[{"embeddable":true,"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/comments?post=13000"}],"version-history":[{"count":1,"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/pages\/13000\/revisions"}],"predecessor-version":[{"id":13001,"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/pages\/13000\/revisions\/13001"}],"up":[{"embeddable":true,"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/pages\/9844"}],"wp:attachment":[{"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/media?parent=13000"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}