> For the complete documentation index, see [llms.txt](https://docs.medcrypt.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.medcrypt.com/guardian/api-overview/api-reference/classes/classmedcrypt-guardian-guardian.md).

# medcrypt::guardian::Guardian

## Overview

The `Guardian` class is the main interface for the Guardian security platform. It provides device provisioning, secure communication, and cryptographic operations for medical devices. It handles the following throughout the device lifecycle:

* Device identity establishment
* Secure connections
* Certificate management

**Include**

```cpp
#include <Guardian.h>
```

### Device provisioning functions

* [Guardian](#function-guardian) : The constructor does no work besides initializing member variables.
* [Initialize](#function-initialize): Uses the provided profile, identity, and trust files to initialize the Guardian system.
* [GenerateProvisionRequest](#function-generateprovisionrequest): This is the first device provisioning step for the provisioning process.
* [StartProvisioningOnline](#function-startprovisioningonline): Start the online device provisioning process.
* [IsProvisioningRunning](#function-isprovisioningrunning): Check if provisioning process is active.
* [GetProvisionedProfile](#function-getprovisionedprofile): Extract provisioned certified profile for device after successful device provisioning.

### Certificate management functions

* [GetCertificateManager:](#function-getcertificatemanager) Retrieve the running certificate manager.
* [GetProvisionedRevocationList](#function-getprovisionedrevocationlist): Retrieve certificate revocation list and populate into buffer.

### **Security operations functions**

* [FindSecureOperation](#function-findsecureoperation): Perform a lookup to get secure operation handler for signing/verification

### **Service management functions**

* [FindService](#function-findservice): Perform a service name lookup to locate a configured service.
* [CreateTask](#function-createtask): Create a task for service, session, or channel operations that separates the provided object and all children from [Run](#function-run).

### **System management functions**

* [GetAuthenticationManager](#function-getauthenticationmanager): Retrieve the running authentication manager.
* [GetTelemetryManager](#function-gettelemetrymanager): Retrieve the running telemetry manager.
* [\~Guardian](#function-~guardian) : The destructor attempts a graceful shutdown of Guardian.
* [Shutdown](#function-shutdown): Clean shutdown of Guardian

## Device setup and provisioning workflow

### Steps overview

#### [Prerequisites: Create Guardian instance](#function-guardian)

**Function:** `Guardian()`

* Creates new Guardian instance
* First step before any other operations
* Initializes member variables and puts system in startup state

#### [Step 1: Device setup](#function-initialize)

**Function:** `Initialize()`

* Must be called first after creating Guardian instance
* Sets up Guardian with initial configuration
* Required before any provisioning operations

#### [Step 2: Generate provisioning request](#function-generateprovisionrequest)

**Function:** `GenerateProvisionRequest()`

* Creates provisioning request (.mcpr) and private identity (.mcpi) files
* Uses provisioning package to generate device keys
* Must be called once before any other provisioning actions

#### [Step 3: Submit and process request](#function-startprovisioningonline)

**Function:** `StartProvisioningOnline()`

* Initiates online provisioning state machine
* Submits provisioning request to Guardian Cloud
* Begins automated processing workflow

#### [Step 4: Monitor provisioning and retrieve device's certified profile](#function-getprovisionedprofile)

**Functions:** `Run()`, `IsProvisioningRunning()`, `GetProvisionedProfile()`

* `Run()` : Executes background provisioning tasks
* `IsProvisioningRunning()` : Checks if provisioning process is still running
* `GetProvisionedProfile()` - Retrieve completed certified profile for device

### Step 1: Run Guardian() <a href="#function-guardian" id="function-guardian"></a>

* **Description:**
  * Creates a new Guardian instance.
  * This is the first step before initializing Guardian with device credentials.
  * This constructor only initializes member variables.
* **Dependencies:** None - this is the first function to call
* **Parameters:** None - default constructor takes no parameters
* **Returns:** Nothing since it is a constructor.
* **Action:** Gets Guardian instance into startup state, ready for initialization (`m_p_guardian`).

**Syntax**

```cpp
Guardian()
```

### Step 2: Run Initialize() <a href="#function-initialize" id="function-initialize"></a>

* **Description:** Initializes Guardian with device credentials and configuration files. Uses the provided profile, identity, and trust files to initialize the guardian system.
* **Dependencies:**
  * Must be called after [creating a Guardian instance](#function-guardian) (`Guardian()` constructor).
  * Must be called before any other Guardian operations
* **Parameters:**
  * `in_files`: Device credentials and configuration files
  * `in_component_handle`: This is the unique component identifier used for provisioning.
    * **Type:** `const char*`
  * `in_hardware_identifier`: This is the unique hardware identifier.
    * **Character limitations:** 36 (37 with null terminator)
    * **Type:** `const char*`
  * `in_options`: Additional initialization configuration options
* **Returns:** Status code indicating success or failure.
  * **Success code:** `OK`**.** Guardian system was successfully initialized.
  * **Error codes:**
    * `FAIL`: General failure. Guardian did not initialize successfully. Check the log file for more information.
    * `BADPARAM`: One of the inputs is null or empty.
    * `FILENOTFOUND`: A required input file is unavailable.
    * `OUTOFMEMORY` **:** Not enough memory to initialize Guardian.
  * **See also:** [All status codes](/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action:** Sets up Guardian with device identity and prepares it for secure operations.

**Syntax**

```cpp
Status Initialize(
    const utilities::InitializeFiles & in_files,
    const char * in_component_handle,
    const char * in_hardware_identifier,
    const InitializeOptions & in_options
)
```

### Step 3: Run GenerateProvisionRequest() <a href="#function-generateprovisionrequest" id="function-generateprovisionrequest"></a>

* **Description:** Creates a provisioning request for device identity establishment.
  * This is the first provisioning step for the provisioning process.
  * This is the only step in the offline provisioning process.
  * Uses input files to generate a provisioning request and private identity
* **Dependencies:**
  * Must be called after `Initialize()`
  * Must be called once before any other provisioning or re-provisioning actions occur.
  * Required before `StartProvisioningOnline()`
* **Parameters:**
  * `io_files` : Provisioning files structure.\
    `in_provisioning_component_handle` : This is the unique component identifier used for provisioning.
    * **Type:** `const char*`
  * `in_provisioning_system` : This is the unique system name identifier which is sent to Guardian Cloud.
    * **Character limitations:** 36 (37 with null terminator)
    * **Type:** `const char*`
  * `in_hardware_identifier` - This is the unique hardware identifier.
    * **Character limitations:** 36 (37 with null terminator)
    * **Type:** `const char*`
* **Returns:** Status code indicating success or failure.
  * **Success code:** `OK`**.** Provisioning request was successfully created
  * **Error codes:**
    * `FAIL`: General failure. Check the log file for more information.
    * `BADPARAM`: One of the inputs is null or empty
    * `FILENOTFOUND`: A required input file is unavailable
    * `NOWRITE`: A required output file could not be written
    * `OUTOFMEMORY` : Not enough memory to provision
  * **See also:** [All status codes](/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Actions:**
  * Generates device keys and creates provisioning request.
  * Will create a private identity ( `PrivateIdentity` ) for the device, as well as the device's provisioning request ( `ProvisionRequest` ).
    * The `PrivateIdentity` includes the generated device keys. This is the **.mcpi** file.
    * The `ProvisionRequest` can be manually uploaded to Guardian Cloud or sent using available online methods in the profile. This is the **.mcpr** file.

**Syntax**

```cpp
Status GenerateProvisionRequest(
    utilities::ProvisionFiles & io_files,
    const char * in_provisioning_component_handle,
    const char * in_provisioning_system,
    const char * in_hardware_identifier
)
```

### Step 4: StartProvisioningOnline() <a href="#function-startprovisioningonline" id="function-startprovisioningonline"></a>

* **Description:** Starts the online provisioning process to submit a provisioning request to Guardian Cloud.
* **Dependencies:** Must be run after [GenerateProvisionRequest()](#function-generateprovisionrequest).
* **Parameters:**
  * `in_files`: Files required for online provisioning
  * `in_options`: Additional optional provisioning configuration options, including timeouts
* **Returns:** Status code indicating success or failure.
  * **Success code:** `OK` : Online provisioning was successfully started
  * **Error codes:**
    * `FAIL` : General failure starting provisioning. Check the log file for more information.
    * `BADPARAM` : One of the inputs is null or invalid
    * `FILENOTFOUND` : A required provisioning file is unavailable
  * **See also:** [All status codes](/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action:** Starts internal provisioning state machine and begins communication with Guardian Cloud

**Syntax**

```cpp
Status StartProvisioningOnline(
    const utilities::ProvisionOnlineFiles & in_files,
    const ProvisioningOptions & in_options
)
```

### Step 5: Monitor provisioning and retrieve device's certified profile

**Process overview:**

1. Call [`Run()`](#function-run) repeatedly to process provisioning tasks
2. Call [`IsProvisioningRunning()`](#function-isprovisioningrunning) to check if provisioning is complete
3. When `IsProvisioningRunning()` returns false, call [`GetProvisionedProfile()`](#function-getprovisionedprofile) to retrieve the certified profile

#### Run() <a href="#function-run" id="function-run"></a>

* **Description:**
  * Executes Guardian background tasks including provisioning state machine processing.
  * Includes provisioning, telemetry, handshakes, authentication, services, sessions, and channels that have not been placed or had a parent placed on another thread by [CreateTask](#function-createtask). This should be called by the program/thread's main loop.
  * Must be called regularly and repeatedly during online provisioning.
  * Use [IsProvisioningRunning()](#function-isprovisioningrunning) to check when provisioning is complete and stop calling Run().
* **Parameters:** No parameters
* **Returns:** Status code indicating success or failure.
  * **Success code:** `OK` - Background tasks executed successfully
  * **Error codes:**
    * `FAIL` - General failure in background processing. Check the log file for more information.
    * `SHUTDOWN` : Guardian is in a shutdown state and must be reinitialized before calling run again.
  * **See also:** [All status codes](/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action:** Processes internal state machines and handles communication with Guardian Cloud

#### IsProvisioningRunning() <a href="#function-isprovisioningrunning" id="function-isprovisioningrunning"></a>

* **Description:** Checks whether the provisioning process is still active.
* **Dependencies:**
  * Must be called after `StartProvisioningOnline()`
  * Used to determine when to stop calling [Run()](#function-run) and attempt to retrieve the provisioned profile.
* **Parameters:** None - this function takes no parameters
* **Returns:** Boolean value indicating provisioning status
  * `true` - Provisioning is still in progress. Continue calling [Run()](#function-run)
  * `false` - Provisioning has completed (successfully or failed). You should now call [GetProvisionedProfile()](#function-getprovisionedprofile).
  * Before the online provisioning process has started, will return `false`.
  * After online provisioning has either succeeded or failed, will again return `false`.
* **Action:** Indicates whether provisioning process is still active

**Syntax**

```cpp
bool IsProvisioningRunning()
```

#### GetProvisionedProfile() <a href="#function-getprovisionedprofile" id="function-getprovisionedprofile"></a>

* **Description:**
  * Extracts the provisioned profile after successful online provisioning.
* **Dependencies:**
  * Must be called only after [IsProvisioningRunning()](#function-isprovisioningrunning) returns `false`.
  * Requires successful completion of `StartProvisioningOnline()` and `Run()` loop
* **Parameters:**
  * `out_profile`: Buffer that will receive the provisioned profile.
    * Type: `char`
  * `io_size`:
    * Provide size of buffer ( `out_profile` ) on input. After successful provisioning, `out_profile` sets to actual size of profile.
    * Type: `size_t`
* **Returns:** Status code indicating success or failure.
  * **Success code:** `OK` : Provisioned profile successfully retrieved.
    * Buffer contains a valid certified profile in `out_profile` of size `io_size`.
  * **Error codes:**
    * `FAIL` : General failure. Check the log file for more information.
    * `INCOMPLETE` : Provisioning process did not complete, thus no profile is available.
    * `BADPARAM` - `out_profile` or `io_size` is null pointer (`nullptr`), or `io_size` is 0
    * `DENIED` - Online provisioning process is still running
    * `FILENOTFOUND` - Provisioning is complete but no provisioned profile is available
    * `BADPARAM` - Buffer or size parameter is invalid
  * **See also:** [All status codes](/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action:** Copies completed provisioned profile to provided buffer.

**Syntax**

```cpp
Status GetProvisionedProfile(
    char * out_profile,
    size_t * io_size
)
```

## Certificate management functions

### GetCertificateManager() <a href="#function-getcertificatemanager" id="function-getcertificatemanager"></a>

* **Description:** Retrieves the certificate manager for handling device certificates. Provides access to certificate operations and lifecycle management.
* **Dependencies:**
  * Can optionally be called after `Initialize()`
* **Parameters:**
  * `out_certificate_manager`: Output pointer to receive the certificate manager instance
* **Returns:** Status code indicating success or failure.
  * **Success code:** `OK` :
    * Certificate manager successfully retrieved
    * The pointer in `out_certificate_manager` is valid
  * **Error codes:**
    * `FAIL` : General failure. Check the log file for more information.
    * `BADPARAM` : `out_certificate_manager` is a null pointer and cannot be filled
    * `DENIED` : Guardian is not initialized
    * `MISCONFIGURED` : The loaded provisioned profile is not configured to allow certificate operations.
  * **See also:** [All status codes](/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action:**
  * Use the retrieved certificate manager to import and export certificates.

**Syntax**

```cpp
Status GetCertificateManager(
    std::unique_ptr< CertificateManager > * out_certificate_manager
)
```

### GetProvisionedRevocationList() <a href="#function-getprovisionedrevocationlist" id="function-getprovisionedrevocationlist"></a>

* **Description:**
  * Retrieves the certificate revocation list (CRL) for checking certificate validity.
  * Used to identify revoked certificates that should no longer be trusted.
* **Dependencies:**
  * Can optionally be called after successful provisioning (after `GetProvisionedProfile` )
* **Parameters:**
  * `out_ccrl`: Buffer to receive the certificate revocation list
    * Type: `char*`
  * `io_size`: Size of buffer on input, actual size on output
    * Provide size of buffer ( `out_ccrl` ) on input. After successful provisioning, `out_ccrl` sets to actual size of CRL.
    * Type: `size_t`
* **Returns:** Status code indicating success or failure.
  * **Success code:** `OK`
    * `out_ccrl` has a valid revocation list of size `io_size`
  * **Error codes:**
    * `FAIL` - General failure. Check the log file for more information.
    * `INCOMPLETE` - Provisioning process did not complete, no revocation list available
    * `BADPARAM` : `out_ccrl` or `io_size` is null pointer, or `io_size` is 0
    * `DENIED` - Online provisioning process is still running
    * `FILENOTFOUND` - Provisioning is complete but no revocation list is available
  * **See also:** [All status codes](/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action:** Copies certificate revocation list to provided buffer

**Syntax**

```cpp
Status GetProvisionedRevocationList(
    char * out_ccrl,
    size_t * io_size
)
```

## Security operations function

### FindSecureOperation() <a href="#function-findsecureoperation" id="function-findsecureoperation"></a>

* **Description:**
  * Perform lookup for secure operation name.
  * Get secure operation handler for signing and verification operations.
* **Dependencies:**
  * Can optionally be called after `Initialize()`
* **Parameters:**
  * `in_secureop_name`: Secure operation name, terminated by null.
    * **Type**: `const char*`
  * `out_secureop`: Pointer to `unique_ptr` storage for located secure operation
* **Returns:** Status code indicating success or failure.
* **Success code:** `OK` : The pointer in `out_secureop` is valid
* **Error codes:**
  * `FAIL` : Could not find the operation specified by `in_secureop_name`
  * `BADPARAM` : `out_secureop` is null pointer and cannot be filled
  * `DENIED` : Guardian is not initialized
* **See also:** [All status codes](/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action:**
  * Sets `out_secureop` to the located operation
  * Will not modify `out_secureop` if the operation `in_secureop_name` is not located

**Syntax**

```cpp
Status FindSecureOperation(
    const char * in_secureop_name,
    std::unique_ptr< SecureOperation > * out_secureop
)
```

## Service management functions

### FindService() <a href="#function-findservice" id="function-findservice"></a>

* **Description:**
  * Performs lookup for service name to locate a configured service.
* **Dependencies:**
  * Must be called after `Initialize()`
* **Parameters:**
  * `in_service_name`: Service name, terminated by null
    * **Type:** `const char*`
  * `out_service`: Pointer to unique\_ptr storage for found service
* **Returns:** Status code indicating success or failure.
  * **Success code:** `OK` : The pointer in `out_service` is valid
  * **Error codes:**
    * `FAIL` : Could not find the service specified by `in_service_name`
    * `BADPARAM` : `out_service` is null pointer and cannot be filled
    * `DENIED` : Guardian is not initialized
  * **See also:** [All status codes](/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action:**
  * Sets `out_service` to the located service
  * Will not modify `out_service` if the service in `in_service_name` is not located
  * or leaves unmodified if the service is not found

**Syntax**

```cpp
Status FindService(
    const char * in_service_name,
    std::unique_ptr< Service > * out_service
)
```

### **CreateTask() - Service variant** <a href="#function-createtask" id="function-createtask"></a>

* **Description:**
  * Create a task for service operations that separates the provided object and all children from Run.
  * Allows for threading of separate objects by removing them from the main Guardian Run loop.
* **Dependencies:**
  * Must be called after `Initialize()`
  * Service object must be valid
* **Parameters:**
  * `io_service`: Service component to place on a thread, will be consumed on success, unmodified on failure
  * `out_task`: Pointer to unique\_ptr storage for the task
* **Returns:** Status code indicating success or failure.
  * **Success code:** `OK` : out\_task has a valid task
  * **Error codes:**
    * `FAIL` : General failure. Check the log file for more information.
    * `BADPARAM` : io\_service or out\_task is null pointer
    * `DENIED` : Specified service is already in a task
  * **See also:** [All status codes](/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action:** A component placed on a Task along with all children will not run when Guardian Run is called, allowing for threading of separate objects

**Syntax**

```cpp
Status CreateTask(
    std::unique_ptr< Service > * io_service,
    std::unique_ptr< Task > * out_task
)
```

### CreateTask() - Session variant <a href="#function-createtask-session" id="function-createtask-session"></a>

* **Description:**
  * Create a task for service operations that separates the provided object and all children from Run.
  * Allows for threading of separate objects by removing them from the main [Run](#function-run) loop.
* **Dependencies:**
  * Can optionally be called after `Initialize()`
  * Service object must be valid
* **Parameters:**
  * `io_service`: Service component to place on a thread. This will be consumed on success, but not modified if not successful.
  * `out_task`: Pointer to `unique_ptr` storage for the task
* **Returns:** Status code indicating success or failure.
  * **Success code:** `OK` : `out_task` has a valid task
  * **Error codes:**
    * `FAIL` : General failure. Check the log file for more information.
    * `BADPARAM` : `io_service` or `out_task` is null pointer
    * `DENIED` : Specified service is already in a task
  * **See also:** [All status codes](/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action:**
  * A component placed on a Task along with all children will not run when [Run](#function-run) is called, allowing for threading of separate objects.
  * To return an object to the main Run loop, destroy the unique\_ptr.

**Syntax**

```cpp
Status CreateTask(
    std::unique_ptr< Session > * io_session,
    std::unique_ptr< Task > * out_task
)
```

### CreateTask() - ChannelGuard Variant <a href="#function-createtask-channelguard" id="function-createtask-channelguard"></a>

* **Description:**
  * Create a task for channel operations that separates the provided object and all children from [Run](#function-run).
  * Allows for threading of separate objects by removing them from the main [Run](#function-run) loop.
* **Dependencies:**
  * Must be called after `Initialize()`
  * `ChannelGuard` object must be valid
* **Parameters:**
  * `io_channelguard`: `ChannelGuard` component to place on a thread
  * `out_task`: Pointer to `unique_ptr` storage for the task
* **Returns:** Status code indicating success or failure.
  * **Success code:** `OK` : `out_task` has a valid task
  * **Error codes:**
    * `FAIL` : General failure. Check the log file for more information.
    * `BADPARAM` : `io_channelguard` or `out_task` is null pointer
    * `DENIED` : Specified `ChannelGuard` is already in a task and has not been returned
  * **See also:** [All status codes](/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action:**
  * A component placed on a Task along with all children will not run when [Run](#function-run) is called, allowing for threading of separate objects.
  * To return an object to the main Run loop, destroy the unique\_ptr.

**Syntax**

```cpp
Status CreateTask(
    std::unique_ptr< ChannelGuard > * io_channelguard,
    std::unique_ptr< Task > * out_task
)
```

## **System management functions**

### GetAuthenticationManager() <a href="#function-getauthenticationmanager" id="function-getauthenticationmanager"></a>

* **Description:**
  * Retrieve the running authentication manager.
  * Provides access to authentication operations and allow/deny lists for user-managed connections.
* **Dependencies:**
  * Can optionally be called after `Initialize()`
* **Parameters:**
  * `out_authentication_manager`: Pointer to unique\_ptr storage for authentication manager
* **Returns:** Status code indicating success or failure.
  * **Success code:** `OK` : The pointer in `out_authentication_manager` is valid
  * **Error codes:**
    * `FAIL` : General failure. Check the log file for more information.
    * `BADPARAM` : `out_authentication_manager` is null pointer and cannot be filled
    * `DENIED` : Guardian is not initialized
    * `MISCONFIGURED` : The loaded profile is not configured to allow external authentication operations
  * **See also:** [All status codes](/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action:** Use the retrieved authentication manager to get allow/deny lists for user managed connections

**Syntax**

```cpp
Status GetAuthenticationManager(
    std::unique_ptr< AuthenticationManager > * out_authentication_manager
)
```

Retrieve the running authentication manager.

### GetTelemetryManager() <a href="#function-gettelemetrymanager" id="function-gettelemetrymanager"></a>

* **Description:**
  * Retrieve the running telemetry manager.
  * Provides access to telemetry service interactions.
* **Dependencies:**
  * Can optionally be called after `Initialize()`
* **Parameters:**
  * `out_telemtry_manager`: Pointer to `unique_ptr` storage for telemetry manager
* **Returns:** Status code indicating success or failure.
  * **Success code:** `OK` : The pointer in `out_telemtry_manager` is valid
  * **Error codes:**
    * `FAIL` : General failure. Check the log file for more information.
    * `BADPARAM` : `out_telemtry_manager` is null pointer and cannot be filled
    * `DENIED` : Guardian is not initialized or there is no telemetry manager running
    * `MISCONFIGURED` : The loaded profile is not configured for telemetry
  * **See also:** [All status codes](/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action:** Use the retrieved telemetry manager to interact with the telemetry service

**Syntax**

```cpp
Status GetTelemetryManager(
    std::unique_ptr< Telemetry > * out_telemtry_manager
)
```

### \~Guardian() <a href="#function-guardian" id="function-guardian"></a>

* **Description:** The destructor attempts a graceful shutdown of Guardian.
* **Dependencies:** None - destructor is automatically called when object goes out of scope or is explicitly deleted
* **Parameters:** None - destructor takes no parameters
* **Returns:** Nothing since it is a destructor.
* **Action:** The destructor will attempt to call [Shutdown](#function-shutdown) for a graceful shutdown, then Guardian will destruct.

**Syntax**

```cpp
~Guardian()
```

### Shutdown() <a href="#function-shutdown" id="function-shutdown"></a>

* **Description:**
  * Attempts to stop all internal state machines, shutting down Guardian.
  * Includes provisioning, telemetry, handshakes, authentication, services, sessions, and channels, INCLUDING those that have been placed or had a parent placed on another thread by [CreateTask](#function-createtask).
* **Dependencies:**
  * Can optionally be called after `Initialize()`
  * If there is data waiting to be sent it will return a failure code or require `in_force`
* **Parameters:**
  * `in_force`: Drop all queued send data and shut down. Default value is `false`.
* **Returns:** Status code indicating success or failure.
  * **Success code:** `OK` : Guardian is shut down successfully
  * **Error codes:**
    * `FAIL` : General failure. Check the log file for more information.
    * `AGAIN` : One or more transports has queued data to send
  * **See also:** [All status codes](/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action:** Stops all internal state machines including provisioning, telemetry, handshakes, authentication, services, sessions, and channels.

**Syntax**

```cpp
Status Shutdown(
    const bool & in_force =false
)
```

## Debugging and logging

Guardian does not create log files. Instead, logging is controlled by the application:

* Guardian logs to `stdout` and `stderr`, which appear in the terminal/CLI of the running application during execution. Look for specific error codes or connection failures in the output.
* **Custom logging:** Use `SetLoggingCallback` to redirect log messages to a callback function, stopping terminal output and allowing custom log handling
* **Log control:** Applications can control log level and verbosity.
* **Guardian Cloud UI**: Check the Guardian Cloud interface for additional error details and provisioning status.