appcontype.c

Go to the documentation of this file.

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

#include <string.h>

#include "appcontype.h"

#include "cipconnectionmanager.h"
#include "cipconnectionobject.h"
#include "opener_api.h"
#include "assert.h"
#include "trace.h"
#include "cipepath.h"

typedef struct {
  unsigned int output_assembly; 
  unsigned int input_assembly; 
  unsigned int config_assembly; 
  CipConnectionObject connection_data; 
} ExclusiveOwnerConnection;

typedef struct {
  unsigned int output_assembly; 
  unsigned int input_assembly; 
  unsigned int config_assembly; 
  CipConnectionObject connection_data[
    OPENER_CIP_NUM_INPUT_ONLY_CONNS_PER_CON_PATH];                                   /*< the connection data */
} InputOnlyConnection;

typedef struct {
  unsigned int output_assembly; 
  unsigned int input_assembly; 
  unsigned int config_assembly; 
  CipConnectionObject connection_data[
    OPENER_CIP_NUM_LISTEN_ONLY_CONNS_PER_CON_PATH
  ];                                                                               
} ListenOnlyConnection;

ExclusiveOwnerConnection g_exlusive_owner_connections[
  OPENER_CIP_NUM_EXLUSIVE_OWNER_CONNS];                                                     
InputOnlyConnection g_input_only_connections[OPENER_CIP_NUM_INPUT_ONLY_CONNS]; 
ListenOnlyConnection g_listen_only_connections[OPENER_CIP_NUM_LISTEN_ONLY_CONNS]; 
CipConnectionObject *GetExclusiveOwnerConnection(
  const CipConnectionObject *const RESTRICT connection_object,
  EipUint16 *const extended_error);

CipConnectionObject *GetInputOnlyConnection(
  const CipConnectionObject *const RESTRICT connection_object,
  EipUint16 *const extended_error);

CipConnectionObject *GetListenOnlyConnection(
  const CipConnectionObject *const RESTRICT connection_object,
  EipUint16 *const extended_error);

void ConfigureExclusiveOwnerConnectionPoint(
  const unsigned int connection_number,
  const unsigned int output_assembly,
  const unsigned int input_assembly,
  const unsigned int config_assembly) {
  if (OPENER_CIP_NUM_EXLUSIVE_OWNER_CONNS > connection_number) {
    g_exlusive_owner_connections[connection_number].output_assembly =
      output_assembly;
    g_exlusive_owner_connections[connection_number].input_assembly =
      input_assembly;
    g_exlusive_owner_connections[connection_number].config_assembly =
      config_assembly;
  }
}

void ConfigureInputOnlyConnectionPoint(const unsigned int connection_number,
                                       const unsigned int output_assembly,
                                       const unsigned int input_assembly,
                                       const unsigned int config_assembly) {
  if (OPENER_CIP_NUM_INPUT_ONLY_CONNS > connection_number) {
    g_input_only_connections[connection_number].output_assembly =
      output_assembly;
    g_input_only_connections[connection_number].input_assembly = input_assembly;
    g_input_only_connections[connection_number].config_assembly =
      config_assembly;
  }
}

void ConfigureListenOnlyConnectionPoint(const unsigned int connection_number,
                                        const unsigned int output_assembly,
                                        const unsigned int input_assembly,
                                        const unsigned int config_assembly) {
  if (OPENER_CIP_NUM_LISTEN_ONLY_CONNS > connection_number) {
    g_listen_only_connections[connection_number].output_assembly =
      output_assembly;
    g_listen_only_connections[connection_number].input_assembly =
      input_assembly;
    g_listen_only_connections[connection_number].config_assembly =
      config_assembly;
  }
}

CipConnectionObject *GetIoConnectionForConnectionData(
  CipConnectionObject *const RESTRICT connection_object,
  EipUint16 *const extended_error) {

  *extended_error = 0;

  CipConnectionObject *io_connection = GetExclusiveOwnerConnection(
    connection_object,
    extended_error);
  if (NULL == io_connection) {
    if (kConnectionManagerExtendedStatusCodeSuccess == *extended_error) {
      /* we found no connection and don't have an error so try input only next */
      io_connection = GetInputOnlyConnection(connection_object, extended_error);
      if (NULL == io_connection) {
        if (kConnectionManagerExtendedStatusCodeSuccess == *extended_error) {
          /* we found no connection and don't have an error so try listen only next */
          io_connection = GetListenOnlyConnection(connection_object,
                                                  extended_error);
          if ( (NULL == io_connection) && (kCipErrorSuccess == *extended_error) ) {
            /* no application connection type was found that suits the given data */
            *extended_error =
              kConnectionManagerExtendedStatusCodeInconsistentApplicationPathCombo;
          } else {
            ConnectionObjectSetInstanceType(connection_object,
                                            kConnectionObjectInstanceTypeIOListenOnly);
            OPENER_TRACE_INFO("IO Listen only connection requested\n");
            //Is listen only connection
          }
        }
      } else {
        ConnectionObjectSetInstanceType(connection_object,
                                        kConnectionObjectInstanceTypeIOInputOnly);
        OPENER_TRACE_INFO("IO Input only connection requested\n");
        //is Input only connection
      }
    }
  } else {
    ConnectionObjectSetInstanceType(connection_object,
                                    kConnectionObjectInstanceTypeIOExclusiveOwner);
    OPENER_TRACE_INFO("IO Exclusive Owner connection requested\n");
    //Is exclusive owner connection
  }

  if (NULL != io_connection) {
    ConnectionObjectDeepCopy(io_connection, connection_object);
  }

  return io_connection;
}

CipConnectionObject *GetExclusiveOwnerConnection(
  const CipConnectionObject *const RESTRICT connection_object,
  EipUint16 *const extended_error) {

  for (size_t i = 0; i < OPENER_CIP_NUM_EXLUSIVE_OWNER_CONNS; ++i) {
    if ( (g_exlusive_owner_connections[i].output_assembly ==
          connection_object->consumed_path.instance_id)
         && (g_exlusive_owner_connections[i].input_assembly ==
             connection_object->produced_path.instance_id)
         && (g_exlusive_owner_connections[i].config_assembly ==
             connection_object->configuration_path.instance_id) ) {

      /* check if on other connection point with the same output assembly is currently connected */
      CipConnectionObject *exclusive_owner = GetConnectedOutputAssembly(
        connection_object->produced_path.instance_id);
      if ( NULL
           != exclusive_owner ) {
        if(kConnectionObjectStateEstablished ==
           ConnectionObjectGetState(exclusive_owner) ) {
          *extended_error =
            kConnectionManagerExtendedStatusCodeErrorOwnershipConflict;
          OPENER_TRACE_INFO("Hit an Ownership conflict in appcontype.c:198\n");
          break;
        }
        if(kConnectionObjectStateTimedOut ==
           ConnectionObjectGetState(exclusive_owner)
           && ConnectionObjectEqualOriginator(connection_object,
                                              exclusive_owner) ) {
          g_exlusive_owner_connections[i].connection_data.
          connection_close_function(&(g_exlusive_owner_connections[i].
                                      connection_data) );
          return &(g_exlusive_owner_connections[i].connection_data);
        } else {
          *extended_error =
            kConnectionManagerExtendedStatusCodeErrorOwnershipConflict;
          OPENER_TRACE_INFO(
            "Hit an Ownership conflict with timed out connection");
          break;
        }
      }
      return &(g_exlusive_owner_connections[i].connection_data);
    }
  }
  return NULL;
}

CipConnectionObject *GetInputOnlyConnection(
  const CipConnectionObject *const RESTRICT connection_object,
  EipUint16 *const extended_error) {

  for (size_t i = 0; i < OPENER_CIP_NUM_INPUT_ONLY_CONNS; ++i) {
    if (g_input_only_connections[i].output_assembly
        == connection_object->consumed_path.instance_id) { /* we have the same output assembly */
      if (g_input_only_connections[i].input_assembly
          != connection_object->produced_path.instance_id) {
        *extended_error =
          kConnectionManagerExtendedStatusCodeInvalidProducingApplicationPath;
        break;
      }
      if (g_input_only_connections[i].config_assembly
          != connection_object->configuration_path.instance_id) {
        *extended_error =
          kConnectionManagerExtendedStatusCodeInconsistentApplicationPathCombo;
        break;
      }

      for (size_t j = 0; j < OPENER_CIP_NUM_INPUT_ONLY_CONNS_PER_CON_PATH;
           ++j) {
        if (kConnectionObjectStateTimedOut
            == ConnectionObjectGetState(&(g_input_only_connections[i].
                                          connection_data[j]) )
            && ConnectionObjectEqualOriginator(connection_object,
                                               &(g_input_only_connections[i].
                                                 connection_data[j]) ) )
        {
          g_input_only_connections[i].connection_data[j].
          connection_close_function(
            &g_input_only_connections[i].connection_data[j]);
          return &(g_input_only_connections[i].connection_data[j]);
        }
      }

      for (size_t j = 0; j < OPENER_CIP_NUM_INPUT_ONLY_CONNS_PER_CON_PATH;
           ++j) {
        if (kConnectionObjectStateNonExistent
            == ConnectionObjectGetState(&(g_input_only_connections[i].
                                          connection_data[j]) ) ) {
          return &(g_input_only_connections[i].connection_data[j]);
        }
      }
      *extended_error =
        kConnectionManagerExtendedStatusCodeTargetObjectOutOfConnections;
      break;
    }
  }
  return NULL;
}

CipConnectionObject *GetListenOnlyConnection(
  const CipConnectionObject *const RESTRICT connection_object,
  EipUint16 *const extended_error) {

  for (size_t i = 0; i < OPENER_CIP_NUM_LISTEN_ONLY_CONNS; i++) {
    if (g_listen_only_connections[i].output_assembly
        == connection_object->consumed_path.instance_id) { /* we have the same output assembly */
      if (g_listen_only_connections[i].input_assembly
          != connection_object->produced_path.instance_id) {
        *extended_error =
          kConnectionManagerExtendedStatusCodeInvalidProducingApplicationPath;
        break;
      }
      if (g_listen_only_connections[i].config_assembly
          != connection_object->configuration_path.instance_id) {
        *extended_error =
          kConnectionManagerExtendedStatusCodeInconsistentApplicationPathCombo;
        break;
      }

      if ( NULL
           == GetExistingProducerMulticastConnection(
             connection_object->produced_path.instance_id) ) {
        *extended_error =
          kConnectionManagerExtendedStatusCodeNonListenOnlyConnectionNotOpened;
        break;
      }

      for (size_t j = 0; j < OPENER_CIP_NUM_LISTEN_ONLY_CONNS_PER_CON_PATH;
           ++j) {
        if (kConnectionObjectStateTimedOut
            == ConnectionObjectGetState(&(g_listen_only_connections[i].
                                          connection_data[j]) )
            && ConnectionObjectEqualOriginator(connection_object,
                                               &(g_listen_only_connections[i].
                                                 connection_data[j]) ) )
        {
          g_listen_only_connections[i].connection_data[j].
          connection_close_function(
            &g_listen_only_connections[i].connection_data[j]);
          return &(g_listen_only_connections[i].connection_data[j]);
        }
      }

      for (size_t j = 0; j < OPENER_CIP_NUM_LISTEN_ONLY_CONNS_PER_CON_PATH;
           j++) {
        if (kConnectionObjectStateNonExistent
            == ConnectionObjectGetState(&(g_listen_only_connections[i].
                                          connection_data[j]) ) ) {
          return &(g_listen_only_connections[i].connection_data[j]);
        }
      }
      *extended_error =
        kConnectionManagerExtendedStatusCodeTargetObjectOutOfConnections;
      break;
    }
  }
  return NULL;
}

CipConnectionObject *GetExistingProducerMulticastConnection(
  const EipUint32 input_point) {
  DoublyLinkedListNode *node = connection_list.first;

  while (NULL != node) {
    CipConnectionObject *producer_multicast_connection = node->data;
    if ( true ==
         ConnectionObjectIsTypeIOConnection(producer_multicast_connection) &&
         (input_point ==
          producer_multicast_connection->produced_path.instance_id) &&
         ( kConnectionObjectConnectionTypeMulticast ==
           ConnectionObjectGetTToOConnectionType(producer_multicast_connection) )
         &&
         (kEipInvalidSocket !=
          producer_multicast_connection->socket[
            kUdpCommuncationDirectionProducing]) )
    {
      /* we have a connection that produces the same input assembly,
       * is a multicast producer and manages the connection.
       */
      return producer_multicast_connection;
    }
    node = node->next;
  }
  return NULL;
}

CipConnectionObject *GetNextNonControlMasterConnection(
  const EipUint32 input_point) {
  DoublyLinkedListNode *node = connection_list.first;

  while (NULL != node) {
    CipConnectionObject *next_non_control_master_connection =
      node->data;
    if ( true == ConnectionObjectIsTypeNonLOIOConnection(next_non_control_master_connection)
         && kConnectionObjectStateEstablished == ConnectionObjectGetState(next_non_control_master_connection)
         && input_point == next_non_control_master_connection->produced_path.instance_id
         &&  kConnectionObjectConnectionTypeMulticast == ConnectionObjectGetTToOConnectionType(next_non_control_master_connection)
         && (kEipInvalidSocket == next_non_control_master_connection->socket[kUdpCommuncationDirectionProducing]) ) {
      /* we have a connection that produces the same input assembly,
       * is a multicast producer and does not manage the connection.
       */
      return next_non_control_master_connection;
    }
    node = node->next;
  }
  return NULL;
}

void CloseAllConnectionsForInputWithSameType(const EipUint32 input_point,
                                             const ConnectionObjectInstanceType instance_type)
{

  OPENER_TRACE_INFO("Close all instance type %d only connections\n", instance_type);
  DoublyLinkedListNode *node = connection_list.first;
  while (NULL != node) {
    CipConnectionObject *connection = node->data;
    node = node->next;
    if ( (instance_type == ConnectionObjectGetInstanceType(connection))
         && (input_point == connection->produced_path.instance_id) ) {
      CipConnectionObject *connection_to_delete = connection;
      CheckIoConnectionEvent(
        connection_to_delete->consumed_path.instance_id,
        connection_to_delete->produced_path.instance_id,
        kIoConnectionEventClosed);

      assert(connection_to_delete->connection_close_function != NULL);
      connection_to_delete->connection_close_function(connection_to_delete);
    }
  }
}

void CloseAllConnections(void) {
  DoublyLinkedListNode *node = connection_list.first;
  while (NULL != node) {
    CipConnectionObject *connection = node->data;
    assert(connection->connection_close_function != NULL);
    connection->connection_close_function(connection);
    node = connection_list.first;
  }
}

bool ConnectionWithSameConfigPointExists(const EipUint32 config_point) {
  DoublyLinkedListNode *node = connection_list.first;

  while (NULL != node) {
    CipConnectionObject *connection = node->data;
    OPENER_ASSERT(NULL != connection)
    if (config_point == connection->configuration_path.instance_id) {
      return true;
    }
    node = node->next;
  }
  return false;
}

void InitializeIoConnectionData(void) {
  memset( g_exlusive_owner_connections, 0,
          OPENER_CIP_NUM_EXLUSIVE_OWNER_CONNS *
          sizeof(ExclusiveOwnerConnection) );
  memset( g_input_only_connections, 0,
          OPENER_CIP_NUM_INPUT_ONLY_CONNS * sizeof(InputOnlyConnection) );
  memset( g_listen_only_connections, 0,
          OPENER_CIP_NUM_LISTEN_ONLY_CONNS * sizeof(ListenOnlyConnection) );
}