vrpn_Connection.h

#ifndef VRPN_CONNECTION_H
#define VRPN_CONNECTION_H
 
#include <stdio.h> // for NULL, snprintf
 
#include "vrpn_Configure.h" // for VRPN_API, VRPN_CALLBACK, etc
#include "vrpn_Shared.h" // for vrpn_SOCKET, timeval
#include "vrpn_Types.h" // for vrpn_int32, vrpn_uint32, etc
#include "vrpn_EndpointContainer.h"
 
#if !(defined(_WIN32) && defined(VRPN_USE_WINSOCK_SOCKETS))
#include <sys/select.h> // for fd_set
#endif
 
struct timeval;
 
// Turn off warnings for deprecated calls when compiling on Microsoft Visual Studio
#ifdef _MSC_VER
#pragma warning(disable : 4995 4996)
#endif
 
enum vrpn_ConnectionStatus {
    LISTEN = (1),
    CONNECTED = (0),
    COOKIE_PENDING = (-1),
    TRYING_TO_CONNECT = (-2),
    BROKEN = (-3),
    LOGGING = (-4)
};
 
class VRPN_API
 vrpn_File_Connection; // Forward declaration for get_File_Connection()
 
struct vrpn_HANDLERPARAM {
    vrpn_int32 type;
    vrpn_int32 sender;
 struct timeval msg_time;
    vrpn_int32 payload_len;
 const char *buffer;
};
 
typedef int(VRPN_CALLBACK *vrpn_MESSAGEHANDLER)(void *userdata,
 vrpn_HANDLERPARAM p);
 
typedef vrpn_MESSAGEHANDLER vrpn_LOGFILTER;
 
const unsigned vrpn_ALIGN = 8;
 
const int vrpn_CONNECTION_MAX_SENDERS = 2000;
const int vrpn_CONNECTION_MAX_TYPES = 2000;
 
 
const int vrpn_ANY_SENDER = -1;
 
 
const int vrpn_ANY_TYPE = -1;
 
 
const int vrpn_CONNECTION_TCP_BUFLEN = 64000;
const int vrpn_CONNECTION_UDP_BUFLEN = 1472;
 
 
const int vrpn_MAX_ENDPOINTS = 256;
 
const vrpn_int32 vrpn_CONNECTION_SENDER_DESCRIPTION = (-1);
const vrpn_int32 vrpn_CONNECTION_TYPE_DESCRIPTION = (-2);
const vrpn_int32 vrpn_CONNECTION_UDP_DESCRIPTION = (-3);
const vrpn_int32 vrpn_CONNECTION_LOG_DESCRIPTION = (-4);
const vrpn_int32 vrpn_CONNECTION_DISCONNECT_MESSAGE = (-5);
 
 
const vrpn_uint32 vrpn_CONNECTION_RELIABLE = (1 << 0);
const vrpn_uint32 vrpn_CONNECTION_FIXED_LATENCY = (1 << 1);
const vrpn_uint32 vrpn_CONNECTION_LOW_LATENCY = (1 << 2);
const vrpn_uint32 vrpn_CONNECTION_FIXED_THROUGHPUT = (1 << 3);
const vrpn_uint32 vrpn_CONNECTION_HIGH_THROUGHPUT = (1 << 4);
 
 
const long vrpn_LOG_NONE = (0);
const long vrpn_LOG_INCOMING = (1 << 0);
const long vrpn_LOG_OUTGOING = (1 << 1);
 
// If defined, will filter out messages:  if the remote side hasn't
// registered a type, messages of that type won't be sent over the
// link.  WARNING:  auto-type-registration breaks this.
//#define vrpn_FILTER_MESSAGES
 
extern VRPN_API const char *vrpn_got_first_connection;
extern VRPN_API const char *vrpn_got_connection;
extern VRPN_API const char *vrpn_dropped_connection;
extern VRPN_API const char *vrpn_dropped_last_connection;
 
 
extern VRPN_API const char *vrpn_CONTROL;
 
const unsigned vrpn_CNAME_LENGTH = 100;
typedef char vrpn_CNAME[vrpn_CNAME_LENGTH];
 
struct VRPN_API vrpn_LOGLIST {
 vrpn_HANDLERPARAM data;
 vrpn_LOGLIST *next;
 vrpn_LOGLIST *prev;
};
 
class VRPN_API vrpn_Endpoint_IP;
class VRPN_API vrpn_Connection;
 
typedef vrpn_Endpoint_IP *(*vrpn_EndpointAllocator)(
 vrpn_Connection *connection, vrpn_int32 *numActiveConnections);
 
namespace vrpn {
 
 class BoundEndpointAllocator {
 public:
 BoundEndpointAllocator()
            : epa_(NULL)
            , conn_(NULL)
            , numActiveEndpoints_(NULL)
        {
        }
 BoundEndpointAllocator(vrpn_EndpointAllocator epa,
 vrpn_Connection *conn,
                               vrpn_int32 *numActiveEndpoints = NULL)
            : epa_(epa)
            , conn_(conn)
            , numActiveEndpoints_(numActiveEndpoints)
        {
        }
 
 typedef vrpn_Endpoint_IP *return_type;
 
 return_type operator()() const
 {
 if (!epa_) {
 return NULL;
            }
 return (*epa_)(conn_, numActiveEndpoints_);
        }
 
 return_type operator()(vrpn_int32 *alternateNumActiveEndpoints) const
 {
 if (!epa_) {
 return NULL;
            }
 return (*epa_)(conn_, alternateNumActiveEndpoints);
        }
 
 private:
        vrpn_EndpointAllocator epa_;
 vrpn_Connection *conn_;
        vrpn_int32 *numActiveEndpoints_;
    };
} // namespace vrpn
 
struct vrpnMsgCallbackEntry {
    vrpn_MESSAGEHANDLER handler; 
 void *userdata;              
    vrpn_int32 sender;           
 vrpnMsgCallbackEntry *next;  
};
 
struct vrpnLogFilterEntry {
    vrpn_LOGFILTER filter; 
 void *userdata;        
 vrpnLogFilterEntry *next;
};
 
class VRPN_API vrpn_Connection;
class VRPN_API vrpn_Log;
class VRPN_API vrpn_TranslationTable;
class VRPN_API vrpn_TypeDispatcher;
 
 
class VRPN_API vrpn_Endpoint {
 
public:
 vrpn_Endpoint(vrpn_TypeDispatcher *dispatcher,
                  vrpn_int32 *connectedEndpointCounter);
 virtual ~vrpn_Endpoint(void);
 
 
 int local_type_id(vrpn_int32 remote_type) const;
 
 int local_sender_id(vrpn_int32 remote_sender) const;
 
 virtual vrpn_bool doing_okay(void) const = 0;
 
 
 void init(void);
 
 virtual int mainloop(timeval *timeout) = 0;
 
 void clear_other_senders_and_types(void);
 
 int newLocalSender(const char *name, vrpn_int32 which);
 int newLocalType(const char *name, vrpn_int32 which);
 
 int newRemoteType(vrpn_CNAME type_name, vrpn_int32 remote_id,
                      vrpn_int32 local_id);
 int newRemoteSender(vrpn_CNAME sender_name, vrpn_int32 remote_id,
                        vrpn_int32 local_id);
 
 virtual int pack_message(vrpn_uint32 len, struct timeval time,
                             vrpn_int32 type, vrpn_int32 sender,
 const char *buffer,
                             vrpn_uint32 class_of_service) = 0;
 
 virtual int send_pending_reports(void) = 0;
 
 int pack_log_description(void);
 
 virtual int setup_new_connection(void) = 0;
 
 virtual void poll_for_cookie(const timeval *timeout = NULL) = 0;
 virtual int finish_new_connection_setup(void) = 0;
 
 virtual void drop_connection(void) = 0;
 
 virtual void clearBuffers(void) = 0;
 
 int pack_sender_description(vrpn_int32 which);
 
 int pack_type_description(vrpn_int32 which);
 
 int status;
 
 
 long d_remoteLogMode;     
 char *d_remoteInLogName;  
 char *d_remoteOutLogName; 
 
 char rhostname[150];
 
 
 vrpn_Log *d_inLog;
 vrpn_Log *d_outLog;
 
 void setLogNames(const char *inName, const char *outName);
 int openLogs(void);
 
 static int VRPN_CALLBACK
    handle_sender_message(void *userdata, vrpn_HANDLERPARAM p);
 static int VRPN_CALLBACK
    handle_type_message(void *userdata, vrpn_HANDLERPARAM p);
 
 void setConnection(vrpn_Connection *conn) { d_parent = conn; }
 vrpn_Connection *getConnection() { return d_parent; }
 
protected:
 virtual int dispatch(vrpn_int32 type, vrpn_int32 sender, timeval time,
                         vrpn_uint32 payload_len, char *bufptr);
 
 int tryToMarshall(char *outbuf, vrpn_int32 &buflen, vrpn_int32 &numOut,
                      vrpn_uint32 len, timeval time, vrpn_int32 type,
                      vrpn_int32 sender, const char *buffer,
                      vrpn_uint32 classOfService);
 
 int marshall_message(char *outbuf, vrpn_uint32 outbuf_size,
                         vrpn_uint32 initial_out, vrpn_uint32 len,
 struct timeval time, vrpn_int32 type,
                         vrpn_int32 sender, const char *buffer,
                         vrpn_uint32 sequenceNumber);
 
 // The senders and types we know about that have been described by
 // the other end of the connection.  Also, record the local mapping
 // for ones that have been described with the same name locally.
 // The arrays are indexed by the ID from the other side, and store
 // the name and local ID that corresponds to each.
 
    vrpn_TranslationTable *d_senders;
    vrpn_TranslationTable *d_types;
 
    vrpn_TypeDispatcher *d_dispatcher;
    vrpn_int32 *d_connectionCounter;
 
 vrpn_Connection *d_parent;
};
 
 
class VRPN_API vrpn_Endpoint_IP : public vrpn_Endpoint {
 
public:
 vrpn_Endpoint_IP(vrpn_TypeDispatcher *dispatcher,
                     vrpn_int32 *connectedEndpointCounter);
 virtual ~vrpn_Endpoint_IP(void);
 
 virtual vrpn_bool doing_okay(void) const;
 
    vrpn_bool outbound_udp_open(void) const;
 
    vrpn_int32 tcp_outbuf_size(void) const;
    vrpn_int32 udp_outbuf_size(void) const;
 
 
 void init(void);
 
 int mainloop(timeval *timeout);
 
 int pack_message(vrpn_uint32 len, struct timeval time, vrpn_int32 type,
                     vrpn_int32 sender, const char *buffer,
                     vrpn_uint32 class_of_service);
 
 virtual int send_pending_reports(void);
 
 int pack_udp_description(int portno);
 
 int handle_tcp_messages(const timeval *timeout);
 int handle_udp_messages(const timeval *timeout);
 
 int connect_tcp_to(const char *msg);
 int connect_tcp_to(const char *addr, int port);
 int connect_udp_to(const char *addr, int port);
 
 int setup_new_connection(void);
 
 void poll_for_cookie(const timeval *timeout = NULL);
 int finish_new_connection_setup(void);
 
 void drop_connection(void);
 
 void clearBuffers(void);
 
 void setNICaddress(const char *);
 
 
    vrpn_SOCKET d_tcpSocket;
 
 
    vrpn_SOCKET d_tcpListenSocket;
 int d_tcpListenPort;
 
    vrpn_SOCKET d_udpLobSocket;
 
 char *d_remote_machine_name;    
 int d_remote_port_number;       
    timeval d_last_connect_attempt; 
 
    vrpn_bool d_tcp_only;
 
protected:
 int getOneTCPMessage(int fd, char *buf, size_t buflen);
 int getOneUDPMessage(char *buf, size_t buflen);
 
    vrpn_SOCKET d_udpOutboundSocket;
    vrpn_SOCKET d_udpInboundSocket;
 
 char *d_tcpOutbuf;
 char *d_udpOutbuf;
    vrpn_int32 d_tcpBuflen;
    vrpn_int32 d_udpBuflen;
    vrpn_int32 d_tcpNumOut;
    vrpn_int32 d_udpNumOut;
 
    vrpn_int32 d_tcpSequenceNumber;
    vrpn_int32 d_udpSequenceNumber;
 
    vrpn_float64
        d_tcpAlignedInbuf[vrpn_CONNECTION_TCP_BUFLEN / sizeof(vrpn_float64) +
                          1];
    vrpn_float64
        d_udpAlignedInbuf[vrpn_CONNECTION_UDP_BUFLEN / sizeof(vrpn_float64) +
                          1];
 char *d_tcpInbuf;
 char *d_udpInbuf;
 
 char *d_NICaddress;
};
 
class VRPN_API vrpn_Connection {
 
protected:
 vrpn_Connection(const char *local_in_logfile_name,
 const char *local_out_logfile_name,
                    vrpn_EndpointAllocator epa = allocateEndpoint);
 
 vrpn_Connection(const char *local_in_logfile_name,
 const char *local_out_logfile_name,
 const char *remote_in_logfile_name,
 const char *remote_out_logfile_name,
                    vrpn_EndpointAllocator epa = allocateEndpoint);
 
public:
 virtual ~vrpn_Connection(void);
 
 virtual vrpn_bool doing_okay(void) const;
 
 virtual vrpn_bool connected(void) const;
 
 void get_log_names(char **local_in_logname, char **local_out_logname,
 char **remote_in_logname, char **remote_out_logname);
 
 virtual int mainloop(const struct timeval *timeout = NULL) = 0;
 
 virtual vrpn_int32 register_sender(const char *name);
 virtual vrpn_int32 register_message_type(const char *name);
 
 virtual int register_handler(vrpn_int32 type, vrpn_MESSAGEHANDLER handler,
 void *userdata,
                                 vrpn_int32 sender = vrpn_ANY_SENDER);
 virtual int unregister_handler(vrpn_int32 type, vrpn_MESSAGEHANDLER handler,
 void *userdata,
                                   vrpn_int32 sender = vrpn_ANY_SENDER);
 
 virtual int pack_message(vrpn_uint32 len, struct timeval time,
                             vrpn_int32 type, vrpn_int32 sender,
 const char *buffer, vrpn_uint32 class_of_service);
 
 virtual int send_pending_reports(void) = 0;
 
 virtual int time_since_connection_open(struct timeval *elapsed_time);
 
 virtual timeval get_time();
 
 virtual const char *sender_name(vrpn_int32 sender);
 virtual const char *message_type_name(vrpn_int32 type);
 
 virtual int register_log_filter(vrpn_LOGFILTER filter, void *userdata);
 
 virtual int save_log_so_far();
 
 virtual vrpn_File_Connection *get_File_Connection(void);
 
 void Jane_stop_this_crazy_thing(vrpn_uint32 stop_looking_after)
    {
        d_stop_processing_messages_after = stop_looking_after;
    };
    vrpn_uint32 get_Jane_value(void)
    {
 return d_stop_processing_messages_after;
    };
 
protected:
    vrpn_uint32 d_stop_processing_messages_after;
 
 int connectionStatus; 
 
 static vrpn_Endpoint_IP *allocateEndpoint(vrpn_Connection *,
                                              vrpn_int32 *connectedEC);
 
#ifdef _MSC_VER
#pragma warning(push)
// Disable "need dll interface" warning on these members
#pragma warning(disable : 4251)
#endif
 vrpn::BoundEndpointAllocator d_boundEndpointAllocator;
 
 vrpn::EndpointContainer d_endpoints;
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif
    vrpn_int32 d_numConnectedEndpoints;
 
 static int VRPN_CALLBACK
 handle_log_message(void *userdata, vrpn_HANDLERPARAM p);
 static int VRPN_CALLBACK
    handle_disconnect_message(void *userdata, vrpn_HANDLERPARAM p);
 
private:
 void init(vrpn_EndpointAllocator
                  epa); 
protected:
 int delete_endpoint(vrpn_Endpoint *endpoint);
 int compact_endpoints(void);
 
 virtual int pack_sender_description(vrpn_int32 which);
 
 virtual int pack_type_description(vrpn_int32 which);
 
 virtual int do_callbacks_for(vrpn_int32 type, vrpn_int32 sender,
 struct timeval time, vrpn_uint32 len,
 const char *buffer);
 
 int message_type_is_registered(const char *) const;
 
    timeval start_time;
 
 //
public:
 void addReference();
 void removeReference();
 
private:
 int d_references;
 
 //
public:
 void setAutoDeleteStatus(bool setvalue) { d_autoDeleteStatus = setvalue; }
 
private:
 bool d_autoDeleteStatus; 
 
public:
 
    vrpn_TypeDispatcher *d_dispatcher;
 
protected:
 int doSystemCallbacksFor(vrpn_HANDLERPARAM, void *);
 
 
 // vrpn_Endpoint * d_serverLogEndpoint;
 int d_serverLogCount;
    vrpn_int32 d_serverLogMode;
 char *d_serverLogName;
 
    vrpn_bool d_updateEndpoint;
 
 virtual void updateEndpoints(void);
};
 
class VRPN_API vrpn_Connection_IP : public vrpn_Connection {
 
protected:
 vrpn_Connection_IP(const char *server_name,
 int port = vrpn_DEFAULT_LISTEN_PORT_NO,
 const char *local_in_logfile_name = NULL,
 const char *local_out_logfile_name = NULL,
 const char *remote_in_logfile_name = NULL,
 const char *remote_out_logfile_name = NULL,
 const char *NIC_IPaddress = NULL,
                       vrpn_EndpointAllocator epa = allocateEndpoint);
 
public:
 vrpn_Connection_IP(
 unsigned short listen_port_no = vrpn_DEFAULT_LISTEN_PORT_NO,
 const char *local_in_logfile_name = NULL,
 const char *local_out_logfile_name = NULL,
 const char *NIC_IPaddress = NULL,
 vrpn_Endpoint_IP *(*epa)(vrpn_Connection *,
                                 vrpn_int32 *) = allocateEndpoint);
 
 virtual ~vrpn_Connection_IP(void);
 
 virtual int connect_to_client(const char *machine, int port);
 
 virtual int mainloop(const struct timeval *timeout = NULL);
 
protected:
    vrpn_uint32 d_stop_processing_messages_after;
 
 friend VRPN_API vrpn_Connection *vrpn_get_connection_by_name(
 const char *cname, const char *local_in_logfile_name,
 const char *local_out_logfile_name, const char *remote_in_logfile_name,
 const char *remote_out_logfile_name, const char *NIC_IPaddress,
 bool force_connection);
 friend VRPN_API vrpn_Connection *
 vrpn_create_server_connection(const char *cname,
 const char *local_in_logfile_name,
 const char *local_out_logfile_name);
 
    vrpn_SOCKET listen_udp_sock; 
    vrpn_SOCKET listen_tcp_sock; 
 
 static int VRPN_CALLBACK
 handle_UDP_message(void *userdata, vrpn_HANDLERPARAM p);
 
 void init(void);
 
 virtual int send_pending_reports(void);
 
 virtual void
    server_check_for_incoming_connections(const struct timeval *timeout = NULL);
 
 virtual void handle_connection(vrpn_Endpoint *endpoint);
 
 virtual void drop_connection(vrpn_Endpoint *endpoint);
 
 void drop_connection_and_compact(vrpn_Endpoint *endpoint);
 
 char *d_NIC_IP;
};
 
 
class VRPN_API vrpn_Connection_Loopback : public vrpn_Connection {
 
protected:
 vrpn_Connection_Loopback();
 
public:
 virtual ~vrpn_Connection_Loopback(void);
 
 virtual int mainloop(const struct timeval *timeout = NULL);
 
 virtual vrpn_bool doing_okay(void) const { return vrpn_true; }
 
 virtual vrpn_bool connected(void) const { return vrpn_true; }
 
protected:
 friend VRPN_API vrpn_Connection *
 vrpn_create_server_connection(const char *cname,
 const char *local_in_logfile_name,
 const char *local_out_logfile_name);
 
 virtual int send_pending_reports(void) { return 0; }
};
 
VRPN_API vrpn_Connection *vrpn_get_connection_by_name(
 const char *cname, const char *local_in_logfile_name = NULL,
 const char *local_out_logfile_name = NULL,
 const char *remote_in_logfile_name = NULL,
 const char *remote_out_logfile_name = NULL,
 const char *NIC_IPaddress = NULL, bool force_reopen = false);
 
VRPN_API vrpn_Connection *
vrpn_create_server_connection(const char *cname,
 const char *local_in_logfile_name = NULL,
 const char *local_out_logfile_name = NULL);
 
inline VRPN_API vrpn_Connection *
vrpn_create_server_connection(int port = vrpn_DEFAULT_LISTEN_PORT_NO,
 const char *local_in_logfile_name = NULL,
 const char *local_out_logfile_name = NULL,
 const char *NIC_NAME = NULL)
{
 char name[256];
 if (NIC_NAME == NULL) {
        snprintf(name, 256, ":%d", port);
    }
 else {
        snprintf(name, 256, "%.200s:%d", NIC_NAME, port);
    }
 return vrpn_create_server_connection(name, local_in_logfile_name,
                                         local_out_logfile_name);
}
 
VRPN_API char *vrpn_copy_service_name(const char *fullname);
VRPN_API char *vrpn_copy_service_location(const char *fullname);
 
VRPN_API char *vrpn_copy_file_name(const char *filespecifier);
 
VRPN_API char *vrpn_copy_machine_name(const char *hostspecifier);
VRPN_API int vrpn_get_port_number(const char *hostspecifier);
VRPN_API char *vrpn_copy_rsh_program(const char *hostspecifier);
VRPN_API char *vrpn_copy_rsh_arguments(const char *hostspecifier);
 
char *vrpn_set_service_name(const char *specifier, const char *newServiceName);
 
VRPN_API int check_vrpn_cookie(const char *buffer);
VRPN_API int check_vrpn_file_cookie(const char *buffer);
 
VRPN_API size_t vrpn_cookie_size(void);
 
VRPN_API int write_vrpn_cookie(char *buffer, size_t length,
 long remote_log_mode);
 
#ifndef VRPN_USE_WINSOCK_SOCKETS
int VRPN_API
vrpn_noint_block_write(int outfile, const char buffer[], size_t length);
int VRPN_API vrpn_noint_block_read(int infile, char buffer[], size_t length);
int VRPN_API vrpn_noint_select(int width, fd_set *readfds, fd_set *writefds,
                               fd_set *exceptfds, struct timeval *timeout);
#else  /* winsock sockets */
int VRPN_API
vrpn_noint_block_write(vrpn_SOCKET outsock, char *buffer, size_t length);
int VRPN_API vrpn_noint_block_read(vrpn_SOCKET insock, char *buffer, size_t length);
#endif /* VRPN_USE_WINSOCK_SOCKETS */
 
//      This section holds data structures and functions to open
// connections by name.
//      The intention of this section is that it can open connections for
// objects that are in different libraries (trackers, buttons and sound),
// even if they all refer to the same connection.
//  Even though each individual vrpn_Connection class is not yet thread
// safe, so should only have its methods called from a single thread,
// the vrpn_ConnectionManager should be thread safe to allow connections
// to be created and destroyed by different threads.
 
class VRPN_API vrpn_ConnectionManager {
 
public:
 ~vrpn_ConnectionManager(void);
 
 static vrpn_ConnectionManager &instance(void);
 
 void addConnection(vrpn_Connection *, const char *name);
 void deleteConnection(vrpn_Connection *);
 
 vrpn_Connection *getByName(const char *name);
 
private:
 vrpn_Semaphore d_semaphore;
 
 struct knownConnection {
 char name[1000];
 vrpn_Connection *connection;
        knownConnection *next;
    };
 
    knownConnection *d_kcList;
 
    knownConnection *d_anonList;
 
 vrpn_ConnectionManager(void);
 
 // @brief copy constructor undefined to prevent instantiations
 vrpn_ConnectionManager(const vrpn_ConnectionManager &);
 
 void deleteConnection(vrpn_Connection *, knownConnection **);
};
 
#endif // VRPN_CONNECTION_H