message.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2020 ETC Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************
 * This file is a part of RDMnet. For more information, go to:
 * https://github.com/ETCLabs/RDMnet
 *****************************************************************************/
 
#ifndef RDMNET_MESSAGE_H_
#define RDMNET_MESSAGE_H_
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include "etcpal/acn_rlp.h"
#include "etcpal/uuid.h"
#include "rdm/message.h"
#include "rdm/uid.h"
#include "rdmnet/common.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct RdmnetRdmCommand
{
  RdmUid rdmnet_source_uid;
  uint16_t dest_endpoint;
  uint32_t seq_num;
  RdmCommandHeader rdm_header;
  const uint8_t* data;
  uint8_t data_len;
} RdmnetRdmCommand;
 
#define RDMNET_COMMAND_IS_TO_DEFAULT_RESPONDER(cmd_ptr) ((cmd_ptr)->dest_endpoint == E133_NULL_ENDPOINT)
 
typedef struct RdmnetSavedRdmCommand
{
  RdmUid rdmnet_source_uid;
  uint16_t dest_endpoint;
  uint32_t seq_num;
  RdmCommandHeader rdm_header;
  uint8_t data[RDM_MAX_PDL];
  uint8_t data_len;
} RdmnetSavedRdmCommand;
 
typedef struct RdmnetRdmResponse
{
  RdmUid rdmnet_source_uid;
  uint16_t source_endpoint;
  uint32_t seq_num;
  bool is_response_to_me;
 
  RdmCommandHeader original_cmd_header;
  const uint8_t* original_cmd_data;
  uint8_t original_cmd_data_len;
 
  RdmResponseHeader rdm_header;
  const uint8_t* rdm_data;
  size_t rdm_data_len;
 
  bool more_coming;
} RdmnetRdmResponse;
 
typedef struct RdmnetSavedRdmResponse
{
  RdmUid rdmnet_source_uid;
  uint16_t source_endpoint;
  uint32_t seq_num;
  bool is_response_to_me;
 
  RdmCommandHeader original_cmd_header;
  uint8_t original_cmd_data[RDM_MAX_PDL];
  uint8_t original_cmd_data_len;
 
  RdmResponseHeader rdm_header;
  uint8_t* rdm_data;
  size_t rdm_data_len;
} RdmnetSavedRdmResponse;
 
#define RDMNET_RESP_ORIGINAL_COMMAND_INCLUDED(resp) ((resp)->seq_num == 0)
 
typedef struct RdmnetRptStatus
{
  RdmUid source_uid;
  uint16_t source_endpoint;
  uint32_t seq_num;
  rpt_status_code_t status_code;
  const char* status_string;
} RdmnetRptStatus;
 
typedef struct RdmnetSavedRptStatus
{
  RdmUid source_uid;
  uint16_t source_endpoint;
  uint32_t seq_num;
  rpt_status_code_t status_code;
  char* status_string;
} RdmnetSavedRptStatus;
 
typedef struct RdmnetDynamicUidMapping
{
  rdmnet_dynamic_uid_status_t status_code;
  RdmUid uid;
  EtcPalUuid rid;
} RdmnetDynamicUidMapping;
 
typedef struct RdmnetDynamicUidAssignmentList
{
  RdmnetDynamicUidMapping* mappings;
  size_t num_mappings;
  bool more_coming;
} RdmnetDynamicUidAssignmentList;
 
typedef struct RdmnetEptData
{
  EtcPalUuid source_cid;
  uint16_t manufacturer_id;
  uint16_t protocol_id;
  const uint8_t* data;
  size_t data_len;
} RdmnetEptData;
 
typedef struct RdmnetSavedEptData
{
  EtcPalUuid source_cid;
  uint16_t manufacturer_id;
  uint16_t protocol_id;
  const uint8_t* data;
  size_t data_len;
} RdmnetSavedEptData;
 
typedef struct RdmnetEptStatus
{
  EtcPalUuid source_cid;
  ept_status_code_t status_code;
  const char* status_string;
} RdmnetEptStatus;
 
typedef struct RdmnetSavedEptStatus
{
  EtcPalUuid source_cid;
  ept_status_code_t status_code;
  const char* status_string;
} RdmnetSavedEptStatus;
 
typedef enum
{
  kRPTClientTypeDevice = E133_RPT_CLIENT_TYPE_DEVICE,
  kRPTClientTypeController = E133_RPT_CLIENT_TYPE_CONTROLLER,
  kRPTClientTypeUnknown = 0xffffffff
} rpt_client_type_t;
 
typedef struct RdmnetRptClientEntry
{
  EtcPalUuid        cid;  
  RdmUid            uid;  
  rpt_client_type_t type; 
  EtcPalUuid binding_cid; 
} RdmnetRptClientEntry;
 
#define EPT_PROTOCOL_STRING_PADDED_LENGTH 32
 
typedef struct RdmnetEptSubProtocol
{
  uint16_t manufacturer_id;
  uint16_t protocol_id;
  const char* protocol_string;
} RdmnetEptSubProtocol;
 
typedef struct RdmnetEptClientEntry
{
  EtcPalUuid            cid;           
  RdmnetEptSubProtocol* protocols;     
  size_t                num_protocols; 
} RdmnetEptClientEntry;
 
typedef struct RdmnetRptClientList
{
  RdmnetRptClientEntry* client_entries;
  size_t num_client_entries;
  bool more_coming;
} RdmnetRptClientList;
 
typedef struct RdmnetEptClientList
{
  RdmnetEptClientEntry* client_entries;
  size_t num_client_entries;
  bool more_coming;
} RdmnetEptClientList;
 
typedef struct LlrpRdmCommand
{
  EtcPalUuid source_cid;
  uint32_t seq_num;
  RdmnetMcastNetintId netint_id;
  RdmCommandHeader rdm_header;
  const uint8_t* data;
  uint8_t data_len;
} LlrpRdmCommand;
 
typedef struct LlrpSavedRdmCommand
{
  EtcPalUuid source_cid;
  uint32_t seq_num;
  RdmnetMcastNetintId netint_id;
  RdmCommandHeader rdm_header;
  uint8_t data[RDM_MAX_PDL];
  uint8_t data_len;
} LlrpSavedRdmCommand;
 
typedef struct LlrpRdmResponse
{
  EtcPalUuid source_cid;
  uint32_t seq_num;
  RdmResponseHeader rdm_header;
  const uint8_t* rdm_data;
  uint8_t rdm_data_len;
} LlrpRdmResponse;
 
typedef struct LlrpSavedRdmResponse
{
  EtcPalUuid source_cid;
  uint32_t seq_num;
  RdmResponseHeader rdm_header;
  uint8_t rdm_data[RDM_MAX_PDL];
  uint8_t rdm_data_len;
} LlrpSavedRdmResponse;
 
const char* rdmnet_rpt_client_type_to_string(rpt_client_type_t client_type);
 
etcpal_error_t rdmnet_save_rdm_command(const RdmnetRdmCommand* command, RdmnetSavedRdmCommand* saved_command);
etcpal_error_t rdmnet_save_rdm_response(const RdmnetRdmResponse* response, RdmnetSavedRdmResponse* saved_response);
etcpal_error_t rdmnet_append_to_saved_rdm_response(const RdmnetRdmResponse* new_response,
                                                   RdmnetSavedRdmResponse*  previously_saved_response);
etcpal_error_t rdmnet_save_rpt_status(const RdmnetRptStatus* status, RdmnetSavedRptStatus* saved_status);
 
etcpal_error_t rdmnet_copy_saved_rdm_response(const RdmnetSavedRdmResponse* saved_resp_old,
                                              RdmnetSavedRdmResponse*       saved_resp_new);
etcpal_error_t rdmnet_copy_saved_rpt_status(const RdmnetSavedRptStatus* saved_status_old,
                                            RdmnetSavedRptStatus*       saved_status_new);
 
etcpal_error_t rdmnet_free_saved_rdm_response(RdmnetSavedRdmResponse* saved_response);
etcpal_error_t rdmnet_free_saved_rpt_status(RdmnetSavedRptStatus* saved_status);
 
etcpal_error_t rdmnet_save_ept_data(const RdmnetEptData* data, RdmnetSavedEptData* saved_data);
etcpal_error_t rdmnet_save_ept_status(const RdmnetEptStatus* status, RdmnetSavedEptStatus* saved_status);
 
etcpal_error_t rdmnet_copy_saved_ept_data(const RdmnetSavedEptData* saved_data_old, RdmnetSavedEptData* saved_data_new);
etcpal_error_t rdmnet_copy_saved_ept_status(const RdmnetSavedEptStatus* saved_status_old,
                                            RdmnetSavedEptStatus*       saved_status_new);
 
etcpal_error_t rdmnet_free_saved_ept_data(RdmnetSavedEptData* saved_data);
etcpal_error_t rdmnet_free_saved_ept_status(RdmnetSavedEptStatus* saved_status);
 
etcpal_error_t rdmnet_save_llrp_rdm_command(const LlrpRdmCommand* command, LlrpSavedRdmCommand* saved_command);
etcpal_error_t rdmnet_save_llrp_rdm_response(const LlrpRdmResponse* response, LlrpSavedRdmResponse* saved_response);
etcpal_error_t rdmnet_copy_saved_llrp_rdm_response(const LlrpSavedRdmResponse* saved_resp_old,
                                                   LlrpSavedRdmResponse*       saved_resp_new);
 
#ifdef __cplusplus
}
#endif
 
#endif /* RDMNET_MESSAGE_H_ */