rti_remote.h

Go to the documentation of this file.

#if defined STANDALONE_RTI
#ifndef RTI_REMOTE_H
#define RTI_REMOTE_H
 
#include <sys/socket.h>
#include <sys/types.h>  // Provides select() function to read from multiple sockets.
#include <netinet/in.h> // Defines struct sockaddr_in
#include <arpa/inet.h>  // inet_ntop & inet_pton
#include <unistd.h>     // Defines read(), write(), and close()
#include <strings.h>    // Defines bzero().
 
#include "rti_common.h"
 
#ifdef __RTI_AUTH__
#include <openssl/rand.h> // For secure random number generation.
#include <openssl/hmac.h> // For HMAC authentication.
#endif
 
#include "lf_types.h"
#include "pqueue_tag.h"
#include "socket_common.h"
 
#define MAX_TIME_FOR_REPLY_TO_STOP_REQUEST SEC(30)
 
 
typedef struct federate_info_t {
  scheduling_node_t enclave;
  bool requested_stop;                   // Indicates that the federate has requested stop or has replied
                                         // to a request for stop from the RTI. Used to prevent double-counting
                                         // a federate when handling lf_request_stop().
  lf_thread_t thread_id;                 // The ID of the thread handling communication with this federate.
  int socket;                            // The TCP socket descriptor for communicating with this federate.
  struct sockaddr_in UDP_addr;           // The UDP address for the federate.
  bool clock_synchronization_enabled;    // Indicates the status of clock synchronization
                                         // for this federate. Enabled by default.
  pqueue_tag_t* in_transit_message_tags; // Record of in-transit messages to this federate that are not
                                         // yet processed. This record is ordered based on the time
                                         // value of each message for a more efficient access.
  char server_hostname[INET_ADDRSTRLEN]; // Human-readable IP address and
  int32_t server_port;                   // port number of the socket server of the federate
                                         // if it has any incoming direct connections from other federates.
                                         // The port number will be -1 if there is no server or if the
                                         // RTI has not been informed of the port number.
  struct in_addr server_ip_addr;         // Information about the IP address of the socket
                                         // server of the federate.
} federate_info_t;
 
typedef enum clock_sync_stat { clock_sync_off, clock_sync_init, clock_sync_on } clock_sync_stat;
 
typedef struct rti_remote_t {
  rti_common_t base;
  // Maximum start time seen so far from the federates.
  int64_t max_start_time;
 
  // Number of federates that have proposed start times.
  int num_feds_proposed_start;
 
  volatile bool all_federates_exited;
 
  const char* federation_id;
 
 
  uint16_t user_specified_port;
 
  uint16_t final_port_TCP;
 
  int socket_descriptor_TCP;
 
 
  uint16_t final_port_UDP;
 
  int socket_descriptor_UDP;
 
 
  /* Thread performing PTP clock sync sessions periodically. */
  lf_thread_t clock_thread;
 
  clock_sync_stat clock_sync_global_status;
 
  uint64_t clock_sync_period_ns;
 
  int32_t clock_sync_exchanges_per_interval;
 
  bool authentication_enabled;
  bool stop_in_progress;
} rti_remote_t;
 
extern int lf_critical_section_enter(environment_t* env);
 
extern int lf_critical_section_exit(environment_t* env);
 
extern bool _lf_federate_reports_error;
 
void update_federate_next_event_tag_locked(uint16_t federate_id, tag_t next_event_tag);
 
void handle_port_absent_message(federate_info_t* sending_federate, unsigned char* buffer);
 
void handle_timed_message(federate_info_t* sending_federate, unsigned char* buffer);
 
void handle_latest_tag_confirmed(federate_info_t* fed);
 
void handle_next_event_tag(federate_info_t* fed);
 
 
void handle_stop_request_message(federate_info_t* fed);
 
void handle_stop_request_reply(federate_info_t* fed);
 
 
void handle_address_query(uint16_t fed_id);
 
void handle_address_ad(uint16_t federate_id);
 
void handle_timestamp(federate_info_t* my_fed);
 
void send_physical_clock(unsigned char message_type, federate_info_t* fed, socket_type_t socket_type);
 
void handle_physical_clock_sync_message(federate_info_t* my_fed, socket_type_t socket_type);
 
void* clock_synchronization_thread(void* noargs);
 
void* federate_info_thread_TCP(void* fed);
 
void send_reject(int* socket_id, unsigned char error_code);
 
void lf_connect_to_federates(int socket_descriptor);
 
void* respond_to_erroneous_connections(void* nothing);
 
void initialize_federate(federate_info_t* fed, uint16_t id);
 
int32_t start_rti_server(uint16_t port);
 
void wait_for_federates(int socket_descriptor);
 
void usage(int argc, const char* argv[]);
 
int process_clock_sync_args(int argc, const char* argv[]);
 
int process_args(int argc, const char* argv[]);
 
void initialize_RTI(rti_remote_t* rti);
 
#endif // RTI_REMOTE_H
#endif // STANDALONE_RTI