running the indent on the files.

bacnet-stack/demo/handler/client.h

@@ -35,63 +35,45 @@
 
 #ifdef __cplusplus
 extern "C" {
-#endif /* __cplusplus */
+#endif                          /* __cplusplus */
 
 /* unconfirmed requests */
-void Send_WhoIs(
-  int32_t low_limit,
-  int32_t high_limit);
+    void Send_WhoIs(int32_t low_limit, int32_t high_limit);
 
-void Send_WhoHas_Object(
-  int32_t low_limit,
-  int32_t high_limit,
-  BACNET_OBJECT_TYPE object_type,
-  uint32_t object_instance);
+    void Send_WhoHas_Object(int32_t low_limit,
+        int32_t high_limit,
+        BACNET_OBJECT_TYPE object_type, uint32_t object_instance);
 
-void Send_WhoHas_Name(
-  int32_t low_limit,
-  int32_t high_limit,
-  char *object_name);
+    void Send_WhoHas_Name(int32_t low_limit,
+        int32_t high_limit, char *object_name);
 
-void Send_I_Have(
-  uint32_t device_id,
-  BACNET_OBJECT_TYPE object_type,
-  uint32_t object_instance,
-  char *object_name);
-  
-/* returns the invoke ID for confirmed request, or 0 if failed */
-uint8_t Send_Read_Property_Request(
-  uint32_t device_id, /* destination device */
-  BACNET_OBJECT_TYPE object_type,
-  uint32_t object_instance,
-  BACNET_PROPERTY_ID object_property,
-  int32_t array_index);
+    void Send_I_Have(uint32_t device_id,
+        BACNET_OBJECT_TYPE object_type,
+        uint32_t object_instance, char *object_name);
 
 /* returns the invoke ID for confirmed request, or 0 if failed */
-uint8_t Send_Write_Property_Request(
-    uint32_t device_id, // destination device
-  BACNET_OBJECT_TYPE object_type,
-  uint32_t object_instance,
-  BACNET_PROPERTY_ID object_property,
-  BACNET_APPLICATION_DATA_VALUE *object_value,
-  uint8_t priority,
-  int32_t array_index);
+    uint8_t Send_Read_Property_Request(uint32_t device_id,      /* destination device */
+        BACNET_OBJECT_TYPE object_type,
+        uint32_t object_instance,
+        BACNET_PROPERTY_ID object_property, int32_t array_index);
 
 /* returns the invoke ID for confirmed request, or 0 if failed */
-uint8_t Send_Reinitialize_Device_Request(
-  uint32_t device_id,
-  BACNET_REINITIALIZED_STATE state,
-  char *password);
+    uint8_t Send_Write_Property_Request(uint32_t device_id,     // destination device
+        BACNET_OBJECT_TYPE object_type,
+        uint32_t object_instance,
+        BACNET_PROPERTY_ID object_property,
+        BACNET_APPLICATION_DATA_VALUE * object_value,
+        uint8_t priority, int32_t array_index);
 
 /* returns the invoke ID for confirmed request, or 0 if failed */
-uint8_t Send_Device_Communication_Control_Request(
-  uint32_t device_id,
-  uint16_t timeDuration, /* 0=optional */
-  BACNET_COMMUNICATION_ENABLE_DISABLE state,
-  char *password); /* NULL=optional */
-  
+    uint8_t Send_Reinitialize_Device_Request(uint32_t device_id,
+        BACNET_REINITIALIZED_STATE state, char *password);
+
+/* returns the invoke ID for confirmed request, or 0 if failed */
+    uint8_t Send_Device_Communication_Control_Request(uint32_t device_id, uint16_t timeDuration,        /* 0=optional */
+        BACNET_COMMUNICATION_ENABLE_DISABLE state, char *password);     /* NULL=optional */
+
 #ifdef __cplusplus
 }
-#endif /* __cplusplus */
-
+#endif                          /* __cplusplus */
 #endif

bacnet-stack/demo/handler/h_arf.c

@@ -41,116 +41,82 @@
 #include "ao.h"
 #include "bacfile.h"
 
-void handler_atomic_read_file(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src,
-  BACNET_CONFIRMED_SERVICE_DATA *service_data)
+void handler_atomic_read_file(uint8_t * service_request,
+    uint16_t service_len,
+    BACNET_ADDRESS * src, BACNET_CONFIRMED_SERVICE_DATA * service_data)
 {
-  BACNET_ATOMIC_READ_FILE_DATA data;
-  int len = 0;
-  int pdu_len = 0;
-  BACNET_ADDRESS my_address;
-  bool send = false;
-  bool error = false;
-  int bytes_sent = 0;
-  BACNET_ERROR_CLASS error_class = ERROR_CLASS_OBJECT;
-  BACNET_ERROR_CODE error_code = ERROR_CODE_UNKNOWN_OBJECT;
+    BACNET_ATOMIC_READ_FILE_DATA data;
+    int len = 0;
+    int pdu_len = 0;
+    BACNET_ADDRESS my_address;
+    bool send = false;
+    bool error = false;
+    int bytes_sent = 0;
+    BACNET_ERROR_CLASS error_class = ERROR_CLASS_OBJECT;
+    BACNET_ERROR_CODE error_code = ERROR_CODE_UNKNOWN_OBJECT;
 
-  fprintf(stderr,"Received Atomic-Read-File Request!\n");
-  len = arf_decode_service_request(
-    service_request,
-    service_len,
-    &data);
-  if (len < 0)
-    fprintf(stderr,"Unable to decode Atomic-Read-File Request!\n");
-  // prepare a reply
-  datalink_get_my_address(&my_address);
-  // encode the NPDU portion of the packet
-  pdu_len = npdu_encode_apdu(
-    &Handler_Transmit_Buffer[0],
-    src,
-    &my_address,
-    false,  // true for confirmed messages
-    MESSAGE_PRIORITY_NORMAL);
-  // bad decoding - send an abort
-  if (len < 0)
-  {
-    pdu_len += abort_encode_apdu(
-      &Handler_Transmit_Buffer[pdu_len],
-      service_data->invoke_id,
-      ABORT_REASON_OTHER);
-    fprintf(stderr,"Sending Abort!\n");
-    send = true;
-  }
-  else if (service_data->segmented_message)
-  {
-    pdu_len += abort_encode_apdu(
-      &Handler_Transmit_Buffer[pdu_len],
-      service_data->invoke_id,
-      ABORT_REASON_SEGMENTATION_NOT_SUPPORTED);
-    fprintf(stderr,"Sending Abort!\n");
-    send = true;
-  }
-  else
-  {
-    if (data.access == FILE_STREAM_ACCESS)
-    {
-      if (data.type.stream.requestedOctetCount <
-          octetstring_capacity(&data.fileData))
-      {
-        if (bacfile_read_data(&data))
-        {
-          pdu_len += arf_ack_encode_apdu(
-            &Handler_Transmit_Buffer[pdu_len],
-            service_data->invoke_id,
-            &data);
-          send = true;
-        }
-        else
-        {
-          send = true;
-          error = true;
-        }
-      }
-      else
-      {
-        pdu_len += abort_encode_apdu(
-          &Handler_Transmit_Buffer[pdu_len],
-          service_data->invoke_id,
-          ABORT_REASON_SEGMENTATION_NOT_SUPPORTED);
-        fprintf(stderr,"Sending Abort!\n");
+    fprintf(stderr, "Received Atomic-Read-File Request!\n");
+    len = arf_decode_service_request(service_request, service_len, &data);
+    if (len < 0)
+        fprintf(stderr, "Unable to decode Atomic-Read-File Request!\n");
+    // prepare a reply
+    datalink_get_my_address(&my_address);
+    // encode the NPDU portion of the packet
+    pdu_len = npdu_encode_apdu(&Handler_Transmit_Buffer[0], src, &my_address, false,    // true for confirmed messages
+        MESSAGE_PRIORITY_NORMAL);
+    // bad decoding - send an abort
+    if (len < 0) {
+        pdu_len += abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+            service_data->invoke_id, ABORT_REASON_OTHER);
+        fprintf(stderr, "Sending Abort!\n");
         send = true;
-      }
+    } else if (service_data->segmented_message) {
+        pdu_len += abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+            service_data->invoke_id,
+            ABORT_REASON_SEGMENTATION_NOT_SUPPORTED);
+        fprintf(stderr, "Sending Abort!\n");
+        send = true;
+    } else {
+        if (data.access == FILE_STREAM_ACCESS) {
+            if (data.type.stream.requestedOctetCount <
+                octetstring_capacity(&data.fileData)) {
+                if (bacfile_read_data(&data)) {
+                    pdu_len +=
+                        arf_ack_encode_apdu(&Handler_Transmit_Buffer
+                        [pdu_len], service_data->invoke_id, &data);
+                    send = true;
+                } else {
+                    send = true;
+                    error = true;
+                }
+            } else {
+                pdu_len +=
+                    abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+                    service_data->invoke_id,
+                    ABORT_REASON_SEGMENTATION_NOT_SUPPORTED);
+                fprintf(stderr, "Sending Abort!\n");
+                send = true;
+            }
+        } else {
+            error_class = ERROR_CLASS_SERVICES;
+            error_code = ERROR_CODE_INVALID_FILE_ACCESS_METHOD;
+            send = true;
+            error = true;
+        }
     }
-    else
-    {
-      error_class = ERROR_CLASS_SERVICES;
-      error_code = ERROR_CODE_INVALID_FILE_ACCESS_METHOD;
-      send = true;
-      error = true;
+    if (error) {
+        pdu_len += bacerror_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+            service_data->invoke_id,
+            SERVICE_CONFIRMED_ATOMIC_READ_FILE, error_class, error_code);
+        fprintf(stderr, "Sending Error!\n");
+        send = true;
+    }
+    if (send) {
+        bytes_sent = datalink_send_pdu(src,     // destination address
+            &Handler_Transmit_Buffer[0], pdu_len);      // number of bytes of data
+        if (bytes_sent <= 0)
+            fprintf(stderr, "Failed to send PDU (%s)!\n", strerror(errno));
     }
-  }
-  if (error)
-  {
-    pdu_len += bacerror_encode_apdu(
-      &Handler_Transmit_Buffer[pdu_len],
-      service_data->invoke_id,
-      SERVICE_CONFIRMED_ATOMIC_READ_FILE,
-      error_class,
-      error_code);
-    fprintf(stderr,"Sending Error!\n");
-    send = true;
-  }
-  if (send)
-  {
-    bytes_sent = datalink_send_pdu(
-      src,  // destination address
-      &Handler_Transmit_Buffer[0],
-      pdu_len); // number of bytes of data
-    if (bytes_sent <= 0)
-      fprintf(stderr,"Failed to send PDU (%s)!\n", strerror(errno));
-  }
 
-  return;
+    return;
 }

bacnet-stack/demo/handler/h_arf_a.c

@@ -47,54 +47,42 @@
 // that someone can read from us.  It is common to
 // use the description as the file name.
 #if BACFILE
-void handler_atomic_read_file_ack(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src,
-  BACNET_CONFIRMED_SERVICE_ACK_DATA *service_data)
+void handler_atomic_read_file_ack(uint8_t * service_request,
+    uint16_t service_len,
+    BACNET_ADDRESS * src, BACNET_CONFIRMED_SERVICE_ACK_DATA * service_data)
 {
-  int len = 0;
-  BACNET_ATOMIC_READ_FILE_DATA data;
-  FILE *pFile = NULL;
-  char *pFilename = NULL;
-  uint32_t instance = 0;
+    int len = 0;
+    BACNET_ATOMIC_READ_FILE_DATA data;
+    FILE *pFile = NULL;
+    char *pFilename = NULL;
+    uint32_t instance = 0;
 
-  (void)src;
-  // get the file instance from the tsm data before freeing it
-  instance = bacfile_instance_from_tsm(service_data->invoke_id);
-  len = arf_ack_decode_service_request(
-    service_request,
-    service_len,
-    &data);
-  fprintf(stderr,"Received Read-File Ack!\n");
-  if ((len > 0) && (instance <= BACNET_MAX_INSTANCE))
-  {
-    // write the data received to the file specified
-    if (data.access == FILE_STREAM_ACCESS)
-    {
-      pFilename = bacfile_name(instance);
-      if (pFilename)
-      {
-        pFile = fopen(pFilename, "rb");
-        if (pFile)
-        {
-          (void)fseek(pFile,
-            data.type.stream.fileStartPosition,
-            SEEK_SET);
-          if (fwrite(octetstring_value(&data.fileData),
-              octetstring_length(&data.fileData),1,pFile) != 1)
-            fprintf(stderr,"Failed to write to %s (%u)!\n",
-              pFilename, instance);
-          fclose(pFile);
+    (void) src;
+    // get the file instance from the tsm data before freeing it
+    instance = bacfile_instance_from_tsm(service_data->invoke_id);
+    len = arf_ack_decode_service_request(service_request,
+        service_len, &data);
+    fprintf(stderr, "Received Read-File Ack!\n");
+    if ((len > 0) && (instance <= BACNET_MAX_INSTANCE)) {
+        // write the data received to the file specified
+        if (data.access == FILE_STREAM_ACCESS) {
+            pFilename = bacfile_name(instance);
+            if (pFilename) {
+                pFile = fopen(pFilename, "rb");
+                if (pFile) {
+                    (void) fseek(pFile,
+                        data.type.stream.fileStartPosition, SEEK_SET);
+                    if (fwrite(octetstring_value(&data.fileData),
+                            octetstring_length(&data.fileData), 1,
+                            pFile) != 1)
+                        fprintf(stderr, "Failed to write to %s (%u)!\n",
+                            pFilename, instance);
+                    fclose(pFile);
+                }
+            }
+        } else if (data.access == FILE_RECORD_ACCESS) {
+            // FIXME: add handling for Record Access
         }
-      }
     }
-    else if (data.access == FILE_RECORD_ACCESS)
-    {
-      // FIXME: add handling for Record Access
-    }
-  }
 }
 #endif
-
-

bacnet-stack/demo/handler/h_dcc.c

@@ -40,106 +40,76 @@
 
 static char *My_Password = "AnnaRoseKarg";
 
-void handler_device_communication_control(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src,
-  BACNET_CONFIRMED_SERVICE_DATA *service_data)
+void handler_device_communication_control(uint8_t * service_request,
+    uint16_t service_len,
+    BACNET_ADDRESS * src, BACNET_CONFIRMED_SERVICE_DATA * service_data)
 {
-  uint16_t timeDuration = 0;
-  BACNET_COMMUNICATION_ENABLE_DISABLE state = COMMUNICATION_ENABLE;
-  BACNET_CHARACTER_STRING password;
-  int len = 0;
-  int pdu_len = 0;
-  BACNET_ADDRESS my_address;
-  int bytes_sent = 0;
+    uint16_t timeDuration = 0;
+    BACNET_COMMUNICATION_ENABLE_DISABLE state = COMMUNICATION_ENABLE;
+    BACNET_CHARACTER_STRING password;
+    int len = 0;
+    int pdu_len = 0;
+    BACNET_ADDRESS my_address;
+    int bytes_sent = 0;
 
-  // decode the service request only
-  len = dcc_decode_service_request(
-    service_request,
-    service_len,
-    &timeDuration,
-    &state,
-    &password);
-  fprintf(stderr,"DeviceCommunicationControl!\n");
-  if (len > 0)
-    fprintf(stderr,"DeviceCommunicationControl: "
-        "timeout=%u state=%u password=%s\n",
-        (unsigned)timeDuration,
-        (unsigned)state,
-        characterstring_value(&password));
-  else
-    fprintf(stderr,"DeviceCommunicationControl: "
-        "Unable to decode request!\n");
-  // prepare a reply
-  datalink_get_my_address(&my_address);
-  // encode the NPDU portion of the packet
-  pdu_len = npdu_encode_apdu(
-    &Handler_Transmit_Buffer[0],
-    src,
-    &my_address,
-    false,  // true for confirmed messages
-    MESSAGE_PRIORITY_NORMAL);
-  // bad decoding or something we didn't understand - send an abort
-  if (len == -1)
-  {
-    pdu_len += abort_encode_apdu(
-        &Handler_Transmit_Buffer[pdu_len],
-    service_data->invoke_id,
-    ABORT_REASON_OTHER);
-    fprintf(stderr,"DeviceCommunicationControl: "
-        "Sending Abort - could not decode.\n");
-  }
-  else if (service_data->segmented_message)
-  {
-    pdu_len += abort_encode_apdu(
-        &Handler_Transmit_Buffer[pdu_len],
-    service_data->invoke_id,
-    ABORT_REASON_SEGMENTATION_NOT_SUPPORTED);
-    fprintf(stderr,"DeviceCommunicationControl: "
-        "Sending Abort - segmented message.\n");
-  }
-  else if (state >= MAX_BACNET_COMMUNICATION_ENABLE_DISABLE)
-  {
-    pdu_len += reject_encode_apdu(
-      &Handler_Transmit_Buffer[pdu_len],
-      service_data->invoke_id,
-      REJECT_REASON_UNDEFINED_ENUMERATION);
-    fprintf(stderr,"DeviceCommunicationControl: "
-        "Sending Reject - undefined enumeration\n");
-  }
-  else
-  {
-    if (characterstring_ansi_same(&password,My_Password))
-    {
-      pdu_len += encode_simple_ack(
-        &Handler_Transmit_Buffer[pdu_len],
-        service_data->invoke_id,
-        SERVICE_CONFIRMED_DEVICE_COMMUNICATION_CONTROL);
-      fprintf(stderr,"DeviceCommunicationControl: "
-          "Sending Simple Ack!\n");
-      dcc_set_status_duration(state,timeDuration);
-    }
+    // decode the service request only
+    len = dcc_decode_service_request(service_request,
+        service_len, &timeDuration, &state, &password);
+    fprintf(stderr, "DeviceCommunicationControl!\n");
+    if (len > 0)
+        fprintf(stderr, "DeviceCommunicationControl: "
+            "timeout=%u state=%u password=%s\n",
+            (unsigned) timeDuration,
+            (unsigned) state, characterstring_value(&password));
     else
-    {
-      pdu_len += bacerror_encode_apdu(
-        &Handler_Transmit_Buffer[pdu_len],
-        service_data->invoke_id,
-        SERVICE_CONFIRMED_DEVICE_COMMUNICATION_CONTROL,
-        ERROR_CLASS_SERVICES,
-        ERROR_CODE_PASSWORD_FAILURE);
-      fprintf(stderr,"DeviceCommunicationControl: "
-          "Sending Error - password failure.\n");
+        fprintf(stderr, "DeviceCommunicationControl: "
+            "Unable to decode request!\n");
+    // prepare a reply
+    datalink_get_my_address(&my_address);
+    // encode the NPDU portion of the packet
+    pdu_len = npdu_encode_apdu(&Handler_Transmit_Buffer[0], src, &my_address, false,    // true for confirmed messages
+        MESSAGE_PRIORITY_NORMAL);
+    // bad decoding or something we didn't understand - send an abort
+    if (len == -1) {
+        pdu_len += abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+            service_data->invoke_id, ABORT_REASON_OTHER);
+        fprintf(stderr, "DeviceCommunicationControl: "
+            "Sending Abort - could not decode.\n");
+    } else if (service_data->segmented_message) {
+        pdu_len += abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+            service_data->invoke_id,
+            ABORT_REASON_SEGMENTATION_NOT_SUPPORTED);
+        fprintf(stderr, "DeviceCommunicationControl: "
+            "Sending Abort - segmented message.\n");
+    } else if (state >= MAX_BACNET_COMMUNICATION_ENABLE_DISABLE) {
+        pdu_len += reject_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+            service_data->invoke_id, REJECT_REASON_UNDEFINED_ENUMERATION);
+        fprintf(stderr, "DeviceCommunicationControl: "
+            "Sending Reject - undefined enumeration\n");
+    } else {
+        if (characterstring_ansi_same(&password, My_Password)) {
+            pdu_len += encode_simple_ack(&Handler_Transmit_Buffer[pdu_len],
+                service_data->invoke_id,
+                SERVICE_CONFIRMED_DEVICE_COMMUNICATION_CONTROL);
+            fprintf(stderr, "DeviceCommunicationControl: "
+                "Sending Simple Ack!\n");
+            dcc_set_status_duration(state, timeDuration);
+        } else {
+            pdu_len +=
+                bacerror_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+                service_data->invoke_id,
+                SERVICE_CONFIRMED_DEVICE_COMMUNICATION_CONTROL,
+                ERROR_CLASS_SERVICES, ERROR_CODE_PASSWORD_FAILURE);
+            fprintf(stderr,
+                "DeviceCommunicationControl: "
+                "Sending Error - password failure.\n");
+        }
     }
-  }
-  bytes_sent = datalink_send_pdu(
-      src,  // destination address
-  &Handler_Transmit_Buffer[0],
-  pdu_len); // number of bytes of data
-  if (bytes_sent <= 0)
-    fprintf(stderr,"DeviceCommunicationControl: "
-        "Failed to send PDU (%s)!\n",
-      strerror(errno));
+    bytes_sent = datalink_send_pdu(src, // destination address
+        &Handler_Transmit_Buffer[0], pdu_len);  // number of bytes of data
+    if (bytes_sent <= 0)
+        fprintf(stderr, "DeviceCommunicationControl: "
+            "Failed to send PDU (%s)!\n", strerror(errno));
 
-  return;
+    return;
 }

bacnet-stack/demo/handler/h_iam.c

@@ -32,61 +32,42 @@
 #include "iam.h"
 #include "address.h"
 
-void handler_i_am_add(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src)
+void handler_i_am_add(uint8_t * service_request,
+    uint16_t service_len, BACNET_ADDRESS * src)
 {
-  int len = 0;
-  uint32_t device_id = 0;
-  unsigned max_apdu = 0;
-  int segmentation = 0;
-  uint16_t vendor_id = 0;
+    int len = 0;
+    uint32_t device_id = 0;
+    unsigned max_apdu = 0;
+    int segmentation = 0;
+    uint16_t vendor_id = 0;
 
-  (void)service_len;
-  len = iam_decode_service_request(
-    service_request,
-    &device_id,
-    &max_apdu,
-    &segmentation,
-    &vendor_id);
-  fprintf(stderr,"Received I-Am Request");
-  if (len != -1)
-  {
-    fprintf(stderr," from %u!\n",device_id);
-    address_add(device_id,
-      max_apdu,
-      src);
-  }
-  else
-    fprintf(stderr,"!\n");
+    (void) service_len;
+    len = iam_decode_service_request(service_request,
+        &device_id, &max_apdu, &segmentation, &vendor_id);
+    fprintf(stderr, "Received I-Am Request");
+    if (len != -1) {
+        fprintf(stderr, " from %u!\n", device_id);
+        address_add(device_id, max_apdu, src);
+    } else
+        fprintf(stderr, "!\n");
 
-  return;  
+    return;
 }
 
-void handler_i_am_bind(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src)
+void handler_i_am_bind(uint8_t * service_request,
+    uint16_t service_len, BACNET_ADDRESS * src)
 {
-  int len = 0;
-  uint32_t device_id = 0;
-  unsigned max_apdu = 0;
-  int segmentation = 0;
-  uint16_t vendor_id = 0;
+    int len = 0;
+    uint32_t device_id = 0;
+    unsigned max_apdu = 0;
+    int segmentation = 0;
+    uint16_t vendor_id = 0;
 
-  (void)service_len;
-  len = iam_decode_service_request(
-    service_request,
-    &device_id,
-    &max_apdu,
-    &segmentation,
-    &vendor_id);
-  // only add address if requested to bind
-  address_add_binding(device_id,
-    max_apdu,
-    src);
+    (void) service_len;
+    len = iam_decode_service_request(service_request,
+        &device_id, &max_apdu, &segmentation, &vendor_id);
+    // only add address if requested to bind
+    address_add_binding(device_id, max_apdu, src);
 
-  return;  
+    return;
 }
-

bacnet-stack/demo/handler/h_ihave.c

@@ -32,31 +32,24 @@
 #include "bactext.h"
 #include "ihave.h"
 
-void handler_i_have(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src)
+void handler_i_have(uint8_t * service_request,
+    uint16_t service_len, BACNET_ADDRESS * src)
 {
-  int len = 0;
-  BACNET_I_HAVE_DATA data;
+    int len = 0;
+    BACNET_I_HAVE_DATA data;
 
-  (void)service_len;
-  (void)src;
-  len = ihave_decode_service_request(
-    service_request,
-    service_len,
-    &data);
-  if (len != -1)
-  {
-    fprintf(stderr,"I-Have: %s %d from %s %u!\r\n",
-      bactext_object_type_name(data.object_id.type),
-      data.object_id.instance,
-      bactext_object_type_name(data.device_id.type),
-      data.device_id.instance);
-  }
-  else
-    fprintf(stderr,"I-Have: received, but unable to decode!\n");
+    (void) service_len;
+    (void) src;
+    len = ihave_decode_service_request(service_request,
+        service_len, &data);
+    if (len != -1) {
+        fprintf(stderr, "I-Have: %s %d from %s %u!\r\n",
+            bactext_object_type_name(data.object_id.type),
+            data.object_id.instance,
+            bactext_object_type_name(data.device_id.type),
+            data.device_id.instance);
+    } else
+        fprintf(stderr, "I-Have: received, but unable to decode!\n");
 
-  return;  
+    return;
 }
-

bacnet-stack/demo/handler/h_rd.c

@@ -40,99 +40,74 @@
 
 static BACNET_CHARACTER_STRING My_Password;
 
-void handler_reinitialize_device(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src,
-  BACNET_CONFIRMED_SERVICE_DATA *service_data)
+void handler_reinitialize_device(uint8_t * service_request,
+    uint16_t service_len,
+    BACNET_ADDRESS * src, BACNET_CONFIRMED_SERVICE_DATA * service_data)
 {
-  BACNET_REINITIALIZED_STATE state;
-  BACNET_CHARACTER_STRING password;
-  int len = 0;
-  int pdu_len = 0;
-  BACNET_ADDRESS my_address;
-  int bytes_sent = 0;
+    BACNET_REINITIALIZED_STATE state;
+    BACNET_CHARACTER_STRING password;
+    int len = 0;
+    int pdu_len = 0;
+    BACNET_ADDRESS my_address;
+    int bytes_sent = 0;
 
-  // decode the service request only
-  len = rd_decode_service_request(
-    service_request,
-    service_len,
-    &state,
-    &password);
-  fprintf(stderr,"ReinitializeDevice!\n");
-  if (len > 0)
-    fprintf(stderr,"ReinitializeDevice: state=%u password=%s\n",
-            (unsigned)state,
-            characterstring_value(&password));
-  else
-    fprintf(stderr,"ReinitializeDevice: Unable to decode request!\n");
-  // prepare a reply
-  datalink_get_my_address(&my_address);
-  // encode the NPDU portion of the packet
-  pdu_len = npdu_encode_apdu(
-    &Handler_Transmit_Buffer[0],
-    src,
-    &my_address,
-    false,  // true for confirmed messages
-    MESSAGE_PRIORITY_NORMAL);
-  // bad decoding or something we didn't understand - send an abort
-  if (len == -1)
-  {
-    pdu_len += abort_encode_apdu(
-        &Handler_Transmit_Buffer[pdu_len],
-    service_data->invoke_id,
-    ABORT_REASON_OTHER);
-    fprintf(stderr,"ReinitializeDevice: Sending Abort - could not decode.\n");
-  }
-  else if (service_data->segmented_message)
-  {
-    pdu_len += abort_encode_apdu(
-        &Handler_Transmit_Buffer[pdu_len],
-    service_data->invoke_id,
-    ABORT_REASON_SEGMENTATION_NOT_SUPPORTED);
-    fprintf(stderr,"ReinitializeDevice: Sending Abort - segmented message.\n");
-  }
-  else if (state >= MAX_BACNET_REINITIALIZED_STATE)
-  {
-    pdu_len += reject_encode_apdu(
-      &Handler_Transmit_Buffer[pdu_len],
-      service_data->invoke_id,
-      REJECT_REASON_UNDEFINED_ENUMERATION);
-    fprintf(stderr,"ReinitializeDevice: Sending Reject - undefined enumeration\n");
-  }
-  else
-  {
-    characterstring_init_ansi(&My_Password,"Jesus");
-    if (characterstring_same(&password,&My_Password))
-    {
-      pdu_len += encode_simple_ack(
-        &Handler_Transmit_Buffer[pdu_len],
-        service_data->invoke_id,
-        SERVICE_CONFIRMED_REINITIALIZE_DEVICE);
-      fprintf(stderr,"ReinitializeDevice: Sending Simple Ack!\n");
-      /* FIXME: now you can reboot, restart, quit, or something clever */
-      /* Note: you can use a mix of state and password to do specific stuff */
-      /* Note: if you don't do something clever like actually restart,
-         you probably should clear any DCC status and timeouts */
-    }
+    // decode the service request only
+    len = rd_decode_service_request(service_request,
+        service_len, &state, &password);
+    fprintf(stderr, "ReinitializeDevice!\n");
+    if (len > 0)
+        fprintf(stderr, "ReinitializeDevice: state=%u password=%s\n",
+            (unsigned) state, characterstring_value(&password));
     else
-    {
-      pdu_len += bacerror_encode_apdu(
-        &Handler_Transmit_Buffer[pdu_len],
-        service_data->invoke_id,
-        SERVICE_CONFIRMED_REINITIALIZE_DEVICE,
-        ERROR_CLASS_SERVICES,
-        ERROR_CODE_PASSWORD_FAILURE);
-      fprintf(stderr,"ReinitializeDevice: Sending Error - password failure.\n");
+        fprintf(stderr, "ReinitializeDevice: Unable to decode request!\n");
+    // prepare a reply
+    datalink_get_my_address(&my_address);
+    // encode the NPDU portion of the packet
+    pdu_len = npdu_encode_apdu(&Handler_Transmit_Buffer[0], src, &my_address, false,    // true for confirmed messages
+        MESSAGE_PRIORITY_NORMAL);
+    // bad decoding or something we didn't understand - send an abort
+    if (len == -1) {
+        pdu_len += abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+            service_data->invoke_id, ABORT_REASON_OTHER);
+        fprintf(stderr,
+            "ReinitializeDevice: Sending Abort - could not decode.\n");
+    } else if (service_data->segmented_message) {
+        pdu_len += abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+            service_data->invoke_id,
+            ABORT_REASON_SEGMENTATION_NOT_SUPPORTED);
+        fprintf(stderr,
+            "ReinitializeDevice: Sending Abort - segmented message.\n");
+    } else if (state >= MAX_BACNET_REINITIALIZED_STATE) {
+        pdu_len += reject_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+            service_data->invoke_id, REJECT_REASON_UNDEFINED_ENUMERATION);
+        fprintf(stderr,
+            "ReinitializeDevice: Sending Reject - undefined enumeration\n");
+    } else {
+        characterstring_init_ansi(&My_Password, "Jesus");
+        if (characterstring_same(&password, &My_Password)) {
+            pdu_len += encode_simple_ack(&Handler_Transmit_Buffer[pdu_len],
+                service_data->invoke_id,
+                SERVICE_CONFIRMED_REINITIALIZE_DEVICE);
+            fprintf(stderr, "ReinitializeDevice: Sending Simple Ack!\n");
+            /* FIXME: now you can reboot, restart, quit, or something clever */
+            /* Note: you can use a mix of state and password to do specific stuff */
+            /* Note: if you don't do something clever like actually restart,
+               you probably should clear any DCC status and timeouts */
+        } else {
+            pdu_len +=
+                bacerror_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+                service_data->invoke_id,
+                SERVICE_CONFIRMED_REINITIALIZE_DEVICE,
+                ERROR_CLASS_SERVICES, ERROR_CODE_PASSWORD_FAILURE);
+            fprintf(stderr,
+                "ReinitializeDevice: Sending Error - password failure.\n");
+        }
     }
-  }
-  bytes_sent = datalink_send_pdu(
-      src,  // destination address
-  &Handler_Transmit_Buffer[0],
-  pdu_len); // number of bytes of data
-  if (bytes_sent <= 0)
-    fprintf(stderr,"ReinitializeDevice: Failed to send PDU (%s)!\n",
-      strerror(errno));
+    bytes_sent = datalink_send_pdu(src, // destination address
+        &Handler_Transmit_Buffer[0], pdu_len);  // number of bytes of data
+    if (bytes_sent <= 0)
+        fprintf(stderr, "ReinitializeDevice: Failed to send PDU (%s)!\n",
+            strerror(errno));
 
-  return;
+    return;
 }

bacnet-stack/demo/handler/h_rp.c

@@ -43,206 +43,148 @@
 #include "bacfile.h"
 #endif
 
-static uint8_t Temp_Buf[MAX_APDU] = {0};
+static uint8_t Temp_Buf[MAX_APDU] = { 0 };
 
-void handler_read_property(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src,
-  BACNET_CONFIRMED_SERVICE_DATA *service_data)
+void handler_read_property(uint8_t * service_request,
+    uint16_t service_len,
+    BACNET_ADDRESS * src, BACNET_CONFIRMED_SERVICE_DATA * service_data)
 {
-  BACNET_READ_PROPERTY_DATA data;
-  int len = 0;
-  int pdu_len = 0;
-  BACNET_ADDRESS my_address;
-  bool send = false;
-  bool error = false;
-  int bytes_sent = 0;
-  BACNET_ERROR_CLASS error_class = ERROR_CLASS_OBJECT;
-  BACNET_ERROR_CODE error_code = ERROR_CODE_UNKNOWN_OBJECT;
+    BACNET_READ_PROPERTY_DATA data;
+    int len = 0;
+    int pdu_len = 0;
+    BACNET_ADDRESS my_address;
+    bool send = false;
+    bool error = false;
+    int bytes_sent = 0;
+    BACNET_ERROR_CLASS error_class = ERROR_CLASS_OBJECT;
+    BACNET_ERROR_CODE error_code = ERROR_CODE_UNKNOWN_OBJECT;
 
-  len = rp_decode_service_request(
-    service_request,
-    service_len,
-    &data);
-  if (len <= 0)
-    fprintf(stderr,"Unable to decode Read-Property Request!\n");
-  // prepare a reply
-  datalink_get_my_address(&my_address);
-  // encode the NPDU portion of the packet
-  pdu_len = npdu_encode_apdu(
-    &Handler_Transmit_Buffer[0],
-    src,
-    &my_address,
-    false,  // true for confirmed messages
-    MESSAGE_PRIORITY_NORMAL);
-  // bad decoding - send an abort
-  if (len == -1)
-  {
-    pdu_len += abort_encode_apdu(
-      &Handler_Transmit_Buffer[pdu_len],
-      service_data->invoke_id,
-      ABORT_REASON_OTHER);
-    fprintf(stderr,"Sending Abort!\n");
-    send = true;
-  }
-  else if (service_data->segmented_message)
-  {
-    pdu_len += abort_encode_apdu(
-      &Handler_Transmit_Buffer[pdu_len],
-      service_data->invoke_id,
-      ABORT_REASON_SEGMENTATION_NOT_SUPPORTED);
-    fprintf(stderr,"Sending Abort!\n");
-    send = true;
-  }
-  else
-  {
-    switch (data.object_type)
-    {
-      case OBJECT_DEVICE:
-        // FIXME: probably need a length limitation sent with encode
-        if (data.object_instance == Device_Object_Instance_Number())
-        {
-          len = Device_Encode_Property_APDU(
-            &Temp_Buf[0],
-            data.object_property,
-            data.array_index,
-            &error_class,
-            &error_code);
-          if (len >= 0)
-          {
-            // encode the APDU portion of the packet
-            data.application_data = &Temp_Buf[0];
-            data.application_data_len = len;
+    len = rp_decode_service_request(service_request, service_len, &data);
+    if (len <= 0)
+        fprintf(stderr, "Unable to decode Read-Property Request!\n");
+    // prepare a reply
+    datalink_get_my_address(&my_address);
+    // encode the NPDU portion of the packet
+    pdu_len = npdu_encode_apdu(&Handler_Transmit_Buffer[0], src, &my_address, false,    // true for confirmed messages
+        MESSAGE_PRIORITY_NORMAL);
+    // bad decoding - send an abort
+    if (len == -1) {
+        pdu_len += abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+            service_data->invoke_id, ABORT_REASON_OTHER);
+        fprintf(stderr, "Sending Abort!\n");
+        send = true;
+    } else if (service_data->segmented_message) {
+        pdu_len += abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+            service_data->invoke_id,
+            ABORT_REASON_SEGMENTATION_NOT_SUPPORTED);
+        fprintf(stderr, "Sending Abort!\n");
+        send = true;
+    } else {
+        switch (data.object_type) {
+        case OBJECT_DEVICE:
             // FIXME: probably need a length limitation sent with encode
-            pdu_len += rp_ack_encode_apdu(
-              &Handler_Transmit_Buffer[pdu_len],
-              service_data->invoke_id,
-              &data);
-            fprintf(stderr,"Sending Read Property Ack!\n");
-            send = true;
-          }
-          else
+            if (data.object_instance == Device_Object_Instance_Number()) {
+                len = Device_Encode_Property_APDU(&Temp_Buf[0],
+                    data.object_property,
+                    data.array_index, &error_class, &error_code);
+                if (len >= 0) {
+                    // encode the APDU portion of the packet
+                    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
+                        [pdu_len], service_data->invoke_id, &data);
+                    fprintf(stderr, "Sending Read Property Ack!\n");
+                    send = true;
+                } else
+                    error = true;
+            } else
+                error = true;
+            break;
+        case OBJECT_ANALOG_INPUT:
+            if (Analog_Input_Valid_Instance(data.object_instance)) {
+                len = Analog_Input_Encode_Property_APDU(&Temp_Buf[0],
+                    data.object_instance,
+                    data.object_property,
+                    data.array_index, &error_class, &error_code);
+                if (len >= 0) {
+                    // encode the APDU portion of the packet
+                    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
+                        [pdu_len], service_data->invoke_id, &data);
+                    fprintf(stderr, "Sending Read Property Ack!\n");
+                    send = true;
+                } else
+                    error = true;
+            } else
+                error = true;
+            break;
+        case OBJECT_ANALOG_OUTPUT:
+            if (Analog_Output_Valid_Instance(data.object_instance)) {
+                len = Analog_Output_Encode_Property_APDU(&Temp_Buf[0],
+                    data.object_instance,
+                    data.object_property,
+                    data.array_index, &error_class, &error_code);
+                if (len >= 0) {
+                    // encode the APDU portion of the packet
+                    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
+                        [pdu_len], service_data->invoke_id, &data);
+                    fprintf(stderr, "Sending Read Property Ack!\n");
+                    send = true;
+                } else
+                    error = true;
+            } else
+                error = true;
+            break;
+#if BACFILE
+        case OBJECT_FILE:
+            if (bacfile_valid_instance(data.object_instance)) {
+                len = bacfile_encode_property_apdu(&Temp_Buf[0],
+                    data.object_instance,
+                    data.object_property,
+                    data.array_index, &error_class, &error_code);
+                if (len >= 0) {
+                    // encode the APDU portion of the packet
+                    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
+                        [pdu_len], service_data->invoke_id, &data);
+                    fprintf(stderr, "Sending Read Property Ack!\n");
+                    send = true;
+                } else
+                    error = true;
+            } else
+                error = true;
+            break;
+#endif
+        default:
             error = true;
+            break;
         }
-        else
-          error = true;
-        break;
-      case OBJECT_ANALOG_INPUT:
-        if (Analog_Input_Valid_Instance(data.object_instance))
-        {
-          len = Analog_Input_Encode_Property_APDU(
-            &Temp_Buf[0],
-            data.object_instance,
-            data.object_property,
-            data.array_index,
-            &error_class,
-            &error_code);
-          if (len >= 0)
-          {
-            // encode the APDU portion of the packet
-            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[pdu_len],
-              service_data->invoke_id,
-              &data);
-            fprintf(stderr,"Sending Read Property Ack!\n");
-            send = true;
-          }
-          else
-            error = true;
-        }
-        else
-          error = true;
-        break;
-      case OBJECT_ANALOG_OUTPUT:
-        if (Analog_Output_Valid_Instance(data.object_instance))
-        {
-          len = Analog_Output_Encode_Property_APDU(
-            &Temp_Buf[0],
-            data.object_instance,
-            data.object_property,
-            data.array_index,
-            &error_class,
-            &error_code);
-          if (len >= 0)
-          {
-            // encode the APDU portion of the packet
-            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[pdu_len],
-              service_data->invoke_id,
-              &data);
-            fprintf(stderr,"Sending Read Property Ack!\n");
-            send = true;
-          }
-          else
-            error = true;
-        }
-        else
-          error = true;
-        break;
-      #if BACFILE
-      case OBJECT_FILE:
-        if (bacfile_valid_instance(data.object_instance))
-        {
-          len = bacfile_encode_property_apdu(
-            &Temp_Buf[0],
-            data.object_instance,
-            data.object_property,
-            data.array_index,
-            &error_class,
-            &error_code);
-          if (len >= 0)
-          {
-            // encode the APDU portion of the packet
-            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[pdu_len],
-              service_data->invoke_id,
-              &data);
-            fprintf(stderr,"Sending Read Property Ack!\n");
-            send = true;
-          }
-          else
-            error = true;
-        }
-        else
-          error = true;
-        break;
-      #endif
-      default:
-        error = true;
-        break;
     }
-  }
-  if (error)
-  {
-    pdu_len += bacerror_encode_apdu(
-      &Handler_Transmit_Buffer[pdu_len],
-      service_data->invoke_id,
-      SERVICE_CONFIRMED_READ_PROPERTY,
-      error_class,
-      error_code);
-    fprintf(stderr,"Sending Read Property Error!\n");
-    send = true;
-  }
-  if (send)
-  {
-    bytes_sent = datalink_send_pdu(
-      src,  // destination address
-      &Handler_Transmit_Buffer[0],
-      pdu_len); // number of bytes of data
-    if (bytes_sent <= 0)
-      fprintf(stderr,"Failed to send PDU (%s)!\n", strerror(errno));
-  }
+    if (error) {
+        pdu_len += bacerror_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+            service_data->invoke_id,
+            SERVICE_CONFIRMED_READ_PROPERTY, error_class, error_code);
+        fprintf(stderr, "Sending Read Property Error!\n");
+        send = true;
+    }
+    if (send) {
+        bytes_sent = datalink_send_pdu(src,     // destination address
+            &Handler_Transmit_Buffer[0], pdu_len);      // number of bytes of data
+        if (bytes_sent <= 0)
+            fprintf(stderr, "Failed to send PDU (%s)!\n", strerror(errno));
+    }
 
-  return;
+    return;
 }
-

bacnet-stack/demo/handler/h_rp_a.c

@@ -42,85 +42,72 @@
 #include "txbuf.h"
 
 /* for debugging... */
-static void PrintReadPropertyData(BACNET_READ_PROPERTY_DATA *data)
+static void PrintReadPropertyData(BACNET_READ_PROPERTY_DATA * data)
 {
-  BACNET_APPLICATION_DATA_VALUE value; /* for decode value data */
-  int len = 0;
-  uint8_t *application_data;
-  int application_data_len;
-  bool first_value = true;
-  bool print_brace = false;
+    BACNET_APPLICATION_DATA_VALUE value;        /* for decode value data */
+    int len = 0;
+    uint8_t *application_data;
+    int application_data_len;
+    bool first_value = true;
+    bool print_brace = false;
 
-  if (data)
-  {
-    #if 0
-    if (data->array_index == BACNET_ARRAY_ALL)
-      fprintf(stderr,"%s #%u %s\n",
-        bactext_object_type_name(data->object_type),
-        data->object_instance,
-        bactext_property_name(data->object_property));
-    else
-      fprintf(stderr,"%s #%u %s[%d]\n",
-        bactext_object_type_name(data->object_type),
-        data->object_instance,
-        bactext_property_name(data->object_property),
-        data->array_index);
-    #endif
-    application_data = data->application_data;
-    application_data_len = data->application_data_len;
-    /* value? need to loop until all of the len is gone... */
-    for (;;)
-    {
-      len = bacapp_decode_application_data(
-        application_data,
-        application_data_len,
-        &value);
-      if (first_value && (len < application_data_len))
-      {
-        first_value = false;
-        fprintf(stdout,"{");
-        print_brace = true;
-      }
-      bacapp_print_value(stdout,&value,data->object_property);
-      if (len)
-      {
-        if (len < application_data_len)
-        {
-          application_data += len;
-          application_data_len -= len;
-          /* there's more! */
-          fprintf(stdout,",");
-        }
+    if (data) {
+#if 0
+        if (data->array_index == BACNET_ARRAY_ALL)
+            fprintf(stderr, "%s #%u %s\n",
+                bactext_object_type_name(data->object_type),
+                data->object_instance,
+                bactext_property_name(data->object_property));
         else
-          break;
-      }
-      else
-        break;
+            fprintf(stderr, "%s #%u %s[%d]\n",
+                bactext_object_type_name(data->object_type),
+                data->object_instance,
+                bactext_property_name(data->object_property),
+                data->array_index);
+#endif
+        application_data = data->application_data;
+        application_data_len = data->application_data_len;
+        /* value? need to loop until all of the len is gone... */
+        for (;;) {
+            len = bacapp_decode_application_data(application_data,
+                application_data_len, &value);
+            if (first_value && (len < application_data_len)) {
+                first_value = false;
+                fprintf(stdout, "{");
+                print_brace = true;
+            }
+            bacapp_print_value(stdout, &value, data->object_property);
+            if (len) {
+                if (len < application_data_len) {
+                    application_data += len;
+                    application_data_len -= len;
+                    /* there's more! */
+                    fprintf(stdout, ",");
+                } else
+                    break;
+            } else
+                break;
+        }
+        if (print_brace)
+            fprintf(stdout, "}");
+        fprintf(stdout, "\r\n");
     }
-    if (print_brace)
-      fprintf(stdout,"}");
-    fprintf(stdout,"\r\n");
-  }
 }
 
-void handler_read_property_ack(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src,
-  BACNET_CONFIRMED_SERVICE_ACK_DATA *service_data)
+void handler_read_property_ack(uint8_t * service_request,
+    uint16_t service_len,
+    BACNET_ADDRESS * src, BACNET_CONFIRMED_SERVICE_ACK_DATA * service_data)
 {
-  int len = 0;
-  BACNET_READ_PROPERTY_DATA data;
+    int len = 0;
+    BACNET_READ_PROPERTY_DATA data;
 
-  (void)src;
-  (void)service_data; /* we could use these... */
-  len = rp_ack_decode_service_request(
-    service_request,
-    service_len,
-    &data);
-  #if 0
-  fprintf(stderr,"Received Read-Property Ack!\n");
-  #endif
-  if (len > 0)
-    PrintReadPropertyData(&data);
+    (void) src;
+    (void) service_data;        /* we could use these... */
+    len = rp_ack_decode_service_request(service_request,
+        service_len, &data);
+#if 0
+    fprintf(stderr, "Received Read-Property Ack!\n");
+#endif
+    if (len > 0)
+        PrintReadPropertyData(&data);
 }

bacnet-stack/demo/handler/h_whohas.c

@@ -35,65 +35,51 @@
 #include "device.h"
 #include "client.h"
 
-void handler_who_has(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src)
+void handler_who_has(uint8_t * service_request,
+    uint16_t service_len, BACNET_ADDRESS * src)
 {
-  int len = 0;
-  BACNET_WHO_HAS_DATA data;
-  bool directed_to_me = false;
-  int object_type = 0;
-  uint32_t object_instance = 0;
-  char *object_name = NULL;
-  bool found = false;
+    int len = 0;
+    BACNET_WHO_HAS_DATA data;
+    bool directed_to_me = false;
+    int object_type = 0;
+    uint32_t object_instance = 0;
+    char *object_name = NULL;
+    bool found = false;
 
-  (void)src;
-  len = whohas_decode_service_request(
-    service_request,
-    service_len,
-    &data);
-  if (len > 0)
-  { 
-    if ((data.low_limit == -1)  || (data.high_limit == -1))
-      directed_to_me = true;
-    else if ((Device_Object_Instance_Number() >= (uint32_t)data.low_limit) &&
-      (Device_Object_Instance_Number() <= (uint32_t)data.high_limit))
-      directed_to_me = true;
-    if (directed_to_me)
-    {
-      /* do we have such an object?  If so, send an I-Have.
-         note: we should have only 1 of such an object */
-      if (data.object_name)
-      {
-        /* valid name in my device? */
-        object_name = characterstring_value(&data.object.name);
-        found = Device_Valid_Object_Name(
-          object_name,
-          &object_type, 
-          &object_instance);
-        if (found)
-          Send_I_Have(
-            Device_Object_Instance_Number(),
-            object_type,
-            object_instance,
-            object_name);
-      }
-      else
-      {
-        /* valid object in my device? */
-        object_name = Device_Valid_Object_Id(
-          data.object.identifier.type, 
-          data.object.identifier.instance);
-        if (object_name)
-          Send_I_Have(
-            Device_Object_Instance_Number(),
-            data.object.identifier.type,
-            data.object.identifier.instance,
-            object_name);
-      }
+    (void) src;
+    len = whohas_decode_service_request(service_request,
+        service_len, &data);
+    if (len > 0) {
+        if ((data.low_limit == -1) || (data.high_limit == -1))
+            directed_to_me = true;
+        else if ((Device_Object_Instance_Number() >=
+                (uint32_t) data.low_limit)
+            && (Device_Object_Instance_Number() <=
+                (uint32_t) data.high_limit))
+            directed_to_me = true;
+        if (directed_to_me) {
+            /* do we have such an object?  If so, send an I-Have.
+               note: we should have only 1 of such an object */
+            if (data.object_name) {
+                /* valid name in my device? */
+                object_name = characterstring_value(&data.object.name);
+                found = Device_Valid_Object_Name(object_name,
+                    &object_type, &object_instance);
+                if (found)
+                    Send_I_Have(Device_Object_Instance_Number(),
+                        object_type, object_instance, object_name);
+            } else {
+                /* valid object in my device? */
+                object_name =
+                    Device_Valid_Object_Id(data.object.identifier.type,
+                    data.object.identifier.instance);
+                if (object_name)
+                    Send_I_Have(Device_Object_Instance_Number(),
+                        data.object.identifier.type,
+                        data.object.identifier.instance, object_name);
+            }
+        }
     }
-  }
 
-  return;  
+    return;
 }

bacnet-stack/demo/handler/h_whois.c

@@ -37,31 +37,25 @@
 /* global flag to send an I-Am */
 bool I_Am_Request = true;
 
-void handler_who_is(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src)
+void handler_who_is(uint8_t * service_request,
+    uint16_t service_len, BACNET_ADDRESS * src)
 {
-  int len = 0;
-  int32_t low_limit = 0;
-  int32_t high_limit = 0;
+    int len = 0;
+    int32_t low_limit = 0;
+    int32_t high_limit = 0;
 
-  (void)src;
-  len = whois_decode_service_request(
-    service_request,
-    service_len,
-    &low_limit,
-    &high_limit);
-  /* in our simple system, we just set a flag and let the main loop
-     send the I-Am request. */
-  if (len == 0)
-    I_Am_Request = true;
-  else if (len != -1)
-  { 
-    if ((Device_Object_Instance_Number() >= (uint32_t)low_limit) && 
-        (Device_Object_Instance_Number() <= (uint32_t)high_limit))
-      I_Am_Request = true;
-  }
+    (void) src;
+    len = whois_decode_service_request(service_request,
+        service_len, &low_limit, &high_limit);
+    /* in our simple system, we just set a flag and let the main loop
+       send the I-Am request. */
+    if (len == 0)
+        I_Am_Request = true;
+    else if (len != -1) {
+        if ((Device_Object_Instance_Number() >= (uint32_t) low_limit) &&
+            (Device_Object_Instance_Number() <= (uint32_t) high_limit))
+            I_Am_Request = true;
+    }
 
-  return;  
+    return;
 }

bacnet-stack/demo/handler/h_wp.c

@@ -43,132 +43,101 @@
 #include "bacfile.h"
 #endif
 
-void handler_write_property(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src,
-  BACNET_CONFIRMED_SERVICE_DATA *service_data)
+void handler_write_property(uint8_t * service_request,
+    uint16_t service_len,
+    BACNET_ADDRESS * src, BACNET_CONFIRMED_SERVICE_DATA * service_data)
 {
-  BACNET_WRITE_PROPERTY_DATA wp_data;
-  int len = 0;
-  int pdu_len = 0;
-  BACNET_ADDRESS my_address;
-  BACNET_ERROR_CLASS error_class = ERROR_CLASS_OBJECT;
-  BACNET_ERROR_CODE error_code = ERROR_CODE_UNKNOWN_OBJECT;
-  int bytes_sent = 0;
+    BACNET_WRITE_PROPERTY_DATA wp_data;
+    int len = 0;
+    int pdu_len = 0;
+    BACNET_ADDRESS my_address;
+    BACNET_ERROR_CLASS error_class = ERROR_CLASS_OBJECT;
+    BACNET_ERROR_CODE error_code = ERROR_CODE_UNKNOWN_OBJECT;
+    int bytes_sent = 0;
 
-  // decode the service request only
-  len = wp_decode_service_request(
-    service_request,
-    service_len,
-    &wp_data);
-  fprintf(stderr,"Received Write-Property Request!\n");
-  if (len > 0)
-    fprintf(stderr,"type=%u instance=%u property=%u index=%d\n",
-      wp_data.object_type,
-      wp_data.object_instance,
-      wp_data.object_property,
-      wp_data.array_index);
-  else
-    fprintf(stderr,"Unable to decode Write-Property Request!\n");
-  // prepare a reply
-  datalink_get_my_address(&my_address);
-  // encode the NPDU portion of the packet
-  pdu_len = npdu_encode_apdu(
-    &Handler_Transmit_Buffer[0],
-    src,
-    &my_address,
-    false,  // true for confirmed messages
-    MESSAGE_PRIORITY_NORMAL);
-  // bad decoding or something we didn't understand - send an abort
-  if (len == -1)
-  {
-    pdu_len += abort_encode_apdu(
-      &Handler_Transmit_Buffer[pdu_len],
-      service_data->invoke_id,
-      ABORT_REASON_OTHER);
-    fprintf(stderr,"Sending Abort!\n");
-  }
-  else if (service_data->segmented_message)
-  {
-    pdu_len += abort_encode_apdu(
-      &Handler_Transmit_Buffer[pdu_len],
-      service_data->invoke_id,
-      ABORT_REASON_SEGMENTATION_NOT_SUPPORTED);
-    fprintf(stderr,"Sending Abort!\n");
-  }
-  else
-  {
-    switch (wp_data.object_type)
-    {
-      case OBJECT_DEVICE:
-        if (Device_Write_Property(&wp_data,&error_class,&error_code))
-        {
-          pdu_len += encode_simple_ack(
-            &Handler_Transmit_Buffer[pdu_len],
+    // decode the service request only
+    len = wp_decode_service_request(service_request,
+        service_len, &wp_data);
+    fprintf(stderr, "Received Write-Property Request!\n");
+    if (len > 0)
+        fprintf(stderr, "type=%u instance=%u property=%u index=%d\n",
+            wp_data.object_type,
+            wp_data.object_instance,
+            wp_data.object_property, wp_data.array_index);
+    else
+        fprintf(stderr, "Unable to decode Write-Property Request!\n");
+    // prepare a reply
+    datalink_get_my_address(&my_address);
+    // encode the NPDU portion of the packet
+    pdu_len = npdu_encode_apdu(&Handler_Transmit_Buffer[0], src, &my_address, false,    // true for confirmed messages
+        MESSAGE_PRIORITY_NORMAL);
+    // bad decoding or something we didn't understand - send an abort
+    if (len == -1) {
+        pdu_len += abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+            service_data->invoke_id, ABORT_REASON_OTHER);
+        fprintf(stderr, "Sending Abort!\n");
+    } else if (service_data->segmented_message) {
+        pdu_len += abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
             service_data->invoke_id,
-            SERVICE_CONFIRMED_WRITE_PROPERTY);
-          fprintf(stderr,"Sending Write Property Simple Ack!\n");
+            ABORT_REASON_SEGMENTATION_NOT_SUPPORTED);
+        fprintf(stderr, "Sending Abort!\n");
+    } else {
+        switch (wp_data.object_type) {
+        case OBJECT_DEVICE:
+            if (Device_Write_Property(&wp_data, &error_class, &error_code)) {
+                pdu_len +=
+                    encode_simple_ack(&Handler_Transmit_Buffer[pdu_len],
+                    service_data->invoke_id,
+                    SERVICE_CONFIRMED_WRITE_PROPERTY);
+                fprintf(stderr, "Sending Write Property Simple Ack!\n");
+            } else {
+                pdu_len +=
+                    bacerror_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+                    service_data->invoke_id,
+                    SERVICE_CONFIRMED_WRITE_PROPERTY, error_class,
+                    error_code);
+                fprintf(stderr, "Sending Write Property Error!\n");
+            }
+            break;
+        case OBJECT_ANALOG_INPUT:
+            error_class = ERROR_CLASS_PROPERTY;
+            error_code = ERROR_CODE_WRITE_ACCESS_DENIED;
+            pdu_len +=
+                bacerror_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+                service_data->invoke_id, SERVICE_CONFIRMED_WRITE_PROPERTY,
+                error_class, error_code);
+            fprintf(stderr, "Sending Write Access Error!\n");
+            break;
+        case OBJECT_ANALOG_OUTPUT:
+            if (Analog_Output_Write_Property(&wp_data, &error_class,
+                    &error_code)) {
+                pdu_len +=
+                    encode_simple_ack(&Handler_Transmit_Buffer[pdu_len],
+                    service_data->invoke_id,
+                    SERVICE_CONFIRMED_WRITE_PROPERTY);
+                fprintf(stderr, "Sending Write Property Simple Ack!\n");
+            } else {
+                pdu_len +=
+                    bacerror_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+                    service_data->invoke_id,
+                    SERVICE_CONFIRMED_WRITE_PROPERTY, error_class,
+                    error_code);
+                fprintf(stderr, "Sending Write Access Error!\n");
+            }
+            break;
+        default:
+            pdu_len +=
+                bacerror_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+                service_data->invoke_id, SERVICE_CONFIRMED_WRITE_PROPERTY,
+                error_class, error_code);
+            fprintf(stderr, "Sending Unknown Object Error!\n");
+            break;
         }
-        else
-        {
-          pdu_len += bacerror_encode_apdu(
-            &Handler_Transmit_Buffer[pdu_len],
-            service_data->invoke_id,
-            SERVICE_CONFIRMED_WRITE_PROPERTY,
-            error_class,
-            error_code);
-          fprintf(stderr,"Sending Write Property Error!\n");
-        }
-        break;
-      case OBJECT_ANALOG_INPUT:
-        error_class = ERROR_CLASS_PROPERTY;
-        error_code = ERROR_CODE_WRITE_ACCESS_DENIED;
-        pdu_len += bacerror_encode_apdu(
-          &Handler_Transmit_Buffer[pdu_len],
-          service_data->invoke_id,
-          SERVICE_CONFIRMED_WRITE_PROPERTY,
-          error_class,
-          error_code);
-        fprintf(stderr,"Sending Write Access Error!\n");
-        break;
-      case OBJECT_ANALOG_OUTPUT:
-        if (Analog_Output_Write_Property(&wp_data,&error_class,&error_code))
-        {
-          pdu_len += encode_simple_ack(
-            &Handler_Transmit_Buffer[pdu_len],
-            service_data->invoke_id,
-            SERVICE_CONFIRMED_WRITE_PROPERTY);
-          fprintf(stderr,"Sending Write Property Simple Ack!\n");
-        }
-        else
-        {
-          pdu_len += bacerror_encode_apdu(
-            &Handler_Transmit_Buffer[pdu_len],
-            service_data->invoke_id,
-            SERVICE_CONFIRMED_WRITE_PROPERTY,
-            error_class,
-            error_code);
-          fprintf(stderr,"Sending Write Access Error!\n");
-  }
-        break;
-      default:
-        pdu_len += bacerror_encode_apdu(
-          &Handler_Transmit_Buffer[pdu_len],
-          service_data->invoke_id,
-          SERVICE_CONFIRMED_WRITE_PROPERTY,
-          error_class,
-          error_code);
-        fprintf(stderr,"Sending Unknown Object Error!\n");
-        break;
     }
-  }
-  bytes_sent = datalink_send_pdu(
-    src,  // destination address
-    &Handler_Transmit_Buffer[0],
-    pdu_len); // number of bytes of data
-  if (bytes_sent <= 0)
-    fprintf(stderr,"Failed to send PDU (%s)!\n", strerror(errno));
+    bytes_sent = datalink_send_pdu(src, // destination address
+        &Handler_Transmit_Buffer[0], pdu_len);  // number of bytes of data
+    if (bytes_sent <= 0)
+        fprintf(stderr, "Failed to send PDU (%s)!\n", strerror(errno));
 
-  return;
+    return;
 }

bacnet-stack/demo/handler/handlers.h

@@ -37,83 +37,64 @@ extern bool I_Am_Request;
 
 #ifdef __cplusplus
 extern "C" {
-#endif /* __cplusplus */
+#endif                          /* __cplusplus */
 
-void handler_unrecognized_service(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *dest,
-  BACNET_CONFIRMED_SERVICE_DATA *service_data);
+    void handler_unrecognized_service(uint8_t * service_request,
+        uint16_t service_len,
+        BACNET_ADDRESS * dest,
+        BACNET_CONFIRMED_SERVICE_DATA * service_data);
 
-void handler_who_is(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src);
-  
-void handler_who_has(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src);
+    void handler_who_is(uint8_t * service_request,
+        uint16_t service_len, BACNET_ADDRESS * src);
 
-void handler_i_am_add(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src);
-  
-void handler_i_am_bind(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src);
-  
-void handler_read_property(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src,
-  BACNET_CONFIRMED_SERVICE_DATA *service_data);
+    void handler_who_has(uint8_t * service_request,
+        uint16_t service_len, BACNET_ADDRESS * src);
 
-void handler_read_property_ack(
-    uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src,
-  BACNET_CONFIRMED_SERVICE_ACK_DATA *service_data);
+    void handler_i_am_add(uint8_t * service_request,
+        uint16_t service_len, BACNET_ADDRESS * src);
 
-void handler_write_property(
-    uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src,
-  BACNET_CONFIRMED_SERVICE_DATA *service_data);
+    void handler_i_am_bind(uint8_t * service_request,
+        uint16_t service_len, BACNET_ADDRESS * src);
 
-void handler_atomic_read_file(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src,
-  BACNET_CONFIRMED_SERVICE_DATA *service_data);
+    void handler_read_property(uint8_t * service_request,
+        uint16_t service_len,
+        BACNET_ADDRESS * src,
+        BACNET_CONFIRMED_SERVICE_DATA * service_data);
 
-void handler_atomic_read_file_ack(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src,
-  BACNET_CONFIRMED_SERVICE_ACK_DATA *service_data);
+    void handler_read_property_ack(uint8_t * service_request,
+        uint16_t service_len,
+        BACNET_ADDRESS * src,
+        BACNET_CONFIRMED_SERVICE_ACK_DATA * service_data);
 
-void handler_reinitialize_device(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src,
-  BACNET_CONFIRMED_SERVICE_DATA *service_data);
+    void handler_write_property(uint8_t * service_request,
+        uint16_t service_len,
+        BACNET_ADDRESS * src,
+        BACNET_CONFIRMED_SERVICE_DATA * service_data);
 
-void handler_device_communication_control(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src,
-  BACNET_CONFIRMED_SERVICE_DATA *service_data);
+    void handler_atomic_read_file(uint8_t * service_request,
+        uint16_t service_len,
+        BACNET_ADDRESS * src,
+        BACNET_CONFIRMED_SERVICE_DATA * service_data);
 
-void handler_i_have(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *src);
+    void handler_atomic_read_file_ack(uint8_t * service_request,
+        uint16_t service_len,
+        BACNET_ADDRESS * src,
+        BACNET_CONFIRMED_SERVICE_ACK_DATA * service_data);
+
+    void handler_reinitialize_device(uint8_t * service_request,
+        uint16_t service_len,
+        BACNET_ADDRESS * src,
+        BACNET_CONFIRMED_SERVICE_DATA * service_data);
+
+    void handler_device_communication_control(uint8_t * service_request,
+        uint16_t service_len,
+        BACNET_ADDRESS * src,
+        BACNET_CONFIRMED_SERVICE_DATA * service_data);
+
+    void handler_i_have(uint8_t * service_request,
+        uint16_t service_len, BACNET_ADDRESS * src);
 
 #ifdef __cplusplus
 }
-#endif /* __cplusplus */
-
+#endif                          /* __cplusplus */
 #endif

bacnet-stack/demo/handler/noserv.c

@@ -34,40 +34,30 @@
 #include "npdu.h"
 #include "reject.h"
 
-void handler_unrecognized_service(
-  uint8_t *service_request,
-  uint16_t service_len,
-  BACNET_ADDRESS *dest,
-  BACNET_CONFIRMED_SERVICE_DATA *service_data)
+void handler_unrecognized_service(uint8_t * service_request,
+    uint16_t service_len,
+    BACNET_ADDRESS * dest, BACNET_CONFIRMED_SERVICE_DATA * service_data)
 {
-  BACNET_ADDRESS src;
-  int pdu_len = 0;
-  int bytes_sent = 0;
-  
-  (void)service_request;
-  (void)service_len;
-  datalink_get_my_address(&src);
+    BACNET_ADDRESS src;
+    int pdu_len = 0;
+    int bytes_sent = 0;
 
-  // encode the NPDU portion of the packet
-  pdu_len = npdu_encode_apdu(
-    &Handler_Transmit_Buffer[0],
-    dest,
-    &src,
-    false,  // true for confirmed messages
-    MESSAGE_PRIORITY_NORMAL);
-  
-  // encode the APDU portion of the packet
-  pdu_len += reject_encode_apdu(
-    &Handler_Transmit_Buffer[pdu_len], 
-    service_data->invoke_id,
-    REJECT_REASON_UNRECOGNIZED_SERVICE);
+    (void) service_request;
+    (void) service_len;
+    datalink_get_my_address(&src);
 
-  bytes_sent = datalink_send_pdu(
-    dest,  // destination address
-    &Handler_Transmit_Buffer[0],
-    pdu_len); // number of bytes of data
-  if (bytes_sent > 0)
-    fprintf(stderr,"Sent Reject!\n");
-  else
-    fprintf(stderr,"Failed to Send Reject (%s)!\n", strerror(errno));
+    // encode the NPDU portion of the packet
+    pdu_len = npdu_encode_apdu(&Handler_Transmit_Buffer[0], dest, &src, false,  // true for confirmed messages
+        MESSAGE_PRIORITY_NORMAL);
+
+    // encode the APDU portion of the packet
+    pdu_len += reject_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+        service_data->invoke_id, REJECT_REASON_UNRECOGNIZED_SERVICE);
+
+    bytes_sent = datalink_send_pdu(dest,        // destination address
+        &Handler_Transmit_Buffer[0], pdu_len);  // number of bytes of data
+    if (bytes_sent > 0)
+        fprintf(stderr, "Sent Reject!\n");
+    else
+        fprintf(stderr, "Failed to Send Reject (%s)!\n", strerror(errno));
 }

bacnet-stack/demo/handler/s_dcc.c

@@ -41,73 +41,56 @@
 #include "handlers.h"
 #include "txbuf.h"
 
-uint8_t Send_Device_Communication_Control_Request(
-  uint32_t device_id,
-  uint16_t timeDuration, /* 0=optional */
-  BACNET_COMMUNICATION_ENABLE_DISABLE state,
-  char *password) /* NULL=optional */
-{
-  BACNET_ADDRESS dest;
-  BACNET_ADDRESS my_address;
-  unsigned max_apdu = 0;
-  uint8_t invoke_id = 0;
-  bool status = false;
-  int pdu_len = 0;
-  int bytes_sent = 0;
-  BACNET_CHARACTER_STRING password_string;
+uint8_t Send_Device_Communication_Control_Request(uint32_t device_id, uint16_t timeDuration,    /* 0=optional */
+    BACNET_COMMUNICATION_ENABLE_DISABLE state, char *password)
+{                               /* NULL=optional */
+    BACNET_ADDRESS dest;
+    BACNET_ADDRESS my_address;
+    unsigned max_apdu = 0;
+    uint8_t invoke_id = 0;
+    bool status = false;
+    int pdu_len = 0;
+    int bytes_sent = 0;
+    BACNET_CHARACTER_STRING password_string;
 
-  if (!dcc_communication_enabled())
-    return 0;
+    if (!dcc_communication_enabled())
+        return 0;
 
-  /* is the device bound? */
-  status = address_get_by_device(device_id, &max_apdu, &dest);
-  /* is there a tsm available? */
-  if (status)
-     status = tsm_transaction_available();
-  if (status)
-  {
-    datalink_get_my_address(&my_address);
-    pdu_len = npdu_encode_apdu(
-      &Handler_Transmit_Buffer[0],
-      &dest,
-      &my_address,
-      true,  // true for confirmed messages
-      MESSAGE_PRIORITY_NORMAL);
+    /* is the device bound? */
+    status = address_get_by_device(device_id, &max_apdu, &dest);
+    /* is there a tsm available? */
+    if (status)
+        status = tsm_transaction_available();
+    if (status) {
+        datalink_get_my_address(&my_address);
+        pdu_len = npdu_encode_apdu(&Handler_Transmit_Buffer[0], &dest, &my_address, true,       // true for confirmed messages
+            MESSAGE_PRIORITY_NORMAL);
 
-    invoke_id = tsm_next_free_invokeID();
-    // load the data for the encoding
-    characterstring_init_ansi(&password_string,password);
-    pdu_len += dcc_encode_apdu(
-      &Handler_Transmit_Buffer[pdu_len],
-      invoke_id,
-      timeDuration,
-      state,
-      password?&password_string:NULL);
-    /* will it fit in the sender?
-       note: if there is a bottleneck router in between
-       us and the destination, we won't know unless
-       we have a way to check for that and update the
-       max_apdu in the address binding table. */
-    if ((unsigned)pdu_len < max_apdu)
-    {
-      tsm_set_confirmed_unsegmented_transaction(
-        invoke_id,
-        &dest,
-        &Handler_Transmit_Buffer[0],
-        pdu_len);
-      bytes_sent = datalink_send_pdu(
-        &dest,  // destination address
-        &Handler_Transmit_Buffer[0],
-        pdu_len); // number of bytes of data
-      if (bytes_sent <= 0)
-        fprintf(stderr,"Failed to Send DeviceCommunicationControl Request (%s)!\n",
-          strerror(errno));
+        invoke_id = tsm_next_free_invokeID();
+        // load the data for the encoding
+        characterstring_init_ansi(&password_string, password);
+        pdu_len += dcc_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+            invoke_id,
+            timeDuration, state, password ? &password_string : NULL);
+        /* will it fit in the sender?
+           note: if there is a bottleneck router in between
+           us and the destination, we won't know unless
+           we have a way to check for that and update the
+           max_apdu in the address binding table. */
+        if ((unsigned) pdu_len < max_apdu) {
+            tsm_set_confirmed_unsegmented_transaction(invoke_id,
+                &dest, &Handler_Transmit_Buffer[0], pdu_len);
+            bytes_sent = datalink_send_pdu(&dest,       // destination address
+                &Handler_Transmit_Buffer[0], pdu_len);  // number of bytes of data
+            if (bytes_sent <= 0)
+                fprintf(stderr,
+                    "Failed to Send DeviceCommunicationControl Request (%s)!\n",
+                    strerror(errno));
+        } else
+            fprintf(stderr,
+                "Failed to Send DeviceCommunicationControl Request "
+                "(exceeds destination maximum APDU)!\n");
     }
-    else
-      fprintf(stderr,"Failed to Send DeviceCommunicationControl Request "
-        "(exceeds destination maximum APDU)!\n");
-  }
-  
-  return invoke_id;
-}
 
+    return invoke_id;
+}

bacnet-stack/demo/handler/s_ihave.c

@@ -43,43 +43,34 @@
 #include "txbuf.h"
 
 /* find a specific device, or use -1 for limit if you want unlimited */
-void Send_I_Have(
-  uint32_t device_id,
-  BACNET_OBJECT_TYPE object_type,
-  uint32_t object_instance,
-  char *object_name)
+void Send_I_Have(uint32_t device_id,
+    BACNET_OBJECT_TYPE object_type,
+    uint32_t object_instance, char *object_name)
 {
-  int pdu_len = 0;
-  BACNET_ADDRESS dest;
-  int bytes_sent = 0;
-  BACNET_I_HAVE_DATA data;
+    int pdu_len = 0;
+    BACNET_ADDRESS dest;
+    int bytes_sent = 0;
+    BACNET_I_HAVE_DATA data;
 
-  /* if we are forbidden to send, don't send! */
-  if (!dcc_communication_enabled())
-    return;
-  /* Who-Has is a global broadcast */
-  datalink_get_broadcast_address(&dest);
-  /* encode the NPDU portion of the packet */
-  pdu_len = npdu_encode_apdu(
-    &Handler_Transmit_Buffer[0],
-    &dest,
-    NULL,
-    false,  /* true for confirmed messages */
-    MESSAGE_PRIORITY_NORMAL);
-  /* encode the APDU portion of the packet */
-  data.device_id.type = OBJECT_DEVICE;
-  data.device_id.instance = device_id;
-  data.object_id.type = object_type;
-  data.object_id.instance = object_instance;
-  characterstring_init_ansi(&data.object_name,object_name);
-  pdu_len += ihave_encode_apdu(
-    &Handler_Transmit_Buffer[pdu_len],
-    &data);
-  /* send the data */
-  bytes_sent = datalink_send_pdu(
-    &dest,  // destination address
-    &Handler_Transmit_Buffer[0],
-    pdu_len); // number of bytes of data
-  if (bytes_sent <= 0)
-    fprintf(stderr,"Failed to Send I-Have Reply (%s)!\n", strerror(errno));
+    /* if we are forbidden to send, don't send! */
+    if (!dcc_communication_enabled())
+        return;
+    /* Who-Has is a global broadcast */
+    datalink_get_broadcast_address(&dest);
+    /* encode the NPDU portion of the packet */
+    pdu_len = npdu_encode_apdu(&Handler_Transmit_Buffer[0], &dest, NULL, false, /* true for confirmed messages */
+        MESSAGE_PRIORITY_NORMAL);
+    /* encode the APDU portion of the packet */
+    data.device_id.type = OBJECT_DEVICE;
+    data.device_id.instance = device_id;
+    data.object_id.type = object_type;
+    data.object_id.instance = object_instance;
+    characterstring_init_ansi(&data.object_name, object_name);
+    pdu_len += ihave_encode_apdu(&Handler_Transmit_Buffer[pdu_len], &data);
+    /* send the data */
+    bytes_sent = datalink_send_pdu(&dest,       // destination address
+        &Handler_Transmit_Buffer[0], pdu_len);  // number of bytes of data
+    if (bytes_sent <= 0)
+        fprintf(stderr, "Failed to Send I-Have Reply (%s)!\n",
+            strerror(errno));
 }

bacnet-stack/demo/handler/s_rd.c

@@ -42,71 +42,54 @@
 #include "handlers.h"
 #include "txbuf.h"
 
-uint8_t Send_Reinitialize_Device_Request(
-  uint32_t device_id,
-  BACNET_REINITIALIZED_STATE state,
-  char *password)
+uint8_t Send_Reinitialize_Device_Request(uint32_t device_id,
+    BACNET_REINITIALIZED_STATE state, char *password)
 {
-  BACNET_ADDRESS dest;
-  BACNET_ADDRESS my_address;
-  unsigned max_apdu = 0;
-  uint8_t invoke_id = 0;
-  bool status = false;
-  int pdu_len = 0;
-  int bytes_sent = 0;
-  BACNET_CHARACTER_STRING password_string;
+    BACNET_ADDRESS dest;
+    BACNET_ADDRESS my_address;
+    unsigned max_apdu = 0;
+    uint8_t invoke_id = 0;
+    bool status = false;
+    int pdu_len = 0;
+    int bytes_sent = 0;
+    BACNET_CHARACTER_STRING password_string;
 
-  if (!dcc_communication_enabled())
-    return 0;
+    if (!dcc_communication_enabled())
+        return 0;
 
-  /* is the device bound? */
-  status = address_get_by_device(device_id, &max_apdu, &dest);
-  /* is there a tsm available? */
-  if (status)
-     status = tsm_transaction_available();
-  if (status)
-  {
-    datalink_get_my_address(&my_address);
-    pdu_len = npdu_encode_apdu(
-      &Handler_Transmit_Buffer[0],
-      &dest,
-      &my_address,
-      true,  // true for confirmed messages
-      MESSAGE_PRIORITY_NORMAL);
+    /* is the device bound? */
+    status = address_get_by_device(device_id, &max_apdu, &dest);
+    /* is there a tsm available? */
+    if (status)
+        status = tsm_transaction_available();
+    if (status) {
+        datalink_get_my_address(&my_address);
+        pdu_len = npdu_encode_apdu(&Handler_Transmit_Buffer[0], &dest, &my_address, true,       // true for confirmed messages
+            MESSAGE_PRIORITY_NORMAL);
 
-    invoke_id = tsm_next_free_invokeID();
-    // load the data for the encoding
-    characterstring_init_ansi(&password_string,password);
-    pdu_len += rd_encode_apdu(
-      &Handler_Transmit_Buffer[pdu_len],
-      invoke_id,
-      state,
-      password?&password_string:NULL);
-    /* will it fit in the sender?
-       note: if there is a bottleneck router in between
-       us and the destination, we won't know unless
-       we have a way to check for that and update the
-       max_apdu in the address binding table. */
-    if ((unsigned)pdu_len < max_apdu)
-    {
-      tsm_set_confirmed_unsegmented_transaction(
-        invoke_id,
-        &dest,
-        &Handler_Transmit_Buffer[0],
-        pdu_len);
-      bytes_sent = datalink_send_pdu(
-        &dest,  // destination address
-        &Handler_Transmit_Buffer[0],
-        pdu_len); // number of bytes of data
-      if (bytes_sent <= 0)
-        fprintf(stderr,"Failed to Send ReinitializeDevice Request (%s)!\n",
-          strerror(errno));
+        invoke_id = tsm_next_free_invokeID();
+        // load the data for the encoding
+        characterstring_init_ansi(&password_string, password);
+        pdu_len += rd_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+            invoke_id, state, password ? &password_string : NULL);
+        /* will it fit in the sender?
+           note: if there is a bottleneck router in between
+           us and the destination, we won't know unless
+           we have a way to check for that and update the
+           max_apdu in the address binding table. */
+        if ((unsigned) pdu_len < max_apdu) {
+            tsm_set_confirmed_unsegmented_transaction(invoke_id,
+                &dest, &Handler_Transmit_Buffer[0], pdu_len);
+            bytes_sent = datalink_send_pdu(&dest,       // destination address
+                &Handler_Transmit_Buffer[0], pdu_len);  // number of bytes of data
+            if (bytes_sent <= 0)
+                fprintf(stderr,
+                    "Failed to Send ReinitializeDevice Request (%s)!\n",
+                    strerror(errno));
+        } else
+            fprintf(stderr, "Failed to Send ReinitializeDevice Request "
+                "(exceeds destination maximum APDU)!\n");
     }
-    else
-      fprintf(stderr,"Failed to Send ReinitializeDevice Request "
-        "(exceeds destination maximum APDU)!\n");
-  }
-  
-  return invoke_id;
-}
 
+    return invoke_id;
+}

bacnet-stack/demo/handler/s_rp.c

@@ -43,74 +43,59 @@
 #include "txbuf.h"
 
 /* returns invoke id of 0 if device is not bound or no tsm available */
-uint8_t Send_Read_Property_Request(
-  uint32_t device_id, /* destination device */
-  BACNET_OBJECT_TYPE object_type,
-  uint32_t object_instance,
-  BACNET_PROPERTY_ID object_property,
-  int32_t array_index)
+uint8_t Send_Read_Property_Request(uint32_t device_id,  /* destination device */
+    BACNET_OBJECT_TYPE object_type,
+    uint32_t object_instance,
+    BACNET_PROPERTY_ID object_property, int32_t array_index)
 {
-  BACNET_ADDRESS dest;
-  BACNET_ADDRESS my_address;
-  unsigned max_apdu = 0;
-  uint8_t invoke_id = 0;
-  bool status = false;
-  int pdu_len = 0;
-  int bytes_sent = 0;
-  BACNET_READ_PROPERTY_DATA data;
+    BACNET_ADDRESS dest;
+    BACNET_ADDRESS my_address;
+    unsigned max_apdu = 0;
+    uint8_t invoke_id = 0;
+    bool status = false;
+    int pdu_len = 0;
+    int bytes_sent = 0;
+    BACNET_READ_PROPERTY_DATA data;
 
-  if (!dcc_communication_enabled())
-    return 0;
+    if (!dcc_communication_enabled())
+        return 0;
 
-  /* is the device bound? */
-  status = address_get_by_device(device_id, &max_apdu, &dest);
-  /* is there a tsm available? */
-  if (status)
-    status = tsm_transaction_available();
-  if (status)
-  {
-    datalink_get_my_address(&my_address);
-    pdu_len = npdu_encode_apdu(
-        &Handler_Transmit_Buffer[0],
-    &dest,
-    &my_address,
-    true,  // true for confirmed messages
-    MESSAGE_PRIORITY_NORMAL);
+    /* is the device bound? */
+    status = address_get_by_device(device_id, &max_apdu, &dest);
+    /* is there a tsm available? */
+    if (status)
+        status = tsm_transaction_available();
+    if (status) {
+        datalink_get_my_address(&my_address);
+        pdu_len = npdu_encode_apdu(&Handler_Transmit_Buffer[0], &dest, &my_address, true,       // true for confirmed messages
+            MESSAGE_PRIORITY_NORMAL);
 
-    invoke_id = tsm_next_free_invokeID();
-    // load the data for the encoding
-    data.object_type = object_type;
-    data.object_instance = object_instance;
-    data.object_property = object_property;
-    data.array_index = array_index;
-    pdu_len += rp_encode_apdu(
-        &Handler_Transmit_Buffer[pdu_len],
-    invoke_id,
-    &data);
-    /* will it fit in the sender?
-    note: if there is a bottleneck router in between
-    us and the destination, we won't know unless
-    we have a way to check for that and update the
-    max_apdu in the address binding table. */
-    if ((unsigned)pdu_len < max_apdu)
-    {
-      tsm_set_confirmed_unsegmented_transaction(
-          invoke_id,
-      &dest,
-      &Handler_Transmit_Buffer[0],
-      pdu_len);
-      bytes_sent = datalink_send_pdu(
-          &dest,  // destination address
-      &Handler_Transmit_Buffer[0],
-      pdu_len); // number of bytes of data
-      if (bytes_sent <= 0)
-        fprintf(stderr,"Failed to Send ReadProperty Request (%s)!\n",
-                strerror(errno));
+        invoke_id = tsm_next_free_invokeID();
+        // load the data for the encoding
+        data.object_type = object_type;
+        data.object_instance = object_instance;
+        data.object_property = object_property;
+        data.array_index = array_index;
+        pdu_len += rp_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+            invoke_id, &data);
+        /* will it fit in the sender?
+           note: if there is a bottleneck router in between
+           us and the destination, we won't know unless
+           we have a way to check for that and update the
+           max_apdu in the address binding table. */
+        if ((unsigned) pdu_len < max_apdu) {
+            tsm_set_confirmed_unsegmented_transaction(invoke_id,
+                &dest, &Handler_Transmit_Buffer[0], pdu_len);
+            bytes_sent = datalink_send_pdu(&dest,       // destination address
+                &Handler_Transmit_Buffer[0], pdu_len);  // number of bytes of data
+            if (bytes_sent <= 0)
+                fprintf(stderr,
+                    "Failed to Send ReadProperty Request (%s)!\n",
+                    strerror(errno));
+        } else
+            fprintf(stderr, "Failed to Send ReadProperty Request "
+                "(exceeds destination maximum APDU)!\n");
     }
-    else
-      fprintf(stderr,"Failed to Send ReadProperty Request "
-          "(exceeds destination maximum APDU)!\n");
-  }
 
-  return invoke_id;
+    return invoke_id;
 }

bacnet-stack/demo/handler/s_whohas.c

@@ -43,83 +43,67 @@
 #include "txbuf.h"
 
 /* find a specific device, or use -1 for limit if you want unlimited */
-void Send_WhoHas_Name(
-  int32_t low_limit,
-  int32_t high_limit,
-  char *object_name)
+void Send_WhoHas_Name(int32_t low_limit,
+    int32_t high_limit, char *object_name)
 {
-  int pdu_len = 0;
-  BACNET_ADDRESS dest;
-  int bytes_sent = 0;
-  BACNET_WHO_HAS_DATA data;
+    int pdu_len = 0;
+    BACNET_ADDRESS dest;
+    int bytes_sent = 0;
+    BACNET_WHO_HAS_DATA data;
 
-  /* if we are forbidden to send, don't send! */
-  if (!dcc_communication_enabled())
-    return;
-  /* Who-Has is a global broadcast */
-  datalink_get_broadcast_address(&dest);
-  /* encode the NPDU portion of the packet */
-  pdu_len = npdu_encode_apdu(
-    &Handler_Transmit_Buffer[0],
-    &dest,
-    NULL,
-    false,  /* true for confirmed messages */
-    MESSAGE_PRIORITY_NORMAL);
-  /* encode the APDU portion of the packet */
-  data.low_limit = 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[pdu_len],
-    &data);
-  /* send the data */
-  bytes_sent = datalink_send_pdu(
-    &dest,  // destination address
-    &Handler_Transmit_Buffer[0],
-    pdu_len); // number of bytes of data
-  if (bytes_sent <= 0)
-    fprintf(stderr,"Failed to Send Who-Has Request (%s)!\n", strerror(errno));
+    /* if we are forbidden to send, don't send! */
+    if (!dcc_communication_enabled())
+        return;
+    /* Who-Has is a global broadcast */
+    datalink_get_broadcast_address(&dest);
+    /* encode the NPDU portion of the packet */
+    pdu_len = npdu_encode_apdu(&Handler_Transmit_Buffer[0], &dest, NULL, false, /* true for confirmed messages */
+        MESSAGE_PRIORITY_NORMAL);
+    /* encode the APDU portion of the packet */
+    data.low_limit = 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[pdu_len],
+        &data);
+    /* send the data */
+    bytes_sent = datalink_send_pdu(&dest,       // destination address
+        &Handler_Transmit_Buffer[0], pdu_len);  // number of bytes of data
+    if (bytes_sent <= 0)
+        fprintf(stderr, "Failed to Send Who-Has Request (%s)!\n",
+            strerror(errno));
 }
 
 /* find a specific device, or use -1 for limit if you want unlimited */
-void Send_WhoHas_Object(
-  int32_t low_limit,
-  int32_t high_limit,
-  BACNET_OBJECT_TYPE object_type,
-  uint32_t object_instance)
+void Send_WhoHas_Object(int32_t low_limit,
+    int32_t high_limit,
+    BACNET_OBJECT_TYPE object_type, uint32_t object_instance)
 {
-  int pdu_len = 0;
-  BACNET_ADDRESS dest;
-  int bytes_sent = 0;
-  BACNET_WHO_HAS_DATA data;
+    int pdu_len = 0;
+    BACNET_ADDRESS dest;
+    int bytes_sent = 0;
+    BACNET_WHO_HAS_DATA data;
 
-  /* if we are forbidden to send, don't send! */
-  if (!dcc_communication_enabled())
-    return;
-  /* Who-Has is a global broadcast */
-  datalink_get_broadcast_address(&dest);
-  /* encode the NPDU portion of the packet */
-  pdu_len = npdu_encode_apdu(
-    &Handler_Transmit_Buffer[0],
-    &dest,
-    NULL,
-    false,  /* true for confirmed messages */
-    MESSAGE_PRIORITY_NORMAL);
-  /* encode the APDU portion of the packet */
-  data.low_limit = low_limit;
-  data.high_limit = high_limit;
-  data.object_name = false;
-  data.object.identifier.type = object_type;
-  data.object.identifier.instance = object_instance;
-  pdu_len += whohas_encode_apdu(
-    &Handler_Transmit_Buffer[pdu_len],
-    &data);
-  /* send the data */
-  bytes_sent = datalink_send_pdu(
-    &dest,  // destination address
-    &Handler_Transmit_Buffer[0],
-    pdu_len); // number of bytes of data
-  if (bytes_sent <= 0)
-    fprintf(stderr,"Failed to Send Who-Has Request (%s)!\n", strerror(errno));
+    /* if we are forbidden to send, don't send! */
+    if (!dcc_communication_enabled())
+        return;
+    /* Who-Has is a global broadcast */
+    datalink_get_broadcast_address(&dest);
+    /* encode the NPDU portion of the packet */
+    pdu_len = npdu_encode_apdu(&Handler_Transmit_Buffer[0], &dest, NULL, false, /* true for confirmed messages */
+        MESSAGE_PRIORITY_NORMAL);
+    /* encode the APDU portion of the packet */
+    data.low_limit = low_limit;
+    data.high_limit = high_limit;
+    data.object_name = false;
+    data.object.identifier.type = object_type;
+    data.object.identifier.instance = object_instance;
+    pdu_len += whohas_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+        &data);
+    /* send the data */
+    bytes_sent = datalink_send_pdu(&dest,       // destination address
+        &Handler_Transmit_Buffer[0], pdu_len);  // number of bytes of data
+    if (bytes_sent <= 0)
+        fprintf(stderr, "Failed to Send Who-Has Request (%s)!\n",
+            strerror(errno));
 }

bacnet-stack/demo/handler/s_whois.c

@@ -43,38 +43,29 @@
 #include "txbuf.h"
 
 /* find a specific device, or use -1 for limit if you want unlimited */
-void Send_WhoIs(
-  int32_t low_limit,
-  int32_t high_limit)
+void Send_WhoIs(int32_t low_limit, int32_t high_limit)
 {
-  int pdu_len = 0;
-  BACNET_ADDRESS dest;
-  int bytes_sent = 0;
+    int pdu_len = 0;
+    BACNET_ADDRESS dest;
+    int bytes_sent = 0;
 
-  if (!dcc_communication_enabled())
-    return;
+    if (!dcc_communication_enabled())
+        return;
 
-  // Who-Is is a global broadcast
-  datalink_get_broadcast_address(&dest);
+    // Who-Is is a global broadcast
+    datalink_get_broadcast_address(&dest);
 
-  // encode the NPDU portion of the packet
-  pdu_len = npdu_encode_apdu(
-    &Handler_Transmit_Buffer[0],
-    &dest,
-    NULL,
-    false,  // true for confirmed messages
-    MESSAGE_PRIORITY_NORMAL);
+    // encode the NPDU portion of the packet
+    pdu_len = npdu_encode_apdu(&Handler_Transmit_Buffer[0], &dest, NULL, false, // true for confirmed messages
+        MESSAGE_PRIORITY_NORMAL);
 
-  // encode the APDU portion of the packet
-  pdu_len += whois_encode_apdu(
-    &Handler_Transmit_Buffer[pdu_len],
-    low_limit,
-    high_limit);
+    // encode the APDU portion of the packet
+    pdu_len += whois_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+        low_limit, high_limit);
 
-  bytes_sent = datalink_send_pdu(
-    &dest,  // destination address
-    &Handler_Transmit_Buffer[0],
-    pdu_len); // number of bytes of data
-  if (bytes_sent <= 0)
-    fprintf(stderr,"Failed to Send Who-Is Request (%s)!\n", strerror(errno));
+    bytes_sent = datalink_send_pdu(&dest,       // destination address
+        &Handler_Transmit_Buffer[0], pdu_len);  // number of bytes of data
+    if (bytes_sent <= 0)
+        fprintf(stderr, "Failed to Send Who-Is Request (%s)!\n",
+            strerror(errno));
 }

bacnet-stack/demo/handler/s_wp.c

@@ -43,79 +43,63 @@
 #include "txbuf.h"
 
 /* returns the invoke ID for confirmed request, or zero on failure */
-uint8_t Send_Write_Property_Request(
-  uint32_t device_id, // destination device
-  BACNET_OBJECT_TYPE object_type,
-  uint32_t object_instance,
-  BACNET_PROPERTY_ID object_property,
-  BACNET_APPLICATION_DATA_VALUE *object_value,
-  uint8_t priority,
-  int32_t array_index)
+uint8_t Send_Write_Property_Request(uint32_t device_id, // destination device
+    BACNET_OBJECT_TYPE object_type,
+    uint32_t object_instance,
+    BACNET_PROPERTY_ID object_property,
+    BACNET_APPLICATION_DATA_VALUE * object_value,
+    uint8_t priority, int32_t array_index)
 {
-  BACNET_ADDRESS dest;
-  BACNET_ADDRESS my_address;
-  unsigned max_apdu = 0;
-  uint8_t invoke_id = 0;
-  bool status = false;
-  int pdu_len = 0;
-  int bytes_sent = 0;
-  BACNET_WRITE_PROPERTY_DATA data;
+    BACNET_ADDRESS dest;
+    BACNET_ADDRESS my_address;
+    unsigned max_apdu = 0;
+    uint8_t invoke_id = 0;
+    bool status = false;
+    int pdu_len = 0;
+    int bytes_sent = 0;
+    BACNET_WRITE_PROPERTY_DATA data;
 
-  if (!dcc_communication_enabled())
-    return 0;
+    if (!dcc_communication_enabled())
+        return 0;
 
-  /* is the device bound? */
-  status = address_get_by_device(device_id, &max_apdu, &dest);
-  /* is there a tsm available? */
-  if (status)
-     status = tsm_transaction_available();
-  if (status)
-  {
-    datalink_get_my_address(&my_address);
-    pdu_len = npdu_encode_apdu(
-      &Handler_Transmit_Buffer[0],
-      &dest,
-      &my_address,
-      true,  // true for confirmed messages
-      MESSAGE_PRIORITY_NORMAL);
+    /* is the device bound? */
+    status = address_get_by_device(device_id, &max_apdu, &dest);
+    /* is there a tsm available? */
+    if (status)
+        status = tsm_transaction_available();
+    if (status) {
+        datalink_get_my_address(&my_address);
+        pdu_len = npdu_encode_apdu(&Handler_Transmit_Buffer[0], &dest, &my_address, true,       // true for confirmed messages
+            MESSAGE_PRIORITY_NORMAL);
 
-    invoke_id = tsm_next_free_invokeID();
-    // load the data for the encoding
-    data.object_type = object_type;
-    data.object_instance = object_instance;
-    data.object_property = object_property;
-    data.array_index = array_index;
-    bacapp_copy(&data.value,object_value);
-    data.priority = priority;
-    pdu_len += wp_encode_apdu(
-      &Handler_Transmit_Buffer[pdu_len],
-      invoke_id,
-      &data);
-    /* will it fit in the sender?
-       note: if there is a bottleneck router in between
-       us and the destination, we won't know unless
-       we have a way to check for that and update the
-       max_apdu in the address binding table. */
-    if ((unsigned)pdu_len < max_apdu)
-    {
-      tsm_set_confirmed_unsegmented_transaction(
-        invoke_id,
-        &dest,
-        &Handler_Transmit_Buffer[0],
-        pdu_len);
-      bytes_sent = datalink_send_pdu(
-        &dest,  // destination address
-        &Handler_Transmit_Buffer[0],
-        pdu_len); // number of bytes of data
-      if (bytes_sent <= 0)
-        fprintf(stderr,"Failed to Send WriteProperty Request (%s)!\n",
-          strerror(errno));
+        invoke_id = tsm_next_free_invokeID();
+        // load the data for the encoding
+        data.object_type = object_type;
+        data.object_instance = object_instance;
+        data.object_property = object_property;
+        data.array_index = array_index;
+        bacapp_copy(&data.value, object_value);
+        data.priority = priority;
+        pdu_len += wp_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
+            invoke_id, &data);
+        /* will it fit in the sender?
+           note: if there is a bottleneck router in between
+           us and the destination, we won't know unless
+           we have a way to check for that and update the
+           max_apdu in the address binding table. */
+        if ((unsigned) pdu_len < max_apdu) {
+            tsm_set_confirmed_unsegmented_transaction(invoke_id,
+                &dest, &Handler_Transmit_Buffer[0], pdu_len);
+            bytes_sent = datalink_send_pdu(&dest,       // destination address
+                &Handler_Transmit_Buffer[0], pdu_len);  // number of bytes of data
+            if (bytes_sent <= 0)
+                fprintf(stderr,
+                    "Failed to Send WriteProperty Request (%s)!\n",
+                    strerror(errno));
+        } else
+            fprintf(stderr, "Failed to Send WriteProperty Request "
+                "(exceeds destination maximum APDU)!\n");
     }
-    else
-      fprintf(stderr,"Failed to Send WriteProperty Request "
-        "(exceeds destination maximum APDU)!\n");
-  }
 
-  return invoke_id;
+    return invoke_id;
 }
-

bacnet-stack/demo/handler/txbuf.c

@@ -27,5 +27,4 @@
 #include "config.h"
 #include "datalink.h"
 
-uint8_t Handler_Transmit_Buffer[MAX_MPDU] = {0};
-
+uint8_t Handler_Transmit_Buffer[MAX_MPDU] = { 0 };