OpenParable
Skip to content
← Back to skills

Socket Programming

Development
socket-programming

Socket Programming is an Agent Skill for development published in the a5c-ai/babysitter repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.

Deep integration with socket APIs for TCP/UDP programming across platforms. Execute socket operations, analyze socket options and buffer configurations, debug connection states, and generate optimized socket code for different I/O models.

View on GitHub ↗
QUICK START

How to use this skill

Bring this guide into your coding agent with a prompt tailored to the tool you use.

  1. Open your project in Codex.
  2. Copy and paste the prompt below.
  3. Review files and risks before approving any action.
Prompt to paste
Inspect the Agent Skill at https://github.com/a5c-ai/babysitter/blob/HEAD/library/specializations/network-programming/skills/socket-programming/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/socket-programming, but wait for my approval before writing files or running scripts.

Copying this prompt does not install or run the skill. Review third-party files before use.

socket-programming

You are socket-programming - a specialized skill for low-level socket programming, providing deep integration with TCP/UDP socket APIs across platforms (BSD sockets, Winsock).

Overview

This skill enables AI-powered socket programming operations including:

  • Executing socket operations and interpreting errors
  • Analyzing socket options and buffer configurations
  • Debugging connection states (ESTABLISHED, TIME_WAIT, CLOSE_WAIT)
  • Generating optimized socket code for different I/O models
  • Interpreting netstat/ss output for socket analysis
  • Configuring non-blocking I/O and event handling
  • Handling platform differences (BSD sockets, Winsock)

Prerequisites

  • Development environment with socket library access
  • netstat or ss CLI tools for socket analysis
  • Appropriate permissions for raw socket operations (if needed)

Capabilities

1. Socket API Operations

Execute and analyze socket operations across platforms:

// TCP Socket Server Pattern (POSIX)
int server_fd = socket(AF_INET, SOCK_STREAM, 0);

// Socket options
int opt = 1;
setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
setsockopt(server_fd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));

// Buffer configuration
int send_buf = 65536;
int recv_buf = 65536;
setsockopt(server_fd, SOL_SOCKET, SO_SNDBUF, &send_buf, sizeof(send_buf));
setsockopt(server_fd, SOL_SOCKET, SO_RCVBUF, &recv_buf, sizeof(recv_buf));

// TCP options
int nodelay = 1;
setsockopt(server_fd, IPPROTO_TCP, TCP_NODELAY, &nodelay, sizeof(nodelay));

2. Connection State Analysis

Debug connection states using system tools:

# Linux - ss command (preferred)
ss -tnp state established '( sport = :8080 )'
ss -tnp state time-wait
ss -s  # Summary statistics

# Cross-platform - netstat
netstat -an | grep :8080
netstat -an | grep ESTABLISHED
netstat -an | grep TIME_WAIT

# Socket buffer analysis
ss -tnpm  # Show memory usage
cat /proc/net/sockstat  # Socket statistics

3. Non-blocking I/O Configuration

Configure non-blocking sockets for high-performance:

// Set non-blocking mode (POSIX)
int flags = fcntl(sockfd, F_GETFL, 0);
fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);

// Windows equivalent
u_long mode = 1;
ioctlsocket(sockfd, FIONBIO, &mode);

4. Error Handling Patterns

Interpret and handle socket errors:

// Common socket errors and handling
switch (errno) {
    case EAGAIN:      // Would block (non-blocking)
    case EWOULDBLOCK: // Same as EAGAIN on most systems
        // Retry later or wait for event
        break;
    case EINTR:       // Interrupted by signal
        // Retry the operation
        break;
    case ECONNRESET:  // Connection reset by peer
        // Close and cleanup
        break;
    case ETIMEDOUT:   // Connection timed out
        // Reconnect logic
        break;
    case EADDRINUSE:  // Address already in use
        // Use SO_REUSEADDR or wait
        break;
}

5. Socket Code Generation

Generate optimized socket implementations:

TCP Server Template

#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>

typedef struct {
    int port;
    int backlog;
    int recv_buffer_size;
    int send_buffer_size;
    bool tcp_nodelay;
    bool non_blocking;
} server_config_t;

int create_tcp_server(server_config_t *config) {
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd < 0) return -1;

    // Reuse address
    int opt = 1;
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    // Buffer sizes
    if (config->recv_buffer_size > 0) {
        setsockopt(server_fd, SOL_SOCKET, SO_RCVBUF,
                   &config->recv_buffer_size, sizeof(int));
    }
    if (config->send_buffer_size > 0) {
        setsockopt(server_fd, SOL_SOCKET, SO_SNDBUF,
                   &config->send_buffer_size, sizeof(int));
    }

    // TCP_NODELAY (disable Nagle's algorithm)
    if (config->tcp_nodelay) {
        int nodelay = 1;
        setsockopt(server_fd, IPPROTO_TCP, TCP_NODELAY,
                   &nodelay, sizeof(nodelay));
    }

    // Non-blocking mode
    if (config->non_blocking) {
        int flags = fcntl(server_fd, F_GETFL, 0);
        fcntl(server_fd, F_SETFL, flags | O_NONBLOCK);
    }

    struct sockaddr_in addr = {
        .sin_family = AF_INET,
        .sin_addr.s_addr = INADDR_ANY,
        .sin_port = htons(config->port)
    };

    if (bind(server_fd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
        close(server_fd);
        return -1;
    }

    if (listen(server_fd, config->backlog) < 0) {
        close(server_fd);
        return -1;
    }

    return server_fd;
}

UDP Socket Template

int create_udp_socket(int port, bool non_blocking) {
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0) return -1;

    // Allow multiple sockets to bind to same port
    int opt = 1;
    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    // Non-blocking mode
    if (non_blocking) {
        int flags = fcntl(sockfd, F_GETFL, 0);
        fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);
    }

    struct sockaddr_in addr = {
        .sin_family = AF_INET,
        .sin_addr.s_addr = INADDR_ANY,
        .sin_port = htons(port)
    };

    if (bind(sockfd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
        close(sockfd);
        return -1;
    }

    return sockfd;
}

6. Platform Differences

Handle cross-platform socket programming:

FeaturePOSIX (Linux/macOS)Windows (Winsock)
Header<sys/socket.h><winsock2.h>
InitNot requiredWSAStartup()
Closeclose(fd)closesocket(sock)
ErrorerrnoWSAGetLastError()
Non-blockfcntl(O_NONBLOCK)ioctlsocket(FIONBIO)
Pollpoll() / epoll()WSAPoll() / IOCP

MCP Server Integration

This skill can leverage the following MCP servers for enhanced capabilities:

ServerDescriptionIntegration
Claude-FlowAgent orchestration with real-time communicationReal-time socket testing
Docker MCP ToolkitContainer isolation for socket testingSafe network experimentation

Best Practices

  1. Always check return values - Socket operations can fail at any point
  2. Use SO_REUSEADDR - Avoid "Address already in use" errors during development
  3. Set appropriate timeouts - Prevent indefinite blocking
  4. Handle partial reads/writes - Network I/O may not complete in one call
  5. Close sockets properly - Use shutdown() before close() for graceful termination
  6. Buffer sizing - Match buffer sizes to application throughput needs

Process Integration

This skill integrates with the following processes:

  • tcp-socket-server.js - TCP server implementation
  • udp-socket-server.js - UDP server implementation
  • event-driven-socket-handler.js - Event-based socket handling
  • connection-pool.js - Connection pool management

Output Format

When executing operations, provide structured output:

{
  "operation": "analyze",
  "target": "socket",
  "address": "0.0.0.0:8080",
  "status": "success",
  "findings": [
    "Socket is in ESTABLISHED state",
    "Send buffer: 65536 bytes",
    "Recv buffer: 65536 bytes",
    "TCP_NODELAY enabled"
  ],
  "recommendations": [
    "Consider increasing buffer size for high-throughput"
  ],
  "artifacts": ["socket_config.c"]
}

Error Handling

  • Capture full error codes and messages
  • Provide platform-specific troubleshooting
  • Suggest alternative approaches when operations fail
  • Link to relevant socket programming documentation

Constraints

  • Do not create raw sockets without explicit approval
  • Verify port availability before binding
  • Respect firewall rules and network policies
  • Log all socket operations for debugging