net: Namespace network symbols to avoid conflicts with Posix/libc

Rename network symbols i.e., add net_, NET_ or ZSOCK_ prefixes
to those network symbols that can be found in Posix or libc.
This way we can avoid circular dependency issues.

Signed-off-by: Jukka Rissanen <jukka.rissanen@nordicsemi.no>

Author: jukkar

doc/connectivity/networking/api/coap_client.rst

@@ -37,7 +37,7 @@ The following is an example of a CoAP client initialization and request sending:
     req.payload = NULL;
     req.len = 0;
 
-    /* Sock is a file descriptor referencing a socket, address is the sockaddr struct for the
+    /* Sock is a file descriptor referencing a socket, address is the net_sockaddr struct for the
      * destination address of the request or NULL if the socket is already connected.
      */
     ret = coap_client_req(&client, sock, &address, &req, -1);

doc/connectivity/networking/api/coap_server.rst

@@ -74,7 +74,7 @@ The following is an example of a CoAP resource registered with our service:
     #include <zephyr/net/coap_service.h>
 
     static int my_get(struct coap_resource *resource, struct coap_packet *request,
-                      struct sockaddr *addr, socklen_t addr_len)
+                      struct net_sockaddr *addr, socklen_t addr_len)
     {
         static const char *msg = "Hello, world!";
         uint8_t data[CONFIG_COAP_SERVER_MESSAGE_SIZE];
@@ -106,7 +106,7 @@ The following is an example of a CoAP resource registered with our service:
     }
 
     static int my_put(struct coap_resource *resource, struct coap_packet *request,
-                      struct sockaddr *addr, socklen_t addr_len)
+                      struct net_sockaddr *addr, socklen_t addr_len)
     {
         /* ... Handle the incoming request ... */
 
@@ -142,7 +142,7 @@ of CoAP services. An example using a temperature sensor can look like:
     K_WORK_DELAYABLE_DEFINE(temp_work, notify_observers);
 
     static int send_temperature(struct coap_resource *resource,
-                                const struct sockaddr *addr, socklen_t addr_len,
+                                const struct net_sockaddr *addr, socklen_t addr_len,
                                 uint16_t age, uint16_t id, const uint8_t *token, uint8_t tkl,
                                 bool is_response)
     {
@@ -187,7 +187,7 @@ of CoAP services. An example using a temperature sensor can look like:
     }
 
     static int temp_get(struct coap_resource *resource, struct coap_packet *request,
-                        struct sockaddr *addr, socklen_t addr_len)
+                        struct net_sockaddr *addr, socklen_t addr_len)
     {
         uint8_t token[COAP_TOKEN_MAX_LEN];
         uint16_t id;

doc/connectivity/networking/api/dns_resolve.rst

@@ -59,12 +59,12 @@ Example:
         if (status == DNS_EAI_INPROGRESS && info) {
                 char str[MAX_STR_LEN + 1];
 
-                if (info->ai_family == AF_INET) {
-                        net_addr_ntop(AF_INET,
+                if (info->ai_family == NET_AF_INET) {
+                        net_addr_ntop(NET_AF_INET,
                                       &net_sin(&info->ai_addr)->sin_addr,
                                       str, NET_IPV4_ADDR_LEN);
-                } else if (info->ai_family == AF_INET6) {
-                        net_addr_ntop(AF_INET6,
+                } else if (info->ai_family == NET_AF_INET6) {
+                        net_addr_ntop(NET_AF_INET6,
                                       &net_sin6(&info->ai_addr)->sin6_addr,
                                       str, NET_IPV6_ADDR_LEN);
                 } else if (info->ai_family == AF_LOCAL) {

doc/connectivity/networking/api/http_server.rst

@@ -166,8 +166,8 @@ To use custom socket creation:
 
 The custom socket creation function receives:
 - ``svc``: Pointer to the service descriptor
-- ``af``: Address family (AF_INET or AF_INET6)
-- ``proto``: Protocol (IPPROTO_TCP or IPPROTO_TLS_1_2 for HTTPS)
+- ``af``: Address family (NET_AF_INET or NET_AF_INET6)
+- ``proto``: Protocol (NET_IPPROTO_TCP or NET_IPPROTO_TLS_1_2 for HTTPS)
 
 The function should return the socket file descriptor on success, or a negative error code on failure.
 

doc/connectivity/networking/api/mqtt.rst

@@ -51,7 +51,7 @@ of the MQTT client and can be shared among MQTT clients:
 .. code-block:: c
 
    /* MQTT Broker address information. */
-   static struct sockaddr_storage broker;
+   static struct net_sockaddr_storage broker;
 
 An MQTT client library will notify MQTT events to the application through a
 callback function created to handle respective events:

doc/connectivity/networking/api/mqtt_sn.rst

@@ -75,12 +75,12 @@ used. An example configuration for UDP transport is shown below:
 .. code-block:: c
 
    struct mqtt_sn_data client_id = MQTT_SN_DATA_STRING_LITERAL("ZEPHYR");
-   struct sockaddr_in gateway = {0};
+   struct net_sockaddr_in gateway = {0};
 
    uint8_t tx_buf[256];
    uint8_t rx_buf[256];
 
-   mqtt_sn_transport_udp_init(&tp, (struct sockaddr*)&gateway, sizeof((gateway)));
+   mqtt_sn_transport_udp_init(&tp, (struct net_sockaddr*)&gateway, sizeof((gateway)));
 
    mqtt_sn_client_init(&client, &client_id, &tp.tp, evt_cb, tx_buf, sizeof(tx_buf), rx_buf, sizeof(rx_buf));
 

doc/connectivity/networking/api/net_pkt.rst

@@ -109,14 +109,14 @@ bytes:
 
 .. code-block:: c
 
-    pkt = net_pkt_alloc_with_buffer(iface, 800, AF_INET4, IPPROTO_UDP, K_FOREVER);
+    pkt = net_pkt_alloc_with_buffer(iface, 800, NET_AF_INET4, IPPROTO_UDP, K_FOREVER);
 
 will successfully allocate 800 + 20 + 8 bytes of buffer for the new
 net_pkt where:
 
 .. code-block:: c
 
-    pkt = net_pkt_alloc_with_buffer(iface, 1600, AF_INET4, IPPROTO_UDP, K_FOREVER);
+    pkt = net_pkt_alloc_with_buffer(iface, 1600, NET_AF_INET4, IPPROTO_UDP, K_FOREVER);
 
 will successfully allocate 1500 bytes, and where 20 + 8 bytes (IPv4 +
 UDP headers) will not be used for the payload.

drivers/ethernet/eth_adin2111.c

@@ -317,7 +317,7 @@ int eth_adin2111_oa_data_read(const struct device *dev, const uint16_t port_idx)
 
 		if (ftr & ADIN2111_OA_DATA_FTR_EV) {
 			pkt = net_pkt_rx_alloc_with_buffer(iface, CONFIG_ETH_ADIN2111_BUFFER_SIZE,
-							   AF_UNSPEC, 0,
+							   NET_AF_UNSPEC, 0,
 							   K_MSEC(CONFIG_ETH_ADIN2111_TIMEOUT));
 			if (!pkt) {
 				LOG_ERR("OA RX: cannot allcate packet space, skipping.");
@@ -439,7 +439,7 @@ static int eth_adin2111_reg_read_generic(const struct device *dev,
 #endif /* CONFIG_ETH_ADIN2111_SPI_CFG0 */
 
 	/* spi header */
-	*(uint16_t *)buf = htons((ADIN2111_READ_TXN_CTRL | reg));
+	*(uint16_t *)buf = net_htons((ADIN2111_READ_TXN_CTRL | reg));
 #if CONFIG_ETH_ADIN2111_SPI_CFG0
 	buf[2] = crc8_ccitt(0, buf, ADIN2111_SPI_HEADER_SIZE);
 	/* TA */
@@ -471,7 +471,7 @@ static int eth_adin2111_reg_read_generic(const struct device *dev,
 	}
 #endif /* CONFIG_ETH_ADIN2111_SPI_CFG0 */
 
-	*val = ntohl((*(uint32_t *)(&buf[header_len])));
+	*val = net_ntohl((*(uint32_t *)(&buf[header_len])));
 
 	return ret;
 }
@@ -490,14 +490,14 @@ static int eth_adin2111_reg_write_generic(const struct device *dev,
 #endif /* CONFIG_ETH_ADIN2111_SPI_CFG0 */
 
 	/* spi header */
-	*(uint16_t *)buf = htons((ADIN2111_WRITE_TXN_CTRL | reg));
+	*(uint16_t *)buf = net_htons((ADIN2111_WRITE_TXN_CTRL | reg));
 	#if CONFIG_ETH_ADIN2111_SPI_CFG0
 	buf[2] = crc8_ccitt(0, buf, header_size);
 	++header_size;
 #endif /* CONFIG_ETH_ADIN2111_SPI_CFG0 */
 
 	/* reg */
-	*(uint32_t *)(buf + header_size) = htonl(val);
+	*(uint32_t *)(buf + header_size) = net_htonl(val);
 #if CONFIG_ETH_ADIN2111_SPI_CFG0
 	buf[header_size + data_size] = crc8_ccitt(0, &buf[header_size], data_size);
 	++data_size;
@@ -576,7 +576,7 @@ static int adin2111_read_fifo(const struct device *dev, const uint16_t port_idx)
 	fsize -= ADIN2111_FRAME_HEADER_SIZE;
 
 	/* spi header */
-	*(uint16_t *)cmd_buf = htons((ADIN2111_READ_TXN_CTRL | rx_reg));
+	*(uint16_t *)cmd_buf = net_htons((ADIN2111_READ_TXN_CTRL | rx_reg));
 #if CONFIG_ETH_ADIN2111_SPI_CFG0
 	cmd_buf[2] = crc8_ccitt(0, cmd_buf, ADIN2111_SPI_HEADER_SIZE);
 	/* TA */
@@ -608,7 +608,7 @@ static int adin2111_read_fifo(const struct device *dev, const uint16_t port_idx)
 	/* remove CRC32 and pass to the stack */
 	fsize_real = fsize - sizeof(uint32_t);
 
-	pkt = net_pkt_rx_alloc_with_buffer(iface, fsize_real, AF_UNSPEC, 0,
+	pkt = net_pkt_rx_alloc_with_buffer(iface, fsize_real, NET_AF_UNSPEC, 0,
 					   K_MSEC(CONFIG_ETH_ADIN2111_TIMEOUT));
 	if (!pkt) {
 		eth_stats_update_errors_rx(iface);
@@ -838,7 +838,7 @@ static int adin2111_port_send(const struct device *dev, struct net_pkt *pkt)
 			eth_adin2111_lock(adin, K_FOREVER);
 		}
 
-		ret = eth_adin2111_send_oa_frame(cfg->adin, pkt, htons(cfg->port_idx));
+		ret = eth_adin2111_send_oa_frame(cfg->adin, pkt, net_htons(cfg->port_idx));
 
 		goto end_check;
 	}
@@ -887,14 +887,14 @@ static int adin2111_port_send(const struct device *dev, struct net_pkt *pkt)
 	memset(ctx->buf, 0, burst_size + ADIN2111_WRITE_HEADER_SIZE);
 
 	/* spi header */
-	*(uint16_t *)ctx->buf = htons(ADIN2111_TXN_CTRL_TX_REG);
+	*(uint16_t *)ctx->buf = net_htons(ADIN2111_TXN_CTRL_TX_REG);
 #if CONFIG_ETH_ADIN2111_SPI_CFG0
 	ctx->buf[2] = crc8_ccitt(0, ctx->buf, header_size);
 	++header_size;
 #endif /* CONFIG_ETH_ADIN2111_SPI_CFG0 */
 
 	/* frame header */
-	*(uint16_t *)(ctx->buf + header_size) = htons(cfg->port_idx);
+	*(uint16_t *)(ctx->buf + header_size) = net_htons(cfg->port_idx);
 
 	/* read pkt into tx buffer */
 	ret = net_pkt_read(pkt,

drivers/ethernet/eth_cyclonev.c

@@ -680,7 +680,8 @@ static void eth_cyclonev_receive(struct eth_cyclonev_priv *p)
 		p->rx_current_desc_number = last_desc_index;
 
 		/* Allocate packet with buffer */
-		pkt = net_pkt_rx_alloc_with_buffer(p->iface, frame_length, AF_UNSPEC, 0, K_NO_WAIT);
+		pkt = net_pkt_rx_alloc_with_buffer(p->iface, frame_length,
+						   NET_AF_UNSPEC, 0, K_NO_WAIT);
 		if (!pkt) {
 			LOG_ERR("net_pkt_rx_alloc_with_buffer() failed");
 			eth_stats_update_errors_rx(p->iface);

drivers/ethernet/eth_e1000.c

@@ -157,7 +157,7 @@ static struct net_pkt *e1000_rx(struct e1000_dev *dev)
 
 	hexdump(buf, len, "%zd byte(s)", len);
 
-	pkt = net_pkt_rx_alloc_with_buffer(dev->iface, len, AF_UNSPEC, 0,
+	pkt = net_pkt_rx_alloc_with_buffer(dev->iface, len, NET_AF_UNSPEC, 0,
 					   K_NO_WAIT);
 	if (!pkt) {
 		LOG_ERR("Out of buffers");