Attachment 1480774 Details for Bug 1625237 – Reproducer

Reproducer

shutdown.c (text/plain), 10.27 KB, created by Petr Pisar on 2018-09-04 13:05:24 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Petr Pisar

Created: 2018-09-04 13:05:24 UTC

Size: 10.27 KB

patch

obsolete

>#define _POSIX_C_SOURCE 1
>#include <unistd.h>
>#include <stdlib.h>
>#include <stdio.h>
>#include <sys/wait.h>
>#include <sys/types.h>
>#include <sys/socket.h>
>#include <netinet/in.h>
>#include <signal.h>
>#include <errno.h>
>#include <openssl/ssl.h>
>#include <openssl/err.h>
>#include <signal.h>
>#include <string.h>
>
>void handler(int signal) {
>    fprintf(stderr, "Server received %d signal\n", signal);
>}
>
>int main(int argc, char **argv) {
>    pid_t server_pid;
>    int wstatus;
>    int server_socket, client_socket;
>    int true = 1;
>    struct sockaddr_in6 addr = {
>        .sin6_family = AF_INET6,
>        .sin6_port = 2000,
>        .sin6_flowinfo = 0,
>        .sin6_addr = IN6ADDR_LOOPBACK_INIT
>    };
>    const char message[] = "text\n";
>    char buffer[1024];
>    int processed;
>    SSL_CTX *ssl_ctx;
>    SSL *ssl;
>    int retval;
>
>    server_socket= socket(AF_INET6, SOCK_STREAM, 0);
>    if (server_socket < 0) {
>        perror("socket failed");
>        exit(EXIT_FAILURE);
>    }
>    if (setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, &true, sizeof(true))) {
>        perror("setcockopt failed\n");
>        exit(EXIT_FAILURE);
>    }
>    if (bind(server_socket, (const struct sockaddr *)&addr, sizeof(addr))) {
>        perror("bind failed");
>        exit(EXIT_FAILURE);
>    }
>    if (listen(server_socket, 1)) {
>        perror("liste failed");
>        exit(EXIT_FAILURE);
>    }
>
>    server_pid = fork();
>    if (server_pid < 0) {
>        perror("fork failed");
>        exit(EXIT_FAILURE);
>    } else if (server_pid == 0) {
>        /* Server */
>        int fd;
>        struct sigaction action;
>
>        printf("Server\n");
>
>        action.sa_handler = handler;
>        action.sa_flags = 0;
>        sigemptyset(&action.sa_mask);
>        sigaction(SIGPIPE, &action, NULL);
>
>        fd = accept(server_socket, NULL, 0);
>        if (fd < 0) {
>            perror("accept failed");
>            exit(EXIT_FAILURE);
>        }
>        printf("TCP accepted.\n");
>
>        ssl_ctx = SSL_CTX_new(TLS_server_method());
>        if (!ssl_ctx) {
>            fprintf(stderr, "SSL_CTX_new failed\n");
>            exit(EXIT_FAILURE);
>        }
>        if (1 != SSL_CTX_use_PrivateKey_file(ssl_ctx, "key.pem", SSL_FILETYPE_PEM)) {
>            fprintf(stderr, "SSL_CTX_use_PrivatKey_file failed: ");
>            ERR_print_errors_fp(stderr);
>            exit(EXIT_FAILURE);
>        }
>        if (1 != SSL_CTX_use_certificate_file(ssl_ctx, "cert.pem", SSL_FILETYPE_PEM)) {
>            fprintf(stderr, "SSL_CTX_use_certificate_file failed: ");
>            ERR_print_errors_fp(stderr);
>            exit(EXIT_FAILURE);
>        }
>        ssl = SSL_new(ssl_ctx);
>        if (!ssl) {
>            fprintf(stderr, "SSL_new failed\n");
>            exit(EXIT_FAILURE);
>        }
>        if (!SSL_set_fd(ssl, fd)) {
>            fprintf(stderr, "SSL_set_fd failed\n");
>            exit(EXIT_FAILURE);
>        }
>#if OPENSSL_VERSION_NUMBER >= 0x1010100fL
>        /* TLS 1.3 server sends session tickets after a handhake as part of
>         * the SSL_accept(). If a client finishes all its job before server
>         * sends the tickets, SSL_accept() fails with EPIPE errno. Since we
>         * are not interested in a session resumption, we can not to send the
>         * tickets. */
>        /*if (1 != SSL_set_num_tickets(ssl, 0)) {
>            fprintf(stderr, "SSL_set_num_tickets failed\n");
>            exit(EXIT_FAILURE);
>        }
>        Or we can perform two-way shutdown. Client must call SSL_read() before
>        the final SSL_shutdown(). */
>#endif
>        retval = SSL_accept(ssl);
>        if (retval  <= 0) {
>            fprintf(stderr, "SSL_accept failed ssl_err=%d errno=%s: ",
>                    SSL_get_error(ssl, retval), strerror(errno));
>            ERR_print_errors_fp(stderr);
>            fprintf(stderr, "\n");
>            exit(EXIT_FAILURE);
>        }
>        printf("SSL accepted.\n");
>
>        while (1) {
>            processed = SSL_read(ssl, buffer, sizeof(buffer));
>            printf("Server SSL_read returned %d\n", processed);
>            if (processed > 0) {
>                printf("%.*s", (int)processed, buffer);
>            } else {
>                int ssl_error = SSL_get_error(ssl, processed);
>                if (ssl_error == SSL_ERROR_ZERO_RETURN) {
>                    printf("Server thinks a client closed a TLS session\n");
>                    break;
>                }
>                if (ssl_error != SSL_ERROR_WANT_READ &&
>                        ssl_error != SSL_ERROR_WANT_WRITE) {
>                    fprintf(stderr, "server read failed: ssl_error=%d:", ssl_error);
>                    ERR_print_errors_fp(stderr);
>                    fprintf(stderr, "\n");
>                    exit(EXIT_FAILURE);
>                }
>            }
>        };
>        printf("Server read finished.\n");
>
>#ifdef TWO_WAY_SHUTDOWN
>        retval = SSL_shutdown(ssl);
>        if (retval < 0) {
>            int ssl_err = SSL_get_error(ssl, retval);
>            fprintf(stderr, "Server SSL_shutdown failed: ssl_err=%d\n", ssl_err);
>            kill(server_pid, SIGTERM);
>            exit(EXIT_FAILURE);
>        }
>        printf("Server shut down a TLS session.\n");
>
>        if (retval != 1) {
>            retval = SSL_shutdown(ssl);
>            if (retval != 1) {
>                int ssl_err = SSL_get_error(ssl, retval);
>                fprintf(stderr,
>                        "Waiting for client shutdown using SSL_shutdown failed: "
>                        "ssl_err=%d\n", ssl_err);
>                kill(server_pid, SIGTERM);
>                exit(EXIT_FAILURE);
>            }
>        }
>        printf("Server thinks a client shut down the TLS session.\n");
>#endif
>
>        SSL_free(ssl);
>        SSL_CTX_free(ssl_ctx);
>        close(fd);
>        exit(EXIT_SUCCESS);
>    }
>
>    /* Client */
>    printf("Client\n");
>    client_socket = socket(AF_INET6, SOCK_STREAM, 0);
>    if (client_socket < 0) {
>        perror("socket failed");
>        kill(server_pid, SIGTERM);
>        exit(EXIT_FAILURE);
>    }
>    if (connect(client_socket, (const struct sockaddr *)&addr, sizeof(addr))) {
>        perror("connect failed");
>        kill(server_pid, SIGTERM);
>        exit(EXIT_FAILURE);
>    }
>    printf("TCP connected.\n");
>
>    ssl_ctx = SSL_CTX_new(TLS_client_method());
>    if (!ssl_ctx) {
>        fprintf(stderr, "SSL_CTX_new failed\n");
>        kill(server_pid, SIGTERM);
>        exit(EXIT_FAILURE);
>    }
>    if (1 != SSL_CTX_use_PrivateKey_file(ssl_ctx, "key.pem", SSL_FILETYPE_PEM)) {
>        fprintf(stderr, "SSL_CTX_use_PrivatKey_file failed: ");
>        ERR_print_errors_fp(stderr);
>        kill(server_pid, SIGTERM);
>        exit(EXIT_FAILURE);
>    }
>    if (1 != SSL_CTX_use_certificate_file(ssl_ctx, "cert.pem", SSL_FILETYPE_PEM)) {
>        fprintf(stderr, "SSL_CTX_use_certificate_file failed: ");
>        ERR_print_errors_fp(stderr);
>        kill(server_pid, SIGTERM);
>        exit(EXIT_FAILURE);
>    }
>    ssl = SSL_new(ssl_ctx);
>    if (!ssl) {
>        fprintf(stderr, "SSL_new failed\n");
>        kill(server_pid, SIGTERM);
>        exit(EXIT_FAILURE);
>    }
>    if (!SSL_set_fd(ssl, client_socket)) {
>        fprintf(stderr, "SSL_set_fd failed\n");
>        kill(server_pid, SIGTERM);
>        exit(EXIT_FAILURE);
>    }
>    if (SSL_connect(ssl) <= 0) {
>        fprintf(stderr, "SSL_connect failed\n");
>        kill(server_pid, SIGTERM);
>        exit(EXIT_FAILURE);
>    }
>    printf("SSL connected.\n");
>
>
>    for (const char *start = message; start - message < sizeof(message);
>            start += processed) {
>        processed = SSL_write(ssl, start, sizeof(message) - (start - message));
>        printf("Client SSL_write returned %d\n", processed);
>        if (processed <= 0) {
>            int ssl_err = SSL_get_error(ssl, processed);
>            if (ssl_err != SSL_ERROR_WANT_READ && ssl_err != SSL_ERROR_WANT_WRITE) {
>                fprintf(stderr, "client write failed: ssl_error=%d: ", ssl_err);
>                ERR_print_errors_fp(stderr);
>                fprintf(stderr, "\n");
>                kill(server_pid, SIGTERM);
>                exit(EXIT_FAILURE);
>            }
>            processed = 0;
>        }
>    };
>    printf("Client write finished.\n");
>
>    retval = SSL_shutdown(ssl);
>    if (retval < 0) {
>        int ssl_err = SSL_get_error(ssl, retval);
>        fprintf(stderr, "Client SSL_shutdown failed: ssl_err=%d\n", ssl_err);
>        kill(server_pid, SIGTERM);
>        exit(EXIT_FAILURE);
>    }
>    printf("Client shut down TLS session.\n");
>
>#ifdef TWO_WAY_SHUTDOWN
>    if (retval != 1) {
>        /* Consume all server's data to access the server's shutdown */
>        while (1) {
>            processed = SSL_read(ssl, buffer, sizeof(buffer));
>            printf("Client SSL_read returned %d\n", processed);
>            if (processed <= 0) {
>                int ssl_error = SSL_get_error(ssl, processed);
>                if (ssl_error == SSL_ERROR_ZERO_RETURN) {
>                    printf("Client thinks a server finished sending data\n");
>                    break;
>                }
>                if (ssl_error != SSL_ERROR_WANT_READ &&
>                        ssl_error != SSL_ERROR_WANT_WRITE) {
>                    fprintf(stderr, "Client read failed: ssl_error=%d errno=%s: ",
>                            ssl_error, strerror(errno));
>                    ERR_print_errors_fp(stderr);
>                    fprintf(stderr, "\n");
>                    exit(EXIT_FAILURE);
>                }
>            }
>        };
>
>        retval = SSL_shutdown(ssl);
>        if (retval != 1) {
>            int ssl_err = SSL_get_error(ssl, retval);
>            fprintf(stderr,
>                    "Waiting for server shutdown using SSL_shutdown failed: "
>                    "ssl_err=%d\n", ssl_err);
>            kill(server_pid, SIGTERM);
>            exit(EXIT_FAILURE);
>        }
>    }
>    printf("Client thinks a server shut down the TLS session.\n");
>#endif
>
>    if (shutdown(client_socket, SHUT_RDWR)) {
>        perror("client shutdown failed");
>        kill(server_pid, SIGTERM);
>        exit(EXIT_FAILURE);
>    }
>    printf("Client shut down TCP.\n");
>
>    SSL_free(ssl);
>    SSL_CTX_free(ssl_ctx);
>    if (server_pid == waitpid(server_pid, &wstatus, 0)) {
>        if (WIFEXITED(wstatus)){
>            printf("Server process terminated normally with %d exit code\n",
>                    WEXITSTATUS(wstatus));
>        } else if (WIFSIGNALED(wstatus)) {
>            printf("Server process terminated with %d signal\n",
>                    WTERMSIG(wstatus));
>        }
>    }
>    exit(EXIT_SUCCESS);
>}

Actions: View

Attachments on bug 1625237: 1480774