Bug fix (missing pointer shift) + code cleanup

Signed-off-by: Martin Melik Merkumians <melik-merkumians@acin.tuwien.ac.at>

source/src/cip/cipassembly.c

@@ -117,14 +117,14 @@ CipInstance *CreateAssemblyObject(const EipUint32 instance_id,
 
   assembly_byte_array->length = data_length;
   assembly_byte_array->data = data;
-  InsertAttribute2(instance,
+  InsertAttribute(instance,
                   3,
                   kCipByteArray,
 				  EncodeCipByteArray,
                   assembly_byte_array,
                   kSetAndGetAble | kPreGetFunc | kPostSetFunc);
   /* Attribute 4 Number of bytes in Attribute 3 */
-  InsertAttribute2(instance,
+  InsertAttribute(instance,
                   4,
                   kCipUint,
 				  EncodeCipUint,

source/src/cip/cipcommon.c

@@ -23,7 +23,7 @@
   #include "cipdlr.h"
 #endif
 
-//#include "../cip_objects/CIPFileObject/cipfile.h"
+#include "../cip_objects/CIPFileObject/cipfile.h"
 
 #include "cipqos.h"
 #include "cpf.h"
@@ -32,9 +32,6 @@
 #include "cipepath.h"
 #include "stdlib.h"
 
-/* global public variables */
-//EipUint8 g_message_data_reply_buffer[OPENER_MESSAGE_DATA_REPLY_BUFFER]; /**< Reply buffer */
-//TODO: Delete
 /* private functions*/
 void EncodeEPath(CipEpath *epath,
                 ENIPMessage *message);
@@ -59,8 +56,8 @@ void CipStackInit(const EipUint16 unique_connection_id) {
 #endif
   eip_status = CipQoSInit();
   OPENER_ASSERT(kEipStatusOk == eip_status)
-//  eip_status = CipFileInit();
-//  OPENER_ASSERT(kEipStatusOk == eip_status)
+  eip_status = CipFileInit();
+  OPENER_ASSERT(kEipStatusOk == eip_status)
   /* the application has to be initialized at last */
   eip_status = ApplicationInitialization();
   OPENER_ASSERT(kEipStatusOk == eip_status)
@@ -291,27 +288,27 @@ CipClass *CreateCipClass(const CipUdint class_code,
   AllocateAttributeMasks(cip_class);  /* Allocation of bitmasks for Instance Attributes */
 
   if (NULL == initializer) {
-    InsertAttribute2( (CipInstance *) cip_class, 1, kCipUint, EncodeCipUint,
+    InsertAttribute( (CipInstance *) cip_class, 1, kCipUint, EncodeCipUint,
                      (void *) &cip_class->revision, kGetableSingleAndAll ); /* revision */
-    InsertAttribute2( (CipInstance *) cip_class, 2, kCipUint, EncodeCipUint,
+    InsertAttribute( (CipInstance *) cip_class, 2, kCipUint, EncodeCipUint,
                      (void *) &cip_class->number_of_instances,
-                     kGetableSingleAndAll );                        /*  largest instance number */
-    InsertAttribute2( (CipInstance *) cip_class, 3, kCipUint, EncodeCipUint,
+                     kGetableSingleAndAll );                        /* #2 Max instance no. */
+    InsertAttribute( (CipInstance *) cip_class, 3, kCipUint, EncodeCipUint,
                      (void *) &cip_class->number_of_instances,
                      kGetableSingleAndAll );                        /* number of instances currently existing*/
-    InsertAttribute2( (CipInstance *) cip_class, 4, kCipUint, EncodeCipUint,
+    InsertAttribute( (CipInstance *) cip_class, 4, kCipUint, EncodeCipUint,
                      (void *) &kCipUintZero, kGetableAll );         /* optional attribute list - default = 0 */
-    InsertAttribute2( (CipInstance *) cip_class, 5, kCipUint, EncodeCipUint,
+    InsertAttribute( (CipInstance *) cip_class, 5, kCipUint, EncodeCipUint,
                      (void *) &kCipUintZero, kNotSetOrGetable );    /* optional service list - default = 0 */
-    InsertAttribute2( (CipInstance *) cip_class, 6, kCipUint, EncodeCipUint,
+    InsertAttribute( (CipInstance *) cip_class, 6, kCipUint, EncodeCipUint,
                      (void *) &meta_class->highest_attribute_number,
                      kGetableSingle );                              /* max class attribute number*/
-    InsertAttribute2( (CipInstance *) cip_class, 7, kCipUint, EncodeCipUint,
+    InsertAttribute( (CipInstance *) cip_class, 7, kCipUint, EncodeCipUint,
                      (void *) &cip_class->highest_attribute_number,
                      kGetableSingle );                              /* max instance attribute number*/
 	  if (number_of_class_services > 0) {
 		if (number_of_class_services > 1) {             /*only if the mask has values add the get_attribute_all service */
-		  InsertService(meta_class, kGetAttributeAll, &GetAttributeAll2,
+		  InsertService(meta_class, kGetAttributeAll, &GetAttributeAll,
 						"GetAttributeAll");                     /* bind instance services to the metaclass*/
 		}
 		InsertService(meta_class, kGetAttributeSingle, &GetAttributeSingle,
@@ -326,54 +323,14 @@ CipClass *CreateCipClass(const CipUdint class_code,
 }
 
 void InsertAttribute(CipInstance *const instance,
-                     const EipUint16 attribute_number,
-                     const EipUint8 cip_type,
-                     void *const data,
-                     const EipByte cip_flags) {
-
-  CipAttributeStruct *attribute = instance->attributes;
-  CipClass *cip_class = instance->cip_class;
-
-  OPENER_ASSERT(NULL != attribute)
-  /* adding a attribute to a class that was not declared to have any attributes is not allowed */
-  for (int i = 0; i < instance->cip_class->number_of_attributes; i++) {
-    if (attribute->data == NULL) {             /* found non set attribute */
-      attribute->attribute_number = attribute_number;
-      attribute->type = cip_type;
-      attribute->encode = NULL;
-      attribute->attribute_flags = cip_flags;
-      attribute->data = data;
-
-      OPENER_ASSERT(attribute_number <= cip_class->highest_attribute_number)
-
-      size_t index = CalculateIndex(attribute_number);
-
-      cip_class->get_single_bit_mask[index] |=
-        (cip_flags & kGetableSingle) ?
-        1 << (attribute_number) % 8 : 0;
-      cip_class->get_all_bit_mask[index] |=
-        (cip_flags & kGetableAll) ? 1 << (attribute_number) % 8 : 0;
-      cip_class->set_bit_mask[index] |=
-        ( (cip_flags & kSetable) ? 1 : 0 ) << ( (attribute_number) % 8 );
-
-      return;
-    }
-    attribute++;
-  }
-  OPENER_TRACE_ERR(
-    "Tried to insert too many attributes into class: %" PRIu32 " '%s', instance %" PRIu32 "\n",
-    cip_class->class_code, cip_class->class_name, instance->instance_number);
-  OPENER_ASSERT(0)
-  /* trying to insert too many attributes*/
-}
-
-void InsertAttribute2(CipInstance *const instance,
                      const EipUint16 attribute_number,
                      const EipUint8 cip_type,
 					 CipAttributeEncodeInMessage encode_function,
                      void *const data,
                      const EipByte cip_flags) {
 
+  OPENER_ASSERT(NULL != data); /* Its not allowed to push a NULL pointer, as this marks an unused attribute struct */
+
   CipAttributeStruct *attribute = instance->attributes;
   CipClass *cip_class = instance->cip_class;
 
@@ -529,6 +486,22 @@ void EncodeCipBool(const void *const data, ENIPMessage *const outgoing_message)
   AddSintToMessage(*(EipUint8 *) (data), outgoing_message);
 }
 
+void EncodeCipByte(const void *const data, ENIPMessage *const outgoing_message) {
+  AddSintToMessage(*(EipUint8 *) (data), outgoing_message);
+}
+
+void EncodeCipWord(const void *const data, ENIPMessage *const outgoing_message) {
+  AddIntToMessage(*(EipUint16 *) (data), outgoing_message);
+}
+
+void EncodeCipDword(const void *const data, ENIPMessage *const outgoing_message) {
+  AddDintToMessage(*(EipUint32 *) (data), outgoing_message);
+}
+
+void EncodeCipLword(const void *const data, ENIPMessage *const outgoing_message) {
+  AddLintToMessage(*(EipUint64 *) (data), outgoing_message);
+}
+
 void EncodeCipUsint(const void *const data, ENIPMessage *const outgoing_message) {
   AddSintToMessage(*(EipUint8 *) (data), outgoing_message);
 }
@@ -541,14 +514,35 @@ void EncodeCipUdint(const void *const data, ENIPMessage *const outgoing_message)
   AddDintToMessage(*(EipUint32 *) (data), outgoing_message);
 }
 
-void EncodeCipWord(const void *const data, ENIPMessage *const outgoing_message) {
+void EncodeCipUlint(const void *const data, ENIPMessage *const outgoing_message) {
+  AddLintToMessage(*(EipUint64 *) (data), outgoing_message);
+}
+
+void EncodeCipSint(const void *const data, ENIPMessage *const outgoing_message) {
+  AddSintToMessage(*(EipUint8 *) (data), outgoing_message);
+}
+
+void EncodeCipInt(const void *const data, ENIPMessage *const outgoing_message) {
   AddIntToMessage(*(EipUint16 *) (data), outgoing_message);
 }
 
-void EncodeCipDword(const void *const data, ENIPMessage *const outgoing_message) {
+void EncodeCipDint(const void *const data, ENIPMessage *const outgoing_message) {
   AddDintToMessage(*(EipUint32 *) (data), outgoing_message);
 }
 
+void EncodeCipLint(const void *const data, ENIPMessage *const outgoing_message) {
+  AddLintToMessage(*(EipUint64 *) (data), outgoing_message);
+}
+
+void EncodeCipReal(const void *const data, ENIPMessage *const outgoing_message) {
+  AddDintToMessage(*(EipUint32 *) (data), outgoing_message);
+}
+
+void EncodeCipLreal(const void *const data, ENIPMessage *const outgoing_message) {
+  AddLintToMessage(*(EipUint64 *) (data), outgoing_message);
+}
+
+
 void EncodeCipShortString(const void *const data, ENIPMessage *const outgoing_message) {
   CipShortString *const short_string = (CipShortString *) data;
 
@@ -575,6 +569,13 @@ void EncodeCipString(const void *const data, ENIPMessage *const outgoing_message
     }
 }
 
+void EncodeCipString2(const void *const data, ENIPMessage *const outgoing_message) {
+  OPENER_ASSERT(false); /* Not implemented yet */
+}
+
+void EncodeCipStringN(const void *const data, ENIPMessage *const outgoing_message) {
+  OPENER_ASSERT(false); /* Not implemented yet */
+}
 
 void EncodeCipByteArray(const void *const data, ENIPMessage *const outgoing_message) {
     OPENER_TRACE_INFO(" -> get attribute byte array\r\n");
@@ -588,148 +589,11 @@ void EncodeCipEPath(const void *const data, ENIPMessage *const outgoing_message)
 	EncodeEPath( (CipEpath *) data, outgoing_message );
 }
 
-void EncodeData(const EipUint8 cip_type,
-               const void *const cip_data,
-			   CipMessageRouterResponse *const message_router_response) {
-
-  switch (cip_type)
-  /* check the data type of attribute */
-  {
-    case (kCipBool):
-    case (kCipSint):
-    case (kCipUsint):
-    case (kCipByte):
-	  AddSintToMessage(*(EipUint8 *) (cip_data), &message_router_response->message);
-      break;
-
-    case (kCipInt):
-    case (kCipUint):
-    case (kCipWord):
-      AddIntToMessage(*(EipUint16 *) (cip_data), &message_router_response->message);
-      break;
-
-    case (kCipDint):
-    case (kCipUdint):
-    case (kCipDword):
-    case (kCipReal):
-      AddDintToMessage(*(EipUint32 *) (cip_data), &message_router_response->message);
-      break;
-
-#ifdef OPENER_SUPPORT_64BIT_DATATYPES
-    case (kCipLint):
-    case (kCipUlint):
-    case (kCipLword):
-    case (kCipLreal):
-      AddLintToMessage(*(EipUint64 *) (cip_data), &message_router_response->message);
-      break;
-#endif
-
-    case (kCipStime):
-    case (kCipDate):
-    case (kCipTimeOfDay):
-    case (kCipDateAndTime):
-      break;
-    case (kCipString): {
-      CipString *const string = (CipString *) cip_data;
-
-      AddIntToMessage(*(EipUint16 *) &(string->length), &message_router_response->message);
-      memcpy(message_router_response->message.current_message_position, string->string, string->length);
-      message_router_response->message.current_message_position += string->length;
-      message_router_response->message.used_message_length += string->length;
-
-      if (message_router_response->message.used_message_length & 0x01) {
-        /* we have an odd byte count */
-    	  AddSintToMessage(0, &message_router_response->message);
-      }
-      break;
-    }
-    case (kCipString2):
-    case (kCipFtime):
-    case (kCipLtime):
-    case (kCipItime):
-    case (kCipStringN):
-      break;
-
-    case (kCipShortString): {
-      CipShortString *const short_string = (CipShortString *) cip_data;
-
-      AddSintToMessage(short_string->length, &message_router_response->message);
-
-      memcpy(message_router_response->message.current_message_position, short_string->string, short_string->length);
-      message_router_response->message.current_message_position += short_string->length;
-      message_router_response->message.used_message_length += short_string->length;
-      break;
-    }
-
-    case (kCipTime):
-      break;
-
-    case (kCipEpath):
-      EncodeEPath( (CipEpath *) cip_data, &message_router_response->message );
-      break;
-
-    case (kCipEngUnit):
-      break;
-
-    case (kCipUsintUsint): {
-      CipRevision *revision = (CipRevision *) cip_data;
-
-      AddSintToMessage(revision->major_revision, &message_router_response->message);
-      AddSintToMessage(revision->minor_revision, &message_router_response->message);
-
-      break;
-    }
-
-    case (kCipUdintUdintUdintUdintUdintString): {
-      /* TCP/IP attribute 5 */
-      CipTcpIpInterfaceConfiguration *
-        tcp_ip_network_interface_configuration =
-        (CipTcpIpInterfaceConfiguration *) cip_data;
-      AddDintToMessage(ntohl(tcp_ip_network_interface_configuration->ip_address), &message_router_response->message);
-      AddDintToMessage(ntohl(tcp_ip_network_interface_configuration->network_mask), &message_router_response->message);
-      AddDintToMessage(ntohl(tcp_ip_network_interface_configuration->gateway), &message_router_response->message);
-      AddDintToMessage(ntohl(tcp_ip_network_interface_configuration->name_server), &message_router_response->message);
-      AddDintToMessage(ntohl(tcp_ip_network_interface_configuration->name_server_2),&message_router_response->message);
-      EncodeData(kCipString, &(tcp_ip_network_interface_configuration->domain_name), message_router_response);
-      break;
-    }
-
-    case (kCip6Usint): {
-      EipUint8 *p = (EipUint8 *) cip_data;
-      memcpy(&message_router_response->message.current_message_position, p, 6);
-      message_router_response->message.current_message_position += 6;
-      message_router_response->message.used_message_length += 6;
-      break;
-    }
-
-    case (kCipMemberList):
-      break;
-
-    case (kCipByteArray): {
-      OPENER_TRACE_INFO(" -> get attribute byte array\r\n");
-      CipByteArray *cip_byte_array = (CipByteArray *) cip_data;
-      memcpy(&message_router_response->message.current_message_position, cip_byte_array->data, cip_byte_array->length);
-      message_router_response->message.current_message_position += cip_byte_array->length;
-      message_router_response->message.used_message_length += cip_byte_array->length;
-    }
-    break;
-
-    case (kInternalUint6):     /* TODO for port class attribute 9, hopefully we can find a better way to do this*/
-    {
-      EipUint16 *internal_unit16_6 = (EipUint16 *) cip_data;
-
-      AddIntToMessage(internal_unit16_6[0], &message_router_response->message);
-      AddIntToMessage(internal_unit16_6[1], &message_router_response->message);
-      AddIntToMessage(internal_unit16_6[2], &message_router_response->message);
-      AddIntToMessage(internal_unit16_6[3], &message_router_response->message);
-      AddIntToMessage(internal_unit16_6[4], &message_router_response->message);
-      AddIntToMessage(internal_unit16_6[5], &message_router_response->message);
-      break;
-    }
-    default:
-      break;
-
-  }
+void EncodeCipEthernetLinkPhyisicalAddress(const void *const data, ENIPMessage *const outgoing_message) {
+    EipUint8 *p = (EipUint8 *) data;
+    memcpy(outgoing_message->current_message_position, p, 6);
+    outgoing_message->current_message_position += 6;
+    outgoing_message->used_message_length += 6;
 }
 
 int DecodeData(const EipUint8 cip_data_type,
@@ -821,7 +685,7 @@ CipServiceStruct *GetCipService(const CipInstance *const instance,
   return NULL; /* didn't find the service */
 }
 
-EipStatus GetAttributeAll2(CipInstance *instance,
+EipStatus GetAttributeAll(CipInstance *instance,
                           CipMessageRouterRequest *message_router_request,
                           CipMessageRouterResponse *message_router_response,
                           const struct sockaddr *originator_address,
@@ -847,7 +711,7 @@ EipStatus GetAttributeAll2(CipInstance *instance,
       if ( (instance->cip_class->get_all_bit_mask[CalculateIndex(
                                                     attribute_number)]) &
            (1 << (attribute_number % 8) ) ) {
-        /* only return attributes that are flagged as being part of GetAttributeALl */
+        /* only return attributes that are flagged as being part of GetAttributeAll */
         message_router_request->request_path.attribute_number =
           attribute_number;
 
@@ -859,53 +723,6 @@ EipStatus GetAttributeAll2(CipInstance *instance,
   return kEipStatusOkSend;
 }
 
-EipStatus GetAttributeAll(CipInstance *instance,
-                          CipMessageRouterRequest *message_router_request,
-                          CipMessageRouterResponse *message_router_response,
-                          const struct sockaddr *originator_address,
-                          const int encapsulation_session) {
-
-  InitializeENIPMessage(&message_router_response->message);
-  CipAttributeStruct *attribute = instance->attributes;       /* pointer to list of attributes*/
-  CipServiceStruct *service = GetCipService(instance, kGetAttributeSingle);       /* pointer to list of services*/
-
-  if(NULL == service) {
-    /* GetAttributeAll service not found */
-    /* Return kEipStatusOk if cannot find GET_ATTRIBUTE_SINGLE service*/
-    return kEipStatusOk;
-  }
-
-  if (0 == instance->cip_class->number_of_attributes) {
-    /*there are no attributes to be sent back*/
-    message_router_response->reply_service =
-      (0x80 | message_router_request->service);
-    message_router_response->general_status = kCipErrorServiceNotSupported;
-    message_router_response->size_of_additional_status = 0;
-  } else {
-    for (size_t j = 0; j < instance->cip_class->number_of_attributes; j++) {
-      /* for each instance attribute of this class */
-      int attribute_number = attribute->attribute_number;
-      if ( (instance->cip_class->get_all_bit_mask[CalculateIndex(
-                                                    attribute_number)]) &
-           (1 << (attribute_number % 8) ) ) {
-        /* only return attributes that are flagged as being part of GetAttributeALl */
-        message_router_request->request_path.attribute_number =
-          attribute_number;
-        if (kEipStatusOkSend !=
-            service->service_function(instance,
-            		                  message_router_request,
-                                      message_router_response,
-                                      originator_address,
-                                      encapsulation_session) ) {
-          return kEipStatusError;
-        }
-      }
-      attribute++;
-    }
-  }
-  return kEipStatusOkSend;
-}
-
 void EncodeEPath(CipEpath *epath,
                 ENIPMessage *message) {
   unsigned int length = epath->path_size;
@@ -1047,138 +864,3 @@ size_t CalculateIndex(EipUint16 attribute_number) {
   size_t index = attribute_number / 8;
   return index;
 }
-
-size_t GetSizeOfAttribute(const CipAttributeStruct *const attribute_struct) {
-  size_t data_type_size = 0;
-  switch (attribute_struct->type) {
-    case (kCipBool):
-      data_type_size = sizeof(CipBool);
-      break;
-    case (kCipSint):
-      data_type_size = sizeof(CipSint);
-      break;
-    case (kCipInt):
-      data_type_size = sizeof(CipInt);
-      break;
-    case (kCipDint):
-      data_type_size = sizeof(CipDint);
-      break;
-    case (kCipUsint):
-      data_type_size = sizeof(CipUsint);
-      break;
-    case (kCipUint):
-      data_type_size = sizeof(CipUint);
-      break;
-    case (kCipUdint):
-      data_type_size = sizeof(CipUdint);
-      break;
-    case (kCipReal):
-      data_type_size = sizeof(CipReal);
-      break;
-#ifdef OPENER_SUPPORT_64BIT_DATATYPES
-    case (kCipLreal):
-      data_type_size = sizeof(CipLreal);
-      break;
-    case (kCipUlint):
-      data_type_size = sizeof(CipUlint);
-      break;
-    case (kCipLint):
-      data_type_size = sizeof(CipLint);
-      break;
-    case (kCipLword):
-      data_type_size = sizeof(CipLword);
-      break;
-    case (kCipLtime):
-      data_type_size = sizeof(CipLint);
-      break;
-#endif /* OPENER_SUPPORT_64BIT_DATATYPES */
-
-    case (kCipStime):
-      data_type_size = sizeof(CipDint);
-      break;
-    case (kCipDate):
-      data_type_size = sizeof(CipUint);
-      break;
-    case (kCipTimeOfDay):
-      data_type_size = sizeof(CipUdint);
-      break;
-    case (kCipDateAndTime):
-      data_type_size = sizeof(CipUdint) + sizeof(CipUint);
-      break;
-    case (kCipString): {
-      CipString *data = (CipString *) attribute_struct->data;
-      data_type_size = sizeof(CipUint) + (data->length) * sizeof(CipOctet);
-    }
-    break;
-    case (kCipByte):
-      data_type_size = sizeof(CipByte);
-      break;
-    case (kCipWord):
-      data_type_size = sizeof(CipWord);
-      break;
-    case (kCipDword):
-      data_type_size = sizeof(CipDword);
-      break;
-    case (kCipString2): {
-      CipString *data = (CipString *) attribute_struct->data;
-      data_type_size = sizeof(CipUint) + 2 * (data->length) * sizeof(CipOctet);
-    }
-    break;
-    case (kCipFtime):
-      data_type_size = sizeof(CipDint);
-      break;
-    case (kCipItime):
-      data_type_size = sizeof(CipInt);
-      break;
-    case (kCipStringN): {
-      CipStringN *data = (CipStringN *) attribute_struct->data;
-      data_type_size = sizeof(CipUint) + sizeof(CipUint)
-                       + (size_t) (data->length) * (size_t) (data->size);
-    }
-    break;
-    case (kCipShortString): {
-      CipShortString *data = (CipShortString *) attribute_struct->data;
-      data_type_size = sizeof(CipUsint) + (data->length) * sizeof(CipOctet);
-    }
-    break;
-    case (kCipTime):
-      data_type_size = sizeof(CipDint);
-      break;
-    case (kCipEpath): {
-      CipEpath *data = (CipEpath *) attribute_struct->data;
-      data_type_size = 2 * (data->path_size);
-    }
-    break;
-    case (kCipEngUnit):
-      data_type_size = sizeof(CipUint);
-      break;
-    case (kCipUsintUsint):
-      data_type_size = 2 * sizeof(CipUsint);
-      break;
-    case (kCipUdintUdintUdintUdintUdintString): {
-      CipTcpIpInterfaceConfiguration *data =
-        (CipTcpIpInterfaceConfiguration *) attribute_struct->data;
-      data_type_size = 5 * sizeof(CipUdint) + sizeof(CipUint)
-                       + (data->domain_name.length) * sizeof(EipByte);
-    }
-    break;
-    case (kCip6Usint):
-      data_type_size = 6 * sizeof(CipUsint);
-      break;
-    case (kCipMemberList):
-      data_type_size = 0;
-      break;
-    case (kCipByteArray): {
-      CipByteArray *data = (CipByteArray *) attribute_struct->data;
-      data_type_size = sizeof(CipUint) + (data->length) * sizeof(CipOctet);
-    }
-    break;
-    case (kInternalUint6):
-      data_type_size = 6 * sizeof(CipUint);
-      break;
-    default:
-      data_type_size = 0;
-      break;
-  }
-  return data_type_size;
-}

source/src/cip/cipcommon.h

@@ -73,12 +73,6 @@ EipStatus GetAttributeAll(CipInstance *instance,
                           const struct sockaddr *originator_address,
                           const int encapsulation_session);
 
-EipStatus GetAttributeAll2(CipInstance *instance,
-                          CipMessageRouterRequest *message_router_request,
-                          CipMessageRouterResponse *message_router_response,
-                          const struct sockaddr *originator_address,
-                          const int encapsulation_session);
-
 /** @brief Decodes padded EPath
  *  @param epath EPath object to the receiving element
  *  @param message pointer to the message to decode
@@ -87,6 +81,4 @@ EipStatus GetAttributeAll2(CipInstance *instance,
 int DecodePaddedEPath(CipEpath *epath,
                       const EipUint8 **message);
 
-size_t GetSizeOfAttribute(const CipAttributeStruct *const attribute_struct);
-
 #endif /* OPENER_CIPCOMMON_H_ */

source/src/cip/cipconnectionmanager.c

@@ -176,25 +176,25 @@ void InitializeConnectionManager(CipClass *class) {
 
   CipClass *meta_class = class->class_instance.cip_class;
 
-  InsertAttribute2( (CipInstance *) class, 1, kCipUint, EncodeCipUint,
+  InsertAttribute( (CipInstance *) class, 1, kCipUint, EncodeCipUint,
                    (void *) &class->revision,
                    kGetableSingleAndAll ); /* revision */
-  InsertAttribute2( (CipInstance *) class, 2, kCipUint, EncodeCipUint,
+  InsertAttribute( (CipInstance *) class, 2, kCipUint, EncodeCipUint,
                    (void *) &class->number_of_instances, kGetableSingleAndAll ); /*  largest instance number */
-  InsertAttribute2( (CipInstance *) class, 3, kCipUint, EncodeCipUint,
+  InsertAttribute( (CipInstance *) class, 3, kCipUint, EncodeCipUint,
                    (void *) &class->number_of_instances, kGetableSingle ); /* number of instances currently existing*/
-  InsertAttribute2( (CipInstance *) class, 4, kCipUint, EncodeCipUint, (void *) &kCipUintZero,
+  InsertAttribute( (CipInstance *) class, 4, kCipUint, EncodeCipUint, (void *) &kCipUintZero,
                    kNotSetOrGetable ); /* optional attribute list - default = 0 */
-  InsertAttribute2( (CipInstance *) class, 5, kCipUint, EncodeCipUint, (void *) &kCipUintZero,
+  InsertAttribute( (CipInstance *) class, 5, kCipUint, EncodeCipUint, (void *) &kCipUintZero,
                    kNotSetOrGetable ); /* optional service list - default = 0 */
-  InsertAttribute2( (CipInstance *) class, 6, kCipUint, EncodeCipUint,
+  InsertAttribute( (CipInstance *) class, 6, kCipUint, EncodeCipUint,
                    (void *) &meta_class->highest_attribute_number,
                    kGetableSingleAndAll ); /* max class attribute number*/
-  InsertAttribute2( (CipInstance *) class, 7, kCipUint, EncodeCipUint,
+  InsertAttribute( (CipInstance *) class, 7, kCipUint, EncodeCipUint,
                    (void *) &class->highest_attribute_number,
                    kGetableSingleAndAll ); /* max instance attribute number*/
 
-  InsertService(meta_class, kGetAttributeAll, &GetAttributeAll2,	"GetAttributeAll"); /* bind instance services to the metaclass*/
+  InsertService(meta_class, kGetAttributeAll, &GetAttributeAll,	"GetAttributeAll"); /* bind instance services to the metaclass*/
   InsertService(meta_class, kGetAttributeSingle, &GetAttributeSingle, "GetAttributeSingle");
 
 }

source/src/cip/cipdlr.c

@@ -90,99 +90,15 @@ CipDlrObject g_dlr;  /**< definition of DLR object instance 1 data */
 /* ********************************************************************
  * local functions
  */
-static void EncodeNodeAddress(CipNodeAddress *node_address, CipMessageRouterResponse *const message_router_response) {
-  EncodeData(kCipUdint, &node_address->device_ip, message_router_response);
-  EncodeData(kCip6Usint, &node_address->device_mac, message_router_response);
+static void EncodeCipRingSupervisorConfig(const void *const data, ENIPMessage *const outgoing_message) {
+  const size_t kRingSupStructSize = 12u;
+  FillNextNMessageOctetsWithValueAndMoveToNextPosition(0, kRingSupStructSize, outgoing_message);
 }
 
-static EipStatus GetAttributeSingleDlr(
-  CipInstance *RESTRICT const instance,
-  CipMessageRouterRequest *const message_router_request,
-  CipMessageRouterResponse *const message_router_response,
-  const struct sockaddr *originator_address,
-  const int encapsulation_session) {
-
-  CipAttributeStruct *attribute = GetCipAttribute(
-    instance, message_router_request->request_path.attribute_number);
-  InitializeENIPMessage(&message_router_response->message);
-  message_router_response->reply_service = (0x80
-                                            | message_router_request->service);
-  message_router_response->general_status = kCipErrorAttributeNotSupported;
-  message_router_response->size_of_additional_status = 0;
-
-  EipUint16 attribute_number = message_router_request->request_path
-                               .attribute_number;
-
-  if ( (NULL != attribute) && (NULL != attribute->data) ) {
-    /* Mask for filtering get-ability */
-    uint8_t get_bit_mask = 0;
-    if (kGetAttributeAll == message_router_request->service) {
-      get_bit_mask = (instance->cip_class->get_all_bit_mask[CalculateIndex(
-                                                              attribute_number)]);
-      message_router_response->general_status = kCipErrorSuccess;
-    } else {
-      get_bit_mask = (instance->cip_class->get_single_bit_mask[CalculateIndex(
-                                                                 attribute_number)
-                      ]);
-    }
-    if ( 0 != ( get_bit_mask & ( 1 << (attribute_number % 8) ) ) ) {
-      /* create a reply message containing the data*/
-      bool use_common_handler;
-      switch (attribute_number) {
-      case 4: /* fall through */
-      case 6: /* fall through */
-      case 7: /* fall through */
-      case 10:
-        use_common_handler = false;
-        OPENER_TRACE_INFO("getAttribute %d\n", attribute_number);
-        break;
-      default:
-        use_common_handler = true;
-        break;
-      }
-
-      /* Call the PreGetCallback if enabled for this attribute and the common handler is not used. */
-      if (!use_common_handler) {
-        if ((attribute->attribute_flags & kPreGetFunc) && NULL != instance->cip_class->PreGetCallback) {
-          instance->cip_class->PreGetCallback(instance, attribute, message_router_request->service);
-        }
-      }
-
-      switch (attribute_number) {
-        case 4: {
-          /* This attribute is not implemented and only reached by GetAttributesAll. */
-          const size_t kRingSupStructSize = 12u;
-          FillNextNMessageOctetsWithValueAndMoveToNextPosition(0, kRingSupStructSize, &message_router_response->message);
-          message_router_response->general_status = kCipErrorSuccess;
-          break;
-        }
-        case 6: /* fall through */
-        case 7: /* fall through */
-        case 10:
-          EncodeNodeAddress(
-            (CipNodeAddress *)attribute->data,
-            message_router_response);
-          message_router_response->general_status = kCipErrorSuccess;
-          break;
-
-        default:
-          GetAttributeSingle(instance, message_router_request,
-                             message_router_response,
-                             originator_address,
-                             encapsulation_session);
-      }
-
-      /* Call the PostGetCallback if enabled for this attribute and the common handler is not used. */
-      if (!use_common_handler) {
-        if ((attribute->attribute_flags & kPostGetFunc) && NULL != instance->cip_class->PostGetCallback) {
-          instance->cip_class->PostGetCallback(instance, attribute, message_router_request->service);
-        }
-      }
-
-    }
-  }
-
-  return kEipStatusOkSend;
+static void EncodeCipNodeAddress(const void *const data, ENIPMessage *const outgoing_message) {
+  CipNodeAddress *node_address = (CipNodeAddress *)data;
+  EncodeCipUdint(&node_address->device_ip, outgoing_message);
+  EncodeData(kCip6Usint, &node_address->device_mac, outgoing_message);
 }
 
 
@@ -211,36 +127,36 @@ EipStatus CipDlrInit(void) {
 
   /* Add services to the class */
   InsertService(dlr_class, kGetAttributeSingle,
-                GetAttributeSingleDlr, "GetAttributeSingleDlr");
+                GetAttributeSingle, "GetAttributeSingle");
   InsertService(dlr_class, kGetAttributeAll,
                 GetAttributeAll, "GetAttributeAll");
 
   /* Bind attributes to the instance */
   CipInstance *dlr_instance = GetCipInstance(dlr_class, 1u);
 
-  InsertAttribute(dlr_instance,  1, kCipUsint, &g_dlr.network_topology,
+  InsertAttribute(dlr_instance,  1, kCipUsint, EncodeCipUsint, &g_dlr.network_topology,
                   kGetableSingleAndAll);
-  InsertAttribute(dlr_instance,  2, kCipUsint, &g_dlr.network_status,
+  InsertAttribute(dlr_instance,  2, kCipUsint, EncodeCipUsint, &g_dlr.network_status,
                   kGetableSingleAndAll);
-  InsertAttribute(dlr_instance,  3, kCipUsint, (void *)&s_0xFF_default,
-                  kGetableAll);
-  InsertAttribute(dlr_instance,  4, kCipAny, (void *)&s_0x00000000_default,
+  InsertAttribute(dlr_instance,  3, kCipUsint, EncodeCipUsint, (void *)&s_0xFF_default,
                   kGetableAll);
-  InsertAttribute(dlr_instance,  5, kCipUint, (void *)&s_0x0000_default,
+  InsertAttribute(dlr_instance,  4, kCipAny, EncodeCipRingSupervisorConfig, (void *)&s_0x00000000_default,
+                  kGetableAllDummy);
+  InsertAttribute(dlr_instance,  5, kCipUint, EncodeCipUint, (void *)&s_0x0000_default,
                   kGetableAll);
-  InsertAttribute(dlr_instance,  6, kCipAny, (void *)&s_zero_node,
+  InsertAttribute(dlr_instance,  6, kCipAny, EncodeCipNodeAddress, (void *)&s_zero_node,
                   kGetableAll);
-  InsertAttribute(dlr_instance,  7, kCipAny, (void *)&s_zero_node,
+  InsertAttribute(dlr_instance,  7, kCipAny, EncodeCipNodeAddress, (void *)&s_zero_node,
                   kGetableAll);
-  InsertAttribute(dlr_instance,  8, kCipUint, (void *)&s_0xFFFF_default,
+  InsertAttribute(dlr_instance,  8, kCipUint, EncodeCipUint, (void *)&s_0xFFFF_default,
                   kGetableAll);
   /* Attribute #9 is not implemented and also NOT part of the GetAttributesAll
    *  response. Therefore it is not added here! */
-  InsertAttribute(dlr_instance, 10, kCipAny, &g_dlr.active_supervisor_address,
+  InsertAttribute(dlr_instance, 10, kCipAny, EncodeCipNodeAddress, &g_dlr.active_supervisor_address,
                   kGetableSingleAndAll);
-  InsertAttribute(dlr_instance, 11, kCipUsint, (void *)&s_0x00_default,
+  InsertAttribute(dlr_instance, 11, kCipUsint, EncodeCipUsint, (void *)&s_0x00_default,
                   kGetableAll);
-  InsertAttribute(dlr_instance, 12, kCipDword, &g_dlr.capability_flags,
+  InsertAttribute(dlr_instance, 12, kCipDword, EncodeCipDword, &g_dlr.capability_flags,
                   kGetableSingleAndAll);
 
   /* Set attributes to initial values */

source/src/cip/cipethernetlink.c

@@ -93,13 +93,6 @@ static void EncodeCipEthernetLinkInterfaceControl(const void *const data, ENIPMe
 
 static void EncodeCipEthernetLinkInterfaceCaps(const void *const data, ENIPMessage *const outgoing_message);
 
-void EncodeCipEthernetLinkPhyisicalAddress(const void *const data, ENIPMessage *const outgoing_message) {
-    EipUint8 *p = (EipUint8 *) data;
-    memcpy(outgoing_message->current_message_position, p, 6);
-    outgoing_message->current_message_position += 6;
-    outgoing_message->used_message_length += 6;
-}
-
 
 /* forward declaration for the GetAttributeSingle service handler function */
 EipStatus GetAttributeSingleEthernetLink(
@@ -249,8 +242,8 @@ EipStatus CipEthernetLinkInit(void) {
     /* add services to the class */
     InsertService(ethernet_link_class, kGetAttributeSingle,
                   &GetAttributeSingle,
-                  "GetAttributeSingleEthernetLink");
-    InsertService(ethernet_link_class, kGetAttributeAll, &GetAttributeAll2,
+                  "GetAttributeSingle");
+    InsertService(ethernet_link_class, kGetAttributeAll, &GetAttributeAll,
                   "GetAttributeAll");
 #if defined(OPENER_ETHLINK_CNTRS_ENABLE) && 0 != OPENER_ETHLINK_CNTRS_ENABLE
     InsertService(ethernet_link_class, kEthLinkGetAndClear,
@@ -267,11 +260,11 @@ EipStatus CipEthernetLinkInit(void) {
       CipInstance *ethernet_link_instance =
         GetCipInstance(ethernet_link_class, idx+1);
 
-      InsertAttribute2(ethernet_link_instance, 1, kCipUdint, EncodeCipUdint,
+      InsertAttribute(ethernet_link_instance, 1, kCipUdint, EncodeCipUdint,
                       &g_ethernet_link[idx].interface_speed, kGetableSingleAndAll);
-      InsertAttribute2(ethernet_link_instance, 2, kCipDword, EncodeCipDword,
+      InsertAttribute(ethernet_link_instance, 2, kCipDword, EncodeCipDword,
                       &g_ethernet_link[idx].interface_flags, kGetableSingleAndAll);
-      InsertAttribute2(ethernet_link_instance, 3, kCip6Usint, EncodeCipEthernetLinkPhyisicalAddress,
+      InsertAttribute(ethernet_link_instance, 3, kCip6Usint, EncodeCipEthernetLinkPhyisicalAddress,
                       &g_ethernet_link[idx].physical_address, kGetableSingleAndAll);
 #if defined(OPENER_ETHLINK_CNTRS_ENABLE) && 0 != OPENER_ETHLINK_CNTRS_ENABLE
       InsertAttribute(ethernet_link_instance, 4, kCipUsint, EncodeCipUsint,
@@ -279,36 +272,36 @@ EipStatus CipEthernetLinkInit(void) {
       InsertAttribute(ethernet_link_instance, 5, kCipUsint, EncodeCipUsint,
                       &g_ethernet_link[idx].media_cntrs, kGetableSingleAndAll);
 #else
-      InsertAttribute2(ethernet_link_instance, 4, kCipAny, EncodeCipEthernetLinkInterfaceCounters,
+      InsertAttribute(ethernet_link_instance, 4, kCipAny, EncodeCipEthernetLinkInterfaceCounters,
                       &dummy_attribute_udint, kGetableAllDummy);
-      InsertAttribute2(ethernet_link_instance, 5, kCipAny, EncodeCipEthernetLinkMediaCounters,
+      InsertAttribute(ethernet_link_instance, 5, kCipAny, EncodeCipEthernetLinkMediaCounters,
                       &dummy_attribute_udint, kGetableAllDummy);
 #endif  /* ... && 0 != OPENER_ETHLINK_CNTRS_ENABLE */
 #if defined(OPENER_ETHLINK_IFACE_CTRL_ENABLE) && 0 != OPENER_ETHLINK_IFACE_CTRL_ENABLE
       if (2 == idx) {
         /* Interface control of internal switch port is never settable. */
-        InsertAttribute2(ethernet_link_instance, 6, kCipAny, EncodeCipEthernetLinkInterfaceControl,
+        InsertAttribute(ethernet_link_instance, 6, kCipAny, EncodeCipEthernetLinkInterfaceControl,
                         &g_ethernet_link[idx].interface_control,
                         IFACE_CTRL_ACCESS_MODE & ~kSetable);
       } else {
-        InsertAttribute2(ethernet_link_instance, 6, kCipAny, EncodeCipEthernetLinkInterfaceControl,
+        InsertAttribute(ethernet_link_instance, 6, kCipAny, EncodeCipEthernetLinkInterfaceControl,
                         &g_ethernet_link[idx].interface_control,
                         IFACE_CTRL_ACCESS_MODE);
       }
 #else
-      InsertAttribute2(ethernet_link_instance, 6, kCipAny, EncodeCipEthernetLinkInterfaceControl, &s_interface_control,
+      InsertAttribute(ethernet_link_instance, 6, kCipAny, EncodeCipEthernetLinkInterfaceControl, &s_interface_control,
                       kGetableAll);
 #endif
-      InsertAttribute2(ethernet_link_instance, 7, kCipUsint, EncodeCipUsint,
+      InsertAttribute(ethernet_link_instance, 7, kCipUsint, EncodeCipUsint,
                       &g_ethernet_link[idx].interface_type, kGetableSingleAndAll);
-      InsertAttribute2(ethernet_link_instance, 8, kCipUsint, EncodeCipUsint,
+      InsertAttribute(ethernet_link_instance, 8, kCipUsint, EncodeCipUsint,
                       &dummy_attribute_usint, kGetableAllDummy);
-      InsertAttribute2(ethernet_link_instance, 9, kCipUsint, EncodeCipUsint,
+      InsertAttribute(ethernet_link_instance, 9, kCipUsint, EncodeCipUsint,
                       &dummy_attribute_usint, kGetableAllDummy);
-      InsertAttribute2(ethernet_link_instance, 10, kCipShortString, EncodeCipShortString,
+      InsertAttribute(ethernet_link_instance, 10, kCipShortString, EncodeCipShortString,
                       &g_ethernet_link[idx].interface_label,
                       IFACE_LABEL_ACCESS_MODE);
-      InsertAttribute2(ethernet_link_instance, 11, kCipAny,  EncodeCipEthernetLinkInterfaceCaps,
+      InsertAttribute(ethernet_link_instance, 11, kCipAny,  EncodeCipEthernetLinkInterfaceCaps,
                       &g_ethernet_link[idx].interface_caps, kGetableSingleAndAll);
     }
   } else {
@@ -386,98 +379,6 @@ static void EncodeCipEthernetLinkInterfaceCaps(const void *const data, ENIPMessa
   }
 }
 
-//EipStatus GetAttributeSingleEthernetLink(
-//  CipInstance *RESTRICT const instance,
-//  CipMessageRouterRequest *const message_router_request,
-//  CipMessageRouterResponse *const message_router_response,
-//  const struct sockaddr *originator_address,
-//  const int encapsulation_session) {
-//
-//  CipAttributeStruct *attribute = GetCipAttribute(
-//    instance, message_router_request->request_path.attribute_number);
-//  InitializeENIPMessage(&message_router_response->message);
-//  message_router_response->reply_service = (0x80
-//                                            | message_router_request->service);
-//  message_router_response->general_status = kCipErrorAttributeNotSupported;
-//  message_router_response->size_of_additional_status = 0;
-//
-//  EipUint16 attribute_number = message_router_request->request_path
-//                               .attribute_number;
-//
-//  if ( (NULL != attribute) && (NULL != attribute->data) ) {
-//    /* Mask for filtering get-ability */
-//    uint8_t get_bit_mask = 0;
-//    if (kGetAttributeAll == message_router_request->service) {
-//      get_bit_mask = (instance->cip_class->get_all_bit_mask[CalculateIndex(
-//                                                              attribute_number)]);
-//      message_router_response->general_status = kCipErrorSuccess;
-//    } else {
-//      get_bit_mask = (instance->cip_class->get_single_bit_mask[CalculateIndex(
-//                                                                 attribute_number)
-//                      ]);
-//    }
-//    if ( 0 != ( get_bit_mask & ( 1 << (attribute_number % 8) ) ) ) {
-//
-//      /* create a reply message containing the data*/
-//      bool use_common_handler;
-//      switch (attribute_number) {
-//      case 4: /* fall through */
-//      case 5: /* fall through */
-//      case 6: /* fall through */
-//      case 11:
-//        use_common_handler = false;
-//        OPENER_TRACE_INFO("getAttribute %d\n", attribute_number);
-//        break;
-//      default:
-//        use_common_handler = true;
-//        break;
-//      }
-//
-//      /* Call the PreGetCallback if enabled for this attribute and the common handler is not used. */
-//      if (!use_common_handler) {
-//        if ((attribute->attribute_flags & kPreGetFunc) && NULL != instance->cip_class->PreGetCallback) {
-//          instance->cip_class->PreGetCallback(instance, attribute, message_router_request->service);
-//        }
-//      }
-//
-//      switch (attribute_number) {
-//        case 4:
-//          EncodeInterfaceCounters(instance->instance_number, message_router_response);
-//          message_router_response->general_status = kCipErrorSuccess;
-//          break;
-//        case 5:
-//          EncodeMediaCounters(instance->instance_number, message_router_response);
-//          message_router_response->general_status = kCipErrorSuccess;
-//          break;
-//        case 6:
-//          EncodeInterfaceControl(instance->instance_number, message_router_response);
-//          message_router_response->general_status = kCipErrorSuccess;
-//          break;
-//        case 11:
-//          EncodeInterfaceCapability(instance->instance_number, message_router_response);
-//          message_router_response->general_status = kCipErrorSuccess;
-//          break;
-//
-//        default:
-//          GetAttributeSingle(instance, message_router_request,
-//                             message_router_response,
-//                             originator_address,
-//                             encapsulation_session);
-//      }
-//
-//      /* Call the PostGetCallback if enabled for this attribute and the common handler is not used. */
-//      if (!use_common_handler) {
-//        if ((attribute->attribute_flags & kPostGetFunc) && NULL != instance->cip_class->PostGetCallback) {
-//          instance->cip_class->PostGetCallback(instance, attribute, message_router_request->service);
-//        }
-//      }
-//
-//    }
-//  }
-//
-//  return kEipStatusOkSend;
-//}
-
 #if defined(OPENER_ETHLINK_CNTRS_ENABLE) && 0 != OPENER_ETHLINK_CNTRS_ENABLE
 EipStatus GetAndClearEthernetLink(
   CipInstance *RESTRICT const instance,

source/src/cip/cipidentity.c

@@ -188,28 +188,28 @@ void InitializeCipIdentity(CipClass *class) {
 
   CipClass *meta_class = class->class_instance.cip_class;
 
-  InsertAttribute2( (CipInstance *) class, 1, kCipUint,
+  InsertAttribute( (CipInstance *) class, 1, kCipUint,
 		           EncodeCipUint,
                    (void *) &class->revision,
                    kGetableSingleAndAll );                 /* revision */
-  InsertAttribute2( (CipInstance *) class, 2, kCipUint,
+  InsertAttribute( (CipInstance *) class, 2, kCipUint,
 		           EncodeCipUint,
                    (void *) &class->number_of_instances, kGetableSingleAndAll ); /*  largest instance number */
-  InsertAttribute2( (CipInstance *) class, 3, kCipUint,
+  InsertAttribute( (CipInstance *) class, 3, kCipUint,
 		           EncodeCipUint,
                    (void *) &class->number_of_instances, kGetableSingle ); /* number of instances currently existing*/
-  InsertAttribute2( (CipInstance *) class, 4, kCipUint, EncodeCipUint, (void *) &kCipUintZero,
+  InsertAttribute( (CipInstance *) class, 4, kCipUint, EncodeCipUint, (void *) &kCipUintZero,
                    kNotSetOrGetable ); /* optional attribute list - default = 0 */
-  InsertAttribute2( (CipInstance *) class, 5, kCipUint, EncodeCipUint, (void *) &kCipUintZero,
+  InsertAttribute( (CipInstance *) class, 5, kCipUint, EncodeCipUint, (void *) &kCipUintZero,
                    kNotSetOrGetable ); /* optional service list - default = 0 */
-  InsertAttribute2( (CipInstance *) class, 6, kCipUint, EncodeCipUint,
+  InsertAttribute( (CipInstance *) class, 6, kCipUint, EncodeCipUint,
                    (void *) &meta_class->highest_attribute_number,
                    kGetableSingleAndAll );                 /* max class attribute number*/
-  InsertAttribute2( (CipInstance *) class, 7, kCipUint, EncodeCipUint,
+  InsertAttribute( (CipInstance *) class, 7, kCipUint, EncodeCipUint,
                    (void *) &class->highest_attribute_number,
                    kGetableSingleAndAll );                 /* max instance attribute number*/
 
-  InsertService(meta_class, kGetAttributeAll, &GetAttributeAll2,
+  InsertService(meta_class, kGetAttributeAll, &GetAttributeAll,
                     "GetAttributeAll");                     /* bind instance services to the metaclass*/
   InsertService(meta_class, kGetAttributeSingle, &GetAttributeSingle,
                   "GetAttributeSingle");
@@ -241,40 +241,40 @@ EipStatus CipIdentityInit() {
   }
 
   CipInstance *instance = GetCipInstance(class, 1);
-  InsertAttribute2(instance,
+  InsertAttribute(instance,
                   1,
                   kCipUint,
 				  EncodeCipUint,
                   &g_identity.vendor_id,
                   kGetableSingleAndAll);
-  InsertAttribute2(instance,
+  InsertAttribute(instance,
                   2,
                   kCipUint,
 				  EncodeCipUint,
                   &g_identity.device_type,
                   kGetableSingleAndAll);
-  InsertAttribute2(instance,
+  InsertAttribute(instance,
                   3,
                   kCipUint,
 				  EncodeCipUint,
                   &g_identity.product_code,
                   kGetableSingleAndAll);
-  InsertAttribute2(instance,4, kCipUsintUsint, EncodeRevision, &g_identity.revision,
+  InsertAttribute(instance,4, kCipUsintUsint, EncodeRevision, &g_identity.revision,
                   kGetableSingleAndAll);
-  InsertAttribute2(instance,
+  InsertAttribute(instance,
                   5,
                   kCipWord,
 				  EncodeCipWord,
                   &g_identity.status,
                   kGetableSingleAndAll);
-  InsertAttribute2(instance, 6, kCipUdint, EncodeCipUdint, &g_identity.serial_number,
+  InsertAttribute(instance, 6, kCipUdint, EncodeCipUdint, &g_identity.serial_number,
                   kGetableSingleAndAll);
-  InsertAttribute2(instance, 7, kCipShortString, EncodeCipShortString, &g_identity.product_name,
+  InsertAttribute(instance, 7, kCipShortString, EncodeCipShortString, &g_identity.product_name,
                   kGetableSingleAndAll);
 
   InsertService(class, kGetAttributeSingle, &GetAttributeSingle,
                 "GetAttributeSingle");
-  InsertService(class, kGetAttributeAll, &GetAttributeAll2, "GetAttributeAll");
+  InsertService(class, kGetAttributeAll, &GetAttributeAll, "GetAttributeAll");
   InsertService(class, kReset, &Reset, "Reset");
 
   return kEipStatusOk;

source/src/cip/cipmessagerouter.c

@@ -15,7 +15,6 @@
 CipMessageRouterRequest g_message_router_request;
 CipMessageRouterResponse g_message_router_response;
 
-
 /** @brief A class registry list node
  *
  * A linked list of this  object is the registry of classes known to the message router
@@ -56,28 +55,28 @@ void InitializeCipMessageRouterClass(CipClass *cip_class) {
 
   CipClass *meta_class = cip_class->class_instance.cip_class;
 
-  InsertAttribute2( (CipInstance *) cip_class, 1, kCipUint, EncodeCipUint,
+  InsertAttribute( (CipInstance *) cip_class, 1, kCipUint, EncodeCipUint,
                    (void *) &cip_class->revision, kGetableSingleAndAll );   /* revision */
-  InsertAttribute2( (CipInstance *) cip_class, 2, kCipUint, EncodeCipUint,
+  InsertAttribute( (CipInstance *) cip_class, 2, kCipUint, EncodeCipUint,
                    (void *) &cip_class->number_of_instances,
                    kGetableSingle );                                       /*  largest instance number */
-  InsertAttribute2( (CipInstance *) cip_class, 3, kCipUint, EncodeCipUint,
+  InsertAttribute( (CipInstance *) cip_class, 3, kCipUint, EncodeCipUint,
                    (void *) &cip_class->number_of_instances,
                    kGetableSingle );                                                           /* number of instances currently existing*/
-  InsertAttribute2( (CipInstance *) cip_class, 4, kCipUint, EncodeCipUint,
+  InsertAttribute( (CipInstance *) cip_class, 4, kCipUint, EncodeCipUint,
                    (void *) &kCipUintZero,
                    kGetableAll );   /* optional attribute list - default = 0 */
-  InsertAttribute2( (CipInstance *) cip_class, 5, kCipUint, EncodeCipUint,
+  InsertAttribute( (CipInstance *) cip_class, 5, kCipUint, EncodeCipUint,
                    (void *) &kCipUintZero,
                    kGetableAll ); /* optional service list - default = 0 */
-  InsertAttribute2( (CipInstance *) cip_class, 6, kCipUint, EncodeCipUint,
+  InsertAttribute( (CipInstance *) cip_class, 6, kCipUint, EncodeCipUint,
                    (void *) &meta_class->highest_attribute_number,
                    kGetableSingleAndAll );                       /* max class attribute number*/
-  InsertAttribute2( (CipInstance *) cip_class, 7, kCipUint, EncodeCipUint,
+  InsertAttribute( (CipInstance *) cip_class, 7, kCipUint, EncodeCipUint,
                    (void *) &cip_class->highest_attribute_number,
                    kGetableSingleAndAll );                       /* max instance attribute number*/
 
-  InsertService(meta_class, kGetAttributeAll, &GetAttributeAll2,
+  InsertService(meta_class, kGetAttributeAll, &GetAttributeAll,
                     "GetAttributeAll");                     /* bind instance services to the metaclass*/
   InsertService(meta_class, kGetAttributeSingle, &GetAttributeSingle,
                   "GetAttributeSingle");
@@ -197,7 +196,6 @@ EipStatus NotifyMessageRouter(EipUint8 *data,
     g_message_router_response.general_status = status;
     g_message_router_response.size_of_additional_status = 0;
     g_message_router_response.reserved = 0;
-    InitializeENIPMessage(&g_message_router_response.message);
     g_message_router_response.reply_service = (0x80
                                                | g_message_router_request.
                                                service);
@@ -213,7 +211,6 @@ EipStatus NotifyMessageRouter(EipUint8 *data,
         kCipErrorPathDestinationUnknown;   /*according to the test tool this should be the correct error flag instead of CIP_ERROR_OBJECT_DOES_NOT_EXIST;*/
       g_message_router_response.size_of_additional_status = 0;
       g_message_router_response.reserved = 0;
-      InitializeENIPMessage(&g_message_router_response.message);
       g_message_router_response.reply_service = (0x80
                                                  | g_message_router_request.
                                                  service);

source/src/cip/cipqos.c

@@ -164,49 +164,49 @@ EipStatus CipQoSInit() {
 
   CipInstance *instance = GetCipInstance(qos_class, 1); /* bind attributes to the instance #1 that was created above */
 
-  InsertAttribute2(instance,
+  InsertAttribute(instance,
                   1,
                   kCipUsint,
 				  EncodeCipUsint,
                   (void *) &g_qos.q_frames_enable,
                   kNotSetOrGetable);
-  InsertAttribute2(instance,
+  InsertAttribute(instance,
                   2,
                   kCipUsint,
 				  EncodeCipUsint,
                   (void *) &g_qos.dscp.event,
                   kNotSetOrGetable);
-  InsertAttribute2(instance,
+  InsertAttribute(instance,
                   3,
                   kCipUsint,
 				  EncodeCipUsint,
                   (void *) &g_qos.dscp.general,
                   kNotSetOrGetable);
-  InsertAttribute2(instance,
+  InsertAttribute(instance,
                   4,
                   kCipUsint,
 				  EncodeCipUsint,
                   (void *) &g_qos.dscp.urgent,
                   kGetableSingle | kSetable | kNvDataFunc);
-  InsertAttribute2(instance,
+  InsertAttribute(instance,
                   5,
                   kCipUsint,
 				  EncodeCipUsint,
                   (void *) &g_qos.dscp.scheduled,
                   kGetableSingle | kSetable | kNvDataFunc);
-  InsertAttribute2(instance,
+  InsertAttribute(instance,
                   6,
                   kCipUsint,
 				  EncodeCipUsint,
                   (void *) &g_qos.dscp.high,
                   kGetableSingle | kSetable | kNvDataFunc);
-  InsertAttribute2(instance,
+  InsertAttribute(instance,
                   7,
                   kCipUsint,
 				  EncodeCipUsint,
                   (void *) &g_qos.dscp.low,
                   kGetableSingle | kSetable | kNvDataFunc);
-  InsertAttribute2(instance,
+  InsertAttribute(instance,
                   8,
                   kCipUsint,
 				  EncodeCipUsint,

source/src/cip/ciptcpipinterface.c

@@ -345,20 +345,6 @@ void EncodeCipLastConflictDetected(const void *const data, ENIPMessage *const ou
   FillNextNMessageOctetsWithValueAndMoveToNextPosition(0, kAttribute11Size, outgoing_message);
 }
 
-EipStatus GetAttributeSingleTcpIpInterface(
-  CipInstance *const RESTRICT instance,
-  CipMessageRouterRequest *const RESTRICT message_router_request,
-  CipMessageRouterResponse *const RESTRICT message_router_response,
-  const struct sockaddr *originator_address,
-  const int encapsulation_session);
-
-EipStatus GetAttributeAllTcpIpInterface(
-  CipInstance *instance,
-  CipMessageRouterRequest *message_router_request,
-  CipMessageRouterResponse *message_router_response,
-  const struct sockaddr *originator_address,
-  const int encapsulation_session);
-
 EipStatus SetAttributeSingleTcpIpInterface(
   CipInstance *instance,
   CipMessageRouterRequest *message_router_request,
@@ -370,6 +356,7 @@ EipStatus SetAttributeSingleTcpIpInterface(
   EipUint16 attribute_number = message_router_request->request_path
                                .attribute_number;
 
+  /* Check attribute exists and is not a dummy for GetAttributeAll */
   if (NULL != attribute && !(kGetableAllDummy & attribute->attribute_flags)) {
     uint8_t set_bit_mask = (instance->cip_class->set_bit_mask[CalculateIndex(
                                                                 attribute_number)
@@ -562,32 +549,32 @@ EipStatus CipTcpIpInterfaceInit() {
 
   CipInstance *instance = GetCipInstance(tcp_ip_class, 1); /* bind attributes to the instance #1 that was created above */
 
-  InsertAttribute2(instance, 1, kCipDword, EncodeCipDword, &g_tcpip.status,
+  InsertAttribute(instance, 1, kCipDword, EncodeCipDword, &g_tcpip.status,
                   kGetableSingleAndAll);
-  InsertAttribute2(instance, 2, kCipDword, EncodeCipDword, &g_tcpip.config_capability,
+  InsertAttribute(instance, 2, kCipDword, EncodeCipDword, &g_tcpip.config_capability,
                   kGetableSingleAndAll);
-  InsertAttribute2(instance, 3 , kCipDword, EncodeCipDword, &g_tcpip.config_control,
+  InsertAttribute(instance, 3 , kCipDword, EncodeCipDword, &g_tcpip.config_control,
                   kSetAndGetAble | kNvDataFunc | IFACE_CFG_SET_MODE );
-  InsertAttribute2(instance, 4, kCipEpath, EncodeCipEPath, &g_tcpip.physical_link_object,
+  InsertAttribute(instance, 4, kCipEpath, EncodeCipEPath, &g_tcpip.physical_link_object,
                   kGetableSingleAndAll);
-  InsertAttribute2(instance, 5, kCipUdintUdintUdintUdintUdintString, EncoodeCipTcpIpInterfaceConfiguration,
+  InsertAttribute(instance, 5, kCipUdintUdintUdintUdintUdintString, EncoodeCipTcpIpInterfaceConfiguration,
                   &g_tcpip.interface_configuration,
                   kGetableSingleAndAll | kNvDataFunc | IFACE_CFG_SET_MODE);
-  InsertAttribute2(instance, 6, kCipString, EncodeCipString, &g_tcpip.hostname,
+  InsertAttribute(instance, 6, kCipString, EncodeCipString, &g_tcpip.hostname,
                   kGetableSingleAndAll | kNvDataFunc | IFACE_CFG_SET_MODE);
-  InsertAttribute2(instance, 7, kCipAny, EncodeSafetyNetworkNumber, &dummy_data_field,
+  InsertAttribute(instance, 7, kCipAny, EncodeSafetyNetworkNumber, &dummy_data_field,
 		  kGetableAllDummy);
-  InsertAttribute2(instance, 8, kCipUsint, EncodeCipUsint, &g_tcpip.mcast_ttl_value,
+  InsertAttribute(instance, 8, kCipUsint, EncodeCipUsint, &g_tcpip.mcast_ttl_value,
                   kGetableSingleAndAll);
-  InsertAttribute2(instance, 9, kCipAny, EncodeCipTcpIpMulticastConfiguration, &g_tcpip.mcast_config,
+  InsertAttribute(instance, 9, kCipAny, EncodeCipTcpIpMulticastConfiguration, &g_tcpip.mcast_config,
                   kGetableSingleAndAll);
-  InsertAttribute2(instance, 10, kCipBool, EncodeCipBool, &g_tcpip.select_acd,
+  InsertAttribute(instance, 10, kCipBool, EncodeCipBool, &g_tcpip.select_acd,
 		  kGetableAllDummy);
-  InsertAttribute2(instance, 11, kCipBool, EncodeCipLastConflictDetected, &dummy_data_field,
+  InsertAttribute(instance, 11, kCipBool, EncodeCipLastConflictDetected, &dummy_data_field,
 		  kGetableAllDummy);
-  InsertAttribute2(instance, 12, kCipBool, EncodeCipBool, &dummy_data_field,
+  InsertAttribute(instance, 12, kCipBool, EncodeCipBool, &dummy_data_field,
 		  kGetableAllDummy);
-  InsertAttribute2(instance,
+  InsertAttribute(instance,
                   13,
                   kCipUint,
 				  EncodeCipUint,
@@ -596,10 +583,10 @@ EipStatus CipTcpIpInterfaceInit() {
 
   InsertService(tcp_ip_class, kGetAttributeSingle,
                 &GetAttributeSingle,
-                "GetAttributeSingleTCPIPInterface");
+                "GetAttributeSingle");
 
-  InsertService(tcp_ip_class, kGetAttributeAll, &GetAttributeAll2,
-                "GetAttributeAllTCPIPInterface");
+  InsertService(tcp_ip_class, kGetAttributeAll, &GetAttributeAll,
+                "GetAttributeAll");
 
   InsertService(tcp_ip_class, kSetAttributeSingle,
                 &SetAttributeSingleTcpIpInterface,
@@ -621,114 +608,6 @@ void ShutdownTcpIpInterface(void) {
   }
 }
 
-EipStatus GetAttributeSingleTcpIpInterface(
-  CipInstance *const RESTRICT instance,
-  CipMessageRouterRequest *const RESTRICT message_router_request,
-  CipMessageRouterResponse *const RESTRICT message_router_response,
-  const struct sockaddr *originator_address,
-  const int encapsulation_session) {
-
-  EipUint16 attribute_number = message_router_request->request_path
-                               .attribute_number;
-
-  /* Use common handler for all attributes except attribute 9. */
-  if (9 != attribute_number) {
-    return GetAttributeSingle(instance,
-                              message_router_request,
-                              message_router_response,
-                              originator_address,
-                              encapsulation_session);
-  }
-
-  { /* attribute 9 can not be easily handled with the default mechanism therefore we will do it by hand */
-    InitializeENIPMessage(&message_router_response->message);
-    message_router_response->reply_service = (0x80
-                                              | message_router_request->service);
-    message_router_response->size_of_additional_status = 0;
-    message_router_response->general_status = kCipErrorAttributeNotSupported;
-
-    uint8_t get_bit_mask = 0;
-    if (kGetAttributeAll == message_router_request->service) {
-      get_bit_mask = (instance->cip_class->get_all_bit_mask[CalculateIndex(
-                                                              attribute_number)]);
-      message_router_response->general_status = kCipErrorSuccess;
-    } else {
-      get_bit_mask = (instance->cip_class->get_single_bit_mask[CalculateIndex(
-                                                                 attribute_number)
-                      ]);
-    }
-
-    if ( 0 != ( get_bit_mask & ( 1 << (attribute_number % 8) ) ) ) {
-      OPENER_TRACE_INFO("getAttribute %d\n",
-                        message_router_request->request_path.attribute_number);
-
-      /* create a reply message containing the data*/
-      EncodeData(kCipUsint, &(g_tcpip.mcast_config.alloc_control), message_router_response);
-      EncodeData(kCipUsint, &(g_tcpip.mcast_config.reserved_shall_be_zero), message_router_response);
-      EncodeData(kCipUint, &(g_tcpip.mcast_config.number_of_allocated_multicast_addresses), message_router_response);
-
-      CipUdint multicast_address = ntohl(
-        g_tcpip.mcast_config.starting_multicast_address);
-
-      EncodeData(kCipUdint, &multicast_address, message_router_response);
-      message_router_response->general_status = kCipErrorSuccess;
-    }
-  }
-
-  return kEipStatusOkSend;
-}
-
-EipStatus GetAttributeAllTcpIpInterface(
-  CipInstance *instance,
-  CipMessageRouterRequest *message_router_request,
-  CipMessageRouterResponse *message_router_response,
-  const struct sockaddr *originator_address,
-  const int encapsulation_session) {
-
-  CipAttributeStruct *attribute = instance->attributes;
-
-  for (size_t j = 0; j < instance->cip_class->number_of_attributes; j++) /* for each instance attribute of this class */
-  {
-    int attribute_number = attribute->attribute_number;
-    if (attribute_number < 32) /* only return attributes that are flagged as being part of GetAttributeALl */
-    {
-      message_router_request->request_path.attribute_number = attribute_number;
-
-      if (8 == attribute_number) { /* insert 6 zeros for the required empty safety network number according to Table 5-3.10 */
-    	FillNextNMessageOctetsWithValueAndMoveToNextPosition(0, 6, &message_router_response->message);
-      }
-
-      if ( kEipStatusOkSend
-           != GetAttributeSingleTcpIpInterface(instance, message_router_request,
-                                               message_router_response,
-                                               originator_address,
-                                               encapsulation_session) ) {
-        return kEipStatusError;
-      }
-
-      if (9 == attribute_number) {
-        /* returning default value for unimplemented attributes 10,11 and 12 */
-
-        /* attribute 10, type: BOOL, default value: 0 */
-        //message_router_response->data += 6;
-    	AddSintToMessage(0, &message_router_response->message);
-
-
-        /* attribute 11, type: STRUCT OF USINT, ARRAY of 6 USINTs, ARRAY of 28 USINTs default value: 0 */
-    	const size_t kAttribute11Size = sizeof(CipUsint) + 6 * sizeof(CipUsint) + 28 * sizeof(CipUsint);
-    	OPENER_ASSERT(kAttribute11Size == 35);
-    	FillNextNMessageOctetsWithValueAndMoveToNextPosition(0, kAttribute11Size, &message_router_response->message);
-
-        /* attribute 12, type: BOOL default value: 0 */
-    	AddSintToMessage(0, &message_router_response->message);
-      }
-
-    }
-    attribute++;
-  }
-  return kEipStatusOkSend;
-}
-
 /**
  *  This function calculates the multicast base address to be used for CIP
  *  connections from the current IP setting. The algorithm is implemented

source/src/cip/ciptcpipinterface.h

@@ -56,7 +56,7 @@ typedef struct {
 
   /** #9 The multicast configuration for this device */
   MulticastAddressConfiguration mcast_config;
-  CipBool select_acd;
+  CipBool select_acd; /**< attribute #10 - Is ACD enabled? */
 
   /** #13 Number of seconds of inactivity before TCP connection is closed */
   CipUint encapsulation_inactivity_timeout;

source/src/cip/ciptypes.h

@@ -57,8 +57,7 @@ typedef enum cip_data_types {
   kCipByteArray = 0xA4, /**< */
   kInternalUint6 = 0xF0, /**< bogus hack, for port class attribute 9, TODO
                            figure out the right way to handle it */
-  kCipStringI,
-  kCipFileRevisionStruct
+  kCipStringI
 } CipDataType;
 
 /** @brief Definition of CIP service codes
@@ -166,7 +165,7 @@ typedef struct {
 typedef struct cip_type_string_i_struct CipStringIStruct;
 
 typedef struct cip_string_i {
-  CipUsint number;
+  CipUsint number_of_strings;
   CipStringIStruct* array_of_string_i_structs;
 } CipStringI;
 
@@ -260,7 +259,7 @@ typedef struct {
   EipUint16 additional_status[MAX_SIZE_OF_ADD_STATUS]; /**< Array of 16 bit words; Additional status;
                                                           If SizeOfAdditionalStatus is 0. there is no
                                                           Additional Status */
-  ENIPMessage message; /* The construct message */
+  ENIPMessage message; /* The constructed message */
 } CipMessageRouterResponse;
 
 /** @brief self-describing data encoding for CIP types */

source/src/enet_encap/cpf.c

@@ -384,11 +384,9 @@ void EncodeDataItemLength(
 void EncodeDataItemData(
   const CipCommonPacketFormatData *const common_packet_format_data_item,
   ENIPMessage *const outgoing_message) {
-  for (size_t i = 0; i < common_packet_format_data_item->data_item.length;
-       i++) {
-    AddSintToMessage(*(common_packet_format_data_item->data_item.data + i),
-      outgoing_message);
-  }
+  memcpy(outgoing_message->current_message_position, common_packet_format_data_item->data_item.data, common_packet_format_data_item->data_item.length);
+  outgoing_message->current_message_position += common_packet_format_data_item->data_item.length;
+  outgoing_message->used_message_length += common_packet_format_data_item->data_item.length;
 }
 
 /**
@@ -401,7 +399,6 @@ void EncodeDataItemData(
 void EncodeConnectedDataItemLength(
   const CipMessageRouterResponse *const message_router_response,
   ENIPMessage *const outgoing_message) {
-
   AddIntToMessage((EipUint16) ( message_router_response->message.used_message_length + 4 + 2  /* TODO: Magic numbers */
                   + (2 * message_router_response->size_of_additional_status) ), outgoing_message);
 }
@@ -523,9 +520,6 @@ void EncodeUnconnectedDataItemLength(
 void EncodeMessageRouterResponseData(
   const CipMessageRouterResponse *const message_router_response,
   ENIPMessage *const outgoing_message) {
-//  for (size_t i = 0; i < message_router_response->message.used_message_length; i++) {
-//    AddSintToMessage( (message_router_response->message.message_buffer)[i], outgoing_message);
-//  }
   memcpy(outgoing_message->current_message_position, message_router_response->message.message_buffer, message_router_response->message.used_message_length);
 
   outgoing_message->current_message_position += message_router_response->message.used_message_length;

source/src/enet_encap/encap.c

@@ -347,6 +347,8 @@ void HandleReceivedListServicesCommand(
   memcpy(outgoing_message->current_message_position,
          g_service_information.name_of_service,
          sizeof(g_service_information.name_of_service) );
+  outgoing_message->current_message_position +=
+    sizeof(g_service_information.name_of_service);
   outgoing_message->used_message_length +=
     sizeof(g_service_information.name_of_service);
 }
@@ -433,6 +435,7 @@ void EncodeListIdentityCipIdentityItem(ENIPMessage *const outgoing_message) {
   AddIntToMessage(g_identity.status, outgoing_message);
   AddDintToMessage(g_identity.serial_number, outgoing_message);
   AddSintToMessage((unsigned char) g_identity.product_name.length, outgoing_message);
+//TODO Change to EncodeCipString
   memcpy(outgoing_message->current_message_position,
          g_identity.product_name.string,
          g_identity.product_name.length);

source/src/enet_encap/endianconv.h

@@ -109,7 +109,7 @@ void AddLintToMessage(const EipUint64 pa_unData,
  */
 void EncapsulateIpAddress(EipUint16 port,
                          EipUint32 address,
-						 ENIPMessage *const outgoing_message);
+			 ENIPMessage *const outgoing_message);
 
 /** Identify if we are running on a big or little endian system and set
  * variable.
@@ -125,11 +125,11 @@ void DetermineEndianess(void);
 int GetEndianess(void);
 
 void MoveMessageNOctets(const int amount_of_bytes_moved,
-		ENIPMessage *const outgoing_message);
+		        ENIPMessage *const outgoing_message);
 
 void FillNextNMessageOctetsWith(CipOctet value,
                                unsigned int amount_of_bytes_written,
-							   ENIPMessage *const outgoing_message);
+			       ENIPMessage *const outgoing_message);
 
 void FillNextNMessageOctetsWithValueAndMoveToNextPosition(CipOctet value, unsigned int amount_of_filled_bytes, ENIPMessage *const outgoing_message);
 

source/src/opener_api.h

@@ -229,16 +229,11 @@ CipInstance *AddCipInstance(CipClass *RESTRICT const cip_class_to_add_instance,
  *  @param cip_instance Pointer to CIP class instance (Instance 0)
  *  @param attribute_number Number of attribute to be inserted.
  *  @param cip_data_type Type of attribute to be inserted.
+ *  @param encode_function Function pointer to the encoding function
  *  @param cip_data Pointer to data of attribute.
  *  @param cip_flags Flags to indicate set-ability and get-ability of attribute.
  */
-void InsertAttribute(CipInstance *const cip_instance,
-                     const EipUint16 attribute_number,
-                     const EipUint8 cip_data_type,
-                     void *const cip_data,
-                     const EipByte cip_flags);
-
-void InsertAttribute2(CipInstance *const instance,
+void InsertAttribute(CipInstance *const instance,
                      const EipUint16 attribute_number,
                      const EipUint8 cip_type,
 					 CipAttributeEncodeInMessage encode_function,
@@ -317,24 +312,48 @@ void EncodeData(const EipUint8 cip_data_type,
 
 void EncodeCipBool(const void *const data, ENIPMessage *const outgoing_message);
 
+void EncodeCipByte(const void *const data, ENIPMessage *const outgoing_message);
+
+void EncodeCipWord(const void *const data, ENIPMessage *const outgoing_message);
+
+void EncodeCipDword(const void *const data, ENIPMessage *const outgoing_message);
+
+void EncodeCipLword(const void *const data, ENIPMessage *const outgoing_message);
+
 void EncodeCipUsint(const void *const data, ENIPMessage *const outgoing_message);
 
 void EncodeCipUint(const void *const data, ENIPMessage *const outgoing_message);
 
 void EncodeCipUdint(const void *const data, ENIPMessage *const outgoing_message);
 
-void EncodeCipWord(const void *const data, ENIPMessage *const outgoing_message);
+void EncodeCipUlint(const void *const data, ENIPMessage *const outgoing_message);
 
-void EncodeCipDword(const void *const data, ENIPMessage *const outgoing_message);
+void EncodeCipSint(const void *const data, ENIPMessage *const outgoing_message);
+
+void EncodeCipInt(const void *const data, ENIPMessage *const outgoing_message);
+
+void EncodeCipDint(const void *const data, ENIPMessage *const outgoing_message);
+
+void EncodeCipLint(const void *const data, ENIPMessage *const outgoing_message);
+
+void EncodeCipReal(const void *const data, ENIPMessage *const outgoing_message);
+
+void EncodeCipLreal(const void *const data, ENIPMessage *const outgoing_message);
 
 void EncodeCipShortString(const void *const data, ENIPMessage *const outgoing_message);
 
 void EncodeCipString(const void *const data, ENIPMessage *const outgoing_message);
 
+void EncodeCipString2(const void *const data, ENIPMessage *const outgoing_message);
+
+void EncodeCipStringN(const void *const data, ENIPMessage *const outgoing_message);
+
 void EncodeCipByteArray(const void *const data, ENIPMessage *const outgoing_message);
 
 void EncodeCipEPath(const void *const data, ENIPMessage *const outgoing_message);
 
+void EncodeCipEthernetLinkPhyisicalAddress(const void *const data, ENIPMessage *const outgoing_message);
+
 /** @ingroup CIP_API
  * @brief Retrieve the given data according to CIP encoding from the message
  * buffer.