#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <string.h>

/* Resolve hostname → IP(s), prefer IPv4 */
int resolve_host(const char *host, char out_ip[INET6_ADDRSTRLEN]) {
    struct addrinfo hints, *res, *rp;
    memset(&hints, 0, sizeof(hints));
    hints.ai_family   = AF_UNSPEC;    /* IPv4 or IPv6 */
    hints.ai_socktype = SOCK_STREAM;  /* TCP */

    int rc = getaddrinfo(host, NULL, &hints, &res);
    if (rc != 0) {
        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rc));
        return -1;
    }

    for (rp = res; rp != NULL; rp = rp->ai_next) {
        void *addr;
        if (rp->ai_family == AF_INET) {
            struct sockaddr_in *ipv4 = (struct sockaddr_in *)rp->ai_addr;
            addr = &ipv4->sin_addr;
        } else {
            struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)rp->ai_addr;
            addr = &ipv6->sin6_addr;
        }
        inet_ntop(rp->ai_family, addr, out_ip, INET6_ADDRSTRLEN);
        printf("Resolved %s → %s\n", host, out_ip);
        break;  /* take first result */
    }

    freeaddrinfo(res);
    return 0;
}

#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main(void) {
    /* 1. Create socket */
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);

    /* 2. Allow port reuse (survive TIME_WAIT on restart) */
    int opt = 1;
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));

    /* 3. Bind to port 8080, all interfaces */
    struct sockaddr_in addr = {
        .sin_family      = AF_INET,
        .sin_port        = htons(8080),
        .sin_addr.s_addr = INADDR_ANY
    };
    bind(server_fd, (struct sockaddr *)&addr, sizeof(addr));

    /* 4. Mark as passive; backlog=128 = max pending SYNs in accept queue */
    listen(server_fd, 128);
    printf("Listening on :8080\n");

    while (1) {
        /* 5. Accept — blocks until 3-way handshake completes */
        struct sockaddr_in client_addr;
        socklen_t client_len = sizeof(client_addr);
        int conn_fd = accept(server_fd,
                             (struct sockaddr *)&client_addr,
                             &client_len);

        /* 6. Disable Nagle for low-latency responses */
        setsockopt(conn_fd, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt));

        /* 7. Read request (simplified — real code loops until \r\n\r\n) */
        char buf[4096];
        ssize_t n = recv(conn_fd, buf, sizeof(buf) - 1, 0);
        buf[n] = '\0';

        /* 8. Send response */
        const char *resp = "HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\nHello";
        send(conn_fd, resp, strlen(resp), 0);

        /* 9. Graceful close — sends FIN, drains */
        close(conn_fd);
    }
}

#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>

int tcp_connect(const char *host, const char *port) {
    struct addrinfo hints = {
        .ai_family   = AF_UNSPEC,
        .ai_socktype = SOCK_STREAM
    };
    struct addrinfo *res;

    int rc = getaddrinfo(host, port, &hints, &res);
    if (rc) { fprintf(stderr, "DNS: %s\n", gai_strerror(rc)); return -1; }

    int fd = -1;
    for (struct addrinfo *rp = res; rp; rp = rp->ai_next) {
        fd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
        if (fd < 0) continue;
        if (connect(fd, rp->ai_addr, rp->ai_addrlen) == 0) break;
        close(fd); fd = -1;
    }
    freeaddrinfo(res);
    if (fd < 0) perror("connect");
    return fd;
}

int main(void) {
    int fd = tcp_connect("httpbin.org", "80");
    if (fd < 0) return 1;

    const char *req = "GET /get HTTP/1.1\r\nHost: httpbin.org\r\nConnection: close\r\n\r\n";
    write(fd, req, strlen(req));

    char buf[4096];
    ssize_t n;
    while ((n = read(fd, buf, sizeof(buf))) > 0)
        fwrite(buf, 1, n, stdout);

    close(fd);
}

#include <openssl/ssl.h>
#include <openssl/err.h>
#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

/* Compile: gcc tls_client.c -lssl -lcrypto -o tls_client */

static int tcp_connect_fd(const char *host, const char *port);  /* as above */

int main(int argc, char **argv) {
    const char *host = argc > 1 ? argv[1] : "example.com";

    /* 1. Init OpenSSL */
    SSL_library_init();
    SSL_load_error_strings();
    OpenSSL_add_all_algorithms();

    /* 2. Create TLS context — prefer TLS 1.3 */
    SSL_CTX *ctx = SSL_CTX_new(TLS_client_method());
    SSL_CTX_set_min_proto_version(ctx, TLS1_2_VERSION);

    /* 3. Load system CA bundle for cert verification */
    SSL_CTX_set_default_verify_paths(ctx);
    SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL);

    /* 4. TCP connect */
    int fd = tcp_connect_fd(host, "443");
    if (fd < 0) { SSL_CTX_free(ctx); return 1; }

    /* 5. Wrap socket in SSL */
    SSL *ssl = SSL_new(ctx);
    SSL_set_fd(ssl, fd);

    /* 6. Set SNI so server returns correct cert */
    SSL_set_tlsext_host_name(ssl, host);

    /* 7. Set hostname for cert validation */
    SSL_set_hostflags(ssl, X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS);
    SSL_set1_host(ssl, host);

    /* 8. TLS handshake */
    int err = SSL_connect(ssl);
    if (err != 1) {
        ERR_print_errors_fp(stderr);
        goto cleanup;
    }

    /* 9. Print negotiated cipher and protocol */
    printf("TLS version : %s\n", SSL_get_version(ssl));
    printf("Cipher suite: %s\n", SSL_get_cipher(ssl));

    /* 10. Print server cert info */
    X509 *cert = SSL_get_peer_certificate(ssl);
    if (cert) {
        char buf[256];
        X509_NAME_oneline(X509_get_subject_name(cert), buf, sizeof(buf));
        printf("Cert subject: %s\n", buf);
        X509_NAME_oneline(X509_get_issuer_name(cert), buf, sizeof(buf));
        printf("Cert issuer : %s\n", buf);
        X509_free(cert);
    }

    /* 11. Send HTTP request */
    char req[512];
    snprintf(req, sizeof(req),
             "GET / HTTP/1.1\r\nHost: %s\r\nConnection: close\r\n\r\n", host);
    SSL_write(ssl, req, strlen(req));

    /* 12. Read response */
    char rbuf[4096];
    int n;
    while ((n = SSL_read(ssl, rbuf, sizeof(rbuf))) > 0)
        fwrite(rbuf, 1, n, stdout);

cleanup:
    SSL_shutdown(ssl);
    SSL_free(ssl);
    close(fd);
    SSL_CTX_free(ctx);
    return 0;
}

#include <sys/socket.h>
#include <netinet/in.h>
#include <pthread.h>
#include <unistd.h>
#include <stdio.h>

static void *handle_client(void *arg) {
    int fd = (int)(intptr_t)arg;
    pthread_detach(pthread_self());  /* auto-reclaim resources */

    char buf[4096];
    ssize_t n;
    while ((n = recv(fd, buf, sizeof(buf), 0)) > 0) {
        /* Echo back */
        send(fd, buf, n, 0);
    }
    /* n == 0: peer closed; n < 0: error */
    close(fd);
    return NULL;
}

int main(void) {
    int srv = socket(AF_INET, SOCK_STREAM, 0);
    setsockopt(srv, SOL_SOCKET, SO_REUSEADDR, &(int){1}, sizeof(int));

    struct sockaddr_in a = {AF_INET, htons(8080), .sin_addr.s_addr=INADDR_ANY};
    bind(srv, (struct sockaddr *)&a, sizeof(a));
    listen(srv, 128);
    printf("Echo server :8080\n");

    while (1) {
        int conn = accept(srv, NULL, NULL);
        if (conn < 0) { perror("accept"); continue; }
        pthread_t t;
        pthread_create(&t, NULL, handle_client, (void *)(intptr_t)conn);
        /* thread detached inside handle_client */
    }
}