discovery.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_DISCOVERY_H_
#define RDMNET_DISCOVERY_H_
 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include "etcpal/error.h"
#include "etcpal/uuid.h"
#include "etcpal/socket.h"
#include "rdmnet/common.h"
#include "rdmnet/defs.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct RdmnetDnsTxtRecordItem
{
  const char*    key;       
  const uint8_t* value;     
  uint8_t        value_len; 
} RdmnetDnsTxtRecordItem;
 
typedef struct RdmnetBrokerRegisterRef* rdmnet_registered_broker_t;
#define RDMNET_REGISTERED_BROKER_INVALID NULL
 
typedef struct RdmnetBrokerDiscInfo
{
  EtcPalUuid cid;
  RdmUid uid;
  int e133_version;
  const char* service_instance_name;
  uint16_t port;
  const EtcPalIpAddr* listen_addrs;
  size_t num_listen_addrs;
  const char* scope;
  const char* model;
  const char* manufacturer;
 
  const RdmnetDnsTxtRecordItem* additional_txt_items;
  size_t num_additional_txt_items;
} RdmnetBrokerDiscInfo;
 
typedef void (*RdmnetDiscBrokerRegisteredCallback)(rdmnet_registered_broker_t handle,
                                                   const char*                assigned_service_instance_name,
                                                   void*                      context);
 
typedef void (*RdmnetDiscBrokerRegisterFailedCallback)(rdmnet_registered_broker_t handle,
                                                       int                        platform_error,
                                                       void*                      context);
 
typedef void (*RdmnetDiscOtherBrokerFoundCallback)(rdmnet_registered_broker_t  handle,
                                                   const RdmnetBrokerDiscInfo* broker_info,
                                                   void*                       context);
 
typedef void (*RdmnetDiscOtherBrokerLostCallback)(rdmnet_registered_broker_t handle,
                                                  const char*                scope,
                                                  const char*                service_instance_name,
                                                  void*                      context);
 
typedef struct RdmnetDiscBrokerCallbacks
{
  RdmnetDiscBrokerRegisteredCallback     broker_registered;      
  RdmnetDiscBrokerRegisterFailedCallback broker_register_failed; 
  RdmnetDiscOtherBrokerFoundCallback     other_broker_found;     
  RdmnetDiscOtherBrokerLostCallback      other_broker_lost;      
  void* context; 
} RdmnetDiscBrokerCallbacks;
 
typedef struct RdmnetBrokerRegisterConfig
{
  /************************************************************************************************
   * Required Values
   ***********************************************************************************************/
 
  EtcPalUuid cid;
  RdmUid uid;
  const char* service_instance_name;
  uint16_t port;
  const unsigned int* netints;
  size_t num_netints;
  const char* scope;
  const char* model;
  const char* manufacturer;
 
  const RdmnetDnsTxtRecordItem* additional_txt_items;
  size_t num_additional_txt_items;
 
  RdmnetDiscBrokerCallbacks callbacks;
} RdmnetBrokerRegisterConfig;
 
#define RDMNET_BROKER_REGISTER_CONFIG_DEFAULT_INIT                                            \
  {                                                                                           \
    {{0}}, {0}, NULL, 0, NULL, 0, NULL, NULL, NULL, NULL, 0, { NULL, NULL, NULL, NULL, NULL } \
  }
 
typedef struct RdmnetScopeMonitorRef* rdmnet_scope_monitor_t;
#define RDMNET_SCOPE_MONITOR_INVALID NULL
 
typedef void (*RdmnetDiscBrokerFoundCallback)(rdmnet_scope_monitor_t      handle,
                                              const RdmnetBrokerDiscInfo* broker_info,
                                              void*                       context);
 
typedef void (*RdmnetDiscBrokerUpdatedCallback)(rdmnet_scope_monitor_t      handle,
                                                const RdmnetBrokerDiscInfo* updated_broker_info,
                                                void*                       context);
 
typedef void (*RdmnetDiscBrokerLostCallback)(rdmnet_scope_monitor_t handle,
                                             const char*            scope,
                                             const char*            service_instance_name,
                                             void*                  context);
 
typedef struct RdmnetScopeMonitorCallbacks
{
  RdmnetDiscBrokerFoundCallback   broker_found;   
  RdmnetDiscBrokerUpdatedCallback broker_updated; 
  RdmnetDiscBrokerLostCallback    broker_lost;    
  void*                           context; 
} RdmnetScopeMonitorCallbacks;
 
typedef struct RdmnetScopeMonitorConfig
{
  /************************************************************************************************
   * Required Values
   ***********************************************************************************************/
 
  const char* scope;
  RdmnetScopeMonitorCallbacks callbacks;
 
  /************************************************************************************************
   * Optional Values
   ***********************************************************************************************/
 
  const char* domain;
} RdmnetScopeMonitorConfig;
 
#define RDMNET_SCOPE_MONITOR_CONFIG_DEFAULT_INIT \
  {                                              \
    E133_DEFAULT_SCOPE, {NULL, NULL, NULL}, NULL \
  }
 
void rdmnet_broker_register_config_init(RdmnetBrokerRegisterConfig* config);
void rdmnet_broker_register_config_set_callbacks(RdmnetBrokerRegisterConfig*            config,
                                                 RdmnetDiscBrokerRegisteredCallback     broker_registered,
                                                 RdmnetDiscBrokerRegisterFailedCallback broker_register_failed,
                                                 RdmnetDiscOtherBrokerFoundCallback     other_broker_found,
                                                 RdmnetDiscOtherBrokerLostCallback      other_broker_lost,
                                                 void*                                  context);
 
void rdmnet_scope_monitor_config_init(RdmnetScopeMonitorConfig* config);
void rdmnet_scope_monitor_config_set_callbacks(RdmnetScopeMonitorConfig*       config,
                                               RdmnetDiscBrokerFoundCallback   broker_found,
                                               RdmnetDiscBrokerUpdatedCallback broker_udpated,
                                               RdmnetDiscBrokerLostCallback    broker_lost,
                                               void*                           context);
 
etcpal_error_t rdmnet_disc_start_monitoring(const RdmnetScopeMonitorConfig* config,
                                            rdmnet_scope_monitor_t*         handle,
                                            int*                            platform_specific_error);
void           rdmnet_disc_stop_monitoring(rdmnet_scope_monitor_t handle);
void           rdmnet_disc_stop_monitoring_all(void);
 
etcpal_error_t rdmnet_disc_register_broker(const RdmnetBrokerRegisterConfig* config,
                                           rdmnet_registered_broker_t*       handle);
void           rdmnet_disc_unregister_broker(rdmnet_registered_broker_t handle);
 
#ifdef __cplusplus
}
#endif
 
#endif /* RDMNET_DISCOVERY_H_ */