Uncrustify auto formatter

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

source/src/cip/appcontype.c

@@ -28,7 +28,8 @@ typedef struct {
   unsigned int output_assembly; /**< the O-to-T point for the connection */
   unsigned int input_assembly; /**< the T-to-O point for the connection */
   unsigned int config_assembly; /**< the config point for the connection */
-  CipConnectionObject connection_data[OPENER_CIP_NUM_INPUT_ONLY_CONNS_PER_CON_PATH]; /*< the connection data */
+  CipConnectionObject connection_data[
+    OPENER_CIP_NUM_INPUT_ONLY_CONNS_PER_CON_PATH];                                   /*< the connection data */
 } InputOnlyConnection;
 
 /** @brief Listen Only connection data */
@@ -36,7 +37,8 @@ typedef struct {
   unsigned int output_assembly; /**< the O-to-T point for the connection */
   unsigned int input_assembly; /**< the T-to-O point for the connection */
   unsigned int config_assembly; /**< the config point for the connection */
-  CipConnectionObject connection_data[OPENER_CIP_NUM_LISTEN_ONLY_CONNS_PER_CON_PATH
+  CipConnectionObject connection_data[
+    OPENER_CIP_NUM_LISTEN_ONLY_CONNS_PER_CON_PATH
   ];                                                                               /**< the connection data */
 } ListenOnlyConnection;
 
@@ -146,18 +148,21 @@ CipConnectionObject *GetIoConnectionForConnectionData(
             *extended_error =
               kConnectionManagerExtendedStatusCodeInconsistentApplicationPathCombo;
           } else {
-            ConnectionObjectSetInstanceType(connection_object, kConnectionObjectInstanceTypeIOListenOnly);
-                //Is listen only connection
+            ConnectionObjectSetInstanceType(connection_object,
+                                            kConnectionObjectInstanceTypeIOListenOnly);
+            //Is listen only connection
             //connection_object->instance_type = kConnectionTypeIoListenOnly;
           }
         }
       } else {
-        ConnectionObjectSetInstanceType(connection_object, kConnectionObjectInstanceTypeIOInputOnly);
+        ConnectionObjectSetInstanceType(connection_object,
+                                        kConnectionObjectInstanceTypeIOInputOnly);
         //is Input only connection
       }
     }
   } else {
-    ConnectionObjectSetInstanceType(connection_object, kConnectionObjectInstanceTypeIOExclusiveOwner);
+    ConnectionObjectSetInstanceType(connection_object,
+                                    kConnectionObjectInstanceTypeIOExclusiveOwner);
     //Is exclusive owner connection
     //connection_object->instance_type = kConnectionTypeIoExclusiveOwner;
   }
@@ -175,7 +180,7 @@ CipConnectionObject *GetExclusiveOwnerConnection(
 
   for (size_t i = 0; i < OPENER_CIP_NUM_EXLUSIVE_OWNER_CONNS; ++i) {
     if ( (g_exlusive_owner_connections[i].output_assembly ==
-         connection_object->consumed_path.instance_id)
+          connection_object->consumed_path.instance_id)
          && (g_exlusive_owner_connections[i].input_assembly ==
              connection_object->produced_path.instance_id)
          && (g_exlusive_owner_connections[i].config_assembly ==
@@ -217,9 +222,11 @@ CipConnectionObject *GetInputOnlyConnection(
         break;
       }
 
-      for (size_t j = 0; j < OPENER_CIP_NUM_INPUT_ONLY_CONNS_PER_CON_PATH; ++j) {
+      for (size_t j = 0; j < OPENER_CIP_NUM_INPUT_ONLY_CONNS_PER_CON_PATH;
+           ++j) {
         if (kConnectionObjectStateNonExistent
-            == ConnectionObjectGetState(&(g_input_only_connections[i].connection_data[j]))) {
+            == ConnectionObjectGetState(&(g_input_only_connections[i].
+                                          connection_data[j]) ) ) {
           return &(g_input_only_connections[i].connection_data[j]);
         }
       }
@@ -269,7 +276,8 @@ CipConnectionObject *GetListenOnlyConnection(
 
       for (int j = 0; j < OPENER_CIP_NUM_LISTEN_ONLY_CONNS_PER_CON_PATH; j++) {
         if (kConnectionObjectStateNonExistent
-            == ConnectionObjectGetState(&(g_listen_only_connections[i].connection_data[j]))) {
+            == ConnectionObjectGetState(&(g_listen_only_connections[i].
+                                          connection_data[j]) ) ) {
           return &(g_listen_only_connections[i].connection_data[j]);
         }
       }
@@ -286,12 +294,14 @@ CipConnectionObject *GetExistingProducerMulticastConnection(
   DoublyLinkedListNode *node = connection_list.first;
 
   while (NULL != node) {
-  CipConnectionObject *producer_multicast_connection = node->data;
-    if ( true == ConnectionObjectIsTypeIOConnection(producer_multicast_connection)) {
+    CipConnectionObject *producer_multicast_connection = node->data;
+    if ( true ==
+         ConnectionObjectIsTypeIOConnection(producer_multicast_connection) ) {
       if ( (input_point
             == producer_multicast_connection->produced_path.instance_id)
            && ( kConnectionObjectConnectionTypeMulticast
-                == ConnectionObjectGetTToOConnectionType(producer_multicast_connection) )
+                == ConnectionObjectGetTToOConnectionType(
+                  producer_multicast_connection) )
            && (kEipInvalidSocket
                != producer_multicast_connection->socket[
                  kUdpCommuncationDirectionProducing]) ) {
@@ -306,19 +316,21 @@ CipConnectionObject *GetExistingProducerMulticastConnection(
   return NULL;
 }
 
-CipConnectionObject *GetNextNonControlMasterConnection(const EipUint32 input_point)
-{
+CipConnectionObject *GetNextNonControlMasterConnection(
+  const EipUint32 input_point) {
   DoublyLinkedListNode *node = connection_list.first;
 
   while (NULL != node) {
-  CipConnectionObject *next_non_control_master_connection =
-    node->data;
-    if ( true == ConnectionObjectIsTypeIOConnection(next_non_control_master_connection)
+    CipConnectionObject *next_non_control_master_connection =
+      node->data;
+    if ( true ==
+         ConnectionObjectIsTypeIOConnection(next_non_control_master_connection)
          ) {
       if ( (input_point
             == next_non_control_master_connection->produced_path.instance_id)
            && ( kConnectionObjectConnectionTypeMulticast
-                == ConnectionObjectGetTToOConnectionType(next_non_control_master_connection) )
+                == ConnectionObjectGetTToOConnectionType(
+                  next_non_control_master_connection) )
            && (kEipInvalidSocket
                == next_non_control_master_connection->socket[
                  kUdpCommuncationDirectionProducing]) ) {
@@ -340,7 +352,7 @@ void CloseAllConnectionsForInputWithSameType(const EipUint32 input_point,
   DoublyLinkedListNode *node = connection_list.first;
 
   while (NULL != node) {
-  CipConnectionObject *connection = node->data;
+    CipConnectionObject *connection = node->data;
     if ( (instance_type == connection->instance_type)
          && (input_point == connection->produced_path.instance_id) ) {
       CipConnectionObject *connection_to_delete = connection;
@@ -360,9 +372,9 @@ void CloseAllConnectionsForInputWithSameType(const EipUint32 input_point,
 }
 
 void CloseAllConnections(void) {
-	DoublyLinkedListNode *node = connection_list.first;
+  DoublyLinkedListNode *node = connection_list.first;
   while (NULL != node) {
-  CipConnectionObject *connection = node->data;
+    CipConnectionObject *connection = node->data;
     assert(connection->connection_close_function != NULL);
     connection->connection_close_function(connection);
     //CloseConnection(connection);
@@ -377,7 +389,7 @@ bool ConnectionWithSameConfigPointExists(const EipUint32 config_point) {
   DoublyLinkedListNode *node = connection_list.first;
 
   while (NULL != node) {
-  CipConnectionObject *connection = node->data;
+    CipConnectionObject *connection = node->data;
     if (config_point == connection->configuration_path.instance_id) {
       return (NULL != connection);
     }

source/src/cip/cipconnectionobject.c

@@ -598,8 +598,7 @@ CipUdint ConnectionObjectGetOToTRequestedPacketInterval(
 
 void ConnectionObjectSetOToTRequestedPacketInterval(
   CipConnectionObject *connection_object,
-  const CipUdint requested_packet_interval)
-{
+  const CipUdint requested_packet_interval) {
   connection_object->o_to_t_requested_packet_interval =
     requested_packet_interval;
 }
@@ -611,8 +610,7 @@ CipUdint ConnectionObjectGetTToORequestedPacketInterval(
 
 void ConnectionObjectSetTToORequestedPacketInterval(
   CipConnectionObject *connection_object,
-  const CipUdint requested_packet_interval)
-{
+  const CipUdint requested_packet_interval) {
   connection_object->t_to_o_requested_packet_interval =
     requested_packet_interval;
 }

source/src/ports/POSIX/main.c

@@ -27,7 +27,8 @@ void LeaveStack(int signal);
 int g_end_stack = 0;
 
 /******************************************************************************/
-int main(int argc, char *arg[]) {
+int main(int argc,
+         char *arg[]) {
   EipUint8 my_mac_address[6];
   EipUint16 unique_connection_id;
 
@@ -40,7 +41,9 @@ int main(int argc, char *arg[]) {
       "    e.g. ./OpENer 192.168.0.2 255.255.255.0 192.168.0.1 test.com testdevice 00 15 C5 BF D0 87\n");
     exit(0);
   } else {
-	  DoublyLinkedListInitialize(&connection_list, CipConnectionObjectListArrayAllocator, CipConnectionObjectListArrayFree);
+    DoublyLinkedListInitialize(&connection_list,
+                               CipConnectionObjectListArrayAllocator,
+                               CipConnectionObjectListArrayFree);
     /* fetch Internet address info from the platform */
     ConfigureNetworkInterface(arg[1], arg[2], arg[3]);
     ConfigureDomainName(arg[4]);

source/tests/cip/cipconnectionobjecttest.cpp

@@ -76,7 +76,8 @@ TEST(CipConnectionObject, StateInvalid) {
 
 TEST(CipConnectionObject, InstanceTypeIExplicitMessaging) {
   CipConnectionObject connection_object = { 0 };
-  connection_object.instance_type = kConnectionObjectInstanceTypeExplicitMessaging;
+  connection_object.instance_type =
+    kConnectionObjectInstanceTypeExplicitMessaging;
   CipUsint value = ConnectionObjectGetInstanceTypeForAttribute(
     &connection_object);
   CHECK_EQUAL(0, value);
@@ -86,15 +87,16 @@ TEST(CipConnectionObject, InstanceTypeIO) {
   CipConnectionObject connection_object = { 0 };
   connection_object.instance_type = kConnectionObjectInstanceTypeIO;
   CipUsint value = ConnectionObjectGetInstanceTypeForAttribute(
-      &connection_object);
+    &connection_object);
   CHECK_EQUAL(1, value);
 }
 
 TEST(CipConnectionObject, InstanceTypeIOExclusiveOwner) {
   CipConnectionObject connection_object = { 0 };
-  connection_object.instance_type = kConnectionObjectInstanceTypeIOExclusiveOwner;
+  connection_object.instance_type =
+    kConnectionObjectInstanceTypeIOExclusiveOwner;
   CipUsint value = ConnectionObjectGetInstanceTypeForAttribute(
-      &connection_object);
+    &connection_object);
   CHECK_EQUAL(1, value);
 }
 
@@ -102,7 +104,7 @@ TEST(CipConnectionObject, InstanceTypeIOInputOnly) {
   CipConnectionObject connection_object = { 0 };
   connection_object.instance_type = kConnectionObjectInstanceTypeIOInputOnly;
   CipUsint value = ConnectionObjectGetInstanceTypeForAttribute(
-      &connection_object);
+    &connection_object);
   CHECK_EQUAL(1, value);
 }
 
@@ -110,7 +112,7 @@ TEST(CipConnectionObject, InstanceTypeIOListenOnly) {
   CipConnectionObject connection_object = { 0 };
   connection_object.instance_type = kConnectionObjectInstanceTypeIOListenOnly;
   CipUsint value = ConnectionObjectGetInstanceTypeForAttribute(
-      &connection_object);
+    &connection_object);
   CHECK_EQUAL(1, value);
 }
 
@@ -118,7 +120,7 @@ TEST(CipConnectionObject, InstanceTypeCipBridged) {
   CipConnectionObject connection_object = { 0 };
   connection_object.instance_type = kConnectionObjectInstanceTypeCipBridged;
   CipUsint value = ConnectionObjectGetInstanceTypeForAttribute(
-      &connection_object);
+    &connection_object);
   CHECK_EQUAL(2, value);
 }
 
@@ -256,76 +258,102 @@ TEST(CipConnectionObject, ExpectedPacketRateZero) {
 
 TEST(CipConnectionObject, ParseConnectionData) {
   CipConnectionObject connection_object = { 0 };
-  const CipOctet message[] = "\x06\x28\x00\x00\x00\x00\x00\x00\x00\x00\x98\xff\x18\x00\x78\x56" \
-"\x34\x12\x00\x00\x00\x00\xe0\x93\x04\x00\x02\x40\xa0\x86\x01\x00" \
-"\x22\x20\x01\x04\x20\x04\x24\x97\x2c\x98\x2c\x64";
+  const CipOctet message[] =
+    "\x06\x28\x00\x00\x00\x00\x00\x00\x00\x00\x98\xff\x18\x00\x78\x56" \
+    "\x34\x12\x00\x00\x00\x00\xe0\x93\x04\x00\x02\x40\xa0\x86\x01\x00" \
+    "\x22\x20\x01\x04\x20\x04\x24\x97\x2c\x98\x2c\x64";
 
-  const CipOctet *message_runner = (const CipOctet*)message;
+  const CipOctet *message_runner = (const CipOctet *)message;
 
   ConnectionObjectInitializeFromMessage(&message_runner, &connection_object);
-  CipUdint o_to_t_network_connection_id = ConnectionObjectGetCipConsumedConnectionID(&connection_object);
+  CipUdint o_to_t_network_connection_id =
+    ConnectionObjectGetCipConsumedConnectionID(&connection_object);
   CHECK_EQUAL(0, o_to_t_network_connection_id);
 
-  CipUdint t_to_o_network_connection_id = ConnectionObjectGetCipProducedConnectionID(&connection_object);
+  CipUdint t_to_o_network_connection_id =
+    ConnectionObjectGetCipProducedConnectionID(&connection_object);
   CHECK_EQUAL(0, t_to_o_network_connection_id);
 
-  CipUint connection_serial_number = ConnectionObjectGetConnectionSerialNumber(&connection_object);
+  CipUint connection_serial_number = ConnectionObjectGetConnectionSerialNumber(
+    &connection_object);
   CHECK_EQUAL(0xff98, connection_serial_number);
 
   CipUint vendor_id = ConnectionObjectGetOriginatorVendorId(&connection_object);
   CHECK_EQUAL(0x0018, vendor_id);
 
-  CipUdint originator_serial_number = ConnectionObjectGetOriginatorSerialNumber(&connection_object);
+  CipUdint originator_serial_number = ConnectionObjectGetOriginatorSerialNumber(
+    &connection_object);
   CHECK_EQUAL(0x12345678, originator_serial_number);
 
-  CipUsint connection_timeout_multiplier = ConnectionObjectGetConnectionTimeoutMultiplier(&connection_object);
+  CipUsint connection_timeout_multiplier =
+    ConnectionObjectGetConnectionTimeoutMultiplier(&connection_object);
   CHECK_EQUAL(0, connection_timeout_multiplier);
 
-  CipUdint o_to_t_rpi_in_microseconds = ConnectionObjectGetOToTRequestedPacketInterval(&connection_object);
+  CipUdint o_to_t_rpi_in_microseconds =
+    ConnectionObjectGetOToTRequestedPacketInterval(&connection_object);
   CHECK_EQUAL(300000, o_to_t_rpi_in_microseconds);
 
-  bool o_to_t_redundant_owner = ConnectionObjectIsOToTRedundantOwner(&connection_object);
+  bool o_to_t_redundant_owner = ConnectionObjectIsOToTRedundantOwner(
+    &connection_object);
   CHECK_EQUAL(false, o_to_t_redundant_owner);
 
-  ConnectionObjectConnectionType o_to_t_connection_type = ConnectionObjectGetOToTConnectionType(&connection_object);
-  CHECK_EQUAL(kConnectionObjectConnectionTypePointToPoint, o_to_t_connection_type);
+  ConnectionObjectConnectionType o_to_t_connection_type =
+    ConnectionObjectGetOToTConnectionType(&connection_object);
+  CHECK_EQUAL(kConnectionObjectConnectionTypePointToPoint,
+              o_to_t_connection_type);
 
-  ConnectionObjectPriority o_to_t_priority = ConnectionObjectGetOToTPriority(&connection_object);
+  ConnectionObjectPriority o_to_t_priority = ConnectionObjectGetOToTPriority(
+    &connection_object);
   CHECK_EQUAL(kConnectionObjectPriorityLow, o_to_t_priority);
 
-  ConnectionObjectConnectionSizeType o_to_t_connection_size_type = ConnectionObjectGetOToTConnectionSizeType(&connection_object);
-  CHECK_EQUAL(kConnectionObjectConnectionSizeTypeFixed, o_to_t_connection_size_type);
+  ConnectionObjectConnectionSizeType o_to_t_connection_size_type =
+    ConnectionObjectGetOToTConnectionSizeType(&connection_object);
+  CHECK_EQUAL(kConnectionObjectConnectionSizeTypeFixed,
+              o_to_t_connection_size_type);
 
-  size_t o_to_t_connection_size = ConnectionObjectGetOToTConnectionSize(&connection_object);
+  size_t o_to_t_connection_size = ConnectionObjectGetOToTConnectionSize(
+    &connection_object);
   CHECK_EQUAL(2ULL, o_to_t_connection_size);
 
   //T to O Tests
 
-  CipUdint t_to_o_rpi_in_microseconds = ConnectionObjectGetTToORequestedPacketInterval(&connection_object);
+  CipUdint t_to_o_rpi_in_microseconds =
+    ConnectionObjectGetTToORequestedPacketInterval(&connection_object);
   CHECK_EQUAL(100000, t_to_o_rpi_in_microseconds);
 
-  bool t_to_o_redundant_owner = ConnectionObjectIsTToORedundantOwner(&connection_object);
+  bool t_to_o_redundant_owner = ConnectionObjectIsTToORedundantOwner(
+    &connection_object);
   CHECK_EQUAL(false, t_to_o_redundant_owner);
 
-  ConnectionObjectConnectionType t_to_o_connection_type = ConnectionObjectGetTToOConnectionType(&connection_object);
+  ConnectionObjectConnectionType t_to_o_connection_type =
+    ConnectionObjectGetTToOConnectionType(&connection_object);
   CHECK_EQUAL(kConnectionObjectConnectionTypeMulticast, t_to_o_connection_type);
 
-  ConnectionObjectPriority t_to_o_priority = ConnectionObjectGetTToOPriority(&connection_object);
+  ConnectionObjectPriority t_to_o_priority = ConnectionObjectGetTToOPriority(
+    &connection_object);
   CHECK_EQUAL(kConnectionObjectPriorityLow, t_to_o_priority);
 
-  ConnectionObjectConnectionSizeType t_to_o_connection_size_type = ConnectionObjectGetTToOConnectionSizeType(&connection_object);
-  CHECK_EQUAL(kConnectionObjectConnectionSizeTypeFixed, t_to_o_connection_size_type);
+  ConnectionObjectConnectionSizeType t_to_o_connection_size_type =
+    ConnectionObjectGetTToOConnectionSizeType(&connection_object);
+  CHECK_EQUAL(kConnectionObjectConnectionSizeTypeFixed,
+              t_to_o_connection_size_type);
 
-  size_t t_to_o_connection_size = ConnectionObjectGetTToOConnectionSize(&connection_object);
+  size_t t_to_o_connection_size = ConnectionObjectGetTToOConnectionSize(
+    &connection_object);
   CHECK_EQUAL(34ULL, t_to_o_connection_size);
 
-  ConnectionObjectTransportClassTriggerDirection direction = ConnectionObjectGetTransportClassTriggerDirection(&connection_object);
+  ConnectionObjectTransportClassTriggerDirection direction =
+    ConnectionObjectGetTransportClassTriggerDirection(&connection_object);
   CHECK_EQUAL(kConnectionObjectTransportClassTriggerDirectionClient, direction);
 
-  ConnectionObjectTransportClassTriggerProductionTrigger trigger = ConnectionObjectGetTransportClassTriggerProductionTrigger(&connection_object);
-  CHECK_EQUAL(kConnectionObjectTransportClassTriggerProductionTriggerCyclic, trigger);
+  ConnectionObjectTransportClassTriggerProductionTrigger trigger =
+    ConnectionObjectGetTransportClassTriggerProductionTrigger(&connection_object);
+  CHECK_EQUAL(kConnectionObjectTransportClassTriggerProductionTriggerCyclic,
+              trigger);
 
-  ConnectionObjectTransportClassTriggerTransportClass transport_class = ConnectionObjectGetTransportClassTriggerTransportClass(&connection_object);
-  CHECK_EQUAL(kConnectionObjectTransportClassTriggerTransportClass1, transport_class);
+  ConnectionObjectTransportClassTriggerTransportClass transport_class =
+    ConnectionObjectGetTransportClassTriggerTransportClass(&connection_object);
+  CHECK_EQUAL(kConnectionObjectTransportClassTriggerTransportClass1,
+              transport_class);
 
 }