SMTP client library. More...

#include <netinet/in.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>
#include <errno.h>
#include <limits.h>
#include <signal.h>
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <openssl/bio.h>
#include <openssl/err.h>
#include <openssl/ssl.h>
#include <openssl/x509.h>
#include <openssl/x509v3.h>
#include "smtp.h"

Include dependency graph for smtp.c:

Go to the source code of this file.

Data Structures
struct	smtp_address

struct	smtp_attachment

struct	smtp_header

struct	smtp

Macros
#define	SMTP_INTERNAL_DEFINE

#define	SMTP_LINKAGE static

#define	SMTP_GETDELIM_READ_SZ 1000

#define	SMTP_LINE_MAX 78

#define	SMTP_DATE_MAX_SZ (32 + 15)

#define	SMTP_MIME_BOUNDARY_LEN 15

#define	SMTP_FLAG_INVALID_MEMORY (enum smtp_flag)(0xFFFFFFFF)

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

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

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

static enum smtp_status_code	smtp_str_getdelimfd_read_timeout (struct smtp *const smtp)

static long	smtp_str_getdelimfd_read (struct str_getdelimfd const gdfd, void buf, size_t count)

static int	smtp_str_getdelimfd_search_delim (const char const buf, size_t buf_len, int delim, size_t const delim_pos)

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

SMTP_LINKAGE void	smtp_str_getdelimfd_free (struct str_getdelimfd *const gdfd)

static enum str_getdelim_retcode	smtp_str_getdelimfd_throw_error (struct str_getdelimfd *const gdfd)

SMTP_LINKAGE enum str_getdelim_retcode	smtp_str_getdelimfd (struct str_getdelimfd *const gdfd)

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

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

SMTP_LINKAGE char *	smtp_strdup (const char *s)

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

static void	smtp_base64_encode_block (const char const buf, size_t buf_block_sz, char const b64)

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

static size_t	smtp_base64_decode_block (const unsigned char const buf, unsigned char const decode)

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

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

SMTP_LINKAGE size_t	smtp_utf8_charlen (char c)

SMTP_LINKAGE int	smtp_str_has_nonascii_utf8 (const char *const s)

SMTP_LINKAGE size_t	smtp_strnlen_utf8 (const char *s, size_t maxlen)

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

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

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

SMTP_LINKAGE char *	smtp_ffile_get_contents (FILE stream, size_t bytes_read)

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

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

static void	smtp_puts_dbg (struct smtp const smtp, const char const prefix, const char *const str)

static enum str_getdelim_retcode	smtp_getline (struct smtp *const smtp)

static int	smtp_read_and_parse_code (struct smtp *const smtp)

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

static enum smtp_status_code	smtp_puts (struct smtp const smtp, const char const s)

static enum smtp_status_code	smtp_puts_terminate (struct smtp const smtp, const char const s)

static int	smtp_connect (struct smtp const smtp, const char const server, const char *const port)

static int	smtp_tls_init (struct smtp const smtp, const char const server)

static enum smtp_status_code	smtp_ehlo (struct smtp *const smtp)

static int	smtp_auth_plain (struct smtp const smtp, const char const user, const char *const pass)

static int	smtp_auth_login (struct smtp const smtp, const char const user, const char *const pass)

static int	smtp_auth_cram_md5 (struct smtp const smtp, const char const user, const char *const pass)

static void	smtp_set_read_timeout (struct smtp *const smtp, long seconds)

static enum smtp_status_code	smtp_initiate_handshake (struct smtp const smtp, const char const server, enum smtp_connection_security connection_security)

SMTP_LINKAGE int	smtp_date_rfc_2822 (char *const date)

static int	smtp_header_cmp_key (const void const v1, const void const v2)

static int	smtp_header_exists (const struct smtp const smtp, const char const key)

static void	smtp_gen_mime_boundary (char *const boundary)

static enum smtp_status_code	smtp_print_mime_header_and_body (struct smtp const smtp, const char const boundary, const char *const body_dd)

static enum smtp_status_code	smtp_print_mime_attachment (struct smtp const smtp, const char const boundary, const struct smtp_attachment *const attachment)

static enum smtp_status_code	smtp_print_mime_end (struct smtp const smtp, const char const boundary)

static enum smtp_status_code	smtp_print_mime_email (struct smtp const smtp, const char const body_dd)

static enum smtp_status_code	smtp_print_nomime_email (struct smtp const smtp, const char const body_dd)

static enum smtp_status_code	smtp_print_email (struct smtp const smtp, const char const body)

static enum smtp_status_code	smtp_print_header (struct smtp const smtp, const struct smtp_header const header)

static enum smtp_status_code	smtp_append_address_to_header (struct smtp const smtp, enum smtp_address_type address_type, const char const key)

static enum smtp_status_code	smtp_mail_envelope_header (struct smtp const smtp, const char const header, const struct smtp_address *const address)

static int	smtp_header_cmp (const void v1, const void v2)

SMTP_LINKAGE int	smtp_header_key_validate (const char *const key)

SMTP_LINKAGE int	smtp_header_value_validate (const char *const value)

SMTP_LINKAGE int	smtp_address_validate_email (const char *const email)

SMTP_LINKAGE int	smtp_address_validate_name (const char *const name)

SMTP_LINKAGE int	smtp_attachment_validate_name (const char *const name)

enum smtp_status_code	smtp_open (const char const server, const char const port, enum smtp_connection_security connection_security, enum smtp_flag flags, const char const cafile, struct smtp *smtp)

enum smtp_status_code	smtp_auth (struct smtp const smtp, enum smtp_authentication_method auth_method, const char const user, const char *const pass)

enum smtp_status_code	smtp_mail (struct smtp const smtp, const char const body)

enum smtp_status_code	smtp_close (struct smtp *smtp)

enum smtp_status_code	smtp_status_code_get (const struct smtp *const smtp)

enum smtp_status_code	smtp_status_code_clear (struct smtp *const smtp)

enum smtp_status_code	smtp_status_code_set (struct smtp *const smtp, enum smtp_status_code status_code)

const char *	smtp_status_code_errstr (enum smtp_status_code status_code)

enum smtp_status_code	smtp_header_add (struct smtp const smtp, const char const key, const char *const value)

void	smtp_header_clear_all (struct smtp *const smtp)

enum smtp_status_code	smtp_address_add (struct smtp const smtp, enum smtp_address_type type, const char const email, const char *const name)

void	smtp_address_clear_all (struct smtp *const smtp)

enum smtp_status_code	smtp_attachment_add_path (struct smtp const smtp, const char const name, const char *const path)

enum smtp_status_code	smtp_attachment_add_fp (struct smtp const smtp, const char const name, FILE *fp)

enum smtp_status_code	smtp_attachment_add_mem (struct smtp const smtp, const char const name, const void *const data, size_t datasz)

void	smtp_attachment_clear_all (struct smtp *const smtp)

Variables
static char	g_base64_encode_table []

static signed char	g_base64_decode_table []

static struct smtp	g_smtp_error

Detailed Description

SMTP client library.

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

Version: 1.00

This SMTP client library allows the user to send emails to an SMTP server. The user can include custom headers and MIME attachments.

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

Definition in file smtp.c.

Macro Definition Documentation

◆ SMTP_DATE_MAX_SZ

#define SMTP_DATE_MAX_SZ (32 + 15)

Maximum size of an RFC 2822 date string.

Thu, 21 May 1998 05:33:29 -0700
12345678901234567890123456789012
        10        20        30 32 (bytes)

Add more bytes to the 32 maximum size to silence compiler warning on the computed UTF offset.

Definition at line 2222 of file smtp.c.

Referenced by smtp_date_rfc_2822(), and smtp_mail().

◆ SMTP_FLAG_INVALID_MEMORY

#define SMTP_FLAG_INVALID_MEMORY (enum smtp_flag)(0xFFFFFFFF)

Special flag value for the SMTP context used to determine if the initial memory allocation failed to create the context.

Definition at line 2945 of file smtp.c.

Referenced by smtp_close().

◆ SMTP_GETDELIM_READ_SZ

#define SMTP_GETDELIM_READ_SZ 1000

Increment the read buffer size by this amount if the delimiter has not been found.

Definition at line 88 of file smtp.c.

Referenced by smtp_str_getdelimfd().

◆ SMTP_INTERNAL_DEFINE

#define SMTP_INTERNAL_DEFINE

Get access to the smtp_result_code and smtp_command definitions.

Definition at line 59 of file smtp.c.

◆ SMTP_LINE_MAX

#define SMTP_LINE_MAX 78

Email header lines should have no more than 78 characters and must not be more than 998 characters.

Definition at line 1218 of file smtp.c.

Referenced by smtp_attachment_add_mem(), and smtp_print_header().

◆ SMTP_LINKAGE

#define SMTP_LINKAGE static

When not testing, all functions should have static linkage except for those in the header.

Definition at line 81 of file smtp.c.

Referenced by smtp_address_validate_email(), smtp_address_validate_name(), smtp_base64_decode(), smtp_base64_decode_block(), smtp_base64_encode_block(), smtp_bin2hex(), smtp_chunk_split(), smtp_ffile_get_contents(), smtp_file_get_contents(), smtp_fold_whitespace(), smtp_header_cmp(), smtp_header_key_validate(), smtp_header_value_validate(), smtp_read_and_parse_code(), smtp_reallocarray(), smtp_si_add_size_t(), smtp_si_sub_size_t(), smtp_stpcpy(), smtp_str_getdelimfd(), smtp_str_getdelimfd_search_delim(), smtp_str_getdelimfd_set_line_and_buf(), smtp_str_getdelimfd_throw_error(), smtp_str_has_nonascii_utf8(), smtp_strdup(), smtp_strnlen_utf8(), and smtp_utf8_charlen().

◆ SMTP_MIME_BOUNDARY_LEN

#define SMTP_MIME_BOUNDARY_LEN 15

Minimum length of buffer required to hold the MIME boundary test: mimeXXXXXXXXXX 123456789012345 1 10 15 bytes

Definition at line 2370 of file smtp.c.

Referenced by smtp_gen_mime_boundary(), smtp_print_mime_attachment(), smtp_print_mime_email(), and smtp_print_mime_end().

Function Documentation

◆ smtp_address_add()

enum smtp_status_code smtp_address_add	(	struct smtp *const	smtp,
		enum smtp_address_type	type,
		const char *const	email,
		const char *const	name
	)

Add a FROM, TO, CC, or BCC address destination to this SMTP context.

Note: Some SMTP servers may reject over 100 recipients.

Parameters

[in]	smtp	SMTP client context.
[in]	type	See smtp_address_type.
[in]	email	The email address of the party. Must consist only of printable characters excluding the angle brackets (<) and (>).
[in]	name	Name or description of the party. Must consist only of printable characters, excluding the quote characters. If set to NULL or empty string, no name will get associated with this email.

Returns: See smtp_status_code.

Definition at line 3347 of file smtp.c.

References smtp::address_list, smtp_address::email, smtp_address::name, smtp::num_address, smtp_address_validate_email(), smtp_address_validate_name(), smtp_reallocarray(), smtp_si_add_size_t(), smtp_status_code_set(), SMTP_STATUS_NOMEM, SMTP_STATUS_OK, SMTP_STATUS_PARAM, smtp_strdup(), smtp::status_code, and smtp_address::type.

Referenced by SMTPMail::address_add(), mailx_send(), smtp_address_add_check(), and test_nossl_smtp().

                                         {
   struct smtp_address *new_address_list;
   struct smtp_address *new_address;
   size_t num_address_inc;
 
   if(smtp->status_code != SMTP_STATUS_OK){
     return smtp->status_code;
   }
 
   if(smtp_address_validate_email(email) < 0){
     return smtp_status_code_set(smtp, SMTP_STATUS_PARAM);
   }
 
   if(name && smtp_address_validate_name(name) < 0){
     return smtp_status_code_set(smtp, SMTP_STATUS_PARAM);
   }
 
   if(smtp_si_add_size_t(smtp->num_address, 1, &num_address_inc)){
     return smtp_status_code_set(smtp, SMTP_STATUS_NOMEM);
   }
 
   new_address_list = smtp_reallocarray(smtp->address_list,
                                        num_address_inc,
                                        sizeof(*new_address_list));
   if(new_address_list == NULL){
     return smtp_status_code_set(smtp, SMTP_STATUS_NOMEM);
   }
   new_address = &new_address_list[smtp->num_address];
 
   smtp->address_list = new_address_list;
 
   new_address->type = type;
   new_address->email = smtp_strdup(email);
   if(name){
     new_address->name = smtp_strdup(name);
   }
   else{
     new_address->name = NULL;
   }
   if(new_address->email == NULL ||
      (new_address->name == NULL && name)){
     free(new_address->email);
     free(new_address->name);
     return smtp_status_code_set(smtp, SMTP_STATUS_NOMEM);
   }
   smtp->num_address = num_address_inc;
 
   return smtp->status_code;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_address_clear_all()

void smtp_address_clear_all ( struct smtp *const smtp )

Free all memory related to the address list.

Parameters

[in] smtp SMTP client context.

Definition at line 3401 of file smtp.c.

References smtp::address_list, smtp_address::email, smtp_address::name, and smtp::num_address.

Referenced by SMTPMail::address_clear_all(), smtp_close(), smtp_func_test_all_address(), and smtp_func_test_all_names().

                                                {
   size_t i;
   struct smtp_address *address;
 
   for(i = 0; i < smtp->num_address; i++){
     address = &smtp->address_list[i];
     free(address->email);
     free(address->name);
   }
   free(smtp->address_list);
   smtp->address_list = NULL;
   smtp->num_address = 0;
 }

Here is the caller graph for this function:

◆ smtp_address_validate_email()

SMTP_LINKAGE 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()

SMTP_LINKAGE 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_append_address_to_header()

static enum smtp_status_code smtp_append_address_to_header	(	struct smtp *const	smtp,
		enum smtp_address_type	address_type,
		const char *const	key
	)

static

Take a FROM, TO, and CC address and add it into the email header list.

The following example shows what the final header might look like when the client sends an email to two CC addresses: Cc: mail1@example.com, mail2@example.com

Parameters

[in]	smtp	SMTP client context.
[in]	address_type	See smtp_address_type.
[in]	key	Header key value, for example, To From Cc.

Returns: See smtp_status_code.

Definition at line 2674 of file smtp.c.

References smtp::address_list, smtp_address::email, smtp_address::name, smtp::num_address, realloc, smtp_header_add(), smtp_si_add_size_t(), smtp_status_code_set(), SMTP_STATUS_NOMEM, smtp_stpcpy(), smtp::status_code, strlen, and smtp_address::type.

Referenced by smtp_mail().

                                                     {
   size_t i;
   size_t num_address_in_header;
   size_t header_value_sz;
   size_t name_slen;
   size_t email_slen;
   size_t concat_len;
   struct smtp_address *address;
   char *header_value;
   char *header_value_new;
   char *concat;
 
   num_address_in_header = 0;
   header_value_sz = 0;
   header_value = NULL;
   concat_len = 0;
   for(i = 0; i < smtp->num_address; i++){
     address = &smtp->address_list[i];
     if(address->type == address_type){
       name_slen = 0;
       if(address->name){
         name_slen = strlen(address->name);
       }
       email_slen = strlen(address->email);
 
       /*
        *                   ', "'      NAME     '" <'      EMAIL     >  \0
        * header_value_sz +=  3  +  name_slen  +  3  +  email_slen + 1 + 1
        */
       if(smtp_si_add_size_t(header_value_sz, name_slen, &header_value_sz) ||
          smtp_si_add_size_t(header_value_sz, email_slen, &header_value_sz) ||
          smtp_si_add_size_t(header_value_sz, 3 + 3 + 1 + 1, &header_value_sz)||
          (header_value_new = realloc(header_value,
                                      header_value_sz)) == NULL){
         free(header_value);
         return smtp_status_code_set(smtp, SMTP_STATUS_NOMEM);
       }
       header_value = header_value_new;
       concat = header_value + concat_len;
       if(num_address_in_header > 0){
         concat = smtp_stpcpy(concat, ", ");
       }
 
       if(name_slen){
         concat = smtp_stpcpy(concat, "\"");
         concat = smtp_stpcpy(concat, address->name);
         concat = smtp_stpcpy(concat, "\" ");
       }
       concat = smtp_stpcpy(concat, "<");
       concat = smtp_stpcpy(concat, address->email);
       concat = smtp_stpcpy(concat, ">");
       num_address_in_header += 1;
       concat_len = (size_t)(concat - header_value);
     }
   }
 
   if(header_value){
     smtp_header_add(smtp, key, header_value);
     free(header_value);
   }
   return smtp->status_code;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_attachment_add_fp()

enum smtp_status_code smtp_attachment_add_fp	(	struct smtp *const	smtp,
		const char *const	name,
		FILE *	fp
	)

Add an attachment using a file pointer.

See smtp_attachment_add_mem for more details.

Parameters

[in]	smtp	SMTP client context.
[in]	name	Filename of the attachment shown to recipients. Must consist only of printable ASCII characters, excluding the quote characters (') and (").
[in]	fp	File pointer already opened by the caller.

Returns: See smtp_status_code.

Definition at line 3439 of file smtp.c.

References smtp_attachment_add_mem(), smtp_ffile_get_contents(), smtp_status_code_set(), SMTP_STATUS_FILE, SMTP_STATUS_NOMEM, SMTP_STATUS_OK, and smtp::status_code.

Referenced by SMTPMail::attachment_add_fp(), smtp_func_test_attachment_fp(), and test_failure_attachment_add().

                                 {
   char *data;
   size_t bytes_read;
 
   if(smtp->status_code != SMTP_STATUS_OK){
     return smtp->status_code;
   }
 
   errno = 0;
   if((data = smtp_ffile_get_contents(fp, &bytes_read)) == NULL){
     if(errno == ENOMEM){
       return smtp_status_code_set(smtp, SMTP_STATUS_NOMEM);
     }
     return smtp_status_code_set(smtp, SMTP_STATUS_FILE);
   }
   smtp_attachment_add_mem(smtp, name, data, bytes_read);
   free(data);
   return smtp->status_code;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_attachment_add_mem()

enum smtp_status_code smtp_attachment_add_mem	(	struct smtp *const	smtp,
		const char *const	name,
		const void *const	data,
		size_t	datasz
	)

Add a MIME attachment to this SMTP context with the data retrieved from memory.

The attachment data will get base64 encoded before sending to the server.

Parameters

[in]	smtp	SMTP client context.
[in]	name	Filename of the attachment shown to recipients. Must consist only of printable ASCII characters, excluding the quote characters (') and (").
[in]	data	Raw attachment data stored in memory.
[in]	datasz	Number of bytes in `data`, or -1 if data null-terminated.

Returns: See smtp_status_code.

Definition at line 3462 of file smtp.c.

References smtp::attachment_list, smtp_attachment::b64_data, smtp_attachment::name, smtp::num_attachment, SIZE_MAX, smtp_attachment_validate_name(), smtp_base64_encode(), smtp_chunk_split(), SMTP_LINE_MAX, smtp_reallocarray(), smtp_si_add_size_t(), smtp_status_code_set(), SMTP_STATUS_NOMEM, SMTP_STATUS_OK, SMTP_STATUS_PARAM, smtp_strdup(), smtp::status_code, and strlen.

Referenced by SMTPMail::attachment_add_mem(), smtp_attachment_add_fp(), smtp_attachment_add_path(), smtp_func_test_attachment_long_text(), smtp_func_test_attachment_mem(), test_failure_attachment_add(), and test_smtp_open_default().

                                       {
   size_t num_attachment_inc;
   struct smtp_attachment *new_attachment_list;
   struct smtp_attachment *new_attachment;
   char *b64_encode;
 
   if(smtp->status_code != SMTP_STATUS_OK){
     return smtp->status_code;
   }
 
   if(smtp_attachment_validate_name(name) < 0){
     return smtp_status_code_set(smtp, SMTP_STATUS_PARAM);
   }
 
   if(datasz == SIZE_MAX){
     datasz = strlen(data);
   }
 
   if(smtp_si_add_size_t(smtp->num_attachment, 1, &num_attachment_inc) ||
      (new_attachment_list = smtp_reallocarray(
                               smtp->attachment_list,
                               num_attachment_inc,
                               sizeof(*new_attachment_list))) == NULL){
     return smtp_status_code_set(smtp, SMTP_STATUS_NOMEM);
   }
   smtp->attachment_list = new_attachment_list;
   new_attachment = &new_attachment_list[smtp->num_attachment];
 
   new_attachment->name = smtp_strdup(name);
   b64_encode = smtp_base64_encode(data, datasz);
   if(new_attachment->name == NULL || b64_encode == NULL){
     free(new_attachment->name);
     free(b64_encode);
     return smtp_status_code_set(smtp, SMTP_STATUS_NOMEM);
   }
 
   new_attachment->b64_data = smtp_chunk_split(b64_encode,
                                               SMTP_LINE_MAX,
                                               "\r\n");
   free(b64_encode);
   if(new_attachment->b64_data == NULL){
     free(new_attachment->name);
     return smtp_status_code_set(smtp, SMTP_STATUS_NOMEM);
   }
 
   smtp->num_attachment = num_attachment_inc;
   return smtp->status_code;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_attachment_add_path()

enum smtp_status_code smtp_attachment_add_path	(	struct smtp *const	smtp,
		const char *const	name,
		const char *const	path
	)

Add a file attachment from a path.

See smtp_attachment_add_mem for more details.

Parameters

[in]	smtp	SMTP client context.
[in]	name	Filename of the attachment shown to recipients. Must consist only of printable ASCII characters, excluding the quote characters (') and (").
[in]	path	Path to file.

Returns: See smtp_status_code.

Definition at line 3416 of file smtp.c.

References smtp_attachment_add_mem(), smtp_file_get_contents(), smtp_status_code_set(), SMTP_STATUS_FILE, SMTP_STATUS_NOMEM, SMTP_STATUS_OK, and smtp::status_code.

Referenced by SMTPMail::attachment_add_path(), mailx_send(), smtp_func_test_attachment_path(), smtp_func_test_attachment_pdf(), smtp_func_test_gmail_attachment(), and test_failure_attachment_add().

                                                 {
   char *data;
   size_t bytes_read;
 
   if(smtp->status_code != SMTP_STATUS_OK){
     return smtp->status_code;
   }
 
   errno = 0;
   if((data = smtp_file_get_contents(path, &bytes_read)) == NULL){
     if(errno == ENOMEM){
       return smtp_status_code_set(smtp, SMTP_STATUS_NOMEM);
     }
     return smtp_status_code_set(smtp, SMTP_STATUS_FILE);
   }
   smtp_attachment_add_mem(smtp, name, data, bytes_read);
   free(data);
   return smtp->status_code;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_attachment_clear_all()

void smtp_attachment_clear_all ( struct smtp *const smtp )

Remove all attachments from the SMTP client context.

Parameters

[in] smtp SMTP client context.

Definition at line 3515 of file smtp.c.

References smtp::attachment_list, smtp_attachment::b64_data, smtp_attachment::name, and smtp::num_attachment.

Referenced by SMTPMail::attachment_clear_all(), and smtp_close().

                                                   {
   size_t i;
   struct smtp_attachment *attachment;
 
   for(i = 0; i < smtp->num_attachment; i++){
     attachment = &smtp->attachment_list[i];
     free(attachment->name);
     free(attachment->b64_data);
   }
   free(smtp->attachment_list);
   smtp->attachment_list = NULL;
   smtp->num_attachment = 0;
 }

Here is the caller graph for this function:

◆ smtp_attachment_validate_name()

SMTP_LINKAGE 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_auth()

enum smtp_status_code smtp_auth	(	struct smtp *const	smtp,
		enum smtp_authentication_method	auth_method,
		const char *const	user,
		const char *const	pass
	)

Authenticate the user using one of the methods listed in smtp_authentication_method.

Parameters

[in]	smtp	SMTP client context.
[in]	auth_method	See smtp_authentication_method.
[in]	user	SMTP user name.
[in]	pass	SMTP password.

Returns: See smtp_status_code.

Definition at line 3026 of file smtp.c.

References SMTP_AUTH_CRAM_MD5, smtp_auth_cram_md5(), SMTP_AUTH_LOGIN, smtp_auth_login(), SMTP_AUTH_NONE, SMTP_AUTH_PLAIN, smtp_auth_plain(), SMTP_STATUS_AUTH, smtp_status_code_set(), SMTP_STATUS_OK, SMTP_STATUS_PARAM, and smtp::status_code.

Referenced by SMTPMail::auth(), mailx_send(), and smtp_auth_check().

                                  {
   int auth_rc;
 
   if(smtp->status_code != SMTP_STATUS_OK){
     return smtp->status_code;
   }
 
   if(auth_method == SMTP_AUTH_PLAIN){
     auth_rc = smtp_auth_plain(smtp, user, pass);
   }
   else if(auth_method == SMTP_AUTH_LOGIN){
     auth_rc = smtp_auth_login(smtp, user, pass);
   }
 #ifdef SMTP_OPENSSL
   else if(auth_method == SMTP_AUTH_CRAM_MD5){
     auth_rc = smtp_auth_cram_md5(smtp, user, pass);
   }
 #endif /* SMTP_OPENSSL */
   else if(auth_method == SMTP_AUTH_NONE){
     auth_rc = 0;
   }
   else{
     return smtp_status_code_set(smtp, SMTP_STATUS_PARAM);
   }
 
   if(auth_rc < 0){
     return smtp_status_code_set(smtp, SMTP_STATUS_AUTH);
   }
 
   return smtp->status_code;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_auth_cram_md5()

static int smtp_auth_cram_md5	(	struct smtp *const	smtp,
		const char *const	user,
		const char *const	pass
	)

static

Authenticate using the CRAM-MD5 method.

Send "AUTH CRAM-MD5<CR><NL>" to the server.
Decode the base64 challenge response from the server.
Do an MD5 HMAC on (2) using the account password as the key.
Convert the binary data in (3) to lowercase hex characters.
Construct the string: "<user> <(4)>".
Encode (5) into base64 format.
Send the final string from (6) to the server and check the response.

Parameters

[in]	smtp	SMTP client context.
[in]	user	SMTP account user name.
[in]	pass	SMTP account password.

Return values

0	Successfully authenticated.
-1	Failed to authenticate.

Definition at line 2037 of file smtp.c.

References smtp::gdfd, HMAC, str_getdelimfd::line, malloc, SIZE_MAX, SMTP_AUTH_CONTINUE, SMTP_AUTH_SUCCESS, smtp_base64_decode(), smtp_base64_encode(), smtp_bin2hex(), smtp_getline(), smtp_parse_cmd_line(), smtp_puts(), smtp_puts_terminate(), smtp_read_and_parse_code(), smtp_si_add_size_t(), SMTP_STATUS_OK, smtp_stpcpy(), smtp::status_code, STRING_GETDELIMFD_ERROR, strlen, and smtp_command::text.

Referenced by smtp_auth().

                                           {
   struct smtp_command cmd;
   unsigned char *challenge_decoded;
   size_t challenge_decoded_len;
   const char *key;
   int key_len;
   unsigned char hmac[EVP_MAX_MD_SIZE];
   unsigned int hmac_len;
   unsigned char *hmac_ret;
   char *challenge_hex;
   size_t user_len;
   size_t challenge_hex_len;
   char *auth_concat;
   char *concat;
   size_t auth_concat_len;
   char *b64_auth;
 
   /* (1) */
   if(smtp_puts(smtp, "AUTH CRAM-MD5\r\n") != SMTP_STATUS_OK){
     return -1;
   }
   if(smtp_getline(smtp) == STRING_GETDELIMFD_ERROR){
     return -1;
   }
   if(smtp_parse_cmd_line(smtp->gdfd.line, &cmd) != SMTP_AUTH_CONTINUE){
     return -1;
   }
 
   /* (2) */
   challenge_decoded_len = smtp_base64_decode(cmd.text,
                                              &challenge_decoded);
   if(challenge_decoded_len == SIZE_MAX){
     return -1;
   }
 
   /* (3) */
   key = pass;
   key_len = (int)strlen(pass);/*********************cast*/
   hmac_ret = HMAC(EVP_md5(),
                   key,
                   key_len,
                   challenge_decoded,
                   challenge_decoded_len,
                   hmac,
                   &hmac_len);
   free(challenge_decoded);
   if(hmac_ret == NULL){
     return -1;
   }
 
   /* (4) */
   challenge_hex = smtp_bin2hex(hmac, hmac_len);
   if(challenge_hex == NULL){
     return -1;
   }
 
   /* (5) */
   user_len = strlen(user);
   challenge_hex_len = strlen(challenge_hex);
   /* auth_concat_len = user_len + 1 + challenge_hex_len + 1 */
   if(smtp_si_add_size_t(user_len, challenge_hex_len, &auth_concat_len) ||
      smtp_si_add_size_t(auth_concat_len, 2, &auth_concat_len) ||
      (auth_concat = malloc(auth_concat_len)) == NULL){
     free(challenge_hex);
     return -1;
   }
   concat = smtp_stpcpy(auth_concat, user);
   concat = smtp_stpcpy(concat, " ");
   smtp_stpcpy(concat, challenge_hex);
   free(challenge_hex);
 
   /* (6) */
   b64_auth = smtp_base64_encode(auth_concat, auth_concat_len - 1);
   free(auth_concat);
   if(b64_auth == NULL){
     return -1;
   }
 
   /* (7) */
   smtp_puts_terminate(smtp, b64_auth);
   free(b64_auth);
   if(smtp->status_code != SMTP_STATUS_OK){
     return -1;
   }
 
   if(smtp_read_and_parse_code(smtp) != SMTP_AUTH_SUCCESS){
     return -1;
   }
   return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_auth_login()

static int smtp_auth_login	(	struct smtp *const	smtp,
		const char *const	user,
		const char *const	pass
	)

static

Authenticate using the LOGIN method.

Base64 encode the user name.
Send string from (1) as part of the login: "AUTH LOGIN <b64_username><CR><NL>".
Base64 encode the password and send that by itself on a separate line: "<b64_password><CR><NL>".

Parameters

[in]	smtp	SMTP client context.
[in]	user	SMTP account user name.
[in]	pass	SMTP account password.

Return values

0	Successfully authenticated.
-1	Failed to authenticate.

Definition at line 1966 of file smtp.c.

References malloc, SIZE_MAX, SMTP_AUTH_CONTINUE, SMTP_AUTH_SUCCESS, smtp_base64_encode(), smtp_puts(), smtp_puts_terminate(), smtp_read_and_parse_code(), smtp_si_add_size_t(), SMTP_STATUS_OK, smtp_stpcpy(), smtp::status_code, and strlen.

Referenced by smtp_auth().

                                        {
   char *b64_user;
   char *b64_pass;
   size_t b64_user_len;
   char *login_str;
   char *concat;
 
   /* (1) */
   if((b64_user = smtp_base64_encode(user, SIZE_MAX)) == NULL){
     return -1;
   }
 
   /* (2) */
   b64_user_len = strlen(b64_user);
   if(smtp_si_add_size_t(b64_user_len, 14, &b64_user_len) ||
      (login_str = malloc(b64_user_len)) == NULL){
     free(b64_user);
     return -1;
   }
   concat = smtp_stpcpy(login_str, "AUTH LOGIN ");
   concat = smtp_stpcpy(concat, b64_user);
   smtp_stpcpy(concat, "\r\n");
 
   free(b64_user);
   smtp_puts(smtp, login_str);
   free(login_str);
   if(smtp->status_code != SMTP_STATUS_OK){
      return -1;
    }
 
   if(smtp_read_and_parse_code(smtp) != SMTP_AUTH_CONTINUE){
     return -1;
   }
 
   /* (3) */
   if((b64_pass = smtp_base64_encode(pass, SIZE_MAX)) == NULL){
     return -1;
   }
   smtp_puts_terminate(smtp, b64_pass);
   free(b64_pass);
   if(smtp->status_code != SMTP_STATUS_OK){
     return -1;
   }
 
   if(smtp_read_and_parse_code(smtp) != SMTP_AUTH_SUCCESS){
     return -1;
   }
   return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_auth_plain()

static int smtp_auth_plain	(	struct smtp *const	smtp,
		const char *const	user,
		const char *const	pass
	)

static

Authenticate using the PLAIN method.

Set the text to the following format: "\0<user>\0<password>", or as shown in the format string: "\0%s\0%s", email, password.
Base64 encode the text from (1).
Send the constructed auth text from (2) to the server: "AUTH PLAIN <b64><CR><NL>".

Parameters

[in]	smtp	SMTP client context.
[in]	user	SMTP account user name.
[in]	pass	SMTP account password.

Return values

0	Successfully authenticated.
-1	Failed to authenticate.

Definition at line 1893 of file smtp.c.

References malloc, SMTP_AUTH_SUCCESS, smtp_base64_encode(), smtp_puts(), smtp_read_and_parse_code(), smtp_si_add_size_t(), SMTP_STATUS_OK, smtp_stpcpy(), smtp::status_code, and strlen.

Referenced by smtp_auth().

                                        {
   size_t user_len;
   size_t pass_len;
   char *login_str;
   size_t login_len;
   char *login_b64;
   size_t login_b64_len;
   char *login_send;
   char *concat;
 
   /* (1) */
   user_len = strlen(user);
   pass_len = strlen(pass);
   /* login_len = 1 + user_len + 1 + pass_len */
   if(smtp_si_add_size_t(user_len, pass_len, &login_len) ||
      smtp_si_add_size_t(login_len, 2, &login_len) ||
      (login_str = malloc(login_len)) == NULL){
     return -1;
   }
   login_str[0] = '\0';
   memcpy(&login_str[1], user, user_len);
   login_str[1 + user_len] = '\0';
   memcpy(&login_str[1 + user_len + 1], pass, pass_len);
 
   /* (2) */
   login_b64 = smtp_base64_encode(login_str, login_len);
   free(login_str);
   if(login_b64 == NULL){
     return -1;
   }
 
   /* (3) */
   login_b64_len = strlen(login_b64);
   if(smtp_si_add_size_t(login_b64_len, 14, &login_b64_len) ||
      (login_send = malloc(login_b64_len)) == NULL){
     free(login_b64);
     return -1;
   }
   concat = smtp_stpcpy(login_send, "AUTH PLAIN ");
   concat = smtp_stpcpy(concat, login_b64);
   smtp_stpcpy(concat, "\r\n");
 
   free(login_b64);
   smtp_puts(smtp, login_send);
   free(login_send);
   if(smtp->status_code != SMTP_STATUS_OK){
     return -1;
   }
 
   if(smtp_read_and_parse_code(smtp) != SMTP_AUTH_SUCCESS){
     return -1;
   }
   return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_base64_decode()

SMTP_LINKAGE 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_decode_block()

static size_t smtp_base64_decode_block	(	const unsigned char *const	buf,
		unsigned char *const	decode
	)

static

Decodes a base64 block of up to four bytes at a time.

Parameters

[in]	buf	Buffer containing bytes to decode.
[out]	decode	Buffer for storing base64 decoded bytes.

Return values

>0	Length of the decoded block.
0	If the block contains invalid base64 data.

Definition at line 924 of file smtp.c.

References g_base64_decode_table, and SMTP_LINKAGE.

Referenced by smtp_base64_decode().

                                                      {
   size_t decode_block_len;
   size_t i;
   signed char decode_table[4];
   unsigned char outb[3];
 
   decode_block_len = 0;
   for(i = 0; i < 4; i++){
     if(buf[i] == '='){
       decode_table[i] = 0;
       continue;
     }
     decode_table[i] = g_base64_decode_table[buf[i]];
     if(decode_table[i] < 0){
       return 0;
     }
   }
 
   outb[0] = ((decode_table[0] << 2) & 0xFC) | ((decode_table[1] >> 4) & 0x03);
   outb[1] = ((decode_table[1] << 4) & 0xF0) | ((decode_table[2] >> 2) & 0x0F);
   outb[2] = ((decode_table[2] << 6) & 0xC0) | ((decode_table[3]     ) & 0x3F);
 
   decode[0] = outb[0];
   decode_block_len += 1;
 
   if(buf[2] == '='){
     decode[1] = '\0';
   }
   else{
     decode[1] = outb[1];
     decode_block_len += 1;
   }
 
   if(buf[3] == '='){
     decode[2] = '\0';
   }
   else{
     decode[2] = outb[2];
     decode_block_len += 1;
   }
 
   return decode_block_len;
 }

Here is the caller graph for this function:

◆ smtp_base64_encode()

SMTP_LINKAGE 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_base64_encode_block()

static void smtp_base64_encode_block	(	const char *const	buf,
		size_t	buf_block_sz,
		char *const	b64
	)

static

Encode a single block of binary data into base64.

Parameters

[in]	buf	Buffer with data to encode.
[in]	buf_block_sz	Number of bytes in buf to encode (min 1, max 3).
[out]	b64	Pointer to buffer with at least 4 bytes for storing the base64 encoded result.

Definition at line 792 of file smtp.c.

References g_base64_encode_table, and SMTP_LINKAGE.

Referenced by smtp_base64_encode().

                                          {
   unsigned char inb[3] = {0};
   unsigned char in_idx[4] = {0};
   char outb[5] = {'=', '=', '=', '=', '\0'};
   size_t i;
 
   memcpy(inb, buf, buf_block_sz);
 
   in_idx[0] = ((inb[0] >> 2))                         & 0x3F;
   in_idx[1] = ((inb[0] << 4) | ((inb[1] >> 4) & 0xF)) & 0x3F;
   in_idx[2] = ((inb[1] << 2) | ((inb[2] >> 6) & 0x3)) & 0x3F;
   in_idx[3] = ((inb[2]     ))                         & 0x3F;
   for(i = 0; i < 4; i++){
     if(i < buf_block_sz + 1){
       outb[i] = g_base64_encode_table[in_idx[i]];
     }
     b64[i] = outb[i];
   }
 }

Here is the caller graph for this function:

◆ smtp_bin2hex()

SMTP_LINKAGE 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()

SMTP_LINKAGE 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_close()

enum smtp_status_code smtp_close ( struct smtp * smtp )

Close the SMTP connection and frees all resources held by the SMTP context.

Parameters

[in] smtp SMTP client context.

Returns: See smtp_status_code.

Definition at line 3168 of file smtp.c.

References close, smtp::flags, smtp::gdfd, smtp_address_clear_all(), smtp_attachment_clear_all(), SMTP_FLAG_INVALID_MEMORY, smtp_header_clear_all(), smtp_puts(), SMTP_STATUS_CLOSE, smtp_status_code_set(), SMTP_STATUS_OK, smtp_str_getdelimfd_free(), smtp::sock, smtp::status_code, smtp::tls, smtp::tls_ctx, and smtp::tls_on.

Referenced by SMTPMail::close(), mailx_send(), smtp_close_check(), smtp_func_test_server_secureserver(), and test_nossl_smtp().

                              {
   enum smtp_status_code status_code;
 
   status_code = smtp->status_code;
 
   if(smtp->flags == SMTP_FLAG_INVALID_MEMORY){
     return status_code;
   }
 
   if(smtp->sock != -1){
     /*
      * Do not error out if this fails because we still need to free the
      * SMTP client resources.
      */
     smtp->status_code = SMTP_STATUS_OK;
     smtp_puts(smtp, "QUIT\r\n");
 
 #ifdef SMTP_OPENSSL
     if(smtp->tls_on){
       SSL_free(smtp->tls);
       SSL_CTX_free(smtp->tls_ctx);
     }
 #endif /* SMTP_OPENSSL */
 
 #ifdef SMTP_IS_WINDOWS
     closesocket(smtp->sock);
     WSACleanup();
 #else /* POSIX */
     if(close(smtp->sock) < 0){
       if(smtp->status_code == SMTP_STATUS_OK){
         smtp_status_code_set(smtp, SMTP_STATUS_CLOSE);
       }
     }
 #endif /* SMTP_IS_WINDOWS */
   }
 
   smtp_str_getdelimfd_free(&smtp->gdfd);
   smtp_header_clear_all(smtp);
   smtp_address_clear_all(smtp);
   smtp_attachment_clear_all(smtp);
   if(status_code == SMTP_STATUS_OK){
     status_code = smtp->status_code;
   }
   free(smtp);
 
   return status_code;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_connect()

static int smtp_connect	(	struct smtp *const	smtp,
		const char *const	server,
		const char *const	port
	)

static

Connect to the server using a standard TCP socket.

This function handles the server name lookup to get an IP address for the server, and then to connect to that IP using a normal TCP connection.

Parameters

[in]	smtp	SMTP client context.
[in]	server	Mail server name or IP address.
[in]	port	Mail server port number.

Return values

0	Successfully connected to server.
-1	Failed to connect to server.

Definition at line 1703 of file smtp.c.

References close, connect, smtp::sock, and socket.

Referenced by smtp_open().

                                     {
   struct addrinfo hints;
   struct addrinfo *res0;
   struct addrinfo *res;
 
   /*
    * Windows requires initializing the socket library before we call any
    * socket functions.
    */
 #ifdef SMTP_IS_WINDOWS
   /* Windows global network socket data structure. */
   WSADATA wsa_data;
   if(WSAStartup(MAKEWORD(2, 2), &wsa_data) != 0){
     return -1;
   }
 #endif /* SMTP_IS_WINDOWS */
 
   memset(&hints, 0, sizeof(hints));
   hints.ai_family   = AF_UNSPEC;
   hints.ai_socktype = SOCK_STREAM;
   hints.ai_flags    = 0;
   hints.ai_protocol = IPPROTO_TCP;
 
   if(getaddrinfo(server, port, &hints, &res0) != 0){
     return -1;
   }
 
   for(res = res0; res; res = res->ai_next){
     smtp->sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
     if(smtp->sock < 0){
       continue;
     }
 
     if(connect(smtp->sock, res->ai_addr, res->ai_addrlen) < 0){
 #ifdef SMTP_IS_WINDOWS
       closesocket(smtp->sock);
 #else /* POSIX */
       close(smtp->sock);
 #endif /* SMTP_IS_WINDOWS */
       smtp->sock = -1;
     }
     else{
       break;
     }
   }
 
   freeaddrinfo(res0);
   if(smtp->sock < 0){
     return -1;
   }
 
   return 0;
 }

Here is the caller graph for this function:

◆ smtp_date_rfc_2822()

SMTP_LINKAGE 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_ehlo()

static enum smtp_status_code smtp_ehlo ( struct smtp *const smtp )

static

Send the EHLO command and parse through the responses.

Ignores all of the server extensions that get returned. If a server doesn't support an extension we need, then we should receive an error later on when we try to use that extension.

Parameters

[in] smtp SMTP client context.

Returns: See smtp_status_code.

Definition at line 1870 of file smtp.c.

References smtp_puts(), smtp_read_and_parse_code(), SMTP_STATUS_OK, and smtp::status_code.

Referenced by smtp_initiate_handshake().

                                   {
   if(smtp_puts(smtp, "EHLO smtp\r\n") == SMTP_STATUS_OK){
     smtp_read_and_parse_code(smtp);
   }
   return smtp->status_code;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_ffile_get_contents()

SMTP_LINKAGE 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()

SMTP_LINKAGE 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()

SMTP_LINKAGE 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()

SMTP_LINKAGE 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_gen_mime_boundary()

static void smtp_gen_mime_boundary ( char *const boundary )

static

Generate the MIME boundary text field and store it in a user-supplied buffer.

For example: mimeXXXXXXXXXX where each X gets set to a pseudo-random uppercase ASCII character.

This uses a simple pseudo-random number generator since we only care about preventing accidental boundary collisions.

Parameters

[out] boundary Buffer that has at least SMTP_MIME_BOUNDARY_LEN bytes.

Definition at line 2386 of file smtp.c.

References SMTP_MIME_BOUNDARY_LEN, and time.

Referenced by smtp_print_mime_email().

                                             {
   size_t i;
   unsigned int seed;
 
   seed = (unsigned int)time(NULL);
   srand(seed);
 
   strcpy(boundary, "mime");
   for(i = 4; i < SMTP_MIME_BOUNDARY_LEN - 1; i++){
     /* Modulo bias okay since we only need to prevent accidental collision. */
     boundary[i] = rand() % 26 + 'A';
   }
   boundary[SMTP_MIME_BOUNDARY_LEN - 1] = '\0';
 }

Here is the caller graph for this function:

◆ smtp_getline()

static enum str_getdelim_retcode smtp_getline ( struct smtp *const smtp )

static

Read a server response line.

Parameters

[in] smtp SMTP client context.

Returns: See str_getdelim_retcode.

Definition at line 1544 of file smtp.c.

References smtp::gdfd, str_getdelimfd::line, str_getdelimfd::line_len, smtp_puts_dbg(), smtp_status_code_set(), SMTP_STATUS_NOMEM, SMTP_STATUS_RECV, smtp_str_getdelimfd(), and STRING_GETDELIMFD_ERROR.

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

                                      {
   enum str_getdelim_retcode rc;
 
   errno = 0;
   rc = smtp_str_getdelimfd(&smtp->gdfd);
   if(errno == ENOMEM){
     smtp_status_code_set(smtp, SMTP_STATUS_NOMEM);
     return rc;
   }
   else if(rc == STRING_GETDELIMFD_ERROR){
     smtp_status_code_set(smtp, SMTP_STATUS_RECV);
     return STRING_GETDELIMFD_ERROR;
   }
 
   if(smtp->gdfd.line_len > 0){
     /* Remove the carriage-return character ('\r'). */
     smtp->gdfd.line[smtp->gdfd.line_len - 1] = '\0';
     smtp_puts_dbg(smtp, "Server", smtp->gdfd.line);
   }
   return rc;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_header_add()

enum smtp_status_code smtp_header_add	(	struct smtp *const	smtp,
		const char *const	key,
		const char *const	value
	)

Add a key/value header to the header list in the SMTP context.

If adding a header with an existing key, this will insert instead of replacing the existing header. See smtp_header_clear_all.

See smtp_mail when overriding the default 'Content-Type' header.

Parameters

[in]	smtp	SMTP client context.
[in]	key	Key name for new header. It must consist only of printable US-ASCII characters except colon.
[in]	value	Value for new header. It must consist only of printable US-ASCII, space, or horizontal tab. If set to NULL, this will prevent the header from printing out.

Returns: See smtp_status_code.

Definition at line 3278 of file smtp.c.

References smtp::header_list, smtp_header::key, smtp::num_headers, smtp_header_cmp(), smtp_header_key_validate(), smtp_header_value_validate(), smtp_reallocarray(), smtp_si_add_size_t(), smtp_status_code_set(), SMTP_STATUS_NOMEM, SMTP_STATUS_OK, SMTP_STATUS_PARAM, smtp_strdup(), smtp::status_code, and smtp_header::value.

Referenced by SMTPMail::header_add(), mailx_send(), smtp_append_address_to_header(), smtp_header_add_check(), smtp_mail(), and test_nossl_smtp().

                                         {
   struct smtp_header *new_header_list;
   struct smtp_header *new_header;
   size_t num_headers_inc;
 
   if(smtp->status_code != SMTP_STATUS_OK){
     return smtp->status_code;
   }
 
   if(smtp_header_key_validate(key) < 0){
     return smtp_status_code_set(smtp, SMTP_STATUS_PARAM);
   }
 
   if(value && smtp_header_value_validate(value) < 0){
     return smtp_status_code_set(smtp, SMTP_STATUS_PARAM);
   }
 
   if(smtp_si_add_size_t(smtp->num_headers, 1, &num_headers_inc) ||
      (new_header_list = smtp_reallocarray(
                           smtp->header_list,
                           num_headers_inc,
                           sizeof(*smtp->header_list))) == NULL){
     return smtp_status_code_set(smtp, SMTP_STATUS_NOMEM);
   }
   smtp->header_list = new_header_list;
   new_header = &smtp->header_list[smtp->num_headers];
 
   new_header->key = smtp_strdup(key);
   if(value){
     new_header->value = smtp_strdup(value);
   }
   else{
     new_header->value = NULL;
   }
   if(new_header->key == NULL ||
      (new_header->value == NULL && value)){
     free(new_header->key);
     free(new_header->value);
     return smtp_status_code_set(smtp, SMTP_STATUS_NOMEM);
   }
 
   smtp->num_headers = num_headers_inc;
 
   qsort(smtp->header_list,
         smtp->num_headers,
         sizeof(*smtp->header_list),
         smtp_header_cmp);
 
   return smtp->status_code;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_header_clear_all()

void smtp_header_clear_all ( struct smtp *const smtp )

Free all memory related to email headers.

Parameters

[in] smtp SMTP client context.

Definition at line 3332 of file smtp.c.

References smtp::header_list, smtp_header::key, smtp::num_headers, and smtp_header::value.

Referenced by SMTPMail::header_clear_all(), smtp_close(), smtp_func_test_all_address(), smtp_func_test_all_names(), smtp_func_test_all_nodebug(), smtp_func_test_header_custom_date(), smtp_func_test_header_long(), smtp_func_test_header_null_no_date(), smtp_func_test_html(), and smtp_func_test_html_with_plaintext().

                                               {
   size_t i;
   struct smtp_header *header;
 
   for(i = 0; i < smtp->num_headers; i++){
     header = &smtp->header_list[i];
     free(header->key);
     free(header->value);
   }
   free(smtp->header_list);
   smtp->header_list = NULL;
   smtp->num_headers = 0;
 }

Here is the caller graph for this function:

◆ smtp_header_cmp()

static int smtp_header_cmp	(	const void *	v1,
		const void *	v2
	)

static

Comparison function for qsort which sorts headers alphabetically based on the key.

Parameters

[in]	v1	The first smtp_header to compare.
[in]	v2	The second smtp_header to compare.

Return values

0	If the keys match.
!0	If the keys do not match.

Definition at line 2802 of file smtp.c.

References smtp_header::key, and SMTP_LINKAGE.

Referenced by smtp_header_add().

                                {
   const struct smtp_header *header1;
   const struct smtp_header *header2;
 
   header1 = v1;
   header2 = v2;
   return strcmp(header1->key, header2->key);
 }

Here is the caller graph for this function:

◆ smtp_header_cmp_key()

static int smtp_header_cmp_key	(	const void *const	v1,
		const void *const	v2
	)

static

Search function used by bsearch, allowing the caller to check for headers with existing keys.

Parameters

v1	String to search for in the list.
v2	The smtp_header to compare.

Return values

0	If the keys match.
!0	If the keys do not match.

Definition at line 2333 of file smtp.c.

References smtp_header::key.

Referenced by smtp_header_exists().

                                          {
   const char *key;
   const struct smtp_header *header2;
 
   key = v1;
   header2 = v2;
   return strcmp(key, header2->key);
 }

Here is the caller graph for this function:

◆ smtp_header_exists()

static int smtp_header_exists	(	const struct smtp *const	smtp,
		const char *const	key
	)

static

Determine if the header key has already been defined in this context.

Parameters

[in]	smtp	SMTP client context.
[in]	key	Header key value to search for.

Return values

1	If the header already exists in this context.
0	If the header does not exist in this context.

Definition at line 2352 of file smtp.c.

References smtp::header_list, smtp::num_headers, and smtp_header_cmp_key().

Referenced by smtp_mail(), and smtp_print_email().

                                          {
   if(bsearch(key,
              smtp->header_list,
              smtp->num_headers,
              sizeof(*smtp->header_list),
              smtp_header_cmp_key) == NULL){
     return 0;
   }
   return 1;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_header_key_validate()

SMTP_LINKAGE 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()

SMTP_LINKAGE 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_initiate_handshake()

static enum smtp_status_code smtp_initiate_handshake	(	struct smtp *const	smtp,
		const char *const	server,
		enum smtp_connection_security	connection_security
	)

static

Perform a handshake with the SMTP server which includes optionally setting up TLS and sending the EHLO greeting.

At this point, the client has already connected to the SMTP server through its socket connection. In this function, the client will:

Optionally convert the connection to TLS (SMTP_SECURITY_TLS).
Read the initial server greeting.
Send an EHLO to the server.
Optionally initiate STARTTLS and resend the EHLO (SMTP_SECURITY_STARTTLS).

Parameters

[in]	smtp	SMTP client context.
[in]	server	Server name or IP address.
[in]	connection_security	See smtp_connection_security.

Returns: See smtp_status_code.

Definition at line 2161 of file smtp.c.

References smtp_ehlo(), smtp_getline(), smtp_puts(), smtp_read_and_parse_code(), SMTP_READY, SMTP_SECURITY_STARTTLS, SMTP_SECURITY_TLS, smtp_set_read_timeout(), smtp_status_code_set(), SMTP_STATUS_HANDSHAKE, SMTP_STATUS_OK, smtp_tls_init(), smtp::status_code, and STRING_GETDELIMFD_ERROR.

Referenced by smtp_open().

                                                                           {
   /* Eliminate unused warnings if not using SMTP_OPENSSL. */
   (void)server;
   (void)connection_security;
 
   /* (1) */
 #ifdef SMTP_OPENSSL
   if(connection_security == SMTP_SECURITY_TLS){
     if(smtp_tls_init(smtp, server) < 0){
       return smtp_status_code_set(smtp, SMTP_STATUS_HANDSHAKE);
     }
   }
 #endif /* SMTP_OPENSSL */
 
   /* (2) */
   /* Get initial 220 message - 5 minute timeout. */
   smtp_set_read_timeout(smtp, 60 * 5);
   if(smtp_getline(smtp) == STRING_GETDELIMFD_ERROR){
     return smtp->status_code;
   }
 
   /* (3) */
   if(smtp_ehlo(smtp) != SMTP_STATUS_OK){
     return smtp->status_code;
   }
 
   /* (4) */
 #ifdef SMTP_OPENSSL
   if(connection_security == SMTP_SECURITY_STARTTLS){
     if(smtp_puts(smtp, "STARTTLS\r\n") != SMTP_STATUS_OK){
       return smtp->status_code;
     }
     if(smtp_read_and_parse_code(smtp) != SMTP_READY){
       return smtp_status_code_set(smtp, SMTP_STATUS_HANDSHAKE);
     }
     if(smtp_tls_init(smtp, server) < 0){
       return smtp_status_code_set(smtp, SMTP_STATUS_HANDSHAKE);
     }
     if(smtp_ehlo(smtp) != SMTP_STATUS_OK){
       return smtp->status_code;
     }
   }
 #endif /* SMTP_OPENSSL */
 
   return smtp->status_code;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_mail()

enum smtp_status_code smtp_mail	(	struct smtp *const	smtp,
		const char *const	body
	)

Sends an email using the addresses, attachments, and headers defined in the current SMTP context.

The caller must call the smtp_open function prior to this.

The 'Date' header will automatically get generated here if it hasn't already been set using smtp_header_add.

If the application overrides the default 'Content-Type' header, then this function will output the body as raw data just below the email headers, and it will not output the attachments added using the smtp_attachment_add_* functions. In other words, the application must create its own MIME sections (if needed) when overriding the 'Content-Type' header.

Parameters

[in]	smtp	SMTP client context.
[in]	body	Null-terminated string to send in the email body.

Returns: See smtp_status_code.

Definition at line 3062 of file smtp.c.

References smtp::address_list, smtp::header_list, smtp::num_address, smtp::num_headers, SMTP_ADDRESS_CC, SMTP_ADDRESS_FROM, SMTP_ADDRESS_TO, smtp_append_address_to_header(), SMTP_BEGIN_MAIL, SMTP_DATE_MAX_SZ, smtp_date_rfc_2822(), SMTP_DONE, smtp_header_add(), smtp_header_exists(), smtp_mail_envelope_header(), smtp_print_email(), smtp_print_header(), smtp_puts(), smtp_read_and_parse_code(), smtp_set_read_timeout(), smtp_status_code_set(), SMTP_STATUS_DATE, SMTP_STATUS_OK, SMTP_STATUS_PARAM, SMTP_STATUS_SERVER_RESPONSE, smtp::status_code, and smtp_address::type.

Referenced by SMTPMail::mail(), mailx_send(), smtp_mail_check(), and test_nossl_smtp().

                                  {
   size_t i;
   int has_mail_from;
   struct smtp_address *address;
   char date[SMTP_DATE_MAX_SZ];
 
   if(smtp->status_code != SMTP_STATUS_OK){
     return smtp->status_code;
   }
 
   /* MAIL timeout 5 minutes. */
   smtp_set_read_timeout(smtp, 60 * 5);
   has_mail_from = 0;
   for(i = 0; i < smtp->num_address; i++){
     address = &smtp->address_list[i];
     if(address->type == SMTP_ADDRESS_FROM){
       if(smtp_mail_envelope_header(smtp,
                                    "MAIL FROM",
                                    address) != SMTP_STATUS_OK){
         return smtp->status_code;
       }
       has_mail_from = 1;
       break;
     }
   }
 
   if(!has_mail_from){
     return smtp_status_code_set(smtp, SMTP_STATUS_PARAM);
   }
 
   /* RCPT timeout 5 minutes. */
   smtp_set_read_timeout(smtp, 60 * 5);
 
   for(i = 0; i < smtp->num_address; i++){
     address = &smtp->address_list[i];
     if(address->type != SMTP_ADDRESS_FROM){
       if(smtp_mail_envelope_header(smtp,
                                    "RCPT TO",
                                    address) != SMTP_STATUS_OK){
         return smtp->status_code;
       }
     }
   }
 
   /* DATA timeout 2 minutes. */
   smtp_set_read_timeout(smtp, 60 * 2);
 
   if(smtp_puts(smtp, "DATA\r\n") != SMTP_STATUS_OK){
     return smtp->status_code;
   }
 
   /* 354 response to DATA must get returned before we can send the message. */
   if(smtp_read_and_parse_code(smtp) != SMTP_BEGIN_MAIL){
     return smtp_status_code_set(smtp, SMTP_STATUS_SERVER_RESPONSE);
   }
 
   if(!smtp_header_exists(smtp, "Date")){
     if(smtp_date_rfc_2822(date) < 0){
       return smtp_status_code_set(smtp, SMTP_STATUS_DATE);
     }
     if(smtp_header_add(smtp, "Date", date) != SMTP_STATUS_OK){
       return smtp->status_code;
     }
   }
 
   /* DATA block timeout 3 minutes. */
   smtp_set_read_timeout(smtp, 60 * 3);
 
   if(smtp_append_address_to_header(smtp,
                                    SMTP_ADDRESS_FROM,
                                    "From") != SMTP_STATUS_OK ||
      smtp_append_address_to_header(smtp,
                                    SMTP_ADDRESS_TO,
                                    "To") != SMTP_STATUS_OK ||
      smtp_append_address_to_header(smtp,
                                    SMTP_ADDRESS_CC,
                                    "Cc") != SMTP_STATUS_OK){
     return smtp->status_code;
   }
 
   for(i = 0; i < smtp->num_headers; i++){
     if(smtp_print_header(smtp, &smtp->header_list[i]) != SMTP_STATUS_OK){
       return smtp->status_code;
     }
   }
 
   if(smtp_print_email(smtp, body)){
     return smtp->status_code;
   }
 
   /* End of DATA segment. */
   if(smtp_puts(smtp, ".\r\n") != SMTP_STATUS_OK){
     return smtp->status_code;
   }
 
   /* DATA termination timeout 250 return code - 10 minutes. */
   smtp_set_read_timeout(smtp, 60 * 10);
   if(smtp_read_and_parse_code(smtp) != SMTP_DONE){
     return smtp_status_code_set(smtp, SMTP_STATUS_SERVER_RESPONSE);
   }
 
   return smtp->status_code;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_mail_envelope_header()

static enum smtp_status_code smtp_mail_envelope_header	(	struct smtp *const	smtp,
		const char *const	header,
		const struct smtp_address *const	address
	)

static

Send envelope MAIL FROM or RCPT TO header address.

Examples: MAIL FROM:<mail@example.com> RCPT TO:<mail@example.com>

Parameters

[in]	smtp	SMTP client context.
[in]	header	Either "MAIL FROM" or "RCPT TO".
[in]	address	See smtp_address -> email field.

Returns: See smtp_status_code.

Definition at line 2752 of file smtp.c.

References smtp_address::email, malloc, smtp_puts(), smtp_read_and_parse_code(), smtp_si_add_size_t(), smtp_status_code_set(), SMTP_STATUS_NOMEM, SMTP_STATUS_OK, smtp_stpcpy(), smtp_str_has_nonascii_utf8(), smtp::status_code, and strlen.

Referenced by smtp_mail().

                                                                    {
   const char *const SMTPUTF8 = " SMTPUTF8";
   const size_t SMTPUTF8_LEN = strlen(SMTPUTF8);
   size_t email_len;
   size_t bufsz;
   char *envelope_address;
   char *concat;
   const char *smtputf8_opt;
 
   email_len = strlen(address->email);
 
   /* bufsz = 14 + email_len + SMTPUTF8_LEN + 1 */
   if(smtp_si_add_size_t(email_len, SMTPUTF8_LEN + 14 + 1, &bufsz) ||
      (envelope_address = malloc(bufsz)) == NULL){
     return smtp_status_code_set(smtp, SMTP_STATUS_NOMEM);
   }
 
   smtputf8_opt = "";
   if(smtp_str_has_nonascii_utf8(address->email)){
     smtputf8_opt = SMTPUTF8;
   }
 
   concat = smtp_stpcpy(envelope_address, header);
   concat = smtp_stpcpy(concat, ":<");
   concat = smtp_stpcpy(concat, address->email);
   concat = smtp_stpcpy(concat, ">");
   concat = smtp_stpcpy(concat, smtputf8_opt);
   smtp_stpcpy(concat, "\r\n");
   smtp_puts(smtp, envelope_address);
   free(envelope_address);
 
   if(smtp->status_code != SMTP_STATUS_OK){
     return smtp->status_code;
   }
   smtp_read_and_parse_code(smtp);
   return smtp->status_code;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_open()

enum smtp_status_code smtp_open	(	const char *const	server,
		const char *const	port,
		enum smtp_connection_security	connection_security,
		enum smtp_flag	flags,
		const char *const	cafile,
		struct smtp **	smtp
	)

Open a connection to an SMTP server and return the context.

After successfully connecting and performing a handshake with the SMTP server, this will return a valid SMTP client context that the application can use in the other library functions.

This always returns a valid SMTP client context even if the server connection or memory allocation fails. In this scenario, the error status will continue to propagate to future library calls for the SMTP context while in this failure mode.

This function will ignore the SIGPIPE signal. Applications that require a handler for that signal should set it up after calling this function.

Parameters

[in]	server	Server name or IP address.
[in]	port	Server port number.
[in]	connection_security	See smtp_connection_security.
[in]	flags	See smtp_flag.
[in]	cafile	Path to certificate file, or NULL to use certificates in the default path.
[out]	smtp	Pointer to a new SMTP context. When finished, the caller must free this context using smtp_close.

Returns: See smtp_status_code.

Definition at line 2987 of file smtp.c.

References smtp::cafile, calloc, str_getdelimfd::delim, smtp::flags, g_smtp_error, smtp::gdfd, str_getdelimfd::getdelimfd_read, smtp_connect(), smtp_initiate_handshake(), smtp_status_code_get(), smtp_status_code_set(), SMTP_STATUS_CONNECT, SMTP_STATUS_HANDSHAKE, SMTP_STATUS_OK, smtp_str_getdelimfd_read(), smtp::sock, smtp::status_code, and str_getdelimfd::user_data.

Referenced by mailx_send(), SMTPMail::open(), smtp_func_test_all_address(), smtp_func_test_all_body(), smtp_func_test_all_names(), smtp_func_test_all_nodebug(), smtp_func_test_all_status_code_get(), smtp_func_test_all_write(), smtp_func_test_attachment_fp(), smtp_func_test_attachment_long_text(), smtp_func_test_attachment_mem(), smtp_func_test_attachment_path(), smtp_func_test_attachment_pdf(), smtp_func_test_gmail_attachment(), smtp_func_test_header_custom_date(), smtp_func_test_header_long(), smtp_func_test_header_null_no_date(), smtp_func_test_html(), smtp_func_test_html_with_plaintext(), smtp_func_test_send_email(), smtp_func_test_server_secureserver(), test_failure_address_add(), test_failure_attachment_add(), test_failure_close(), test_failure_header_add(), test_failure_misc(), test_failure_open(), test_failure_status_code_set(), test_failure_timeout(), test_nossl_smtp(), and test_smtp_open_default().

                              {
   struct smtp *snew;
 
   if((snew = calloc(1, sizeof(**smtp))) == NULL){
     *smtp = &g_smtp_error;
     return smtp_status_code_get(*smtp);
   }
   *smtp = snew;
 
   snew->flags                = flags;
   snew->sock                 = -1;
   snew->gdfd.delim           = '\n';
   snew->gdfd.getdelimfd_read = smtp_str_getdelimfd_read;
   snew->gdfd.user_data       = snew;
   snew->cafile               = cafile;
 
 #ifndef SMTP_IS_WINDOWS
   signal(SIGPIPE, SIG_IGN);
 #endif /* !(SMTP_IS_WINDOWS) */
 
   if(smtp_connect(snew, server, port) < 0){
     return smtp_status_code_set(*smtp, SMTP_STATUS_CONNECT);
   }
 
   if(smtp_initiate_handshake(snew,
                              server,
                              connection_security) != SMTP_STATUS_OK){
     return smtp_status_code_set(*smtp, SMTP_STATUS_HANDSHAKE);
   }
 
   return snew->status_code;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_parse_cmd_line()

SMTP_LINKAGE 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_print_email()

static enum smtp_status_code smtp_print_email	(	struct smtp *const	smtp,
		const char *const	body
	)

static

Send the email body to the mail server.

Parameters

[in,out]	smtp	SMTP client context.
[in]	body	Email body text.

Returns: See smtp_status_code.

Definition at line 2589 of file smtp.c.

References smtp_header_exists(), smtp_print_mime_email(), smtp_print_nomime_email(), smtp_status_code_set(), SMTP_STATUS_NOMEM, smtp_str_replace(), and smtp::status_code.

Referenced by smtp_mail().

                                         {
   char *body_double_dot;
 
   /*
    * Insert an extra dot for each line that begins with a dot. This will
    * prevent data in the body parameter from prematurely ending the DATA
    * segment.
    */
   if((body_double_dot = smtp_str_replace("\n.", "\n..", body)) == NULL){
     return smtp_status_code_set(smtp, SMTP_STATUS_NOMEM);
   }
 
   if(smtp_header_exists(smtp, "Content-Type")){
     smtp_print_nomime_email(smtp, body_double_dot);
   }
   else{
     smtp_print_mime_email(smtp, body_double_dot);
   }
   free(body_double_dot);
   return smtp->status_code;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_print_header()

static enum smtp_status_code smtp_print_header	(	struct smtp *const	smtp,
		const struct smtp_header *const	header
	)

static

Convert a header into an RFC 5322 formatted string and send it to the SMTP server.

This will adding proper line wrapping and indentation for long header lines.

Parameters

[in]	smtp	SMTP client context.
[in]	header	See smtp_header.

Returns: See smtp_status_code.

Definition at line 2624 of file smtp.c.

References smtp_header::key, malloc, smtp_fold_whitespace(), SMTP_LINE_MAX, smtp_puts_terminate(), smtp_si_add_size_t(), smtp_status_code_set(), SMTP_STATUS_NOMEM, smtp_stpcpy(), smtp::status_code, strlen, and smtp_header::value.

Referenced by smtp_mail().

                                                          {
   size_t key_len;
   size_t value_len;
   size_t concat_len;
   char *header_concat;
   char *concat;
   char *header_fmt;
 
   if(header->value == NULL){
     return smtp->status_code;
   }
 
   key_len = strlen(header->key);
   value_len = strlen(header->value);
 
   /* concat_len = key_len + 2 + value_len + 1 */
   if(smtp_si_add_size_t(key_len, value_len, &concat_len) ||
      smtp_si_add_size_t(concat_len, 3, &concat_len) ||
      (header_concat = malloc(concat_len)) == NULL){
     return smtp_status_code_set(smtp, SMTP_STATUS_NOMEM);
   }
   concat = smtp_stpcpy(header_concat, header->key);
   concat = smtp_stpcpy(concat, ": ");
   smtp_stpcpy(concat, header->value);
 
   header_fmt = smtp_fold_whitespace(header_concat, SMTP_LINE_MAX);
   free(header_concat);
   if(header_fmt == NULL){
     return smtp_status_code_set(smtp, SMTP_STATUS_NOMEM);
   }
 
   smtp_puts_terminate(smtp, header_fmt);
   free(header_fmt);
   return smtp->status_code;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_print_mime_attachment()

static enum smtp_status_code smtp_print_mime_attachment	(	struct smtp *const	smtp,
		const char *const	boundary,
		const struct smtp_attachment *const	attachment
	)

static

Print a MIME section containing an attachment.

Parameters

[in]	smtp	SMTP client context.
[in]	boundary	MIME boundary text.
[in]	attachment	See smtp_attachment.

Returns: See smtp_status_code.

Definition at line 2464 of file smtp.c.

References smtp_attachment::b64_data, malloc, smtp_attachment::name, SMTP_MIME_BOUNDARY_LEN, smtp_puts(), smtp_si_add_size_t(), smtp_status_code_set(), SMTP_STATUS_NOMEM, smtp_stpcpy(), smtp::status_code, and strlen.

Referenced by smtp_print_mime_email().

                                                                           {
   /* Buffer size for the static MIME text used below. */
   const size_t MIME_TEXT_BUFSZ = 1000;
   size_t name_len;
   size_t b64_data_len;
   size_t bufsz;
   char *mime_attach_text;
   char *concat;
 
   name_len = strlen(attachment->name);
   b64_data_len = strlen(attachment->b64_data);
   /*
    * bufsz = SMTP_MIME_BOUNDARY_LEN + name_len + b64_data_len + MIME_TEXT_BUFSZ
    */
   if(smtp_si_add_size_t(name_len, b64_data_len, &bufsz) ||
      smtp_si_add_size_t(bufsz,
                         SMTP_MIME_BOUNDARY_LEN + MIME_TEXT_BUFSZ,
                         &bufsz) ||
      (mime_attach_text = malloc(bufsz)) == NULL){
     return smtp_status_code_set(smtp, SMTP_STATUS_NOMEM);
   }
 
   concat = smtp_stpcpy(mime_attach_text,
                        "--");
   concat = smtp_stpcpy(concat,
                        boundary);
   concat = smtp_stpcpy(concat,
                        "\r\n"
                        "Content-Type: application/octet-stream\r\n"
                        "Content-Disposition: attachment; filename=\"");
   concat = smtp_stpcpy(concat,
                        attachment->name);
   concat = smtp_stpcpy(concat,
                        "\"\r\n"
                        "Content-Transfer-Encoding: base64\r\n"
                        "\r\n");
   concat = smtp_stpcpy(concat,
                        attachment->b64_data);
   smtp_stpcpy(concat,
               "\r\n"
               "\r\n");
   smtp_puts(smtp, mime_attach_text);
   free(mime_attach_text);
   return smtp->status_code;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_print_mime_email()

static enum smtp_status_code smtp_print_mime_email	(	struct smtp *const	smtp,
		const char *const	body_dd
	)

static

Send the main email body to the SMTP server.

This includes the MIME sections for the email body and attachments.

Parameters

[in]	smtp	SMTP client context.
[in]	body_dd	Email body with double dots added at the beginning of each line.

Returns: See smtp_status_code.

Definition at line 2543 of file smtp.c.

References smtp::attachment_list, smtp::num_attachment, smtp_gen_mime_boundary(), SMTP_MIME_BOUNDARY_LEN, smtp_print_mime_attachment(), smtp_print_mime_end(), smtp_print_mime_header_and_body(), SMTP_STATUS_OK, and smtp::status_code.

Referenced by smtp_print_email().

                                                 {
   char boundary[SMTP_MIME_BOUNDARY_LEN];
   size_t i;
   struct smtp_attachment *attachment;
 
   smtp_gen_mime_boundary(boundary);
 
   if(smtp_print_mime_header_and_body(smtp, boundary, body_dd) != SMTP_STATUS_OK){
     return smtp->status_code;
   }
 
   for(i = 0; i < smtp->num_attachment; i++){
     attachment = &smtp->attachment_list[i];
     if(smtp_print_mime_attachment(smtp,
                                   boundary,
                                   attachment) != SMTP_STATUS_OK){
       return smtp->status_code;
     }
   }
 
   return smtp_print_mime_end(smtp, boundary);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_print_mime_end()

static enum smtp_status_code smtp_print_mime_end	(	struct smtp *const	smtp,
		const char *const	boundary
	)

static

Prints double hyphen on both sides of the MIME boundary which indicates the end of the MIME sections.

Parameters

[in]	smtp	SMTP client context.
[in]	boundary	MIME boundary text.

Returns: See smtp_status_code and smtp_puts.

Definition at line 2521 of file smtp.c.

References SMTP_MIME_BOUNDARY_LEN, smtp_puts(), and smtp_stpcpy().

Referenced by smtp_print_mime_email().

                                                {
   char *concat;
   char mime_end[2 + SMTP_MIME_BOUNDARY_LEN + 4 + 1];
 
   concat = smtp_stpcpy(mime_end, "--");
   concat = smtp_stpcpy(concat, boundary);
   smtp_stpcpy(concat, "--\r\n");
   return smtp_puts(smtp, mime_end);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_print_mime_header_and_body()

static enum smtp_status_code smtp_print_mime_header_and_body	(	struct smtp *const	smtp,
		const char *const	boundary,
		const char *const	body_dd
	)

static

Print the MIME header and the MIME section containing the email body.

Parameters

[in]	smtp	SMTP client context.
[in]	boundary	MIME boundary text.
[in]	body_dd	Email body with double dots added at the beginning of each line.

Returns: See smtp_status_code.

Definition at line 2411 of file smtp.c.

References malloc, smtp_puts(), smtp_si_add_size_t(), smtp_status_code_set(), SMTP_STATUS_NOMEM, smtp_stpcpy(), smtp::status_code, and strlen.

Referenced by smtp_print_mime_email().

                                                           {
   /* Buffer size for the static MIME text used below. */
   const size_t MIME_TEXT_BUFSZ = 1000;
   size_t data_double_dot_len;
   char *data_header_and_body;
   char *concat;
 
   data_double_dot_len = strlen(body_dd);
   if(smtp_si_add_size_t(data_double_dot_len,
                         MIME_TEXT_BUFSZ,
                         &data_double_dot_len) ||
      (data_header_and_body = malloc(data_double_dot_len)) == NULL){
     return smtp_status_code_set(smtp, SMTP_STATUS_NOMEM);
   }
 
   concat = smtp_stpcpy(data_header_and_body,
                        "MIME-Version: 1.0\r\n"
                        "Content-Type: multipart/mixed; boundary=");
   concat = smtp_stpcpy(concat,
                        boundary);
   concat = smtp_stpcpy(concat,
                        "\r\n"
                        "\r\n"
                        "Multipart MIME message.\r\n"
                        "--");
   concat = smtp_stpcpy(concat,
                        boundary);
   concat = smtp_stpcpy(concat,
                        "\r\n"
                        "Content-Type: text/plain; charset=\"UTF-8\"\r\n"
                        "\r\n");
   concat = smtp_stpcpy(concat,
                        body_dd);
   smtp_stpcpy(concat,
               "\r\n"
               "\r\n");
 
   smtp_puts(smtp, data_header_and_body);
   free(data_header_and_body);
   return smtp->status_code;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_print_nomime_email()

static enum smtp_status_code smtp_print_nomime_email	(	struct smtp *const	smtp,
		const char *const	body_dd
	)

static

Print the email data provided by the user without MIME formatting.

Parameters

[in,out]	smtp	SMTP client context.
[in]	body_dd	Email body with double dots added at the beginning of each line.

Returns: See smtp_status_code.

Definition at line 2576 of file smtp.c.

References smtp_puts_terminate().

Referenced by smtp_print_email().

                                                   {
   return smtp_puts_terminate(smtp, body_dd);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_puts()

static enum smtp_status_code smtp_puts	(	struct smtp *const	smtp,
		const char *const	s
	)

static

Send a null-terminated string to the SMTP server.

Parameters

[in]	smtp	SMTP client context.
[in]	s	Null-terminated string to send to the SMTP server.

Returns: See smtp_status_code and smtp_write.

Definition at line 1655 of file smtp.c.

References smtp_write(), and strlen.

Referenced by smtp_auth_cram_md5(), smtp_auth_login(), smtp_auth_plain(), smtp_close(), smtp_ehlo(), smtp_initiate_handshake(), smtp_mail(), smtp_mail_envelope_header(), smtp_print_mime_attachment(), smtp_print_mime_end(), smtp_print_mime_header_and_body(), and smtp_puts_terminate().

                               {
   return smtp_write(smtp, s, strlen(s));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_puts_dbg()

static void smtp_puts_dbg	(	struct smtp *const	smtp,
		const char *const	prefix,
		const char *const	str
	)

static

Prints communication between the client and server to stderr only if the debug flag has been set.

Parameters

[in]	smtp	SMTP client context.
[in]	prefix	Print this prefix before the main debug line text.
[in]	str	Debug text to print out.

Definition at line 1512 of file smtp.c.

References smtp::flags, SMTP_DEBUG, and smtp_strdup().

Referenced by smtp_getline(), and smtp_write().

                                     {
   char *sdup;
   size_t i;
 
   if(smtp->flags & SMTP_DEBUG){
     if((sdup = smtp_strdup(str)) == NULL){
       return;
     }
 
     /* Remove carriage return and newline when printing to stderr. */
     for(i = 0; sdup[i]; i++){
       if(sdup[i] == '\r' || sdup[i] == '\n'){
         sdup[i] = ' ';
       }
     }
 
     if(fprintf(stderr, "[smtp %s]: %s\n", prefix, sdup) < 0){
       /* Do not care if this fails. */
     }
     free(sdup);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_puts_terminate()

static enum smtp_status_code smtp_puts_terminate	(	struct smtp *const	smtp,
		const char *const	s
	)

static

Same as smtp_puts except this function also appends the line terminating carriage return and newline bytes at the end of the string.

Parameters

[in]	smtp	SMTP client context.
[in]	s	Null-terminated string to send to the SMTP server.

Returns: See smtp_status_code and smtp_puts.

Definition at line 1669 of file smtp.c.

References malloc, smtp_puts(), smtp_si_add_size_t(), smtp_status_code_set(), SMTP_STATUS_NOMEM, smtp_stpcpy(), and strlen.

Referenced by smtp_auth_cram_md5(), smtp_auth_login(), smtp_print_header(), and smtp_print_nomime_email().

                                         {
   enum smtp_status_code rc;
   char *line;
   char *concat;
   size_t slen;
   size_t allocsz;
 
   slen = strlen(s);
   if(smtp_si_add_size_t(slen, 3, &allocsz) ||
      (line = malloc(allocsz)) == NULL){
     return smtp_status_code_set(smtp, SMTP_STATUS_NOMEM);
   }
   concat = smtp_stpcpy(line, s);
   smtp_stpcpy(concat, "\r\n");
   rc = smtp_puts(smtp, line);
   free(line);
   return rc;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_read_and_parse_code()

static int smtp_read_and_parse_code ( struct smtp *const smtp )

static

Loop through all of the server response lines until the last line, and then return the status code from the last response line.

Parameters

[in] smtp SMTP client context.

Returns: See smtp_result_code.

Definition at line 1574 of file smtp.c.

References smtp_command::code, smtp::gdfd, str_getdelimfd::line, smtp_command::more, smtp_getline(), SMTP_INTERNAL_ERROR, SMTP_LINKAGE, smtp_parse_cmd_line(), STRING_GETDELIMFD_DONE, and STRING_GETDELIMFD_ERROR.

Referenced by smtp_auth_cram_md5(), smtp_auth_login(), smtp_auth_plain(), smtp_ehlo(), smtp_initiate_handshake(), smtp_mail(), and smtp_mail_envelope_header().

                                                  {
   struct smtp_command cmd;
   enum str_getdelim_retcode rc;
 
   do{
     rc = smtp_getline(smtp);
     if(rc == STRING_GETDELIMFD_ERROR){
       return SMTP_INTERNAL_ERROR;
     }
 
     smtp_parse_cmd_line(smtp->gdfd.line, &cmd);
   }while (rc != STRING_GETDELIMFD_DONE && cmd.more);
 
   return cmd.code;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_reallocarray()

SMTP_LINKAGE 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_set_read_timeout()

static void smtp_set_read_timeout	(	struct smtp *const	smtp,
		long	seconds
	)

static

Set the timeout for the next socket read operation.

Parameters

[in]	smtp	SMTP client context.
[in]	seconds	Timeout in seconds.

Definition at line 2138 of file smtp.c.

References smtp::timeout_sec.

Referenced by smtp_initiate_handshake(), and smtp_mail().

                               {
   smtp->timeout_sec = seconds;
 }

Here is the caller graph for this function:

◆ smtp_si_add_size_t()

SMTP_LINKAGE 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()

SMTP_LINKAGE 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()

SMTP_LINKAGE 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_status_code_clear()

enum smtp_status_code smtp_status_code_clear ( struct smtp *const smtp )

Clear the current error code set in the SMTP client context.

Parameters

[in,out] smtp SMTP client context.

Returns: Previous error code before clearing.

Definition at line 3222 of file smtp.c.

References smtp_status_code_get(), smtp_status_code_set(), and SMTP_STATUS_OK.

Referenced by smtp_func_test_all_address(), smtp_func_test_all_status_code_get(), test_failure_address_add(), test_failure_attachment_add(), test_failure_header_add(), and test_failure_status_code_set().

                                                {
   enum smtp_status_code old_status;
 
   old_status = smtp_status_code_get(smtp);
   smtp_status_code_set(smtp, SMTP_STATUS_OK);
   return old_status;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_status_code_errstr()

const char* smtp_status_code_errstr ( enum smtp_status_code status_code )

Convert a standard SMTP client status code to a descriptive string.

Parameters

[in] status_code Status code returned from one of the other library functions.

Returns: String containing a description of the status_code. The caller must not free or modify this string.

Definition at line 3241 of file smtp.c.

References SMTP_STATUS__LAST.

Referenced by mailx_send(), smtp_unit_test_smtp_status_code_errstr(), and SMTPMailException::what().

                                                           {
   const char *const status_code_err_str[] = {
     /* SMTP_STATUS_OK */
     "Success",
     /* SMTP_STATUS_NOMEM */
     "Memory allocation failed",
     /* SMTP_STATUS_CONNECT */
     "Failed to connect to the mail server",
     /* SMTP_STATUS_HANDSHAKE */
     "Failed to handshake or negotiate a TLS connection with the server",
     /* SMTP_STATUS_AUTH */
     "Failed to authenticate with the given credentials",
     /* SMTP_STATUS_SEND */
     "Failed to send bytes to the server",
     /* SMTP_STATUS_RECV */
     "Failed to receive bytes from the server",
     /* SMTP_STATUS_CLOSE */
     "Failed to properly close a connection",
     /* SMTP_STATUS_SERVER_RESPONSE */
     "SMTP server sent back an unexpected status code",
     /* SMTP_STATUS_PARAM */
     "Invalid parameter",
     /* SMTP_STATUS_FILE */
     "Failed to read or open a local file",
     /* SMTP_STATUS_DATE */
     "Failed to get the local date and time",
     /* SMTP_STATUS__LAST */
     "Unknown error"
   };
 
   if((unsigned)status_code > SMTP_STATUS__LAST){
     status_code = SMTP_STATUS__LAST;
   }
   return status_code_err_str[status_code];
 }

Here is the caller graph for this function:

◆ smtp_status_code_get()

enum smtp_status_code smtp_status_code_get ( const struct smtp *const smtp )

Get the current status/error code.

Parameters

[in] smtp SMTP client context.

Returns: See smtp_status_code.

Definition at line 3217 of file smtp.c.

References smtp::status_code.

Referenced by smtp_func_test_all_status_code_get(), smtp_open(), smtp_status_code_clear(), SMTPMail::status_code_get(), and test_failure_status_code_set().

                                                    {
   return smtp->status_code;
 }

Here is the caller graph for this function:

◆ smtp_status_code_set()

enum smtp_status_code smtp_status_code_set	(	struct smtp *const	smtp,
		enum smtp_status_code	new_status_code
	)

Set the error status of the SMTP client context and return the same code.

This allows the caller to clear an error status to SMTP_STATUS_OK so that previous errors will stop propagating. However, this will only work correctly for clearing the SMTP_STATUS_PARAM and SMTP_STATUS_FILE errors. Do not use this to clear any other error codes.

Deprecated:: Use smtp_status_code_clear instead.

Parameters

[in]	smtp	SMTP client context.
[in]	new_status_code	See smtp_status_code.

Returns: See smtp_status_code.

Definition at line 3231 of file smtp.c.

References SMTP_STATUS__LAST, SMTP_STATUS_PARAM, and smtp::status_code.

Referenced by smtp_address_add(), smtp_append_address_to_header(), smtp_attachment_add_fp(), smtp_attachment_add_mem(), smtp_attachment_add_path(), smtp_auth(), smtp_close(), smtp_func_test_all_status_code_get(), smtp_getline(), smtp_header_add(), smtp_initiate_handshake(), smtp_mail(), smtp_mail_envelope_header(), smtp_open(), smtp_print_email(), smtp_print_header(), smtp_print_mime_attachment(), smtp_print_mime_header_and_body(), smtp_puts_terminate(), smtp_status_code_clear(), smtp_str_getdelimfd_read_timeout(), smtp_write(), SMTPMail::status_code_set(), test_failure_address_add(), test_failure_attachment_add(), test_failure_auth(), test_failure_header_add(), test_failure_mail(), and test_failure_status_code_set().

                                                        {
   if((unsigned)status_code >= SMTP_STATUS__LAST){
     return smtp_status_code_set(smtp, SMTP_STATUS_PARAM);
   }
   smtp->status_code = status_code;
   return status_code;
 }

Here is the caller graph for this function:

◆ smtp_stpcpy()

SMTP_LINKAGE 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()

SMTP_LINKAGE enum str_getdelim_retcode 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()

SMTP_LINKAGE 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_read()

static long smtp_str_getdelimfd_read	(	struct str_getdelimfd *const	gdfd,
		void *	buf,
		size_t	count
	)

static

This function gets called by the smtp_str_getdelimfd interface when it needs to read in more data.

It reads using either the plain socket connection if encryption not enabled, or it reads using OpenSSL if it has an active TLS connection.

Parameters

[in]	gdfd	See str_getdelimfd.
[out]	buf	Pointer to buffer for storing bytes read.
[in]	count	Maximum number of bytes to try reading.

Return values

>=0	Number of bytes read.
-1	Failed to read from the socket.

Definition at line 382 of file smtp.c.

References BIO_should_retry, recv, SMTP_STATUS_OK, smtp_str_getdelimfd_read_timeout(), smtp::sock, SSL_read, smtp::tls, smtp::tls_bio, smtp::tls_on, and str_getdelimfd::user_data.

Referenced by smtp_open().

                                       {
   struct smtp *smtp;
   long bytes_read;
 
   smtp = gdfd->user_data;
 
   if(smtp_str_getdelimfd_read_timeout(smtp) != SMTP_STATUS_OK){
     return -1;
   }
 
   bytes_read = 0;
   if(smtp->tls_on){
 #ifdef SMTP_OPENSSL
     do{
       /*
        * Count will never have a value greater than SMTP_GETDELIM_READ_SZ,
        * so we can safely convert this to an int.
        */
       bytes_read = SSL_read(smtp->tls, buf, (int)count);
     } while(bytes_read <= 0 && BIO_should_retry(smtp->tls_bio));
 #endif /* SMTP_OPENSSL */
   }
   else{
     bytes_read = recv(smtp->sock, buf, count, 0);
   }
   return bytes_read;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_str_getdelimfd_read_timeout()

static enum smtp_status_code smtp_str_getdelimfd_read_timeout ( struct smtp *const smtp )

static

Wait until more data has been made available on the socket read end.

Parameters

[in] smtp SMTP client context.

Return values

SMTP_STATUS_OK	If data available to read on the socket.
SMTP_STATUS_RECV	If the connection times out before any data appears on the socket.

Definition at line 352 of file smtp.c.

References select, smtp_status_code_set(), SMTP_STATUS_OK, SMTP_STATUS_RECV, smtp::sock, and smtp::timeout_sec.

Referenced by smtp_str_getdelimfd_read().

                                                          {
   fd_set readfds;
   struct timeval timeout;
   int sel_rc;
 
   FD_ZERO(&readfds);
   FD_SET(smtp->sock, &readfds);
   timeout.tv_sec  = smtp->timeout_sec;
   timeout.tv_usec = 0;
   sel_rc = select(smtp->sock + 1, &readfds, NULL, NULL, &timeout);
   if(sel_rc < 1){
     return smtp_status_code_set(smtp, SMTP_STATUS_RECV);
   }
   return SMTP_STATUS_OK;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_str_getdelimfd_search_delim()

static int smtp_str_getdelimfd_search_delim	(	const char *const	buf,
		size_t	buf_len,
		int	delim,
		size_t *const	delim_pos
	)

static

Find and return the location of the delimiter character in the search buffer.

This function gets used by the main socket parsing function which continually reads from the socket and expands the buffer until it encounters the expected delimiter. This function provides the logic to check for the delimiter character in order to simplify the code in the main parse function.

Parameters

[in]	buf	Search buffer used to find the delimiter.
[in]	buf_len	Number of bytes to search for in buf.
[in]	delim	The delimiter to search for in buf.
[out]	delim_pos	If delimiter found in buf, return the delimiter position in this parameter.

Return values

1	If the delimiter character found.
0	If the delimiter character not found.

Definition at line 431 of file smtp.c.

References SMTP_LINKAGE.

Referenced by smtp_str_getdelimfd().

                                                          {
   size_t i;
 
   *delim_pos = 0;
   for(i = 0; i < buf_len; i++){
     if(buf[i] == delim){
       *delim_pos = i;
       return 1;
     }
   }
   return 0;
 }

Here is the caller graph for this function:

◆ smtp_str_getdelimfd_set_line_and_buf()

SMTP_LINKAGE 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_getdelimfd_throw_error()

static enum str_getdelim_retcode smtp_str_getdelimfd_throw_error ( struct str_getdelimfd *const gdfd )

static

Free the str_getdelimfd and return the STRING_GETDELIMFD_ERROR error code.

Parameters

[in] gdfd See str_getdelimfd.

Returns: See str_getdelim_retcode.

Definition at line 507 of file smtp.c.

References SMTP_LINKAGE, smtp_str_getdelimfd_free(), and STRING_GETDELIMFD_ERROR.

Referenced by smtp_str_getdelimfd().

                                                                   {
   smtp_str_getdelimfd_free(gdfd);
   return STRING_GETDELIMFD_ERROR;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smtp_str_has_nonascii_utf8()

SMTP_LINKAGE 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()

SMTP_LINKAGE 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()

SMTP_LINKAGE 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()

SMTP_LINKAGE 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_tls_init()

static int smtp_tls_init	(	struct smtp *const	smtp,
		const char *const	server
	)

static

Initialize the TLS library and establish a TLS handshake with the server over the existing socket connection.

Parameters

[in]	smtp	SMTP client context.
[in]	server	Server name or IP address.

Return values

0	Successfully established a TLS connection with the server.
-1	Failed to establish a TLS connection with the server.

Definition at line 1770 of file smtp.c.

References BIO_new_socket, smtp::cafile, ERR_peek_error, smtp::flags, SMTP_NO_CERT_VERIFY, smtp::sock, SSL_connect, SSL_CTX_new, SSL_do_handshake, SSL_get_peer_certificate, SSL_new, smtp::tls, smtp::tls_bio, smtp::tls_ctx, smtp::tls_on, and X509_check_host.

Referenced by smtp_initiate_handshake().

                                        {
   X509 *X509_cert_peer;
 
   /* Do not need to check the return value since this always returns 1. */
   SSL_library_init();
 
   SSL_load_error_strings();
   ERR_load_BIO_strings();
   OpenSSL_add_all_algorithms();
 
   if((smtp->tls_ctx = SSL_CTX_new(SSLv23_client_method())) == NULL){
     return -1;
   }
 
   /* Disable SSLv2, SSLv3, and TLSv1.0. */
   SSL_CTX_set_options(smtp->tls_ctx,
                       SSL_OP_NO_SSLv2 |
                       SSL_OP_NO_SSLv3 |
                       SSL_OP_NO_TLSv1);
 
   SSL_CTX_set_mode(smtp->tls_ctx, SSL_MODE_AUTO_RETRY);
   if((smtp->flags & SMTP_NO_CERT_VERIFY) == 0){
     SSL_CTX_set_verify(smtp->tls_ctx, SSL_VERIFY_PEER, NULL);
   }
 
   /*
    * Set the path to the user-provided CA file or use the default cert paths
    * if not provided.
    */
   if(smtp->cafile){
     if(SSL_CTX_load_verify_locations(smtp->tls_ctx, smtp->cafile, NULL) != 1){
       SSL_CTX_free(smtp->tls_ctx);
       return -1;
     }
   }
   else{
     X509_STORE_set_default_paths(SSL_CTX_get_cert_store(smtp->tls_ctx));
     if(ERR_peek_error() != 0){
       SSL_CTX_free(smtp->tls_ctx);
       return -1;
     }
   }
 
   if((smtp->tls = SSL_new(smtp->tls_ctx)) == NULL){
     SSL_CTX_free(smtp->tls_ctx);
     return -1;
   }
 
   if((smtp->tls_bio = BIO_new_socket(smtp->sock, 0)) == NULL){
     SSL_CTX_free(smtp->tls_ctx);
     SSL_free(smtp->tls);
     return -1;
   }
 
   SSL_set_bio(smtp->tls, smtp->tls_bio, smtp->tls_bio);
   SSL_set_connect_state(smtp->tls);
   if(SSL_connect(smtp->tls) != 1){
     SSL_CTX_free(smtp->tls_ctx);
     SSL_free(smtp->tls);
     return -1;
   }
 
   if(SSL_do_handshake(smtp->tls) != 1){
     SSL_CTX_free(smtp->tls_ctx);
     SSL_free(smtp->tls);
     return -1;
   }
 
   /* Verify matching subject in certificate. */
   if((smtp->flags & SMTP_NO_CERT_VERIFY) == 0){
     if((X509_cert_peer = SSL_get_peer_certificate(smtp->tls)) == NULL){
       SSL_CTX_free(smtp->tls_ctx);
       SSL_free(smtp->tls);
       return -1;
     }
     if(X509_check_host(X509_cert_peer, server, 0, 0, NULL) != 1){
       SSL_CTX_free(smtp->tls_ctx);
       SSL_free(smtp->tls);
       return -1;
     }
     X509_free(X509_cert_peer);
   }
 
   smtp->tls_on = 1;
   return 0;
 }

Here is the caller graph for this function:

◆ smtp_utf8_charlen()

SMTP_LINKAGE 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()

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

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ g_base64_decode_table

signed char g_base64_decode_table[]

static

Initial value:

= {
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1, -1,
  62,                                     
  -1, -1, -1,
  63,                                     
  52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 
  -1, -1, -1, -1, -1, -1, -1,
   0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 
  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 
  20, 21, 22, 23, 24, 25,                 
  -1, -1, -1, -1, -1, -1,
  26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 
  36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 
  46, 47, 48, 49, 50, 51,                 
  -1, -1, -1, -1, -1
}

Lookup table used to decode base64 data.

For base64 encoding, every six bits have been encoded using only the ASCII characters from g_base64_encode_table. This table has entries which allow the reversal of that process. It has 128 entries which map over to the index value from the encoding table. If an indexing result ends up with -1 during the decoding process, then that indicates an invalid base64 character in the encoded data.

Definition at line 894 of file smtp.c.

Referenced by smtp_base64_decode_block().

◆ g_base64_encode_table

char g_base64_encode_table[]

static

Initial value:

= {
  'A','B','C','D','E','F','G','H','I','J',
  'K','L','M','N','O','P','Q','R','S','T',
  'U','V','W','X','Y','Z',
  'a','b','c','d','e','f','g','h','i','j',
  'k','l','m','n','o','p','q','r','s','t',
  'u','v','w','x','y','z',
  '0','1','2','3','4','5','6','7','8','9',
  '+','/'
}

Lookup table used to encode data into base64.

Base64 encoding takes six bits of data and encodes those bits using this table. Since 2^6 = 64, this array has 64 entries which maps directly from the 6 bit value into the corresponding array value.

Definition at line 772 of file smtp.c.

Referenced by smtp_base64_encode_block().

◆ g_smtp_error

struct smtp g_smtp_error

static

This error structure used for the single error case where we cannot initially allocate memory. This makes it easier to propagate any error codes when calling the other header functions because the caller will always get a valid SMTP structure returned.

Definition at line 2954 of file smtp.c.

Referenced by smtp_open().

Data Structures

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ SMTP_DATE_MAX_SZ

◆ SMTP_FLAG_INVALID_MEMORY

◆ SMTP_GETDELIM_READ_SZ

◆ SMTP_INTERNAL_DEFINE

◆ SMTP_LINE_MAX

◆ SMTP_LINKAGE

◆ SMTP_MIME_BOUNDARY_LEN

Function Documentation

◆ smtp_address_add()

◆ smtp_address_clear_all()

◆ smtp_address_validate_email()

◆ smtp_address_validate_name()

◆ smtp_append_address_to_header()

◆ smtp_attachment_add_fp()

◆ smtp_attachment_add_mem()

◆ smtp_attachment_add_path()

◆ smtp_attachment_clear_all()

◆ smtp_attachment_validate_name()

◆ smtp_auth()

◆ smtp_auth_cram_md5()

◆ smtp_auth_login()

◆ smtp_auth_plain()

◆ smtp_base64_decode()

◆ smtp_base64_decode_block()

◆ smtp_base64_encode()

◆ smtp_base64_encode_block()

◆ smtp_bin2hex()

◆ smtp_chunk_split()

◆ smtp_close()

◆ smtp_connect()

◆ smtp_date_rfc_2822()

◆ smtp_ehlo()

◆ smtp_ffile_get_contents()

◆ smtp_file_get_contents()

◆ smtp_fold_whitespace()

◆ smtp_fold_whitespace_get_offset()

◆ smtp_gen_mime_boundary()

◆ smtp_getline()

◆ smtp_header_add()

◆ smtp_header_clear_all()

◆ smtp_header_cmp()

◆ smtp_header_cmp_key()

◆ smtp_header_exists()

◆ smtp_header_key_validate()

◆ smtp_header_value_validate()

◆ smtp_initiate_handshake()

◆ smtp_mail()

◆ smtp_mail_envelope_header()

◆ smtp_open()

◆ smtp_parse_cmd_line()

◆ smtp_print_email()

◆ smtp_print_header()

◆ smtp_print_mime_attachment()

◆ smtp_print_mime_email()

◆ smtp_print_mime_end()

◆ smtp_print_mime_header_and_body()

◆ smtp_print_nomime_email()

◆ smtp_puts()

◆ smtp_puts_dbg()

◆ smtp_puts_terminate()

◆ smtp_read_and_parse_code()

◆ smtp_reallocarray()

◆ smtp_set_read_timeout()

◆ smtp_si_add_size_t()

◆ smtp_si_mul_size_t()

◆ smtp_si_sub_size_t()

◆ smtp_status_code_clear()

◆ smtp_status_code_errstr()

◆ smtp_status_code_get()

◆ smtp_status_code_set()

◆ smtp_stpcpy()

◆ smtp_str_getdelimfd()

◆ smtp_str_getdelimfd_free()

◆ smtp_str_getdelimfd_read()