cipconnectionobject.h

Go to the documentation of this file.

/*******************************************************************************
 * Copyright (c) 2017, Rockwell Automation, Inc.
 * All rights reserved.
 *
 ******************************************************************************/

#ifndef SRC_CIP_CIPCONNECTIONOBJECT_H_
#define SRC_CIP_CIPCONNECTIONOBJECT_H_

#include "typedefs.h"
#include "ciptypes.h"
#include "opener_user_conf.h"
#include "opener_api.h"
#include "doublylinkedlist.h"
#include "cipelectronickey.h"
#include "cipepath.h"

#define CIP_CONNECTION_OBJECT_CODE 0x05

typedef enum {
  kConnectionObjectStateNonExistent = 0, 
  kConnectionObjectStateConfiguring, 
  kConnectionObjectStateWaitingForConnectionID, 
  kConnectionObjectStateEstablished, 
  kConnectionObjectStateTimedOut, 
  kConnectionObjectStateDeferredDelete, 
  kConnectionObjectStateClosing, 
  kConnectionObjectStateInvalid 
} ConnectionObjectState;

typedef enum {
  kConnectionObjectInstanceTypeInvalid = -1, 
  kConnectionObjectInstanceTypeExplicitMessaging = 0, 
  kConnectionObjectInstanceTypeIO, 
  kConnectionObjectInstanceTypeIOExclusiveOwner, 
  kConnectionObjectInstanceTypeIOInputOnly, 
  kConnectionObjectInstanceTypeIOListenOnly, 
  kConnectionObjectInstanceTypeCipBridged  
} ConnectionObjectInstanceType;

typedef enum {
  kConnectionObjectTransportClassTriggerDirectionClient = 0,  
  kConnectionObjectTransportClassTriggerDirectionServer 
} ConnectionObjectTransportClassTriggerDirection;

typedef enum {
  kConnectionObjectTransportClassTriggerProductionTriggerInvalid = -1,  
  kConnectionObjectTransportClassTriggerProductionTriggerCyclic = 0, 
  kConnectionObjectTransportClassTriggerProductionTriggerChangeOfState, 
  kConnectionObjectTransportClassTriggerProductionTriggerApplicationObject 
} ConnectionObjectTransportClassTriggerProductionTrigger;

typedef enum {
  kConnectionObjectTransportClassTriggerTransportClassInvalid = -1, 
  kConnectionObjectTransportClassTriggerTransportClass0 = 0, 
  kConnectionObjectTransportClassTriggerTransportClass1, 
  kConnectionObjectTransportClassTriggerTransportClass2, 
  kConnectionObjectTransportClassTriggerTransportClass3 
  /* Higher transport classes not supported */
} ConnectionObjectTransportClassTriggerTransportClass;

typedef enum {
  kConnectionObjectWatchdogTimeoutActionTransitionToTimedOut = 0,       
  kConnectionObjectWatchdogTimeoutActionAutoDelete,       
  kConnectionObjectWatchdogTimeoutActionAutoReset,       
  kConnectionObjectWatchdogTimeoutActionDeferredDelete,       
  kConnectionObjectWatchdogTimeoutActionInvalid       
} ConnectionObjectWatchdogTimeoutAction;

typedef enum {
  kConnectionObjectConnectionTypeNull = 0,
  kConnectionObjectConnectionTypeMulticast,
  kConnectionObjectConnectionTypePointToPoint,
  kConnectionObjectConnectionTypeInvalid
} ConnectionObjectConnectionType;

typedef enum {
  kConnectionObjectPriorityLow = 0,
  kConnectionObjectPriorityHigh,
  kConnectionObjectPriorityScheduled,
  kConnectionObjectPriorityUrgent
} ConnectionObjectPriority;

typedef enum {
  kConnectionObjectConnectionSizeTypeFixed,
  kConnectionObjectConnectionSizeTypeVariable
} ConnectionObjectConnectionSizeType;

typedef enum {
  kConnectionObjectSocketTypeProducing = 0,
  kConnectionObjectSocketTypeConsuming = 1
} ConnectionObjectSocketType;

typedef struct cip_connection_object CipConnectionObject;

typedef EipStatus (*CipConnectionStateHandler)(CipConnectionObject *RESTRICT
                                               const connection_object,
                                               ConnectionObjectState new_state);

struct cip_connection_object {
  CipUsint state; /*< Attribute 1 */
  CipUsint instance_type; /*< Attribute 2 */
  CipByte transport_class_trigger; /*< Attribute 3 */
  /* Attribute 4-6 only for device net*/
  CipUint produced_connection_size; /*< Attribute 7 - Limits produced connection size - for explicit messaging 0xFFFF means no predefined limit */
  CipUint consumed_connection_size; /*< Attribute 8 - Limits produced connection size - for explicit messaging 0xFFFF means no predefined limit */
  CipUint expected_packet_rate; /*< Attribute 9 - Resolution in Milliseconds */
  CipUdint cip_produced_connection_id; /*< Attribute 10 */
  CipUdint cip_consumed_connection_id; /*< Attribute 11 */
  CipUsint watchdog_timeout_action; /*< Attribute 12 */
  CipUint produced_connection_path_length; /*< Attribute 13 */
  CipOctet *produced_connection_path; /*< Attribute 14 */
  CipConnectionPathEpath produced_path;
  CipUint consumed_connection_path_length; /*< Attribute 15 */
  CipOctet *consumed_connection_path; /*< Attribute 16 */
  CipConnectionPathEpath consumed_path;
  CipUint production_inhibit_time; /*< Attribute 17 */
  CipUsint connection_timeout_multiplier; /*< Attribute 18 */
  /* Attribute 19 not supported as Connection Bind service not supported */

  /* End of CIP attributes */
  /* Start of needed non-object variables */
  CipElectronicKey electronic_key; //TODO: Check if really needed

  CipConnectionPathEpath configuration_path;

  CipInstance *producing_instance;
  CipInstance *consuming_instance;

  CipUint requested_produced_connection_size;
  CipUint requested_consumed_connection_size;

  uint64_t transmission_trigger_timer;
  uint64_t inactivity_watchdog_timer;
  uint64_t last_package_watchdog_timer;
  uint64_t production_inhibit_timer;

  CipUint connection_serial_number;
  CipUint originator_vendor_id;
  CipUdint originator_serial_number;

  CipUdint o_to_t_requested_packet_interval;
  CipWord o_to_t_network_connection_parameters;

  CipUdint t_to_o_requested_packet_interval;
  CipWord t_to_o_network_connection_parameters;

  CipUint sequence_count_producing; 
  CipUint sequence_count_consuming; 
  EipUint32 eip_level_sequence_count_producing; 
  EipUint32 eip_level_sequence_count_consuming; 
  CipInt correct_originator_to_target_size;
  CipInt correct_target_to_originator_size;

  /* Sockets for consuming and producing connection */
  int socket[2];

  struct sockaddr_in remote_address; /* socket address for produce */
  struct sockaddr_in originator_address; /* the address of the originator that
                                              established the connection. needed
                                              for scanning if the right packet is
                                              arriving */

  size_t associated_encapsulation_session; /* The session handle ID via which the forward open was sent */

  /* pointers to connection handling functions */
  CipConnectionStateHandler current_state_handler;

  ConnectionCloseFunction connection_close_function;
  ConnectionTimeoutFunction connection_timeout_function;
  ConnectionSendDataFunction connection_send_data_function;
  ConnectionReceiveDataFunction connection_receive_data_function;

  ENIPMessage last_reply_sent;
};

DoublyLinkedListNode *CipConnectionObjectListArrayAllocator(
  );
void CipConnectionObjectListArrayFree(DoublyLinkedListNode **node);

CipConnectionObject *CipConnectionObjectCreate(const CipOctet *message);

void CipConnectionObjectDelete(CipConnectionObject **connection_object);

void ConnectionObjectInitializeEmpty(
  CipConnectionObject *const connection_object);

void ConnectionObjectInitializeFromMessage(
  const CipOctet **message,
  CipConnectionObject *const
  connection_object);

ConnectionObjectState ConnectionObjectGetState(
  const CipConnectionObject *const connection_object);

void ConnectionObjectSetState(CipConnectionObject *const connection_object,
                              const ConnectionObjectState state);

ConnectionObjectInstanceType ConnectionObjectGetInstanceType(
  const CipConnectionObject *const connection_object);

void ConnectionObjectSetInstanceType(
  CipConnectionObject *const connection_object,
  const ConnectionObjectInstanceType instance_type);

CipUsint ConnectionObjectGetInstanceTypeForAttribute(
  const CipConnectionObject *const connection_object);

ConnectionObjectTransportClassTriggerDirection
ConnectionObjectGetTransportClassTriggerDirection(
  const CipConnectionObject *const connection_object);

ConnectionObjectTransportClassTriggerProductionTrigger
ConnectionObjectGetTransportClassTriggerProductionTrigger(
  const CipConnectionObject *const connection_object);

ConnectionObjectTransportClassTriggerTransportClass
ConnectionObjectGetTransportClassTriggerTransportClass(
  const CipConnectionObject *const connection_object);

CipUint ConnectionObjectGetProducedConnectionSize(
  const CipConnectionObject *const connection_object);

void ConnectionObjectSetProducedConnectionSize(
  CipConnectionObject *const connection_object,
  const CipUint
  produced_connection_size);

CipUint ConnectionObjectGetConsumedConnectionSize(
  const CipConnectionObject *const connection_object);

void ConnectionObjectSetConsumedConnectionSize(
  CipConnectionObject *const connection_object,
  const CipUint
  consumed_connection_size);

CipUint ConnectionObjectGetExpectedPacketRate(
  const CipConnectionObject *const connection_object);

CipUint ConnectionObjectGetRequestedPacketInterval(
  const CipConnectionObject *const connection_object);

void ConnectionObjectSetExpectedPacketRate(
  CipConnectionObject *const connection_object);

CipUdint ConnectionObjectGetCipProducedConnectionID(
  const CipConnectionObject *const connection_object);

void ConnectionObjectSetCipProducedConnectionID(
  CipConnectionObject *const connection_object,
  const CipUdint
  cip_produced_connection_id);

CipUdint ConnectionObjectGetCipConsumedConnectionID(
  const CipConnectionObject *const connection_object);

void ConnectionObjectSetCipConsumedConnectionID(
  CipConnectionObject *const connection_object,
  const CipUdint
  cip_consumed_connection_id);

ConnectionObjectWatchdogTimeoutAction ConnectionObjectGetWatchdogTimeoutAction(
  const CipConnectionObject *const connection_object);

void ConnectionObjectSetWatchdogTimeoutAction(
  CipConnectionObject *const connection_object,
  const CipUsint
  watchdog_timeout_action);

CipUint ConnectionObjectGetProducedConnectionPathLength(
  const CipConnectionObject *const connection_object);

void ConnectionObjectSetProducedConnectionPathLength(
  CipConnectionObject *const connection_object,
  const CipUint
  produced_connection_path_length);

CipUint ConnectionObjectGetConsumedConnectionPathLength(
  const CipConnectionObject *const connection_object);

void ConnectionObjectSetConsumedConnectionPathLength(
  CipConnectionObject *const connection_object,
  const CipUint
  consumed_connection_path_length);

CipUint ConnectionObjectGetProductionInhibitTime(
  const CipConnectionObject *const connection_object);

void ConnectionObjectSetProductionInhibitTime(
  CipConnectionObject *const connection_object,
  const CipUint
  production_inhibit_time);

CipUsint ConnectionObjectGetConnectionTimeoutMultiplier(
  const CipConnectionObject *const connection_object);

void ConnectionObjectSetConnectionTimeoutMultiplier(
  CipConnectionObject *const connection_object,
  const CipUsint
  connection_timeout_multiplier);

void ConnectionObjectResetInactivityWatchdogTimerValue(
  CipConnectionObject *const connection_object);

void ConnectionObjectResetLastPackageInactivityTimerValue(
  CipConnectionObject *const connection_object);

CipUint ConnectionObjectGetConnectionSerialNumber(
  const CipConnectionObject *const connection_object);

void ConnectionObjectSetConnectionSerialNumber(
  CipConnectionObject *connection_object,
  const CipUint connection_serial_number);

CipUint ConnectionObjectGetOriginatorVendorId(
  const CipConnectionObject *const connection_object);

void ConnectionObjectSetOriginatorVendorId(
  CipConnectionObject *connection_object,
  const CipUint vendor_id);

CipUdint ConnectionObjectGetOriginatorSerialNumber(
  const CipConnectionObject *const connection_object);

void ConnectionObjectSetOriginatorSerialNumber(
  CipConnectionObject *connection_object,
  CipUdint originator_serial_number);

CipUdint ConnectionObjectGetOToTRequestedPacketInterval(
  const CipConnectionObject *const connection_object);

void ConnectionObjectSetOToTRequestedPacketInterval(
  CipConnectionObject *connection_object,
  const CipUdint requested_packet_interval);

bool ConnectionObjectIsOToTRedundantOwner(
  const CipConnectionObject *const connection_object);

ConnectionObjectConnectionType ConnectionObjectGetOToTConnectionType(
  const CipConnectionObject *const connection_object);

ConnectionObjectPriority ConnectionObjectGetOToTPriority(
  const CipConnectionObject *const connection_object);

ConnectionObjectConnectionSizeType ConnectionObjectGetOToTConnectionSizeType(
  const CipConnectionObject *const connection_object);

size_t ConnectionObjectGetOToTConnectionSize(
  const CipConnectionObject *const connection_object);

/* T to O */
CipUdint ConnectionObjectGetTToORequestedPacketInterval(
  const CipConnectionObject *const connection_object);

void ConnectionObjectSetTToORequestedPacketInterval(
  CipConnectionObject *connection_object,
  const CipUdint requested_packet_interval);

bool ConnectionObjectIsTToORedundantOwner(
  const CipConnectionObject *const connection_object);

ConnectionObjectConnectionType ConnectionObjectGetTToOConnectionType(
  const CipConnectionObject *const connection_object);

ConnectionObjectPriority ConnectionObjectGetTToOPriority(
  const CipConnectionObject *const connection_object);

ConnectionObjectConnectionSizeType ConnectionObjectGetTToOConnectionSizeType(
  const CipConnectionObject *const connection_object);

size_t ConnectionObjectGetTToOConnectionSize(
  const CipConnectionObject *const connection_object);

void ConnectionObjectDeepCopy(CipConnectionObject *RESTRICT destination,
                              const CipConnectionObject *RESTRICT const source);

void ConnectionObjectResetProductionInhibitTimer(
  CipConnectionObject *const connection_object);

void ConnectionObjectGeneralConfiguration(
  CipConnectionObject *const connection_object);

bool ConnectionObjectIsTypeNonLOIOConnection(
  const CipConnectionObject *const connection_object);

bool ConnectionObjectIsTypeIOConnection(
  const CipConnectionObject *const connection_object);

bool ConnectionObjectEqualOriginator(const CipConnectionObject *const object1,
                                     const CipConnectionObject *const object2);

bool EqualConnectionTriad(const CipConnectionObject *const object1,
                          const CipConnectionObject *const object2);

bool CipConnectionObjectOriginatorHasSameIP(
  const CipConnectionObject *const connection_object,
  const struct sockaddr *const originator_address);

#endif /* SRC_CIP_CIPCONNECTIONOBJECT_H_ */