Receiving email

// Accept clients
while (1) {
  client_fd = accept(server_fd, (struct sockaddr *)&address, (socklen_t *)&addrlen);
  if (client_fd < 0) { perror("accept failed"); continue; }

  int *fd_ptr = malloc(sizeof(int));
  *fd_ptr = client_fd;

  pthread_t thread;
  pthread_create(&thread, NULL, handle_client, fd_ptr);
  pthread_detach(thread);
}

struct Session {
  bool greeted;
  bool set_mail_from;
  bool in_data_mode;
  int recipient_count;
  int recv_len;                               // new
  char mail_from[ADDRESS_SIZE];
  char rcpt_to[MAX_ADDRESSES][ADDRESS_SIZE];
  char data[DATA_SIZE];
  char recv_buf[RECV_BUFFER_SIZE];            // new (along with #define RECV_BUFFER_SIZE)
};

int read_line(int client_fd, struct Session *state, char *out, int out_size) {
  while (1) {
    for (int i = 0; i < state->recv_len - 1; i++) {
      if (state->recv_buf[i] == '\r' && state->recv_buf[i+1] == '\n') {
        int line_len = i;
        if (line_len >= out_size) line_len = out_size - 1;
        memcpy(out, state->recv_buf, line_len);
        out[line_len] = '\0';

        int consumed = i + 2; // +2 for \r\n
        state->recv_len -= consumed;
        memmove(state->recv_buf, state->recv_buf + consumed, state->recv_len);

        return line_len;
      }
    }

    int space = RECV_BUFFER_SIZE - state->recv_len;
    if (space <= 0) { // Buffer full
      return -1;
    }

    int n = read(client_fd, state->recv_buf + state->recv_len, space);
    if (n <= 0) return n; // Return with disconnect or error
    state->recv_len += n;
  }
}

int stripped_len = read_line(client_fd, &session_state, buffer, BUFFER_SIZE);

char line[BUFFER_SIZE];

// greeting
snprintf(line, sizeof(line), "250-%s greets %s\r\n", NAME, arg);
send_msg(client_fd, line);

// Extensions (dash)
snprintf(line, sizeof(line), "250-SIZE %d\r\n", DATA_SIZE);
send_msg(client_fd, line);

// Final extension (no dash)
send_msg(client_fd, "250 VRFY\r\n");

This command clears the reverse-path buffer, the forward-path buffer,
   and the mail data buffer, and it inserts the reverse-path information
   from its argument clause into the reverse-path buffer.

Any system that includes an SMTP server supporting mail relaying or
delivery MUST support the reserved mailbox "postmaster" as a case-
insensitive local name.  This postmaster address is not strictly
necessary if the server always returns 554 on connection opening (as
described in Section 3.1).  The requirement to accept mail for
postmaster implies that RCPT commands that specify a mailbox for
postmaster at any of the domains for which the SMTP server provides
mail service, as well as the special case of "RCPT TO:<Postmaster>"
(with no domain specification), MUST be supported.

SMTP systems are expected to make every reasonable effort to accept
mail directed to Postmaster from any other system on the Internet.
In extreme cases -- such as to contain a denial of service attack or
other breach of security -- an SMTP server may block mail directed to
Postmaster.  However, such arrangements SHOULD be narrowly tailored
so as to avoid blocking messages that are not part of such attacks.

bool is_postmaster(const char *addr) {
  if (strcasecmp(addr, "Postmaster") == 0) return true;    
  const char *at = strchr(addr, '@');
  if (at && strncasecmp(addr, "Postmaster", at - addr) == 0  && strlen("Postmaster") == (size_t)(at - addr)) return true;
  return false;
}

The maximum total length of a command line including the command word
and the <CRLF> is 512 octets.  SMTP extensions may be used to
increase this limit.