320 lines
6.8 KiB
C
320 lines
6.8 KiB
C
/* $OpenBSD: queue_ram.c,v 1.11 2021/06/14 17:58:16 eric Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 2012 Eric Faurot <eric@openbsd.org>
|
|
*
|
|
* Permission to use, copy, modify, and distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice appear in all copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include "smtpd.h"
|
|
#include "log.h"
|
|
|
|
struct qr_envelope {
|
|
char *buf;
|
|
size_t len;
|
|
};
|
|
|
|
struct qr_message {
|
|
char *buf;
|
|
size_t len;
|
|
struct tree envelopes;
|
|
};
|
|
|
|
static struct tree messages;
|
|
|
|
static struct qr_message *
|
|
get_message(uint32_t msgid)
|
|
{
|
|
struct qr_message *msg;
|
|
|
|
msg = tree_get(&messages, msgid);
|
|
if (msg == NULL)
|
|
log_warn("warn: queue-ram: message not found");
|
|
|
|
return (msg);
|
|
}
|
|
|
|
static int
|
|
queue_ram_message_create(uint32_t *msgid)
|
|
{
|
|
struct qr_message *msg;
|
|
|
|
msg = calloc(1, sizeof(*msg));
|
|
if (msg == NULL) {
|
|
log_warn("warn: queue-ram: calloc");
|
|
return (0);
|
|
}
|
|
tree_init(&msg->envelopes);
|
|
|
|
do {
|
|
*msgid = queue_generate_msgid();
|
|
} while (tree_check(&messages, *msgid));
|
|
|
|
tree_xset(&messages, *msgid, msg);
|
|
|
|
return (1);
|
|
}
|
|
|
|
static int
|
|
queue_ram_message_commit(uint32_t msgid, const char *path)
|
|
{
|
|
struct qr_message *msg;
|
|
struct stat sb;
|
|
size_t n;
|
|
FILE *f;
|
|
int ret;
|
|
|
|
if ((msg = tree_get(&messages, msgid)) == NULL) {
|
|
log_warnx("warn: queue-ram: msgid not found");
|
|
return (0);
|
|
}
|
|
|
|
f = fopen(path, "rb");
|
|
if (f == NULL) {
|
|
log_warn("warn: queue-ram: fopen: %s", path);
|
|
return (0);
|
|
}
|
|
if (fstat(fileno(f), &sb) == -1) {
|
|
log_warn("warn: queue-ram: fstat");
|
|
fclose(f);
|
|
return (0);
|
|
}
|
|
|
|
msg->len = sb.st_size;
|
|
msg->buf = malloc(msg->len);
|
|
if (msg->buf == NULL) {
|
|
log_warn("warn: queue-ram: malloc");
|
|
fclose(f);
|
|
return (0);
|
|
}
|
|
|
|
ret = 0;
|
|
n = fread(msg->buf, 1, msg->len, f);
|
|
if (ferror(f))
|
|
log_warn("warn: queue-ram: fread");
|
|
else if ((off_t)n != sb.st_size)
|
|
log_warnx("warn: queue-ram: bad read");
|
|
else {
|
|
ret = 1;
|
|
stat_increment("queue.ram.message.size", msg->len);
|
|
}
|
|
fclose(f);
|
|
|
|
return (ret);
|
|
}
|
|
|
|
static int
|
|
queue_ram_message_delete(uint32_t msgid)
|
|
{
|
|
struct qr_message *msg;
|
|
struct qr_envelope *evp;
|
|
uint64_t evpid;
|
|
|
|
if ((msg = tree_pop(&messages, msgid)) == NULL) {
|
|
log_warnx("warn: queue-ram: not found");
|
|
return (0);
|
|
}
|
|
while (tree_poproot(&messages, &evpid, (void**)&evp)) {
|
|
stat_decrement("queue.ram.envelope.size", evp->len);
|
|
free(evp->buf);
|
|
free(evp);
|
|
}
|
|
stat_decrement("queue.ram.message.size", msg->len);
|
|
free(msg->buf);
|
|
free(msg);
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
queue_ram_message_fd_r(uint32_t msgid)
|
|
{
|
|
struct qr_message *msg;
|
|
size_t n;
|
|
FILE *f;
|
|
int fd, fd2;
|
|
|
|
if ((msg = tree_get(&messages, msgid)) == NULL) {
|
|
log_warnx("warn: queue-ram: not found");
|
|
return (-1);
|
|
}
|
|
|
|
fd = mktmpfile();
|
|
if (fd == -1) {
|
|
log_warn("warn: queue-ram: mktmpfile");
|
|
return (-1);
|
|
}
|
|
|
|
fd2 = dup(fd);
|
|
if (fd2 == -1) {
|
|
log_warn("warn: queue-ram: dup");
|
|
close(fd);
|
|
return (-1);
|
|
}
|
|
f = fdopen(fd2, "w");
|
|
if (f == NULL) {
|
|
log_warn("warn: queue-ram: fdopen");
|
|
close(fd);
|
|
close(fd2);
|
|
return (-1);
|
|
}
|
|
n = fwrite(msg->buf, 1, msg->len, f);
|
|
if (n != msg->len) {
|
|
log_warn("warn: queue-ram: write");
|
|
close(fd);
|
|
fclose(f);
|
|
return (-1);
|
|
}
|
|
fclose(f);
|
|
lseek(fd, 0, SEEK_SET);
|
|
return (fd);
|
|
}
|
|
|
|
static int
|
|
queue_ram_envelope_create(uint32_t msgid, const char *buf, size_t len,
|
|
uint64_t *evpid)
|
|
{
|
|
struct qr_envelope *evp;
|
|
struct qr_message *msg;
|
|
|
|
if ((msg = get_message(msgid)) == NULL)
|
|
return (0);
|
|
|
|
do {
|
|
*evpid = queue_generate_evpid(msgid);
|
|
} while (tree_check(&msg->envelopes, *evpid));
|
|
evp = calloc(1, sizeof *evp);
|
|
if (evp == NULL) {
|
|
log_warn("warn: queue-ram: calloc");
|
|
return (0);
|
|
}
|
|
evp->len = len;
|
|
evp->buf = malloc(len);
|
|
if (evp->buf == NULL) {
|
|
log_warn("warn: queue-ram: malloc");
|
|
free(evp);
|
|
return (0);
|
|
}
|
|
memmove(evp->buf, buf, len);
|
|
tree_xset(&msg->envelopes, *evpid, evp);
|
|
stat_increment("queue.ram.envelope.size", len);
|
|
return (1);
|
|
}
|
|
|
|
static int
|
|
queue_ram_envelope_delete(uint64_t evpid)
|
|
{
|
|
struct qr_envelope *evp;
|
|
struct qr_message *msg;
|
|
|
|
if ((msg = get_message(evpid_to_msgid(evpid))) == NULL)
|
|
return (0);
|
|
|
|
if ((evp = tree_pop(&msg->envelopes, evpid)) == NULL) {
|
|
log_warnx("warn: queue-ram: not found");
|
|
return (0);
|
|
}
|
|
stat_decrement("queue.ram.envelope.size", evp->len);
|
|
free(evp->buf);
|
|
free(evp);
|
|
if (tree_empty(&msg->envelopes)) {
|
|
tree_xpop(&messages, evpid_to_msgid(evpid));
|
|
stat_decrement("queue.ram.message.size", msg->len);
|
|
free(msg->buf);
|
|
free(msg);
|
|
}
|
|
return (1);
|
|
}
|
|
|
|
static int
|
|
queue_ram_envelope_update(uint64_t evpid, const char *buf, size_t len)
|
|
{
|
|
struct qr_envelope *evp;
|
|
struct qr_message *msg;
|
|
void *tmp;
|
|
|
|
if ((msg = get_message(evpid_to_msgid(evpid))) == NULL)
|
|
return (0);
|
|
|
|
if ((evp = tree_get(&msg->envelopes, evpid)) == NULL) {
|
|
log_warn("warn: queue-ram: not found");
|
|
return (0);
|
|
}
|
|
tmp = malloc(len);
|
|
if (tmp == NULL) {
|
|
log_warn("warn: queue-ram: malloc");
|
|
return (0);
|
|
}
|
|
memmove(tmp, buf, len);
|
|
free(evp->buf);
|
|
evp->len = len;
|
|
evp->buf = tmp;
|
|
stat_decrement("queue.ram.envelope.size", evp->len);
|
|
stat_increment("queue.ram.envelope.size", len);
|
|
return (1);
|
|
}
|
|
|
|
static int
|
|
queue_ram_envelope_load(uint64_t evpid, char *buf, size_t len)
|
|
{
|
|
struct qr_envelope *evp;
|
|
struct qr_message *msg;
|
|
|
|
if ((msg = get_message(evpid_to_msgid(evpid))) == NULL)
|
|
return (0);
|
|
|
|
if ((evp = tree_get(&msg->envelopes, evpid)) == NULL) {
|
|
log_warn("warn: queue-ram: not found");
|
|
return (0);
|
|
}
|
|
if (len < evp->len) {
|
|
log_warnx("warn: queue-ram: buffer too small");
|
|
return (0);
|
|
}
|
|
memmove(buf, evp->buf, evp->len);
|
|
return (evp->len);
|
|
}
|
|
|
|
static int
|
|
queue_ram_envelope_walk(uint64_t *evpid, char *buf, size_t len)
|
|
{
|
|
return (-1);
|
|
}
|
|
|
|
static int
|
|
queue_ram_init(struct passwd *pw, int server, const char * conf)
|
|
{
|
|
tree_init(&messages);
|
|
|
|
queue_api_on_message_create(queue_ram_message_create);
|
|
queue_api_on_message_commit(queue_ram_message_commit);
|
|
queue_api_on_message_delete(queue_ram_message_delete);
|
|
queue_api_on_message_fd_r(queue_ram_message_fd_r);
|
|
queue_api_on_envelope_create(queue_ram_envelope_create);
|
|
queue_api_on_envelope_delete(queue_ram_envelope_delete);
|
|
queue_api_on_envelope_update(queue_ram_envelope_update);
|
|
queue_api_on_envelope_load(queue_ram_envelope_load);
|
|
queue_api_on_envelope_walk(queue_ram_envelope_walk);
|
|
|
|
return (1);
|
|
}
|
|
|
|
struct queue_backend queue_backend_ram = {
|
|
queue_ram_init,
|
|
};
|