adding files

16 files changed, 1263 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..4543fbf
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,4 @@
+build/
+compile_commands.json
+.cache/
+.clang-tidy
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..b35984b
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,35 @@
+cmake_minimum_required(VERSION 3.17.0)
+
+project(rssmail VERSION 1.0.0 LANGUAGES C)
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+find_package(LibXml2 REQUIRED)
+find_package(CURL REQUIRED)
+
+add_executable(rssmail
+  src/main.c
+  src/fetch.c
+  src/parse.c
+  src/mail.c
+  src/config.c
+  src/post.c)
+
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+  target_compile_options(rssmail PRIVATE -ggdb3 -fsanitize=address -fsanitize=undefined)
+  target_link_options(rssmail PRIVATE -no-pie -fsanitize=address -fsanitize=undefined)
+  target_compile_definitions(rssmail PRIVATE DEBUG RSSMAIL_SEND_TO_FILE)
+endif()
+
+# disabling logging may reduce binary size
+# target_compile_definitions(rssmail PRIVATE RSSMAIL_DISABLE_LOGGING)
+
+target_link_libraries(rssmail
+  PRIVATE
+  ${LIBXML2_LIBRARIES}
+  ${CURL_LIBRARIES})
+target_include_directories(rssmail
+  PRIVATE
+  "${CMAKE_CURRENT_SOURCE_DIR}/include"
+  ${LIBXML2_INCLUDE_DIRS}
+  ${CURL_INCLUDE_DIRS})
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..453eeed
--- /dev/null
+++ b/README.md
@@ -0,0 +1,70 @@
+# rssmail
+
+An RSS-to-email aggregator tool.
+
+The aim of this tool is to be simple to configure and run.
+
+## Usage
+```
+./rssmail <first.conf> [second.conf ...]
+```
+
+See example.conf for available configuration options and aliases.
+
+Configuration can be split across multiple files.  A use-case for this might be one in which you'd like to send different digests to different sets of recipients using a common set SMTP parameters:
+
+```
+./rssmail server.conf cat-feeds.conf cat-lovers.conf
+./rssmail server.conf mushroom-feeds.conf shroom-lovers.conf
+
+
+server.conf:
+
+  username: admin@example.com
+  password: hatemyjob
+  host: mail.example.com
+  port: 465
+  from: mailer@example.com
+
+
+cat-feeds.conf:
+
+  max_age: 1440
+  uri: https://cats.example.com/rss.xml
+  uri: https://kittens.example.com/rss
+  uri: https://tabbies.example.com/feed
+  ...
+
+
+mushroom-feeds.conf:
+
+  max_age: 1440
+  uri: https://mush.example.com/rss
+  uri: https://mycelium.example.com/feed&type=rss
+  ...
+
+
+cat-lovers.conf:
+
+  to: cats-list@example.com
+  recipient: alice@example.com
+  recipient: bob@example.com
+  ...
+
+
+shroom-lovers.conf:
+
+  to: myco-list@example.com
+  recipient: jake@example.com
+  recipient: balthazar@example.com
+  recipient: alice@example.com
+  ...
+```
+
+## Runtime Dependencies
+- LibXML2
+- LibCURL
+
+## Build Dependencies
+- GCC or Clang
+- CMake
diff --git a/example.conf b/example.conf
new file mode 100644
index 0000000..1df4d83
--- /dev/null
+++ b/example.conf
@@ -0,0 +1,73 @@
+# --------------------------------------------------
+# Notice
+# --------------------------------------------------
+#
+# Configuration settings may be spread across multiple files.
+#
+# This allows you to, for example, have files with different lists of 
+# recipients, or one list of recipients that receives digests from
+# varied sources.
+#
+# The order of the file paths passed as arguments doesn't matter;
+# the application treats them as though they were concatenated
+# files.
+#
+# Example:
+#
+# ./rssmail recipients.conf primary.conf
+# ./rssmail secondary.conf recipients.conf extra_recipients.conf 
+
+
+# --------------------------------------------------
+# SMTP configuration
+# --------------------------------------------------
+
+# server information
+username            sender@example.com
+password            hunter2
+host                mail.example.com
+port                465
+
+# outgoing mail headers
+from                sender@example.com
+to                  list@example.com
+subject             RSS Mailing List
+
+
+# --------------------------------------------------
+# RSS feed configuration
+# --------------------------------------------------
+
+useragent           rssmail by panda-roux (https://sr.ht/~panda-roux/rssmail/)
+
+# feeds
+feed_uri            https://itsgoingdown.org/feed
+feed_uri            https://crimethinc.com/rss
+feed_uri            https://www.revolutionbythebook.akpress.org/feed/
+feed_uri            https://channelzeronetwork.com/rss
+
+# maximum age of posts to include in the digest (minutes)
+max_age             1440
+
+# recipients are listed on separate lines beginning with the "recipient" token
+recipient           contact@panda-roux.dev
+recipient           someone@example.com
+recipient           someone-else@example.com
+
+
+# --------------------------------------------------
+# Miscellaneous
+# --------------------------------------------------
+
+# aliases:
+# - from, sender, from_address
+# - to, to_address
+# - subject, subj, sub
+# - username, user
+# - password, pass, passwd
+# - host, server_host
+# - port, server_port
+# - recipient, rcpt
+# - feed_uri, feed_url, uri, url, feed
+# - useragent, agent
+# - max_age, age
diff --git a/include/config.h b/include/config.h
new file mode 100644
index 0000000..3045878
--- /dev/null
+++ b/include/config.h
@@ -0,0 +1,39 @@
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#include <stdbool.h>
+
+#define RSSMAIL_CONFIGURE_SUCCESS 0
+#define RSSMAIL_CONFIGURE_FAILURE -1
+
+typedef struct smtp_config_t {
+  int recipient_count;
+  int port;
+  char* from;
+  char* to;
+  char* subject;
+  char* username;
+  char* password;
+  char* host;
+  char* cert_path;
+  char** recipients;
+} smtp_config_t;
+
+typedef struct rss_config_t {
+  int max_age;
+  int uri_count;
+  char** uris;
+  char* useragent;
+} rss_config_t;
+
+int read_config_file(const char* path, smtp_config_t* s, rss_config_t* r);
+
+void init_config(smtp_config_t* s, rss_config_t* r);
+
+void generate_config_file(void);
+
+void free_smtp_config(smtp_config_t* smtp);
+
+void free_rss_config(rss_config_t* rss);
+
+#endif
diff --git a/include/fetch.h b/include/fetch.h
new file mode 100644
index 0000000..fc2fa43
--- /dev/null
+++ b/include/fetch.h
@@ -0,0 +1,22 @@
+#ifndef FETCH_H
+#define FETCH_H
+
+#include "config.h"
+#include "post.h"
+
+/*
+ * Fetches an RSS document and converts into a list of post_item_t structures
+ */
+post_item_t* fetch_posts(rss_config_t* config, int* count);
+
+/*
+ * Initializes global resources required for fetching data from URLs
+ */
+void init_fetch(void);
+
+/*
+ * Cleans up global resources used for fetching data from URLs
+ */
+void cleanup_fetch(void);
+
+#endif
diff --git a/include/log.h b/include/log.h
new file mode 100644
index 0000000..04ceca4
--- /dev/null
+++ b/include/log.h
@@ -0,0 +1,25 @@
+#ifndef LOG_H
+#define LOG_H
+
+#ifndef RSSMAIL_DISABLE_LOGGING
+
+#include <stdlib.h>
+
+#define LOG(fmt, ...) printf(fmt "\n", ##__VA_ARGS__)
+#define LOG_ERROR(fmt, ...) fprintf(stderr, fmt "\n", ##__VA_ARGS__)
+
+#ifdef DEBUG
+#define LOG_DEBUG(fmt, ...) printf("DEBUG: " fmt "\n", ##__VA_ARGS__)
+#else
+#define LOG_DEBUG(fmt, ...) (void)(fmt)
+#endif
+
+#else
+
+#define LOG(fmt, ...) (void)(fmt)
+#define LOG_ERROR(fmt, ...) (void)(fmt)
+#define LOG_DEBUG(fmt, ...) (void)(fmt)
+
+#endif
+
+#endif
diff --git a/include/mail.h b/include/mail.h
new file mode 100644
index 0000000..c54a153
--- /dev/null
+++ b/include/mail.h
@@ -0,0 +1,12 @@
+#ifndef MAIL_H
+#define MAIL_H
+
+#include "config.h"
+#include "post.h"
+
+#define RSSMAIL_SEND_SUCCESS 0
+#define RSSMAIL_SEND_FAILURE -1
+
+int send_posts_as_digest(smtp_config_t* config, post_item_t* posts, int count);
+
+#endif
diff --git a/include/parse.h b/include/parse.h
new file mode 100644
index 0000000..5bbad27
--- /dev/null
+++ b/include/parse.h
@@ -0,0 +1,26 @@
+#ifndef PARSE_H
+#define PARSE_H
+
+#include <libxml/tree.h>
+
+#include "config.h"
+#include "post.h"
+
+/*
+ * Reads the contents of the provided XML document and uses the information it
+ * contains in order to construct zero or more syndicated post objects
+ */
+post_item_t* parse_posts_from_doc(xmlDocPtr doc, int* count,
+                                  rss_config_t* config);
+
+/*
+ * Initializes the global resources used by LibXML
+ */
+void init_parse(void);
+
+/*
+ * Cleans up the global resources used by LibXML
+ */
+void cleanup_parse(void);
+
+#endif
diff --git a/include/post.h b/include/post.h
new file mode 100644
index 0000000..82c4ee5
--- /dev/null
+++ b/include/post.h
@@ -0,0 +1,25 @@
+#ifndef POST_H
+#define POST_H
+
+/*
+ * Represents a single syndicated post entry as received from a remote RSS feed
+ */
+typedef struct post_item_t {
+  char* title;
+  char* description;
+  char* url;
+} post_item_t;
+
+/*
+ * Frees the resources allocated for each of the fields in post_item_t
+ *
+ * Note that this WILL NOT free the provided pointer itself, only its
+ * constituent parts
+ */
+void free_post_item(post_item_t* item);
+
+#ifndef RSSMAIL_POST_MAX_FIELD_LENGTH
+#define RSSMAIL_POST_MAX_FIELD_LENGTH 2048
+#endif
+
+#endif
diff --git a/src/config.c b/src/config.c
new file mode 100644
index 0000000..cf0e835
--- /dev/null
+++ b/src/config.c
@@ -0,0 +1,179 @@
+#include "config.h"
+
+#ifdef __STDC_ALLOC_LIB__
+#define __STDC_WANT_LIB_EXT2__ 1
+#endif
+
+#include <ctype.h>
+#include <post.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "log.h"
+
+#define SMTP_FROM "from_address", "sender", "from"
+#define SMTP_TO "to_address", "to"
+#define SMTP_SUBJECT "subject", "subj", "sub"
+#define SMTP_USERNAME "username", "user"
+#define SMTP_PASSWORD "password", "pass", "passwd"
+#define SMTP_HOST "server_host", "host"
+#define SMTP_CERTPATH "certificate_path", "cert", "cert_path"
+#define SMTP_PORT "server_port", "port"
+#define SMTP_RECIPIENT "recipient", "rcpt"
+
+#define RSS_URI "feed_uri", "feed_url", "feed", "uri", "url"
+#define RSS_USERAGENT "useragent", "agent"
+#define RSS_MAXAGE "max_age", "age"
+
+#define COMMENT_TOKEN '#'
+
+#define CFG_STR(line, fld, ...)                                \
+  {                                                            \
+    char* tokens[] = {__VA_ARGS__};                            \
+    for (int i = 0; i < sizeof(tokens) / sizeof(char*); ++i) { \
+      if (strstr(line, tokens[i]) == (line) &&                 \
+          isspace(line[strlen(tokens[i])])) {                  \
+        if ((fld) != NULL) {                                   \
+          free((fld));                                         \
+        }                                                      \
+        (fld) = copy_line_value(line);                         \
+        LOG_DEBUG("%s = %s", tokens[i], fld);                  \
+        break;                                                 \
+      }                                                        \
+    }                                                          \
+  }
+
+#define CFG_STRAPPEND(line, fld, n, ...)                       \
+  {                                                            \
+    char* tokens[] = {__VA_ARGS__};                            \
+    for (int i = 0; i < sizeof(tokens) / sizeof(char*); ++i) { \
+      if (strstr(line, tokens[i]) == (line) &&                 \
+          isspace(line[strlen(tokens[i])])) {                  \
+        (fld) = realloc(fld, ++(n) * sizeof(char*));           \
+        (fld)[(n)-1] = copy_line_value(line);                  \
+        LOG_DEBUG("%s (%d) = %s", tokens[i], n, (fld)[(n)-1]); \
+        break;                                                 \
+      }                                                        \
+    }                                                          \
+  }
+
+#define CFG_INT(line, fld, ...)                                \
+  {                                                            \
+    char* tokens[] = {__VA_ARGS__};                            \
+    for (int i = 0; i < sizeof(tokens) / sizeof(char*); ++i) { \
+      if (strstr(line, tokens[i]) == (line) &&                 \
+          isspace(line[strlen(tokens[i])])) {                  \
+        char* strval = copy_line_value(line);                  \
+        if (strval != NULL) {                                  \
+          (fld) = (int)strtol(strval, NULL, 10);               \
+          LOG_DEBUG("%s = %d", tokens[i], fld);                \
+          free(strval);                                        \
+        }                                                      \
+        break;                                                 \
+      }                                                        \
+    }                                                          \
+  }
+
+static char* copy_line_value(char* line) {
+  // find first whitespace character
+  char* value = strchr(line, ' ');
+  if (value == NULL) {
+    return NULL;
+  }
+
+  // advanced until no-longer whitespace
+  while (isspace(value[0])) {
+    ++value;
+  }
+
+  // return a copy from that position
+  return strndup(value, strnlen(value, RSSMAIL_POST_MAX_FIELD_LENGTH) - 1);
+}
+
+// NOLINTNEXTLINE
+static void parse_line(char* line, smtp_config_t* smtp, rss_config_t* rss) {
+  // check to see if the line starts with the comment char; if so, skip it
+  if (strchr(line, COMMENT_TOKEN) == line) {
+    return;
+  }
+
+  CFG_INT(line, smtp->port, SMTP_PORT);
+  CFG_STR(line, smtp->from, SMTP_FROM);
+  CFG_STR(line, smtp->to, SMTP_TO);
+  CFG_STR(line, smtp->subject, SMTP_SUBJECT);
+  CFG_STR(line, smtp->username, SMTP_USERNAME);
+  CFG_STR(line, smtp->password, SMTP_PASSWORD);
+  CFG_STR(line, smtp->host, SMTP_HOST);
+  CFG_STR(line, smtp->cert_path, SMTP_CERTPATH);
+  CFG_STRAPPEND(line, smtp->recipients, smtp->recipient_count, SMTP_RECIPIENT);
+  CFG_STRAPPEND(line, rss->uris, rss->uri_count, RSS_URI);
+  CFG_STR(line, rss->useragent, RSS_USERAGENT);
+  CFG_INT(line, rss->max_age, RSS_MAXAGE);
+}
+
+int read_config_file(const char* path, smtp_config_t* s, rss_config_t* r) {
+  FILE* file;
+  if ((file = fopen(path, "r")) == NULL) {
+    perror("Failed to open configuration file");
+    return RSSMAIL_CONFIGURE_FAILURE;
+  }
+
+  char* line = NULL;
+  size_t len = 0;
+  while (getline(&line, &len, file) > 0) {
+    if (line != NULL) {
+      parse_line(line, s, r);
+    }
+  }
+
+  free(line);
+
+  fclose(file);
+
+  return RSSMAIL_CONFIGURE_SUCCESS;
+}
+
+void init_config(smtp_config_t* s, rss_config_t* r) {
+  s->recipient_count = 0;
+  s->port = 0;
+  s->from = NULL;
+  s->to = NULL;
+  s->subject = NULL;
+  s->username = NULL;
+  s->password = NULL;
+  s->host = NULL;
+  s->cert_path = NULL;
+  s->recipients = NULL;
+
+  r->uris = NULL;
+  r->uri_count = 0;
+  r->useragent = NULL;
+}
+
+void free_smtp_config(smtp_config_t* s) {
+  free(s->from);
+  free(s->to);
+  free(s->username);
+  free(s->password);
+  free(s->host);
+  free(s->cert_path);
+  free(s->subject);
+
+  for (int i = 0; i < s->recipient_count; ++i) {
+    free(s->recipients[i]);
+  }
+
+  free(s->recipients);
+}
+
+void free_rss_config(rss_config_t* r) {
+  free(r->useragent);
+
+  for (int i = 0; i < r->uri_count; ++i) {
+    free(r->uris[i]);
+  }
+
+  free(r->uris);
+}
+
diff --git a/src/fetch.c b/src/fetch.c
new file mode 100644
index 0000000..3b156af
--- /dev/null
+++ b/src/fetch.c
@@ -0,0 +1,219 @@
+#include "fetch.h"
+
+#include <curl/curl.h>
+#include <curl/multi.h>
+#include <libxml/parser.h>
+#include <string.h>
+
+#include "log.h"
+#include "parse.h"
+
+#define REQUEST_TIMEOUT_MS (30 * 1000)
+
+static size_t write_data(void* data, size_t size, size_t count, void* file) {
+  // as data comes in, push it directly into the XML parser
+  size_t length = size * count;
+  xmlParserCtxtPtr* parser = (xmlParserCtxtPtr*)file;
+  if (*parser == NULL) {
+    LOG_DEBUG("Initializing a document parser");
+
+    // if this is the first time this is being called, create the parser
+    *parser =
+        xmlCreatePushParserCtxt(NULL, NULL, (char*)data, (int)length, NULL);
+  } else {
+    xmlParseChunk(*parser, (char*)data, (int)length, 0);
+  }
+
+  LOG_DEBUG("Received %zu bytes", count);
+
+  return length;
+}
+
+static void init_request(CURLM* curlm, rss_config_t* config, int uri_index) {
+  char* uri = config->uris[uri_index];
+
+  CURL* curl = NULL;
+  if ((curl = curl_easy_init()) == NULL) {
+    LOG_ERROR("Failed to create CURL object for URI \"%s\"", uri);
+    return;
+  }
+
+  LOG_DEBUG("Fetching document from %s", uri);
+
+  xmlParserCtxtPtr* parser = malloc(sizeof(xmlParserCtxtPtr));
+  *parser = NULL;
+
+  curl_easy_setopt(curl, CURLOPT_URL, uri);
+  curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
+  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
+  curl_easy_setopt(curl, CURLOPT_WRITEDATA, parser);
+  curl_easy_setopt(curl, CURLOPT_PRIVATE, parser);
+  curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
+  curl_easy_setopt(curl, CURLOPT_USERAGENT, config->useragent);
+
+#ifdef DEBUG
+  curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+#endif
+
+  curl_multi_add_handle(curlm, curl);
+}
+
+static int parse_response_document(post_item_t** posts, xmlDocPtr doc,
+                                   rss_config_t* config, const char* url,
+                                   int total) {
+  int doc_post_count = 0;
+  post_item_t* doc_posts = parse_posts_from_doc(doc, &doc_post_count, config);
+
+  if (doc_posts != NULL) {
+    if (doc_post_count > 0) {
+      LOG_DEBUG("Found %d syndicated entries", doc_post_count);
+      post_item_t* expanded =
+          realloc(*posts, (total + doc_post_count) * sizeof(post_item_t));
+      if (expanded == NULL) {
+        LOG_ERROR("Ran out of memory while fetching posts from %s", url);
+        return 0;
+      }
+
+      memcpy(&expanded[total], doc_posts, doc_post_count * sizeof(post_item_t));
+      *posts = expanded;
+    }
+
+    // only free the temporary buffer, not the post items themselves; the
+    // string pointers on the post structure need to remain valid after this
+    // point
+    free(doc_posts);
+  }
+
+  return doc_post_count;
+}
+
+static void wait_until_finished(CURLM* curlm) {
+  int running = 0;
+  curl_multi_perform(curlm, &running);
+
+  do {
+    int numfds = 0;
+    int result = curl_multi_wait(curlm, NULL, 0, REQUEST_TIMEOUT_MS, &numfds);
+    if (result != CURLM_OK) {
+      LOG_ERROR("An error occurred while waiting for a request to complete: %s",
+                curl_multi_strerror(result));
+      break;
+    }
+
+    curl_multi_perform(curlm, &running);
+  } while (running);
+}
+
+static bool ensure_response_success_code(CURL* curl) {
+  int status_code = 0;
+  curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &status_code);
+
+  if (status_code != 200) {
+    char* url = NULL;
+    curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &url);
+    if (url != NULL) {
+      LOG_ERROR("Received HTTP error code %d from %s", status_code, url);
+    }
+
+    curl_easy_cleanup(curl);
+    false;
+  }
+
+  return true;
+}
+
+static bool ensure_curl_success(CURLMsg* msg, CURL* curl) {
+  if (msg->data.result != CURLE_OK) {
+    char* url = NULL;
+    curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &url);
+    if (url != NULL) {
+      LOG_ERROR("Received CURL error code %d while fetching %s",
+                msg->data.result, url);
+    } else {
+      LOG_ERROR("Received CURL error code %ds", msg->data.result);
+    }
+
+    return false;
+  }
+
+  return true;
+}
+
+static void append_posts_from_parser(CURL* curl, int* total,
+                                     rss_config_t* config,
+                                     post_item_t** posts) {
+  xmlParserCtxtPtr* parser;
+  curl_easy_getinfo(curl, CURLINFO_PRIVATE, &parser);
+  if (parser != NULL) {
+    if (*parser != NULL) {
+      // terminate the parser
+      xmlParseChunk(*parser, NULL, 0, 1);
+      xmlDocPtr doc = (*parser)->myDoc;
+      xmlFreeParserCtxt(*parser);
+
+      char* url = NULL;
+      curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &url);
+      *total += parse_response_document(posts, doc, config, url, *total);
+
+      xmlFreeDoc(doc);
+    }
+
+    free(parser);
+  }
+}
+
+post_item_t* fetch_posts(rss_config_t* config, int* count) {
+  post_item_t* posts = NULL;
+  *count = 0;
+
+  CURLM* curlm = curl_multi_init();
+
+  for (int i = 0; i < config->uri_count; ++i) {
+    init_request(curlm, config, i);
+  }
+
+  wait_until_finished(curlm);
+
+  CURLMsg* msg;
+  int msgs_left = 0;
+  while ((msg = curl_multi_info_read(curlm, &msgs_left))) {
+    if (msg->msg != CURLMSG_DONE) {
+      // log error
+      continue;
+    }
+
+    CURL* curl = msg->easy_handle;
+
+    curl_multi_remove_handle(curlm, curl);
+
+    if (!ensure_curl_success(msg, curl)) {
+      continue;
+    }
+
+    if (!ensure_response_success_code(curl)) {
+      continue;
+    }
+
+    append_posts_from_parser(curl, count, config, &posts);
+
+    curl_easy_cleanup(curl);
+  }
+
+  curl_multi_cleanup(curlm);
+
+  return posts;
+}
+
+void init_fetch(void) {
+  LOG_DEBUG("Initializing CURL globally");
+
+  curl_global_init(CURL_GLOBAL_DEFAULT);
+}
+
+/*
+ * Cleans up global resources used for fetching data from URLs
+ */
+void cleanup_fetch(void) {
+  LOG_DEBUG("Cleaning up CURL global resources");
+  curl_global_cleanup();
+}
diff --git a/src/mail.c b/src/mail.c
new file mode 100644
index 0000000..f72a797
--- /dev/null
+++ b/src/mail.c
@@ -0,0 +1,221 @@
+#include "mail.h"
+
+#include <curl/curl.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+
+#include "log.h"
+
+#define URI_MAX_LENGTH 255
+#define NEWLINE "\r\n"
+#define HEADER_LINE_BUFFER_LENGTH 256
+
+typedef struct message_payload_t {
+  FILE* file;
+  size_t bytes_sent;
+  size_t total_length;
+} message_payload_t;
+
+static void write_header_line(FILE* file, const char* name, char* value) {
+  char buffer[HEADER_LINE_BUFFER_LENGTH];
+  size_t len = snprintf(&buffer[0], HEADER_LINE_BUFFER_LENGTH - 1,
+                        "%s: %s" NEWLINE, name, value);
+  fwrite(&buffer[0], sizeof(char), len, file);
+}
+
+static void write_empty_line(FILE* file) {
+  fwrite(NEWLINE NEWLINE, sizeof(char), (sizeof(NEWLINE) - 1) * 2, file);
+}
+
+static void write_body_line(FILE* file, char* contents) {
+  size_t len = strnlen(contents, RSSMAIL_POST_MAX_FIELD_LENGTH);
+  fwrite(contents, sizeof(char), len, file);
+}
+
+static void write_post_body(FILE* file, post_item_t* post) {
+  write_body_line(file, post->title);
+  write_empty_line(file);
+  write_body_line(file, post->description);
+  write_empty_line(file);
+  write_body_line(file, post->url);
+}
+
+static void write_post_count(FILE* file, int count) {
+  char buffer[128];
+  size_t len =
+      snprintf(buffer, sizeof(buffer),
+               "This message contains %d posts in a digest format assembled by "
+               "RSSMail." NEWLINE NEWLINE,
+               count);
+  fwrite(&buffer[0], sizeof(char), len, file);
+}
+
+static void write_divider(FILE* file) {
+  char buffer[] = NEWLINE NEWLINE NEWLINE "-----" NEWLINE NEWLINE NEWLINE;
+  fwrite(&buffer[0], sizeof(char), sizeof(buffer) - 1, file);
+}
+
+static void build_digest_body(FILE* file, post_item_t* posts, int count) {
+  write_post_count(file, count);
+
+  // write the first post (isn't followed by divider line)
+  write_post_body(file, &posts[0]);
+
+  // if there was only one post, we're done
+  if (count == 1) {
+    return;
+  }
+
+  // write the rest of the posts
+  for (int i = 1; i < count; ++i) {
+    write_divider(file);
+    write_post_body(file, &posts[i]);
+  }
+}
+
+static void build_digest_headers(FILE* file, smtp_config_t* config,
+                                 int post_count) {
+  // get a local timestamp
+  time_t ticks = time(NULL);
+  struct tm* now = localtime(&ticks);
+  char date_buffer[HEADER_LINE_BUFFER_LENGTH];
+  strftime(&date_buffer[0], HEADER_LINE_BUFFER_LENGTH, "%c", now);
+
+  // write headers
+  write_header_line(file, "Date", &date_buffer[0]);
+  write_header_line(file, "To", config->to);
+  write_header_line(file, "From", config->from);
+  write_header_line(file, "MIME-Version", "1.0");
+  write_header_line(file, "Content-Transfer-Encoding", "8bit");
+  write_header_line(file, "Content-Type", "text/plain;charset=utf-8");
+
+  char subject_buffer[HEADER_LINE_BUFFER_LENGTH];
+  snprintf(&subject_buffer[0], HEADER_LINE_BUFFER_LENGTH, "%s (%d posts)",
+           config->subject, post_count);
+
+  write_header_line(file, "Subject", &subject_buffer[0]);
+
+  // terminate with an additional cr/lf
+  write_empty_line(file);
+}
+
+static FILE* build_digest_payload(post_item_t* posts, int count, size_t* length,
+                                  smtp_config_t* config) {
+#ifdef RSSMAIL_SEND_TO_FILE
+  FILE* file = fopen("rssmail_output", "w+");
+#else
+  FILE* file = tmpfile();
+#endif
+
+  build_digest_headers(file, config, count);
+  build_digest_body(file, posts, count);
+
+  // add null-terminator
+  // fwrite("\0", sizeof(char), 1, file);
+
+  *length = (size_t)ftell(file);
+
+  LOG_DEBUG("Digest payload size: %zu bytes", *length);
+
+  fseek(file, 0, SEEK_SET);
+  return file;
+}
+
+static void free_digest_payload(message_payload_t* payload) {
+  if (payload != NULL) {
+    if (payload->file != NULL) {
+      fclose(payload->file);
+    }
+
+    free(payload);
+  }
+}
+
+static size_t upload_payload(char* ptr, size_t size, size_t count,
+                             void* userdata) {
+  message_payload_t* payload = (message_payload_t*)userdata;
+  if (payload->bytes_sent >= payload->total_length || size * count == 0 ||
+      feof(payload->file) != 0) {
+    LOG_DEBUG("Reached the end of the payload");
+    return 0;
+  }
+
+  size_t bytes_to_send = count * size;
+  size_t bytes_remaining = payload->total_length - payload->bytes_sent;
+  if (bytes_to_send > bytes_remaining) {
+    bytes_to_send = bytes_remaining;
+  }
+
+  size_t bytes_sent = fread(ptr, 1, bytes_to_send, payload->file);
+
+  payload->bytes_sent += bytes_sent;
+
+  LOG_DEBUG("Sent %zu of %zu bytes to the mail server", payload->bytes_sent,
+            payload->total_length);
+
+  return bytes_sent;
+}
+
+int send_posts_as_digest(smtp_config_t* config, post_item_t* posts, int count) {
+  CURL* curl = NULL;
+  struct curl_slist* recipients = NULL;
+  message_payload_t* payload = NULL;
+
+  char smtp_uri[URI_MAX_LENGTH + 1];
+  if (snprintf(&smtp_uri[0], URI_MAX_LENGTH, "smtps://%s:%d", config->host,
+               config->port) >= URI_MAX_LENGTH) {
+    LOG_ERROR(
+        "The provided SMTP URI is too long; the maximum allowed length is %d",
+        URI_MAX_LENGTH);
+    return RSSMAIL_SEND_FAILURE;
+  }
+
+  if ((curl = curl_easy_init()) == NULL) {
+    LOG_ERROR("Failed to create CURL prior to sending mail digest");
+    return RSSMAIL_SEND_FAILURE;
+  }
+
+  for (int i = 0; i < config->recipient_count; ++i) {
+    recipients = curl_slist_append(recipients, config->recipients[i]);
+  }
+
+  payload = (message_payload_t*)malloc(sizeof(message_payload_t));
+  payload->bytes_sent = 0;
+  payload->file =
+      build_digest_payload(posts, count, &payload->total_length, config);
+
+  curl_easy_setopt(curl, CURLOPT_MAIL_RCPT, recipients);
+  curl_easy_setopt(curl, CURLOPT_MAIL_FROM, config->from);
+  curl_easy_setopt(curl, CURLOPT_USERNAME, config->username);
+  curl_easy_setopt(curl, CURLOPT_PASSWORD, config->password);
+  curl_easy_setopt(curl, CURLOPT_URL, &smtp_uri[0]);
+  curl_easy_setopt(curl, CURLOPT_USE_SSL, (long)CURLUSESSL_ALL);
+  curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
+  curl_easy_setopt(curl, CURLOPT_READFUNCTION, upload_payload);
+  curl_easy_setopt(curl, CURLOPT_READDATA, payload);
+  curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
+
+  if (config->cert_path != NULL) {
+    curl_easy_setopt(curl, CURLOPT_CAINFO, config->cert_path);
+  }
+
+#ifdef DEBUG
+  curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+#endif
+
+#ifndef RSSMAIL_SEND_TO_FILE
+  CURLcode result = curl_easy_perform(curl);
+  if (result != CURLE_OK) {
+    LOG_ERROR("Failed to send message: %s", curl_easy_strerror(result));
+  }
+#endif
+
+  free_digest_payload(payload);
+
+  curl_slist_free_all(recipients);
+
+  curl_easy_cleanup(curl);
+
+  return RSSMAIL_SEND_SUCCESS;
+}
diff --git a/src/main.c b/src/main.c
new file mode 100644
index 0000000..228604e
--- /dev/null
+++ b/src/main.c
@@ -0,0 +1,63 @@
+#include <assert.h>
+
+#include "config.h"
+#include "fetch.h"
+#include "log.h"
+#include "mail.h"
+#include "parse.h"
+
+int main(int argc, const char** argv) {
+  if (argc < 2) {
+    LOG("Error: Missing configuration file path argument\n");
+    LOG("Usage: rssmail options.conf [other_options.conf, ...]");
+    return EXIT_FAILURE;
+  }
+
+  // I am relying on this assumption in many places for the sake of convenience
+  static_assert(sizeof(xmlChar) == sizeof(char),
+                "xmlChar and char are not the same size!");
+
+  // this initializes global libcurl and libxml resources
+  init_fetch();
+  init_parse();
+
+  // initialize configuration objects
+  smtp_config_t smtp_config;
+  rss_config_t rss_config;
+  init_config(&smtp_config, &rss_config);
+
+  // read each of the configuration files whose paths were passed in as
+  // command-line arguments
+  for (int i = 1; i < argc; ++i) {
+    if (read_config_file(argv[i], &smtp_config, &rss_config) != 0) {
+      LOG_ERROR("Failed to read configuration file %s", argv[1]);
+      goto done;
+    }
+  }
+
+  // download all the RSS posts from the configured URI
+  int count;
+  post_item_t* posts = fetch_posts(&rss_config, &count);
+
+  // if there are posts
+  if (posts != NULL && count > 0) {
+    send_posts_as_digest(&smtp_config, posts, count);
+  }
+
+  // cleanup
+  for (int i = 0; i < count; ++i) {
+    free_post_item(&posts[i]);
+  }
+
+  free(posts);
+
+done:
+  free_smtp_config(&smtp_config);
+  free_rss_config(&rss_config);
+
+  cleanup_parse();
+  cleanup_fetch();
+
+  EXIT_SUCCESS;
+}
+
diff --git a/src/parse.c b/src/parse.c
new file mode 100644
index 0000000..fe7b2b1
--- /dev/null
+++ b/src/parse.c
@@ -0,0 +1,231 @@
+#include "parse.h"
+
+#include <curl/curl.h>
+#include <libxml/HTMLparser.h>
+#include <libxml/xpath.h>
+#include <string.h>
+#include <time.h>
+
+#include "log.h"
+
+static void extract_text_from_html(xmlChar* body, xmlChar** output) {
+  htmlDocPtr doc = NULL;
+  xmlXPathContextPtr xpath_ctx = NULL;
+  xmlXPathObjectPtr xpath_obj = NULL;
+  *output = NULL;
+
+  if (!(doc = htmlParseDoc(body, "UTF-8"))) {
+    return;
+  }
+
+  if (!(xpath_ctx = xmlXPathNewContext(doc))) {
+    goto done;
+  }
+
+  if (!(xpath_obj =
+            xmlXPathEvalExpression(BAD_CAST "//child::text()", xpath_ctx))) {
+    goto done;
+  }
+
+  size_t len = 0;
+  *output = calloc(RSSMAIL_POST_MAX_FIELD_LENGTH, sizeof(xmlChar));
+  for (int i = 0; i < xpath_obj->nodesetval->nodeNr; ++i) {
+    xmlNodePtr node = xpath_obj->nodesetval->nodeTab[i];
+    xmlChar* contents = xmlNodeGetContent(node);
+    if (contents != NULL) {
+      size_t contents_len =
+          strnlen((char*)contents, RSSMAIL_POST_MAX_FIELD_LENGTH - len);
+      if (contents_len + len < RSSMAIL_POST_MAX_FIELD_LENGTH) {
+        strncat(&((char*)(*output))[len], (char*)contents, contents_len);
+      } else {
+        LOG_DEBUG(
+            "Maximum field length (%d) was met while parsing HTML; text will "
+            "be "
+            "truncated",
+            RSSMAIL_POST_MAX_FIELD_LENGTH);
+
+        free(contents);
+
+        break;
+      }
+
+      free(contents);
+    }
+  }
+
+done:
+  if (xpath_obj != NULL) {
+    xmlXPathFreeObject(xpath_obj);
+  }
+
+  if (xpath_ctx != NULL) {
+    xmlXPathFreeContext(xpath_ctx);
+  }
+
+  if (doc != NULL) {
+    xmlFreeDoc(doc);
+  }
+}
+
+static void extract_content_by_xpath(xmlXPathContextPtr xpath_ctx,
+                                     xmlNodePtr parent, const xmlChar* expr,
+                                     xmlChar** output) {
+  xmlXPathObjectPtr obj = xmlXPathNodeEval(parent, expr, xpath_ctx);
+
+  if (obj == NULL) {
+    LOG_ERROR("Failed to evaluate XPath expression \"%s\"", expr);
+    *output = NULL;
+    return;
+  }
+
+  *output = obj->nodesetval->nodeNr == 0
+                ? NULL
+                : xmlNodeGetContent(obj->nodesetval->nodeTab[0]);
+
+  if (*output == NULL) {
+    LOG_DEBUG("Couldn't find any content matching xpath expression \"%s\"",
+              expr);
+  }
+
+  xmlXPathFreeObject(obj);
+}
+
+static void extract_parts_from_node(xmlXPathContextPtr xpath_ctx,
+                                    xmlNodePtr node, xmlChar** title,
+                                    xmlChar** desc, xmlChar** url) {
+  extract_content_by_xpath(xpath_ctx, node, BAD_CAST "title[1]", title);
+
+  extract_content_by_xpath(xpath_ctx, node, BAD_CAST "link[1]", url);
+
+  xmlChar* desc_body;
+  extract_content_by_xpath(xpath_ctx, node,
+                           BAD_CAST "description/descendant-or-self::*/text()",
+                           &desc_body);
+
+  if (desc_body != NULL) {
+    extract_text_from_html(desc_body, desc);
+    xmlFree(desc_body);
+  } else {
+    *desc = NULL;
+  }
+
+  // perform some debug logging
+  // (the rest of the function after this line should be optimized away on
+  // release builds)
+
+  if (title != NULL && *title != NULL) {
+    LOG_DEBUG("Title: %s", *title);
+  } else {
+    LOG_DEBUG("Missing title");
+  }
+
+  if (desc != NULL && *desc != NULL) {
+    LOG_DEBUG("Description: %s", *desc);
+  } else {
+    LOG_DEBUG("Missing description");
+  }
+
+  if (url != NULL && *url != NULL) {
+    LOG_DEBUG("URL: %s", *url);
+  } else {
+    LOG_DEBUG("Missing URL");
+  }
+}
+
+static int get_node_published_age(xmlXPathContextPtr xpath_ctx,
+                                  xmlNodePtr node) {
+  xmlChar* text = NULL;
+  extract_content_by_xpath(xpath_ctx, node, BAD_CAST "pubDate[1]", &text);
+  if (text != NULL) {
+    time_t timestamp = curl_getdate((char*)text, NULL);
+    xmlFree(text);
+    return (int)(difftime(time(NULL), timestamp) / 60.0);
+  }
+
+  LOG_DEBUG(
+      "Couldn't determine the publication date of a post, so it will be "
+      "included");
+
+  // couldn't get age, return 0 to guarantee inclusion
+  return 0;
+}
+
+post_item_t* parse_posts_from_doc(xmlDocPtr doc, int* count,
+                                  rss_config_t* config) {
+  xmlXPathContextPtr xpath_ctx = NULL;
+  xmlXPathObjectPtr xpath_obj = NULL;
+  post_item_t* buffer = NULL;
+
+  // create xpath context
+  if (!(xpath_ctx = xmlXPathNewContext(doc))) {
+    LOG_ERROR("Failed to create new XPath context prior to parsing post items");
+    goto done;
+  }
+
+  if (!(xpath_obj = xmlXPathEvalExpression(BAD_CAST "//item", xpath_ctx))) {
+    LOG_ERROR("Failed to evaluate top-level 'item' xpath expression");
+    goto done;
+  }
+
+  int node_count = xpath_obj->nodesetval->nodeNr;
+  int n = 0;
+
+  // for (int i = *count - 1; i >= 0; --i) {
+  for (int i = 0; i < node_count; ++i) {
+    LOG_DEBUG("Reading node %d of %d", i + 1, node_count);
+
+    xmlNodePtr node = xpath_obj->nodesetval->nodeTab[node_count - i - 1];
+
+    // check age of the post
+    int age = get_node_published_age(xpath_ctx, node);
+    if (age > config->max_age) {
+      LOG_DEBUG(
+          "Skipping post with an age of %d minutes over maximum "
+          "allowed (age is %d minutes)",
+          age - config->max_age, age);
+      continue;
+    }
+
+    LOG_DEBUG("Post is of a permissible age (%d minutes)", age);
+
+    // if age is good, add the post to the buffer
+    post_item_t* expanded = realloc(buffer, (n + 1) * sizeof(post_item_t));
+    if (expanded == NULL) {
+      LOG_ERROR(
+          "Ran out of memory attempting to extract the contents of feed "
+          "entries");
+      break;
+    }
+
+    buffer = expanded;
+
+    post_item_t* item = &buffer[n++];
+    extract_parts_from_node(xpath_ctx, node, (xmlChar**)&item->title,
+                            (xmlChar**)&item->description,
+                            (xmlChar**)&item->url);
+  }
+
+  *count = n;
+
+done:
+  if (xpath_obj != NULL) {
+    xmlXPathFreeObject(xpath_obj);
+  }
+
+  if (xpath_ctx != NULL) {
+    xmlXPathFreeContext(xpath_ctx);
+  }
+
+  return buffer;
+}
+
+void init_parse(void) {
+  LOG_DEBUG("Initializing LibXML global resources");
+  xmlInitParser();
+  LIBXML_TEST_VERSION;
+}
+
+void cleanup_parse(void) {
+  LOG_DEBUG("Cleaning up LibXML global resources");
+  xmlCleanupParser();
+}
diff --git a/src/post.c b/src/post.c
new file mode 100644
index 0000000..e2f9d97
--- /dev/null
+++ b/src/post.c
@@ -0,0 +1,19 @@
+#include "post.h"
+
+#include <stdlib.h>
+
+void free_post_item(post_item_t* item) {
+  if (item != NULL) {
+    if (item->title != NULL) {
+      free(item->title);
+    }
+
+    if (item->description != NULL) {
+      free(item->description);
+    }
+
+    if (item->url != NULL) {
+      free(item->url);
+    }
+  }
+}