Chapter 89: Socket Options and Configurations

Chapter Objectives

After completing this chapter, students will be able to:

• Understand the purpose and importance of socket options in network programming.
• Identify different levels for socket options (SOL_SOCKET, IPPROTO_IP, IPPROTO_TCP).
• Use getsockopt() and setsockopt() functions to query and modify socket options.
• Configure common socket options like SO_REUSEADDR, SO_KEEPALIVE, TCP_NODELAY, SO_SNDBUF, SO_RCVBUF, SO_RCVTIMEO, SO_SNDTIMEO, SO_BROADCAST, and SO_LINGER.
• Understand the impact of these options on TCP, UDP, and raw socket behavior.
• Configure options related to IP Time-To-Live (IP_TTL) and multicast operations (IP_MULTICAST_TTL, IP_ADD_MEMBERSHIP, IP_DROP_MEMBERSHIP).
• Recognize LwIP-specific considerations and limitations for socket options on ESP32.
• Troubleshoot common issues related to socket option configurations.

Introduction

Throughout our exploration of TCP, UDP, and raw sockets, we’ve seen how these protocols provide different types of network communication services. While their default behaviors are suitable for a wide range of applications, there are often times when we need to customize or fine-tune how sockets operate to meet specific performance, reliability, or functional requirements. This is achieved through socket options.

Socket options are parameters that can be queried and modified to control various aspects of a socket’s behavior, from how it handles timeouts and buffering to its interaction with underlying protocols like TCP and IP. In ESP-IDF, the LwIP TCP/IP stack provides a rich set of socket options compliant with the Berkeley Sockets API, allowing developers to tailor network communication to the needs of their embedded applications.

This chapter provides a consolidated guide to understanding and utilizing key socket options. We will revisit some options briefly mentioned in previous chapters (like TCP_NODELAY or SO_KEEPALIVE in Chapter 86, or IP_HDRINCL in Chapter 88) and introduce others, offering a more comprehensive perspective on how to configure sockets for optimal performance and functionality on your ESP32 devices.

Theory

1. What are Socket Options?

Socket options are settings or flags associated with a network socket that control its behavior and the behavior of the underlying communication protocols. They provide a mechanism for applications to influence aspects that are not covered by the standard data transfer functions (send, recv, sendto, recvfrom).

These options can affect various layers of the network stack:

• Socket Layer (SOL_SOCKET): General options applicable to all socket types.
• IP Layer (IPPROTO_IP): Options specific to the Internet Protocol (IPv4 or IPv6).
• TCP Layer (IPPROTO_TCP): Options specific to the Transmission Control Protocol.
• UDP Layer (IPPROTO_UDP): While UDP itself has few options, some IP-level options are particularly relevant to UDP usage (e.g., for multicast).

2. getsockopt() and setsockopt() Functions

The primary way to interact with socket options is through two functions:

• int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);
  • Sets a socket option.
  • sockfd: The file descriptor of the socket.
  • level: The protocol level at which the option resides (e.g., SOL_SOCKET, IPPROTO_IP, IPPROTO_TCP).
  • optname: The specific option to set (e.g., SO_REUSEADDR, TCP_NODELAY).
  • optval: A pointer to a buffer containing the value for the option. The data type of this value depends on the option being set (e.g., an int for a boolean flag, a struct timeval for timeouts).
  • optlen: The size of the buffer pointed to by optval.
  • Returns 0 on success, -1 on error (with errno set).
• int getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen);
  • Gets the current value of a socket option.
  • sockfd, level, optname: Same as setsockopt.
  • optval: A pointer to a buffer where the option value will be stored.
  • optlen: A value-result argument. Before calling, it should point to a socklen_t variable holding the size of the optval buffer. On return, it will be updated with the actual size of the option value retrieved.
  • Returns 0 on success, -1 on error.

Important: Always check the return values of these functions and consult errno in case of failure to understand the cause.

3. Common Socket Options

Here’s a breakdown of some frequently used socket options available in LwIP on ESP32:

a. Socket Level Options (SOL_SOCKET)

These options are general and apply to various socket types.

b. IP Level Options (IPPROTO_IP)

These options control aspects of the IP protocol.

c. TCP Level Options (IPPROTO_TCP)

These options are specific to TCP sockets.

%%{ init: { 'theme': 'base', 'themeVariables': { 'fontFamily': 'Open Sans' } } }%%
graph TD
    A[Application Code] --> B(Sockets API <br> e.g., setsockopt, getsockopt)

    subgraph Socket Layer
        B --> C{SOL_SOCKET Options <br> e.g., SO_REUSEADDR, SO_KEEPALIVE, SO_RCVTIMEO}
    end

    subgraph Transport Layer
        C --> D{IPPROTO_TCP Options <br> e.g., TCP_NODELAY, TCP_KEEPIDLE}
        C --> E{"IPPROTO_UDP Options <br> (Fewer direct options, often IP-level for multicast)"}
    end

    subgraph Network/Internet Layer
        D --> F{IPPROTO_IP Options <br> e.g., IP_TTL, IP_ADD_MEMBERSHIP}
        E --> F
    end

    F --> G["Network Interface <br> (Wi-Fi, Ethernet)"]

    classDef app fill:#DBEAFE,stroke:#2563EB,stroke-width:1px,color:#1E40AF;
    classDef api fill:#DBEAFE,stroke:#2563EB,stroke-width:1px,color:#1E40AF;
    classDef sol_socket fill:#EDE9FE,stroke:#5B21B6,stroke-width:2px,color:#5B21B6;
    classDef ipproto_tcp fill:#FEF3C7,stroke:#D97706,stroke-width:1px,color:#92400E;
    classDef ipproto_udp fill:#FEF3C7,stroke:#D97706,stroke-width:1px,color:#92400E;
    classDef ipproto_ip fill:#D1FAE5,stroke:#059669,stroke-width:2px,color:#065F46;
    classDef netif fill:#FEE2E2,stroke:#DC2626,stroke-width:1px,color:#991B1B;

    class A app;
    class B api;
    class C sol_socket;
    class D ipproto_tcp;
    class E ipproto_udp;
    class F ipproto_ip;
    class G netif;

4. LwIP Specific Considerations

%%{ init: { 'theme': 'base', 'themeVariables': { 'fontFamily': 'Open Sans' } } }%%
graph TD
    Start((TCP Connection Established <br> SO_KEEPALIVE enabled)) --> Idle{Connection Idle?};
    Idle -- Yes --> TimerTCPKeepIdle[\TCP_KEEPIDLE Timer Running/];
    TimerTCPKeepIdle -- Expires --> SendProbe[Send Keepalive Probe 1];
    SendProbe --> WaitForAck{"Wait for ACK"};
    WaitForAck -- ACK Received --> ConnectionActive[Connection Considered Active <br> Reset Idle Timer];
    ConnectionActive --> Idle;
    Idle -- No --> ConnectionActive;

    WaitForAck -- No ACK within Probe Timeout --> ProbeCount{Probe Count < TCP_KEEPCNT?};
    ProbeCount -- Yes --> TimerTCPKeepIntvl[\TCP_KEEPINTVL Timer Running/];
    TimerTCPKeepIntvl -- Expires --> SendNextProbe[Send Next Keepalive Probe];
    SendNextProbe --> WaitForAck;
    ProbeCount -- No --> ConnectionDead[Connection Considered Dead <br> Inform Application];

    classDef startNode fill:#EDE9FE,stroke:#5B21B6,stroke-width:2px,color:#5B21B6;
    classDef processNode fill:#DBEAFE,stroke:#2563EB,stroke-width:1px,color:#1E40AF;
    classDef decisionNode fill:#FEF3C7,stroke:#D97706,stroke-width:1px,color:#92400E;
    classDef successNode fill:#D1FAE5,stroke:#059669,stroke-width:2px,color:#065F46;
    classDef errorNode fill:#FEE2E2,stroke:#DC2626,stroke-width:1px,color:#991B1B;

    class Start startNode;
    class Idle decisionNode;
    class WaitForAck decisionNode;
    class TimerTCPKeepIdle processNode;
    class SendProbe processNode;
    class ConnectionActive processNode;
    class ProbeCount processNode;
    class TimerTCPKeepIntvl processNode;
    class SendNextProbe processNode;
    class ConnectionDead errorNode;

• Memory Usage: LwIP is designed for embedded systems with limited memory. Options like SO_SNDBUF and SO_RCVBUF are hints. LwIP manages a central pool of packet buffers (pbufs). Excessively large suggested buffer sizes won’t necessarily allocate dedicated large buffers per socket and can be constrained by global LwIP memory settings (TCP_WND, TCP_SND_BUF, PBUF_POOL_SIZE etc. in menuconfig).
• Default Values: Default values for options like TCP keepalive timers can be quite large in LwIP. For responsive dead connection detection, you’ll need to set them explicitly.
• Supported Options: While LwIP aims for POSIX compliance, not every conceivable socket option found on desktop OSes might be implemented or have the exact same nuanced behavior. Always check LwIP documentation or test. The options listed above are generally well-supported.
• Configuration via menuconfig: Many global LwIP parameters that affect default socket behavior (e.g., default TCP window size, max number of active PCBs) are configured via idf.py menuconfig under Component config -> LWIP. Per-socket options can override or refine these for individual connections.

Practical Examples

Let’s see how to use some of these options. Assume basic network initialization and Wi-Fi/Ethernet connection are already established.

Example 1: Setting SO_REUSEADDR for a TCP Server

#include "lwip/sockets.h"
#include "esp_log.h"

static const char *TAG_REUSEADDR = "so_reuseaddr";

void setup_tcp_server_socket_reuseaddr(int port) {
    int listen_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (listen_sock < 0) {
        ESP_LOGE(TAG_REUSEADDR, "Unable to create socket: errno %d", errno);
        return;
    }

    // Enable SO_REUSEADDR
    int opt = 1;
    if (setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
        ESP_LOGE(TAG_REUSEADDR, "Unable to set SO_REUSEADDR: errno %d", errno);
        // Continue, but binding might fail if port is in TIME_WAIT
    } else {
        ESP_LOGI(TAG_REUSEADDR, "SO_REUSEADDR enabled.");
    }

    struct sockaddr_in dest_addr;
    dest_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    dest_addr.sin_family = AF_INET;
    dest_addr.sin_port = htons(port);

    if (bind(listen_sock, (struct sockaddr *)&dest_addr, sizeof(dest_addr)) < 0) {
        ESP_LOGE(TAG_REUSEADDR, "Socket unable to bind: errno %d", errno);
        close(listen_sock);
        return;
    }
    ESP_LOGI(TAG_REUSEADDR, "Socket bound to port %d", port);

    // ... proceed with listen() and accept() ...
    // close(listen_sock); // Eventually
}

Example 2: Configuring SO_KEEPALIVE and TCP Keepalive Timers

#include "lwip/sockets.h"
#include "esp_log.h"

static const char *TAG_KEEPALIVE = "so_keepalive";

void configure_tcp_keepalive(int sock) {
    int err;

    // 1. Enable SO_KEEPALIVE at the socket level
    int keepalive_enable = 1;
    err = setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &keepalive_enable, sizeof(keepalive_enable));
    if (err != 0) {
        ESP_LOGE(TAG_KEEPALIVE, "setsockopt SO_KEEPALIVE failed: errno %d", errno);
        return;
    }
    ESP_LOGI(TAG_KEEPALIVE, "SO_KEEPALIVE enabled.");

    // 2. Configure TCP_KEEPIDLE: Idle time before first probe (e.g., 30 seconds)
    int keepidle = 30; // Seconds
    err = setsockopt(sock, IPPROTO_TCP, TCP_KEEPIDLE, &keepidle, sizeof(keepidle));
    if (err != 0) {
        ESP_LOGE(TAG_KEEPALIVE, "setsockopt TCP_KEEPIDLE failed: errno %d", errno);
    } else {
        ESP_LOGI(TAG_KEEPALIVE, "TCP_KEEPIDLE set to %d seconds.", keepidle);
    }

    // 3. Configure TCP_KEEPINTVL: Interval between probes (e.g., 5 seconds)
    int keepintvl = 5; // Seconds
    err = setsockopt(sock, IPPROTO_TCP, TCP_KEEPINTVL, &keepintvl, sizeof(keepintvl));
    if (err != 0) {
        ESP_LOGE(TAG_KEEPALIVE, "setsockopt TCP_KEEPINTVL failed: errno %d", errno);
    } else {
        ESP_LOGI(TAG_KEEPALIVE, "TCP_KEEPINTVL set to %d seconds.", keepintvl);
    }

    // 4. Configure TCP_KEEPCNT: Number of probes before timeout (e.g., 3 probes)
    int keepcnt = 3;
    err = setsockopt(sock, IPPROTO_TCP, TCP_KEEPCNT, &keepcnt, sizeof(keepcnt));
    if (err != 0) {
        ESP_LOGE(TAG_KEEPALIVE, "setsockopt TCP_KEEPCNT failed: errno %d", errno);
    } else {
        ESP_LOGI(TAG_KEEPALIVE, "TCP_KEEPCNT set to %d.", keepcnt);
    }
    // Total time to detect dead connection approx: keepidle + (keepcnt * keepintvl)
    // Example: 30 + (3 * 5) = 45 seconds
}

// Call configure_tcp_keepalive(conn_sock) after a TCP connection is accepted or established.

Example 3: Setting SO_RCVTIMEO for a UDP Receiver

#include "lwip/sockets.h"
#include "esp_log.h"

static const char *TAG_RCVTIMEO = "so_rcvtimeo";
#define UDP_PORT 1235
#define MAX_UDP_BUF 64

void udp_receiver_with_timeout_task(void *pvParameters) {
    char rx_buffer[MAX_UDP_BUF];
    int sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (sock < 0) {
        ESP_LOGE(TAG_RCVTIMEO, "Failed to create UDP socket: errno %d", errno);
        vTaskDelete(NULL);
        return;
    }

    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(UDP_PORT);
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);

    if (bind(sock, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        ESP_LOGE(TAG_RCVTIMEO, "Failed to bind UDP socket: errno %d", errno);
        close(sock);
        vTaskDelete(NULL);
        return;
    }

    // Set receive timeout: 5 seconds
    struct timeval timeout;
    timeout.tv_sec = 5;
    timeout.tv_usec = 0;
    if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) < 0) {
        ESP_LOGE(TAG_RCVTIMEO, "Failed to set SO_RCVTIMEO: errno %d", errno);
        // Socket will block indefinitely if this fails
    } else {
        ESP_LOGI(TAG_RCVTIMEO, "SO_RCVTIMEO set to 5 seconds.");
    }

    struct sockaddr_storage source_addr;
    socklen_t socklen = sizeof(source_addr);
    ESP_LOGI(TAG_RCVTIMEO, "UDP socket listening on port %d. Waiting for data...", UDP_PORT);

    while(1) {
        int len = recvfrom(sock, rx_buffer, sizeof(rx_buffer) - 1, 0, (struct sockaddr *)&source_addr, &socklen);
        if (len < 0) {
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                ESP_LOGI(TAG_RCVTIMEO, "Receive timeout. No data received.");
                // Perform other actions, or continue waiting
            } else {
                ESP_LOGE(TAG_RCVTIMEO, "recvfrom failed: errno %d", errno);
                break; // Or handle error differently
            }
        } else {
            rx_buffer[len] = 0; // Null-terminate
            ESP_LOGI(TAG_RCVTIMEO, "Received %d bytes: %s", len, rx_buffer);
        }
        vTaskDelay(pdMS_TO_TICKS(100)); // Small delay to prevent busy-looping if timeout is very short
    }
    close(sock);
    vTaskDelete(NULL);
}

Example 4: Enabling SO_BROADCAST for a UDP Sender

#include "lwip/sockets.h"
#include "esp_log.h"

static const char *TAG_BROADCAST = "so_broadcast";
#define BROADCAST_PORT 1236
#define BROADCAST_MSG "ESP32 UDP Broadcast!"

void udp_broadcast_sender_task(void *pvParameters) {
    int sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (sock < 0) {
        ESP_LOGE(TAG_BROADCAST, "Failed to create UDP socket: errno %d", errno);
        vTaskDelete(NULL);
        return;
    }

    // Enable SO_BROADCAST
    int broadcast_enable = 1;
    if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &broadcast_enable, sizeof(broadcast_enable)) < 0) {
        ESP_LOGE(TAG_BROADCAST, "Failed to set SO_BROADCAST: errno %d", errno);
        close(sock);
        vTaskDelete(NULL);
        return;
    }
    ESP_LOGI(TAG_BROADCAST, "SO_BROADCAST enabled.");

    struct sockaddr_in dest_addr;
    dest_addr.sin_family = AF_INET;
    dest_addr.sin_port = htons(BROADCAST_PORT);
    // Use 255.255.255.255 for limited broadcast (local network segment)
    // Or use specific subnet broadcast address if known (e.g., 192.168.1.255)
    dest_addr.sin_addr.s_addr = htonl(INADDR_BROADCAST); // Equivalent to 255.255.255.255

    while(1) {
        int err = sendto(sock, BROADCAST_MSG, strlen(BROADCAST_MSG), 0, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
        if (err < 0) {
            ESP_LOGE(TAG_BROADCAST, "sendto broadcast failed: errno %d", errno);
        } else {
            ESP_LOGI(TAG_BROADCAST, "Broadcast message sent: %s", BROADCAST_MSG);
        }
        vTaskDelay(pdMS_TO_TICKS(5000)); // Send broadcast every 5 seconds
    }
    close(sock); // Should not be reached in this example
    vTaskDelete(NULL);
}

Build Instructions

1. Create Project: Standard ESP-IDF project.
2. Add Code: Integrate the chosen example(s) into your main.c or other source files.
3. Network Setup: Ensure app_main includes Wi-Fi/Ethernet initialization and connection logic.
4. Task Creation: Create FreeRTOS tasks for the example functions (e.g., xTaskCreate(udp_receiver_with_timeout_task, ..., NULL);).
5. LwIP Configuration: No special LwIP component configuration is typically needed for these common socket options beyond the standard LwIP enablement, unless dealing with raw sockets or very specific LwIP internals.
6. Build: idf.py build
7. Flash: idf.py -p (PORT) flash
8. Monitor: idf.py -p (PORT) monitor

Run/Flash/Observe Steps

• SO_REUSEADDR: To observe, create a server, connect a client, close the client, then quickly stop and restart the server. Without SO_REUSEADDR, the bind on restart might fail if the port is in TIME_WAIT. With it, bind should succeed.
• SO_KEEPALIVE: Establish a TCP connection. Leave it idle. Use Wireshark to observe keepalive probes after TCP_KEEPIDLE time. Disconnect the peer abruptly (e.g., unplug network cable or kill peer process); observe probes failing and the ESP32 connection eventually erroring out.
• SO_RCVTIMEO: Run the UDP receiver. Send no data. Observe the “Receive timeout” log message after the specified timeout. Then, send data (e.g., using netcat on a PC: echo "Hello" | nc -u <ESP32_IP> 1235) and see it received.
• SO_BROADCAST: Run the UDP broadcast sender on one ESP32. On another ESP32 (or PC with netcat -ul -p 1236) on the same network, listen for the broadcast messages.

Variant Notes

The standard Berkeley Sockets API for getsockopt and setsockopt, and the common options discussed, are consistently implemented by LwIP across the ESP32, ESP32-S2, ESP32-S3, ESP32-C3, ESP32-C6, and ESP32-H2 variants.

• LwIP Core Consistency: The LwIP stack itself provides these options, so their availability and basic function are uniform.
• Resource Impact (RAM/CPU):
  • Options influencing buffer sizes (SO_SNDBUF, SO_RCVBUF) or requiring active processing (like SO_KEEPALIVE probes) have resource implications.
  • Variants with more RAM (e.g., ESP32-S3, ESP32 with PSRAM) can better accommodate larger effective buffer sizes if LwIP’s global memory pools are configured accordingly. However, the per-socket options are still hints.
  • CPU usage for managing these options is generally low but could be a factor in extremely high-performance or heavily loaded systems. All ESP32 variants are typically capable.
• Network Interface Specifics: The underlying network interface (Wi-Fi, Ethernet, Thread on ESP32-H2/C6) doesn’t change the socket options API but can influence the effectiveness or necessity of certain options. For example, keepalives might be more critical over less reliable Wi-Fi than over stable Ethernet.
• Default LwIP Settings: While the API is consistent, the default values for some LwIP parameters that indirectly affect socket options (e.g., default TCP window, default keepalive timers if not overridden by setsockopt) might have slight variations in the SDK’s default LwIP configuration for different target chips, optimized for typical resource availability. However, setsockopt allows explicit control.

In summary, you can expect these socket options to work as described on all ESP32 variants. The primary differences will relate to how aggressively you can tune resource-intensive options based on the specific variant’s RAM and CPU capabilities.

Common Mistakes & Troubleshooting Tips

Tip: When in doubt, use getsockopt after setsockopt to verify if the option was set to the value you intended, or what value LwIP actually accepted (especially for buffer sizes).

Exercises

1. SO_LINGER Exploration:
   • Create a TCP client that connects to a server (e.g., netcat on your PC).
   • Experiment with SO_LINGER:
     • Case 1 (Default): Send some data, then close() the socket. Observe if netcat receives all data.
     • Case 2 (l_onoff = 1, l_linger = 0): Send some data, set linger to hard close, then close(). Observe if netcat receives all data (it might not if data wasn’t fully transmitted by the stack yet). Use Wireshark to see if an RST is sent.
     • Case 3 (l_onoff = 1, l_linger = 5 (seconds)): Send data, set linger to block for 5 seconds, then close(). If the data is small, close() might return quickly. If you try to send a lot of data to a slow peer, observe if close() blocks.
   • Document your observations on the behavior of close() and data transmission in each case.
2. Multicast Sender TTL:
   • Create a UDP multicast sender application (refer to examples from previous chapters or build a new one).
   • Implement a way to configure the IP_MULTICAST_TTL socket option (e.g., read a value from a Kconfig setting or a global variable).
   • Set up two network segments/subnets with a multicast router between them (this might require a more complex network setup or virtualization if you don’t have physical routers).
   • Test sending multicast packets with IP_MULTICAST_TTL = 1. Verify they are received on the local subnet but not the remote one.
   • Test with IP_MULTICAST_TTL > 1 (e.g., 2 or 5). Verify if packets now cross the router to the remote subnet. (Requires multicast routing to be enabled on the router).
3. Get and Print Default Socket Options:
   • Write an ESP32 application that creates a TCP socket and a UDP socket.
   • For each socket, use getsockopt to query and print the default values for at least the following options:
     • SO_SNDBUF
     • SO_RCVBUF
     • SO_KEEPALIVE (for TCP socket)
     • TCP_NODELAY (for TCP socket, after enabling keepalive to ensure it’s a valid TCP socket state for querying this)
     • IP_TTL (for both)
   • Compare these default values with what might be documented or configured in LwIP’s menuconfig settings.

Summary

• Socket options provide fine-grained control over socket behavior using setsockopt() to modify and getsockopt() to query values.
• Options are organized by level (SOL_SOCKET, IPPROTO_IP, IPPROTO_TCP) and optname.
• Key options include:
  • SO_REUSEADDR: Allows reuse of local addresses, vital for restarting servers.
  • SO_KEEPALIVE (with TCP_KEEPIDLE, TCP_KEEPINTVL, TCP_KEEPCNT): Manages TCP connection liveness.
  • TCP_NODELAY: Disables Nagle’s algorithm for low-latency TCP.
  • SO_SNDBUF/SO_RCVBUF: Hint at buffer sizes, influencing LwIP’s internal management.
  • SO_RCVTIMEO/SO_SNDTIMEO: Set timeouts for blocking socket operations.
  • SO_BROADCAST: Enables sending UDP broadcast packets.
  • SO_LINGER: Controls close() behavior for unsent data.
  • IP-level options like IP_TTL, IP_MULTICAST_TTL, and multicast membership options (IP_ADD_MEMBERSHIP, IP_DROP_MEMBERSHIP) manage IP packet characteristics and multicast group participation.
• LwIP on ESP32 supports these standard options, but resource constraints (memory) must be considered, especially for buffer-related settings.
• Correct usage involves specifying the correct level, option name, option value type/size, and always checking function return values.

Further Reading

• ESP-IDF Programming Guide:
  • https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-guides/lwip.html
  • https://github.com/espressif/esp-idf/tree/master/examples/protocols/sockets
• LwIP Project Documentation:
  • LwIP Wiki: http://lwip.wikia.com/wiki/LwIP_Wiki
  • LwIP header files: lwip/sockets.h, lwip/tcp.h, lwip/ip.h for specific option definitions and structures.
• RFCs (Request for Comments): Relevant RFCs for TCP (RFC 793), IP (RFC 791), and specific mechanisms like Nagle (RFC 896).
• Books:
  • “Unix Network Programming, Vol. 1: The Sockets Networking API” by W. Richard Stevens, Bill Fenner, and Andrew M. Rudoff – The definitive guide to socket programming, including detailed explanations of socket options.
  • “TCP/IP Illustrated, Vol. 1: The Protocols” by W. Richard Stevens.