Super User's BSD Cross Reference: /OpenBSD/usr.sbin/smtpd/to.c

 /* $OpenBSD: to.c,v 1.50 2023年05月31日 16:51:46 op Exp $ */

 /*
 * Copyright (c) 2009 Jacek Masiulaniec <jacekm@dobremiasto.net>
 * Copyright (c) 2012 Eric Faurot <eric@openbsd.org>
 * Copyright (c) 2012 Gilles Chehade <gilles@poolp.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 <arpa/inet.h>
#include <ctype.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#if IO_TLS
#include <tls.h>
#endif

#include "smtpd.h"
#include "log.h"

 static int alias_is_filter(struct expandnode *, const char *, size_t);
 static int alias_is_username(struct expandnode *, const char *, size_t);
 static int alias_is_address(struct expandnode *, const char *, size_t);
 static int alias_is_filename(struct expandnode *, const char *, size_t);
 static int alias_is_include(struct expandnode *, const char *, size_t);
 static int alias_is_error(struct expandnode *, const char *, size_t);

 const char *
 sockaddr_to_text(const struct sockaddr *sa)
{
 static char buf[NI_MAXHOST];

 if (getnameinfo(sa, sa->sa_len, buf, sizeof(buf), NULL, 0,
 NI_NUMERICHOST))
 return ("(unknown)");
 else
 return (buf);
}

 int
 text_to_mailaddr(struct mailaddr *maddr, const char *email)
{
 char *username;
 char *hostname;
 char buffer[LINE_MAX];

 if (strlcpy(buffer, email, sizeof buffer) >= sizeof buffer)
 return 0;

 memset(maddr, 0, sizeof *maddr);

 username = buffer;
 hostname = strrchr(username, '@');

 if (hostname == NULL) {
 if (strlcpy(maddr->user, username, sizeof maddr->user)
 >= sizeof maddr->user)
 return 0;
 }
 else if (username == hostname) {
 *hostname++ = '0円';
 if (strlcpy(maddr->domain, hostname, sizeof maddr->domain)
 >= sizeof maddr->domain)
 return 0;
 }
 else {
 *hostname++ = '0円';
 if (strlcpy(maddr->user, username, sizeof maddr->user)
 >= sizeof maddr->user)
 return 0;
 if (strlcpy(maddr->domain, hostname, sizeof maddr->domain)
 >= sizeof maddr->domain)
 return 0;
 }

 return 1;
}

 const char *
 mailaddr_to_text(const struct mailaddr *maddr)
{
 static char buffer[LINE_MAX];

 (void)strlcpy(buffer, maddr->user, sizeof buffer);
 (void)strlcat(buffer, "@", sizeof buffer);
 if (strlcat(buffer, maddr->domain, sizeof buffer) >= sizeof buffer)
 return NULL;

 return buffer;
}


 const char *
 sa_to_text(const struct sockaddr *sa)
{
 static char buf[NI_MAXHOST + 5];
 char *p;

 buf[0] = '0円';
 p = buf;

 if (sa->sa_family == AF_LOCAL)
 (void)strlcpy(buf, "local", sizeof buf);
 else if (sa->sa_family == AF_INET) {
 in_addr_t addr;

 addr = ((const struct sockaddr_in *)sa)->sin_addr.s_addr;
 addr = ntohl(addr);
 (void)bsnprintf(p, NI_MAXHOST, "%d.%d.%d.%d",
 (addr >> 24) & 0xff, (addr >> 16) & 0xff,
 (addr >> 8) & 0xff, addr & 0xff);
 }
 else if (sa->sa_family == AF_INET6) {
 (void)bsnprintf(p, NI_MAXHOST, "[%s]", sockaddr_to_text(sa));
 }

 return (buf);
}

 const char *
 ss_to_text(const struct sockaddr_storage *ss)
{
 return (sa_to_text((const struct sockaddr*)ss));
}

 const char *
 time_to_text(time_t when)
{
 struct tm *lt;
 static char buf[40];
 const char *day[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
 const char *month[] = {"Jan","Feb","Mar","Apr","May","Jun",
 "Jul","Aug","Sep","Oct","Nov","Dec"};
 const char *tz;
 long offset;

 lt = localtime(&when);
 if (lt == NULL || when == 0)
 fatalx("time_to_text: localtime");

 offset = lt->tm_gmtoff;
 tz = lt->tm_zone;

 /* We do not use strftime because it is subject to locale substitution*/
 if (!bsnprintf(buf, sizeof(buf),
 "%s, %d %s %d %02d:%02d:%02d %c%02d%02d (%s)",
 day[lt->tm_wday], lt->tm_mday, month[lt->tm_mon],
 lt->tm_year + 1900,
 lt->tm_hour, lt->tm_min, lt->tm_sec,
 offset >= 0 ? '+' : '-',
 abs((int)offset / 3600),
 abs((int)offset % 3600) / 60,
 tz))
 fatalx("time_to_text: bsnprintf");

 return buf;
}

 const char *
 duration_to_text(time_t t)
{
 static char dst[64];
 char buf[64];
 int h, m, s;
 long long d;

 if (t == 0) {
 (void)strlcpy(dst, "0s", sizeof dst);
 return (dst);
 }

 dst[0] = '0円';
 if (t < 0) {
 (void)strlcpy(dst, "-", sizeof dst);
 t = -t;
 }

 s = t % 60;
 t /= 60;
 m = t % 60;
 t /= 60;
 h = t % 24;
 d = t / 24;

 if (d) {
 (void)snprintf(buf, sizeof buf, "%lldd", d);
 (void)strlcat(dst, buf, sizeof dst);
 }
 if (h) {
 (void)snprintf(buf, sizeof buf, "%dh", h);
 (void)strlcat(dst, buf, sizeof dst);
 }
 if (m) {
 (void)snprintf(buf, sizeof buf, "%dm", m);
 (void)strlcat(dst, buf, sizeof dst);
 }
 if (s) {
 (void)snprintf(buf, sizeof buf, "%ds", s);
 (void)strlcat(dst, buf, sizeof dst);
 }

 return (dst);
}

 int
 text_to_netaddr(struct netaddr *netaddr, const char *s)
{
 struct sockaddr_storage ss;
 struct sockaddr_in ssin;
 struct sockaddr_in6 ssin6;
 int bits;
 char buf[NI_MAXHOST];
 size_t len;

 memset(&ssin, 0, sizeof(struct sockaddr_in));
 memset(&ssin6, 0, sizeof(struct sockaddr_in6));

 if (strncasecmp("IPv6:", s, 5) == 0)
 s += 5;

 bits = inet_net_pton(AF_INET, s, &ssin.sin_addr,
 sizeof(struct in_addr));
 if (bits != -1) {
 ssin.sin_family = AF_INET;
 memcpy(&ss, &ssin, sizeof(ssin));
 ss.ss_len = sizeof(struct sockaddr_in);
 } else {
 if (s[0] != '[') {
 if ((len = strlcpy(buf, s, sizeof buf)) >= sizeof buf)
 return 0;
 }
 else {
 s++;
 if (strncasecmp("IPv6:", s, 5) == 0)
 s += 5;
 if ((len = strlcpy(buf, s, sizeof buf)) >= sizeof buf)
 return 0;
 if (buf[len-1] != ']')
 return 0;
 buf[len-1] = 0;
 }
 bits = inet_net_pton(AF_INET6, buf, &ssin6.sin6_addr,
 sizeof(struct in6_addr));
 if (bits == -1)
 return 0;
 ssin6.sin6_family = AF_INET6;
 memcpy(&ss, &ssin6, sizeof(ssin6));
 ss.ss_len = sizeof(struct sockaddr_in6);
 }

 netaddr->ss = ss;
 netaddr->bits = bits;
 return 1;
}

 int
 text_to_relayhost(struct relayhost *relay, const char *s)
{
 static const struct schema {
 const char *name;
 int tls;
 uint16_t flags;
 uint16_t port;
 } schemas [] = {
 /*
 * new schemas should be *appended* otherwise the default
 * schema index needs to be updated later in this function.
 */
 { "smtp://", RELAY_TLS_OPPORTUNISTIC, 0, 25 },
 { "smtp+tls://", RELAY_TLS_STARTTLS, 0, 25 },
 { "smtp+notls://", RELAY_TLS_NO, 0, 25 },
 /* need to specify an explicit port for LMTP */
 { "lmtp://", RELAY_TLS_NO, RELAY_LMTP, 0 },
 { "smtps://", RELAY_TLS_SMTPS, 0, 465 }
 };
 const char *errstr = NULL;
 char *p, *q;
 char buffer[1024];
 char *beg, *end;
 size_t i;
 size_t len;

 memset(buffer, 0, sizeof buffer);
 if (strlcpy(buffer, s, sizeof buffer) >= sizeof buffer)
 return 0;

 for (i = 0; i < nitems(schemas); ++i)
 if (strncasecmp(schemas[i].name, s,
 strlen(schemas[i].name)) == 0)
 break;

 if (i == nitems(schemas)) {
 /* there is a schema, but it's not recognized */
 if (strstr(buffer, "://"))
 return 0;

 /* no schema, default to smtp:// */
 i = 0;
 p = buffer;
 }
 else
 p = buffer + strlen(schemas[i].name);

 relay->tls = schemas[i].tls;
 relay->flags = schemas[i].flags;
 relay->port = schemas[i].port;

 /* first, we extract the label if any */
 if ((q = strchr(p, '@')) != NULL) {
 *q = 0;
 if (strlcpy(relay->authlabel, p, sizeof (relay->authlabel))
 >= sizeof (relay->authlabel))
 return 0;
 p = q + 1;
 }

 /* then, we extract the mail exchanger */
 beg = end = p;
 if (*beg == '[') {
 if ((end = strchr(beg, ']')) == NULL)
 return 0;
 /* skip ']', it has to be included in the relay hostname */
 ++end;
 len = end - beg;
 }
 else {
 for (end = beg; *end; ++end)
 if (!isalnum((unsigned char)*end) &&
 *end != '_' && *end != '.' && *end != '-')
 break;
 len = end - beg;
 }
 if (len >= sizeof relay->hostname)
 return 0;
 for (i = 0; i < len; ++i)
 relay->hostname[i] = beg[i];
 relay->hostname[i] = 0;

 /* finally, we extract the port */
 p = beg + len;
 if (*p == ':') {
 relay->port = strtonum(p+1, 1, IPPORT_HILASTAUTO, &errstr);
 if (errstr)
 return 0;
 }

 if (!valid_domainpart(relay->hostname))
 return 0;
 if ((relay->flags & RELAY_LMTP) && (relay->port == 0))
 return 0;
 if (relay->authlabel[0]) {
 /* disallow auth on non-tls scheme. */
 if (relay->tls != RELAY_TLS_STARTTLS &&
 relay->tls != RELAY_TLS_SMTPS)
 return 0;
 relay->flags |= RELAY_AUTH;
 }

 return 1;
}

 uint64_t
 text_to_evpid(const char *s)
{
 uint64_t ulval;
 char *ep;

 errno = 0;
 ulval = strtoull(s, &ep, 16);
 if (s[0] == '0円' || *ep != '0円')
 return 0;
 if (errno == ERANGE && ulval == ULLONG_MAX)
 return 0;
 if (ulval == 0)
 return 0;
 return (ulval);
}

 uint32_t
 text_to_msgid(const char *s)
{
 uint64_t ulval;
 char *ep;

 errno = 0;
 ulval = strtoull(s, &ep, 16);
 if (s[0] == '0円' || *ep != '0円')
 return 0;
 if (errno == ERANGE && ulval == ULLONG_MAX)
 return 0;
 if (ulval == 0)
 return 0;
 if (ulval > 0xffffffff)
 return 0;
 return (ulval & 0xffffffff);
}

 const char *
 rule_to_text(struct rule *r)
{
 static char buf[4096];

 memset(buf, 0, sizeof buf);
 (void)strlcpy(buf, "match", sizeof buf);
 if (r->flag_tag) {
 if (r->flag_tag < 0)
 (void)strlcat(buf, " !", sizeof buf);
 (void)strlcat(buf, " tag ", sizeof buf);
 (void)strlcat(buf, r->table_tag, sizeof buf);
 }

 if (r->flag_from) {
 if (r->flag_from < 0)
 (void)strlcat(buf, " !", sizeof buf);
 if (r->flag_from_socket)
 (void)strlcat(buf, " from socket", sizeof buf);
 else if (r->flag_from_rdns) {
 (void)strlcat(buf, " from rdns", sizeof buf);
 if (r->table_from) {
 (void)strlcat(buf, " ", sizeof buf);
 (void)strlcat(buf, r->table_from, sizeof buf);
 }
 }
 else if (strcmp(r->table_from, "<anyhost>") == 0)
 (void)strlcat(buf, " from any", sizeof buf);
 else if (strcmp(r->table_from, "<localhost>") == 0)
 (void)strlcat(buf, " from local", sizeof buf);
 else {
 (void)strlcat(buf, " from src ", sizeof buf);
 (void)strlcat(buf, r->table_from, sizeof buf);
 }
 }

 if (r->flag_for) {
 if (r->flag_for < 0)
 (void)strlcat(buf, " !", sizeof buf);
 if (strcmp(r->table_for, "<anydestination>") == 0)
 (void)strlcat(buf, " for any", sizeof buf);
 else if (strcmp(r->table_for, "<localnames>") == 0)
 (void)strlcat(buf, " for local", sizeof buf);
 else {
 (void)strlcat(buf, " for domain ", sizeof buf);
 (void)strlcat(buf, r->table_for, sizeof buf);
 }
 }

 if (r->flag_smtp_helo) {
 if (r->flag_smtp_helo < 0)
 (void)strlcat(buf, " !", sizeof buf);
 (void)strlcat(buf, " helo ", sizeof buf);
 (void)strlcat(buf, r->table_smtp_helo, sizeof buf);
 }

 if (r->flag_smtp_auth) {
 if (r->flag_smtp_auth < 0)
 (void)strlcat(buf, " !", sizeof buf);
 (void)strlcat(buf, " auth", sizeof buf);
 if (r->table_smtp_auth) {
 (void)strlcat(buf, " ", sizeof buf);
 (void)strlcat(buf, r->table_smtp_auth, sizeof buf);
 }
 }

 if (r->flag_smtp_starttls) {
 if (r->flag_smtp_starttls < 0)
 (void)strlcat(buf, " !", sizeof buf);
 (void)strlcat(buf, " tls", sizeof buf);
 }

 if (r->flag_smtp_mail_from) {
 if (r->flag_smtp_mail_from < 0)
 (void)strlcat(buf, " !", sizeof buf);
 (void)strlcat(buf, " mail-from ", sizeof buf);
 (void)strlcat(buf, r->table_smtp_mail_from, sizeof buf);
 }

 if (r->flag_smtp_rcpt_to) {
 if (r->flag_smtp_rcpt_to < 0)
 (void)strlcat(buf, " !", sizeof buf);
 (void)strlcat(buf, " rcpt-to ", sizeof buf);
 (void)strlcat(buf, r->table_smtp_rcpt_to, sizeof buf);
 }
 (void)strlcat(buf, " action ", sizeof buf);
 if (r->reject)
 (void)strlcat(buf, "reject", sizeof buf);
 else
 (void)strlcat(buf, r->dispatcher, sizeof buf);
 return buf;
}


 int
 text_to_userinfo(struct userinfo *userinfo, const char *s)
{
 char buf[PATH_MAX];
 char *p;
 const char *errstr;

 memset(buf, 0, sizeof buf);
 p = buf;
 while (*s && *s != ':')
 *p++ = *s++;
 if (*s++ != ':')
 goto error;

 if (strlcpy(userinfo->username, buf,
 sizeof userinfo->username) >= sizeof userinfo->username)
 goto error;

 memset(buf, 0, sizeof buf);
 p = buf;
 while (*s && *s != ':')
 *p++ = *s++;
 if (*s++ != ':')
 goto error;
 userinfo->uid = strtonum(buf, 0, UID_MAX, &errstr);
 if (errstr)
 goto error;

 memset(buf, 0, sizeof buf);
 p = buf;
 while (*s && *s != ':')
 *p++ = *s++;
 if (*s++ != ':')
 goto error;
 userinfo->gid = strtonum(buf, 0, GID_MAX, &errstr);
 if (errstr)
 goto error;

 if (strlcpy(userinfo->directory, s,
 sizeof userinfo->directory) >= sizeof userinfo->directory)
 goto error;

 return 1;

 error:
 return 0;
}

 int
 text_to_credentials(struct credentials *creds, const char *s)
{
 char *p;
 char buffer[LINE_MAX];
 size_t offset;

 p = strchr(s, ':');
 if (p == NULL) {
 creds->username[0] = '0円';
 if (strlcpy(creds->password, s, sizeof creds->password)
 >= sizeof creds->password)
 return 0;
 return 1;
 }

 offset = p - s;

 memset(buffer, 0, sizeof buffer);
 if (strlcpy(buffer, s, sizeof buffer) >= sizeof buffer)
 return 0;
 p = buffer + offset;
 *p = '0円';

 if (strlcpy(creds->username, buffer, sizeof creds->username)
 >= sizeof creds->username)
 return 0;
 if (strlcpy(creds->password, p+1, sizeof creds->password)
 >= sizeof creds->password)
 return 0;

 return 1;
}

 int
 text_to_expandnode(struct expandnode *expandnode, const char *s)
{
 size_t l;

 l = strlen(s);
 if (alias_is_error(expandnode, s, l) ||
 alias_is_include(expandnode, s, l) ||
 alias_is_filter(expandnode, s, l) ||
 alias_is_filename(expandnode, s, l) ||
 alias_is_address(expandnode, s, l) ||
 alias_is_username(expandnode, s, l))
 return (1);

 return (0);
}

 const char *
 expandnode_to_text(struct expandnode *expandnode)
{
 switch (expandnode->type) {
 case EXPAND_FILTER:
 case EXPAND_FILENAME:
 case EXPAND_INCLUDE:
 case EXPAND_ERROR:
 case EXPAND_USERNAME:
 return expandnode->u.user;
 case EXPAND_ADDRESS:
 return mailaddr_to_text(&expandnode->u.mailaddr);
 case EXPAND_INVALID:
 break;
 }

 return NULL;
}

 /******/
 static int
 alias_is_filter(struct expandnode *alias, const char *line, size_t len)
{
 int v = 0;

 if (*line == '"')
 v = 1;
 if (*(line+v) == '|') {
 if (strlcpy(alias->u.buffer, line + v + 1,
 sizeof(alias->u.buffer)) >= sizeof(alias->u.buffer))
 return 0;
 if (v) {
 v = strlen(alias->u.buffer);
 if (v == 0)
 return (0);
 if (alias->u.buffer[v-1] != '"')
 return (0);
 alias->u.buffer[v-1] = '0円';
 }
 alias->type = EXPAND_FILTER;
 return (1);
 }
 return (0);
}

 static int
 alias_is_username(struct expandnode *alias, const char *line, size_t len)
{
 memset(alias, 0, sizeof *alias);

 if (strlcpy(alias->u.user, line,
 sizeof(alias->u.user)) >= sizeof(alias->u.user))
 return 0;

 while (*line) {
 if (!isalnum((unsigned char)*line) &&
 *line != '_' && *line != '.' && *line != '-' && *line != '+')
 return 0;
 ++line;
 }

 alias->type = EXPAND_USERNAME;
 return 1;
}

 static int
 alias_is_address(struct expandnode *alias, const char *line, size_t len)
{
 char *domain;

 memset(alias, 0, sizeof *alias);

 if (len < 3) /* x@y */
 return 0;

 domain = strchr(line, '@');
 if (domain == NULL)
 return 0;

 /* @ cannot start or end an address */
 if (domain == line || domain == line + len - 1)
 return 0;

 /* scan pre @ for disallowed chars */
 *domain++ = '0円';
 (void)strlcpy(alias->u.mailaddr.user, line, sizeof(alias->u.mailaddr.user));
 (void)strlcpy(alias->u.mailaddr.domain, domain,
 sizeof(alias->u.mailaddr.domain));

 while (*line) {
 char allowedset[] = "!#$%*/?|^{}`~&'+-=_.";
 if (!isalnum((unsigned char)*line) &&
 strchr(allowedset, *line) == NULL)
 return 0;
 ++line;
 }

 while (*domain) {
 char allowedset[] = "-.";
 if (!isalnum((unsigned char)*domain) &&
 strchr(allowedset, *domain) == NULL)
 return 0;
 ++domain;
 }

 alias->type = EXPAND_ADDRESS;
 return 1;
}

 static int
 alias_is_filename(struct expandnode *alias, const char *line, size_t len)
{
 memset(alias, 0, sizeof *alias);

 if (*line != '/')
 return 0;

 if (strlcpy(alias->u.buffer, line,
 sizeof(alias->u.buffer)) >= sizeof(alias->u.buffer))
 return 0;
 alias->type = EXPAND_FILENAME;
 return 1;
}

 static int
 alias_is_include(struct expandnode *alias, const char *line, size_t len)
{
 size_t skip;

 memset(alias, 0, sizeof *alias);

 if (strncasecmp(":include:", line, 9) == 0)
 skip = 9;
 else if (strncasecmp("include:", line, 8) == 0)
 skip = 8;
 else
 return 0;

 if (!alias_is_filename(alias, line + skip, len - skip))
 return 0;

 alias->type = EXPAND_INCLUDE;
 return 1;
}

 static int
 alias_is_error(struct expandnode *alias, const char *line, size_t len)
{
 size_t skip;

 memset(alias, 0, sizeof *alias);

 if (strncasecmp(":error:", line, 7) == 0)
 skip = 7;
 else if (strncasecmp("error:", line, 6) == 0)
 skip = 6;
 else
 return 0;

 if (strlcpy(alias->u.buffer, line + skip,
 sizeof(alias->u.buffer)) >= sizeof(alias->u.buffer))
 return 0;

 if (strlen(alias->u.buffer) < 5)
 return 0;

 /* [45][0-9]{2} [a-zA-Z0-9].* */
 if (alias->u.buffer[3] != ' ' ||
 !isalnum((unsigned char)alias->u.buffer[4]) ||
 (alias->u.buffer[0] != '4' && alias->u.buffer[0] != '5') ||
 !isdigit((unsigned char)alias->u.buffer[1]) ||
 !isdigit((unsigned char)alias->u.buffer[2]))
 return 0;

 alias->type = EXPAND_ERROR;
 return 1;
}

#if IO_TLS
 const char *
 tls_to_text(struct tls *tls)
{
 static char buf[256];

 (void)snprintf(buf, sizeof buf, "%s:%s:%d",
 tls_conn_version(tls),
 tls_conn_cipher(tls),
 tls_conn_cipher_strength(tls));

 return (buf);
}
#endif
 

Indexes created Sun Nov 23 03:53:09 PST 2025