// We need pseudo-random numbers for a few things. Seed generously.
void seed_random_number_generator(void) {
- FILE *urandom;
- struct timeval tv;
- unsigned int seed;
-
- syslog(LOG_INFO, "Seeding the pseudo-random number generator...");
- urandom = fopen("/dev/urandom", "r");
- if (urandom != NULL) {
- if (fread(&seed, sizeof seed, 1, urandom) == -1) {
- syslog(LOG_ERR, "citserver: failed to read random seed: %m");
- }
- fclose(urandom);
- }
- else {
- gettimeofday(&tv, NULL);
- seed = tv.tv_usec;
- }
- srand(seed);
- srandom(seed);
+ syslog(LOG_INFO, "citserver: seeding the pseudo-random number generator");
+ srand(time(NULL) + getpid() + clock());
}
struct passwd *pw;
gid_t gid;
- syslog(LOG_DEBUG, "master_startup() started");
+ syslog(LOG_DEBUG, "citserver: master_startup() started");
time(&server_startup_time);
- syslog(LOG_INFO, "Checking directory access");
+ syslog(LOG_INFO, "citserver: checking directory access");
if ((pw = getpwuid(ctdluid)) == NULL) {
gid = getgid();
}
syslog(LOG_DEBUG, "citserver: ctdl_key_dir is %s", ctdl_key_dir);
syslog(LOG_DEBUG, "citserver: ctdl_run_dir is %s", ctdl_run_dir);
- syslog(LOG_INFO, "Opening databases");
+ syslog(LOG_INFO, "citserver: opening databases");
cdb_init_backends();
cdb_open_databases();
// Load site-specific configuration
seed_random_number_generator(); // must be done before config system
- syslog(LOG_INFO, "Initializing configuration system");
+ syslog(LOG_INFO, "citserver: initializing configuration system");
initialize_config_system();
validate_config();
migrate_legacy_control_record();
// Check floor reference counts
check_ref_counts();
- syslog(LOG_INFO, "Creating base rooms (if necessary)");
+ syslog(LOG_INFO, "citserver: creating base rooms (if necessary)");
CtdlCreateRoom(CtdlGetConfigStr("c_baseroom"), 0, "", 0, 1, 0, VIEW_BBS);
CtdlCreateRoom(AIDEROOM, 3, "", 0, 1, 0, VIEW_BBS);
CtdlCreateRoom(SYSCONFIGROOM, 3, "", 0, 1, 0, VIEW_BBS);
CtdlPutRoomLock(&qrbuf);
}
- syslog(LOG_DEBUG, "master_startup() finished");
+ syslog(LOG_DEBUG, "citserver: master_startup() finished");
}
int CtdlHostAlias(char *fqdn);
char *harvest_collected_addresses(struct CtdlMessage *msg);
int is_email_subscribed_to_list(char *email, char *room_name);
+void generate_one_click_url(char *target_buf, char *base_url, char *action, char *roomname, char *emailaddr);
// Values that can be returned by CtdlHostAlias()
enum {
// This module delivers messages to mailing lists.
//
-// Copyright (c) 2002-2023 by the citadel.org team
+// Copyright (c) 2002-2024 by the citadel.org team
//
// This program is open source software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 3.
}
// return our module name for the log
- return "listsub";
+ return "listdeliver";
}
}
+// Generate a pre-authorized subscribe/unsubscribe URL for a particular email address for a particular room.
+// This can be used as the second part of a double-opt-in or double-opt-out process.
+// It can also be used to generate a "one click unsubscribe" link.
+void generate_one_click_url(char *target_buf, char *base_url, char *action, char *roomname, char *emailaddr) {
+
+ // We need a URL-safe representation of the room name
+ char encoded_roomname[ROOMNAMELEN+10];
+ urlesc(encoded_roomname, sizeof(encoded_roomname), roomname);
+
+ // The confirmation token pre-authorizes the generated URL. It is hashed by the host key so it can't be guessed.
+ char confirmation_token[128];
+ generate_confirmation_token(confirmation_token, sizeof confirmation_token, roomname, emailaddr);
+
+ // Write to the buffer
+ snprintf(target_buf, SIZ, "%s?cmd=%s&email=%s&room=%s&token=%s",
+ base_url,
+ action,
+ emailaddr,
+ encoded_roomname,
+ confirmation_token
+ );
+}
+
+
// This generates an email with a link the user clicks to confirm a list subscription.
void send_subscribe_confirmation_email(char *roomname, char *emailaddr, char *url, char *confirmation_token) {
- // We need a URL-safe representation of the room name
- char urlroom[ROOMNAMELEN+10];
- urlesc(urlroom, sizeof(urlroom), roomname);
+
+ char confirm_subscribe_url[SIZ];
+ generate_one_click_url(confirm_subscribe_url, url, "confirm_subscribe", roomname, emailaddr);
char from_address[1024];
snprintf(from_address, sizeof from_address, "noreply@%s", CtdlGetConfigStr("c_fqdn"));
"<%s> to the <%s> mailing list.\n"
"\n"
"Please go here to confirm this request:\n"
- "%s?cmd=confirm_subscribe&email=%s&room=%s&token=%s\n"
+ "%s\n"
"\n"
"If this request has been submitted in error and you do not\n"
"wish to receive the <%s> mailing list, simply do nothing,\n"
"--__ctdlmultipart__\n"
"Content-type: text/html\n"
"\n"
- "<html><body><p>Someone (probably you) has submitted a request to subscribe "
- "<strong>%s</strong> to the <strong>%s</strong> mailing list.</p>"
- "<p>Please go here to confirm this request:</p>"
- "<p><a href=\"%s?cmd=confirm_subscribe&email=%s&room=%s&token=%s\">"
- "%s?cmd=confirm_subscribe&email=%s&room=%s&token=%s</a></p>"
- "<p>If this request has been submitted in error and you do not "
- "wish to receive the <strong>%s<strong> mailing list, simply do nothing, "
- "and you will not receive any further mailings.</p>"
+ "<html><body><p>Someone (probably you) has submitted a request to subscribe\n"
+ "<strong>%s</strong> to the <strong>%s</strong> mailing list.</p>\n"
+ "<p>Please go here to confirm this request:</p>\n"
+ "<p><a href=\"%s\">%s</a></p>\n"
+ "<p>If this request has been submitted in error and you do not\n"
+ "wish to receive the <strong>%s</strong> mailing list, simply do nothing,\n"
+ "and you will not receive any further mailings.</p>\n"
"</body></html>\n"
"\n"
"--__ctdlmultipart__--\n"
,
- emailaddr, roomname,
- url, emailaddr, urlroom, confirmation_token,
- roomname
- ,
- emailaddr, roomname,
- url, emailaddr, urlroom, confirmation_token,
- url, emailaddr, urlroom, confirmation_token,
- roomname
+ emailaddr, roomname, confirm_subscribe_url, roomname,
+ emailaddr, roomname, confirm_subscribe_url, confirm_subscribe_url, roomname
);
quickie_message("Citadel", from_address, emailaddr, NULL, emailtext, FMT_RFC822, "Please confirm your list subscription");
// This generates an email with a link the user clicks to confirm a list unsubscription.
void send_unsubscribe_confirmation_email(char *roomname, char *emailaddr, char *url, char *confirmation_token) {
- // We need a URL-safe representation of the room name
- char urlroom[ROOMNAMELEN+10];
- urlesc(urlroom, sizeof(urlroom), roomname);
+
+ char confirm_unsubscribe_url[SIZ];
+ generate_one_click_url(confirm_unsubscribe_url, url, "confirm_unsubscribe", roomname, emailaddr);
char from_address[1024];
snprintf(from_address, sizeof from_address, "noreply@%s", CtdlGetConfigStr("c_fqdn"));
"<%s> from the <%s> mailing list.\n"
"\n"
"Please go here to confirm this request:\n"
- "%s?cmd=confirm_unsubscribe&email=%s&room=%s&token=%s\n"
+ "%s\n"
"\n"
"If this request has been submitted in error and you still\n"
"wish to receive the <%s> mailing list, simply do nothing,\n"
"--__ctdlmultipart__\n"
"Content-type: text/html\n"
"\n"
- "<html><body><p>Someone (probably you) has submitted a request to unsubscribe "
- "<strong>%s</strong> from the <strong>%s</strong> mailing list.</p>"
- "<p>Please go here to confirm this request:</p>"
- "<p><a href=\"%s?cmd=confirm_unsubscribe&email=%s&room=%s&token=%s\">"
- "%s?cmd=confirm_unsubscribe&email=%s&room=%s&token=%s</a></p>"
- "<p>If this request has been submitted in error and you still "
- "wish to receive the <strong>%s<strong> mailing list, simply do nothing, "
- "and you will remain subscribed.</p>"
+ "<html><body><p>Someone (probably you) has submitted a request to unsubscribe\n"
+ "<strong>%s</strong> from the <strong>%s</strong> mailing list.</p>\n"
+ "<p>Please go here to confirm this request:</p>\n"
+ "<p><a href=\"%s\">%s</a></p>\n"
+ "<p>If this request has been submitted in error and you still\n"
+ "wish to receive the <strong>%s</strong> mailing list, simply do nothing,\n"
+ "and you will remain subscribed.</p>\n"
"</body></html>\n"
"\n"
"--__ctdlmultipart__--\n"
,
- emailaddr, roomname,
- url, emailaddr, urlroom, confirmation_token,
- roomname
- ,
- emailaddr, roomname,
- url, emailaddr, urlroom, confirmation_token,
- url, emailaddr, urlroom, confirmation_token,
- roomname
+ emailaddr, roomname, confirm_unsubscribe_url, roomname,
+ emailaddr, roomname, confirm_unsubscribe_url, confirm_unsubscribe_url, roomname
);
quickie_message("Citadel", from_address, emailaddr, NULL, emailtext, FMT_RFC822, "Please confirm your list unsubscription");
--- /dev/null
+// DKIM signature creation
+// https://www.rfc-editor.org/rfc/rfc6376.html#section-5
+//
+// Copyright (c) 2024 by Art Cancro
+// This program is open source software. Use, duplication, or disclosure is subject to the GNU General Public License v3.
+
+// Make sure we don't accidentally use any deprecated API calls
+#define OPENSSL_NO_DEPRECATED_3_0
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include <time.h>
+#include <openssl/rand.h>
+#include <openssl/rsa.h>
+#include <openssl/engine.h>
+#include <openssl/sha.h>
+#include <openssl/hmac.h>
+#include <openssl/evp.h>
+#include <openssl/bio.h>
+#include <openssl/pem.h>
+#include <openssl/buffer.h>
+#include <openssl/err.h>
+#include <libcitadel.h>
+
+
+char *dkim_rtrim(char *str) {
+ char *end;
+ int len = strlen(str);
+
+ while (*str && len) {
+ end = str + len-1;
+
+ if (*end == ' ' || *end == '\t') {
+ *end = '\0';
+ }
+ else {
+ break;
+ }
+
+ len = strlen(str);
+ }
+
+ return str;
+}
+
+
+char *dkim_rtrim_lines(char *str) {
+ char *end;
+ int len = strlen(str);
+
+ while (*str && len) {
+ end = str + len-1;
+
+ if (*end == '\r' || *end == '\n') {
+ *end = '\0';
+ }
+ else {
+ break;
+ }
+
+ len = strlen(str);
+ }
+
+ return str;
+}
+
+
+// Convert binary to base64 using openssl library function. We should replace this with the encoder from libcitadel.
+char *dkim_base64_encode(const unsigned char *input, int length) {
+ BIO *bmem, *b64;
+ BUF_MEM *bptr;
+
+ b64 = BIO_new(BIO_f_base64());
+ bmem = BIO_new(BIO_s_mem());
+ b64 = BIO_push(b64, bmem);
+
+ BIO_write(b64, input, length);
+ BIO_flush(b64);
+ BIO_get_mem_ptr(b64, &bptr);
+
+ char *buf = malloc(bptr->length);
+ memcpy(buf, bptr->data, bptr->length-1);
+ buf[bptr->length-1] = '\0';
+
+ BIO_free_all(b64);
+
+ // remove line breaks
+ int buf_len = strlen(buf);
+ int i, cur = 0;
+ for (i = 0; i < buf_len; ++i) {
+ if (buf[i] != '\r' && buf[i] != '\n') {
+ buf[cur++] = buf[i];
+ }
+ }
+ buf[cur] = '\0';
+ return buf;
+}
+
+
+// Canonicalize one line of the message body as per the "relaxed" algorithm
+char *dkim_canonicalize_body_line(char *line) {
+ int line_len = 0;
+ int i;
+
+ // Ignores all whitespace at the end of lines. Implementations MUST NOT remove the CRLF at the end of the line.
+ dkim_rtrim(line);
+
+ // Reduces all sequences of whitespace within a line to a single SP character.
+ line_len = strlen(line);
+ int new_len = 0;
+
+ for (i = 0; i < line_len; ++i) {
+ if (line[i] == '\t') {
+ line[i] = ' ';
+ }
+
+ if (i > 0) {
+ if (!(line[i-1] == ' ' && line[i] == ' ')) {
+ line[new_len++] = line[i];
+ }
+ }
+ else {
+ line[new_len++] = line[i];
+ }
+ }
+
+ line[new_len] = '\0';
+ return line;
+}
+
+
+// Canonicalize the message body as per the "relaxed" algorithm
+char *dkim_canonicalize_body(char *body) {
+ int i = 0;
+ int offset = 0;
+ int body_len = strlen(body);
+
+ char *new_body = malloc(body_len*2+3);
+ int new_body_len = 0;
+
+ for (i = 0; i < body_len; ++i) {
+ int is_r = 0;
+
+ if (body[i] == '\n') {
+ if (i > 0) {
+ if (body[i-1] == '\r') {
+ i--;
+ is_r = 1;
+ }
+ }
+
+ char *line = malloc(i - offset + 1);
+ memcpy(line, body+offset, i-offset);
+ line[i-offset] = '\0';
+
+ dkim_canonicalize_body_line(line);
+
+ int line_len = strlen(line);
+ memcpy(new_body+new_body_len, line, line_len);
+ memcpy(new_body+new_body_len+line_len, "\r\n", 2);
+ new_body_len += line_len+2;
+
+ if (is_r) {
+ i++;
+ }
+
+ offset = i+1;
+ free(line);
+ }
+ }
+
+ if (offset < body_len) {
+ char *line = malloc(i - offset + 1);
+ memcpy(line, body+offset, i-offset);
+ line[i-offset] = '\0';
+
+ dkim_canonicalize_body_line(line);
+
+ int line_len = strlen(line);
+ memcpy(new_body+new_body_len, line, line_len);
+ memcpy(new_body+new_body_len+line_len, "\r\n", 2);
+ new_body_len += line_len+2;
+
+ free(line);
+ }
+
+ memcpy(new_body+new_body_len, "\0", 1);
+
+ // Ignores all empty lines at the end of the message body. "Empty line" is defined in Section 3.4.3.
+ new_body = dkim_rtrim_lines(new_body);
+
+ // Note that a completely empty or missing body is canonicalized as a
+ // single "CRLF"; that is, the canonicalized length will be 2 octets.
+ new_body_len = strlen(new_body);
+ new_body[new_body_len++] = '\r';
+ new_body[new_body_len++] = '\n';
+ new_body[new_body_len] = '\0';
+
+ return new_body;
+}
+
+
+// Second step to canonicalize a block of headers as per the "relaxed" algorithm.
+// Unfold all headers onto single lines.
+void dkim_unfold_headers(StrBuf *unfolded_headers) {
+ char *headers_start = (char *)ChrPtr(unfolded_headers);
+ char *fold;
+
+ while (
+ fold = strstr(headers_start, "\r\n "), // find the first holded header
+ fold = (fold ? fold : strstr(headers_start, "\r\n\t")), // it could be folded with tabs
+ fold != NULL // keep going until there aren't any left
+ ) {
+
+ // Replace CRLF<space> or CRLF<tab> with CRLF
+ StrBufReplaceToken(unfolded_headers, (long)(fold-headers_start), 3, HKEY("\r\n"));
+
+ // And when we've got them all, remove the CRLF as well.
+ if (
+ (strstr(headers_start, "\r\n ") != fold)
+ && (strstr(headers_start, "\r\n\t") != fold)
+ && (!strncmp(fold, HKEY("\r\n")))
+ ) {
+ StrBufReplaceToken(unfolded_headers, (long)(fold-headers_start), 2, HKEY(""));
+ }
+
+ }
+}
+
+
+// Second step to canonicalize a block of headers as per the "relaxed" algorithm.
+// Headers MUST already be unfolded with dkim_unfold_headers()
+void dkim_canonicalize_unfolded_headers(StrBuf *headers) {
+
+ char *cheaders = (char *)ChrPtr(headers);
+ char *ptr = cheaders;
+ while (*ptr) {
+
+ // We are at the beginning of a line. Find the colon separator between field name and value.
+ char *start_of_this_line = ptr;
+ char *colon = strstr(ptr, ":");
+
+ // remove whitespace after the colon
+ while ( (*(colon+1) == ' ') || (*(colon+2) == '\t') ) {
+ StrBufReplaceToken(headers, (long)(colon+1-cheaders), 1, HKEY(""));
+ }
+ char *end_of_this_line = strstr(ptr, "\r\n");
+
+ // Convert header field names to all lower case
+ for (char *c = start_of_this_line; c<colon; ++c) {
+ cheaders[c-cheaders] = tolower(cheaders[c-cheaders]);
+ }
+
+ ptr = end_of_this_line + 2; // Advance to the beginning of the next line
+ }
+}
+
+
+// Third step to canonicalize a block of headers as per the "relaxed" algorithm.
+// Reduce the canonicalized header block to only the fields being signed
+void dkim_reduce_canonicalized_headers(StrBuf *headers, char *header_list) {
+
+ char *cheaders = (char *)ChrPtr(headers);
+ char *ptr = cheaders;
+ while (*ptr) {
+
+ // We are at the beginning of a line. Find the colon separator between field name and value.
+ char *start_of_this_line = ptr;
+ char *colon = strstr(ptr, ":");
+ char *end_of_this_line = strstr(ptr, "\r\n");
+
+ char relevant_headers[1024];
+ strncpy(relevant_headers, header_list, sizeof(relevant_headers));
+ char *rest = relevant_headers;
+ char *token = NULL;
+ int keep_this_header = 0;
+
+ while (token = strtok_r(rest, ":", &rest)) {
+ if (!strncmp(start_of_this_line, token, strlen(token))) {
+ keep_this_header = 1;
+ }
+ }
+
+ if (keep_this_header) { // Advance to the beginning of the next line
+ ptr = end_of_this_line + 2;
+ }
+ else {
+ StrBufReplaceToken(headers, (long)(start_of_this_line - cheaders), end_of_this_line-start_of_this_line+2, HKEY(""));
+ }
+ }
+
+}
+
+
+// Make a new header list containing only the headers actually present in the canonicalized header block.
+void dkim_final_header_list(char *header_list, size_t header_list_size, StrBuf *unfolded_headers) {
+ header_list[0] = 0;
+
+ char *cheaders = (char *)ChrPtr(unfolded_headers);
+ char *ptr = cheaders;
+ while (*ptr) {
+
+ // We are at the beginning of a line. Find the colon separator between field name and value.
+ char *start_of_this_line = ptr;
+ char *colon = strstr(ptr, ":");
+ char *end_of_this_line = strstr(ptr, "\r\n");
+
+ if (ptr != cheaders) {
+ strcat(header_list, ":");
+ }
+
+ strncat(header_list, start_of_this_line, (colon-start_of_this_line));
+
+ ptr = end_of_this_line + 2; // Advance to the beginning of the next line
+ }
+}
+
+
+// DKIM-sign an email, supplied as a full RFC2822-compliant message stored in a StrBuf
+void dkim_sign(StrBuf *email, char *pkey_in, char *domain, char *selector) {
+ int i = 0;
+
+ if (!email) { // no message was supplied
+ return;
+ }
+
+ // find the break between headers and body
+ size_t msglen = StrLength(email); // total length of message (headers + body)
+
+ char *body_ptr = strstr(ChrPtr(email), "\r\n\r\n");
+ if (body_ptr == NULL) {
+ fprintf(stderr, "dkim: this message cannot be signed because it has no body\n");
+ return;
+ }
+
+ size_t body_offset = body_ptr - ChrPtr(email); // offset at which message body begins
+ StrBuf *header_block = NewStrBufPlain(ChrPtr(email), body_offset+2); // headers only (the +2 makes it include final CRLF)
+ //fprintf(stderr, "Supplied headers:\n-----\n%s-----\n", ChrPtr(header_block));
+
+ // This removes the headers from the supplied email buffer. We MUST put them back in later.
+ StrBufCutLeft(email, body_offset+4); // The +4 makes it NOT include the CRLFCRLF
+ //fprintf(stderr, "Body:\n-----\n%s-----\n", ChrPtr(email));
+
+ // Apply the "relaxed" canonicalization to the message body
+ char *relaxed_body = dkim_canonicalize_body((char *)ChrPtr(email));
+ int relaxed_body_len = strlen(relaxed_body);
+ //fprintf(stderr, "Canonicalized body:\n-----\n%s-----\n", relaxed_body);
+
+ // hash of the canonicalized body
+ unsigned char *uhash = malloc(SHA256_DIGEST_LENGTH);
+ SHA256((unsigned char*)relaxed_body, relaxed_body_len, uhash);
+ free(relaxed_body); // don't need this anymore
+ relaxed_body = NULL;
+
+ // base64 encode the body hash
+ char *encoded_body_hash = dkim_base64_encode(uhash, SHA256_DIGEST_LENGTH);
+ free(uhash);
+
+ // In the test harness email, the body hash should be 2PMBIMGyD2GZlndKI2MRsbhiMr6jD5rCxhq+mCvY7os=
+ // fprintf(stderr, "Body hash: %s\n", encoded_body_hash);
+
+ // "relaxed" header canonicalization, step 1 : unfold the headers
+ StrBuf *unfolded_headers = NewStrBufDup(header_block);
+ dkim_unfold_headers(unfolded_headers);
+
+ // "relaxed" header canonicalization, step 2 : lowercase the header names, remove whitespace after the colon
+ dkim_canonicalize_unfolded_headers(unfolded_headers);
+
+ // "relaxed" header canonicalization, step 3 : reduce the canonicalized header block to only the fields being signed
+ char *header_list = "from:to:cc:reply-to:subject:date:list-unsubscribe:list-unsubscribe-post";
+ dkim_reduce_canonicalized_headers(unfolded_headers, header_list);
+
+ // fprintf(stderr, "Canonicalized headers:\n-----\n%s-----\n", (char *)ChrPtr(unfolded_headers));
+
+ // Make a new header list containing only the ones we actually have.
+ char final_header_list[1024];
+ dkim_final_header_list(final_header_list, sizeof(final_header_list), unfolded_headers);
+
+ // create DKIM header
+ time_t now = time(NULL); // signature timestamp
+ StrBuf *dkim_header = NewStrBuf();
+ StrBufPrintf(dkim_header,
+ "v=1; a=rsa-sha256; s=%s; d=%s; l=%d; t=%ld; c=relaxed/relaxed; h=%s; bh=%s; b=",
+ selector,
+ domain,
+ relaxed_body_len,
+ now,
+ final_header_list,
+ encoded_body_hash
+ );
+ free(encoded_body_hash); // Don't need this anymore either.
+
+ // Add the initial DKIM header (which is still missing the value after "b=") to the headers to be signed.
+ // As far as I can tell, RFC6376 does *not* want us to include any "\r\n" after "b="
+ StrBufAppendBufPlain(unfolded_headers, HKEY("dkim-signature:"), 0);
+ StrBufAppendBuf(unfolded_headers, dkim_header, 0);
+ // fprintf(stderr, "Canonicalized headers:\n-----\n%s\n-----\n", (char *)ChrPtr(unfolded_headers));
+
+ // Compute a hash of the canonicalized headers. RFC6376 says that we hash and sign everything up to the "b="
+ // and then we'll add the rest at the end.
+ unsigned char *headers_hash = malloc(SHA256_DIGEST_LENGTH);
+ SHA256((unsigned char*)ChrPtr(unfolded_headers), StrLength(unfolded_headers), headers_hash);
+ FreeStrBuf(&unfolded_headers); // All we need now is the hash.
+
+ // Load the private key into an OpenSSL "BIO" structure
+ BIO *bufio = BIO_new_mem_buf((void*)pkey_in, strlen(pkey_in));
+ if (bufio == NULL) {
+ fprintf(stderr, "dkim: BIO_new_mem_buf() failed\n");
+ abort();
+ }
+
+ // Now import the private key
+ EVP_PKEY *pkey = NULL; // Don't combine this line with the next one. It will barf.
+ pkey = PEM_read_bio_PrivateKey(
+ bufio, // BIO to read the private key from
+ &pkey, // pointer to EVP_PKEY structure
+ NULL, // password callback - can be NULL
+ NULL // parameter passed to callback or password if callback is NULL
+ );
+ if (pkey == NULL) {
+ fprintf(stderr, "dkim: PEM_read_bio_PrivateKey() failed\n");
+ abort();
+ }
+ BIO_free(bufio); // Don't need this anymore, we have `pkey` now
+
+ // Everything I ever needed to know I learned from https://wiki.openssl.org/index.php/EVP_Signing_and_Verifying
+ EVP_MD_CTX *mdctx = NULL;
+
+ // Create the Message Digest Context
+ mdctx = EVP_MD_CTX_create();
+ if (mdctx == NULL) {
+ fprintf(stderr, "dkim: EVP_MD_CTX_create() failed\n");
+ abort();
+ }
+
+ // Initialize the DigestSign operation using SHA-256 algorithm
+ if (EVP_DigestSignInit(mdctx, NULL, EVP_sha256(), NULL, pkey) != 1) {
+ fprintf(stderr, "dkim: EVP_DigestSignInit() failed\n");
+ abort();
+ }
+
+ // free the private key (we don't need it past here)
+ EVP_PKEY_free(pkey);
+
+ // Call update with the "message" (the canonicalized headers)
+ if (EVP_DigestSignUpdate(mdctx, headers_hash, SHA256_DIGEST_LENGTH) != 1) {
+ fprintf(stderr, "dkim: EVP_DigestSignUpdate() failed\n");
+ abort();
+ }
+ free(headers_hash);
+
+ // Finalize the DigestSign operation.
+
+ // First call EVP_DigestSignFinal with a NULL sig parameter to obtain the length of the signature.
+ // Length is returned in slen
+ size_t slen;
+ if (EVP_DigestSignFinal(mdctx, NULL, &slen) != 1) {
+ fprintf(stderr, "dkim: EVP_DigestSignFinal() failed\n");
+ abort();
+ }
+
+ // Allocate memory for the signature based on size in slen
+ unsigned char *sig = NULL;
+ sig = OPENSSL_malloc(slen);
+ if (sig == NULL) {
+ fprintf(stderr, "dkim: OPENSSL_malloc() failed\n");
+ abort();
+ }
+
+ // Obtain the signature
+ if (EVP_DigestSignFinal(mdctx, sig, &slen) != 1) {
+ fprintf(stderr, "dkim: EVP_DigestSignFinal() failed\n");
+ abort();
+ }
+ EVP_MD_CTX_free(mdctx);
+
+ // base64 encode the signature
+ char *sig_b64 = dkim_base64_encode(sig, slen);
+ int sig_b64_len = strlen(sig_b64);
+ free(sig); // Free the raw signature, keep the b64-encoded one.
+
+ // We should probably wrap the dkim signature here.
+
+ // Add the signature to the original header block. Also append the extra CRLF indicating end of headers.
+ StrBufAppendPrintf(header_block, "DKIM-Signature: %s%s\r\n\r\n", (char *)ChrPtr(dkim_header), sig_b64);
+ FreeStrBuf(&dkim_header); // These were added to the final header block.
+ free(sig_b64); // So we don't need them anymore.
+
+ // Append the body.
+ StrBufAppendBuf(header_block, email, 0);
+ SwapBuffers(header_block, email);
+ FreeStrBuf(&header_block);
+
+ // And we're done!
+}
//
// This is the new, exciting, clever version that makes libcurl do all the work :)
//
-// Copyright (c) 1997-2023 by the citadel.org team
+// Copyright (c) 1997-2024 by the citadel.org team
//
// This program is open source software. Use, duplication, or disclosure
// is subject to the terms of the GNU General Public License, version 3.
process_rfc822_addr(recp, user, node, name); // split recipient address into username, hostname, displayname
num_mx = getmx(mxes, node);
if (num_mx < 1) {
- return (421);
+ return(421);
}
CC->redirect_buffer = NewStrBufPlain(NULL, SIZ);
+
+ // If we have a source room, it's probably a mailing list message; generate an unsubscribe header
if (!IsEmptyStr(source_room)) {
- // If we have a source room, it's probably a mailing list message; generate an unsubscribe header
- char esc_room[ROOMNAMELEN*2];
- char esc_email[1024];
- urlesc(esc_room, sizeof esc_room, source_room);
- urlesc(esc_email, sizeof esc_email, recp);
- cprintf("List-Unsubscribe: <http://%s/listsub?cmd=unsubscribe&room=%s&email=%s>\r\n",
- CtdlGetConfigStr("c_fqdn"),
- esc_room,
- esc_email
- );
+ char base_url[SIZ];
+ char unsubscribe_url[SIZ];
+ snprintf(base_url, sizeof base_url, "https://%s/listsub", CtdlGetConfigStr("c_fqdn"));
+ generate_one_click_url(unsubscribe_url, base_url, "unsubscribe", source_room, recp);
+ cprintf("List-Unsubscribe: %s\r\n", unsubscribe_url);
+ cprintf("List-Unsubscribe-Post: List-Unsubscribe=One-Click\r\n"); // RFC 8058
+
}
+
CtdlOutputMsg(msgid, MT_RFC822, HEADERS_ALL, 0, 1, NULL, 0, NULL, &fromaddr, NULL);
s.TheMessage = CC->redirect_buffer;
- s.bytes_total = StrLength(CC->redirect_buffer);
- s.bytes_sent = 0;
CC->redirect_buffer = NULL;
+
+#if 0
+ // FIXME genericize this
+ char *pkey_in =
+ "-----BEGIN PRIVATE KEY-----\n"
+ "MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQDfuefcepokRrnp\n"
+ "SSDsxu+QDqeD8GL9QnZz/N6IxTdBv6Wc10ExBe2IjS5dKI7AvhSSEK0zGE8Hkpmw\n"
+ "eccbiepQqeueteWzAMZ1uT43bD3k7eye7vWobiOP9QtoYGR6sG25h2W5Tbc91W4f\n"
+ "dvYnxYVJjx8wIVF0f3o25v+rQueoo0HlvGyA9/xi9GAaJL05OmK1xnMJgSvW/Q8Q\n"
+ "zq7apf1D6XPXHuhv5tevElkZ5jlvM2w0cTVyAzMrUh6Rkcn9xM4/NPWYghBc3jO4\n"
+ "TrPnSrobQGrX0fcizE/FN6I0in0Ke8Z+gMM8NeFcsjvLZe9MpY9i0pw/ygLIh5t3\n"
+ "O4qpwC1JAgMBAAECggEAIwiTCMEAGzciDKhhagJ66BWLYMtHTP5X2zDZThSH4xlW\n"
+ "HznL4RfbCtuEy5y6we7h/L90x8ACPB7WRz7CkYrmsMvy9A7q0b2I1k10MyyVgqBJ\n"
+ "QdgMitv4YKYQK7+QbG/tNrS/lqVXUOz3iiDQSgkRpqOtUBWfkj0WD7vbhF99NDhV\n"
+ "dxaehFkKv3yNy0bXJlHJBJ6KtOUnDwub8TExh8dyj3kB8Qzj4I98shaXPNUSSaOw\n"
+ "zG6QG72yrxlMs495jkIPbF2JDidmLrX+oVISwKyaBWx+BkFV/KFAEKgaB5/nCw7+\n"
+ "qq/jxsmXim3HuQ3MIAjq1yw9aGRH1HMi8Gn7tYlNGwKBgQDy6EEKpuEiW9wwlI2+\n"
+ "GVuSkhSTTX1h6qK/ay8Jtyb8yJM/BxogAQlfjdgFixiZHy5MaomTbfeT2GDji553\n"
+ "+RsnZ60+g7FI9nHwabSxtuCQ+vjbFqCsdMPAiSeG0bEzo0zf5TjASdUtuZL0vXjl\n"
+ "yMZWDEuESoVNlYlvCOVkw2nvIwKBgQDryPuSq6PNVHRWsKRRs5ju4wKs/1ucBOg5\n"
+ "gCcN8lE03mFCWAlZhypE4/fAhTQ/a5KQoAzc0QZcXRueDyNsnc+QWw3/QWf8/fkV\n"
+ "HPfTWS3Dcuj+4RnWUucaZ/mKFlTC3+eNSlpyaPIMlCjXGsJ9GlPrsaAi9KPbD2v/\n"
+ "XcMq/PMOowKBgHVf7S3sfZVQthFzdxqIvksQ84hKRW/vJT1B2bTkH56+fQhTsjgM\n"
+ "yC64J85l7DjxbDnYsSngVWXHhOnvKV/nq0tbOcefcydCjsQREBNfvxvPajjTskgj\n"
+ "FAQRQlxPL0U4f4khBk9EXhJ+PZithaHjZpNl1YfTSp62x3Yz4kTSeHnpAoGAGn5m\n"
+ "5kArE7NdrzACBrwrfww7DL1Uyd8zSOLBgKutvEcQnqfNxSWO9la3TAarrESmH2Ic\n"
+ "j+Nc15wOsl/5FwdUf1/73qa2zJKtHlY28qSeo8uRqrIYeSCvnyP3wjBoLc2C8zlb\n"
+ "mGd6azdqr2DuYahHrcAzwjnC/6Zn+DXM7FOn7AkCgYBp1xxY88cCoF24yffkD3MC\n"
+ "ACUury4qRSDTGx6/qCCkIyWxg1vuiDrlPWhSwQznxHvovcfpdjdbWcFY87IK6mpG\n"
+ "aJHwMJ7Kw+baoxGPZWHwdg6BgvUCihe3xlcaq6rOBoLviD6FOzbogg++Tvi0LemG\n"
+ "y/wEs/mZkaRzW4n41ir0Xw==\n"
+ "-----END PRIVATE KEY-----\n"
+ ;
+ dkim_sign(s.TheMessage, pkey_in, "dev.citadel.org", "foo");
+#endif
+
+ // Prepare the buffer for transmittal
+ s.bytes_total = StrLength(s.TheMessage);
+ s.bytes_sent = 0;
response_code = 421;
- // keep trying MXes until one works or we run out
+
+
+ // Keep trying MXes until one works or we run out.
for (i = 0; ((i < num_mx) && ((response_code / 100) == 4)); ++i) {
response_code = 421; // default 421 makes non-protocol errors transient
s.bytes_sent = 0; // rewind our buffer in case we try multiple MXes
msg = CtdlFetchMessage(qmsgnum, 1);
if (msg == NULL) {
- syslog(LOG_WARNING, "smtpclient: %ld does not exist", qmsgnum);
+ syslog(LOG_WARNING, "smtpclient: msg#%ld does not exist", qmsgnum);
return;
}
}
}
else {
- syslog(LOG_DEBUG, "smtpclient: %ld retry time not reached", qmsgnum);
+ syslog(LOG_DEBUG, "smtpclient: msg#%ld retry time not reached", qmsgnum);
}
if (bounceto != NULL) {
-/*
- * Copyright (c) 1998-2017 by the citadel.org team
- *
- * This program is open source software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- */
+// Copyright (c) 1998-2024 by the citadel.org team
+// This program is open source software. Use, duplication, or disclosure is subject to the GNU General Public License v3.
-struct citsmtp { /* Information about the current session */
+struct citsmtp { // Information about the current session
int command_state;
StrBuf *Cmd;
StrBuf *helo_node;
void smtp_do_bounce(const char *instr, int is_final);
char *smtpstatus(int code);
+void dkim_sign(StrBuf *email, char *pkey_in, char *domain, char *selector);
This is libcitadel, a library which contains code that is used in multiple
components of the Citadel system -- the server, the text mode client, and
WebCit. It is not intended to be a general-purpose library for widespread
-use, although there are parts of it that may be useful for that purpose,
-such as the MIME parser and the vCard data type.
+use, although there are parts of it that may be useful for that purpose.
-Copyright (c) 1987-2023 by the citadel.org development team.
-This program is distributed under the terms of the GNU General Public
-License, version 3.
+Copyright (c) 1987-2024 by the citadel.org development team.
+This program is open source software. Use, duplication, or disclosure is subject to the GNU General Public License v3.
To build and install libcitadel:
-// Copyright (c) 1987-2023 by the citadel.org team
+// Copyright (c) 1987-2024 by the citadel.org team
//
-// This program is open source software. Use, duplication, or disclosure
-// is subject to the terms of the GNU General Public License, version 3.
+// This program is open source software. Use, duplication, or disclosure is subject to the GNU General Public License, version 3.
#define _GNU_SOURCE
#include "sysdep.h"
#endif
int BaseStrBufSize = 64;
int EnableSplice = 0;
-int ZLibCompressionRatio = -1; /* defaults to 6 */
+int ZLibCompressionRatio = -1; // defaults to 6
#ifdef HAVE_ZLIB
-#define DEF_MEM_LEVEL 8 /*< memlevel??? */
-#define OS_CODE 0x03 /*< unix */
-const int gz_magic[2] = { 0x1f, 0x8b }; /* gzip magic header */
+#define DEF_MEM_LEVEL 8 // memlevel???
+#define OS_CODE 0x03 // unix
+const int gz_magic[2] = { 0x1f, 0x8b }; // gzip magic header
#endif
const char *StrBufNOTNULL = ((char*) NULL) - 1;
}
#else
-/* void it... */
+// void it...
#define dbg_FreeStrBuf(a, b)
#define dbg_IncreaseBuf(a)
#define dbg_Init(a)
#endif
-/*
- * swaps the contents of two StrBufs
- * this is to be used to have cheap switched between a work-buffer and a target buffer
- * A First one
- * B second one
- */
+// swaps the contents of two StrBufs
+// this is to be used to have cheap switched between a work-buffer and a target buffer
+// A First one
+// B second one
static inline void iSwapBuffers(StrBuf *A, StrBuf *B) {
StrBuf C;
}
-/*
- * Cast operator to Plain String
- * @note if the buffer is altered by StrBuf operations, this pointer may become
- * invalid. So don't lean on it after altering the buffer!
- * Since this operation is considered cheap, rather call it often than risking
- * your pointer to become invalid!
- * Str the string we want to get the c-string representation for
- * @returns the Pointer to the Content. Don't mess with it!
- */
+// Cast operator to Plain String
+// note: if the buffer is altered by StrBuf operations, this pointer may become
+// invalid. So don't lean on it after altering the buffer!
+// Since this operation is considered cheap, rather call it often than risking
+// your pointer to become invalid!
+// Str the string we want to get the c-string representation for
+// returns the Pointer to the Content. Don't mess with it!
inline const char *ChrPtr(const StrBuf *Str) {
if (Str == NULL)
return "";
}
-/*
- * since we know strlen()'s result, provide it here.
- * Str the string to return the length to
- * @returns contentlength of the buffer
- */
+// since we know strlen()'s result, provide it here.
+// Str the string to return the length to
+// returns contentlength of the buffer
inline int StrLength(const StrBuf *Str) {
return (Str != NULL) ? Str->BufUsed : 0;
}
}
-/*
- * shrink long term buffers to their real size so they don't waste memory
- * Buf buffer to shrink
- * Force if not set, will just executed if the buffer is much to big; set for lifetime strings
- * @returns physical size of the buffer
- */
+// shrink long term buffers to their real size so they don't waste memory
+// Buf buffer to shrink
+// Force if not set, will just executed if the buffer is much to big; set for lifetime strings
+// returns physical size of the buffer
long StrBufShrinkToFit(StrBuf *Buf, int Force) {
if (Buf == NULL)
return -1;
}
-/*
- * Allocate a new buffer with default buffer size
- * @returns the new stringbuffer
- */
+// Allocate a new buffer with default buffer size
+// returns the new stringbuffer
StrBuf *NewStrBuf(void) {
StrBuf *NewBuf;
}
-/*
- * Copy Constructor; returns a duplicate of CopyMe
- * CopyMe Buffer to faxmilate
- * @returns the new stringbuffer
- */
+// Copy Constructor; returns a duplicate of CopyMe
+// CopyMe Buffer to faxmilate
+// returns the new stringbuffer
StrBuf *NewStrBufDup(const StrBuf *CopyMe) {
StrBuf *NewBuf;
}
-/*
- * Copy Constructor; CreateRelpaceMe will contain CopyFlushMe afterwards.
- * NoMe if non-NULL, we will use that buffer as value; KeepOriginal will abused as len.
- * CopyFlushMe Buffer to faxmilate if KeepOriginal, or to move into CreateRelpaceMe if !KeepOriginal.
- * CreateRelpaceMe If NULL, will be created, else Flushed and filled CopyFlushMe
- * KeepOriginal should CopyFlushMe remain intact? or may we Steal its buffer?
- * @returns the new stringbuffer
- */
+// Copy Constructor; CreateRelpaceMe will contain CopyFlushMe afterwards.
+// NoMe if non-NULL, we will use that buffer as value; KeepOriginal will abused as len.
+// CopyFlushMe Buffer to faxmilate if KeepOriginal, or to move into CreateRelpaceMe if !KeepOriginal.
+// CreateRelpaceMe If NULL, will be created, else Flushed and filled CopyFlushMe
+// KeepOriginal should CopyFlushMe remain intact? or may we Steal its buffer?
+// returns the new stringbuffer
void NewStrBufDupAppendFlush(StrBuf **CreateRelpaceMe, StrBuf *CopyFlushMe, const char *NoMe, int KeepOriginal) {
StrBuf *NewBuf;
return;
}
- /*
- * Randomly Chosen: bigger than 64 chars is cheaper to swap the buffers instead of copying.
- * else *CreateRelpaceMe may use more memory than needed in a longer term, CopyFlushMe might
- * be a big IO-Buffer...
- */
+ // Randomly Chosen: bigger than 64 chars is cheaper to swap the buffers instead of copying.
+ // else *CreateRelpaceMe may use more memory than needed in a longer term, CopyFlushMe might
+ // be a big IO-Buffer...
if (KeepOriginal || (StrLength(CopyFlushMe) < 256)) {
if (*CreateRelpaceMe == NULL) {
*CreateRelpaceMe = NewBuf = NewStrBufPlain(NULL, CopyFlushMe->BufUsed);
}
-/*
- * create a new Buffer using an existing c-string
- * this function should also be used if you want to pre-suggest
- * the buffer size to allocate in conjunction with ptr == NULL
- * ptr the c-string to copy; may be NULL to create a blank instance
- * nChars How many chars should we copy; -1 if we should measure the length ourselves
- * @returns the new stringbuffer
- */
+// create a new Buffer using an existing c-string
+// this function should also be used if you want to pre-suggest
+// the buffer size to allocate in conjunction with ptr == NULL
+// ptr the c-string to copy; may be NULL to create a blank instance
+// nChars How many chars should we copy; -1 if we should measure the length ourselves
+// returns the new stringbuffer
StrBuf *NewStrBufPlain(const char* ptr, int nChars) {
StrBuf *NewBuf;
size_t Siz = BaseStrBufSize;
}
-/*
- * Set an existing buffer from a c-string
- * Buf buffer to load
- * ptr c-string to put into
- * nChars set to -1 if we should work 0-terminated
- * @returns the new length of the string
- */
+//
+// Set an existing buffer from a c-string
+// Buf buffer to load
+// ptr c-string to put into
+// nChars set to -1 if we should work 0-terminated
+// @returns the new length of the string
+///
int StrBufPlain(StrBuf *Buf, const char* ptr, int nChars) {
size_t Siz;
size_t CopySize;
}
-/*
- * use strbuf as wrapper for a string constant for easy handling
- * StringConstant a string to wrap
- * SizeOfStrConstant should be sizeof(StringConstant)-1
- */
-StrBuf* _NewConstStrBuf(const char* StringConstant, size_t SizeOfStrConstant)
-{
+//
+// use strbuf as wrapper for a string constant for easy handling
+// StringConstant a string to wrap
+// SizeOfStrConstant should be sizeof(StringConstant)-1
+///
+StrBuf *_NewConstStrBuf(const char* StringConstant, size_t SizeOfStrConstant) {
StrBuf *NewBuf;
NewBuf = (StrBuf*) malloc(sizeof(StrBuf));
}
-/*
- * flush the content of a Buf; keep its struct
- * buf Buffer to flush
- */
+//
+// flush the content of a Buf; keep its struct
+// buf Buffer to flush
+///
int FlushStrBuf(StrBuf *buf) {
if ((buf == NULL) || (buf->buf == NULL)) {
return -1;
return 0;
}
-/*
- * wipe the content of a Buf thoroughly (overwrite it -> expensive); keep its struct
- * buf Buffer to wipe
- */
-int FLUSHStrBuf(StrBuf *buf)
-{
+//
+// wipe the content of a Buf thoroughly (overwrite it -> expensive); keep its struct
+// buf Buffer to wipe
+///
+int FLUSHStrBuf(StrBuf *buf) {
if (buf == NULL)
return -1;
if (buf->ConstBuf)
#ifdef SIZE_DEBUG
int hFreeDbglog = -1;
#endif
-/*
- * Release a Buffer
- * Its a double pointer, so it can NULL your pointer
- * so fancy SIG11 appear instead of random results
- * FreeMe Pointer Pointer to the buffer to free
- */
-void FreeStrBuf (StrBuf **FreeMe)
-{
+//
+// Release a Buffer
+// Its a double pointer, so it can NULL your pointer
+// so fancy SIG11 appear instead of random results
+// FreeMe Pointer Pointer to the buffer to free
+///
+void FreeStrBuf (StrBuf **FreeMe) {
if (*FreeMe == NULL)
return;
*FreeMe = NULL;
}
-/*
- * flatten a Buffer to the Char * we return
- * Its a double pointer, so it can NULL your pointer
- * so fancy SIG11 appear instead of random results
- * The Callee then owns the buffer and is responsible for freeing it.
- * SmashMe Pointer Pointer to the buffer to release Buf from and free
- * @returns the pointer of the buffer; Callee owns the memory thereafter.
- */
+//
+// flatten a Buffer to the Char * we return
+// Its a double pointer, so it can NULL your pointer
+// so fancy SIG11 appear instead of random results
+// The Callee then owns the buffer and is responsible for freeing it.
+// SmashMe Pointer Pointer to the buffer to release Buf from and free
+// @returns the pointer of the buffer; Callee owns the memory thereafter.
+///
char *SmashStrBuf (StrBuf **SmashMe) {
char *Ret;
}
-/*
- * Release the buffer
- * If you want put your StrBuf into a Hash, use this as Destructor.
- * VFreeMe untyped pointer to a StrBuf. be shure to do the right thing [TM]
- */
+// Release the buffer
+// If you want put your StrBuf into a Hash, use this as Destructor.
+// VFreeMe untyped pointer to a StrBuf. be shure to do the right thing [TM]
void HFreeStrBuf (void *VFreeMe) {
StrBuf *FreeMe = (StrBuf*)VFreeMe;
if (FreeMe == NULL)
}
-/*******************************************************************************
- * Simple string transformations *
- *******************************************************************************/
+//******************************************************************************
+// Simple string transformations *
+//******************************************************************************/
-// Wrapper around atol
+// Wrapper around atol
long StrTol(const StrBuf *Buf) {
if (Buf == NULL)
return 0;
}
-// Wrapper around atoi
+// Wrapper around atoi
int StrToi(const StrBuf *Buf) {
if (Buf == NULL)
return 0;
return NCharsRemain;
}
-/**
- * Cut nChars from the start of the string
- * Buf Buffer to modify
- * nChars how many chars should be skipped?
- */
-void StrBufCutLeft(StrBuf *Buf, int nChars)
-{
+// Cut nChars from the start of the string
+// Buf Buffer to modify
+// nChars how many chars should be skipped?
+void StrBufCutLeft(StrBuf *Buf, int nChars) {
if ((Buf == NULL) || (Buf->BufUsed == 0)) return;
if (nChars >= Buf->BufUsed) {
FlushStrBuf(Buf);
Buf->buf[Buf->BufUsed] = '\0';
}
-/**
- * Cut the trailing n Chars from the string
- * Buf Buffer to modify
- * nChars how many chars should be trunkated?
- */
-void StrBufCutRight(StrBuf *Buf, int nChars)
-{
+// Cut the trailing n Chars from the string
+// Buf Buffer to modify
+// nChars how many chars should be trunkated?
+void StrBufCutRight(StrBuf *Buf, int nChars) {
if ((Buf == NULL) || (Buf->BufUsed == 0) || (Buf->buf == NULL))
return;
Buf->buf[Buf->BufUsed] = '\0';
}
-/**
- * Cut the string after n Chars
- * Buf Buffer to modify
- * AfternChars after how many chars should we trunkate the string?
- * At if non-null and points inside of our string, cut it there.
- */
-void StrBufCutAt(StrBuf *Buf, int AfternChars, const char *At)
-{
+
+// Cut the string after n Chars
+// Buf Buffer to modify
+// AfternChars after how many chars should we trunkate the string?
+// At if non-null and points inside of our string, cut it there.
+void StrBufCutAt(StrBuf *Buf, int AfternChars, const char *At) {
if ((Buf == NULL) || (Buf->BufUsed == 0)) return;
if (At != NULL){
AfternChars = At - Buf->buf;
}
-/**
- * Strip leading and trailing spaces from a string; with premeasured and adjusted length.
- * Buf the string to modify
- */
-void StrBufTrim(StrBuf *Buf)
-{
+// Strip leading and trailing spaces from a string; with premeasured and adjusted length.
+// Buf the string to modify
+void StrBufTrim(StrBuf *Buf) {
int delta = 0;
if ((Buf == NULL) || (Buf->BufUsed == 0)) return;
}
if (delta > 0) StrBufCutLeft(Buf, delta);
}
-/**
- * changes all spaces in the string (tab, linefeed...) to Blank (0x20)
- * Buf the string to modify
- */
-void StrBufSpaceToBlank(StrBuf *Buf)
-{
+
+
+// changes all spaces in the string (tab, linefeed...) to Blank (0x20)
+// Buf the string to modify
+void StrBufSpaceToBlank(StrBuf *Buf) {
char *pche, *pch;
if ((Buf == NULL) || (Buf->BufUsed == 0)) return;
}
}
-void StrBufStripAllBut(StrBuf *Buf, char leftboundary, char rightboundary)
-{
+void StrBufStripAllBut(StrBuf *Buf, char leftboundary, char rightboundary) {
const char *pLeft;
const char *pRight;
}
-/**
- * uppercase the contents of a buffer
- * Buf the buffer to translate
- */
-void StrBufUpCase(StrBuf *Buf)
-{
+// uppercase the contents of a buffer
+// Buf the buffer to translate
+void StrBufUpCase(StrBuf *Buf) {
char *pch, *pche;
if ((Buf == NULL) || (Buf->BufUsed == 0)) return;
}
-/**
- * lowercase the contents of a buffer
- * Buf the buffer to translate
- */
-void StrBufLowerCase(StrBuf *Buf)
-{
+// lowercase the contents of a buffer
+// Buf the buffer to translate
+void StrBufLowerCase(StrBuf *Buf) {
char *pch, *pche;
if ((Buf == NULL) || (Buf->BufUsed == 0)) return;
}
-/*******************************************************************************
- * a tokenizer that kills, maims, and destroys *
- *******************************************************************************/
+//******************************************************************************
+// a tokenizer that kills, maims, and destroys *
+//******************************************************************************/
-/**
- * Replace a token at a given place with a given length by another token with given length
- * Buf String where to work on
- * where where inside of the Buf is the search-token
- * HowLong How long is the token to be replaced
- * Repl Token to insert at 'where'
- * ReplLen Length of repl
- * @returns -1 if fail else length of resulting Buf
- */
+//*
+// Replace a token at a given place with a given length by another token with given length
+// Buf String where to work on
+// where where inside of the Buf is the search-token
+// HowLong How long is the token to be replaced
+// Repl Token to insert at 'where'
+// ReplLen Length of repl
+// @returns -1 if fail else length of resulting Buf
+///
int StrBufReplaceToken(StrBuf *Buf, long where, long HowLong, const char *Repl, long ReplLen) {
if ((Buf == NULL) || (where > Buf->BufUsed) || (where + HowLong > Buf->BufUsed)) {
memmove(Buf->buf + where + ReplLen, Buf->buf + where + HowLong, Buf->BufUsed - where - HowLong);
memcpy(Buf->buf + where, Repl, ReplLen);
Buf->BufUsed += ReplLen - HowLong;
+ Buf->buf[Buf->BufUsed] = 0;
return Buf->BufUsed;
}
-/**
- * Counts the numbmer of tokens in a buffer
- * source String to count tokens in
- * tok Tokenizer char to count
- * @returns numbers of tokenizer chars found
- */
+// Counts the numbmer of tokens in a buffer
+// source String to count tokens in
+// tok Tokenizer char to count
+// @returns numbers of tokenizer chars found
int StrBufNum_tokens(const StrBuf *source, char tok) {
char *pch, *pche;
long NTokens;
return NTokens;
}
-/**
- * a string tokenizer
- * Source StringBuffer to read into
- * parmnum n'th Parameter to remove
- * separator tokenizer character
- * @returns -1 if not found, else length of token.
- */
-int StrBufRemove_token(StrBuf *Source, int parmnum, char separator)
-{
+
+// a string tokenizer
+// Source StringBuffer to read into
+// parmnum n'th Parameter to remove
+// separator tokenizer character
+// @returns -1 if not found, else length of token.
+int StrBufRemove_token(StrBuf *Source, int parmnum, char separator) {
int ReducedBy;
- char *d, *s, *end; /* dest, source */
+ char *d, *s, *end; // dest, source
int count = 0;
- /* Find desired eter */
+ // Find desired eter
end = Source->buf + Source->BufUsed;
d = Source->buf;
while ((d <= end) && (count < parmnum)) {
- /* End of string, bail! */
+ // End of string, bail!
if (!*d) {
d = NULL;
break;
d++;
}
if ((d == NULL) || (d >= end))
- return 0; /* @Parameter not found */
+ return 0; // Parameter not found
- /* Find next eter */
+ // Find next eter
s = d;
while ((s <= end) && (*s && *s != separator)) {
s++;
s++;
ReducedBy = d - s;
- /* Hack and slash */
+ // Hack and slash
if (s >= end) {
return 0;
}
*--d = '\0';
Source->BufUsed += ReducedBy;
}
- /*
- while (*s) {
- *d++ = *s++;
- }
- *d = 0;
- */
+
+ //while (*s) {
+ //*d++ = *s++;
+ //}
+ //*d = 0;
+
return ReducedBy;
}
-int StrBufExtract_tokenFromStr(StrBuf *dest, const char *Source, long SourceLen, int parmnum, char separator)
-{
+int StrBufExtract_tokenFromStr(StrBuf *dest, const char *Source, long SourceLen, int parmnum, char separator) {
const StrBuf Temp = {
(char*)Source,
SourceLen,
return StrBufExtract_token(dest, &Temp, parmnum, separator);
}
-/**
- * a string tokenizer
- * dest Destination StringBuffer
- * Source StringBuffer to read into
- * parmnum n'th Parameter to extract
- * separator tokenizer character
- * @returns -1 if not found, else length of token.
- */
-int StrBufExtract_token(StrBuf *dest, const StrBuf *Source, int parmnum, char separator)
-{
- const char *s, *e; //* source * /
- int len = 0; //* running total length of extracted string * /
- int current_token = 0; //* token currently being processed * /
+// a string tokenizer
+// dest Destination StringBuffer
+// Source StringBuffer to read into
+// parmnum n'th Parameter to extract
+// separator tokenizer character
+// returns -1 if not found, else length of token.
+int StrBufExtract_token(StrBuf *dest, const StrBuf *Source, int parmnum, char separator) {
+ const char *s, *e; // source
+ int len = 0; // running total length of extracted string
+ int current_token = 0; // token currently being processed
if (dest != NULL) {
dest->buf[0] = '\0';
}
-
-
-
-/**
- * a string tokenizer to fetch an integer
- * Source String containing tokens
- * parmnum n'th Parameter to extract
- * separator tokenizer character
- * @returns 0 if not found, else integer representation of the token
- */
-int StrBufExtract_int(const StrBuf* Source, int parmnum, char separator)
-{
+// a string tokenizer to fetch an integer
+// Source String containing tokens
+// parmnum n'th Parameter to extract
+// separator tokenizer character
+// @returns 0 if not found, else integer representation of the token
+int StrBufExtract_int(const StrBuf* Source, int parmnum, char separator) {
StrBuf tmp;
char buf[64];
return 0;
}
-/**
- * a string tokenizer to fetch a long integer
- * Source String containing tokens
- * parmnum n'th Parameter to extract
- * separator tokenizer character
- * @returns 0 if not found, else long integer representation of the token
- */
-long StrBufExtract_long(const StrBuf* Source, int parmnum, char separator)
-{
+
+// a string tokenizer to fetch a long integer
+// Source String containing tokens
+// parmnum n'th Parameter to extract
+// separator tokenizer character
+// returns 0 if not found, else long integer representation of the token
+long StrBufExtract_long(const StrBuf* Source, int parmnum, char separator) {
StrBuf tmp;
char buf[64];
}
-/**
- * a string tokenizer to fetch an unsigned long
- * Source String containing tokens
- * parmnum n'th Parameter to extract
- * separator tokenizer character
- * @returns 0 if not found, else unsigned long representation of the token
- */
-unsigned long StrBufExtract_unsigned_long(const StrBuf* Source, int parmnum, char separator)
-{
+// a string tokenizer to fetch an unsigned long
+// Source String containing tokens
+// parmnum n'th Parameter to extract
+// separator tokenizer character
+// returns 0 if not found, else unsigned long representation of the token
+unsigned long StrBufExtract_unsigned_long(const StrBuf* Source, int parmnum, char separator) {
StrBuf tmp;
char buf[64];
char *pnum;
}
-
-/**
- * a string tokenizer; Bounds checker
- * function to make shure whether StrBufExtract_NextToken and friends have reached the end of the string.
- * Source our tokenbuffer
- * pStart the token iterator pointer to inspect
- * @returns whether the revolving pointer is inside of the search range
- */
+// a string tokenizer; Bounds checker
+// function to make shure whether StrBufExtract_NextToken and friends have reached the end of the string.
+// Source our tokenbuffer
+// pStart the token iterator pointer to inspect
+// returns whether the revolving pointer is inside of the search range
int StrBufHaveNextToken(const StrBuf *Source, const char **pStart) {
if ((Source == NULL) || (*pStart == StrBufNOTNULL) || (Source->BufUsed == 0)) {
return 0;
* PlainIn way in from plain old c strings
* PlainInLen way in from plain old c strings; maybe you've got binary data or know the length?
*/
-void StrBufHexEscAppend(StrBuf *OutBuf, const StrBuf *In, const unsigned char *PlainIn, long PlainInLen)
-{
+void StrBufHexEscAppend(StrBuf *OutBuf, const StrBuf *In, const unsigned char *PlainIn, long PlainInLen) {
const unsigned char *pch, *pche;
char *pt, *pte;
int len;
* nolinebreaks if set to 1, linebreaks are removed from the string.
* if set to 2, linebreaks are replaced by <br/>
*/
-long StrEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn, int nbsp, int nolinebreaks)
-{
+long StrEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn, int nbsp, int nolinebreaks) {
const char *aptr, *eiptr;
char *bptr, *eptr;
long len;
* Source source buffer; set to NULL if you just have a C-String
* PlainIn Plain-C string to append; set to NULL if unused
*/
-void StrMsgEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn)
-{
+void StrMsgEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn) {
const char *aptr, *eiptr;
char *tptr, *eptr;
long len;
* Source source buffer; set to NULL if you just have a C-String
* PlainIn Plain-C string to append; set to NULL if unused
*/
-void StrIcalEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn)
-{
+void StrIcalEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn) {
const char *aptr, *eiptr;
char *tptr, *eptr;
long len;
* PlainIn Plain-C string to append; set to NULL if unused
* @returns size of result or -1
*/
-long StrECMAEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn)
-{
+long StrECMAEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn) {
const char *aptr, *eiptr;
char *bptr, *eptr;
long len;
* Mute char to put over invalid chars
* Buf Buffor to transform
*/
-int StrBufSanitizeAscii(StrBuf *Buf, const char Mute)
-{
+int StrBufSanitizeAscii(StrBuf *Buf, const char Mute) {
unsigned char *pch;
if (Buf == NULL) return -1;
* Buf Buffer to translate
* StripBlanks Reduce several blanks to one?
*/
-long StrBufUnescape(StrBuf *Buf, int StripBlanks)
-{
+long StrBufUnescape(StrBuf *Buf, int StripBlanks) {
int a, b;
char hex[3];
long len;
* source Source string to be encoded.
* @returns encoded length; -1 if non success.
*/
-int StrBufRFC2047encode(StrBuf **target, const StrBuf *source)
-{
+int StrBufRFC2047encode(StrBuf **target, const StrBuf *source) {
const char headerStr[] = "=?UTF-8?Q?";
int need_to_encode = 0;
int i = 0;
* removes all \\r s from the string, or replaces them with \n if its not a combination of both.
* buf Buffer to modify
*/
-void StrBufToUnixLF(StrBuf *buf)
-{
+void StrBufToUnixLF(StrBuf *buf) {
char *pche, *pchS, *pchT;
if (buf == NULL)
return;
* fromcode Source encoding
* pic anonimized pointer to iconv struct
*/
-void ctdl_iconv_open(const char *tocode, const char *fromcode, void *pic)
-{
+void ctdl_iconv_open(const char *tocode, const char *fromcode, void *pic) {
#ifdef HAVE_ICONV
iconv_t ic = (iconv_t)(-1) ;
ic = iconv_open(tocode, fromcode);
* bptr where to start searching
* @returns found position, NULL if none.
*/
-static inline const char *FindNextEnd (const StrBuf *Buf, const char *bptr)
-{
+static inline const char *FindNextEnd (const StrBuf *Buf, const char *bptr) {
const char * end;
/* Find the next ?Q? */
if (Buf->BufUsed - (bptr - Buf->buf) < 6)
* TmpBuf To share a workbuffer over several iterations. prepare to have it filled with useless stuff afterwards.
* pic Pointer to the iconv-session Object
*/
-void StrBufConvert(StrBuf *ConvertBuf, StrBuf *TmpBuf, void *pic)
-{
+void StrBufConvert(StrBuf *ConvertBuf, StrBuf *TmpBuf, void *pic) {
#ifdef HAVE_ICONV
long trycount = 0;
size_t siz;
* FoundCharset overrides DefaultCharset if non-empty; If we find a charset inside of the string,
* put it here for later use where no string might be known.
*/
-void StrBuf_RFC822_to_Utf8(StrBuf *Target, const StrBuf *DecodeMe, const StrBuf* DefaultCharset, StrBuf *FoundCharset)
-{
+void StrBuf_RFC822_to_Utf8(StrBuf *Target, const StrBuf *DecodeMe, const StrBuf* DefaultCharset, StrBuf *FoundCharset) {
StrBuf *ConvertBuf;
StrBuf *ConvertBuf2;
ConvertBuf = NewStrBufPlain(NULL, StrLength(DecodeMe));
* Char the character to examine
* @returns width of utf8 chars in bytes; if the sequence is broken 0 is returned; 1 if its simply ASCII.
*/
-static inline int Ctdl_GetUtf8SequenceLength(const char *CharS, const char *CharE)
-{
+static inline int Ctdl_GetUtf8SequenceLength(const char *CharS, const char *CharE) {
int n = 0;
unsigned char test = (1<<7);
* Char character to inspect
* @returns yes or no
*/
-static inline int Ctdl_IsUtf8SequenceStart(const char Char)
-{
+static inline int Ctdl_IsUtf8SequenceStart(const char Char) {
/** 11??.???? indicates an UTF8 Sequence. */
return ((Char & 0xC0) == 0xC0);
}
* Buf string to measure
* @returns the number of glyphs in Buf
*/
-long StrBuf_Utf8StrLen(StrBuf *Buf)
-{
+long StrBuf_Utf8StrLen(StrBuf *Buf) {
int n = 0;
int m = 0;
char *aptr, *eptr;
* maxlen how long may the string become?
* @returns current length of the string
*/
-long StrBuf_Utf8StrCut(StrBuf *Buf, int maxlen)
-{
+long StrBuf_Utf8StrCut(StrBuf *Buf, int maxlen) {
char *aptr, *eptr;
int n = 0, m = 0;
* Attention! If you feed this a Const String, you must maintain the uncompressed buffer yourself!
* Buf buffer whose content is to be gzipped
*/
-int CompressBuffer(StrBuf *Buf)
-{
+int CompressBuffer(StrBuf *Buf) {
#ifdef HAVE_ZLIB
char *compressed_data = NULL;
size_t compressed_len, bufsize;
* File I/O; Callbacks to libevent *
*******************************************************************************/
-long StrBuf_read_one_chunk_callback (int fd, short event, IOBuffer *FB)
-{
+long StrBuf_read_one_chunk_callback (int fd, short event, IOBuffer *FB) {
long bufremain = 0;
int n;
* check whether the chunk-buffer has more data waiting or not.
* FB Chunk-Buffer to inspect
*/
-eReadState StrBufCheckBuffer(IOBuffer *FB)
-{
+eReadState StrBufCheckBuffer(IOBuffer *FB) {
if (FB == NULL)
return eReadFail;
if (FB->Buf->BufUsed == 0)
* Error strerror() on error
* @returns numbers of chars read
*/
-int StrBufTCP_read_line(StrBuf *buf, int *fd, int append, const char **Error)
-{
+int StrBufTCP_read_line(StrBuf *buf, int *fd, int append, const char **Error) {
int len, rlen, slen;
if ((buf == NULL) || (buf->buf == NULL)) {
* Error strerror() on error
* @returns numbers of chars read
*/
-int StrBufReadBLOB(StrBuf *Buf, int *fd, int append, long nBytes, const char **Error)
-{
+int StrBufReadBLOB(StrBuf *Buf, int *fd, int append, long nBytes, const char **Error) {
int fdflags;
int rlen;
int nSuccessLess;