seams.c

Go to the documentation of this file.

#include <assert.h>
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

#include "test.h"

int g_smtp_test_err_bio_new_socket_ctr = -1;

int g_smtp_test_err_bio_should_retry_ctr = -1;

int g_smtp_test_err_bio_should_retry_rc = -1;

int g_smtp_test_err_calloc_ctr = -1;

int g_smtp_test_err_close_ctr = -1;

int g_smtp_test_err_connect_ctr = -1;

int g_smtp_test_err_err_peek_error_ctr = -1;

int g_smtp_test_err_fclose_ctr = -1;

int g_smtp_test_err_ferror_ctr = -1;

int g_smtp_test_err_gmtime_r_ctr = -1;

int g_smtp_test_err_hmac_ctr = -1;

int g_smtp_test_err_localtime_r_ctr = -1;

int g_smtp_test_err_malloc_ctr = -1;

int g_smtp_test_err_mktime_ctr = -1;

int g_smtp_test_err_realloc_ctr = -1;

int g_smtp_test_err_recv_ctr = -1;

int g_smtp_test_err_recv_rc = -1;

char g_smtp_test_err_recv_bytes[90] = {0};

int g_smtp_test_err_select_ctr = -1;

int g_smtp_test_err_send_ctr = -1;

int g_smtp_test_send_one_byte = 0;

int g_smtp_test_err_si_add_size_t_ctr = -1;

int g_smtp_test_err_si_sub_size_t_ctr = -1;

int g_smtp_test_err_si_mul_size_t_ctr = -1;

int g_smtp_test_err_socket_ctr = -1;

int g_smtp_test_err_ssl_connect_ctr = -1;

int g_smtp_test_err_ssl_ctx_new_ctr = -1;

int g_smtp_test_err_ssl_do_handshake_ctr = -1;

int g_smtp_test_err_ssl_get_peer_certificate_ctr = -1;

int g_smtp_test_err_x509_check_host_ctr = -1;

int g_smtp_test_err_ssl_new_ctr = -1;

int g_smtp_test_err_ssl_read_ctr = -1;

int g_smtp_test_err_ssl_write_ctr = -1;

int g_smtp_test_err_sprintf_ctr = -1;

int g_smtp_test_err_sprintf_rc = 0;

int g_smtp_test_strlen_custom_ret = 0;

size_t g_smtp_test_strlen_ret_value = 0;

int g_smtp_test_time_custom_ret = 0;

time_t g_smtp_test_time_ret_value = 0;

int
smtp_test_seam_dec_err_ctr(int *const test_err_ctr){
  if(*test_err_ctr >= 0){
    *test_err_ctr -= 1;
    if(*test_err_ctr < 0){
      return 1;
    }
  }
  return 0;
}

BIO *
smtp_test_seam_bio_new_socket(int sock,
                              int close_flag){
  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_bio_new_socket_ctr)){
    return NULL;
  }
  return BIO_new_socket(sock, close_flag);
}

int
smtp_test_seam_bio_should_retry(BIO *bio){
  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_bio_should_retry_ctr)){
    return 0;
  }
  if(g_smtp_test_err_bio_should_retry_rc != -1){
    return g_smtp_test_err_bio_should_retry_rc;
  }
  return BIO_should_retry(bio);
}

void *
smtp_test_seam_calloc(size_t nelem,
                      size_t elsize){
  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_calloc_ctr)){
    errno = ENOMEM;
    return NULL;
  }
  return calloc(nelem, elsize);
}

int
smtp_test_seam_close(int fildes){
  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_close_ctr)){
    errno = EBADF;
    return -1;
  }
  return close(fildes);
}

int
smtp_test_seam_connect(int socket,
                       const struct sockaddr *address,
                       socklen_t address_len){
  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_connect_ctr)){
    errno = ECONNREFUSED;
    return -1;
  }
  return connect(socket, address, address_len);
}

unsigned long
smtp_test_seam_err_peek_error(void){
  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_err_peek_error_ctr)){
    return 1;
  }
  return ERR_peek_error();
}

int smtp_test_seam_fclose(FILE *stream){
  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_fclose_ctr)){
    errno = EBADF;
    return EOF;
  }
  return fclose(stream);
}

int
smtp_test_seam_ferror(FILE *stream){
  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_ferror_ctr)){
    return 1;
  }
  return ferror(stream);
}

struct tm *
smtp_test_seam_gmtime_r(const time_t *timep,
                        struct tm *result){
  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_gmtime_r_ctr)){
    return NULL;
  }
  return gmtime_r(timep, result);
}

unsigned char *
smtp_test_seam_hmac(const EVP_MD *evp_md,
                    const void *key,
                    int key_len,
                    const unsigned char *d,
                    size_t n,
                    unsigned char *md,
                    unsigned int *md_len){
  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_hmac_ctr)){
    return NULL;
  }
  return HMAC(evp_md, key, key_len, d, n, md, md_len);
}

struct tm *
smtp_test_seam_localtime_r(const time_t *timep,
                           struct tm *result){
  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_localtime_r_ctr)){
    return NULL;
  }
  return localtime_r(timep, result);
}

void *
smtp_test_seam_malloc(size_t size){
  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_malloc_ctr)){
    errno = ENOMEM;
    return NULL;
  }
  return malloc(size);
}

time_t
smtp_test_seam_mktime(struct tm *timeptr){
  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_mktime_ctr)){
    return -1;
  }
  return mktime(timeptr);
}

void *
smtp_test_seam_realloc(void *ptr,
                       size_t size){
  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_realloc_ctr)){
    errno = ENOMEM;
    return NULL;
  }
  return realloc(ptr, size);
}

long
smtp_test_seam_recv(int socket,
                    void *buffer,
                    size_t length,
                    int flags){
  size_t bytes_inject_len;

  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_recv_ctr)){
    if(g_smtp_test_err_recv_rc != -1){
      return g_smtp_test_err_recv_rc;
    }
    if(*g_smtp_test_err_recv_bytes){
      bytes_inject_len = strlen(g_smtp_test_err_recv_bytes);
      assert(bytes_inject_len < length && bytes_inject_len < LONG_MAX);
      memcpy(buffer, g_smtp_test_err_recv_bytes, bytes_inject_len);
      return (long)bytes_inject_len;
    }
    errno = EBADF;
    return -1;
  }
  return recv(socket, buffer, length, flags);
}

int
smtp_test_seam_select(int nfds,
                      fd_set *readfds,
                      fd_set *writefds,
                      fd_set *errorfds,
                      struct timeval *timeout){
  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_select_ctr)){
    errno = EINTR;
    return -1;
  }
  return select(nfds, readfds, writefds, errorfds, timeout);
}

ssize_t
smtp_test_seam_send(int socket,
                    const void *buffer,
                    size_t length,
                    int flags){
  long sent_bytes;
  size_t bytes_to_send;

  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_send_ctr)){
    errno = EBADF;
    sent_bytes = -1;
  }
  else{
    bytes_to_send = length;
    if(g_smtp_test_send_one_byte){
      bytes_to_send = 1;
    }
    sent_bytes = send(socket, buffer, bytes_to_send, flags);
  }
  return sent_bytes;
}

int
smtp_test_seam_socket(int domain,
                      int type,
                      int protocol){
  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_socket_ctr)){
    errno = EINVAL;
    return -1;
  }
  return socket(domain, type, protocol);
}

int
smtp_test_seam_ssl_connect(SSL *ssl){
  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_ssl_connect_ctr)){
    return 0;
  }
  return SSL_connect(ssl);
}

SSL_CTX *
smtp_test_seam_ssl_ctx_new(const SSL_METHOD *method){
  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_ssl_ctx_new_ctr)){
    return NULL;
  }
  return SSL_CTX_new(method);
}

int
smtp_test_seam_ssl_do_handshake(SSL *ssl){
  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_ssl_do_handshake_ctr)){
    return 0;
  }
  return SSL_do_handshake(ssl);
}

X509 *
smtp_test_seam_ssl_get_peer_certificate(const SSL *ssl){
  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_ssl_get_peer_certificate_ctr)){
    return NULL;
  }
  return SSL_get_peer_certificate(ssl);
}

int
smtp_test_seam_x509_check_host(X509 *cert,
                               const char *name,
                               size_t namelen,
                               unsigned int flags,
                               char **peername){
  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_x509_check_host_ctr)){
    return -1;
  }
  return X509_check_host(cert, name, namelen, flags, peername);
}

SSL *
smtp_test_seam_ssl_new(SSL_CTX *ctx){
  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_ssl_new_ctr)){
    return NULL;
  }
  return SSL_new(ctx);
}

int
smtp_test_seam_ssl_read(SSL *ssl,
                        void *buf,
                        int num){
  size_t bytes_inject_len;

  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_ssl_read_ctr)){
    if(*g_smtp_test_err_recv_bytes){
      bytes_inject_len = strlen(g_smtp_test_err_recv_bytes);
      assert(bytes_inject_len < (size_t)num && bytes_inject_len < INT_MAX);
      memcpy(buf, g_smtp_test_err_recv_bytes, bytes_inject_len);
      return (int)bytes_inject_len;
    }
    return -1;
  }
  return SSL_read(ssl, buf, num);
}

int
smtp_test_seam_ssl_write(SSL *ssl,
                         const void *buf,
                         int num){
  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_ssl_write_ctr)){
    return -1;
  }
  return SSL_write(ssl, buf, num);
}

int
smtp_test_seam_sprintf(char *s,
                       const char *format, ...){
  va_list ap;
  int rc;

  if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_sprintf_ctr)){
    errno = ENOMEM;
    return g_smtp_test_err_sprintf_rc;
  }
  va_start(ap, format);
  rc = vsprintf(s, format, ap);
  va_end(ap);
  return rc;
}

size_t
smtp_test_seam_strlen(const char *s){
  size_t result;

  if(g_smtp_test_strlen_custom_ret){
    result = g_smtp_test_strlen_ret_value;
  }
  else{
    result = strlen(s);
  }
  return result;
}

time_t
smtp_test_seam_time(time_t *tloc){
  if(g_smtp_test_time_custom_ret){
    return g_smtp_test_time_ret_value;
  }
  return time(tloc);
}