Makes EPath tests working

source/src/cip/CMakeLists.txt

@@ -12,6 +12,6 @@ opener_common_includes()
 #######################################
 opener_platform_support("INCLUDES")
 
-set( CIP_SRC appcontype.c cipassembly.c cipclass3connection.c cipcommon.c cipconnectionmanager.c ciperror.h cipethernetlink.c cipidentity.c cipioconnection.c cipmessagerouter.c ciptcpipinterface.c ciptypes.h )
+set( CIP_SRC appcontype.c cipassembly.c cipclass3connection.c cipcommon.c cipconnectionmanager.c ciperror.h cipethernetlink.c cipidentity.c cipioconnection.c cipmessagerouter.c ciptcpipinterface.c ciptypes.h cipepath.h cipepath.c cipelectronickey.h cipelectronickey.c )
 
 add_library( CIP ${CIP_SRC} )

source/src/cip/cipassembly.c

@@ -5,6 +5,7 @@
  ******************************************************************************/
 
 #include <string.h>
+#include <stdbool.h>
 
 #include "cipassembly.h"
 

source/src/cip/cipcommon.c

@@ -21,6 +21,7 @@
 #include "cpf.h"
 #include "trace.h"
 #include "appcontype.h"
+#include "cipepath.h"
 
 /* global public variables */
 EipUint8 g_message_data_reply_buffer[OPENER_MESSAGE_DATA_REPLY_BUFFER]; /**< Reply buffer */
@@ -757,34 +758,34 @@ int DecodePaddedEPath(CipEpath *epath, const EipUint8 **message) {
     }
 
     switch (*message_runner) {
-      case kSegmentTypeLogicalSegment + kLogicalSegmentLogicalTypeClassId + kLogicalSegmentLogicalFormatEightBitValue:
+      case SEGMENT_TYPE_LOGICAL_SEGMENT_MESSAGE_VALUE + LOGICAL_SEGMENT_TYPE_CLASS_ID_MESSAGE_VALUE + LOGICAL_SEGMENT_FORMAT_EIGHT_BIT_MESSAGE_VALUE:
         epath->class_id = *(EipUint8 *) (message_runner + 1);
         message_runner += 2;
         break;
 
-      case kSegmentTypeLogicalSegment + kLogicalSegmentLogicalTypeClassId + kLogicalSegmentLogicalFormatSixteenBitValue:
+      case SEGMENT_TYPE_LOGICAL_SEGMENT_MESSAGE_VALUE + LOGICAL_SEGMENT_TYPE_CLASS_ID_MESSAGE_VALUE + LOGICAL_SEGMENT_FORMAT_SIXTEEN_BIT_MESSAGE_VALUE:
         message_runner += 2;
         epath->class_id = GetIntFromMessage(&(message_runner));
         number_of_decoded_elements++;
         break;
 
-      case kSegmentTypeLogicalSegment + kLogicalSegmentLogicalTypeInstanceId + kLogicalSegmentLogicalFormatEightBitValue:
+      case SEGMENT_TYPE_LOGICAL_SEGMENT_MESSAGE_VALUE + LOGICAL_SEGMENT_TYPE_INSTANCE_ID_MESSAGE_VALUE + LOGICAL_SEGMENT_FORMAT_EIGHT_BIT_MESSAGE_VALUE:
         epath->instance_number = *(EipUint8 *) (message_runner + 1);
         message_runner += 2;
         break;
 
-      case kSegmentTypeLogicalSegment + kLogicalSegmentLogicalTypeInstanceId + kLogicalSegmentLogicalFormatSixteenBitValue:
+      case SEGMENT_TYPE_LOGICAL_SEGMENT_MESSAGE_VALUE + LOGICAL_SEGMENT_TYPE_INSTANCE_ID_MESSAGE_VALUE + LOGICAL_SEGMENT_FORMAT_SIXTEEN_BIT_MESSAGE_VALUE:
         message_runner += 2;
         epath->instance_number = GetIntFromMessage(&(message_runner));
         number_of_decoded_elements++;
         break;
 
-      case kSegmentTypeLogicalSegment + kLogicalSegmentLogicalTypeAttributeId + kLogicalSegmentLogicalFormatEightBitValue:
+      case SEGMENT_TYPE_LOGICAL_SEGMENT_MESSAGE_VALUE + LOGICAL_SEGMENT_TYPE_ATTRIBUTE_ID_MESSAGE_VALUE + LOGICAL_SEGMENT_FORMAT_EIGHT_BIT_MESSAGE_VALUE:
         epath->attribute_number = *(EipUint8 *) (message_runner + 1);
         message_runner += 2;
         break;
 
-      case kSegmentTypeLogicalSegment + kLogicalSegmentLogicalTypeAttributeId + kLogicalSegmentLogicalFormatSixteenBitValue:
+      case SEGMENT_TYPE_LOGICAL_SEGMENT_MESSAGE_VALUE + LOGICAL_SEGMENT_TYPE_ATTRIBUTE_ID_MESSAGE_VALUE + LOGICAL_SEGMENT_FORMAT_SIXTEEN_BIT_MESSAGE_VALUE:
         message_runner += 2;
         epath->attribute_number = GetIntFromMessage(&(message_runner));
         number_of_decoded_elements++;

source/src/cip/cipconnectionmanager.c

@@ -4,6 +4,7 @@
  *
  ******************************************************************************/
 #include <string.h>
+#include <stdbool.h>
 
 #include "cipconnectionmanager.h"
 

source/src/cip/cipelectronickey.h

@@ -9,6 +9,8 @@
 
 #include <stdbool.h>
 
+#include "typedefs.h"
+
 typedef struct electronic_key_format_4 ElectronicKeyFormat4;
 
 void SetElectronicKeyFormat4VendorId(const CipUint vendor_id, ElectronicKeyFormat4 *const electronic_key);

source/src/cip/cipepath.c

@@ -5,60 +5,62 @@
  ******************************************************************************/
 
 #include <stdbool.h>
+#include <stdlib.h>
 
 #include "cipepath.h"
 
 #include "endianconv.h"
 #include "cipelectronickey.h"
+#include "trace.h"
 
 const unsigned int kPortSegmentExtendedPort = 15; /**< Reserved port segment port value, indicating the use of the extended port field */
 
 /* Segments */
-const unsigned int kSegmentTypePortSegmentMessageValue = 0x00; /**< Message value of the Port segment */
-const unsigned int kSegmentTypeLogicalSegmentMessageValue = 0x20; /**< Message value of the Logical segment */
-const unsigned int kSegmentTypeNetworkSegmentMessageValue = 0x40; /**< Message value of the Network segment */
-const unsigned int kSegmentTypeSymbolicSegmentMessageValue = 0x60; /**< Message value of the Symbolic segment */
-const unsigned int kSegmentTypeDataSegmentMessageValue = 0x80; /**< Message value of the Data segment */
-const unsigned int kSegmentTypeDataTypeConstructedMessageValue = 0xA0; /**< Message value of the Data type constructed */
-const unsigned int kSegmentTypeDataTypeElementaryMessageValue = 0xC0; /**< Message value of the Data type elementary */
-const unsigned int kSegmentTypeSegmentTypeReservedMessageValue = 0xE0; /**< Reserved value */
-
-const unsigned int kLogicalSegmentLogicalTypeClassIdMessageValue = 0x00; /**< Message value of the logical segment/logical type Class ID */
-const unsigned int kLogicalSegmentLogicalTypeInstanceIdMessageValue = 0x04; /**< Message value of the logical segment/logical type Instance ID */
-const unsigned int kLogicalSegmentLogicalTypeMemberIdMessageValue = 0x08; /**< Message value of the logical segment/logical type Member ID */
-const unsigned int kLogicalSegmentLogicalTypeConnectionPointMessageValue = 0x0C; /**< Message value of the logical segment/logical type Connection Point */
-const unsigned int kLogicalSegmentLogicalTypeAttributeIdMessageValue = 0x10; /**< Message value of the logical segment/logical type Attribute ID */
-const unsigned int kLogicalSegmentLogicalTypeSpecialMessageValue = 0x14; /**< Message value of the logical segment/logical type Special */
-const unsigned int kLogicalSegmentLogicalTypeServiceIdMessageValue = 0x18; /**< Message value of the logical segment/logical type Service ID */
-const unsigned int kLogicalSegmentLogicalTypeExtendedLogicalMessageValue = 0x1C; /**< Message value of the logical segment/logical type Extended Logical */
-
-const unsigned int kLogicalSegmentLogicalFormatEightBitMessageValue = 0x00;
-const unsigned int kLogicalSegmentLogicalFormatSixteenBitMessageValue = 0x01;
-const unsigned int kLogicalSegmentLogicalFormatThirtyTwoBitMessageValue = 0x02;
-
-const unsigned int kLogicalSegmentLogicalExtendedTypeReservedMessageValue = 0x00;
-const unsigned int kLogicalSegmentLogicalExtendedTypeArrayIndexMessageValue = 0x01;
-const unsigned int kLogicalSegmentLogicalExtendedTypeIndirectArrayIndexMessageValue = 0x02;
-const unsigned int kLogicalSegmentLogicalExtendedTypeBitIndexMessageValue = 0x03;
-const unsigned int kLogicalSegmentLogicalExtendedTypeIndirectBitIndexMessageValue = 0x04;
-const unsigned int kLogicalSegmentLogicalExtendedTypeStructureMemberNumberMessageValue = 0x05;
-const unsigned int kLogicalSegmentLogicalExtendedTypeStructureMemberHandleMessageValue = 0x06;
-
-const unsigned int kLogicalSegmentSpecialTypeLogicalFormatElectronicKeyMessageValue = 0x00;
-
-const unsigned int kNetworkSegmentSubtypeScheduleSegmentMessageValue = 0x01;
-const unsigned int kNetworkSegmentSubtypeFixedTagSegmentMessageValue = 0x02;
-const unsigned int kNetworkSegmentSubtypeProductionInhibitTimeInMillisecondsMessageValue = 0x03;
-const unsigned int kNetworkSegmentSubtypeSafetySegmentMessageValue = 0x04;
-const unsigned int kNetworkSegmentSubtypeProductionInhibitTimeInMicrosecondsMessageValue = 0x10;
-const unsigned int kNetworkSegmentSubtypeExtendedNetworkSegmentMessageValue = 0x1F;
+#define SEGMENT_TYPE_PORT_SEGMENT_MESSAGE_VALUE 0x00 /**< Message value of the Port segment */
+#define SEGMENT_TYPE_LOGICAL_SEGMENT_MESSAGE_VALUE 0x20 /**< Message value of the Logical segment */
+#define SEGMENT_TYPE_NETWORK_SEGMENT_MESSAGE_VALUE 0x40 /**< Message value of the Network segment */
+#define SEGMENT_TYPE_SYMBOLIC_SEGMENT_MESSAGE_VALUE 0x60 /**< Message value of the Symbolic segment */
+#define SEGMENT_TYPE_DATA_SEGMENT_MESSAGE_VALUE 0x80 /**< Message value of the Data segment */
+#define SEGMENT_TYPE_DATA_TYPE_CONSTRUCTED_MESSAGE_VALUE 0xA0 /**< Message value of the Data type constructed */
+#define SEGMENT_TYPE_DATA_TYPE_ELEMENTARTY_MESSAGE_VALUE 0xC0 /**< Message value of the Data type elementary */
+#define SEGMENT_TYPE_SEGMENT_RESERVED_MESSAGE_VALUE 0xE0 /**< Reserved value */
+
+#define LOGICAL_SEGMENT_TYPE_CLASS_ID_MESSAGE_VALUE 0x00 /**< Message value of the logical segment/logical type Class ID */
+#define LOGICAL_SEGMENT_TYPE_INSTANCE_ID_MESSAGE_VALUE 0x04 /**< Message value of the logical segment/logical type Instance ID */
+#define LOGICAL_SEGMENT_TYPE_MEMBER_ID_MESSAGE_VALUE 0x08 /**< Message value of the logical segment/logical type Member ID */
+#define LOGICAL_SEGMENT_TYPE_CONNECTION_POINT_MESSAGE_VALUE 0x0C /**< Message value of the logical segment/logical type Connection Point */
+#define LOGICAL_SEGMENT_TYPE_ATTRIBUTE_ID_MESSAGE_VALUE 0x10 /**< Message value of the logical segment/logical type Attribute ID */
+#define LOGICAL_SEGMENT_TYPE_SPECIAL_MESSAGE_VALUE 0x14 /**< Message value of the logical segment/logical type Special */
+#define LOGICAL_SEGMENT_TYPE_SERVICE_ID_MESSAGE_VALUE 0x18 /**< Message value of the logical segment/logical type Service ID */
+#define LOGICAL_SEGMENT_TYPE_EXTENDED_LOGICAL_MESSAGE_VALUE 0x1C /**< Message value of the logical segment/logical type Extended Logical */
+
+#define LOGICAL_SEGMENT_FORMAT_EIGHT_BIT_MESSAGE_VALUE 0x00
+#define LOGICAL_SEGMENT_FORMAT_SIXTEEN_BIT_MESSAGE_VALUE 0x01
+#define LOGICAL_SEGMENT_FORMAT_THIRTY_TWO_BIT_MESSAGE_VALUE 0x02
+
+#define LOGICAL_SEGMENT_EXTENDED_TYPE_RESERVED_MESSAGE_VALUE 0x00
+#define LOGICAL_SEGMENT_EXTENDED_TYPE_ARRAY_INDEX_MESSAGE_VALUE 0x01
+#define LOGICAL_SEGMENT_EXTENDED_TYPE_INDIRECT_ARRAY_INDEX_MESSAGE_VALUE 0x02
+#define LOGICAL_SEGMENT_EXTENDED_TYPE_BIT_INDEX_MESSAGE_VALUE 0x03
+#define LOGICAL_SEGMENT_EXTENDED_TYPE_INDIRECT_BIT_INDEX_MESSAGE_VALUE 0x04
+#define LOGICAL_SEGMENT_EXTENDED_TYPE_STRUCTURE_MEMBER_NUMBER_MESSAGE_VALUE 0x05
+#define LOGICAL_SEGMENT_EXTENDED_TYPE_STRUCTURE_MEMBER_HANDLE_MESSAGE_VALUE 0x06
+
+#define LOGICAL_SEGMENT_SPECIAL_TYPE_FORMAT_ELECTRONIC_KEY_MESSAGE_VALUE 0x00
+
+#define NETWORK_SEGMENT_SUBTYPE_SCHEDULE_MESSAGE_VALUE 0x01
+#define NETWORK_SEGMENT_SUBTYPE_FIXED_TAG_MESSAGE_VALUE 0x02
+#define NETWORK_SEGMENT_SUBTYPE_PRODUCTION_INHIBIT_TIME_IN_MILLISECONDS_MESSAGE_VALUE 0x03
+#define NETWORK_SEGMENT_SUBTYPE_SAFETY_MESSAGE_VALUE 0x04
+#define NETWORK_SEGMENT_SUBTYPE_PRODUCTION_INHIBIT_TIME_IN_MICROSECONDS_MESSAGE_VALUE 0x10
+#define NETWORK_SEGMENT_SUBTYPE_EXTENDED_NETWORK_MESSAGE_VALUE 0x1F
 
 typedef enum {
   kElectronicKeySegmentFormatReserved,
   kElectronicKeySegmentFormatKeyFormat4
 } ElectronicKeySegmentFormat;
 
-const unsigned int kElectronicKeySegmentFormatKeyFormat4MessageValue = 0x04;
+#define ELECTRONIC_KEY_SEGMENT_KEY_FORMAT_4_MESSAGE_VALUE 0x04
 
 typedef enum {
   kDataSegmentSubtypeReserved,
@@ -66,39 +68,39 @@ typedef enum {
   kDataSegmentSubtypeANSIExtendedSymbol
 } DataSegmentSubtype;
 
-const unsigned int kDataSegmentSubtypeSimpleDataMessageValue = 0x00;
-const unsigned int kDataSegmentSubtypeANSIExtendedSymbolMessageValue = 0x11;
+#define DATA_SEGMENT_SUBTYPE_SIMPLE_DATA_MESSAGE_VALUE 0x00
+#define DATA_SEGMENT_SUBTYPE_ANSI_EXTENDED_SYMBOL_MESSAGE_VALUE 0x11
 
 
 
 /*** Path Segment ***/
-SegmentType GetPathSegementType(const char *const cip_path) {
+SegmentType GetPathSegmentType(const char *const cip_path) {
   const unsigned int kSegmentTypeMask = 0xE0;
-  const unsigned int segment_type = cip_path & kSegmentTypeMask;
+  const unsigned int segment_type = *cip_path & kSegmentTypeMask;
   SegmentType result = kSegmentTypeReserved;
   switch (segment_type) {
-    case kSegmentTypePortSegmentMessageValue:
+    case SEGMENT_TYPE_PORT_SEGMENT_MESSAGE_VALUE:
       result = kSegmentTypePortSegment;
       break;
-    case kSegmentTypeLogicalSegmentMessageValue:
+    case SEGMENT_TYPE_LOGICAL_SEGMENT_MESSAGE_VALUE:
       result = kSegmentTypeLogicalSegment;
       break;
-    case kSegmentTypeNetworkSegmentMessageValue:
+    case SEGMENT_TYPE_NETWORK_SEGMENT_MESSAGE_VALUE:
       result = kSegmentTypeNetworkSegment;
       break;
-    case kSegmentTypeSymbolicSegmentMessageValue:
+    case SEGMENT_TYPE_SYMBOLIC_SEGMENT_MESSAGE_VALUE:
       result = kSegmentTypeSymbolicSegment;
       break;
-    case kSegmentTypeDataSegmentMessageValue:
+    case SEGMENT_TYPE_DATA_SEGMENT_MESSAGE_VALUE:
       result = kSegmentTypeDataSegment;
       break;
-    case kSegmentTypeDataTypeConstructedMessageValue:
+    case SEGMENT_TYPE_DATA_TYPE_CONSTRUCTED_MESSAGE_VALUE:
       result = kSegmentTypeDataTypeConstructed;
       break;
-    case kSegmentTypeDataTypeElementaryMessageValue:
+    case SEGMENT_TYPE_DATA_TYPE_ELEMENTARTY_MESSAGE_VALUE:
       result = kSegmentTypeDataTypeElementary;
       break;
-    case kSegmentTypeSegmentTypeReservedMessageValue:
+    case SEGMENT_TYPE_SEGMENT_RESERVED_MESSAGE_VALUE:
       result = kSegmentTypeReserved;
       break;
     default:
@@ -109,31 +111,31 @@ SegmentType GetPathSegementType(const char *const cip_path) {
   return result;
 }
 
-void SetPathSegementType(SegmentType segment_type, char *const cip_path) {
+void SetPathSegmentType(SegmentType segment_type, char *const cip_path) {
   switch (segment_type) {
     case kSegmentTypePortSegment:
-      cip_path |= kSegmentTypePortSegmentMessageValue;
+      *cip_path |= SEGMENT_TYPE_PORT_SEGMENT_MESSAGE_VALUE;
       break;
     case kSegmentTypeLogicalSegment:
-      cip_path |= kSegmentTypeLogicalSegmentMessageValue;
+      *cip_path |= SEGMENT_TYPE_LOGICAL_SEGMENT_MESSAGE_VALUE;
       break;
     case kSegmentTypeNetworkSegment:
-      cip_path |= kSegmentTypeNetworkSegmentMessageValue;
+      *cip_path |= SEGMENT_TYPE_NETWORK_SEGMENT_MESSAGE_VALUE;
       break;
     case kSegmentTypeSymbolicSegment:
-      cip_path |= kSegmentTypeSymbolicSegmentMessageValue;
+      *cip_path |= SEGMENT_TYPE_SYMBOLIC_SEGMENT_MESSAGE_VALUE;
       break;
     case kSegmentTypeDataSegment:
-      cip_path |= kSegmentTypeDataSegmentMessageValue;
+      *cip_path |= SEGMENT_TYPE_DATA_SEGMENT_MESSAGE_VALUE;
       break;
     case kSegmentTypeDataTypeConstructed:
-      cip_path |= kSegmentTypeDataTypeConstructedMessageValue;
+      *cip_path |= SEGMENT_TYPE_DATA_TYPE_CONSTRUCTED_MESSAGE_VALUE;
       break;
     case kSegmentTypeDataTypeElementary:
-      cip_path |= kSegmentTypeDataTypeElementaryMessageValue;
+      *cip_path |= SEGMENT_TYPE_DATA_TYPE_ELEMENTARTY_MESSAGE_VALUE;
       break;
     case kSegmentTypeReserved:
-      cip_path |= kSegmentTypeSegmentTypeReservedMessageValue;
+      *cip_path |= SEGMENT_TYPE_SEGMENT_RESERVED_MESSAGE_VALUE;
       break;
     default:
       OPENER_ASSERT(
@@ -142,9 +144,9 @@ void SetPathSegementType(SegmentType segment_type, char *const cip_path) {
 }
 
 /*** Port Segment ***/
-bool GetPathPortSegementExtendedLinkAddressSizeBit(const char *const cip_path) {
+bool GetPathPortSegmentExtendedLinkAddressSizeBit(const char *const cip_path) {
   const unsigned int kExtendedLinkAddressSizeMask = 0x10;
-  if (kExtendedLinkAddressSizeMask == cip_path & kExtendedLinkAddressSizeMask) {
+  if (kExtendedLinkAddressSizeMask == (*cip_path & kExtendedLinkAddressSizeMask) ) {
     return true;
   }
   return false;
@@ -152,31 +154,34 @@ bool GetPathPortSegementExtendedLinkAddressSizeBit(const char *const cip_path) {
 
 unsigned int GetPathPortSegmentPortIdentifier(const char *const cip_path) {
   const unsigned int kPortIdentifierMask = 0x0F;
-  unsigned int port_identifier = cip_path & kPortIdentifierMask;
-  OPENER_ASSERT(0 != port_identifier, "Use of reserved port identifier 0\n");
+  unsigned int port_identifier = *cip_path & kPortIdentifierMask;
+//  OPENER_ASSERT(0 != port_identifier, "Use of reserved port identifier 0\n");
+  OPENER_ASSERT(0 != port_identifier);
   return port_identifier;
 }
 
 void SetPathPortSegmentPortIdentifier(const unsigned int port_identifier,
                                       char *const cip_path) {
-  OPENER_ASSERT(
-      port_identifier < 16,
-      "Port identifier too large for standard port identifier field\n");
+//  OPENER_ASSERT(
+//      port_identifier < 16,
+//      "Port identifier too large for standard port identifier field\n");
+  OPENER_ASSERT(port_identifier < 16);
 
 }
 
-unsigned int GetPathPortSegementLinkAddressSize(const char *const cip_path) {
-  OPENER_ASSERT(
-  false == GetPathPortSegementExtendedLinkAddressSizeBit(cip_path),
-                "Call to non existent extended link address size\n");
+unsigned int GetPathPortSegmentLinkAddressSize(const char *const cip_path) {
+//  OPENER_ASSERT(false == GetPathPortSegmentExtendedLinkAddressSizeBit(cip_path),
+//                "Call to non existent extended link address size\n");
+  OPENER_ASSERT(false == GetPathPortSegmentExtendedLinkAddressSizeBit(cip_path));
   return *(cip_path + 1);
 }
 
 unsigned int GetPathPortSegmentExtendedPortNumber(const char *const cip_path) {
-  OPENER_ASSERT(kPortSegmentExtendedPort == GetPathPortSegmentPortIdentifier,
-                "There is no extended port available!\n");
+//  OPENER_ASSERT(kPortSegmentExtendedPort == GetPathPortSegmentPortIdentifier(cip_path),
+//                "There is no extended port available!\n");
+  OPENER_ASSERT(kPortSegmentExtendedPort == GetPathPortSegmentPortIdentifier(cip_path));
   const unsigned int kExtendedPortSegmentPosition =
-      GetPathPortSegementExtendedLinkAddressSizeBit(cip_path) == true ? 3 : 2;
+      GetPathPortSegmentExtendedLinkAddressSizeBit(cip_path) == true ? 3 : 2;
   return cip_path[kExtendedPortSegmentPosition]
       + (cip_path[kExtendedPortSegmentPosition + 1] << 8);
 }
@@ -185,11 +190,11 @@ void SetPathPortSegmentExtendedPortIdentifier(
     const unsigned int extended_port_identifier, char *const cip_path) {
   SetPathPortSegmentPortIdentifier(kPortSegmentExtendedPort, cip_path);
   const unsigned int kExtendedPortSegmentPosition =
-      GetPathPortSegementExtendedLinkAddressSizeBit(cip_path) == true ? 3 : 2;
-  cip_path[kExtendedPortSegmentPosition] = (char*) (extended_port_identifier
+      GetPathPortSegmentExtendedLinkAddressSizeBit(cip_path) == true ? 3 : 2;
+  cip_path[kExtendedPortSegmentPosition] = (char) (extended_port_identifier
       & 0x00FF);
   cip_path[kExtendedPortSegmentPosition + 1] =
-      (char*) ((extended_port_identifier & 0xFF00) >> 8);
+      (char) ((extended_port_identifier & 0xFF00) >> 8);
 }
 /*** Port Segment ***/
 
@@ -201,28 +206,28 @@ LogicalSegmentLogicalType GetPathLogicalSegmentLogicalType(
   const unsigned int logical_type = (*cip_path) & kLogicalTypeMask;
   LogicalSegmentLogicalType result = kLogicalSegmentLogicalTypeExtendedLogical;
   switch (logical_type) {
-    case kLogicalSegmentLogicalTypeClassIdMessageValue:
+    case LOGICAL_SEGMENT_TYPE_CLASS_ID_MESSAGE_VALUE:
       result = kLogicalSegmentLogicalTypeClassId;
       break;
-    case kLogicalSegmentLogicalTypeInstanceIdMessageValue:
+    case LOGICAL_SEGMENT_TYPE_INSTANCE_ID_MESSAGE_VALUE:
       result = kLogicalSegmentLogicalTypeInstanceId;
       break;
-    case kLogicalSegmentLogicalTypeMemberIdMessageValue:
+    case LOGICAL_SEGMENT_TYPE_MEMBER_ID_MESSAGE_VALUE:
       result = kLogicalSegmentLogicalTypeMemberId;
       break;
-    case kLogicalSegmentLogicalTypeConnectionPointMessageValue:
+    case LOGICAL_SEGMENT_TYPE_CONNECTION_POINT_MESSAGE_VALUE:
       result = kLogicalSegmentLogicalTypeConnectionPoint;
       break;
-    case kLogicalSegmentLogicalTypeAttributeIdMessageValue:
+    case LOGICAL_SEGMENT_TYPE_ATTRIBUTE_ID_MESSAGE_VALUE:
       result = kLogicalSegmentLogicalTypeAttributeId;
       break;
-    case kLogicalSegmentLogicalTypeSpecialMessageValue:
+    case LOGICAL_SEGMENT_TYPE_SPECIAL_MESSAGE_VALUE:
       result = kLogicalSegmentLogicalTypeSpecial;
       break;
-    case kLogicalSegmentLogicalTypeServiceIdMessageValue:
+    case LOGICAL_SEGMENT_TYPE_SERVICE_ID_MESSAGE_VALUE:
       result = kLogicalSegmentLogicalTypeServiceId;
       break;
-    case kLogicalSegmentLogicalTypeExtendedLogicalMessageValue:
+    case LOGICAL_SEGMENT_TYPE_EXTENDED_LOGICAL_MESSAGE_VALUE:
       result = kLogicalSegmentLogicalTypeExtendedLogical;
       break;
     default:
@@ -239,13 +244,13 @@ LogicalSegmentLogicalFormat GetPathLogicalSegmentLogicalFormat(
   const unsigned int logical_format = (*cip_path) & kLogicalFormatMask;
   LogicalSegmentLogicalFormat result = kLogicalSegmentLogicalFormatEightBit;
   switch (logical_format) {
-    case kLogicalSegmentLogicalFormatEightBitMessageValue:
+    case LOGICAL_SEGMENT_FORMAT_EIGHT_BIT_MESSAGE_VALUE:
       result = kLogicalSegmentLogicalFormatEightBit;
       break;
-    case kLogicalSegmentLogicalFormatSixteenBitMessageValue:
+    case LOGICAL_SEGMENT_FORMAT_SIXTEEN_BIT_MESSAGE_VALUE:
       result = kLogicalSegmentLogicalFormatSixteenBit;
       break;
-    case kLogicalSegmentLogicalFormatThirtyTwoBitMessageValue:
+    case LOGICAL_SEGMENT_FORMAT_THIRTY_TWO_BIT_MESSAGE_VALUE:
       result = kLogicalSegmentLogicalFormatThirtyTwoBit;
       break;
     default:
@@ -257,30 +262,32 @@ LogicalSegmentLogicalFormat GetPathLogicalSegmentLogicalFormat(
 }
 
 LogicalSegmentExtendedLogicalType GetPathLogicalSegmentExtendedLogicalType(const char *const cip_path) {
-  OPENER_ASSERT(kLogicalSegmentLogicalTypeExtendedLogicalMessageValue == GetPathLogicalSegmentLogicalType(cip_path),
-                "Trying to extract non-existent extended logical type");
-  const char extended_logical_type = *(cip_path + 1);
+//  OPENER_ASSERT(LOGICAL_SEGMENT_TYPE_EXTENDED_kLogicalSegmentLogicalTypeExtendedLogicalMessageValue == GetPathLogicalSegmentLogicalType(cip_path),
+//                "Trying to extract non-existent extended logical type");
+  OPENER_ASSERT(LOGICAL_SEGMENT_TYPE_EXTENDED_LOGICAL_MESSAGE_VALUE == GetPathLogicalSegmentLogicalType(cip_path));
+  const unsigned int extended_logical_type = *(cip_path + 1);
   LogicalSegmentExtendedLogicalType result = kLogicalSegmentExtendedLogicalTypeReserved;
   switch(extended_logical_type) {
-    case kLogicalSegmentLogicalExtendedTypeArrayIndexMessageValue: result = kLogicalSegmentExtendedLogicalTypeArrayIndex; break;
-    case kLogicalSegmentLogicalExtendedTypeIndirectArrayIndexMessageValue: result = kLogicalSegmentExtendedLogicalTypeIndirectArrayIndex; break;
-    case kLogicalSegmentLogicalExtendedTypeBitIndexMessageValue: result = kLogicalSegmentExtendedLogicalTypeBitIndex; break;
-    case kLogicalSegmentLogicalExtendedTypeIndirectBitIndexMessageValue: result = kLogicalSegmentExtendedLogicalTypeIndirectBitIndex; break;
-    case kLogicalSegmentLogicalExtendedTypeStructureMemberNumberMessageValue: result = kLogicalSegmentExtendedLogicalTypeStructureMemberNumber; break;
-    case kLogicalSegmentLogicalExtendedTypeStructureMemberHandleMessageValue: result = kLogicalSegmentExtendedLogicalTypeStructureMemberHandle; break;
+    case LOGICAL_SEGMENT_EXTENDED_TYPE_ARRAY_INDEX_MESSAGE_VALUE: result = kLogicalSegmentExtendedLogicalTypeArrayIndex; break;
+    case LOGICAL_SEGMENT_EXTENDED_TYPE_INDIRECT_ARRAY_INDEX_MESSAGE_VALUE: result = kLogicalSegmentExtendedLogicalTypeIndirectArrayIndex; break;
+    case LOGICAL_SEGMENT_EXTENDED_TYPE_BIT_INDEX_MESSAGE_VALUE: result = kLogicalSegmentExtendedLogicalTypeBitIndex; break;
+    case LOGICAL_SEGMENT_EXTENDED_TYPE_INDIRECT_BIT_INDEX_MESSAGE_VALUE: result = kLogicalSegmentExtendedLogicalTypeIndirectBitIndex; break;
+    case LOGICAL_SEGMENT_EXTENDED_TYPE_STRUCTURE_MEMBER_NUMBER_MESSAGE_VALUE: result = kLogicalSegmentExtendedLogicalTypeStructureMemberNumber; break;
+    case LOGICAL_SEGMENT_EXTENDED_TYPE_STRUCTURE_MEMBER_HANDLE_MESSAGE_VALUE: result = kLogicalSegmentExtendedLogicalTypeStructureMemberHandle; break;
     default: result = kLogicalSegmentExtendedLogicalTypeReserved;
   }
   return result;
 }
 
 LogicalSegmentSpecialTypeLogicalFormat GetPathLogicalSegmentSpecialTypeLogicalType(const char *const cip_path) {
-  OPENER_ASSERT(kSegmentTypeLogicalSegment == GetPathSegementType(cip_path), "Not a logical segment!\n");
+//  OPENER_ASSERT(kSegmentTypeLogicalSegment == GetPathSegmentType(cip_path), "Not a logical segment!\n");
+  OPENER_ASSERT(kSegmentTypeLogicalSegment == GetPathSegmentType(cip_path));
   const unsigned int kLogicalFormatMask = 0x03;
   const unsigned int logical_format = (*cip_path) & kLogicalFormatMask;
 
   LogicalSegmentSpecialTypeLogicalFormat result = kLogicalSegmentSpecialTypeLogicalFormatReserved;
   switch(logical_format) {
-    case kLogicalSegmentSpecialTypeLogicalFormatElectronicKeyMessageValue:
+    case LOGICAL_SEGMENT_SPECIAL_TYPE_FORMAT_ELECTRONIC_KEY_MESSAGE_VALUE:
       result = kLogicalSegmentSpecialTypeLogicalFormatElectronicKey; break;
     default: result = kLogicalSegmentSpecialTypeLogicalFormatReserved; break;
   }
@@ -288,28 +295,32 @@ LogicalSegmentSpecialTypeLogicalFormat GetPathLogicalSegmentSpecialTypeLogicalTy
   return result;
 }
 
-ElectronicKeySegmentFormat *GetPathLogicalSegmentElectronicKeyFormat(const char *const cip_path) {
+ElectronicKeySegmentFormat GetPathLogicalSegmentElectronicKeyFormat(const char *const cip_path) {
+//  OPENER_ASSERT(kLogicalSegmentSpecialTypeLogicalFormatElectronicKey ==
+//      GetPathLogicalSegmentSpecialTypeLogicalType(cip_path), "Not an electronic key!\n");
   OPENER_ASSERT(kLogicalSegmentSpecialTypeLogicalFormatElectronicKey ==
-      GetPathLogicalSegmentSpecialTypeLogicalType(cip_path), "Not an electronic key!\n");
+        GetPathLogicalSegmentSpecialTypeLogicalType(cip_path));
   ElectronicKeySegmentFormat result = kElectronicKeySegmentFormatReserved;
   switch(*(cip_path + 1)) {
-    case kElectronicKeySegmentFormatKeyFormat4MessageValue: result = kElectronicKeySegmentFormatKeyFormat4; break;
+    case ELECTRONIC_KEY_SEGMENT_KEY_FORMAT_4_MESSAGE_VALUE: result = kElectronicKeySegmentFormatKeyFormat4; break;
     default: result = kElectronicKeySegmentFormatReserved; break;
   }
   return result;
 }
 
 ElectronicKeyFormat4 *GetPathLogicalSegmentElectronicKeyFormat4(const char *const cip_path) {
+//  OPENER_ASSERT(kElectronicKeySegmentFormatKeyFormat4 ==
+//      GetPathLogicalSegmentElectronicKeyFormat(cip_path), "Not electronic key format 4!\n");
   OPENER_ASSERT(kElectronicKeySegmentFormatKeyFormat4 ==
-      GetPathLogicalSegmentElectronicKeyFormat(cip_path), "Not electronic key format 4!\n");
+        GetPathLogicalSegmentElectronicKeyFormat(cip_path));
 
   const char *message_runner = (const char *)cip_path;
-  ElectronicKeyFormat4 *result = calloc(sizeof(ElectronicKeySegmentFormat));
+  ElectronicKeyFormat4 *result = calloc(1, sizeof(ElectronicKeySegmentFormat));
   SetElectronicKeyFormat4VendorId(GetIntFromMessage(&message_runner), result);
   SetElectronicKeyFormat4DeviceType(GetIntFromMessage(&message_runner), result);
   SetElectronicKeyFormat4ProductCode(GetIntFromMessage(&message_runner), result);
   SetElectronicKeyFormat4MajorRevisionCompatibility(GetSintFromMessage(&message_runner), result);
-  SetElectronicKeyFormat4MinorRevision(GetSIntFromMessage(&message_runner), result);
+  SetElectronicKeyFormat4MinorRevision(GetSintFromMessage(&message_runner), result);
 
   return result;
 }
@@ -329,15 +340,15 @@ NetworkSegmentSubType GetPathNetworkSegmentSubtype(const char *const cip_path) {
   const unsigned int subtype = (*cip_path) & kSubtypeMask;
   NetworkSegmentSubType result = kNetworkSegmentSubtypeReserved;
   switch(subtype) {
-    case kNetworkSegmentSubtypeScheduleSegmentMessageValue:
+    case NETWORK_SEGMENT_SUBTYPE_SCHEDULE_MESSAGE_VALUE:
       result = kNetworkSegmentSubtypeScheduleSegment; break;
-    case kNetworkSegmentSubtypeFixedTagSegmentMessageValue:
+    case NETWORK_SEGMENT_SUBTYPE_FIXED_TAG_MESSAGE_VALUE:
       result = kNetworkSegmentSubtypeFixedTagSegment; break;
-    case kNetworkSegmentSubtypeProductionInhibitTimeInMillisecondsMessageValue:
+    case NETWORK_SEGMENT_SUBTYPE_PRODUCTION_INHIBIT_TIME_IN_MILLISECONDS_MESSAGE_VALUE:
       result = kNetworkSegmentSubtypeProductionInhibitTimeInMilliseconds; break;
-    case kNetworkSegmentSubtypeSafetySegmentMessageValue:
+    case NETWORK_SEGMENT_SUBTYPE_SAFETY_MESSAGE_VALUE:
       result = kNetworkSegmentSubtypeSafetySegment; break;
-    case kNetworkSegmentSubtypeProductionInhibitTimeInMicrosecondsMessageValue:
+    case NETWORK_SEGMENT_SUBTYPE_PRODUCTION_INHIBIT_TIME_IN_MICROSECONDS_MESSAGE_VALUE:
       result = kNetworkSegmentSubtypeProductionInhibitTimeInMicroseconds; break;
     default: result = kNetworkSegmentSubtypeReserved; break;
   }
@@ -352,9 +363,11 @@ NetworkSegmentSubType GetPathNetworkSegmentSubtype(const char *const cip_path) {
  * @return the Production Inhibit Time in milliseconds ranging from 0 to 255
  */
 CipUsint GetPathNetworkSegmentProductionInhibitTimeInMilliseconds(const char *const cip_path) {
-  OPENER_ASSERT(kSegmentTypeNetworkSegment == GetPathSegementType(cip_path),"Not a network segment!\n");
-  OPENER_ASSERT(kNetworkSegmentSubtypeProductionInhibitTimeInMilliseconds == GetPathNetworkSegmentSubtype(cip_path),
-                "Not a Production Inhibit Time milliseconds segment!\n");
+//  OPENER_ASSERT(kSegmentTypeNetworkSegment == GetPathSegmentType(cip_path),"Not a network segment!\n");
+//  OPENER_ASSERT(kNetworkSegmentSubtypeProductionInhibitTimeInMilliseconds == GetPathNetworkSegmentSubtype(cip_path),
+//                "Not a Production Inhibit Time milliseconds segment!\n");
+  OPENER_ASSERT(kSegmentTypeNetworkSegment == GetPathSegmentType(cip_path));
+  OPENER_ASSERT(kNetworkSegmentSubtypeProductionInhibitTimeInMilliseconds == GetPathNetworkSegmentSubtype(cip_path));
   return *(cip_path + 1);
 }
 
@@ -365,10 +378,15 @@ CipUsint GetPathNetworkSegmentProductionInhibitTimeInMilliseconds(const char *co
  * @return the Production Inhibit Time in microseconds ranging from 0 to 4294967295
  */
 CipUdint GetPathNetworkSegmentProductionInhibitTimeInMicroseconds(const char *const cip_path) {
-  OPENER_ASSERT(kSegmentTypeNetworkSegment == GetPathSegementType(cip_path),"Not a network segment!\n");
-  OPENER_ASSERT(kNetworkSegmentSubtypeProductionInhibitTimeInMicroseconds == GetPathNetworkSegmentSubtype(cip_path),
-                  "Not a Production Inhibit Time microseconds segment!\n");
-  OPENER_ASSERT(2 == *(cip_path + 1), "Data Words length is incorrect! See CIP Spec Vol.1 C-1.4.3.3.2\n");
+//  OPENER_ASSERT(kSegmentTypeNetworkSegment == GetPathSegmentType(cip_path),"Not a network segment!\n");
+//  OPENER_ASSERT(kNetworkSegmentSubtypeProductionInhibitTimeInMicroseconds == GetPathNetworkSegmentSubtype(cip_path),
+//                  "Not a Production Inhibit Time microseconds segment!\n");
+//  OPENER_ASSERT(2 == *(cip_path + 1), "Data Words length is incorrect! See CIP Spec Vol.1 C-1.4.3.3.2\n");
+
+  OPENER_ASSERT(kSegmentTypeNetworkSegment == GetPathSegmentType(cip_path));
+  OPENER_ASSERT(kNetworkSegmentSubtypeProductionInhibitTimeInMicroseconds == GetPathNetworkSegmentSubtype(cip_path));
+  OPENER_ASSERT(2 == *(cip_path + 1));
+
   const char *message_runner = cip_path;
   return GetDintFromMessage(&message_runner);
 }
@@ -389,9 +407,9 @@ DataSegmentSubtype GetPathDataSegmentSubtype(const char *const cip_path) {
 
   DataSegmentSubtype result = kDataSegmentSubtypeReserved;
   switch(data_subtype) {
-    case kDataSegmentSubtypeSimpleDataMessageValue:
+    case DATA_SEGMENT_SUBTYPE_SIMPLE_DATA_MESSAGE_VALUE:
       result = kDataSegmentSubtypeSimpleData; break;
-    case kDataSegmentSubtypeANSIExtendedSymbolMessageValue:
+    case DATA_SEGMENT_SUBTYPE_ANSI_EXTENDED_SYMBOL_MESSAGE_VALUE:
       result = kDataSegmentSubtypeANSIExtendedSymbol; break;
     default: result = kDataSegmentSubtypeReserved; break;
   }
@@ -403,9 +421,12 @@ DataSegmentSubtype GetPathDataSegmentSubtype(const char *const cip_path) {
  * @param cip_path Pointer to the start of the EPath message
  * @return The amount of 16-bit words of data in the EPath
  */
-CipUsint GetPathDataSegmentSimpleDataWordLength(const char *const cip_path) {
-  OPENER_ASSERT(kSegmentTypeDataSegment == GetPathSegementType(cip_path),"Not a data segment!\n");
-  OPENER_ASSERT(kDataSegmentSubtypeSimpleData == GetPathDataSegmentSubtype(cip_path), "Not a simple data segment!\n");
+CipUsint GetPathDataSegmentSimpleDataWordLength(const char * const cip_path) {
+//  OPENER_ASSERT(kSegmentTypeDataSegment == GetPathSegmentType(cip_path),"Not a data segment!\n");
+//  OPENER_ASSERT(kDataSegmentSubtypeSimpleData == GetPathDataSegmentSubtype(cip_path), "Not a simple data segment!\n");
+  OPENER_ASSERT(kSegmentTypeDataSegment == GetPathSegmentType(cip_path));
+  OPENER_ASSERT(
+      kDataSegmentSubtypeSimpleData == GetPathDataSegmentSubtype(cip_path));
 
   const char *message_runner = cip_path;
   return GetSintFromMessage(&message_runner);

source/src/cip/cipepath.h

@@ -11,7 +11,46 @@
 
 #include "ciptypes.h"
 
-typedef enum {
+#define SEGMENT_TYPE_PORT_SEGMENT_MESSAGE_VALUE 0x00 /**< Message value of the Port segment */
+#define SEGMENT_TYPE_LOGICAL_SEGMENT_MESSAGE_VALUE 0x20 /**< Message value of the Logical segment */
+#define SEGMENT_TYPE_NETWORK_SEGMENT_MESSAGE_VALUE 0x40 /**< Message value of the Network segment */
+#define SEGMENT_TYPE_SYMBOLIC_SEGMENT_MESSAGE_VALUE 0x60 /**< Message value of the Symbolic segment */
+#define SEGMENT_TYPE_DATA_SEGMENT_MESSAGE_VALUE 0x80 /**< Message value of the Data segment */
+#define SEGMENT_TYPE_DATA_TYPE_CONSTRUCTED_MESSAGE_VALUE 0xA0 /**< Message value of the Data type constructed */
+#define SEGMENT_TYPE_DATA_TYPE_ELEMENTARTY_MESSAGE_VALUE 0xC0 /**< Message value of the Data type elementary */
+#define SEGMENT_TYPE_SEGMENT_RESERVED_MESSAGE_VALUE 0xE0 /**< Reserved value */
+
+#define LOGICAL_SEGMENT_TYPE_CLASS_ID_MESSAGE_VALUE 0x00 /**< Message value of the logical segment/logical type Class ID */
+#define LOGICAL_SEGMENT_TYPE_INSTANCE_ID_MESSAGE_VALUE 0x04 /**< Message value of the logical segment/logical type Instance ID */
+#define LOGICAL_SEGMENT_TYPE_MEMBER_ID_MESSAGE_VALUE 0x08 /**< Message value of the logical segment/logical type Member ID */
+#define LOGICAL_SEGMENT_TYPE_CONNECTION_POINT_MESSAGE_VALUE 0x0C /**< Message value of the logical segment/logical type Connection Point */
+#define LOGICAL_SEGMENT_TYPE_ATTRIBUTE_ID_MESSAGE_VALUE 0x10 /**< Message value of the logical segment/logical type Attribute ID */
+#define LOGICAL_SEGMENT_TYPE_SPECIAL_MESSAGE_VALUE 0x14 /**< Message value of the logical segment/logical type Special */
+#define LOGICAL_SEGMENT_TYPE_SERVICE_ID_MESSAGE_VALUE 0x18 /**< Message value of the logical segment/logical type Service ID */
+#define LOGICAL_SEGMENT_TYPE_EXTENDED_LOGICAL_MESSAGE_VALUE 0x1C /**< Message value of the logical segment/logical type Extended Logical */
+
+#define LOGICAL_SEGMENT_FORMAT_EIGHT_BIT_MESSAGE_VALUE 0x00
+#define LOGICAL_SEGMENT_FORMAT_SIXTEEN_BIT_MESSAGE_VALUE 0x01
+#define LOGICAL_SEGMENT_FORMAT_THIRTY_TWO_BIT_MESSAGE_VALUE 0x02
+
+#define LOGICAL_SEGMENT_EXTENDED_TYPE_RESERVED_MESSAGE_VALUE 0x00
+#define LOGICAL_SEGMENT_EXTENDED_TYPE_ARRAY_INDEX_MESSAGE_VALUE 0x01
+#define LOGICAL_SEGMENT_EXTENDED_TYPE_INDIRECT_ARRAY_INDEX_MESSAGE_VALUE 0x02
+#define LOGICAL_SEGMENT_EXTENDED_TYPE_BIT_INDEX_MESSAGE_VALUE 0x03
+#define LOGICAL_SEGMENT_EXTENDED_TYPE_INDIRECT_BIT_INDEX_MESSAGE_VALUE 0x04
+#define LOGICAL_SEGMENT_EXTENDED_TYPE_STRUCTURE_MEMBER_NUMBER_MESSAGE_VALUE 0x05
+#define LOGICAL_SEGMENT_EXTENDED_TYPE_STRUCTURE_MEMBER_HANDLE_MESSAGE_VALUE 0x06
+
+#define LOGICAL_SEGMENT_SPECIAL_TYPE_FORMAT_ELECTRONIC_KEY_MESSAGE_VALUE 0x00
+
+#define NETWORK_SEGMENT_SUBTYPE_SCHEDULE_MESSAGE_VALUE 0x01
+#define NETWORK_SEGMENT_SUBTYPE_FIXED_TAG_MESSAGE_VALUE 0x02
+#define NETWORK_SEGMENT_SUBTYPE_PRODUCTION_INHIBIT_TIME_IN_MILLISECONDS_MESSAGE_VALUE 0x03
+#define NETWORK_SEGMENT_SUBTYPE_SAFETY_MESSAGE_VALUE 0x04
+#define NETWORK_SEGMENT_SUBTYPE_PRODUCTION_INHIBIT_TIME_IN_MICROSECONDS_MESSAGE_VALUE 0x10
+#define NETWORK_SEGMENT_SUBTYPE_EXTENDED_NETWORK_MESSAGE_VALUE 0x1F
+
+typedef enum network_segment_subtype {
   kNetworkSegmentSubtypeReserved,
   kNetworkSegmentSubtypeScheduleSegment,
   kNetworkSegmentSubtypeFixedTagSegment,

source/src/enet_encap/encap.c

@@ -5,6 +5,7 @@
  ******************************************************************************/
 #include <string.h>
 #include <stdlib.h>
+#include <stdbool.h>
 
 #include "encap.h"
 

source/src/ports/POSIX/sample_application/sampleapplication.c

@@ -4,9 +4,11 @@
  *
  ******************************************************************************/
 
-#include "opener_api.h"
 #include <string.h>
 #include <stdlib.h>
+#include <stdbool.h>
+
+#include "opener_api.h"
 
 #define DEMO_APP_INPUT_ASSEMBLY_NUM                100 //0x064
 #define DEMO_APP_OUTPUT_ASSEMBLY_NUM               150 //0x096

source/src/ports/generic_networkhandler.c

@@ -12,6 +12,7 @@
  */
 
 #include <assert.h>
+#include <stdbool.h>
 
 #include "generic_networkhandler.h"
 

source/src/typedefs.h

@@ -108,10 +108,10 @@ typedef enum {
 #ifndef __cplusplus
 /** @brief If we don't have C++ define a C++ -like "bool" keyword defines
  */
-typedef enum {
-  false = 0, /**< defines "false" as 0 */
-  true = 1 /**< defines "true" as 1 */
-} BoolKeywords;
+//typedef enum {
+//  false = 0, /**< defines "false" as 0 */
+//  true = 1 /**< defines "true" as 1 */
+//} BoolKeywords;
 #endif /* __cplusplus */
 
 #endif /* OPENER_TYPEDEFS_H_ */

source/tests/CMakeLists.txt

@@ -13,7 +13,7 @@ add_test_includes()
 ###################################################
 configure_file( CTestCustom.cmake ${PROJECT_BINARY_DIR}/CTestCustom.cmake )
 
-#add_subdirectory( cip )
+add_subdirectory( cip )
 add_subdirectory( utils )
 add_subdirectory( enet_encap )
 add_executable( OpENer_Tests OpENerTests.cpp )
@@ -24,6 +24,7 @@ find_library ( CPPUTESTEXT_LIBRARY CppUTestExt ${CPPUTEST_HOME}/cpputest_build/l
 target_link_libraries( OpENer_Tests gcov ${CPPUTEST_LIBRARY} ${CPPUTESTEXT_LIBRARY} )
 target_link_libraries( OpENer_Tests UtilsTest Utils ) 
 target_link_libraries( OpENer_Tests EthernetEncapsulationTest ENET_ENCAP )
+target_link_libraries( OpENer_Tests CipTest CIP )
 
 ########################################
 # Adds test to CTest environment       #

source/tests/OpENerTests.h

@@ -3,3 +3,4 @@
 IMPORT_TEST_GROUP(RandomClass);
 IMPORT_TEST_GROUP(XorShiftRandom);
 IMPORT_TEST_GROUP(EndianConversion);
+IMPORT_TEST_GROUP(CipEpath);

source/tests/cip/CMakeLists.txt

@@ -1,7 +1,7 @@
 
 opener_common_includes()
 
-set( CipTestSrc connectionmanagertest.cpp cipepathtest.cpp )
+set( CipTestSrc cipepathtest.cpp )
 
 include_directories( ${SRC_DIR}/cip )
 

source/tests/cip/cipepathtest.cpp

@@ -21,49 +21,49 @@ TEST_GROUP(CipEpath) {
 /** Segment type tests **/
 TEST(CipEpath, GetSegmentTypePortSegment) {
   const char message[] = {0x00};
-  NetworkSegmentSubtype segment_type = GetPathSegmentType(message);
+  SegmentType segment_type = GetPathSegmentType(message);
   CHECK_EQUAL(kSegmentTypePortSegment, segment_type);
 }
 
 TEST(CipEpath, GetSegmentTypeLogicalSegment) {
   const char message[] = {0x20};
-  NetworkSegmentSubtype segment_type = GetPathSegmentType(message);
+  SegmentType segment_type = GetPathSegmentType(message);
   CHECK_EQUAL(kSegmentTypeLogicalSegment, segment_type);
 }
 
 TEST(CipEpath, GetSegmentTypeNetworkSegment) {
   const char message[] = {0x40};
-  NetworkSegmentSubtype segment_type = GetPathSegmentType(message);
+  SegmentType segment_type = GetPathSegmentType(message);
   CHECK_EQUAL(kSegmentTypeNetworkSegment, segment_type);
 }
 
 TEST(CipEpath, GetSegmentTypeSymbolicSegment) {
   const char message[] = {0x60};
-  NetworkSegmentSubtype segment_type = GetPathSegmentType(message);
+  SegmentType segment_type = GetPathSegmentType(message);
   CHECK_EQUAL(kSegmentTypeSymbolicSegment, segment_type);
 }
 
 TEST(CipEpath, GetSegmentTypeDataSegment) {
   const char message[] = {0x80};
-  NetworkSegmentSubtype segment_type = GetPathSegmentType(message);
+  SegmentType segment_type = GetPathSegmentType(message);
   CHECK_EQUAL(kSegmentTypeDataSegment, segment_type);
 }
 
 TEST(CipEpath, GetSegmentTypeDataTypeConstructed) {
   const char message[] = {0xA0};
-  NetworkSegmentSubtype segment_type = GetPathSegmentType(message);
+  SegmentType segment_type = GetPathSegmentType(message);
   CHECK_EQUAL(kSegmentTypeDataTypeConstructed, segment_type);
 }
 
 TEST(CipEpath, GetSegmentTypeDataTypeElementary) {
   const char message[] = {0xC0};
-  NetworkSegmentSubtype segment_type = GetPathSegmentType(message);
+  SegmentType segment_type = GetPathSegmentType(message);
   CHECK_EQUAL(kSegmentTypeDataTypeElementary, segment_type);
 }
 
 TEST(CipEpath, GetSegmentTypeReserved) {
-  const char message[] = {0xC0};
-  NetworkSegmentSubtype segment_type = GetPathSegmentType(message);
+  const char message[] = {0xE0};
+  SegmentType segment_type = GetPathSegmentType(message);
   CHECK_EQUAL(kSegmentTypeReserved, segment_type);
 }
 

source/tests/enet_encap/endianconvtest.cpp

@@ -16,6 +16,7 @@ extern "C" {
 #include "endianconv.h"
 
 #include "ciptypes.h"
+
 }
 
 TEST_GROUP(EndianConversion) {