engage-engine 1.234.90740002 → 1.238.90780004

package/include/ConfigurationObjects.h

@@ -53,6 +53,8 @@ namespace ConfigurationObjects
 namespace AppConfigurationObjects
 #endif
 {
+    static const char *ENGAGE_CONFIGURATION_OBJECT_ATTACHED_OBJECT = "_attached";
+
     //-----------------------------------------------------------
     #pragma pack(push, 1)
         typedef struct _DataSeriesHeader_t
@@ -298,6 +300,12 @@ namespace AppConfigurationObjects
     #define FROMJSON_IMPL(__var, __type, __default) \
         getOptional<__type>(#__var, p.__var, j, __default)
 
+    #define TOJSON_BASE_IMPL() \
+        to_json(j, (ConfigurationObjectBase&)p)
+
+    #define FROMJSON_BASE_IMPL() \
+        from_json(j, (ConfigurationObjectBase&)p);
+
 
     //-----------------------------------------------------------
     static std::string EMPTY_STRING;
@@ -408,10 +416,40 @@ namespace AppConfigurationObjects
             return _documenting;
         }
 
+        nlohmann::json      _attached;
+
     protected:
-        bool _documenting;
+        bool                _documenting;
     };
 
+    static void to_json(nlohmann::json& j, const ConfigurationObjectBase& p)
+    {
+        try
+        {
+            if(p._attached != nullptr)
+            {
+                j[ENGAGE_CONFIGURATION_OBJECT_ATTACHED_OBJECT] = p._attached;
+            }
+        }
+        catch(...)
+        {
+        }
+    }
+    static void from_json(const nlohmann::json& j, ConfigurationObjectBase& p)
+    {
+        try
+        {
+            if(j.contains(ENGAGE_CONFIGURATION_OBJECT_ATTACHED_OBJECT))
+            {
+                p._attached = j.at(ENGAGE_CONFIGURATION_OBJECT_ATTACHED_OBJECT);
+            }
+        }
+        catch(...)
+        {
+        }
+    }
+
+
     //-----------------------------------------------------------
     JSON_SERIALIZED_CLASS(FipsCryptoSettings)
     class FipsCryptoSettings : public ConfigurationObjectBase
@@ -2067,6 +2105,22 @@ namespace AppConfigurationObjects
         getOptional<NetworkAddress>("tx", p.tx, j);
     }
 
+    /** @brief Enum describing restriction types. */
+    typedef enum
+    {
+        /** @brief Registration for groups is allowed by default */
+        graptPermissive = 0,
+
+        /** @brief Registration for groups is NOT allowed by default - requires definitive access through something like a whitelist*/
+        graptStrict = 1
+    } GroupRestrictionAccessPolicyType_t;
+
+    static bool isValidGroupRestrictionAccessPolicyType(GroupRestrictionAccessPolicyType_t t)
+    {
+        return (t == GroupRestrictionAccessPolicyType_t::graptPermissive ||
+                t == GroupRestrictionAccessPolicyType_t::graptStrict );
+    }
+
     /** @brief Enum describing restriction types. */
     typedef enum
     {
@@ -2087,6 +2141,43 @@ namespace AppConfigurationObjects
                 t == RestrictionType_t::rtBlacklist );
     }
 
+    /** @brief Enum describing restriction element types. */
+    typedef enum
+    {
+        /** @brief A literal group ID */
+        retGroupId = 0,
+
+        /** @brief Elements are group ID regex patterns */
+        retGroupIdPattern = 1,
+
+        /** @brief Elements are generic access tags regex patterns */
+        retGenericAccessTagPattern = 2,
+
+        /** @brief Elements are X.509 certificate serial number regex patterns */
+        retCertificateSerialNumberPattern = 3,
+
+        /** @brief Elements are X.509 certificate fingerprint regex patterns */
+        retCertificateFingerprintPattern = 4,
+
+        /** @brief Elements are X.509 certificate subject regex patterns */
+        retCertificateSubjectPattern = 5,
+
+        /** @brief Elements are X.509 certificate issuer regex patterns */
+        retCertificateIssuerPattern = 6
+    } RestrictionElementType_t;    
+
+    static bool isValidRestrictionElementType(RestrictionElementType_t t)
+    {
+        return (t == RestrictionElementType_t::retGroupId ||
+                t == RestrictionElementType_t::retGroupIdPattern ||
+                t == RestrictionElementType_t::retGenericAccessTagPattern ||
+                t == RestrictionElementType_t::retCertificateSerialNumberPattern ||
+                t == RestrictionElementType_t::retCertificateFingerprintPattern ||
+                t == RestrictionElementType_t::retCertificateSubjectPattern ||
+                t == RestrictionElementType_t::retCertificateIssuerPattern);
+    }
+
+
     //-----------------------------------------------------------
     JSON_SERIALIZED_CLASS(NetworkAddressRestrictionList)
     /**
@@ -2158,12 +2249,16 @@ namespace AppConfigurationObjects
         /** @brief Type indicating how the elements are to be treated **/
         RestrictionType_t                   type;
 
+        /** @brief Type indicating what kind of data each element contains **/
+        RestrictionElementType_t            elementsType;
+
         /** @brief List of elements */
-        std::vector<std::string>     elements;
+        std::vector<std::string>            elements;
 
         StringRestrictionList()
         {
             type = RestrictionType_t::rtUndefined;
+            elementsType = RestrictionElementType_t::retGroupId;
             clear();
         }
 
@@ -2177,6 +2272,7 @@ namespace AppConfigurationObjects
     {
         j = nlohmann::json{
             TOJSON_IMPL(type),
+            TOJSON_IMPL(elementsType),
             TOJSON_IMPL(elements)
         };
     }
@@ -2184,10 +2280,61 @@ namespace AppConfigurationObjects
     {
         p.clear();
         getOptional<RestrictionType_t>("type", p.type, j, RestrictionType_t::rtUndefined);
+        getOptional<RestrictionElementType_t>("elementsType", p.elementsType, j, RestrictionElementType_t::retGroupId);
         getOptional<std::vector<std::string>>("elements", p.elements, j);
     }
 
 
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(PacketCapturer)
+    /**
+     * @brief Description of a packet capturer
+     *
+     * Helper C++ class to serialize and de-serialize PacketCapturer JSON.
+     *
+     * Example: @include[doc] examples/PacketCapturer.json
+     *
+     */
+    class PacketCapturer : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(PacketCapturer)
+
+    public:
+        bool            enabled;
+        uint32_t        maxMb;
+        std::string     filePrefix;
+
+        PacketCapturer()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            enabled = false;
+            maxMb = 10;
+            filePrefix.clear();
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const PacketCapturer& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(enabled),
+            TOJSON_IMPL(maxMb),
+            TOJSON_IMPL(filePrefix)
+        };
+    }
+    static void from_json(const nlohmann::json& j, PacketCapturer& p)
+    {
+        p.clear();
+        getOptional<bool>("enabled", p.enabled, j, false);
+        getOptional<uint32_t>("maxMb", p.maxMb, j, 10);
+        getOptional<std::string>("filePrefix", p.filePrefix, j, EMPTY_STRING);
+    }
+
+
     //-----------------------------------------------------------
     JSON_SERIALIZED_CLASS(TransportImpairment)
     /**
@@ -2806,7 +2953,7 @@ namespace AppConfigurationObjects
 
 
             /* PCM */
-            /** @brief PCM </a> */
+            /** @brief PCM */
             ctPcm           = 5,
 
             // AMR Narrowband */
@@ -3791,6 +3938,44 @@ namespace AppConfigurationObjects
     ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_SECURITY_CLASSIFICATION_LEVEL_TOO_HIGH = "SecurityClassificationLevelTooHigh";
     /** @brief The Rallypoint has denied the registration for no specific reason **/
     ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_GENERAL_DENIAL = "GeneralDenial";
+
+    /** @brief The Rallypoint denied the registration request because the far-end's certificate does not have an access tag for the group **/
+    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NO_ACCESS_TAG = "NoAccessTag";
+    /** @brief The Rallypoint denied the registration request because the far-end's certificate does not have an access tag for the group **/
+    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_EXCLUDED_ACCESS_TAG = "ExcludedAccessTag";
+    /** @brief The Rallypoint denied the registration request because the far-end's certificate does not have an an approved serial number **/
+    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NO_SERIAL = "NoSerial";
+    /** @brief The Rallypoint denied the registration request because the far-end's certificate serial number has been excluded **/
+    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_EXCLUDED_SERIAL = "ExcludedSerial";
+    /** @brief The Rallypoint denied the registration request because the far-end's certificate does not have an an approved fingerprint **/
+    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NO_FINGERPRINT = "NoFingerprint";
+    /** @brief The Rallypoint denied the registration request because the far-end's certificate fingerprint has been excluded **/
+    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_EXCLUDED_FINGERPRINT = "ExcludedFingerprint";
+    /** @brief The Rallypoint denied the registration request because the far-end's certificate does not have an an approved subject **/
+    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NO_SUBJECT = "NoSubject";
+    /** @brief The Rallypoint denied the registration request because the far-end's certificate subject has been excluded **/
+    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_EXCLUDED_SUBJECT = "ExcludedSubject";
+    /** @brief The Rallypoint denied the registration request because the far-end's certificate does not have an an approved issuer **/
+    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NO_ISSUER = "NoIssuer";
+    /** @brief The Rallypoint denied the registration request because the far-end's certificate issuer has been excluded **/
+    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_EXCLUDED_ISSUER = "ExcludedIssuer";
+    /** @brief The Rallypoint denied the registration request because the far-end does not appear in any whitelist criteria **/
+    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NOT_ON_WHITELIST = "NotOnWhitelist";
+    /** @brief The Rallypoint denied the registration request because the far-end does appears in blackist criteria **/
+    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_ON_BLACKLIST = "OnBlacklist";
+
+    /** @} */
+
+    /** @addtogroup OID IANA-type object identifiers
+     *
+     * Object Identifiers we commonly use
+     *
+     *  @{
+     */
+    /** @brief Rally Tactical Systems' PEN as assigned by IANA */
+    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *OID_RTS_PEM = "58217";
+    /** @brief The link to the Rallypoint is down */
+    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *OID_RTS_CERT_SUBJ_ACCESS_TAGS = "1.3.6.1.4.1.58217.1";    
     /** @} */
 
 
@@ -4448,9 +4633,17 @@ namespace AppConfigurationObjects
         /** @brief [Optional] List of sources to ignore for this group */
         std::vector<Source>                     ignoreSources;
 
-        /** @brief ISO 639-2 lanuguage code for the group  */
+        /** @brief ISO 639-2 language code for the group  */
         std::string                             languageCode;
 
+        /** @brief Name of the synthesis voice to use for the group  */
+        std::string                             synVoice;
+
+        /** @brief Details for capture of received packets  */
+        PacketCapturer                          rxCapture;
+
+        /** @brief Details for capture of transmitted packets  */
+        PacketCapturer                          txCapture;
 
         Group()
         {
@@ -4524,6 +4717,10 @@ namespace AppConfigurationObjects
             ignoreSources.clear();
 
             languageCode.clear();
+            synVoice.clear();
+
+            rxCapture.clear();
+            txCapture.clear();
         }
     };
 
@@ -4581,9 +4778,15 @@ namespace AppConfigurationObjects
 
             TOJSON_IMPL(ignoreSources),
 
-            TOJSON_IMPL(languageCode)
+            TOJSON_IMPL(languageCode),
+            TOJSON_IMPL(synVoice),
+
+            TOJSON_IMPL(rxCapture),
+            TOJSON_IMPL(txCapture)
         };
 
+        TOJSON_BASE_IMPL();
+
         // TODO: need a better way to indicate whether rtpProfile is present
         if(p._wasDeserialized_rtpProfile || p.isDocumenting())
         {
@@ -4655,6 +4858,12 @@ namespace AppConfigurationObjects
         getOptional<uint32_t>("securityLevel", p.securityLevel, j, 0);
         getOptional<std::vector<Source>>("ignoreSources", p.ignoreSources, j);
         getOptional<std::string>("languageCode", p.languageCode, j);
+        getOptional<std::string>("synVoice", p.synVoice, j);        
+
+        getOptional<PacketCapturer>("rxCapture", p.rxCapture, j);
+        getOptional<PacketCapturer>("txCapture", p.txCapture, j);
+
+        FROMJSON_BASE_IMPL();
     }
 
 
@@ -4841,7 +5050,8 @@ namespace AppConfigurationObjects
     static void to_json(nlohmann::json& j, const LicenseDescriptor& p)
     {
         j = nlohmann::json{
-            TOJSON_IMPL(entitlement),
+            //TOJSON_IMPL(entitlement),
+            {"entitlement", "*entitlement*"},
             TOJSON_IMPL(key),
             TOJSON_IMPL(activationCode),
             TOJSON_IMPL(type),
@@ -4850,7 +5060,8 @@ namespace AppConfigurationObjects
             TOJSON_IMPL(flags),
             TOJSON_IMPL(deviceId),
             TOJSON_IMPL(status),
-            TOJSON_IMPL(manufacturerId),
+            //TOJSON_IMPL(manufacturerId),
+            {"manufacturerId", "*manufacturerId*"},
             TOJSON_IMPL(cargo),
             TOJSON_IMPL(cargoFlags)
         };
@@ -7706,9 +7917,15 @@ namespace AppConfigurationObjects
         IMPLEMENT_JSON_DOCUMENTATION(RallypointWebsocketSettings)
 
     public:
+        /** @brief [Default: false] Websocket is enabled */
+        bool                                    enabled;
+
         /** @brief Listen port (TCP).  Default is 8443 */
         int                                     listenPort;
 
+        /** @brief Certificate to be used for WebSockets */
+        SecurityCertificate                     certificate;
+
         RallypointWebsocketSettings()
         {
             clear();
@@ -7716,20 +7933,159 @@ namespace AppConfigurationObjects
 
         void clear()
         {
+            enabled = false;
             listenPort = 8443;
+            certificate.clear();
         }
     };
 
     static void to_json(nlohmann::json& j, const RallypointWebsocketSettings& p)
     {
         j = nlohmann::json{
-            TOJSON_IMPL(listenPort)
+            TOJSON_IMPL(enabled),
+            TOJSON_IMPL(listenPort),
+            TOJSON_IMPL(certificate)
         };
     }
     static void from_json(const nlohmann::json& j, RallypointWebsocketSettings& p)
     {
         p.clear();
+        getOptional<bool>("enabled", p.enabled, j, false);
         getOptional<int>("listenPort", p.listenPort, j, 8443);
+        getOptional<SecurityCertificate>("certificate", p.certificate, j);
+    }
+
+
+
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(RallypointAdvertisingSettings)
+    /**
+     * @brief Defines settings for Rallypoint advertising
+     *
+     * Example: @include[doc] examples/RallypointAdvertisingSettings.json
+     *
+     */
+    class RallypointAdvertisingSettings : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(RallypointAdvertisingSettings)
+
+    public:
+        /** @brief [Default: false] Advertising is enabled */
+        bool                                    enabled;
+
+        /** @brief [Optional] This Rallypoint's mesh name */
+        std::string                             meshName;
+
+        /** @brief [Optional] This Rallypoint's DNS-SD host name */
+        std::string                             hostName;
+
+        /** @brief [Optional, Default "_rallypoint._tcp.local."] The service name */
+        std::string                             serviceName;
+
+        /** @brief The multicast network interface for mDNS */
+        std::string                             interfaceName;
+
+        /** @brief [Default: RP port] The multicast network interface for mDNS */
+        int                                     port;
+
+        /** @brief [Default: 60] TTL for service TTL */
+        int                                     ttl;
+
+        /** @brief [Optional] List of additional meshes that can be reached via this RP */
+        std::vector<std::string>                extraMeshes;
+
+
+        RallypointAdvertisingSettings()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            enabled = false;
+            meshName.clear();
+            hostName.clear();
+            serviceName = "_rallypoint._tcp.local.";
+            interfaceName.clear();
+            port = 0;
+            ttl = 60;
+            extraMeshes.clear();
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const RallypointAdvertisingSettings& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(enabled),
+            TOJSON_IMPL(meshName),
+            TOJSON_IMPL(hostName),
+            TOJSON_IMPL(serviceName),
+            TOJSON_IMPL(interfaceName),
+            TOJSON_IMPL(port),
+            TOJSON_IMPL(ttl),
+            TOJSON_IMPL(extraMeshes)
+        };
+    }
+    static void from_json(const nlohmann::json& j, RallypointAdvertisingSettings& p)
+    {
+        p.clear();
+        getOptional<bool>("enabled", p.enabled, j, false);
+        getOptional<std::string>("meshName", p.meshName, j);
+        getOptional<std::string>("hostName", p.hostName, j);
+        getOptional<std::string>("serviceName", p.serviceName, j, "_rallypoint._tcp.local.");
+        getOptional<std::string>("interfaceName", p.interfaceName, j);
+
+        getOptional<int>("port", p.port, j, 0);
+        getOptional<int>("ttl", p.ttl, j, 60);
+        getOptional<std::vector<std::string>>("extraMeshes", p.extraMeshes, j);
+    }
+
+
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(RallypointExtendedGroupRestriction)
+    /**
+     * @brief Defines settings for Rallypoint extended group restrictions
+     *
+     * Example: @include[doc] examples/RallypointExtendedGroupRestriction.json
+     *
+     */
+    class RallypointExtendedGroupRestriction : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(RallypointExtendedGroupRestriction)
+
+    public:
+        /** @brief Group ID */
+        std::string                             id;
+
+        /** @brief Restrictions */
+        std::vector<StringRestrictionList>      restrictions;
+
+        RallypointExtendedGroupRestriction()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            id.clear();
+            restrictions.clear();
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const RallypointExtendedGroupRestriction& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(id),
+            TOJSON_IMPL(restrictions)
+        };
+    }
+    static void from_json(const nlohmann::json& j, RallypointExtendedGroupRestriction& p)
+    {
+        p.clear();
+        getOptional<std::string>("id", p.id, j);
+        getOptional<std::vector<StringRestrictionList>>("restrictions", p.restrictions, j);
     }
 
 
@@ -7845,6 +8201,12 @@ namespace AppConfigurationObjects
         /** @brief Group IDs to be restricted (inclusive or exclusive) */
         StringRestrictionList                       groupRestrictions;
 
+        /** @brief The policy employed to allow group registration */
+        GroupRestrictionAccessPolicyType_t          groupRestrictionAccessPolicyType;
+
+        /** @brief Extended group restrictions */
+        std::vector<RallypointExtendedGroupRestriction>       extendedGroupRestrictions;
+
         /** @brief Name to use for signalling a configuration check */
         std::string                                 configurationCheckSignalName;
 
@@ -7890,6 +8252,9 @@ namespace AppConfigurationObjects
         /** @brief [Optional] Settings for NSM. */
         NsmConfiguration                            nsm;
 
+        /** @brief [Optional] Settings for advertising. */
+        RallypointAdvertisingSettings               advertising;
+
         RallypointServer()
         {
             clear();
@@ -7944,6 +8309,9 @@ namespace AppConfigurationObjects
             peerRtBehaviors.clear();
             websocket.clear();
             nsm.clear();
+            advertising.clear();
+            extendedGroupRestrictions.clear();
+            groupRestrictionAccessPolicyType = GroupRestrictionAccessPolicyType_t::graptPermissive;
         }
     };
 
@@ -7996,7 +8364,10 @@ namespace AppConfigurationObjects
             TOJSON_IMPL(peerRtTestIntervalMs),
             TOJSON_IMPL(peerRtBehaviors),
             TOJSON_IMPL(websocket),
-            TOJSON_IMPL(nsm)
+            TOJSON_IMPL(nsm),
+            TOJSON_IMPL(advertising),
+            TOJSON_IMPL(extendedGroupRestrictions),
+            TOJSON_IMPL(groupRestrictionAccessPolicyType)
         };
     }
     static void from_json(const nlohmann::json& j, RallypointServer& p)
@@ -8049,6 +8420,9 @@ namespace AppConfigurationObjects
         getOptional<std::vector<RallypointRpRtTimingBehavior>>("peerRtBehaviors", p.peerRtBehaviors, j);
         getOptional<RallypointWebsocketSettings>("websocket", p.websocket, j);
         getOptional<NsmConfiguration>("nsm", p.nsm, j);
+        getOptional<RallypointAdvertisingSettings>("advertising", p.advertising, j);
+        getOptional<std::vector<RallypointExtendedGroupRestriction>>("extendedGroupRestrictions", p.extendedGroupRestrictions, j);        
+        getOptional<GroupRestrictionAccessPolicyType_t>("groupRestrictionAccessPolicyType", p.groupRestrictionAccessPolicyType, j, GroupRestrictionAccessPolicyType_t::graptPermissive);
     }
 
     //-----------------------------------------------------------
@@ -8486,6 +8860,53 @@ namespace AppConfigurationObjects
         getOptional<std::vector<CertStoreCertificateElement>>("certificates", p.certificates, j);
     }
 
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(CertificateSubjectElement)
+    /**
+    * @brief Description of a certificate subject element
+    *
+    * Helper C++ class to serialize and de-serialize CertificateSubjectElement JSON
+    *
+    */
+    class CertificateSubjectElement : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(CertificateSubjectElement)
+
+    public:
+        /** @brief Name */
+        std::string                                     name;
+
+        /** @brief Value */
+        std::string                                     value;
+
+        CertificateSubjectElement()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            name.clear();
+            value.clear();
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const CertificateSubjectElement& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(name),
+            TOJSON_IMPL(value)
+        };
+    }
+    static void from_json(const nlohmann::json& j, CertificateSubjectElement& p)
+    {
+        p.clear();
+        getOptional<std::string>("name", p.name, j, EMPTY_STRING);
+        getOptional<std::string>("value", p.value, j, EMPTY_STRING);
+    }
+
+
     //-----------------------------------------------------------
     JSON_SERIALIZED_CLASS(CertificateDescriptor)
     /**
@@ -8524,6 +8945,9 @@ namespace AppConfigurationObjects
         /** @brief Fingerprint */
         std::string                                     fingerprint;
 
+        /** @brief Array of subject elements */
+        std::vector<CertificateSubjectElement>          subjectElements;
+
         CertificateDescriptor()
         {
             clear();
@@ -8539,6 +8963,7 @@ namespace AppConfigurationObjects
             notAfter.clear();
             serial.clear();
             fingerprint.clear();
+            subjectElements.clear();
         }
     };
 
@@ -8552,7 +8977,8 @@ namespace AppConfigurationObjects
             TOJSON_IMPL(notBefore),
             TOJSON_IMPL(notAfter),
             TOJSON_IMPL(serial),
-            TOJSON_IMPL(fingerprint)
+            TOJSON_IMPL(fingerprint),
+            TOJSON_IMPL(subjectElements)
         };
     }
     static void from_json(const nlohmann::json& j, CertificateDescriptor& p)
@@ -8566,6 +8992,7 @@ namespace AppConfigurationObjects
         getOptional<std::string>("notAfter", p.notAfter, j, EMPTY_STRING);
         getOptional<std::string>("serial", p.serial, j, EMPTY_STRING);
         getOptional<std::string>("fingerprint", p.fingerprint, j, EMPTY_STRING);
+        getOptional<std::vector<CertificateSubjectElement>>("subjectElements", p.subjectElements, j);
     }
 
 

package/include/EngageConstants.h

@@ -9,8 +9,11 @@
 #include <stdint.h>
 
 #if 1
-#include <cstddef>
-#include <cstdint>
+
+#if !defined(__APPLE__)
+    #include <cstddef>
+    #include <cstdint>
+#endif
 
 #ifdef WIN32
     #include <winsock2.h>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engage-engine",
-  "version": "1.234.90740002",
+  "version": "1.238.90780004",
   "description": "Use Engage to communicate with everyone, everywhere, from any device",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"