indented.

bacnet-stack/apdu.c

@@ -272,8 +272,7 @@ uint16_t apdu_decode_confirmed_service_request(uint8_t * apdu,  /* APDU data */
     return len;
 }
 
-void apdu_handler(BACNET_ADDRESS * src,
+void apdu_handler(BACNET_ADDRESS * src, uint8_t * apdu, /* APDU data */
-    uint8_t * apdu,  /* APDU data */
     uint16_t apdu_len)
 {
     BACNET_CONFIRMED_SERVICE_DATA service_data = { 0 };

bacnet-stack/bacapp.c

@@ -48,8 +48,7 @@ int bacapp_encode_application_data(uint8_t * apdu,
 {
     int apdu_len = 0;           /* total length of the apdu, return value */
 
-    if (value && apdu)
+    if (value && apdu) {
-    {
         switch (value->tag) {
         case BACNET_APPLICATION_TAG_NULL:
             apdu[0] = value->tag;
@@ -68,20 +67,17 @@ int bacapp_encode_application_data(uint8_t * apdu,
                 value->type.Signed_Int);
             break;
         case BACNET_APPLICATION_TAG_REAL:
-                apdu_len = encode_tagged_real(&apdu[0],
+            apdu_len = encode_tagged_real(&apdu[0], value->type.Real);
-                    value->type.Real);
             break;
         case BACNET_APPLICATION_TAG_ENUMERATED:
             apdu_len = encode_tagged_enumerated(&apdu[0],
                 value->type.Enumerated);
             break;
         case BACNET_APPLICATION_TAG_DATE:
-                apdu_len = encode_tagged_date(&apdu[0],
+            apdu_len = encode_tagged_date(&apdu[0], &value->type.Date);
-                    &value->type.Date);
             break;
         case BACNET_APPLICATION_TAG_TIME:
-                apdu_len = encode_tagged_time(&apdu[0],
+            apdu_len = encode_tagged_time(&apdu[0], &value->type.Time);
-                    &value->type.Time);
             break;
         case BACNET_APPLICATION_TAG_OBJECT_ID:
             apdu_len = encode_tagged_object_id(&apdu[0],
@@ -491,6 +487,7 @@ bool bacapp_same_time(BACNET_TIME * time1, BACNET_TIME * time2)
 
     return status;
 }
+
 /* generic - can be used by other unit tests
    returns true if matching or same, false if different */
 bool bacapp_same_value(BACNET_APPLICATION_DATA_VALUE * value,

bacnet-stack/bactext.h

@@ -77,7 +77,5 @@ extern "C" {
 #ifdef __cplusplus
 }
 #endif                          /* __cplusplus */
-
 #endif                          /* BACTEXT_PRINT_ENABLED */
-
 #endif

bacnet-stack/demo/handler/h_arf.c

@@ -76,7 +76,8 @@ void handler_atomic_read_file(uint8_t * service_request,
             if (data.type.stream.requestedOctetCount <
                 octetstring_capacity(&data.fileData)) {
                 if (bacfile_read_data(&data)) {
-                    pdu_len = arf_ack_encode_apdu(&Handler_Transmit_Buffer[0],
+                    pdu_len =
+                        arf_ack_encode_apdu(&Handler_Transmit_Buffer[0],
                         service_data->invoke_id, &data);
                 } else {
                     error = true;
@@ -91,9 +92,11 @@ void handler_atomic_read_file(uint8_t * service_request,
 #endif
             }
         } else {
-            pdu_len = bacerror_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+            pdu_len =
-                service_data->invoke_id, SERVICE_CONFIRMED_ATOMIC_READ_FILE,
+                bacerror_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
-                ERROR_CLASS_SERVICES, ERROR_CODE_INVALID_FILE_ACCESS_METHOD);
+                service_data->invoke_id,
+                SERVICE_CONFIRMED_ATOMIC_READ_FILE, ERROR_CLASS_SERVICES,
+                ERROR_CODE_INVALID_FILE_ACCESS_METHOD);
 #if PRINT_ENABLED
             fprintf(stderr, "Record Access Requested. Sending Error!\n");
 #endif

bacnet-stack/demo/handler/h_arf_a.c

@@ -76,8 +76,7 @@ void handler_atomic_read_file_ack(uint8_t * service_request,
                         data.type.stream.fileStartPosition, SEEK_SET);
                     if (fwrite(octetstring_value(&data.fileData),
                             octetstring_length(&data.fileData), 1,
-                            pFile) != 1)
+                            pFile) != 1) {
-                    {
 #if PRINT_ENABLED
                         fprintf(stderr, "Failed to write to %s (%u)!\n",
                             pFilename, instance);

bacnet-stack/demo/handler/h_rp.c

@@ -99,7 +99,8 @@ void handler_read_property(uint8_t * service_request,
                     data.application_data = &Temp_Buf[0];
                     data.application_data_len = len;
                     /* FIXME: probably need a length limitation sent with encode */
-                    pdu_len = rp_ack_encode_apdu(&Handler_Transmit_Buffer[0],
+                    pdu_len =
+                        rp_ack_encode_apdu(&Handler_Transmit_Buffer[0],
                         service_data->invoke_id, &data);
 #if PRINT_ENABLED
                     fprintf(stderr,
@@ -168,7 +169,8 @@ void handler_read_property(uint8_t * service_request,
                     data.application_data = &Temp_Buf[0];
                     data.application_data_len = len;
                     /* FIXME: probably need a length limitation sent with encode */
-                    pdu_len = rp_ack_encode_apdu(&Handler_Transmit_Buffer[0],
+                    pdu_len =
+                        rp_ack_encode_apdu(&Handler_Transmit_Buffer[0],
                         service_data->invoke_id, &data);
 #if PRINT_ENABLED
                     fprintf(stderr, "Sending Read Property Ack for BO!\n");
@@ -338,8 +340,7 @@ void handler_read_property(uint8_t * service_request,
     }
     if (send) {
         npdu_encode_confirmed_apdu(&npdu_data, MESSAGE_PRIORITY_NORMAL);
-        bytes_sent = datalink_send_pdu(src, &npdu_data,
+        bytes_sent = datalink_send_pdu(src, &npdu_data, &Handler_Transmit_Buffer[0], pdu_len);  /* number of bytes of data */
-            &Handler_Transmit_Buffer[0], pdu_len);      /* number of bytes of data */
 #if PRINT_ENABLED
         if (bytes_sent <= 0)
             fprintf(stderr, "Failed to send PDU (%s)!\n", strerror(errno));

bacnet-stack/demo/handler/s_arfs.c

@@ -74,10 +74,12 @@ uint8_t Send_Atomic_Read_File_Stream(uint32_t device_id,
            we have a way to check for that and update the
            max_apdu in the address binding table. */
         if ((unsigned) pdu_len < max_apdu) {
-            npdu_encode_confirmed_apdu(&npdu_data, MESSAGE_PRIORITY_NORMAL);
+            npdu_encode_confirmed_apdu(&npdu_data,
-            tsm_set_confirmed_unsegmented_transaction(invoke_id,
+                MESSAGE_PRIORITY_NORMAL);
-                &dest, &npdu_data, &Handler_Transmit_Buffer[0], pdu_len);
+            tsm_set_confirmed_unsegmented_transaction(invoke_id, &dest,
-            bytes_sent = datalink_send_pdu(&dest, &npdu_data,
+                &npdu_data, &Handler_Transmit_Buffer[0], pdu_len);
+            bytes_sent =
+                datalink_send_pdu(&dest, &npdu_data,
                 &Handler_Transmit_Buffer[0], pdu_len);
 #if PRINT_ENABLED
             if (bytes_sent <= 0)

bacnet-stack/demo/handler/s_awfs.c

@@ -75,10 +75,12 @@ uint8_t Send_Atomic_Write_File_Stream(uint32_t device_id,
                we have a way to check for that and update the
                max_apdu in the address binding table. */
             if ((unsigned) pdu_len <= max_apdu) {
-                npdu_encode_confirmed_apdu(&npdu_data, MESSAGE_PRIORITY_NORMAL);
+                npdu_encode_confirmed_apdu(&npdu_data,
-                tsm_set_confirmed_unsegmented_transaction(invoke_id,
+                    MESSAGE_PRIORITY_NORMAL);
-                    &dest, &npdu_data, &Handler_Transmit_Buffer[0], pdu_len);
+                tsm_set_confirmed_unsegmented_transaction(invoke_id, &dest,
-                bytes_sent = datalink_send_pdu(&dest, &npdu_data,
+                    &npdu_data, &Handler_Transmit_Buffer[0], pdu_len);
+                bytes_sent =
+                    datalink_send_pdu(&dest, &npdu_data,
                     &Handler_Transmit_Buffer[0], pdu_len);
 #if PRINT_ENABLED
                 if (bytes_sent <= 0)
@@ -108,4 +110,3 @@ uint8_t Send_Atomic_Write_File_Stream(uint32_t device_id,
 
     return invoke_id;
 }
-

bacnet-stack/demo/handler/s_dcc.c

@@ -73,10 +73,12 @@ uint8_t Send_Device_Communication_Control_Request(uint32_t device_id, uint16_t t
            we have a way to check for that and update the
            max_apdu in the address binding table. */
         if ((unsigned) pdu_len < max_apdu) {
-            npdu_encode_confirmed_apdu(&npdu_data, MESSAGE_PRIORITY_NORMAL);
+            npdu_encode_confirmed_apdu(&npdu_data,
-            tsm_set_confirmed_unsegmented_transaction(invoke_id,
+                MESSAGE_PRIORITY_NORMAL);
-                &dest, &npdu_data, &Handler_Transmit_Buffer[0], pdu_len);
+            tsm_set_confirmed_unsegmented_transaction(invoke_id, &dest,
-            bytes_sent = datalink_send_pdu(&dest, &npdu_data,
+                &npdu_data, &Handler_Transmit_Buffer[0], pdu_len);
+            bytes_sent =
+                datalink_send_pdu(&dest, &npdu_data,
                 &Handler_Transmit_Buffer[0], pdu_len);
 #if PRINT_ENABLED
             if (bytes_sent <= 0)

bacnet-stack/demo/handler/s_ihave.c

@@ -67,8 +67,7 @@ void Send_I_Have(uint32_t device_id,
     pdu_len = ihave_encode_apdu(&Handler_Transmit_Buffer[0], &data);
     /* send the data */
     npdu_encode_unconfirmed_apdu(&npdu_data, MESSAGE_PRIORITY_NORMAL);
-    bytes_sent = datalink_send_pdu(&dest, &npdu_data,
+    bytes_sent = datalink_send_pdu(&dest, &npdu_data, &Handler_Transmit_Buffer[0], pdu_len);    /* number of bytes of data */
-        &Handler_Transmit_Buffer[0], pdu_len);  /* number of bytes of data */
 #if PRINT_ENABLED
     if (bytes_sent <= 0)
         fprintf(stderr, "Failed to Send I-Have Reply (%s)!\n",

bacnet-stack/demo/handler/s_rd.c

@@ -73,10 +73,12 @@ uint8_t Send_Reinitialize_Device_Request(uint32_t device_id,
            we have a way to check for that and update the
            max_apdu in the address binding table. */
         if ((unsigned) pdu_len < max_apdu) {
-            npdu_encode_confirmed_apdu(&npdu_data, MESSAGE_PRIORITY_NORMAL);
+            npdu_encode_confirmed_apdu(&npdu_data,
-            tsm_set_confirmed_unsegmented_transaction(invoke_id,
+                MESSAGE_PRIORITY_NORMAL);
-                &dest, &npdu_data, &Handler_Transmit_Buffer[0], pdu_len);
+            tsm_set_confirmed_unsegmented_transaction(invoke_id, &dest,
-            bytes_sent = datalink_send_pdu(&dest, &npdu_data,
+                &npdu_data, &Handler_Transmit_Buffer[0], pdu_len);
+            bytes_sent =
+                datalink_send_pdu(&dest, &npdu_data,
                 &Handler_Transmit_Buffer[0], pdu_len);
 #if PRINT_ENABLED
             if (bytes_sent <= 0)

bacnet-stack/demo/handler/s_rp.c

@@ -79,10 +79,12 @@ uint8_t Send_Read_Property_Request(uint32_t device_id,  /* destination device */
            we have a way to check for that and update the
            max_apdu in the address binding table. */
         if ((unsigned) pdu_len < max_apdu) {
-            npdu_encode_confirmed_apdu(&npdu_data, MESSAGE_PRIORITY_NORMAL);
+            npdu_encode_confirmed_apdu(&npdu_data,
-            tsm_set_confirmed_unsegmented_transaction(invoke_id,
+                MESSAGE_PRIORITY_NORMAL);
-                &dest, &npdu_data, &Handler_Transmit_Buffer[0], pdu_len);
+            tsm_set_confirmed_unsegmented_transaction(invoke_id, &dest,
-            bytes_sent = datalink_send_pdu(&dest, &npdu_data,
+                &npdu_data, &Handler_Transmit_Buffer[0], pdu_len);
+            bytes_sent =
+                datalink_send_pdu(&dest, &npdu_data,
                 &Handler_Transmit_Buffer[0], pdu_len);
 #if PRINT_ENABLED
             if (bytes_sent <= 0)

bacnet-stack/demo/handler/s_whohas.c

@@ -62,8 +62,7 @@ void Send_WhoHas_Name(int32_t low_limit,
     data.high_limit = high_limit;
     data.object_name = true;
     characterstring_init_ansi(&data.object.name, object_name);
-    pdu_len = whohas_encode_apdu(&Handler_Transmit_Buffer[0],
+    pdu_len = whohas_encode_apdu(&Handler_Transmit_Buffer[0], &data);
-        &data);
     npdu_encode_unconfirmed_apdu(&npdu_data, MESSAGE_PRIORITY_NORMAL);
     /* send the data */
     bytes_sent = datalink_send_pdu(&dest, &npdu_data,

bacnet-stack/demo/handler/s_wp.c

@@ -83,10 +83,12 @@ uint8_t Send_Write_Property_Request(uint32_t device_id, /* destination device */
            we have a way to check for that and update the
            max_apdu in the address binding table. */
         if ((unsigned) pdu_len < max_apdu) {
-            npdu_encode_confirmed_apdu(&npdu_data, MESSAGE_PRIORITY_NORMAL);
+            npdu_encode_confirmed_apdu(&npdu_data,
-            tsm_set_confirmed_unsegmented_transaction(invoke_id,
+                MESSAGE_PRIORITY_NORMAL);
-                &dest, &npdu_data, &Handler_Transmit_Buffer[0], pdu_len);
+            tsm_set_confirmed_unsegmented_transaction(invoke_id, &dest,
-            bytes_sent = datalink_send_pdu(&dest, &npdu_data,
+                &npdu_data, &Handler_Transmit_Buffer[0], pdu_len);
+            bytes_sent =
+                datalink_send_pdu(&dest, &npdu_data,
                 &Handler_Transmit_Buffer[0], pdu_len);
 #if PRINT_ENABLED
             if (bytes_sent <= 0)

bacnet-stack/demo/object/bacfile.c

@@ -312,12 +312,12 @@ uint32_t bacfile_instance_from_tsm(uint8_t invokeID)
     found = tsm_get_transaction_pdu(invokeID, &dest, &npdu_data, &apdu[0],
         &apdu_len);
     if (found) {
-        if (!npdu_data.network_layer_message && npdu_data.confirmed_message &&
+        if (!npdu_data.network_layer_message && npdu_data.confirmed_message
-            (apdu[0] == PDU_TYPE_CONFIRMED_SERVICE_REQUEST)) {
+            && (apdu[0] == PDU_TYPE_CONFIRMED_SERVICE_REQUEST)) {
-            len = apdu_decode_confirmed_service_request(&apdu[0],
+            len =
-                apdu_len - apdu_offset,
+                apdu_decode_confirmed_service_request(&apdu[0],
-                &service_data,
+                apdu_len - apdu_offset, &service_data, &service_choice,
-                &service_choice, &service_request, &service_request_len);
+                &service_request, &service_request_len);
             if (service_choice == SERVICE_CONFIRMED_ATOMIC_READ_FILE) {
                 len = arf_decode_service_request(service_request,
                     service_request_len, &data);

bacnet-stack/demo/readfile/readfile.c

@@ -239,7 +239,8 @@ int main(int argc, char *argv[])
     timeout_seconds = (Device_APDU_Timeout() / 1000) *
         Device_Number_Of_APDU_Retries();
     /* try to bind with the device */
-    Send_WhoIs(Target_Device_Object_Instance,Target_Device_Object_Instance);
+    Send_WhoIs(Target_Device_Object_Instance,
+        Target_Device_Object_Instance);
     /* loop forever */
     for (;;) {
         /* increment timer - exit if timed out */

bacnet-stack/demo/writefile/writefile.c

@@ -195,7 +195,8 @@ int main(int argc, char *argv[])
     timeout_seconds = (Device_APDU_Timeout() / 1000) *
         Device_Number_Of_APDU_Retries();
     /* try to bind with the device */
-    Send_WhoIs(Target_Device_Object_Instance,Target_Device_Object_Instance);
+    Send_WhoIs(Target_Device_Object_Instance,
+        Target_Device_Object_Instance);
     /* loop forever */
     for (;;) {
         /* increment timer - exit if timed out */

bacnet-stack/dlmstp.h

@@ -44,8 +44,7 @@
 #define MAX_HEADER (2+1+1+1+2+1+2+1)
 #define MAX_MPDU (MAX_HEADER+MAX_PDU)
 
-typedef struct dlmstp_packet
+typedef struct dlmstp_packet {
-{
     bool ready;                 /* true if ready to be sent or received */
     bool data_expecting_reply;
     BACNET_ADDRESS address;     /* src or dest address */

bacnet-stack/iam.c

@@ -151,8 +151,7 @@ int iam_send(uint8_t * buffer)
     /* encode the NPDU portion of the packet */
     npdu_encode_unconfirmed_apdu(&npdu_data, MESSAGE_PRIORITY_NORMAL);
     /* send data */
-    bytes_sent = datalink_send_pdu(&dest, &npdu_data,
+    bytes_sent = datalink_send_pdu(&dest, &npdu_data, &buffer[0], pdu_len);
-        &buffer[0], pdu_len);
 
     return bytes_sent;
 }

bacnet-stack/npdu.c

@@ -57,8 +57,7 @@ void npdu_copy_data(BACNET_NPDU_DATA * dest, BACNET_NPDU_DATA * src)
 
 int npdu_encode_pdu(uint8_t * npdu,
     BACNET_ADDRESS * dest,
-    BACNET_ADDRESS * src,
+    BACNET_ADDRESS * src, BACNET_NPDU_DATA * npdu_data)
-    BACNET_NPDU_DATA * npdu_data)
 {
     int len = 0;                /* return value - number of octets loaded in this function */
     int i = 0;                  /* counter  */
@@ -158,8 +157,7 @@ int npdu_encode_pdu(uint8_t * npdu,
 void npdu_encode_confirmed_apdu(BACNET_NPDU_DATA * npdu_data,
     BACNET_MESSAGE_PRIORITY priority)
 {
-    if (npdu_data)
+    if (npdu_data) {
-    {
         npdu_data->confirmed_message = true;
         npdu_data->protocol_version = BACNET_PROTOCOL_VERSION;
         npdu_data->network_layer_message = false;       /* false if APDU */
@@ -173,8 +171,7 @@ void npdu_encode_confirmed_apdu(BACNET_NPDU_DATA * npdu_data,
 void npdu_encode_unconfirmed_apdu(BACNET_NPDU_DATA * npdu_data,
     BACNET_MESSAGE_PRIORITY priority)
 {
-    if (npdu_data)
+    if (npdu_data) {
-    {
         npdu_data->confirmed_message = false;
         npdu_data->protocol_version = BACNET_PROTOCOL_VERSION;
         npdu_data->network_layer_message = false;       /* false if APDU */

bacnet-stack/ports/pic18/dlmstp.c

@@ -64,12 +64,12 @@ int dlmstp_send_pdu(BACNET_ADDRESS * dest,      /* destination address */
     bool status;
     int bytes_sent = 0;
 
-    if (Transmit_Buffer.ready == false)
+    if (Transmit_Buffer.ready == false) {
-    {
         /* FIXME: how do we get data_expecting_reply? */
         Transmit_Buffer.data_expecting_reply = false;
         Receive_Buffer.pdu_len = 0;
-        memmove(&Transmit_Buffer.address,dest,sizeof(Transmit_Buffer.address));
+        memmove(&Transmit_Buffer.address, dest,
+            sizeof(Transmit_Buffer.address));
         Transmit_Buffer.pdu_len = pdu_len;
         /* FIXME: copy the whole PDU or just the pdu_len? */
         memmove(Transmit_Buffer.pdu, pdu, sizeof(Transmit_Buffer.pdu));
@@ -83,14 +83,13 @@ int dlmstp_send_pdu(BACNET_ADDRESS * dest,      /* destination address */
 /* function for MS/TP to use to get a packet to transmit
    returns the number of bytes in the packet, or zero if none. */
 int dlmstp_get_transmit_pdu(BACNET_ADDRESS * dest,      /* destination address */
-    uint8_t * pdu)              /* any data to be sent - may be null */
+    uint8_t * pdu)
-{
+{                               /* any data to be sent - may be null */
     bool status;
     DLMSTP_PACKET *packet;
     unsigned pdu_len = 0;
 
-    if (Transmit_Buffer.ready)
+    if (Transmit_Buffer.ready) {
-    {
         memmove(dest, &packet->address, sizeof(packet->address));
         pdu_len = packet->pdu_len;
         memmove(pdu, packet->pdu, sizeof(packet.pdu));
@@ -130,8 +129,7 @@ uint16_t dlmstp_receive(BACNET_ADDRESS * src,   /* source address */
 
     (void) timeout;
     /* see if there is a packet available */
-    if (!Ringbuf_Empty(&Receive_Buffer))
+    if (!Ringbuf_Empty(&Receive_Buffer)) {
-    {
         packet = (char *) Ringbuf_Pop_Front(&Receive_Buffer);
         memmove(src, &packet->address, sizeof(packet->address));
         pdu_len = packet->pdu_len;

bacnet-stack/ports/pic18/main.c

@@ -52,6 +52,7 @@
 static uint8_t Temp_Buf[MAX_APDU];
 /* buffer used for receiving */
 static uint8_t Rx_Buf[MAX_MPDU] = { 0 };
+
 /* address where message came from */
 static BACNET_ADDRESS src;
 /* address used to send */

bacnet-stack/tsm.c

@@ -133,8 +133,7 @@ uint8_t tsm_next_free_invokeID(void)
     bool found = false;
 
     /* is there even space available? */
-    if (tsm_transaction_available())
+    if (tsm_transaction_available()) {
-    {
         while (!found) {
             index = tsm_find_invokeID_index(current_invokeID);
             /* not found - that is good! */