dali/bacnet_stack
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed the Zephyr-OS BIP6 datalink module. (#659)

Browse Source
This commit is contained in:
Steve Karg
2024-05-30 17:26:03 -05:00
committed by GitHub
parent 52f3f08cb1
commit f6ebf11066
2 changed files with 350 additions and 357 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ports/zephyr/bip-init.c
+3 -4
View File
@@ -174,14 +174,14 @@ void bip_get_broadcast_address(BACNET_ADDRESS *dest)
/**
* @brief Set the BACnet/IP address
* @param addr - network IPv4 address (in network byte order)
* @param addr - network IPv4 address
* @return true if the address was set
*/
bool bip_set_addr(BACNET_IP_ADDRESS *addr)
{
if (addr) {
memcpy(&BIP_Address.s_addr, &addr->address[0], IP_ADDRESS_MAX);
BIP_Port = addr->port;
BIP_Port = htons(addr->port);
return true;
}
return false;
@@ -196,7 +196,7 @@ bool bip_get_addr(BACNET_IP_ADDRESS *addr)
{
if (addr) {
memcpy(&addr->address[0], &BIP_Address.s_addr, IP_ADDRESS_MAX);
addr->port = BIP_Port;
addr->port = ntohs(BIP_Port);
return true;
}
return false;
@@ -627,7 +627,6 @@ void bip_cleanup(void)
{
LOG_DBG("bip_cleanup()");
BIP_Port = 0;
memset(&BIP_Address, 0, sizeof(BIP_Address));
memset(&BIP_Broadcast_Addr, 0, sizeof(BIP_Broadcast_Addr));
ports/zephyr/bip6-init.c
+347 -353
View File
@@ -34,48 +34,37 @@
#include <stdint.h>
#include <stdbool.h>
#include <device.h>
#include <init.h>
#include <kernel.h>
#include <sys/printk.h>
#include <net/net_ip.h>
#include <net/socket.h>
#include <net/socket_select.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/printk.h>
#include <zephyr/net/net_ip.h>
#include <zephyr/net/socket.h>
#include <zephyr/net/socket_select.h>
/* BACnet Stack defines - first */
#include "bacnet/bacdef.h"
/* BACnet Stack API */
#include "bacnet/bacdcode.h"
#include "bacnet/bacint.h"
#include "bacnet/datalink/bip6.h"
#include "bacnet/basic/object/device.h"
#include "bacnet/basic/sys/debug.h"
#include "bacnet/basic/bbmd6/h_bbmd6.h"
/* Logging module registration is already done in ports/zephyr/main.c */
#include <logging/log.h>
#include <logging/log_ctrl.h>
#include <zephyr/logging/log.h>
#include <zephyr/logging/log_ctrl.h>
LOG_MODULE_DECLARE(bacnet, CONFIG_BACNETSTACK_LOG_LEVEL);
#define THIS_FILE "bip6-init.c"
#if (MAX_MAC_LEN < BIP6_ADDRESS_MAX) /* Make sure an 18 byte address can be \
stored */
#error \
"BACNET_ADDRESS.mac (bacdef.h) is not large enough to store an IPv6 address."
#endif
/* zephyr socket */
static int BIP6_Socket = -1;
/* NOTE: we store address and port in network byte order
since BACnet/IP uses network byte order for all address byte arrays
*/
/* port to use - stored here in network byte order */
static uint16_t BIP6_Port = htons(CONFIG_BACDL_BIP6_PORT);
/* IP address - stored here in network byte order */
static struct in6_addr BIP6_Address;
/* IP multicast address - stored here in network byte order */
static struct in6_addr BIP6_Multicast_Addr;
static int BIP6_Socket_Scope_Id;
/* local address - filled by init functions */
static BACNET_IP6_ADDRESS BIP6_Addr;
static BACNET_IP6_ADDRESS BIP6_Broadcast_Addr;
/* Used by inet6_ntoa */
#if CONFIG_BACNETSTACK_LOG_LEVEL
@@ -121,280 +110,6 @@ static char *inet6_ntoa(struct in6_addr *a)
return &ipv6_addr_str[0];
}
/**
* @brief Set the BACnet IPv6 UDP port number
* @param port - IPv6 UDP port number - in host byte order
*/
void bip6_set_port(uint16_t port)
{
BIP6_Port = htons(port);
}
/**
* @brief Get the BACnet IPv6 UDP port number
* @return IPv4 UDP port number - in host byte order
*/
uint16_t bip6_get_port(void)
{
return ntohs(BIP6_Port);
}
/**
* @brief Get the IPv6 address for my interface. Used for sending src address.
* @param addr - BACnet datalink address
*/
void bip6_get_my_address(BACNET_ADDRESS *addr)
{
unsigned int i = 0;
if (addr) {
addr->mac_len = BIP6_ADDRESS_MAX; /* 18 */
memcpy(&addr->mac[0], &BIP6_Address.s6_addr, IP6_ADDRESS_MAX); /* 16 */
memcpy(&addr->mac[IP6_ADDRESS_MAX], &BIP6_Port, sizeof(BIP6_Port));
/* local only, no routing */
addr->net = 0;
/* no SLEN */
addr->len = 0;
for (i = 0; i < MAX_MAC_LEN; i++) {
/* no SADR */
addr->adr[i] = 0;
}
}
}
/**
* Get the IPv6 broadcast address for my interface.
*
* @param addr - BACnet datalink address
*/
void bip6_get_broadcast_address(BACNET_ADDRESS *dest)
{
/* BIP6_ADDRESS_MAX = 18 */
/* IP6_ADDRESS_MAX = 16 */
/* Store IPv6 address and port in dest->mac and
clear dest->adr which is used for hardware MAC */
if (dest) {
dest->mac_len = BIP6_ADDRESS_MAX;
memcpy(&dest->mac[0], &BIP6_Multicast_Addr.s6_addr, IP6_ADDRESS_MAX);
memcpy(&dest->mac[IP6_ADDRESS_MAX], &BIP6_Port, sizeof(BIP6_Port));
memset(&dest->adr, 0, sizeof(dest->adr));
dest->net = BACNET_BROADCAST_NETWORK;
dest->len = 0;
}
return;
}
/**
* Set the BACnet/IP address
*
* @param addr - network IPv6 address
*/
bool bip6_set_addr(BACNET_IP6_ADDRESS *addr)
{
if (addr) {
memcpy(&BIP6_Address.s6_addr, &addr->address[0], IP6_ADDRESS_MAX);
memcpy(&BIP6_Port, &addr->port, sizeof(addr->port));
return true;
}
return false;
}
/**
* @brief Get the BACnet/IP address
* @param addr - network IPv6 address
* @return true if the address was retrieved
*/
bool bip6_get_addr(BACNET_IP6_ADDRESS *addr)
{
if (addr) {
memcpy(&addr->address[0], &BIP6_Address, IP6_ADDRESS_MAX);
memcpy(&addr->port, &BIP6_Port, sizeof(addr->port));
return true;
}
return false;
}
/**
* @brief Set the BACnet/IP address
* @param addr - network IPv6 address
* @return true if the address was set
*/
bool bip6_set_broadcast_addr(BACNET_IP6_ADDRESS *addr)
{
if (addr) {
memcpy(
&BIP6_Multicast_Addr.s6_addr, &addr->address[0], IP6_ADDRESS_MAX);
return true;
}
return false;
}
/**
* Get the BACnet/IP address
*
* @return BACnet/IP address
*/
bool bip6_get_broadcast_addr(BACNET_IP6_ADDRESS *addr)
{
if (addr) {
memcpy(
&addr->address[0], &BIP6_Multicast_Addr.s6_addr, IP6_ADDRESS_MAX);
addr->port = ntohs(BIP6_Port);
return true;
}
return false;
}
/**
* @brief Set the BACnet/IP subnet mask CIDR prefix
* @return true if the subnet mask CIDR prefix is set
*/
bool bip6_set_subnet_prefix(uint8_t prefix)
{
/* not something we do within this driver */
return false;
}
/**
* @brief Set the BACnet/IP subnet mask CIDR prefix
* @return true if the subnet mask CIDR prefix is set
*/
uint8_t bip6_get_subnet_prefix(void)
{
/* not something we do within this driver */
return 0;
}
/**
* The send function for BACnet/IP driver layer
*
* @param dest - Points to a BACNET_IP_ADDRESS structure containing the
* destination address.
* @param mtu - the bytes of data to send
* @param mtu_len - the number of bytes of data to send
*
* @return Upon successful completion, returns the number of bytes sent.
* Otherwise, -1 shall be returned and errno set to indicate the error.
*/
int bip6_send_mpdu(BACNET_IP6_ADDRESS *dest, uint8_t *mtu, uint16_t mtu_len)
{
struct sockaddr_in6 bip6_dest = { 0 };
/* assumes that the driver has already been initialized */
if (BIP6_Socket < 0) {
LOG_ERR("%s:%d - Socket not initialized!", THIS_FILE, __LINE__);
return BIP6_Socket;
}
/* load destination IP address */
bip6_dest.sin6_family = AF_INET6;
memcpy(&bip6_dest.sin6_addr.s6_addr, &dest->address[0], IP6_ADDRESS_MAX);
bip6_dest.sin6_port = htons(dest->port);
/* Send the packet */
return zsock_sendto(
BIP6_Socket, (char *)mtu, mtu_len, 0, (struct sockaddr *)&bip6_dest,
sizeof(struct sockaddr));
}
uint16_t bip6_receive(
BACNET_ADDRESS *src, uint8_t *npdu, uint16_t max_npdu, unsigned timeout)
{
uint16_t npdu_len = 0; /* return value */
zsock_fd_set read_fds;
int max = 0;
struct zsock_timeval select_timeout;
struct sockaddr_in6 sin = { 0 };
BACNET_IP6_ADDRESS addr = { { 0 } };
socklen_t sin_len = sizeof(sin);
int received_bytes = 0;
int offset = 0;
uint16_t i = 0;
/* Make sure the socket is open */
if (BIP6_Socket < 0) {
return 0;
}
/* we could just use a non-blocking socket, but that consumes all
the CPU time. We can use a timeout; it is only supported as
a select. */
if (timeout >= 1000) {
select_timeout.tv_sec = timeout / 1000;
select_timeout.tv_usec =
1000 * (timeout - select_timeout.tv_sec * 1000);
} else {
select_timeout.tv_sec = 0;
select_timeout.tv_usec = 1000 * timeout;
}
ZSOCK_FD_ZERO(&read_fds);
ZSOCK_FD_SET(BIP6_Socket, &read_fds);
max = BIP6_Socket;
/* see if there is a packet for us */
if (zsock_select(max + 1, &read_fds, NULL, NULL, &select_timeout) > 0) {
received_bytes = zsock_recvfrom(
BIP6_Socket, (char *)&npdu[0], max_npdu, 0, (struct sockaddr *)&sin,
&sin_len);
} else {
return 0;
}
/* See if there is a problem */
if (received_bytes < 0) {
LOG_WRN(
"%s:%d - RX zsock_recvfrom() error: %d", THIS_FILE, __LINE__,
received_bytes);
return 0;
}
/* no problem, just no bytes */
if (received_bytes == 0) {
return 0;
}
/* the signature of a BACnet/IPv6 packet */
if (npdu[0] != BVLL_TYPE_BACNET_IP6) {
LOG_WRN("%s:%d - RX bad packet", THIS_FILE, __LINE__);
return 0;
}
/* Data link layer addressing between B/IPv6 nodes consists of a 128-bit
IPv6 address followed by a two-octet UDP port number (both of which
shall be transmitted with the most significant octet first). This
address shall be referred to as a B/IPv6 address.
*/
memcpy(&addr.address[0], &sin.sin6_addr.s6_addr, IP6_ADDRESS_MAX);
addr.port = ntohs(sin.sin6_port);
offset = bvlc6_handler(&addr, src, npdu, received_bytes);
if (offset > 0) {
npdu_len = received_bytes - offset;
if (npdu_len <= max_npdu) {
/* shift the buffer to return a valid NPDU */
for (i = 0; i < npdu_len; i++) {
npdu[i] = npdu[offset + i];
}
} else {
LOG_WRN("%s:%d - NPDU dropped!", THIS_FILE, __LINE__);
npdu_len = 0;
}
}
return npdu_len;
}
int bip6_send_pdu(
BACNET_ADDRESS *dest,
BACNET_NPDU_DATA *npdu_data,
uint8_t *pdu,
unsigned pdu_len)
{
dest->net = BACNET_BROADCAST_NETWORK;
return bvlc6_send_pdu(dest, npdu_data, pdu, pdu_len);
}
void bip6_set_interface(char *ifname)
{
struct net_if *interface = 0;
@@ -404,12 +119,12 @@ void bip6_set_interface(char *ifname)
BACNET_IP6_ADDRESS unicast = { 0 };
BACNET_IP6_ADDRESS multicast = { 0 };
unicast.port = BIP6_Port;
multicast.port = BIP6_Port;
LOG_INF("bip6_set_interface()");
LOG_INF("UDP port: %d", ntohs(BIP6_Port));
unicast.port = bip6_get_port();
multicast.port = unicast.port;
LOG_DBG("bip6_set_interface()");
LOG_INF("BIP6: UDP port: 0x%04X", (unsigned)unicast.port);
LOG_INF("BIP6: seeking interface: %s", ifname?ifname:"NULL");
if (ifname) {
index = atoi(ifname);
@@ -421,7 +136,7 @@ void bip6_set_interface(char *ifname)
} else {
interface = net_if_get_by_index(index);
if (interface) {
LOG_INF("Using interface %d", index);
LOG_INF("BIP6: Using interface %d", index);
} else {
LOG_ERR(
"%s:%d - No interface at index %d", THIS_FILE, __LINE__,
@@ -429,27 +144,23 @@ void bip6_set_interface(char *ifname)
}
}
}
if (index == -1) {
LOG_WRN(
"%s:%d - No valid interface specified - using default ", THIS_FILE,
__LINE__);
LOG_INF("BIP6: No valid interface specified. Using default ");
interface = net_if_get_default();
}
if (interface) {
LOG_INF("Interface set - Configured addresses:");
BIP6_Socket_Scope_Id = net_if_get_by_iface(interface);
LOG_INF("BIP6: Socket Scope ID = %d", BIP6_Socket_Scope_Id);
LOG_INF("BIP6: Interface set - Configured addresses:");
for (x = 0; x < NET_IF_MAX_IPV6_ADDR; x++) {
inet6_ntoa(&interface->config.ip.ipv6->unicast[x].address.in6_addr);
LOG_INF(" unicast[%d]: %s", x, ipv6_addr_str);
}
for (x = 0; x < NET_IF_MAX_IPV6_MADDR; x++) {
inet6_ntoa(&interface->config.ip.ipv6->mcast[x].address.in6_addr);
LOG_INF(" multicast[%d]: %s", x, ipv6_addr_str);
}
if (CONFIG_BACDL_BIP6_ADDRESS_INDEX >= NET_IF_MAX_IPV6_ADDR) {
LOG_ERR(
"%s:%d - IPv6 address index of %d is out of range (0-%d)",
@@ -457,10 +168,8 @@ void bip6_set_interface(char *ifname)
NET_IF_MAX_IPV6_ADDR - 1);
return;
}
LOG_INF(
"Using IPv6 address at index %d", CONFIG_BACDL_BIP6_ADDRESS_INDEX);
LOG_INF("BIP6: Using configured index %d",
CONFIG_BACDL_BIP6_ADDRESS_INDEX);
memcpy(
&unicast.address,
&interface->config.ip.ipv6->unicast[CONFIG_BACDL_BIP6_ADDRESS_INDEX]
@@ -488,24 +197,305 @@ void bip6_set_interface(char *ifname)
}
}
bool bip6_init(char *ifname)
/**
* Set the BACnet IPv6 UDP port number
*
* @param port - IPv6 UDP port number
*/
void bip6_set_port(uint16_t port)
{
LOG_INF("bip6_init()");
BIP6_Addr.port = port;
BIP6_Broadcast_Addr.port = port;
}
int sock_fd = -1;
const int sockopt = 1;
int status = -1;
struct sockaddr_in6 sin6 = { 0 };
/**
* Get the BACnet IPv6 UDP port number
*
* @return IPv6 UDP port number
*/
uint16_t bip6_get_port(void)
{
return BIP6_Addr.port;
}
bip6_set_interface(ifname);
/**
* Get the BACnet broadcast address for my interface.
* Used as dest address in messages sent as BROADCAST
*
* @param addr - IPv6 source address
*/
void bip6_get_broadcast_address(BACNET_ADDRESS *addr)
{
if (addr) {
addr->net = BACNET_BROADCAST_NETWORK;
addr->mac_len = 0;
addr->len = 0;
}
}
if (BIP6_Address.s6_addr == 0) {
LOG_ERR(
"%s:%d - Failed to get an IPv6 address on interface: %s\n",
THIS_FILE, __LINE__, ifname ? ifname : "[default]");
return false;
/**
* Get the IPv6 address for my interface. Used as src address in messages sent.
*
* @param addr - IPv6 source address
*/
void bip6_get_my_address(BACNET_ADDRESS *addr)
{
uint32_t device_id = 0;
if (addr) {
device_id = Device_Object_Instance_Number();
bvlc6_vmac_address_set(addr, device_id);
}
}
/**
* Set the BACnet/IP address
*
* @param addr - network IPv6 address
*/
bool bip6_set_addr(BACNET_IP6_ADDRESS *addr)
{
return bvlc6_address_copy(&BIP6_Addr, addr);
}
/**
* Get the BACnet/IP address
*
* @return BACnet/IP address
*/
bool bip6_get_addr(BACNET_IP6_ADDRESS *addr)
{
return bvlc6_address_copy(addr, &BIP6_Addr);
}
/**
* Set the BACnet/IP address
*
* @param addr - network IPv6 address
*/
bool bip6_set_broadcast_addr(BACNET_IP6_ADDRESS *addr)
{
return bvlc6_address_copy(&BIP6_Broadcast_Addr, addr);
}
/**
* Get the BACnet/IP address
*
* @return BACnet/IP address
*/
bool bip6_get_broadcast_addr(BACNET_IP6_ADDRESS *addr)
{
return bvlc6_address_copy(addr, &BIP6_Broadcast_Addr);
}
/**
* The send function for BACnet/IPv6 driver layer
*
* @param dest - Points to a BACNET_IP6_ADDRESS structure containing the
* destination address.
* @param mtu - the bytes of data to send
* @param mtu_len - the number of bytes of data to send
*
* @return Upon successful completion, returns the number of bytes sent.
* Otherwise, -1 shall be returned and errno set to indicate the error.
*/
int bip6_send_mpdu(BACNET_IP6_ADDRESS *dest, uint8_t *mtu, uint16_t mtu_len)
{
struct sockaddr_in6 bvlc_dest = { 0 };
uint16_t addr16[8];
/* assumes that the driver has already been initialized */
if (BIP6_Socket < 0) {
LOG_ERR("%s:%d - Socket not initialized!", THIS_FILE, __LINE__);
return BIP6_Socket;
}
/* load destination IP address */
bvlc_dest.sin6_family = AF_INET6;
bvlc6_address_get(
dest, &addr16[0], &addr16[1], &addr16[2], &addr16[3], &addr16[4],
&addr16[5], &addr16[6], &addr16[7]);
bvlc_dest.sin6_addr.s6_addr16[0] = htons(addr16[0]);
bvlc_dest.sin6_addr.s6_addr16[1] = htons(addr16[1]);
bvlc_dest.sin6_addr.s6_addr16[2] = htons(addr16[2]);
bvlc_dest.sin6_addr.s6_addr16[3] = htons(addr16[3]);
bvlc_dest.sin6_addr.s6_addr16[4] = htons(addr16[4]);
bvlc_dest.sin6_addr.s6_addr16[5] = htons(addr16[5]);
bvlc_dest.sin6_addr.s6_addr16[6] = htons(addr16[6]);
bvlc_dest.sin6_addr.s6_addr16[7] = htons(addr16[7]);
bvlc_dest.sin6_port = htons(dest->port);
bvlc_dest.sin6_scope_id = BIP6_Socket_Scope_Id;
inet6_ntoa(&bvlc_dest.sin6_addr);
LOG_DBG("BIP6: Sending MPDU to %s", ipv6_addr_str);
/* Send the packet */
return zsock_sendto(
BIP6_Socket, (char *)mtu, mtu_len, 0, (struct sockaddr *)&bvlc_dest,
sizeof(bvlc_dest));
}
/**
* The common send function for BACnet/IPv6 application layer
*
* @param dest - Points to a #BACNET_ADDRESS structure containing the
* destination address.
* @param npdu_data - Points to a BACNET_NPDU_DATA structure containing the
* destination network layer control flags and data.
* @param pdu - the bytes of data to send
* @param pdu_len - the number of bytes of data to send
* @return Upon successful completion, returns the number of bytes sent.
* Otherwise, -1 shall be returned and errno set to indicate the error.
*/
int bip6_send_pdu(
BACNET_ADDRESS *dest,
BACNET_NPDU_DATA *npdu_data,
uint8_t *pdu,
unsigned pdu_len)
{
return bvlc6_send_pdu(dest, npdu_data, pdu, pdu_len);
}
/**
* BACnet/IP Datalink Receive handler.
*
* @param src - returns the source address
* @param npdu - returns the NPDU buffer
* @param max_npdu -maximum size of the NPDU buffer
* @param timeout - number of milliseconds to wait for a packet
*
* @return Number of bytes received, or 0 if none or timeout.
*/
uint16_t bip6_receive(
BACNET_ADDRESS *src, uint8_t *npdu, uint16_t max_npdu, unsigned timeout)
{
uint16_t npdu_len = 0; /* return value */
zsock_fd_set read_fds;
int max = 0;
struct zsock_timeval select_timeout;
struct sockaddr_in6 sin = { 0 };
BACNET_IP6_ADDRESS addr = { { 0 } };
socklen_t sin_len = sizeof(sin);
int received_bytes = 0;
int offset = 0;
uint16_t i = 0;
/* Make sure the socket is open */
if (BIP6_Socket < 0) {
return 0;
}
/* we could just use a non-blocking socket, but that consumes all
the CPU time. We can use a timeout; it is only supported as
a select. */
if (timeout >= 1000) {
select_timeout.tv_sec = timeout / 1000;
select_timeout.tv_usec =
1000 * (timeout - select_timeout.tv_sec * 1000);
} else {
select_timeout.tv_sec = 0;
select_timeout.tv_usec = 1000 * timeout;
}
ZSOCK_FD_ZERO(&read_fds);
ZSOCK_FD_SET(BIP6_Socket, &read_fds);
max = BIP6_Socket;
/* see if there is a packet for us */
if (zsock_select(max + 1, &read_fds, NULL, NULL, &select_timeout) > 0) {
received_bytes = zsock_recvfrom(
BIP6_Socket, (char *)&npdu[0], max_npdu, 0, (struct sockaddr *)&sin,
&sin_len);
} else {
return 0;
}
/* See if there is a problem */
if (received_bytes < 0) {
LOG_WRN(
"%s:%d - RX zsock_recvfrom() error: %d", THIS_FILE, __LINE__,
received_bytes);
return 0;
}
/* no problem, just no bytes */
if (received_bytes == 0) {
return 0;
}
/* the signature of a BACnet/IPv6 packet */
if (npdu[0] != BVLL_TYPE_BACNET_IP6) {
LOG_DBG("BIP6: not a BACnet packet. Dropped.");
return 0;
}
/* pass the packet into the BBMD handler */
inet6_ntoa(&sin.sin6_addr);
LOG_DBG("BIP6: Received MPDU from %s", ipv6_addr_str);
bvlc6_address_set(
&addr, ntohs(sin.sin6_addr.s6_addr16[0]),
ntohs(sin.sin6_addr.s6_addr16[1]), ntohs(sin.sin6_addr.s6_addr16[2]),
ntohs(sin.sin6_addr.s6_addr16[3]), ntohs(sin.sin6_addr.s6_addr16[4]),
ntohs(sin.sin6_addr.s6_addr16[5]), ntohs(sin.sin6_addr.s6_addr16[6]),
ntohs(sin.sin6_addr.s6_addr16[7]));
addr.port = ntohs(sin.sin6_port);
offset = bvlc6_handler(&addr, src, npdu, received_bytes);
if (offset > 0) {
npdu_len = received_bytes - offset;
if (npdu_len <= max_npdu) {
/* shift the buffer to return a valid NPDU */
for (i = 0; i < npdu_len; i++) {
npdu[i] = npdu[offset + i];
}
} else {
LOG_WRN("%s:%d - NPDU dropped (too long)!", THIS_FILE, __LINE__);
npdu_len = 0;
}
}
return npdu_len;
}
/** Cleanup and close out the BACnet/IP services by closing the socket.
* @ingroup DLBIP6
*/
void bip6_cleanup(void)
{
LOG_DBG("bip6_cleanup();");
bvlc6_cleanup();
if (BIP6_Socket != -1) {
zsock_close(BIP6_Socket);
}
BIP6_Socket = -1;
}
/** Initialize the BACnet/IP services at the given interface.
* @ingroup DLBIP6
* -# Gets the local IP address and local broadcast address from the system,
* and saves it into the BACnet/IPv6 data structures.
* -# Opens a UDP socket
* -# Configures the socket for sending and receiving
* -# Configures the socket so it can send multicasts
* -# Binds the socket to the local IP address at the specified port for
* BACnet/IPv6 (by default, 0xBAC0 = 47808).
*
* @param ifname [in] The named interface to use for the network layer.
* If NULL, the "eth0" interface is assigned.
* @return True if the socket is successfully opened for BACnet/IP,
* else False if the socket functions fail.
*/
bool bip6_init(char *ifname)
{
int sock_fd = -1;
int status = -1;
struct sockaddr_in6 server = { 0 };
struct in6_addr broadcast_address;
struct ipv6_mreq join_request;
const int sockopt = 1;
LOG_DBG("bip6_init()");
bip6_set_interface(ifname);
if (BIP6_Addr.port == 0) {
bip6_set_port(0xBAC0U);
}
LOG_INF("BIP6: IPv6 UDP port: 0x%04X", (unsigned)BIP6_Addr.port);
if (BIP6_Broadcast_Addr.address[0] == 0) {
bvlc6_address_set(
&BIP6_Broadcast_Addr, BIP6_MULTICAST_SITE_LOCAL, 0, 0, 0, 0, 0, 0,
BIP6_MULTICAST_GROUP_ID);
LOG_INF("BIP6: IPv6 MULTICAST_SITE_LOCAL");
}
/* assumes that the driver has already been initialized */
sock_fd = zsock_socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
BIP6_Socket = sock_fd;
@@ -525,48 +515,52 @@ bool bip6_init(char *ifname)
BIP6_Socket = -1;
return false;
}
/* subscribe to a multicast address */
memcpy(
&broadcast_address.s6_addr[0], &BIP6_Broadcast_Addr.address[0],
IP6_ADDRESS_MAX);
memcpy(
&join_request.ipv6mr_multiaddr, &broadcast_address,
sizeof(struct in6_addr));
/* Let system not choose the interface */
join_request.ipv6mr_ifindex = BIP6_Socket_Scope_Id;
status = setsockopt(
BIP6_Socket, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, &join_request,
sizeof(join_request));
if (status < 0) {
perror("BIP6: setsockopt(IPV6_ADD_MEMBERSHIP)");
}
/* bind the socket to the local port number and IP address */
sin6.sin6_family = AF_INET6;
sin6.sin6_addr = in6addr_any;
sin6.sin6_port = BIP6_Port;
server.sin6_family = AF_INET6;
LOG_INF("Binding to port %d", ntohs(BIP6_Port));
server.sin6_addr = in6addr_any;
server.sin6_port = htons(BIP6_Addr.port);
status = zsock_bind(
sock_fd, (const struct sockaddr *)&sin6, sizeof(struct sockaddr));
LOG_INF("BIP6: Binding to port %d", BIP6_Addr.port);
status =
zsock_bind(sock_fd, (const struct sockaddr *)&server, sizeof(server));
if (status < 0) {
zsock_close(sock_fd);
BIP6_Socket = -1;
LOG_ERR("%s:%d - zsock_bind() failure", THIS_FILE, __LINE__);
return false;
} else {
LOG_INF("Socket bound");
LOG_INF("BIP6: Socket bound");
}
bvlc6_init();
LOG_INF("bip6_init() success");
LOG_DBG("bip6_init() success");
return true;
}
/**
* @brief Check if the BACnet/IPv6 socket is valid
* @return True if the socket is valid, else False
*/
bool bip6_valid(void)
{
return (BIP6_Socket != -1);
}
void bip6_cleanup(void)
{
LOG_INF("bip6_cleanup()");
BIP6_Port = 0;
memset(&BIP6_Address, 0, sizeof(BIP6_Address));
memset(&BIP6_Multicast_Addr, 0, sizeof(BIP6_Multicast_Addr));
if (BIP6_Socket != -1) {
zsock_close(BIP6_Socket);
}
BIP6_Socket = -1;
return;
}