Minimum viable email service

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <unistd.h>
#include <arpa/inet.h>

#define PORT 2525
#define NAME "foo.com"
#define BUFFER_SIZE 1024
#define ADDRESS_SIZE 128
#define MAX_ADDRESSES 128
#define DATA_SIZE 2048

#define EHLO_CMD "EHLO"
#define HELO_CMD "HELO"
#define MAIL_CMD "MAIL FROM:"
#define RCPT_CMD "RCPT TO:"
#define DATA_CMD "DATA"
#define RSET_CMD "RSET"
#define NOOP_CMD "NOOP"
#define QUIT_CMD "QUIT"
#define VRFY_CMD "VRFY"

struct Session {
    bool greeted;
    bool set_mail_from;
    bool in_data_mode;
    int recipient_count;
    char mail_from[ADDRESS_SIZE];
    char rcpt_to[MAX_ADDRESSES][ADDRESS_SIZE];
    char data[DATA_SIZE];
};

void reset_transaction(struct Session *state) {
    state->set_mail_from = false;
    state->in_data_mode = false;
    state->recipient_count = 0;
    memset(state->mail_from, 0, ADDRESS_SIZE);
    memset(state->rcpt_to, 0, sizeof(state->rcpt_to));
    memset(state->data, 0, DATA_SIZE);
}

void reset_session(struct Session *state) {
    state->greeted = false;
    reset_transaction(state);
}

void send_msg(const int client_fd, const char msg[]) {
    send(client_fd, msg, strlen(msg), 0);
    printf("S: %s", msg);
}

bool extract_address(const char *arg, char *out_addr, size_t out_size) {
    if (arg[0] != '<') { 
        return false;
    }
    const char *close = strchr(arg, '>');
    if (!close || close == arg + 1) { // missing or empty
        return false; 
    } 
    size_t len = (size_t)(close - arg - 1);
    if (len >= out_size) { 
        return false;
    }
    strncpy(out_addr, arg + 1, len);
    out_addr[len] = '\0';
    return true;
}

int main() {
    int server_fd, client_fd;
    struct sockaddr_in address;
    int addrlen = sizeof(address);
    char buffer[BUFFER_SIZE];

    // Create socket
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd < 0) { perror("socket failed"); exit(EXIT_FAILURE); }

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

    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("bind failed"); exit(EXIT_FAILURE);
    }
    if (listen(server_fd, 5) < 0) {
        perror("listen failed"); exit(EXIT_FAILURE);
    }

    // Responses
    char greeting[BUFFER_SIZE];
    snprintf(greeting, sizeof(greeting), "220 %s Simple Mail Transfer Service Ready\r\n", NAME);
    char bye[BUFFER_SIZE];
    snprintf(bye, sizeof(bye), "221 %s Service closing transmission channel\r\n", NAME);
    const char *okay = "250 OK\r\n";
    const char *cannot_verify = "252 Cannot VRFY user, but will accept message and attempt delivery\r\n";
    const char *start_mail_input = "354 Start mail input; end with <CRLF>.<CRLF>\r\n";
    const char *not_implemented = "500 Command not implemented\r\n";
    const char *syntax_error_param = "501 Syntax error in parameters or arguments\r\n";
    const char *bad_sequence = "503 Bad sequence of commands\r\n";
    const char *too_many_recipients = "452 Requested action not taken: insufficient system storage\r\n";

    printf("TCP: Listening on :%d\n", PORT);

    // Accept client
    while (1) {
        client_fd = accept(server_fd, (struct sockaddr *)&address, (socklen_t *)&addrlen);
        if (client_fd < 0) { perror("accept failed"); continue; }
        printf("TCP: Client connected: %s\n", inet_ntoa(address.sin_addr));

        // Initialize session state
        struct Session session_state;
        reset_session(&session_state);

        // Send greeting
        send_msg(client_fd, greeting);

        // Conversation with client
        while (1) {
            memset(buffer, 0, BUFFER_SIZE);
            int bytes_read = read(client_fd, buffer, BUFFER_SIZE - 1);

            if (bytes_read <= 0) {
                printf("TCP: Client disconnected.\n");
                break;
            }

            buffer[bytes_read] = '\0';

            // Strip trailing \r\n
            char *end = buffer + strcspn(buffer, "\r\n");
            *end = '\0';
            int stripped_len = (int)(end - buffer);

            printf("C: %s\n", buffer);

            // Data mode
            if (session_state.in_data_mode) {
                if (strcmp(buffer, ".") == 0) { // Terminate
                    session_state.in_data_mode = false;
                    send_msg(client_fd, okay);
                } else {
                    // Dot-stuffing
                    const char *line = (buffer[0] == '.' && buffer[1] != '\0') ? buffer + 1 : buffer;
                    strncat(session_state.data, line, DATA_SIZE - strlen(session_state.data) - 1);
                    strncat(session_state.data, "\r\n", DATA_SIZE - strlen(session_state.data) - 1);
                }
                continue;
            }

            // Command mode
            char arg[BUFFER_SIZE];
            char extracted_addr[ADDRESS_SIZE];
            if (strncmp(buffer, EHLO_CMD, strlen(EHLO_CMD)) == 0) { // EHLO
                session_state.greeted = true;
                if (stripped_len > (int)strlen(EHLO_CMD) + 1) { // Get client FQDN if was provided (that is, content after "EHLO ")
                    // Construct arg
                    strncpy(arg, buffer + strlen(EHLO_CMD) + 1, sizeof(arg) - 1);
                    arg[sizeof(arg) - 1] = '\0';

                    // Personalized greeting
                    char greets_you[BUFFER_SIZE];
                    snprintf(greets_you, sizeof(greets_you), "250 %s greets %s\r\n", NAME, arg); // ASSUMING NO EXTENSIONS
                    send_msg(client_fd, greets_you);
                } else { // No FQDN provided by client
                    send_msg(client_fd, okay);
                }
            } else if (strncmp(buffer, HELO_CMD, strlen(HELO_CMD)) == 0) { // HELO     
                session_state.greeted = true;
                send_msg(client_fd, okay);
            } else if (strncmp(buffer, MAIL_CMD, strlen(MAIL_CMD)) == 0) { // MAIL
                if (!session_state.greeted) {
                    send_msg(client_fd, bad_sequence);
                    continue;
                }

                strncpy(arg, buffer + strlen(MAIL_CMD), sizeof(arg) - 1);
                arg[sizeof(arg) - 1] = '\0';

                if (strcmp(arg, "<>") == 0) { // Allow empty reverse-path <> (used by bounce messages)
                    session_state.mail_from[0] = '\0';
                } else if (extract_address(arg, extracted_addr, ADDRESS_SIZE)) { // Extracted address
                    strncpy(session_state.mail_from, extracted_addr, ADDRESS_SIZE - 1);
                    session_state.mail_from[ADDRESS_SIZE - 1] = '\0';
                } else { // Invalid
                    send_msg(client_fd, syntax_error_param);
                    continue;
                }

                session_state.set_mail_from = true;
                send_msg(client_fd, okay);
            } else if (strncmp(buffer, RCPT_CMD, strlen(RCPT_CMD)) == 0) { // RCPT
                if (!session_state.greeted || !session_state.set_mail_from) {
                    send_msg(client_fd, bad_sequence);
                    continue;
                }
                if (session_state.recipient_count >= MAX_ADDRESSES) {
                    send_msg(client_fd, too_many_recipients);
                    continue;
                }

                strncpy(arg, buffer + strlen(RCPT_CMD), sizeof(arg) - 1);
                arg[sizeof(arg) - 1] = '\0';

                // Attempt extract address
                if (!extract_address(arg, extracted_addr, ADDRESS_SIZE)) {
                    send_msg(client_fd, syntax_error_param);
                    continue;
                }

                // Update session for new address
                strncpy(session_state.rcpt_to[session_state.recipient_count], extracted_addr, ADDRESS_SIZE - 1);
                session_state.rcpt_to[session_state.recipient_count][ADDRESS_SIZE - 1] = '\0';
                session_state.recipient_count++;

                send_msg(client_fd, okay);
            } else if (strncmp(buffer, DATA_CMD, strlen(DATA_CMD)) == 0) { // DATA
                if (!session_state.greeted || !session_state.set_mail_from || session_state.recipient_count == 0) {
                    send_msg(client_fd, bad_sequence);
                    continue;
                } else {
                    session_state.in_data_mode = true;
                    send_msg(client_fd, start_mail_input);
                }
            } else if (strncmp(buffer, RSET_CMD, strlen(RSET_CMD)) == 0) { // RSET
                reset_transaction(&session_state); // Reset transaction (not session)
                send_msg(client_fd, okay);
            } else if (strncmp(buffer, NOOP_CMD, strlen(NOOP_CMD)) == 0) { // NOOP
                send_msg(client_fd, okay);
            } else if (strncmp(buffer, QUIT_CMD, strlen(QUIT_CMD)) == 0) { // QUIT
                reset_session(&session_state);
                send_msg(client_fd, bye);
                break;
            } else if (strncmp(buffer, VRFY_CMD, strlen(VRFY_CMD)) == 0) { // VRFY
                send_msg(client_fd, cannot_verify);
            } else { // Catchall
                send_msg(client_fd, not_implemented);
            }
        }

        close(client_fd);
        printf("TCP: Connection closed\n\n");
    }

    close(server_fd);
    return 0;
}