path: root/usr.sbin/spamdb/spamdb.c

/*	$OpenBSD: spamdb.c,v 1.36 2018/07/26 19:33:20 mestre Exp $	*/

/*
 * Copyright (c) 2004 Bob Beck.  All rights reserved.
 *
 * 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/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <db.h>
#include <err.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <netdb.h>
#include <ctype.h>
#include <errno.h>
#include <unistd.h>

#include "grey.h"

/* things we may add/delete from the db */
#define WHITE 0
#define TRAPHIT 1
#define SPAMTRAP 2
#define GREY 3

int	dblist(DB *);
int	dbupdate(DB *, char *, int, int);

int
dbupdate(DB *db, char *ip, int add, int type)
{
	DBT		dbk, dbd;
	struct gdata	gd;
	time_t		now;
	int		r;
	struct addrinfo hints, *res;

	now = time(NULL);
	memset(&hints, 0, sizeof(hints));
	hints.ai_family = PF_UNSPEC;
	hints.ai_socktype = SOCK_DGRAM;	/*dummy*/
	hints.ai_flags = AI_NUMERICHOST;
	if (add && (type == TRAPHIT || type == WHITE)) {
		if (getaddrinfo(ip, NULL, &hints, &res) != 0) {
			warnx("invalid ip address %s", ip);
			goto bad;
		}
		freeaddrinfo(res);
	}
	memset(&dbk, 0, sizeof(dbk));
	dbk.size = strlen(ip);
	dbk.data = ip;
	memset(&dbd, 0, sizeof(dbd));
	if (!add) {
		/* remove entry */
		if (type == GREY) {
			for (r = db->seq(db, &dbk, &dbd, R_FIRST); !r;
			    r = db->seq(db, &dbk, &dbd, R_NEXT)) {
				char *cp = memchr(dbk.data, '\n', dbk.size);
				if (cp != NULL) {
					size_t len = cp - (char *)dbk.data;
					if (memcmp(ip, dbk.data, len) == 0 &&
					    ip[len] == '\0')
						break;
				}
			}
		} else {
			r = db->get(db, &dbk, &dbd, 0);
			if (r == -1) {
				warn("db->get failed");
				goto bad;
			}
		}
		if (r) {
			warnx("no entry for %s", ip);
			goto bad;
		} else if (db->del(db, &dbk, 0)) {
			warn("db->del failed");
			goto bad;
		}
	} else {
		/* add or update entry */
		r = db->get(db, &dbk, &dbd, 0);
		if (r == -1) {
			warn("db->get failed");
			goto bad;
		}
		if (r) {
			int i;

			/* new entry */
			memset(&gd, 0, sizeof(gd));
			gd.first = now;
			gd.bcount = 1;
			switch (type) {
			case WHITE:
				gd.pass = now;
				gd.expire = now + WHITEEXP;
				break;
			case TRAPHIT:
				gd.expire = now + TRAPEXP;
				gd.pcount = -1;
				break;
			case SPAMTRAP:
				gd.expire = 0;
				gd.pcount = -2;
				/* ensure address is of the form user@host */
				if (strchr(ip, '@') == NULL)
					errx(-1, "not an email address: %s", ip);
				/* ensure address is lower case*/
				for (i = 0; ip[i] != '\0'; i++)
					if (isupper((unsigned char)ip[i]))
						ip[i] = tolower((unsigned char)ip[i]);
				break;
			default:
				errx(-1, "unknown type %d", type);
			}
			memset(&dbk, 0, sizeof(dbk));
			dbk.size = strlen(ip);
			dbk.data = ip;
			memset(&dbd, 0, sizeof(dbd));
			dbd.size = sizeof(gd);
			dbd.data = &gd;
			r = db->put(db, &dbk, &dbd, 0);
			if (r) {
				warn("db->put failed");
				goto bad;
			}
		} else {
			if (gdcopyin(&dbd, &gd) == -1) {
				/* whatever this is, it doesn't belong */
				db->del(db, &dbk, 0);
				goto bad;
			}
			gd.pcount++;
			switch (type) {
			case WHITE:
				gd.pass = now;
				gd.expire = now + WHITEEXP;
				break;
			case TRAPHIT:
				gd.expire = now + TRAPEXP;
				gd.pcount = -1;
				break;
			case SPAMTRAP:
				gd.expire = 0; /* XXX */
				gd.pcount = -2;
				break;
			default:
				errx(-1, "unknown type %d", type);
			}

			memset(&dbk, 0, sizeof(dbk));
			dbk.size = strlen(ip);
			dbk.data = ip;
			memset(&dbd, 0, sizeof(dbd));
			dbd.size = sizeof(gd);
			dbd.data = &gd;
			r = db->put(db, &dbk, &dbd, 0);
			if (r) {
				warn("db->put failed");
				goto bad;
			}
		}
	}
	return (0);
 bad:
	return (1);
}

int
print_entry(DBT *dbk, DBT *dbd)
{
	struct gdata gd;
	char *a, *cp;

	if ((dbk->size < 1) || gdcopyin(dbd, &gd) == -1) {
		warnx("bogus size db entry - bad db file?");
		return (1);
	}
	a = malloc(dbk->size + 1);
	if (a == NULL)
		err(1, "malloc");
	memcpy(a, dbk->data, dbk->size);
	a[dbk->size]='\0';
	cp = strchr(a, '\n');
	if (cp == NULL) {
		/* this is a non-greylist entry */
		switch (gd.pcount) {
		case -1: /* spamtrap hit, with expiry time */
			printf("TRAPPED|%s|%lld\n", a,
			    (long long)gd.expire);
			break;
		case -2: /* spamtrap address */
			printf("SPAMTRAP|%s\n", a);
			break;
		default: /* whitelist */
			printf("WHITE|%s|||%lld|%lld|%lld|%d|%d\n", a,
			    (long long)gd.first, (long long)gd.pass,
			    (long long)gd.expire, gd.bcount,
			    gd.pcount);
			break;
		}
	} else {
		char *helo, *from, *to;

		/* greylist entry */
		*cp = '\0';
		helo = cp + 1;
		from = strchr(helo, '\n');
		if (from == NULL) {
			warnx("No from part in grey key %s", a);
			free(a);
			return (1);
		}
		*from = '\0';
		from++;
		to = strchr(from, '\n');
		if (to == NULL) {
			/* probably old format - print it the
			 * with an empty HELO field instead 
			 * of erroring out.
			 */			  
			printf("GREY|%s|%s|%s|%s|%lld|%lld|%lld|%d|%d\n",
			    a, "", helo, from, (long long)gd.first,
			    (long long)gd.pass, (long long)gd.expire,
			    gd.bcount, gd.pcount);
		
		} else {
			*to = '\0';
			to++;
			printf("GREY|%s|%s|%s|%s|%lld|%lld|%lld|%d|%d\n",
			    a, helo, from, to, (long long)gd.first,
			    (long long)gd.pass, (long long)gd.expire,
			    gd.bcount, gd.pcount);
		}
	}
	free(a);

	return (0);
}

int
dblist(DB *db)
{
	DBT		dbk, dbd;
	int		r;

	/* walk db, list in text format */
	memset(&dbk, 0, sizeof(dbk));
	memset(&dbd, 0, sizeof(dbd));
	for (r = db->seq(db, &dbk, &dbd, R_FIRST); !r;
	    r = db->seq(db, &dbk, &dbd, R_NEXT)) {
		if (print_entry(&dbk, &dbd) != 0) {
			r = -1;
			break;
		}
	}
	db->close(db);
	db = NULL;
	return (r == -1);
}

int
dbshow(DB *db, char **addrs)
{
	DBT dbk, dbd;
	int errors = 0;
	char *a;

	/* look up each addr */
	while ((a = *addrs) != NULL) {
		memset(&dbk, 0, sizeof(dbk));
		dbk.size = strlen(a);
		dbk.data = a;
		memset(&dbd, 0, sizeof(dbd));
		switch (db->get(db, &dbk, &dbd, 0)) {
		case -1:
			warn("db->get failed");
			errors++;
			goto done;
		case 0:
			if (print_entry(&dbk, &dbd) != 0) {
				errors++;
				goto done;
			}
			break;
		case 1:
		default:
			/* not found */
			errors++;
			break;
		}
		addrs++;
	}
 done:
	db->close(db);
	db = NULL;
	return (errors);
}

extern char *__progname;

static int
usage(void)
{
	fprintf(stderr, "usage: %s [-adGTt] [keys ...]\n", __progname);
	exit(1);
	/* NOTREACHED */
}

int
main(int argc, char **argv)
{
	int i, ch, action = 0, type = WHITE, r = 0, c = 0;
	HASHINFO	hashinfo;
	DB		*db;

	while ((ch = getopt(argc, argv, "adGtT")) != -1) {
		switch (ch) {
		case 'a':
			action = 1;
			break;
		case 'd':
			action = 2;
			break;
		case 'G':
			type = GREY;
			break;
		case 't':
			type = TRAPHIT;
			break;
		case 'T':
			type = SPAMTRAP;
			break;
		default:
			usage();
			break;
		}
	}
	argc -= optind;
	argv += optind;
	if (action == 0 && type != WHITE)
		usage();

	memset(&hashinfo, 0, sizeof(hashinfo));
	db = dbopen(PATH_SPAMD_DB, O_EXLOCK | (action ? O_RDWR : O_RDONLY),
	    0600, DB_HASH, &hashinfo);
	if (db == NULL) {
		err(1, "cannot open %s for %s", PATH_SPAMD_DB,
		    action ? "writing" : "reading");
	}

	if (pledge("stdio", NULL) == -1)
		err(1, "pledge");

	switch (action) {
	case 0:
		if (argc)
			return dbshow(db, argv);
		else
			return dblist(db);
	case 1:
		if (type == GREY)
			errx(2, "cannot add GREY entries");
		for (i=0; i<argc; i++)
			if (argv[i][0] != '\0') {
				c++;
				r += dbupdate(db, argv[i], 1, type);
			}
		if (c == 0)
			errx(2, "no addresses specified");
		break;
	case 2:
		for (i=0; i<argc; i++)
			if (argv[i][0] != '\0') {
				c++;
				r += dbupdate(db, argv[i], 0, type);
			}
		if (c == 0)
			errx(2, "no addresses specified");
		break;
	default:
		errx(-1, "bad action");
	}
	db->close(db);
	return (r);
}