Test the smtp-client library. More...

#include <sys/select.h>
#include <sys/socket.h>
#include <sys/types.h>
#include "../src/smtp.h"
#include <openssl/bio.h>
#include <openssl/err.h>
#include <openssl/ssl.h>
#include <openssl/x509.h>
#include <openssl/x509v3.h>

Include dependency graph for test.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
int	smtp_si_add_size_t (const size_t a, const size_t b, size_t *const result)

int	smtp_si_sub_size_t (const size_t a, const size_t b, size_t *const result)

int	smtp_si_mul_size_t (const size_t a, const size_t b, size_t *const result)

size_t	smtp_base64_decode (const char const buf, unsigned char *decode)

char *	smtp_base64_encode (const char *const buf, size_t buflen)

char *	smtp_bin2hex (const unsigned char *const s, size_t slen)

enum smtp_status_code	smtp_write (struct smtp const smtp, const char const buf, size_t len)

int	smtp_str_getdelimfd (struct str_getdelimfd *const gdfd)

int	smtp_str_getdelimfd_set_line_and_buf (struct str_getdelimfd *const gdfd, size_t copy_len)

void	smtp_str_getdelimfd_free (struct str_getdelimfd *const gdfd)

char *	smtp_stpcpy (char s1, const char s2)

void *	smtp_reallocarray (void *ptr, size_t nmemb, size_t size)

char *	smtp_strdup (const char *s)

char *	smtp_str_replace (const char const search, const char const replace, const char *const s)

size_t	smtp_utf8_charlen (char c)

int	smtp_str_has_nonascii_utf8 (const char *const s)

size_t	smtp_strnlen_utf8 (const char *s, size_t maxlen)

size_t	smtp_fold_whitespace_get_offset (const char *const s, unsigned int maxlen)

char *	smtp_fold_whitespace (const char *const s, unsigned int maxlen)

char *	smtp_chunk_split (const char const s, size_t chunklen, const char const end)

char *	smtp_ffile_get_contents (FILE stream, size_t bytes_read)

char *	smtp_file_get_contents (const char const filename, size_t bytes_read)

int	smtp_parse_cmd_line (char const line, struct smtp_command const cmd)

int	smtp_date_rfc_2822 (char *const date)

int	smtp_address_validate_email (const char *const email)

int	smtp_address_validate_name (const char *const name)

int	smtp_attachment_validate_name (const char *const name)

int	smtp_header_key_validate (const char *const key)

int	smtp_header_value_validate (const char *const value)

int	smtp_test_seam_dec_err_ctr (int *const test_err_ctr)

BIO *	smtp_test_seam_bio_new_socket (int sock, int close_flag)

int	smtp_test_seam_bio_should_retry (BIO *bio)

void *	smtp_test_seam_calloc (size_t nelem, size_t elsize)

int	smtp_test_seam_close (int fildes)

int	smtp_test_seam_connect (int socket, const struct sockaddr *address, socklen_t address_len)

unsigned long	smtp_test_seam_err_peek_error (void)

int	smtp_test_seam_fclose (FILE *stream)

int	smtp_test_seam_ferror (FILE *stream)

struct tm *	smtp_test_seam_gmtime_r (const time_t timep, struct tm 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)

struct tm *	smtp_test_seam_localtime_r (const time_t timep, struct tm result)

void *	smtp_test_seam_malloc (size_t size)

time_t	smtp_test_seam_mktime (struct tm *timeptr)

void *	smtp_test_seam_realloc (void *ptr, size_t size)

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

int	smtp_test_seam_select (int nfds, fd_set readfds, fd_set writefds, fd_set errorfds, struct timeval timeout)

ssize_t	smtp_test_seam_send (int socket, const void *buffer, size_t length, int flags)

int	smtp_test_seam_socket (int domain, int type, int protocol)

int	smtp_test_seam_ssl_connect (SSL *ssl)

SSL_CTX *	smtp_test_seam_ssl_ctx_new (const SSL_METHOD *method)

int	smtp_test_seam_ssl_do_handshake (SSL *ssl)

X509 *	smtp_test_seam_ssl_get_peer_certificate (const SSL *ssl)

int	smtp_test_seam_x509_check_host (X509 cert, const char name, size_t namelen, unsigned int flags, char **peername)

SSL *	smtp_test_seam_ssl_new (SSL_CTX *ctx)

int	smtp_test_seam_ssl_read (SSL ssl, void buf, int num)

int	smtp_test_seam_ssl_write (SSL ssl, const void buf, int num)

int	smtp_test_seam_sprintf (char s, const char format,...)

size_t	smtp_test_seam_strlen (const char *s)

time_t	smtp_test_seam_time (time_t *tloc)

Variables
int	g_smtp_test_err_bio_new_socket_ctr

int	g_smtp_test_err_bio_should_retry_ctr

int	g_smtp_test_err_bio_should_retry_rc

int	g_smtp_test_err_calloc_ctr

int	g_smtp_test_err_close_ctr

int	g_smtp_test_err_connect_ctr

int	g_smtp_test_err_err_peek_error_ctr

int	g_smtp_test_err_fclose_ctr

int	g_smtp_test_err_ferror_ctr

int	g_smtp_test_err_gmtime_r_ctr

int	g_smtp_test_err_hmac_ctr

int	g_smtp_test_err_localtime_r_ctr

int	g_smtp_test_err_malloc_ctr

int	g_smtp_test_err_mktime_ctr

int	g_smtp_test_err_realloc_ctr

int	g_smtp_test_err_recv_ctr

int	g_smtp_test_err_recv_rc

char	g_smtp_test_err_recv_bytes [90]

int	g_smtp_test_err_select_ctr

int	g_smtp_test_err_send_ctr

int	g_smtp_test_send_one_byte

int	g_smtp_test_err_si_add_size_t_ctr

int	g_smtp_test_err_si_sub_size_t_ctr

int	g_smtp_test_err_si_mul_size_t_ctr

int	g_smtp_test_err_socket_ctr

int	g_smtp_test_err_ssl_connect_ctr

int	g_smtp_test_err_ssl_ctx_new_ctr

int	g_smtp_test_err_ssl_do_handshake_ctr

int	g_smtp_test_err_ssl_get_peer_certificate_ctr

int	g_smtp_test_err_x509_check_host_ctr

int	g_smtp_test_err_ssl_new_ctr

int	g_smtp_test_err_ssl_read_ctr

int	g_smtp_test_err_ssl_write_ctr

int	g_smtp_test_err_sprintf_ctr

int	g_smtp_test_err_sprintf_rc

int	g_smtp_test_strlen_custom_ret

size_t	g_smtp_test_strlen_ret_value

int	g_smtp_test_time_custom_ret

time_t	g_smtp_test_time_ret_value

Detailed Description

Test the smtp-client library.

Author: James Humphrey (mail@.nosp@m.somn.nosp@m.isoft.nosp@m..com)

Version: 1.00

This smtp-client testing framework has 100% branch coverage on POSIX systems. It requires a Postfix SMTP server that supports all of the connection security and authentication methods. These functional tests also require the user to manually check and ensure that the destination addresses received all of the test emails.

This software has been placed into the public domain using CC0.

test_seams_countdown_global

The test harnesses control most of the test seams through the use of global counter values.

Setting a global counter to -1 will make the test seam function operate as it normally would. If set to a positive value, the value will continue to decrement every time the function gets called. When the counter reaches 0, the test seam will force the function to return an error value.

For example, initially setting the counter to 0 will force the test seam to return an error condition the first time it gets called. Setting the value to 1 initially will force the test seam to return an error condition on the second time it gets called.

Definition in file test.h.

Function Documentation

◆ smtp_address_validate_email()

int smtp_address_validate_email ( const char *const email )

Validate characters in the email address.

The email address must consist only of printable characters excluding the angle brackets (<) and (>).

Parameters

[in] email The email address of the party.

Return values

0	Successful validation.
-1	Failed to validate.

Definition at line 2878 of file smtp.c.

References SMTP_LINKAGE.

Referenced by smtp_address_add(), and smtp_unit_test_all_smtp_address_validate_email().

                                                     {
   size_t i;
   unsigned char uc;
 
   for(i = 0; email[i]; i++){
     uc = (unsigned char)email[i];
     if(uc <= ' ' || uc == 127 ||
        uc == '<' || uc == '>'){
       return -1;
     }
   }
   return 0;
 }

Here is the caller graph for this function:

◆ smtp_address_validate_name()

int smtp_address_validate_name ( const char *const name )

Validate characters in the email name.

Email user name must consist only of printable characters, excluding the double quote character.

Parameters

[in] name Email name to validate.

Return values

0	Successful validation.
-1	Failed to validate.

Definition at line 2903 of file smtp.c.

References SMTP_LINKAGE.

Referenced by smtp_address_add(), and smtp_unit_test_all_smtp_address_validate_name().

                                                   {
   size_t i;
   unsigned char uc;
 
   for(i = 0; name[i]; i++){
     uc = (unsigned char)name[i];
     if(uc < ' ' || uc == 127 || uc == '\"'){
       return -1;
     }
   }
   return 0;
 }

Here is the caller graph for this function:

◆ smtp_attachment_validate_name()

int smtp_attachment_validate_name ( const char *const name )

Validate characters in the attachment file name.

Must consist only of printable characters or the space character ( ), and excluding the quote characters (') and (").

Parameters

[in] name Filename of the attachment shown to recipients.

Return values

0	Successful validation.
-1	Failed to validate.

Definition at line 2927 of file smtp.c.

Referenced by smtp_attachment_add_mem(), and smtp_unit_test_all_smtp_attachment_validate_name().

                                                      {
   size_t i;
   unsigned char uc;
 
   for(i = 0; name[i]; i++){
     uc = (unsigned char)name[i];
     if(uc < ' ' || uc == 127 ||
        uc == '\'' || uc == '\"'){
       return -1;
     }
   }
   return 0;
 }

Here is the caller graph for this function:

◆ smtp_base64_decode()

size_t smtp_base64_decode	(	const char *const	buf,
		unsigned char **	decode
	)

Decode a base64 string.

The decode parameter will get dynamically allocated by this function if it successfully completes. Therefore, the caller must free the decode parameter after use.

Parameters

[in]	buf	Null-terminated base64 string.
[out]	decode	Pointer to buffer which will get dynamically allocated and will contain the decoded binary data. This parameter will get set to NULL if the memory allocation fails.

Return values

>=0	Length of the data stored in the decode parameter.
-1	Memory allocation failure or invalid base64 byte sequences.

Definition at line 984 of file smtp.c.

References calloc, SIZE_MAX, smtp_base64_decode_block(), SMTP_LINKAGE, smtp_si_add_size_t(), and strlen.

Referenced by smtp_auth_cram_md5(), and smtp_unit_test_base64_decode().

                                           {
   size_t buf_len;
   size_t buf_len_inc;
   size_t buf_i;
   unsigned char *b64_decode;
   size_t decode_len;
   size_t decode_block_len;
 
   *decode = NULL;
 
   buf_len = strlen(buf);
   if(buf_len % 4 != 0){
     return SIZE_MAX;
   }
 
   if(smtp_si_add_size_t(buf_len, 1, &buf_len_inc) ||
      (b64_decode = calloc(1, buf_len_inc)) == NULL){
     return SIZE_MAX;
   }
 
   decode_len = 0;
   for(buf_i = 0; buf_i < buf_len; buf_i += 4){
     decode_block_len = smtp_base64_decode_block(
                          (const unsigned char*)&buf[buf_i],
                          &b64_decode[decode_len]);
     if(decode_block_len == 0){
       free(b64_decode);
       return SIZE_MAX;
     }
     decode_len += decode_block_len;
   }
   *decode = b64_decode;
   return decode_len;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_base64_encode()

char* smtp_base64_encode	(	const char *const	buf,
		size_t	buflen
	)

Encode binary data into a base64 string.

Parameters

[in]	buf	Binary data to encode in base64.
[in]	buflen	Number of bytes in the `buf` parameter, or -1 if null-terminated.

Return values

char*	Dynamically allocated base64 encoded string. The caller must free this string when finished.
NULL	Memory allocation failure.

Definition at line 825 of file smtp.c.

References calloc, SIZE_MAX, smtp_base64_encode_block(), smtp_si_mul_size_t(), and strlen.

Referenced by smtp_attachment_add_mem(), smtp_auth_cram_md5(), smtp_auth_login(), smtp_auth_plain(), and smtp_unit_test_base64_encode().

                                  {
   char *b64;
   size_t b64_sz;
   size_t buf_i;
   size_t b64_i;
   size_t remaining_block_sz;
   size_t buf_block_sz;
 
   if(buflen == SIZE_MAX){
     buflen = strlen(buf);
   }
 
   /*
    * base64 size expands by 33%
    * +1 to round integer division up
    * +2 for '=' padding
    * +1 null terminator
    */
   if(smtp_si_mul_size_t(buflen, 4, NULL)){
     return NULL;
   }
   b64_sz = (4 * buflen / 3) + 1 + 2 + 1;
   if((b64 = calloc(1, b64_sz)) == NULL){
     return NULL;
   }
 
   if(buflen == 0){
     return b64;
   }
 
   buf_i = 0;
   b64_i = 0;
   remaining_block_sz = buflen;
   while(remaining_block_sz > 0){
     if(remaining_block_sz >= 3){
       buf_block_sz = 3;
     }
     else{
       buf_block_sz = remaining_block_sz;
     }
 
     smtp_base64_encode_block(&buf[buf_i], buf_block_sz, &b64[b64_i]);
 
     /*
      * Do not need to check for wrapping because these values restricted to
      * range of b64_sz, which has already been checked for wrapping above.
      */
     buf_i += 3;
     b64_i += 4;
 
     remaining_block_sz -= buf_block_sz;
   }
 
   return b64;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_bin2hex()

char* smtp_bin2hex	(	const unsigned char *const	s,
		size_t	slen
	)

Convert binary data to lowercase hexadecimal representation.

Parameters

[in]	s	Buffer containing binary data to convert.
[in]	slen	Number of bytes in `s`.

Return values

char*	Dynamically allocated string consisting of a hexadecimal representation of binary data in `s`. The caller must free this memory when finished.
NULL	Memory allocation or encoding error.

Definition at line 1031 of file smtp.c.

References malloc, SMTP_LINKAGE, smtp_si_add_size_t(), smtp_si_mul_size_t(), and sprintf.

Referenced by smtp_auth_cram_md5(), and smtp_unit_test_bin2hex().

                          {
   char *snew;
   size_t alloc_sz;
   size_t i;
   size_t j;
   unsigned hex;
   int rc;
 
   /* alloc_sz = slen * 2 + 1 */
   if(smtp_si_mul_size_t(slen, 2, &alloc_sz) ||
      smtp_si_add_size_t(alloc_sz, 1, &alloc_sz)){
     return NULL;
   }
   if((snew = malloc(alloc_sz)) == NULL){
     return NULL;
   }
 
   j = 0;
   for(i = 0; i < slen; i++){
     hex = s[i];
     rc = sprintf(&snew[j], "%02x", hex);
     if(rc < 0 || (size_t)rc >= 3){
       free(snew);
       return NULL;
     }
     j += 2;
   }
   snew[j] = '\0';
 
   return snew;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_chunk_split()

char* smtp_chunk_split	(	const char *const	s,
		size_t	chunklen,
		const char *const	end
	)

Splits a string into smaller chunks separated by a terminating string.

Parameters

[in]	s	The string to chunk.
[in]	chunklen	Number of bytes for each chunk in the string.
[in]	end	Terminating string placed at the end of each chunk.

Return values

char*	Pointer to an allocated string with the contents split into separate chunks. The caller must free this memory when done.
NULL	Memory allocation failure.

Definition at line 1312 of file smtp.c.

References calloc, SIZE_MAX, SMTP_LINKAGE, smtp_si_add_size_t(), smtp_si_mul_size_t(), smtp_strdup(), smtp_strnlen_utf8(), and strlen.

Referenced by smtp_attachment_add_mem(), and smtp_unit_test_chunk_split().

                                        {
   char *snew;
   size_t bodylen;
   size_t bodylen_inc;
   size_t endlen;
   size_t endlen_inc;
   size_t snewlen;
   size_t chunk_i;
   size_t snew_i;
   size_t body_i;
   size_t body_copy_len;
 
   if(chunklen < 1){
     errno = EINVAL;
     return NULL;
   }
 
   bodylen = strlen(s);
   endlen = strlen(end);
 
   if(bodylen < 1){
     return smtp_strdup(end);
   }
 
   /*
    *                                                               \0
    * snewlen = bodylen + (endlen + 1) * (bodylen / chunklen + 1) + 1
    */
   if(smtp_si_add_size_t(endlen, 1, &endlen_inc) ||
      smtp_si_add_size_t(bodylen, 1, &bodylen_inc) ||
      smtp_si_mul_size_t(endlen_inc, bodylen / chunklen + 1, &snewlen) ||
      smtp_si_add_size_t(snewlen, bodylen_inc, &snewlen) ||
      (snew = calloc(1, snewlen)) == NULL){
     return NULL;
   }
 
   body_i = 0;
   snew_i = 0;
   for(chunk_i = 0; chunk_i < bodylen / chunklen + 1; chunk_i++){
     body_copy_len = smtp_strnlen_utf8(&s[body_i], chunklen);
     if(body_copy_len == SIZE_MAX){
       free(snew);
       return NULL;
     }
     memcpy(&snew[snew_i], &s[body_i], body_copy_len);
     snew_i += body_copy_len;
     if(s[body_i] == '\0'){
       snew_i += 1;
     }
     body_i += body_copy_len;
 
     if(endlen > 0){
       memcpy(&snew[snew_i], end, endlen);
     }
     snew_i += endlen;
   }
 
   return snew;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_date_rfc_2822()

int smtp_date_rfc_2822 ( char *const date )

Convert the time into an RFC 2822 formatted string.

Example date format: Thu, 21 May 1998 05:33:29 -0700

Parameters

[out] date Buffer that has at least SMTP_DATE_MAX_SZ bytes.

Return values

0	Successfully copied the current date to the buffer.
-1	Failed to establish the current date or an output format error occurred.

Definition at line 2236 of file smtp.c.

References gmtime_r, localtime_r, mktime, SMTP_DATE_MAX_SZ, sprintf, and time.

Referenced by smtp_mail(), and smtp_unit_test_date_rfc_2822().

                                     {
   time_t t;
   time_t t_local;
   time_t t_utc;
   struct tm tm_local;
   struct tm tm_utc;
   long offset_utc;
   double diff_local_utc;
   int rc;
 
   const char weekday_abbreviation[7][4] = {
     "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
   };
 
   const char month_abbreviation[12][4] = {
     "Jan", "Feb", "Mar", "Apr", "May", "Jun",
     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
   };
 
   if((t = time(NULL)) == (time_t)(-1)){
     return -1;
   }
 
 #ifdef SMTP_IS_WINDOWS
   if(localtime_s(&tm_local, &t) ||
      gmtime_s(&tm_utc, &t)){
     return -1;
   }
 #else /* POSIX */
   /* Not defined if system does not have localtime_r or gmtime_r. */
 # ifdef SMTP_TIME_NO_REENTRANT
   struct tm *tm;
 
   /* localtime() not thread-safe. */
   if((tm = localtime(&t)) == NULL){
     return -1;
   }
   memcpy(&tm_local, tm, sizeof(tm_local));
 
   /* gmtime() not thread-safe. */
   if((tm = gmtime(&t)) == NULL){
     return -1;
   }
   memcpy(&tm_utc, tm, sizeof(tm_utc));
 # else /* Reentrant versions: localtime_r() and gmtime_r(). */
   if(localtime_r(&t, &tm_local) == NULL ||
      gmtime_r(&t, &tm_utc) == NULL){
     return -1;
   }
 # endif /* SMTP_TIME_NO_REENTRANT */
 #endif /* SMTP_IS_WINDOWS */
 
   if((t_local = mktime(&tm_local)) == (time_t)(-1)){
     return -1;
   }
 
   if((t_utc = mktime(&tm_utc)) == (time_t)(-1)){
     return -1;
   }
 
   /*
    * After computing the offset, it will contain a maximum of 4 digits.
    * For example, PST time zone will have an offset of -800 which will get
    * formatted as -0800 in the sprintf call below.
    */
   diff_local_utc = difftime(t_local, t_utc);
   offset_utc = (long)diff_local_utc;
   offset_utc = offset_utc / 60 / 60 * 100;
 
   rc = sprintf(date,
                "%s, %02d %s %d %02d:%02d:%02d %0+5ld",
                weekday_abbreviation[tm_local.tm_wday],
                tm_local.tm_mday,
                month_abbreviation[tm_local.tm_mon],
                tm_local.tm_year + 1900,
                tm_local.tm_hour,
                tm_local.tm_min,
                tm_local.tm_sec, /* 0 - 60 (leap second) */
                offset_utc);
 
   if(rc + 1 != SMTP_DATE_MAX_SZ - 15){ /* See @ref SMTP_DATE_MAX_SZ for -5. */
     return -1;
   }
 
   return 0;
 }

Here is the caller graph for this function:

◆ smtp_ffile_get_contents()

char* smtp_ffile_get_contents	(	FILE *	stream,
		size_t *	bytes_read
	)

Read the entire contents of a file stream and store the data into a dynamically allocated buffer.

Parameters

[in]	stream	File stream already opened by the caller.
[out]	bytes_read	Number of bytes stored in the return buffer.

Return values

char*	A dynamically allocated buffer which contains the entire contents of `stream`. The caller must free this memory when done.
NULL	Memory allocation or file read error.

Definition at line 1386 of file smtp.c.

References ferror, realloc, SMTP_LINKAGE, and smtp_si_add_size_t().

Referenced by smtp_attachment_add_fp(), and smtp_file_get_contents().

                                            {
   char *read_buf;
   size_t bufsz;
   size_t bufsz_inc;
   char *new_buf;
   size_t bytes_read_loop;
   const size_t BUFSZ_INCREMENT = 512;
 
   read_buf = NULL;
   bufsz = 0;
 
   if(bytes_read){
     *bytes_read = 0;
   }
 
   do{
     if(smtp_si_add_size_t(bufsz, BUFSZ_INCREMENT, &bufsz_inc) ||
        (new_buf = realloc(read_buf, bufsz_inc)) == NULL){
       free(read_buf);
       return NULL;
     }
     read_buf = new_buf;
     bufsz = bufsz_inc;
 
     bytes_read_loop = fread(&read_buf[bufsz - BUFSZ_INCREMENT],
                             sizeof(char),
                             BUFSZ_INCREMENT,
                             stream);
     if(bytes_read){
       *bytes_read += bytes_read_loop;
     }
     if(ferror(stream)){
       free(read_buf);
       return NULL;
     }
   } while(!feof(stream));
 
   return read_buf;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_file_get_contents()

char* smtp_file_get_contents	(	const char *const	filename,
		size_t *	bytes_read
	)

Read the entire contents of a file from a given path, and store the data into a dynamically allocated buffer.

Parameters

[in]	filename	Path of file to open and read from.
[out]	bytes_read	Number of bytes stored in the return buffer.

Return values

char*	A dynamically allocated buffer which has the contents of the file at `filename`. The caller must free this memory when done.
NULL	Memory allocation or file read error.

Definition at line 1439 of file smtp.c.

References fclose, smtp_ffile_get_contents(), and SMTP_LINKAGE.

Referenced by smtp_attachment_add_path(), smtp_test_config_load_from_file(), smtp_unit_test_all_file_get_contents(), and smtp_unit_test_file_get_contents().

                                           {
   FILE *fp;
   char *read_buf;
 
   if((fp = fopen(filename, "rb")) == NULL){
     return NULL;
   }
 
   read_buf = smtp_ffile_get_contents(fp, bytes_read);
 
   if(fclose(fp) == EOF){
     free(read_buf);
     read_buf = NULL;
   }
 
   return read_buf;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_fold_whitespace()

char* smtp_fold_whitespace	(	const char *const	s,
		unsigned int	maxlen
	)

Fold a line at whitespace characters.

This function tries to keep the total number of characters per line under maxlen, but does not guarantee this. For really long text with no whitespace, the line will still extend beyond maxlen and possibly beyond the RFC limit as defined in SMTP_LINE_MAX. This is by design and intended to keep the algorithm simpler to implement. Users sending long headers with no space characters should not assume that will work, but modern email systems may correctly process those headers anyways.

Lines get folded by adding a [CR][LF] and then two space characters on the beginning of the next line. For example, this Subject line:

Subject: Email[WS][WS]Header

Would get folded like this (assuming a small maxlen):

Subject: Email[WS][CR][LF] [WS][WS]Header

Parameters

[in]	s	String to fold.
[in]	maxlen	Number of bytes for each line in the string (soft limit). The minimum value of this parameter is 3 and it will get forced to 3 if the provided value is less.

Return values

char*	Pointer to an allocated string with the contents split into separate lines. The caller must free this memory when done.
NULL	Memory allocation failed.

Definition at line 1250 of file smtp.c.

References realloc, smtp_fold_whitespace_get_offset(), SMTP_LINKAGE, smtp_si_add_size_t(), and strlen.

Referenced by smtp_print_header(), and smtp_unit_test_fold_whitespace().

                                          {
   const char *const SMTP_LINE_FOLD_STR = "\r\n ";
   size_t end_slen;
   size_t s_i;
   size_t buf_i;
   size_t bufsz;
   size_t ws_offset;
   char *buf;
   char *buf_new;
 
   if(maxlen < 3){
     maxlen = 3;
   }
 
   end_slen = strlen(SMTP_LINE_FOLD_STR);
 
   s_i = 0;
   buf_i = 0;
   bufsz = 0;
   buf = NULL;
 
   while(1){
     ws_offset = smtp_fold_whitespace_get_offset(&s[s_i], maxlen - 2);
 
     /* bufsz += ws_offset + end_slen + 1 */
     if(smtp_si_add_size_t(bufsz, ws_offset, &bufsz) ||
        smtp_si_add_size_t(bufsz, end_slen, &bufsz) ||
        smtp_si_add_size_t(bufsz, 1, &bufsz) ||
        (buf_new = realloc(buf, bufsz)) == NULL){
       free(buf);
       return NULL;
     }
     buf = buf_new;
     memcpy(&buf[buf_i], &s[s_i], ws_offset);
     buf[buf_i + ws_offset] = '\0';
 
     if(s[s_i + ws_offset] == '\0'){
       break;
     }
 
     buf_i += ws_offset;
     strcat(&buf[buf_i], SMTP_LINE_FOLD_STR);
     buf_i += end_slen;
 
     /*                 WS */
     s_i += ws_offset + 1;
   }
   return buf;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_fold_whitespace_get_offset()

size_t smtp_fold_whitespace_get_offset	(	const char *const	s,
		unsigned int	maxlen
	)

Get the offset of the next whitespace block to process folding.

If a string does not have whitespace before maxlen, then the index will get returned past maxlen. Also returns the index of NULL character if that fits within the next block. The caller must check for the NULL index to indicate the last block. It will skip past any leading whitespace even if that means going over maxlen.

Examples: smtp_fold_whitespace_get_offset ("Subject: Test WS", 1/2/8/9/10/13) -> 8 smtp_fold_whitespace_get_offset ("Subject: Test WS", 14/15) -> 13 smtp_fold_whitespace_get_offset ("Subject: Test WS", 17/18) -> 16

Parameters

[in]	s	String to get offset from.
[in]	maxlen	Number of bytes for each line in the string (soft limit).

Returns: Index in s.

Definition at line 1179 of file smtp.c.

Referenced by smtp_fold_whitespace(), and smtp_unit_test_fold_whitespace_get_offset().

                                                     {
   size_t i;
   size_t offset_i;
 
   i = 0;
   offset_i = 0;
 
   while(s[i] == ' ' || s[i] == '\t'){
     i += 1;
   }
 
   while(s[i]){
     if(s[i] == ' ' || s[i] == '\t'){
       do{
         i += 1;
       } while(s[i] == ' ' || s[i] == '\t');
       i -= 1;
       if(i < maxlen || !offset_i){
         offset_i = i;
       }
       else{
         break;
       }
     }
     i += 1;
   }
 
   if(!offset_i || i < maxlen){
     offset_i = i;
   }
 
   return offset_i;
 }

Here is the caller graph for this function:

◆ smtp_header_key_validate()

int smtp_header_key_validate ( const char *const key )

Validate characters in the email header key.

Must consist only of printable US-ASCII characters except colon.

Parameters

[in] key Header key to validate.

Return values

0	Successful validation.
-1	Failed to validate.

Definition at line 2822 of file smtp.c.

References SMTP_LINKAGE, and strlen.

Referenced by smtp_header_add(), and smtp_unit_test_all_smtp_header_key_validate().

                                                {
   unsigned char uc;
   size_t i;
   size_t keylen;
 
   keylen = strlen(key);
   if(keylen < 1){
     return -1;
   }
 
   for(i = 0; i < keylen; i++){
     uc = (unsigned char)key[i];
     if(uc <= ' ' || uc > 126 || uc == ':'){
       return -1;
     }
   }
 
   return 0;
 }

Here is the caller graph for this function:

◆ smtp_header_value_validate()

int smtp_header_value_validate ( const char *const value )

Validate characters in the email header contents.

Must consist only of printable character, space, or horizontal tab.

Parameters

[in] value Header value to validate.

Return values

0	Successful validation.
-1	Failed to validate.

Definition at line 2852 of file smtp.c.

References SMTP_LINKAGE.

Referenced by smtp_header_add(), and smtp_unit_test_all_smtp_header_value_validate().

                                                    {
   size_t i;
   unsigned char uc;
 
   for(i = 0; value[i]; i++){
     uc = (unsigned char)value[i];
     if((uc < ' ' || uc > 126) &&
         uc != '\t' &&
         uc < 0x80){ /* Allow UTF-8 byte sequence. */
       return -1;
     }
   }
   return 0;
 }

Here is the caller graph for this function:

◆ smtp_parse_cmd_line()

int smtp_parse_cmd_line	(	char *const	line,
		struct smtp_command *const	cmd
	)

Parse a server response line into the smtp_command data structure.

Parameters

[in]	line	Server response string.
[out]	cmd	Structure containing the server response data broken up into its separate components.

Returns: See smtp_result_code.

Definition at line 1467 of file smtp.c.

References smtp_command::code, smtp_command::more, SMTP_BEGIN_MAIL, SMTP_INTERNAL_ERROR, strlen, and smtp_command::text.

Referenced by smtp_auth_cram_md5(), smtp_read_and_parse_code(), and smtp_unit_test_parse_cmd_line().

                                                    {
   char *ep;
   char code_str[4];
   size_t line_len;
   unsigned long int ulcode;
 
   line_len = strlen(line);
   if(line_len < 5){
     cmd->code = SMTP_INTERNAL_ERROR;
     cmd->more = 0;
     cmd->text = line;
     return cmd->code;
   }
 
   cmd->text = &line[4];
 
   memcpy(code_str, line, 3);
   code_str[3] = '\0';
   ulcode = strtoul(code_str, &ep, 10);
   if(*ep != '\0' || ulcode > SMTP_BEGIN_MAIL){
     cmd->code = SMTP_INTERNAL_ERROR;
   }
   else{
     cmd->code = (enum smtp_result_code)ulcode;
   }
 
   if(line[3] == '-'){
     cmd->more = 1;
   }
   else{
     cmd->more = 0;
   }
   return cmd->code;
 }

Here is the caller graph for this function:

◆ smtp_reallocarray()

void* smtp_reallocarray	(	void *	ptr,
		size_t	nmemb,
		size_t	size
	)

Reallocate memory with unsigned wrapping checks.

Parameters

[in]	ptr	Existing allocation buffer, or NULL when allocating a new buffer.
[in]	nmemb	Number of elements to allocate.
[in]	size	Size of each element in `nmemb`.

Return values

void*	Pointer to a reallocated buffer containing `nmemb` * `size` bytes.
NULL	Failed to reallocate memory.

Definition at line 622 of file smtp.c.

References realloc, SMTP_LINKAGE, and smtp_si_mul_size_t().

Referenced by smtp_address_add(), smtp_attachment_add_mem(), smtp_header_add(), and smtp_unit_test_reallocarray().

                               {
   void *alloc;
   size_t size_mul;
 
   if(smtp_si_mul_size_t(nmemb, size, &size_mul)){
     alloc = NULL;
     errno = ENOMEM;
   }
   else{
     alloc = realloc(ptr, size_mul);
   }
   return alloc;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_si_add_size_t()

int smtp_si_add_size_t	(	const size_t	a,
		const size_t	b,
		size_t *const	result
	)

Check if adding a size_t value will cause a wrap.

Parameters

[in]	a	Add this value with `b`.
[in]	b	Add this value with `a`.
[out]	result	Save the addition to this buffer. Does not perform the addition if set to NULL.

Return values

1	Value wrapped.
0	Value did not wrap.

Definition at line 252 of file smtp.c.

References g_smtp_test_err_si_add_size_t_ctr, SIZE_MAX, SMTP_LINKAGE, and smtp_test_seam_dec_err_ctr().

Referenced by smtp_address_add(), smtp_append_address_to_header(), smtp_attachment_add_mem(), smtp_auth_cram_md5(), smtp_auth_login(), smtp_auth_plain(), smtp_base64_decode(), smtp_bin2hex(), smtp_chunk_split(), smtp_ffile_get_contents(), smtp_fold_whitespace(), smtp_header_add(), smtp_mail_envelope_header(), smtp_print_header(), smtp_print_mime_attachment(), smtp_print_mime_header_and_body(), smtp_puts_terminate(), smtp_str_getdelimfd(), smtp_str_getdelimfd_set_line_and_buf(), smtp_str_replace(), smtp_strdup(), and smtp_unit_test_all_si().

                                         {
   int wraps;
 
 #ifdef SMTP_TEST
   if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_si_add_size_t_ctr)){
     return 1;
   }
 #endif /* SMTP_TEST */
 
   if(SIZE_MAX - a < b){
     wraps = 1;
   }
   else{
     wraps = 0;
   }
   if(result){
     *result = a + b;
   }
   return wraps;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_si_mul_size_t()

int smtp_si_mul_size_t	(	const size_t	a,
		const size_t	b,
		size_t *const	result
	)

Check if multiplying a size_t value will cause a wrap.

Parameters

[in]	a	Multiply this value with `b`.
[in]	b	Multiply this value with `a`.
[out]	result	Save the multiplication to this buffer. Does not perform the multiplication if set to NULL.

Return values

1	Value wrapped.
0	Value did not wrap.

Definition at line 320 of file smtp.c.

References g_smtp_test_err_si_mul_size_t_ctr, SIZE_MAX, and smtp_test_seam_dec_err_ctr().

Referenced by smtp_base64_encode(), smtp_bin2hex(), smtp_chunk_split(), smtp_reallocarray(), and smtp_unit_test_all_si().

                                         {
   int wraps;
 
 #ifdef SMTP_TEST
   if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_si_mul_size_t_ctr)){
     return 1;
   }
 #endif /* SMTP_TEST */
 
   if(b != 0 && a > SIZE_MAX / b){
     wraps = 1;
   }
   else{
     wraps = 0;
   }
   if(result){
     *result = a * b;
   }
   return wraps;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_si_sub_size_t()

int smtp_si_sub_size_t	(	const size_t	a,
		const size_t	b,
		size_t *const	result
	)

Check if subtracting a size_t value will cause wrap.

Parameters

[in]	a	Subtract this value by `b`.
[in]	b	Subtract this value from `a`.
[out]	result	Save the subtraction to this buffer. Does not perform the subtraction if set to NULL.

Return values

1	Value wrapped.
0	Value did not wrap.

Definition at line 286 of file smtp.c.

References g_smtp_test_err_si_sub_size_t_ctr, SMTP_LINKAGE, and smtp_test_seam_dec_err_ctr().

Referenced by smtp_str_getdelimfd(), smtp_str_getdelimfd_set_line_and_buf(), and smtp_unit_test_all_si().

                                         {
   int wraps;
 
 #ifdef SMTP_TEST
   if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_si_sub_size_t_ctr)){
     return 1;
   }
 #endif /* SMTP_TEST */
 
   if(a < b){
     wraps = 1;
   }
   else{
     wraps = 0;
   }
   if(result){
     *result = a - b;
   }
   return wraps;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_stpcpy()

char* smtp_stpcpy	(	char *	s1,
		const char *	s2
	)

Copy a string and get the pointer to the end of the copied buffer.

This function behaves similar to POSIX stpcpy(), useful for concatenating multiple strings onto a buffer. It always adds a null-terminated byte at the end of the string.

Parameters

[in]	s1	Destination buffer.
[in]	s2	Null-terminated source string to copy to `s1`.

Returns: Pointer to location in s1 after the last copied byte.

Definition at line 599 of file smtp.c.

References SMTP_LINKAGE.

Referenced by smtp_append_address_to_header(), smtp_auth_cram_md5(), smtp_auth_login(), smtp_auth_plain(), smtp_mail_envelope_header(), smtp_print_header(), smtp_print_mime_attachment(), smtp_print_mime_end(), smtp_print_mime_header_and_body(), smtp_puts_terminate(), and smtp_unit_test_stpcpy().

                            {
   size_t i;
 
   i = 0;
   do{
     s1[i] = s2[i];
   } while(s2[i++] != '\0');
   return &s1[i-1];
 }

Here is the caller graph for this function:

◆ smtp_str_getdelimfd()

int smtp_str_getdelimfd ( struct str_getdelimfd *const gdfd )

Read and parse a delimited string using a custom socket read function.

This interface handles all of the logic for expanding the buffer, parsing the delimiter in the buffer, and returning each "line" to the caller for handling.

Parameters

[in] gdfd See str_getdelimfd.

Returns: See str_getdelim_retcode.

Definition at line 523 of file smtp.c.

References str_getdelimfd::_buf, str_getdelimfd::_buf_len, str_getdelimfd::_bufsz, str_getdelimfd::delim, str_getdelimfd::getdelimfd_read, realloc, SMTP_GETDELIM_READ_SZ, SMTP_LINKAGE, smtp_si_add_size_t(), smtp_si_sub_size_t(), smtp_str_getdelimfd_search_delim(), smtp_str_getdelimfd_set_line_and_buf(), smtp_str_getdelimfd_throw_error(), STRING_GETDELIMFD_DONE, STRING_GETDELIMFD_ERROR, and STRING_GETDELIMFD_NEXT.

Referenced by smtp_getline(), and smtp_unit_test_str_getdelimfd().

                                                       {
   size_t delim_pos;
   long bytes_read;
   void *read_buf_ptr;
   char *buf_new;
   size_t buf_sz_remaining;
   size_t buf_sz_new;
 
   if(gdfd->getdelimfd_read == NULL){
     return STRING_GETDELIMFD_ERROR;
   }
 
   bytes_read = -1;
 
   while(1){
     if(smtp_str_getdelimfd_search_delim(gdfd->_buf,
                                         gdfd->_buf_len,
                                         gdfd->delim,
                                         &delim_pos)){
       if(smtp_str_getdelimfd_set_line_and_buf(gdfd, delim_pos) < 0){
         return smtp_str_getdelimfd_throw_error(gdfd);
       }
       return STRING_GETDELIMFD_NEXT;
     }else if(bytes_read == 0){
       if(smtp_str_getdelimfd_set_line_and_buf(gdfd, gdfd->_buf_len) < 0){
         return smtp_str_getdelimfd_throw_error(gdfd);
       }
       return STRING_GETDELIMFD_DONE;
     }
 
     if(smtp_si_sub_size_t(gdfd->_bufsz, gdfd->_buf_len, &buf_sz_remaining)){
       return smtp_str_getdelimfd_throw_error(gdfd);
     }
 
     if(buf_sz_remaining < SMTP_GETDELIM_READ_SZ){
       if(smtp_si_add_size_t(buf_sz_remaining,
                             SMTP_GETDELIM_READ_SZ,
                             &buf_sz_new)){
         return smtp_str_getdelimfd_throw_error(gdfd);
       }
       buf_new = realloc(gdfd->_buf, buf_sz_new);
       if(buf_new == NULL){
         return smtp_str_getdelimfd_throw_error(gdfd);
       }
       gdfd->_buf = buf_new;
       gdfd->_bufsz = buf_sz_new;
     }
 
     if(smtp_si_add_size_t((size_t)gdfd->_buf, gdfd->_buf_len, NULL)){
       return smtp_str_getdelimfd_throw_error(gdfd);
     }
     read_buf_ptr = gdfd->_buf + gdfd->_buf_len;
     bytes_read = (*gdfd->getdelimfd_read)(gdfd,
                                           read_buf_ptr,
                                           SMTP_GETDELIM_READ_SZ);
     if(bytes_read < 0 ||
        smtp_si_add_size_t(gdfd->_buf_len,
                           (size_t)bytes_read,
                           &gdfd->_buf_len)){
       return smtp_str_getdelimfd_throw_error(gdfd);
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_str_getdelimfd_free()

void smtp_str_getdelimfd_free ( struct str_getdelimfd *const gdfd )

Free memory in the str_getdelimfd data structure.

Parameters

[in] gdfd Frees memory stored in this socket parsing structure.

Definition at line 489 of file smtp.c.

References str_getdelimfd::_buf, str_getdelimfd::_buf_len, str_getdelimfd::_bufsz, str_getdelimfd::line, and str_getdelimfd::line_len.

Referenced by smtp_close(), smtp_str_getdelimfd_throw_error(), and smtp_unit_test_str_getdelimfd().

                                                            {
   free(gdfd->_buf);
   free(gdfd->line);
   gdfd->_buf = NULL;
   gdfd->_bufsz = 0;
   gdfd->_buf_len = 0;
   gdfd->line = NULL;
   gdfd->line_len = 0;
 }

Here is the caller graph for this function:

◆ smtp_str_getdelimfd_set_line_and_buf()

int smtp_str_getdelimfd_set_line_and_buf	(	struct str_getdelimfd *const	gdfd,
		size_t	copy_len
	)

Set the internal line buffer to the number of bytes specified.

Parameters

[in]	gdfd	See str_getdelimfd.
[in]	copy_len	Number of bytes to copy to the internal line buffer.

Return values

0	Successfully allocated and copied data over to the new line buffer.
-1	Failed to allocate memory for the new line buffer.

Definition at line 457 of file smtp.c.

References str_getdelimfd::_buf, str_getdelimfd::_buf_len, calloc, str_getdelimfd::line, str_getdelimfd::line_len, SMTP_LINKAGE, smtp_si_add_size_t(), and smtp_si_sub_size_t().

Referenced by smtp_str_getdelimfd(), and smtp_unit_test_getdelimfd_set_line_and_buf().

                                                      {
   size_t copy_len_inc;
   size_t nbytes_to_shift;
   size_t new_buf_len;
 
   if(gdfd->line){
     free(gdfd->line);
     gdfd->line = NULL;
   }
 
   if(smtp_si_add_size_t(copy_len, 1, &copy_len_inc) ||
      smtp_si_add_size_t((size_t)gdfd->_buf, copy_len_inc, NULL) ||
      smtp_si_sub_size_t(gdfd->_buf_len, copy_len, &nbytes_to_shift) ||
      (gdfd->line = calloc(1, copy_len_inc)) == NULL){
     return -1;
   }
   memcpy(gdfd->line, gdfd->_buf, copy_len);
   gdfd->line_len = copy_len;
   memmove(gdfd->_buf, gdfd->_buf + copy_len_inc, nbytes_to_shift);
   if(smtp_si_sub_size_t(nbytes_to_shift, 1, &new_buf_len) == 0){
     gdfd->_buf_len = new_buf_len;
   }
   return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_str_has_nonascii_utf8()

int smtp_str_has_nonascii_utf8 ( const char *const s )

Check if a string contains non-ASCII UTF-8 characters.

Uses the simple algorithm from smtp_utf8_charlen to check for non-ASCII UTF-8 characters.

Parameters

[in] s UTF-8 string.

Return values

1	String contains non-ASCII UTF-8 characters.
0	String contains only ASCII characters.

Definition at line 1110 of file smtp.c.

References SMTP_LINKAGE, and smtp_utf8_charlen().

Referenced by smtp_mail_envelope_header(), and smtp_unit_test_all_smtp_str_has_nonascii_utf8().

                                                {
   size_t i;
   size_t charlen;
 
   for(i = 0; s[i]; i++){
     charlen = smtp_utf8_charlen(s[i]);
     if(charlen != 1){
       return 1;
     }
   }
   return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_str_replace()

char* smtp_str_replace	(	const char *const	search,
		const char *const	replace,
		const char *const	s
	)

Search for all substrings in a string and replace each instance with a replacement string.

Parameters

[in]	search	Substring to search for in `s`.
[in]	replace	Replace each instance of the search string with this.
[in]	s	Null-terminated string to search and replace.

Return values

char*	A dynamically allocated string with the replaced instances as described above. The caller must free the allocated memory when finished.
NULL	Memory allocation failure.

Definition at line 679 of file smtp.c.

References realloc, smtp_si_add_size_t(), smtp_strdup(), and strlen.

Referenced by smtp_print_email(), and smtp_unit_test_str_replace().

                                      {
   size_t search_len;
   size_t replace_len;
   size_t replace_len_inc;
   size_t slen;
   size_t slen_inc;
   size_t s_idx;
   size_t snew_len;
   size_t snew_len_inc;
   size_t snew_sz;
   size_t snew_sz_dup;
   size_t snew_sz_plus_slen;
   size_t snew_replace_len_inc;
   char *snew;
   char *stmp;
 
   search_len    = strlen(search);
   replace_len   = strlen(replace);
   slen          = strlen(s);
   s_idx         = 0;
   snew          = NULL;
   snew_len      = 0;
   snew_sz       = 0;
 
   if(smtp_si_add_size_t(replace_len, 1, &replace_len_inc) ||
      smtp_si_add_size_t(slen, 1, &slen_inc)){
     return NULL;
   }
 
   if(s[0] == '\0'){
     return smtp_strdup("");
   }
   else if(search_len < 1){
     return smtp_strdup(s);
   }
 
   while(s[s_idx]){
     if(smtp_si_add_size_t(snew_len, 1, &snew_len_inc) ||
        smtp_si_add_size_t(snew_sz, snew_sz, &snew_sz_dup) ||
        smtp_si_add_size_t(snew_sz, slen, &snew_sz_plus_slen)){
       free(snew);
       return NULL;
     }
 
     if(strncmp(&s[s_idx], search, search_len) == 0){
       if(smtp_si_add_size_t(snew_len, replace_len_inc, &snew_replace_len_inc)){
         free(snew);
         return NULL;
       }
       if(snew_replace_len_inc >= snew_sz){
         /* snew_sz += snew_sz + slen + replace_len + 1 */
         if(smtp_si_add_size_t(snew_sz_dup, slen_inc, &snew_sz) ||
            smtp_si_add_size_t(snew_sz, replace_len, &snew_sz) ||
            (stmp = realloc(snew, snew_sz)) == NULL){
           free(snew);
           return NULL;
         }
         snew = stmp;
       }
       memcpy(&snew[snew_len], replace, replace_len);
       snew_len += replace_len;
       s_idx += search_len;
     }
     else{
       if(snew_len_inc >= snew_sz){
         /* snew_sz += snew_sz + slen + snew_len + 1 */
         if(smtp_si_add_size_t(snew_sz_dup, slen, &snew_sz) ||
            smtp_si_add_size_t(snew_sz, snew_len_inc, &snew_sz) ||
            (stmp = realloc(snew, snew_sz)) == NULL){
           free(snew);
           return NULL;
         }
         snew = stmp;
       }
       snew[snew_len] = s[s_idx];
       s_idx += 1;
       snew_len = snew_len_inc;
     }
   }
   snew[snew_len] = '\0';
 
   return snew;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_strdup()

char* smtp_strdup ( const char * s )

Copy a string into a new dynamically allocated buffer.

Returns a dynamically allocated string, with the same contents as the input string. The caller must free the returned string when finished.

Parameters

[in] s String to duplicate.

Return values

char*	Pointer to a new dynamically allocated string duplicated from `s`.
NULL	Failed to allocate memory for the new duplicate string.

Definition at line 650 of file smtp.c.

References malloc, SMTP_LINKAGE, smtp_si_add_size_t(), and strlen.

Referenced by smtp_address_add(), smtp_attachment_add_mem(), smtp_chunk_split(), smtp_header_add(), smtp_puts_dbg(), smtp_str_repeat(), smtp_str_replace(), smtp_unit_test_parse_cmd_line(), and smtp_unit_test_strdup().

                           {
   char *dup;
   size_t dup_len;
   size_t slen;
 
   slen = strlen(s);
   if(smtp_si_add_size_t(slen, 1, &dup_len)){
     dup = NULL;
     errno = ENOMEM;
   }
   else if((dup = malloc(dup_len)) != NULL){
     memcpy(dup, s, dup_len);
   }
   return dup;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_strnlen_utf8()

size_t smtp_strnlen_utf8	(	const char *	s,
		size_t	maxlen
	)

Get the number of bytes in a UTF-8 string, or a shorter count if the string exceeds a maximum specified length.

See maxlen for more information on multi-byte parsing.

Parameters

[in]	s	Null-terminated UTF-8 string.
[in]	maxlen	Do not check more than `maxlen` bytes of string `s` except if in the middle of a multi-byte character.

Return values

strlen(s)	If length of s has less bytes than maxlen or the same number of bytes as maxlen. See `maxlen` for more details.
maxlen	If length of s has more bytes than maxlen.
-1	If `s` contains an invalid UTF-8 byte sequence.

Definition at line 1138 of file smtp.c.

References SIZE_MAX, SMTP_LINKAGE, and smtp_utf8_charlen().

Referenced by smtp_chunk_split(), and smtp_unit_test_strnlen_utf8().

                                 {
   size_t i;
   size_t utf8_i;
   size_t utf8_len;
 
   for(i = 0; *s && i < maxlen; i += utf8_len){
     utf8_len = smtp_utf8_charlen(*s);
     if(utf8_len == 0){
       return SIZE_MAX;
     }
 
     for(utf8_i = 0; utf8_i < utf8_len; utf8_i++){
       if(!*s){
         return SIZE_MAX;
       }
       s += 1;
     }
   }
   return i;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_test_seam_bio_new_socket()

BIO* smtp_test_seam_bio_new_socket	(	int	sock,
		int	close_flag
	)

Allows the test harness to control when BIO_new_socket() fails.

Parameters

[in]	sock	Existing socket to attach the BIO to.
[in]	close_flag	Close flag for new BIO.

Return values

BIO*	New BIO created on existing socket.
NULL	Failed to create the new BIO.

Definition at line 263 of file seams.c.

References BIO_new_socket, g_smtp_test_err_bio_new_socket_ctr, and smtp_test_seam_dec_err_ctr().

                                              {
   if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_bio_new_socket_ctr)){
     return NULL;
   }
   return BIO_new_socket(sock, close_flag);
 }

Here is the call graph for this function:

◆ smtp_test_seam_bio_should_retry()

int smtp_test_seam_bio_should_retry ( BIO * bio )

Allows the test harness to control when BIO_should_retry() fails.

Parameters

[in] bio Existing BIO connection.

Return values

0	The error condition does not allow a retry.
1	The error condition allows a retry.

Definition at line 279 of file seams.c.

References BIO_should_retry, g_smtp_test_err_bio_should_retry_ctr, g_smtp_test_err_bio_should_retry_rc, and smtp_test_seam_dec_err_ctr().

                                          {
   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);
 }

Here is the call graph for this function:

◆ smtp_test_seam_calloc()

void* smtp_test_seam_calloc	(	size_t	nelem,
		size_t	elsize
	)

Allows the test harness to control when calloc() fails.

Parameters

[in]	nelem	Number of elements to allocate.
[in]	elsize	Size of each element to allocate.

Return values

void*	Pointer to new allocated memory.
NULL	Memory allocation failed.

Definition at line 298 of file seams.c.

References calloc, g_smtp_test_err_calloc_ctr, and smtp_test_seam_dec_err_ctr().

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

Here is the call graph for this function:

◆ smtp_test_seam_close()

int smtp_test_seam_close ( int fildes )

Allows the test harness to control when close() fails.

Parameters

[in] fildes Socket file descriptor to close.

Return values

0	Successfully closed file descriptor.
-1	Failed to close file descriptor.

Definition at line 315 of file seams.c.

References close, g_smtp_test_err_close_ctr, and smtp_test_seam_dec_err_ctr().

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

Here is the call graph for this function:

◆ smtp_test_seam_connect()

int smtp_test_seam_connect	(	int	socket,
		const struct sockaddr *	address,
		socklen_t	address_len
	)

Allows the test harness to control when connect() fails.

Parameters

[in]	socket	Socket connection.
[in]	address	Network address of peer.
[in]	address_len	Number of bytes in `address`.

Return values

0	Successfully connected to the peer.
-1	Failed to connect to the peer.

Definition at line 333 of file seams.c.

References connect, g_smtp_test_err_connect_ctr, and smtp_test_seam_dec_err_ctr().

                                              {
   if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_connect_ctr)){
     errno = ECONNREFUSED;
     return -1;
   }
   return connect(socket, address, address_len);
 }

Here is the call graph for this function:

◆ smtp_test_seam_dec_err_ctr()

int smtp_test_seam_dec_err_ctr ( int *const test_err_ctr )

Decrement an error counter until it reaches -1.

Once a counter reaches -1, it will return a successful response (1). This typically gets used to denote when to cause a function to fail. For example, the unit test or functional test might need to cause the realloc() function to fail after calling it the third time.

Parameters

[in,out] test_err_ctr Integer counter to decrement.

Return values

0	The counter has been decremented, but did not reach -1 yet.
1	The counter has reached -1.

Definition at line 244 of file seams.c.

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

Here is the caller graph for this function:

◆ smtp_test_seam_err_peek_error()

unsigned long smtp_test_seam_err_peek_error ( void )

Allows the test harness to control when ERR_peek_error() returns a failure code.

Return values

0	No error code on the error queue.
!0	An error code exists on the error queue.

Definition at line 351 of file seams.c.

References ERR_peek_error, g_smtp_test_err_err_peek_error_ctr, and smtp_test_seam_dec_err_ctr().

                                    {
   if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_err_peek_error_ctr)){
     return 1;
   }
   return ERR_peek_error();
 }

Here is the call graph for this function:

◆ smtp_test_seam_fclose()

int smtp_test_seam_fclose ( FILE * stream )

Allows the test harness to control when fclose() fails.

Parameters

[in] stream File stream to close.

Return values

0	Successfully closed the file stream.
EOF	An error occurred while closing the file stream.

Definition at line 365 of file seams.c.

References fclose, g_smtp_test_err_fclose_ctr, and smtp_test_seam_dec_err_ctr().

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

Here is the call graph for this function:

◆ smtp_test_seam_ferror()

int smtp_test_seam_ferror ( FILE * stream )

Allows the test harness to control the file stream error indicator return value in ferror().

Parameters

[in] stream Check for errors on this file stream.

Return values

0	No errors detected on the file stream.
1	An error occurred during a file stream operation.

Definition at line 382 of file seams.c.

References ferror, g_smtp_test_err_ferror_ctr, and smtp_test_seam_dec_err_ctr().

                                    {
   if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_ferror_ctr)){
     return 1;
   }
   return ferror(stream);
 }

Here is the call graph for this function:

◆ smtp_test_seam_gmtime_r()

struct tm* smtp_test_seam_gmtime_r	(	const time_t *	timep,
		struct tm *	result
	)

Allows the test harness to control when gmtime_r() fails.

Parameters

[in]	timep	Time value to convert to a struct tm.
[out]	result	Converts the `timep` value into a UTC tm structure value and stores the results in this pointer.

Return values

tm*	time_t value converted to a tm structure value.
NULL	An error occurred while converting the time.

Definition at line 399 of file seams.c.

References g_smtp_test_err_gmtime_r_ctr, gmtime_r, and smtp_test_seam_dec_err_ctr().

                                           {
   if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_gmtime_r_ctr)){
     return NULL;
   }
   return gmtime_r(timep, result);
 }

Here is the call graph for this function:

◆ smtp_test_seam_hmac()

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
	)

Allows the test harness to control when HMAC() fails.

Parameters

[in]	evp_md	Hash function.
[in]	key	Hash key.
[in]	key_len	Number of bytes in `key`.
[in]	d	Message data.
[in]	n	Number of bytes in `d`.
[out]	md	The computed message authentication code.
[in]	md_len	Number of bytes in `md`.

Return values

uchar*	Pointer to `md`.
NULL	An error occurred.

Definition at line 421 of file seams.c.

References g_smtp_test_err_hmac_ctr, HMAC, and smtp_test_seam_dec_err_ctr().

                                          {
   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);
 }

Here is the call graph for this function:

◆ smtp_test_seam_localtime_r()

struct tm* smtp_test_seam_localtime_r	(	const time_t *	timep,
		struct tm *	result
	)

Allows the test harness to control when localtime_r() fails.

Parameters

[in]	timep	Time value to convert to a struct tm.
[out]	result	Converts the `timep` value into a local time tm structure value and stores the results in this pointer.

Return values

tm*	time_t value converted to a tm structure value.
NULL	An error occurred while converting the time.

Definition at line 444 of file seams.c.

References g_smtp_test_err_localtime_r_ctr, localtime_r, and smtp_test_seam_dec_err_ctr().

                                              {
   if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_localtime_r_ctr)){
     return NULL;
   }
   return localtime_r(timep, result);
 }

Here is the call graph for this function:

◆ smtp_test_seam_malloc()

void* smtp_test_seam_malloc ( size_t size )

Allows the test harness to control when malloc() fails.

Parameters

[in] size Number of bytes to allocate.

Return values

void*	Pointer to new allocated memory.
NULL	Memory allocation failed.

Definition at line 460 of file seams.c.

References g_smtp_test_err_malloc_ctr, malloc, and smtp_test_seam_dec_err_ctr().

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

Here is the call graph for this function:

◆ smtp_test_seam_mktime()

time_t smtp_test_seam_mktime ( struct tm * timeptr )

Allows the test harness to control when mktime() fails.

Parameters

[in] timeptr tm data structure to convert to time_t.

Return values

>=0	Time since the epoch.
-1	Failed to convert the time.

Definition at line 476 of file seams.c.

References g_smtp_test_err_mktime_ctr, mktime, and smtp_test_seam_dec_err_ctr().

                                          {
   if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_mktime_ctr)){
     return -1;
   }
   return mktime(timeptr);
 }

Here is the call graph for this function:

◆ smtp_test_seam_realloc()

void* smtp_test_seam_realloc	(	void *	ptr,
		size_t	size
	)

Allows the test harness to control when realloc() fails.

Parameters

[in]	ptr	Previously allocated memory or NULL memory has not been allocated yet.
[in]	size	Number of bytes to reallocate.

Return values

void*	Pointer to new allocated memory.
NULL	Memory allocation failed.

Definition at line 493 of file seams.c.

References g_smtp_test_err_realloc_ctr, realloc, and smtp_test_seam_dec_err_ctr().

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

Here is the call graph for this function:

◆ smtp_test_seam_recv()

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

Allows the test harness to control when recv() fails.

Parameters

[in]	socket	TCP network socket.
[in]	buffer	Store received data in this buffer.
[in]	length	Number of bytes in `buffer`.
[in]	flags	Set this to 0.

Return values

>=0	Number of bytes received.
-1	Failed to receive bytes over the network.

Definition at line 513 of file seams.c.

References g_smtp_test_err_recv_bytes, g_smtp_test_err_recv_ctr, g_smtp_test_err_recv_rc, recv, smtp_test_seam_dec_err_ctr(), and strlen.

                               {
   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);
 }

Here is the call graph for this function:

◆ smtp_test_seam_select()

int smtp_test_seam_select	(	int	nfds,
		fd_set *	readfds,
		fd_set *	writefds,
		fd_set *	errorfds,
		struct timeval *	timeout
	)

Allows the test harness to control when select() fails.

Parameters

[in]	nfds	Check for file descriptors in range 0 to (`nfds` - 1) which have any of the read/write/error conditions.
[in]	readfds	Checks for file descriptors in fd_set that have bytes ready for reading.
[in]	writefds	Checks for file descriptors in fd_set that have bytes ready for writing.
[in]	errorfds	Checks for file descriptors in fd_set that have errors pending.
[in]	timeout	Wait for the read/write/error conditions in blocking mode until this timeout or an interrupt occurs.

Return values

>=0	Number of bits set in the bitmask.
-1	An error occurred.

Definition at line 552 of file seams.c.

References g_smtp_test_err_select_ctr, select, and smtp_test_seam_dec_err_ctr().

                                               {
   if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_select_ctr)){
     errno = EINTR;
     return -1;
   }
   return select(nfds, readfds, writefds, errorfds, timeout);
 }

Here is the call graph for this function:

◆ smtp_test_seam_send()

ssize_t smtp_test_seam_send	(	int	socket,
		const void *	buffer,
		size_t	length,
		int	flags
	)

Allows the test harness to control when send() fails.

Parameters

[in]	socket	TCP network socket.
[in]	buffer	Data to send over the network.
[in]	length	Number of bytes in `buffer`.
[in]	flags	Set this to 0.

Return values

>=0	Number of bytes sent.
-1	Failed to send bytes over the network.

Definition at line 575 of file seams.c.

References g_smtp_test_err_send_ctr, g_smtp_test_send_one_byte, send, and smtp_test_seam_dec_err_ctr().

                               {
   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;
 }

Here is the call graph for this function:

◆ smtp_test_seam_socket()

int smtp_test_seam_socket	(	int	domain,
		int	type,
		int	protocol
	)

Allows the test harness to control when socket() fails.

Parameters

[in]	domain	Socket domain.
[in]	type	Socket type.
[in]	protocol	Socket protocol.

Return values

!(-1)	The file descriptor for the new socket.
-1	Failed to create the socket.

Definition at line 606 of file seams.c.

References g_smtp_test_err_socket_ctr, smtp_test_seam_dec_err_ctr(), and socket.

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

Here is the call graph for this function:

◆ smtp_test_seam_sprintf()

int smtp_test_seam_sprintf	(	char *	s,
		const char *	format,
			...
	)

Allows the test harness to control when sprintf() fails.

Parameters

[in]	s	Buffer to store the output contents to.
[in]	format	Format string defined in sprintf().

Return values

>=0	Number of bytes copied to `s`, excluding the null-terminator.
<0	Output or formatting error.

Definition at line 771 of file seams.c.

References g_smtp_test_err_sprintf_ctr, g_smtp_test_err_sprintf_rc, and smtp_test_seam_dec_err_ctr().

                                                {
   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;
 }

Here is the call graph for this function:

◆ smtp_test_seam_ssl_connect()

int smtp_test_seam_ssl_connect ( SSL * ssl )

Allows the test harness to control when SSL_connect() fails.

Parameters

[in] ssl OpenSSL handle.

Return values

1	TLS connection handshake successful.
<1	TLS connection handshake failed.

Definition at line 624 of file seams.c.

References g_smtp_test_err_ssl_connect_ctr, smtp_test_seam_dec_err_ctr(), and SSL_connect.

                                     {
   if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_ssl_connect_ctr)){
     return 0;
   }
   return SSL_connect(ssl);
 }

Here is the call graph for this function:

◆ smtp_test_seam_ssl_ctx_new()

SSL_CTX* smtp_test_seam_ssl_ctx_new ( const SSL_METHOD * method )

Allows the test harness to control when SSL_CTX_new() fails.

Parameters

[in] method TLS connection method.

Return values

SSL_CTX*	Pointer to new TLS context.
NULL	Failed to create new TLS context.

Definition at line 639 of file seams.c.

References g_smtp_test_err_ssl_ctx_new_ctr, smtp_test_seam_dec_err_ctr(), and SSL_CTX_new.

                                                     {
   if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_ssl_ctx_new_ctr)){
     return NULL;
   }
   return SSL_CTX_new(method);
 }

Here is the call graph for this function:

◆ smtp_test_seam_ssl_do_handshake()

int smtp_test_seam_ssl_do_handshake ( SSL * ssl )

Allows the test harness to control when SSL_do_handshake() fails.

Parameters

[in] ssl OpenSSL handle.

Return values

1	TLS handshake successful.
<1	TLS handshake failed.

Definition at line 654 of file seams.c.

References g_smtp_test_err_ssl_do_handshake_ctr, smtp_test_seam_dec_err_ctr(), and SSL_do_handshake.

                                          {
   if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_ssl_do_handshake_ctr)){
     return 0;
   }
   return SSL_do_handshake(ssl);
 }

Here is the call graph for this function:

◆ smtp_test_seam_ssl_get_peer_certificate()

X509* smtp_test_seam_ssl_get_peer_certificate ( const SSL * ssl )

Allows the test harness to control when SSL_get_peer_certificate() fails.

Parameters

[in] ssl OpenSSL handle.

Return values

X509*	Peer certficate which must get freed by using X509_free().
NULL	Failed to get the peer certificate.

Definition at line 669 of file seams.c.

References g_smtp_test_err_ssl_get_peer_certificate_ctr, smtp_test_seam_dec_err_ctr(), and SSL_get_peer_certificate.

                                                        {
   if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_ssl_get_peer_certificate_ctr)){
     return NULL;
   }
   return SSL_get_peer_certificate(ssl);
 }

Here is the call graph for this function:

◆ smtp_test_seam_ssl_new()

SSL* smtp_test_seam_ssl_new ( SSL_CTX * ctx )

Allows the test harness to control when SSL_new() fails.

Parameters

[in] ctx OpenSSL TLS context.

Return values

SSL*	Pointer to a new TLS context.
NULL	Failed to create new TLS context.

Definition at line 709 of file seams.c.

References g_smtp_test_err_ssl_new_ctr, smtp_test_seam_dec_err_ctr(), and SSL_new.

                                     {
   if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_ssl_new_ctr)){
     return NULL;
   }
   return SSL_new(ctx);
 }

Here is the call graph for this function:

◆ smtp_test_seam_ssl_read()

int smtp_test_seam_ssl_read	(	SSL *	ssl,
		void *	buf,
		int	num
	)

Allows the test harness to control when SSL_read() fails.

Parameters

[in]	ssl	OpenSSL TLS object.
[in]	buf	Store received data in this buffer.
[in]	num	Number of bytes in `buf`.

Return values

>0	Number of bytes successfully read from the TLS connection.
<=0	Failed to read bytes on the TLS connection.

Definition at line 726 of file seams.c.

References g_smtp_test_err_recv_bytes, g_smtp_test_err_ssl_read_ctr, smtp_test_seam_dec_err_ctr(), SSL_read, and strlen.

                                 {
   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);
 }

Here is the call graph for this function:

◆ smtp_test_seam_ssl_write()

int smtp_test_seam_ssl_write	(	SSL *	ssl,
		const void *	buf,
		int	num
	)

Allows the test harness to control when SSL_write() fails.

Parameters

[in]	ssl	OpenSSL TLS object.
[in]	buf	Data to write to the TLS connection.
[in]	num	Number of bytes in `buf`.

Return values

>0	Number of bytes successfully written to the TLS connection.
<=0	Failed to write bytes to the TLS connection.

Definition at line 753 of file seams.c.

References g_smtp_test_err_ssl_write_ctr, smtp_test_seam_dec_err_ctr(), and SSL_write.

                                  {
   if(smtp_test_seam_dec_err_ctr(&g_smtp_test_err_ssl_write_ctr)){
     return -1;
   }
   return SSL_write(ssl, buf, num);
 }

Here is the call graph for this function:

◆ smtp_test_seam_strlen()

size_t smtp_test_seam_strlen ( const char * s )

Allows the test harness to control the return value of strlen().

Parameters

[in] s Null-terminated string.

Returns: Length of s.

Definition at line 793 of file seams.c.

References g_smtp_test_strlen_custom_ret, g_smtp_test_strlen_ret_value, and strlen.

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

◆ smtp_test_seam_time()

time_t smtp_test_seam_time ( time_t * tloc )

Allows the test harness to control when time() fails.

Parameters

[out] tloc Buffer to hold the time_t results.

Return values

>=0	Time in seconds since the Epoch.
-1	Failed to store the time in `tloc`.

Definition at line 813 of file seams.c.

References g_smtp_test_time_custom_ret, g_smtp_test_time_ret_value, and time.

                                  {
   if(g_smtp_test_time_custom_ret){
     return g_smtp_test_time_ret_value;
   }
   return time(tloc);
 }

◆ smtp_test_seam_x509_check_host()

int smtp_test_seam_x509_check_host	(	X509 *	cert,
		const char *	name,
		size_t	namelen,
		unsigned int	flags,
		char **	peername
	)

Allows the test harness to control when X509_check_host() fails.

Parameters

[in]	cert	X509 certificate handle.
[in]	name	Server name.
[in]	namelen	Number of characters in `name` or 0 if null-terminated.
[in]	flags	Usually set to 0.
[in]	peername	Pointer to CN from certificate stored in this buffer if not NULL.

Return values

1	Successful host check.
0	Failed host check.
-1	Internal error.

Definition at line 690 of file seams.c.

References g_smtp_test_err_x509_check_host_ctr, smtp_test_seam_dec_err_ctr(), and X509_check_host.

                                                {
   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);
 }

Here is the call graph for this function:

◆ smtp_utf8_charlen()

size_t smtp_utf8_charlen ( char c )

Get the length in bytes of a UTF-8 character.

This consists of a very simple check and assumes the user provides a valid UTF-8 byte sequence. It gets the length from the first byte in the sequence and does not validate any other bytes in the character sequence or any other bits in the first byte of the character sequence.

Parameters

[in] c The first byte in a valid UTF-8 character sequence.

Return values

>0	Number of bytes for the current UTF-8 character sequence.
-1	Invalid byte sequence.

Definition at line 1078 of file smtp.c.

References SMTP_LINKAGE.

Referenced by smtp_str_has_nonascii_utf8(), smtp_strnlen_utf8(), and smtp_unit_test_all_smtp_utf8_charlen().

                          {
   unsigned char uc;
 
   uc = (unsigned char)c;
   if((uc & 0x80) == 0){         /* 0XXXXXXX */
     return 1;
   }
   else if((uc & 0xE0) == 0xC0){ /* 110XXXXX */
     return 2;
   }
   else if((uc & 0xF0) == 0xE0){ /* 1110XXXX */
     return 3;
   }
   else if((uc & 0xF8) == 0xF0){ /* 11110XXX */
     return 4;
   }
   else{                        /* invalid  */
     return 0;
   }
 }

Here is the caller graph for this function:

◆ smtp_write()

enum smtp_status_code smtp_write	(	struct smtp *const	smtp,
		const char *const	buf,
		size_t	len
	)

Send data to the SMTP server.

Writes a buffer of length len into either the unencrypted TCP socket or the TLS encrypted socket, depending on the current underlying mode of the socket.

Parameters

[in]	smtp	SMTP client context.
[in]	buf	Data to send to the SMTP server.
[in]	len	Number of bytes in buf.

Returns: See smtp_status_code.

Definition at line 1603 of file smtp.c.

References send, smtp_puts_dbg(), smtp_status_code_set(), SMTP_STATUS_SEND, smtp::sock, SSL_write, smtp::status_code, smtp::tls, and smtp::tls_on.

Referenced by smtp_puts(), and test_failure_misc().

                       {
   size_t bytes_to_send;
   long bytes_sent;
   const char *buf_offset;
   int ssl_bytes_to_send;
 
   smtp_puts_dbg(smtp, "Client", buf);
 
   bytes_to_send = len;
   buf_offset = buf;
   while(bytes_to_send){
     if(bytes_to_send > INT_MAX){
       return smtp_status_code_set(smtp, SMTP_STATUS_SEND);
     }
 
     if(smtp->tls_on){
 #ifdef SMTP_OPENSSL
       /* bytes_to_send <= INT_MAX */
       ssl_bytes_to_send = (int)bytes_to_send;
       bytes_sent = SSL_write(smtp->tls, buf_offset, ssl_bytes_to_send);
       if(bytes_sent <= 0){
         return smtp_status_code_set(smtp, SMTP_STATUS_SEND);
       }
 #else /* !(SMTP_OPENSSL) */
       /* unreachable */
       bytes_sent = 0;
       (void)ssl_bytes_to_send;
 #endif /* SMTP_OPENSSL */
     }
     else{
       bytes_sent = send(smtp->sock, buf_offset, bytes_to_send, 0);
       if(bytes_sent < 0){
         return smtp_status_code_set(smtp, SMTP_STATUS_SEND);
       }
     }
     bytes_to_send -= (size_t)bytes_sent;
     buf_offset += bytes_sent;
   }
 
   return smtp->status_code;
 }