From f6ebf1106681a81eb5228d9d2ea9f95e888c7c98 Mon Sep 17 00:00:00 2001 From: Steve Karg Date: Thu, 30 May 2024 17:26:03 -0500 Subject: [PATCH] Fixed the Zephyr-OS BIP6 datalink module. (#659) --- ports/zephyr/bip-init.c | 7 +- ports/zephyr/bip6-init.c | 700 +++++++++++++++++++-------------------- 2 files changed, 350 insertions(+), 357 deletions(-) diff --git a/ports/zephyr/bip-init.c b/ports/zephyr/bip-init.c index f36ea2b2..eee7f615 100644 --- a/ports/zephyr/bip-init.c +++ b/ports/zephyr/bip-init.c @@ -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)); diff --git a/ports/zephyr/bip6-init.c b/ports/zephyr/bip6-init.c index d58db934..fae1ed0a 100644 --- a/ports/zephyr/bip6-init.c +++ b/ports/zephyr/bip6-init.c @@ -34,48 +34,37 @@ #include #include -#include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include /* 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 -#include +#include +#include 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; -}