engage-engine 1.242.90820008 → 1.244.90840009

package/include/ConfigurationObjects.h

@@ -1088,7 +1088,10 @@ namespace AppConfigurationObjects
             bptEngageBinaryHumanBiometrics  = 4,
 
             /** @brief The payload is MIME-encoded as per RFC 2045 */
-            bptAppMimeMessage               = 5
+            bptAppMimeMessage               = 5,
+
+            /** @brief The payload is internal to Engage */
+            bptEngageInternal               = 42
         } PayloadType_t;
 
         /** @brief [Optional, Default : 0] Size of the payload */
@@ -3230,6 +3233,9 @@ namespace AppConfigurationObjects
         /** @brief [Optional, Default: 5] Number of headers to send at the conclusion of a talk burst. */
         int             trailingHeaderBurst;
 
+        /** @brief [Optional, Default: 5] Number of start TX notifications to send when TX is about to begin. */
+        int             startTxNotifications;
+
         /** @brief [Optional, Default: -1] The custom RTP payload type to use for transmission. A value of -1 causes the default
          * Engage-defined RTP payload type to be used for the selected CODEC.
         */
@@ -3268,6 +3274,7 @@ namespace AppConfigurationObjects
             extensionSendInterval = 10;
             initialHeaderBurst = 5;
             trailingHeaderBurst = 5;
+            startTxNotifications = 5;
             customRtpPayloadType = -1;
             internalKey = 0;
             resetRtpOnTx = true;
@@ -3291,6 +3298,7 @@ namespace AppConfigurationObjects
             TOJSON_IMPL(extensionSendInterval),
             TOJSON_IMPL(initialHeaderBurst),
             TOJSON_IMPL(trailingHeaderBurst),
+            TOJSON_IMPL(startTxNotifications),
             TOJSON_IMPL(customRtpPayloadType),
             TOJSON_IMPL(resetRtpOnTx),
             TOJSON_IMPL(enableSmoothing),
@@ -3314,6 +3322,7 @@ namespace AppConfigurationObjects
         getOptional("extensionSendInterval", p.extensionSendInterval, j, 10);
         getOptional("initialHeaderBurst", p.initialHeaderBurst, j, 5);
         getOptional("trailingHeaderBurst", p.trailingHeaderBurst, j, 5);
+        getOptional("startTxNotifications", p.startTxNotifications, j, 5);        
         getOptional("customRtpPayloadType", p.customRtpPayloadType, j, -1);
         getOptional("resetRtpOnTx", p.resetRtpOnTx, j, true);
         getOptional("enableSmoothing", p.enableSmoothing, j, true);
@@ -4331,6 +4340,9 @@ namespace AppConfigurationObjects
         /** @brief [NOT USED AT THIS TIME] */
         StringRestrictionList       issuerRestrictions;
 
+        /** @brief [Optional] Array of serial numbers certificates that have been revoked*/
+        std::vector<std::string>    crlSerials;
+
         Tls()
         {
             clear();
@@ -4343,6 +4355,7 @@ namespace AppConfigurationObjects
             caCertificates.clear();
             subjectRestrictions.clear();
             issuerRestrictions.clear();
+            crlSerials.clear();
         }
     };
 
@@ -4353,7 +4366,8 @@ namespace AppConfigurationObjects
             TOJSON_IMPL(allowSelfSignedCertificates),
             TOJSON_IMPL(caCertificates),
             TOJSON_IMPL(subjectRestrictions),
-            TOJSON_IMPL(issuerRestrictions)
+            TOJSON_IMPL(issuerRestrictions),
+            TOJSON_IMPL(crlSerials)
         };
     }
     static void from_json(const nlohmann::json& j, Tls& p)
@@ -4364,6 +4378,7 @@ namespace AppConfigurationObjects
         getOptional<std::vector<std::string>>("caCertificates", p.caCertificates, j);
         getOptional<StringRestrictionList>("subjectRestrictions", p.subjectRestrictions, j);
         getOptional<StringRestrictionList>("issuerRestrictions", p.issuerRestrictions, j);
+        getOptional<std::vector<std::string>>("crlSerials", p.crlSerials, j);
     }
     
     //-----------------------------------------------------------
@@ -4696,7 +4711,7 @@ namespace AppConfigurationObjects
         /** @brief Details for capture of transmitted packets  */
         PacketCapturer                          txCapture;
 
-        /** @brief [Optional, Default: 66] The RTP payload type to be used for blobs sent over RTP (see BlobInfo) */
+        /** @brief [Optional, Default: ENGAGE_DEFAULT_BLOB_RTP_PAYLOAD_TYPE] The RTP payload type to be used for blobs sent over RTP (see BlobInfo) */
         uint16_t                                blobRtpPayloadType;
 
         /** @brief [Optional, Default: iagpAnonymousAlias]  */
@@ -4705,6 +4720,9 @@ namespace AppConfigurationObjects
         /** @brief [Optional] Inbound gating of audio - only audio allowed through by the gate will be processed */
         AudioGate                               gateIn;
 
+        /** @brief [Optional, Default: false] Indicates that the group should ignore traffic that is audio-related */
+        bool                                    ignoreAudioTraffic;
+
         Group()
         {
             clear();
@@ -4778,9 +4796,11 @@ namespace AppConfigurationObjects
             rxCapture.clear();
             txCapture.clear();
 
-            blobRtpPayloadType = 66;
+            blobRtpPayloadType = ENGAGE_DEFAULT_BLOB_RTP_PAYLOAD_TYPE;
             inboundAliasGenerationPolicy = iagpAnonymousAlias;
             gateIn.clear();
+
+            ignoreAudioTraffic = false;
         }
     };
 
@@ -4845,7 +4865,9 @@ namespace AppConfigurationObjects
 
             TOJSON_IMPL(inboundAliasGenerationPolicy),
 
-            TOJSON_IMPL(gateIn)
+            TOJSON_IMPL(gateIn),
+
+            TOJSON_IMPL(ignoreAudioTraffic)
         };
 
         TOJSON_BASE_IMPL();
@@ -4923,12 +4945,14 @@ namespace AppConfigurationObjects
         getOptional<PacketCapturer>("rxCapture", p.rxCapture, j);
         getOptional<PacketCapturer>("txCapture", p.txCapture, j);
 
-        getOptional<uint16_t>("blobRtpPayloadType", p.blobRtpPayloadType, j, 66);
+        getOptional<uint16_t>("blobRtpPayloadType", p.blobRtpPayloadType, j, ENGAGE_DEFAULT_BLOB_RTP_PAYLOAD_TYPE);
 
         getOptional<Group::InboundAliasGenerationPolicy_t>("inboundAliasGenerationPolicy", p.inboundAliasGenerationPolicy, j, Group::InboundAliasGenerationPolicy_t::iagpAnonymousAlias);
 
         getOptional<AudioGate>("gateIn", p.gateIn, j);
 
+        getOptional<bool>("ignoreAudioTraffic", p.ignoreAudioTraffic, j, false);
+        
         FROMJSON_BASE_IMPL();
     }
 
@@ -7870,6 +7894,9 @@ namespace AppConfigurationObjects
         /** @brief [Optional] The name of the NIC on which to send and receive multicast traffic. */
         std::string                             multicastInterfaceName;
 
+        /** @brief Vector of additional TX addresses . */
+        std::vector<NetworkAddress>            additionalTx;
+
         RallypointReflector()
         {
             clear();
@@ -7881,6 +7908,7 @@ namespace AppConfigurationObjects
             rx.clear();
             tx.clear();
             multicastInterfaceName.clear();
+            additionalTx.clear();
         }
     };
 
@@ -7890,7 +7918,8 @@ namespace AppConfigurationObjects
             TOJSON_IMPL(id),
             TOJSON_IMPL(rx),
             TOJSON_IMPL(tx),
-            TOJSON_IMPL(multicastInterfaceName)
+            TOJSON_IMPL(multicastInterfaceName),
+            TOJSON_IMPL(additionalTx)
         };
     }
     static void from_json(const nlohmann::json& j, RallypointReflector& p)
@@ -7900,6 +7929,7 @@ namespace AppConfigurationObjects
         j.at("rx").get_to(p.rx);
         j.at("tx").get_to(p.tx);
         getOptional<std::string>("multicastInterfaceName", p.multicastInterfaceName, j);
+        getOptional<std::vector<NetworkAddress>>("additionalTx", p.additionalTx, j);
     }    
 
 
@@ -8338,7 +8368,7 @@ namespace AppConfigurationObjects
         int                                         listenPort;
 
         /** @brief [Optional, Default IpFamilyType_t::ifIp4] Address familiy to be used for listening */
-        IpFamilyType_t                         ipFamily;
+        IpFamilyType_t                              ipFamily;
 
         /** @brief Name of the NIC to bind to for listening for incoming TCP connections. */
         std::string                                 interfaceName;
@@ -8478,6 +8508,12 @@ namespace AppConfigurationObjects
         /** @brief [Optional] Settings for advertising. */
         RallypointAdvertisingSettings               advertising;
 
+        /** @brief Details for capture of received packets  */
+        PacketCapturer                          rxCapture;
+
+        /** @brief Details for capture of transmitted packets  */
+        PacketCapturer                          txCapture;
+
         RallypointServer()
         {
             clear();
@@ -8536,6 +8572,8 @@ namespace AppConfigurationObjects
             extendedGroupRestrictions.clear();
             groupRestrictionAccessPolicyType = GroupRestrictionAccessPolicyType_t::graptPermissive;
             ipFamily = IpFamilyType_t::ifIpUnspec;
+            rxCapture.clear();
+            txCapture.clear();
         }
     };
 
@@ -8592,7 +8630,9 @@ namespace AppConfigurationObjects
             TOJSON_IMPL(advertising),
             TOJSON_IMPL(extendedGroupRestrictions),
             TOJSON_IMPL(groupRestrictionAccessPolicyType),
-            TOJSON_IMPL(ipFamily)            
+            TOJSON_IMPL(ipFamily),
+            TOJSON_IMPL(rxCapture),
+            TOJSON_IMPL(txCapture)
         };
     }
     static void from_json(const nlohmann::json& j, RallypointServer& p)
@@ -8649,6 +8689,8 @@ namespace AppConfigurationObjects
         getOptional<std::vector<RallypointExtendedGroupRestriction>>("extendedGroupRestrictions", p.extendedGroupRestrictions, j);        
         getOptional<GroupRestrictionAccessPolicyType_t>("groupRestrictionAccessPolicyType", p.groupRestrictionAccessPolicyType, j, GroupRestrictionAccessPolicyType_t::graptPermissive);
         getOptional<IpFamilyType_t>("ipFamily", p.ipFamily, j, IpFamilyType_t::ifIpUnspec);
+        getOptional<PacketCapturer>("rxCapture", p.rxCapture, j);
+        getOptional<PacketCapturer>("txCapture", p.txCapture, j);
     }
 
     //-----------------------------------------------------------
@@ -9539,7 +9581,10 @@ namespace AppConfigurationObjects
             txsInvalidId                    = -9,
 
             /** @brief  TX has ended with a failure */
-            txsTxEndedWithFailure           = -10            
+            txsTxEndedWithFailure           = -10,
+
+            /** @brief  One or more other entities are or will soon be actively transmitting */
+            txsOthersActive                = -11
         } TxStatus_t;
 
         /** @brief ID of the group */
@@ -11198,6 +11243,310 @@ namespace AppConfigurationObjects
         getOptional<NsmConfiguration>("nsm", p.nsm, j);
     }
 
+//-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(EngageSemGroupsConfiguration)
+    /**
+    * @brief Engage Semaphore configuration
+    *
+    * Helper C++ class to serialize and de-serialize EngageSemGroupsConfiguration JSON
+    *
+    * Example: @include[doc] examples/EngageSemGroupsConfiguration.json
+    *
+    * @see TODO: ConfigurationObjects::EngageSemGroupsConfiguration
+    */
+    class EngageSemGroupsConfiguration : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(EngageSemGroupsConfiguration)
+
+    public:
+        /** @brief Array of groups in the configuration */
+        std::vector<Group>          groups;
+
+        EngageSemGroupsConfiguration()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            groups.clear();
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const EngageSemGroupsConfiguration& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(groups)
+        };
+    }
+    static void from_json(const nlohmann::json& j, EngageSemGroupsConfiguration& p)
+    {
+        p.clear();
+        getOptional<std::vector<Group>>("groups", p.groups, j);
+    }
+
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(EngageSemServerStatusReportConfiguration)
+    /**
+    * @brief TODO: Configuration for the EFC server status report file
+    *
+    * Helper C++ class to serialize and de-serialize EngageSemServerStatusReportConfiguration JSON
+    *
+    * Example: @include[doc] examples/EngageSemServerStatusReportConfiguration.json
+    *
+    * @see RallypointServer
+    */
+    class EngageSemServerStatusReportConfiguration : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(EngageSemServerStatusReportConfiguration)
+
+    public:
+        /** File name to use for the status report. */
+        std::string                     fileName;
+
+        /** [Optional, Default: 30] The interval at which to write out the status report to file. */
+        int                             intervalSecs;
+
+        /** [Optional, Default: false] Indicates if status reporting is enabled. */
+        bool                            enabled;
+
+        /** [Optional, Default: null] Command to be executed every time the status report is produced. */
+        std::string                     runCmd;
+
+        /** [Optional, Default: false] Indicates whether to include details of each group. */
+        bool                            includeGroupDetail;
+
+        EngageSemServerStatusReportConfiguration()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            fileName.clear();
+            intervalSecs = 60;
+            enabled = false;
+            includeGroupDetail = false;
+            runCmd.clear();
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const EngageSemServerStatusReportConfiguration& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(fileName),
+            TOJSON_IMPL(intervalSecs),
+            TOJSON_IMPL(enabled),
+            TOJSON_IMPL(includeGroupDetail),
+            TOJSON_IMPL(runCmd)
+        };
+    }
+    static void from_json(const nlohmann::json& j, EngageSemServerStatusReportConfiguration& p)
+    {
+        p.clear();
+        getOptional<std::string>("fileName", p.fileName, j);
+        getOptional<int>("intervalSecs", p.intervalSecs, j, 60);
+        getOptional<bool>("enabled", p.enabled, j, false);
+        getOptional<std::string>("runCmd", p.runCmd, j);
+        getOptional<bool>("includeGroupDetail", p.includeGroupDetail, j, false);
+    }
+
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(EngageSemServerInternals)
+    /**
+    * @brief Internal EFC server settings
+    *
+    * These settings are used to configure internal parameters.
+    *
+    * Helper C++ class to serialize and de-serialize EngageSemServerInternals JSON
+    *
+    * Example: @include[doc] examples/EngageSemServerInternals.json
+    *
+    * @see engageInitialize, ConfigurationObjects::EngageSemServerConfiguration
+    */
+    class EngageSemServerInternals : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(EngageSemServerInternals)
+
+    public:
+        /** @brief [Optional] Settings for the EFC's watchdog. */
+        WatchdogSettings    watchdog;
+
+        /** @brief [Optional, Default: 1000] Interval at which to run the housekeeper thread. */
+        int                 housekeeperIntervalMs;
+
+        EngageSemServerInternals()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            watchdog.clear();
+            housekeeperIntervalMs = 1000;
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const EngageSemServerInternals& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(watchdog),
+            TOJSON_IMPL(housekeeperIntervalMs)
+        };
+    }
+    static void from_json(const nlohmann::json& j, EngageSemServerInternals& p)
+    {
+        p.clear();
+        getOptional<WatchdogSettings>("watchdog", p.watchdog, j);
+        getOptional<int>("housekeeperIntervalMs", p.housekeeperIntervalMs, j, 1000);
+    }
+
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(EngageSemServerConfiguration)
+    /**
+    * @brief Configuration for the EFC server
+    *
+    * Helper C++ class to serialize and de-serialize EngageSemServerConfiguration JSON
+    *
+    * Example: @include[doc] examples/EngageSemServerConfiguration.json
+    *
+    */
+    class EngageSemServerConfiguration : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(EngageSemServerConfiguration)
+
+    public:
+
+        /** @brief A unqiue identifier for the EFC server */
+        std::string                                 id;
+
+        /** @brief Number of seconds between checks to see if the service configuration has been updated.  Default is 60.*/
+        int                                         serviceConfigurationFileCheckSecs;
+        
+        /** @brief Name of a file containing the EFC configuration. */
+        std::string                                 groupsConfigurationFileName;
+
+        /** @brief Command-line to execute that returns a configuration */
+        std::string                                 groupsConfigurationFileCommand;
+
+        /** @brief Number of seconds between checks to see if the configuration has been updated.  Default is 60.*/
+        int                                         groupsConfigurationFileCheckSecs;
+
+        /** @brief Details for producing a status report. @see EngageSemServerStatusReportConfiguration */
+        EngageSemServerStatusReportConfiguration          statusReport;
+
+        /** @brief Details concerning the server's interaction with an external health-checker such as a load-balancer.  @see ExternalHealthCheckResponder */
+        ExternalHealthCheckResponder                 externalHealthCheckResponder;
+
+        /** @brief Internal settings */
+        EngageSemServerInternals                           internals;
+
+        /** @brief Path to the certificate store */
+        std::string                                  certStoreFileName;
+
+        /** @brief Hex password for the certificate store (if any) */
+        std::string                                  certStorePasswordHex;
+
+        /** @brief The policy to be used for the underlying Engage Engine */
+        EnginePolicy                                 enginePolicy;
+
+        /** @brief Name to use for signalling a configuration check */
+        std::string                                 configurationCheckSignalName;
+
+        /** @brief [Optional] Settings for the FIPS crypto. */
+        FipsCryptoSettings                          fipsCrypto;
+
+        /** @brief [Optional] Settings for NSM. */
+        NsmConfiguration                            nsm;
+
+        int                                         maxQueueLen;
+        int                                         minQueuingMs;
+        int                                         maxQueuingMs;
+        int                                         minPriority;
+        int                                         maxPriority;
+
+        EngageSemServerConfiguration()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            id.clear();
+            serviceConfigurationFileCheckSecs = 60;
+            groupsConfigurationFileName.clear();
+            groupsConfigurationFileCommand.clear();
+            groupsConfigurationFileCheckSecs = 60;
+            statusReport.clear();
+            externalHealthCheckResponder.clear();
+            internals.clear();
+            certStoreFileName.clear();
+            certStorePasswordHex.clear();
+            enginePolicy.clear();
+            configurationCheckSignalName = "rts.9a164fa.${id}";
+            fipsCrypto.clear();
+            nsm.clear();
+
+            maxQueueLen = 64;
+            minQueuingMs = 0;
+            maxQueuingMs = 15000;
+            minPriority = 0;
+            maxPriority = 255;
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const EngageSemServerConfiguration& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(id),
+            TOJSON_IMPL(serviceConfigurationFileCheckSecs),
+            TOJSON_IMPL(groupsConfigurationFileName),
+            TOJSON_IMPL(groupsConfigurationFileCommand),
+            TOJSON_IMPL(groupsConfigurationFileCheckSecs),
+            TOJSON_IMPL(statusReport),
+            TOJSON_IMPL(externalHealthCheckResponder),
+            TOJSON_IMPL(internals),
+            TOJSON_IMPL(certStoreFileName),
+            TOJSON_IMPL(certStorePasswordHex),
+            TOJSON_IMPL(enginePolicy),
+            TOJSON_IMPL(configurationCheckSignalName),
+            TOJSON_IMPL(fipsCrypto),
+            TOJSON_IMPL(nsm),
+            TOJSON_IMPL(maxQueueLen),
+            TOJSON_IMPL(minQueuingMs),
+            TOJSON_IMPL(maxQueuingMs),
+            TOJSON_IMPL(minPriority),
+            TOJSON_IMPL(maxPriority)
+        };
+    }
+    static void from_json(const nlohmann::json& j, EngageSemServerConfiguration& p)
+    {
+        p.clear();
+        getOptional<std::string>("id", p.id, j);
+        getOptional<int>("serviceConfigurationFileCheckSecs", p.serviceConfigurationFileCheckSecs, j, 60);
+        getOptional<std::string>("groupsConfigurationFileName", p.groupsConfigurationFileName, j);
+        getOptional<std::string>("groupsConfigurationFileCommand", p.groupsConfigurationFileCommand, j);
+        getOptional<int>("groupsConfigurationFileCheckSecs", p.groupsConfigurationFileCheckSecs, j, 60);
+        getOptional<EngageSemServerStatusReportConfiguration>("statusReport", p.statusReport, j);
+        getOptional<ExternalHealthCheckResponder>("externalHealthCheckResponder", p.externalHealthCheckResponder, j);
+        getOptional<EngageSemServerInternals>("internals", p.internals, j);
+        getOptional<std::string>("certStoreFileName", p.certStoreFileName, j);
+        getOptional<std::string>("certStorePasswordHex", p.certStorePasswordHex, j);
+        j.at("enginePolicy").get_to(p.enginePolicy);
+        getOptional<std::string>("configurationCheckSignalName", p.configurationCheckSignalName, j, "rts.9a164fa.${id}");
+        getOptional<FipsCryptoSettings>("fipsCrypto", p.fipsCrypto, j);
+        getOptional<NsmConfiguration>("nsm", p.nsm, j);
+        getOptional<int>("maxQueueLen", p.maxQueueLen, j, 64);
+        getOptional<int>("minQueuingMs", p.minQueuingMs, j, 0);
+        getOptional<int>("maxQueuingMs", p.maxQueuingMs, j, 15000);
+        getOptional<int>("minPriority", p.minPriority, j, 0);
+        getOptional<int>("maxPriority", p.maxPriority, j, 255);
+    }
+
     //-----------------------------------------------------------
     static inline void dumpExampleConfigurations(const char *path)
     {
@@ -11309,6 +11658,11 @@ namespace AppConfigurationObjects
         EarServerConfiguration::document();
         RangerPackets::document();
         TransportImpairment::document();
+
+        EngageSemGroupsConfiguration::document();
+        EngageSemServerStatusReportConfiguration::document();
+        EngageSemServerInternals::document();
+        EngageSemServerConfiguration::document();
     }
 }
 

package/include/EngageConstants.h

@@ -209,6 +209,18 @@ static const uint8_t ENGAGE_TXFLAG_TID_INVALIDATED          = 0x0010;
 
 /** @brief Indicates that the receiver should auto-mute using the alias specializer if receiver has that specializer present */
 static const uint8_t ENGAGE_TXFLAG_MUTE_RX_FOR_SPECIALIZER  = 0x0020;                    // READ-ONLY!!
+
+/** @brief Indicates that a transmission is about to start */
+static const uint8_t ENGAGE_TXFLAG_TX_START                 = 0x0040;                    // READ-ONLY!!
+/** @} */
+
+/** @addtogroup internals Engage internal constants
+ *
+ *  @{
+ */
+
+/** @brief The default RTP payload type Engage uses for RTP blob messaging */
+static const uint8_t ENGAGE_DEFAULT_BLOB_RTP_PAYLOAD_TYPE   = 66;
 /** @} */
 
 #endif // EngageConstants_h

package/include/EngageSemNames.h

@@ -0,0 +1,64 @@
+//
+//  Copyright (c) 2024 Rally Tactical Systems, Inc.
+//  All rights reserved.
+//
+/** @file EngageSemNames.h
+ *  @brief Object and field names used for interaction with Engage Semaphore Service
+ *
+ */
+
+#ifndef EngageSemNames_h
+#define EngageSemNames_h
+
+/** @brief The root name of the JSON object. */
+#define ENSEM_JSON_OBJECT_NAME                              "ensem"
+
+/** @brief Message type. */
+#define ENSEM_JSON_FIELD_MESSAGE_TYPE                       "ty"
+
+/** @brief The semaphore identifier.  Case insensitive.  */
+#define ENSEM_JSON_FIELD_SEM_ID                             "i"
+
+/** @brief Maximum number of owners the semaphore may have. */
+#define ENSEM_JSON_FIELD_MAX_OWNERS                         "x"
+
+/** @brief Number of tokens waiting on the semaphore. */
+#define ENSEM_JSON_FIELD_WAITING_COUNT                      "w"
+
+/** @brief Array of semaphore owners. */
+#define ENSEM_JSON_FIELD_OWNERS                             "o"
+
+/** @brief The toekn identifier.  Case insensitive. */
+#define ENSEM_JSON_FIELD_TOKEN_ID                           "t"
+
+/** @brief Local timestamp (milliseconds) until ownership expires. */
+#define ENSEM_JSON_FIELD_OWNER_UNTIL                        "u"
+
+/** @brief Local 64-bit timestamp - typically number of milliseconds since Jan 1, 1970 */
+#define ENSEM_JSON_FIELD_LOCAL_TIMESTAMP                    "ts"
+
+/** @brief Local 64-bit timestamp when the token request will expire. */
+#define ENSEM_JSON_FIELD_LOCAL_EXPIRATION_TIMESTAMP         "es"
+
+/** @brief Milliseconds of semaphore ownership. */
+#define ENSEM_JSON_FIELD_DURATION_MS                        "r"
+
+/** @brief Request priority 0 - 255 */
+#define ENSEM_JSON_FIELD_PRIORITY                           "p"
+
+/** @brief The intended use of the semaphore. */
+#define ENSEM_JSON_FIELD_SEM_USE                            "us"
+
+/** @brief The RTP SSRC associated with the stream the semaphore represents. */
+#define ENSEM_JSON_FIELD_SSRC                               "s"
+
+/** @brief The alias of the transmitter of the stream the semaphore represents. */
+#define ENSEM_JSON_FIELD_ALIAS                              "a"
+
+/** @brief The display name for the transmitter of the stream the semaphore represents. */
+#define ENSEM_JSON_FIELD_DISPLAY_NAME                       "d"
+
+/** @brief The node ID for the transmitter of the stream the semaphore represents. */
+#define ENSEM_JSON_FIELD_NODE_ID                            "n"
+
+#endif  // EngageSemNames_h

package/package.json

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