tests: net: socket: af_packet: Add more tests to verify binding

In case the receiving packet socket is not bound to any specific
interface, or is explicitly bound to "any" interface (at index 0),
it should collect packets from all interfaces. Add test cases which
verify that.

Also, if a packet socket is bound to a specific interface, it should not
receive packets from others. Add a test case to verify that as well.

Signed-off-by: Robert Lubos <[email protected]>

Author: rlubos

tests/net/socket/af_packet/src/main.c

@@ -72,12 +72,16 @@ LOG_MODULE_REGISTER(net_test, CONFIG_NET_SOCKETS_LOG_LEVEL);
  *   * (AF_PACKET, SOCK_RAW, htons(ETH_P_ALL)) - The packet is received for all protocols.
  *     The L2 header is not removed from the data:
  *     - test_raw_sock_recv_proto_wildcard
+ *     - test_raw_sock_recv_proto_wildcard_bound_other_iface
  *     - test_raw_sock_recvfrom_proto_wildcard
+ *     - test_raw_sock_recvfrom_proto_wildcard_unbound
  *
  *   * (AF_PACKET, SOCK_DGRAM, htons(ETH_P_ALL)) - The packet is received for all protocols.
  *     The L2 header is removed from the data:
  *     - test_dgram_sock_recv_proto_wildcard
+ *     - test_dgram_sock_recv_proto_wildcard_bound_other_iface
  *     - test_dgram_sock_recvfrom_proto_wildcard
+ *     - test_dgram_sock_recvfrom_proto_wildcard_unbound
  */
 
 #if defined(CONFIG_NET_SOCKETS_LOG_LEVEL_DBG)
@@ -128,14 +132,16 @@ static int eth_fake_send(const struct device *dev, struct net_pkt *pkt)
 	DBG("Sending data (%d bytes) to iface %d\n",
 	    net_pkt_get_len(pkt), net_if_get_by_iface(net_pkt_iface(pkt)));
 
-	recv_pkt = net_pkt_rx_clone(pkt, K_NO_WAIT);
-
 	if (memcmp(pkt->frags->data, lladdr1, sizeof(lladdr1)) == 0) {
 		target_iface = eth_fake_data1.iface;
-	} else {
+	} else if (memcmp(pkt->frags->data, lladdr2, sizeof(lladdr2)) == 0) {
 		target_iface = eth_fake_data2.iface;
+	} else {
+		return 0;
 	}
 
+	recv_pkt = net_pkt_rx_clone(pkt, K_NO_WAIT);
+
 	net_pkt_set_iface(recv_pkt, target_iface);
 
 	k_sleep(K_MSEC(10)); /* Let the receiver run */
@@ -201,7 +207,7 @@ static void bind_packet_socket(int sock, struct net_if *iface)
 
 	memset(&addr, 0, sizeof(addr));
 
-	addr.sll_ifindex = net_if_get_by_iface(iface);
+	addr.sll_ifindex = (iface == NULL) ? 0 : net_if_get_by_iface(iface);
 	addr.sll_family = AF_PACKET;
 
 	ret = zsock_bind(sock, (struct sockaddr *)&addr, sizeof(addr));
@@ -866,6 +872,20 @@ ZTEST(socket_packet, test_raw_sock_recv_proto_wildcard)
 	test_recv_common(SOCK_RAW, ETH_P_ALL, true);
 }
 
+static void validate_recvfrom_addr(struct sockaddr_ll *ll_rx, socklen_t addrlen,
+				   int iface, uint8_t *lladdr)
+{
+	zassert_equal(addrlen, sizeof(struct sockaddr_ll),
+		      "Invalid address length (%u)", addrlen);
+	zassert_equal(ll_rx->sll_family, AF_PACKET, "Invalid family");
+	zassert_equal(ll_rx->sll_protocol, htons(ETH_P_IP), "Invalid protocol");
+	zassert_equal(ll_rx->sll_ifindex, iface, "Invalid interface");
+	zassert_equal(ll_rx->sll_hatype, ARPHRD_ETHER, "Invalid hardware type");
+	zassert_equal(ll_rx->sll_pkttype, PACKET_OTHERHOST, "Invalid packet type");
+	zassert_equal(ll_rx->sll_halen, NET_ETH_ADDR_LEN, "Invalid address length");
+	zassert_mem_equal(ll_rx->sll_addr, lladdr, NET_ETH_ADDR_LEN, "Invalid address");
+}
+
 static void test_recvfrom_common(int sock_type, int proto)
 {
 	struct sockaddr_ll ll_dst;
@@ -905,15 +925,8 @@ static void test_recvfrom_common(int sock_type, int proto)
 			  "Invalid payload received");
 	zassert_equal(addrlen, sizeof(struct sockaddr_ll),
 		      "Invalid address length (%u)", addrlen);
-	zassert_equal(ll_rx.sll_family, AF_PACKET, "Invalid family");
-	zassert_equal(ll_rx.sll_protocol, htons(ETH_P_IP), "Invalid protocol");
-	zassert_equal(ll_rx.sll_ifindex, net_if_get_by_iface(ud.first),
-		      "Invalid interface");
-	zassert_equal(ll_rx.sll_hatype, ARPHRD_ETHER, "Invalid hardware type");
-	zassert_equal(ll_rx.sll_pkttype, PACKET_OTHERHOST, "Invalid packet type");
-	zassert_equal(ll_rx.sll_halen, NET_ETH_ADDR_LEN, "Invalid address length");
-	zassert_mem_equal(ll_rx.sll_addr, &lladdr2, NET_ETH_ADDR_LEN,
-			  "Invalid address");
+	validate_recvfrom_addr(&ll_rx, addrlen, net_if_get_by_iface(ud.first),
+			       lladdr2);
 }
 
 ZTEST(socket_packet, test_raw_sock_recvfrom_proto_wildcard)
@@ -931,6 +944,147 @@ ZTEST(socket_packet, test_dgram_sock_recvfrom_proto_wildcard)
 	test_recvfrom_common(SOCK_DGRAM, ETH_P_ALL);
 }
 
+static void test_recvfrom_unbound_round(int tx_sock, int rx_sock, int sock_type,
+					uint8_t *src_addr, struct net_if *src_iface,
+					uint8_t *dst_addr, struct net_if *dst_iface)
+{
+	uint16_t offset = (sock_type == SOCK_DGRAM) ? sizeof(struct net_eth_hdr) : 0;
+	struct sockaddr_ll ll_dst;
+	struct sockaddr_ll ll_rx = { 0 };
+	socklen_t addrlen = sizeof(ll_rx);
+	uint16_t pkt_len;
+	int ret;
+
+	prepare_test_packet(SOCK_RAW, ETH_P_IP, src_addr, dst_addr, &pkt_len);
+	prepare_test_dst_lladdr(&ll_dst, ETH_P_IP, dst_addr, src_iface);
+
+	ret = zsock_sendto(packet_sock_1, tx_buf, pkt_len, 0,
+			   (struct sockaddr *)&ll_dst,
+			   sizeof(struct sockaddr_ll));
+	zassert_not_equal(ret, -1, "Failed to send (%d)", errno);
+	zassert_equal(ret, pkt_len, "Invalid data length sent (%d/%d)", ret, pkt_len);
+
+	pkt_len -= offset;
+
+	ret = zsock_recvfrom(packet_sock_2, rx_buf, sizeof(rx_buf), 0,
+			     (struct sockaddr *)&ll_rx, &addrlen);
+	zassert_not_equal(ret, -1, "Failed to receive packet (%d)", errno);
+	zassert_equal(ret, pkt_len,
+		      "Invalid data size received (%d, expected %d)",
+		      ret, pkt_len);
+	zassert_mem_equal(rx_buf, tx_buf + offset, pkt_len,
+			  "Invalid payload received");
+	validate_recvfrom_addr(&ll_rx, addrlen, net_if_get_by_iface(dst_iface),
+			       src_addr);
+}
+
+static void test_recvfrom_common_unbound(int sock_type, bool bind_iface_0)
+{
+	struct sockaddr_ll ll_dst;
+	static uint8_t dummy_lladdr[] = { 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
+	uint16_t pkt_len;
+	int ret;
+
+	/* Transmitting sock */
+	setup_packet_socket(&packet_sock_1, SOCK_RAW, 0);
+	/* Receiving sock */
+	setup_packet_socket(&packet_sock_2, sock_type, htons(ETH_P_ALL));
+
+	if (bind_iface_0) {
+		bind_packet_socket(packet_sock_2, NULL);
+	}
+
+	/* Verify we get packet from iface 1 */
+	test_recvfrom_unbound_round(packet_sock_1, packet_sock_2, sock_type,
+				    lladdr2, ud.second, lladdr1, ud.first);
+
+	/* Verify we get packet from iface 2 */
+	test_recvfrom_unbound_round(packet_sock_1, packet_sock_2, sock_type,
+				    lladdr1, ud.first, lladdr2, ud.second);
+
+	/* Send some dummy data into the void on the "receiving" socket and make
+	 * sure it doesn't get automatically "bound" to the target iface.
+	 */
+	prepare_test_dst_lladdr(&ll_dst, ETH_P_IP, dummy_lladdr, ud.second);
+	prepare_test_packet(sock_type, ETH_P_IP, lladdr2, dummy_lladdr, &pkt_len);
+	ret = zsock_sendto(packet_sock_2, tx_buf, pkt_len, 0,
+			   (struct sockaddr *)&ll_dst,
+			   sizeof(struct sockaddr_ll));
+	zassert_not_equal(ret, -1, "Failed to send (%d)", errno);
+	zassert_equal(ret, pkt_len, "Invalid data length sent (%d/%d)", ret, pkt_len);
+
+	/* And try to receive again. */
+	/* Verify we get packet from iface 1 */
+	test_recvfrom_unbound_round(packet_sock_1, packet_sock_2, sock_type,
+				    lladdr2, ud.second, lladdr1, ud.first);
+
+	/* Verify we get packet from iface 2 */
+	test_recvfrom_unbound_round(packet_sock_1, packet_sock_2, sock_type,
+				    lladdr1, ud.first, lladdr2, ud.second);
+}
+
+ZTEST(socket_packet, test_raw_sock_recvfrom_proto_wildcard_unbound)
+{
+	test_recvfrom_common_unbound(SOCK_RAW, false);
+}
+
+ZTEST(socket_packet, test_dgram_sock_recvfrom_proto_wildcard_unbound)
+{
+	test_recvfrom_common_unbound(SOCK_DGRAM, false);
+}
+
+ZTEST(socket_packet, test_raw_sock_recvfrom_proto_wildcard_bound_iface_0)
+{
+	test_recvfrom_common_unbound(SOCK_RAW, true);
+}
+
+ZTEST(socket_packet, test_dgram_sock_recvfrom_proto_wildcard_bound_iface_0)
+{
+	test_recvfrom_common_unbound(SOCK_DGRAM, true);
+}
+
+static void test_recv_common_bound_other_iface(int sock_type)
+{
+	struct sockaddr_ll ll_dst;
+	struct sockaddr_in ip_src;
+	uint16_t pkt_len;
+	int ret;
+
+	/* Transmitting sock */
+	setup_packet_socket(&packet_sock_1, SOCK_RAW, 0);
+	prepare_test_packet(SOCK_RAW, ETH_P_IP, lladdr1, lladdr2, &pkt_len);
+	prepare_test_dst_lladdr(&ll_dst, ETH_P_IP, lladdr2, ud.first);
+	/* Receiving sock */
+	setup_packet_socket(&packet_sock_2, sock_type, htons(ETH_P_ALL));
+	bind_packet_socket(packet_sock_2, ud.first);
+	prepare_udp_socket(&udp_sock_1, &ip_src, DST_PORT);
+
+	ret = zsock_sendto(packet_sock_1, tx_buf, pkt_len, 0,
+			   (struct sockaddr *)&ll_dst,
+			   sizeof(struct sockaddr_ll));
+	zassert_not_equal(ret, -1, "Failed to send (%d)", errno);
+	zassert_equal(ret, pkt_len, "Invalid data length sent (%d/%d)", ret, pkt_len);
+
+	/* Packet socket should not get the packet due to different binding */
+	ret = zsock_recv(packet_sock_2, rx_buf, sizeof(rx_buf), 0);
+	zassert_equal(ret, -1, "Recv should fail");
+	zassert_equal(errno, EAGAIN, "Wrong errno");
+
+	/* But UDP socket should get the packet just fine. */
+	ret = zsock_recv(udp_sock_1, rx_buf, sizeof(rx_buf), 0);
+	zassert_not_equal(ret, -1, "Failed to receive UDP packet (%d)", errno);
+}
+
+ZTEST(socket_packet, test_raw_sock_recv_proto_wildcard_bound_other_iface)
+{
+	test_recv_common_bound_other_iface(SOCK_RAW);
+}
+
+ZTEST(socket_packet, test_dgram_sock_recv_proto_wildcard_bound_other_iface)
+{
+	test_recv_common_bound_other_iface(SOCK_DGRAM);
+}
+
 ZTEST(socket_packet, test_raw_dgram_udp_socks_recv)
 {
 	struct sockaddr_in ip_src;