/* $OpenBSD: smtpd.h,v 1.193 2010/06/10 19:34:51 chl Exp $ */ /* * Copyright (c) 2008 Gilles Chehade * Copyright (c) 2008 Pierre-Yves Ritschard * * 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 #ifndef nitems #define nitems(_a) (sizeof((_a)) / sizeof((_a)[0])) #endif #define IMSG_DATA_SIZE(imsg) ((imsg)->hdr.len - IMSG_HEADER_SIZE) #define CONF_FILE "/etc/mail/smtpd.conf" #define MAX_LISTEN 16 #define PROC_COUNT 8 #define MAX_NAME_SIZE 64 #define MAX_HOPS_COUNT 100 /* sizes include the tailing '\0' */ #define MAX_LINE_SIZE 1024 #define MAX_LOCALPART_SIZE 128 #define MAX_DOMAINPART_SIZE MAXHOSTNAMELEN #define MAX_TAG_SIZE 32 /* return and forward path size */ #define MAX_PATH_SIZE 256 #define SMTPD_EXPIRE (4 * 24 * 60 * 60) #define SMTPD_USER "_smtpd" #define SMTPD_SOCKET "/var/run/smtpd.sock" #define SMTPD_BANNER "220 %s ESMTP OpenSMTPD" #define SMTPD_SESSION_TIMEOUT 300 #define SMTPD_BACKLOG 5 #define PATH_SMTPCTL "/usr/sbin/smtpctl" #define PATH_SPOOL "/var/spool/smtpd" #define PATH_OFFLINE "/offline" /* number of MX records to lookup */ #define MAX_MX_COUNT 10 /* max response delay under flood conditions */ #define MAX_RESPONSE_DELAY 60 /* how many responses per state are undelayed */ #define FAST_RESPONSES 2 /* max len of any smtp line */ #define SMTP_LINE_MAX 16384 #define F_STARTTLS 0x01 #define F_SMTPS 0x02 #define F_AUTH 0x04 #define F_SSL (F_SMTPS|F_STARTTLS) #define F_SCERT 0x01 #define F_CCERT 0x02 #define ADVERTISE_TLS(s) \ ((s)->s_l->flags & F_STARTTLS && !((s)->s_flags & F_SECURE)) #define ADVERTISE_AUTH(s) \ ((s)->s_l->flags & F_AUTH && (s)->s_flags & F_SECURE && \ !((s)->s_flags & F_AUTHENTICATED)) struct netaddr { struct sockaddr_storage ss; int bits; }; struct relayhost { u_int8_t flags; char hostname[MAXHOSTNAMELEN]; u_int16_t port; char cert[PATH_MAX]; }; enum imsg_type { IMSG_NONE, IMSG_CTL_OK, /* answer to smtpctl requests */ IMSG_CTL_FAIL, IMSG_CTL_SHUTDOWN, IMSG_CTL_VERBOSE, IMSG_CONF_START, IMSG_CONF_SSL, IMSG_CONF_SSL_CERT, IMSG_CONF_SSL_KEY, IMSG_CONF_LISTENER, IMSG_CONF_MAP, IMSG_CONF_MAP_CONTENT, IMSG_CONF_RULE, IMSG_CONF_RULE_SOURCE, IMSG_CONF_CONDITION, IMSG_CONF_OPTION, IMSG_CONF_END, IMSG_CONF_RELOAD, IMSG_LKA_MAIL, IMSG_LKA_RCPT, IMSG_LKA_RULEMATCH, IMSG_LKA_SECRET, IMSG_MDA_DONE, IMSG_MFA_MAIL, IMSG_MFA_RCPT, IMSG_QUEUE_CREATE, IMSG_QUEUE_APPEND, IMSG_QUEUE_OPEN, IMSG_QUEUE_CLOSE, IMSG_QUEUE_DELETE, IMSG_QUEUE_STATS, IMSG_QUEUE_PAUSE_LOCAL, IMSG_QUEUE_PAUSE_RELAY, IMSG_QUEUE_RESUME_LOCAL, IMSG_QUEUE_RESUME_RELAY, IMSG_QUEUE_SCHEDULE, IMSG_QUEUE_REMOVE, IMSG_BATCH_CREATE, IMSG_BATCH_APPEND, IMSG_BATCH_CLOSE, IMSG_BATCH_UPDATE, IMSG_BATCH_DONE, IMSG_PARENT_FORWARD_OPEN, IMSG_PARENT_FORK_MDA, IMSG_PARENT_STATS, IMSG_PARENT_AUTHENTICATE, IMSG_PARENT_SEND_CONFIG, IMSG_SMTP_STATS, IMSG_STATS, IMSG_SMTP_ENQUEUE, IMSG_SMTP_PAUSE, IMSG_SMTP_RESUME, IMSG_DNS_A, IMSG_DNS_A_END, IMSG_DNS_MX, IMSG_DNS_PTR }; enum blockmodes { BM_NORMAL, BM_NONBLOCK }; struct imsgev { struct imsgbuf ibuf; void (*handler)(int, short, void *); struct event ev; void *data; struct smtpd *env; int proc; short events; }; struct ctl_conn { TAILQ_ENTRY(ctl_conn) entry; u_int8_t flags; #define CTL_CONN_NOTIFY 0x01 struct imsgev iev; }; TAILQ_HEAD(ctl_connlist, ctl_conn); typedef u_int32_t objid_t; struct ctl_id { objid_t id; char name[MAX_NAME_SIZE]; }; enum smtp_proc_type { PROC_PARENT = 0, PROC_SMTP, PROC_MFA, PROC_LKA, PROC_QUEUE, PROC_MDA, PROC_MTA, PROC_CONTROL } smtpd_process; struct peer { enum smtp_proc_type id; void (*cb)(int, short, void *); }; enum map_type { T_SINGLE, T_LIST, T_HASH }; enum map_src { S_NONE, S_DYN, S_DNS, S_PLAIN, S_DB, S_EXT }; enum map_kind { K_NONE, K_ALIAS, K_VIRTUAL, K_SECRET }; enum mapel_type { ME_STRING, ME_NET, ME_NETMASK }; struct mapel { TAILQ_ENTRY(mapel) me_entry; union mapel_data { char med_string[MAX_LINE_SIZE]; struct netaddr med_addr; } me_key; union mapel_data me_val; }; struct map { TAILQ_ENTRY(map) m_entry; #define F_USED 0x01 #define F_DYNAMIC 0x02 u_int8_t m_flags; char m_name[MAX_LINE_SIZE]; objid_t m_id; enum map_type m_type; enum mapel_type m_eltype; enum map_src m_src; char m_config[MAXPATHLEN]; TAILQ_HEAD(mapel_list, mapel) m_contents; }; struct map_backend { enum map_src source; void *(*open)(char *); void (*close)(void *); char *(*get)(void *, char *, size_t *); int (*put)(void *, char *, char *); }; struct map_parser { enum map_kind kind; void *(*extract)(char *, char *, size_t); }; enum cond_type { C_ALL, C_NET, C_DOM, C_VDOM }; struct cond { TAILQ_ENTRY(cond) c_entry; objid_t c_map; enum cond_type c_type; }; enum action_type { A_INVALID, A_RELAY, A_RELAYVIA, A_MAILDIR, A_MBOX, A_FILENAME, A_EXT }; #define IS_MAILBOX(x) ((x).rule.r_action == A_MAILDIR || (x).rule.r_action == A_MBOX || (x).rule.r_action == A_FILENAME) #define IS_RELAY(x) ((x).rule.r_action == A_RELAY || (x).rule.r_action == A_RELAYVIA) #define IS_EXT(x) ((x).rule.r_action == A_EXT) struct rule { TAILQ_ENTRY(rule) r_entry; char r_tag[MAX_TAG_SIZE]; int r_accept; struct map *r_sources; struct cond r_condition; enum action_type r_action; union rule_dest { char path[MAXPATHLEN]; struct relayhost relayhost; #define MAXCOMMANDLEN 256 char command[MAXCOMMANDLEN]; } r_value; char *r_user; objid_t r_amap; }; enum path_flags { F_PATH_ALIAS = 0x1, F_PATH_VIRTUAL = 0x2, F_PATH_EXPANDED = 0x4, F_PATH_NOFORWARD = 0x8, F_PATH_FORWARDED = 0x10, F_PATH_ACCOUNT = 0x20, F_PATH_AUTHENTICATED = 0x40, F_PATH_RELAY = 0x80, }; struct mailaddr { char user[MAX_LOCALPART_SIZE]; char domain[MAX_DOMAINPART_SIZE]; }; union path_data { char username[MAXLOGNAME]; char filename[MAXPATHLEN]; char filter[MAXPATHLEN]; struct mailaddr mailaddr; }; struct path { TAILQ_ENTRY(path) entry; struct rule rule; enum path_flags flags; u_int8_t forwardcnt; char user[MAX_LOCALPART_SIZE]; char domain[MAX_DOMAINPART_SIZE]; char pw_name[MAXLOGNAME]; union path_data u; }; TAILQ_HEAD(deliverylist, path); enum expand_type { EXPAND_INVALID, EXPAND_USERNAME, EXPAND_FILENAME, EXPAND_FILTER, EXPAND_INCLUDE, EXPAND_ADDRESS }; enum expand_flags { F_EXPAND_NONE, F_EXPAND_DONE }; struct expandnode { RB_ENTRY(expandnode) entry; size_t refcnt; enum expand_flags flags; enum expand_type type; union path_data u; }; RB_HEAD(expandtree, expandnode); struct action { SLIST_ENTRY(action) entry; u_int64_t id; char data[1]; /* actually bigger */ }; struct content { SLIST_HEAD(,action) actions; u_int64_t id; int ref; struct event *ev; }; #define NO_RETRY_EXPIRED 0 #define RETRY_NOW 1 struct batch { SLIST_ENTRY(batch) entry; SLIST_HEAD(,action) actions; struct content *content; time_t retry; char sortkey[1]; /* actually bigger */ }; struct incoming { SLIST_ENTRY(incoming) entry; SLIST_HEAD(,batch) batches[3]; struct content *content; char **local; int local_sz; int nlocal; }; #define Q_LOCAL 0 #define Q_RELAY 1 #define Q_BOUNCE 2 struct queue { SLIST_HEAD(,batch) head; struct event ev; struct smtpd *env; char *name; void **session; int session_sz; size_t sessions; size_t max; }; struct aux { char *mode; char *mail_from; char *rcpt_to; char *user_from; char *user_to; char *path; char *rcpt; char *relay_via; char *port; char *ssl; char *cert; char *auth; }; struct bounce { struct event ev; struct batch *batch; struct smtp_client *pcb; int id; }; enum message_flags { F_MESSAGE_AUTHENTICATED = 0x1 }; enum message_status { S_MESSAGE_PERMFAILURE = 0x1, S_MESSAGE_TEMPFAILURE = 0x2 }; struct message { TAILQ_ENTRY(message) entry; char tag[MAX_TAG_SIZE]; u_int32_t id; /* smtp session id */ u_int32_t session_id; /* smtp session id */ u_int32_t queue_id; char session_helo[MAXHOSTNAMELEN]; char session_hostname[MAXHOSTNAMELEN]; char session_errorline[MAX_LINE_SIZE]; struct sockaddr_storage session_ss; struct path session_rcpt; struct path sender; struct path recipient; time_t creation; time_t lasttry; u_int8_t retry; enum message_flags flags; enum message_status status; }; enum child_type { CHILD_INVALID, CHILD_DAEMON, CHILD_MDA, CHILD_ENQUEUE_OFFLINE }; struct child { SPLAY_ENTRY(child) entry; pid_t pid; enum child_type type; enum smtp_proc_type title; int mda_out; u_int32_t mda_id; }; enum session_state { S_INVALID = 0, S_INIT, S_GREETED, S_TLS, S_AUTH_INIT, S_AUTH_USERNAME, S_AUTH_PASSWORD, S_AUTH_FINALIZE, S_HELO, S_MAIL_MFA, S_MAIL_QUEUE, S_MAIL, S_RCPT_MFA, S_RCPT, S_DATA, S_DATA_QUEUE, S_DATACONTENT, S_DONE, S_QUIT }; #define STATE_COUNT 18 struct ssl { SPLAY_ENTRY(ssl) ssl_nodes; char ssl_name[PATH_MAX]; char *ssl_cert; off_t ssl_cert_len; char *ssl_key; off_t ssl_key_len; u_int8_t flags; }; struct listener { u_int8_t flags; int fd; struct sockaddr_storage ss; in_port_t port; struct timeval timeout; struct event ev; struct smtpd *env; char ssl_cert_name[PATH_MAX]; struct ssl *ssl; void *ssl_ctx; char tag[MAX_TAG_SIZE]; TAILQ_ENTRY(listener) entry; }; struct auth { u_int64_t id; char user[MAXLOGNAME]; char pass[MAX_LINE_SIZE]; int success; }; enum session_flags { F_EHLO = 0x1, F_QUIT = 0x2, F_8BITMIME = 0x4, F_SECURE = 0x8, F_AUTHENTICATED = 0x10, F_PEERHASTLS = 0x20, F_PEERHASAUTH = 0x40, F_WRITEONLY = 0x80 }; struct session { SPLAY_ENTRY(session) s_nodes; u_int32_t s_id; enum session_flags s_flags; enum session_state s_state; int s_fd; struct sockaddr_storage s_ss; char s_hostname[MAXHOSTNAMELEN]; struct event s_ev; struct bufferevent *s_bev; struct listener *s_l; struct smtpd *s_env; void *s_ssl; u_char *s_buf; int s_buflen; struct timeval s_tv; struct message s_msg; short s_nresp[STATE_COUNT]; size_t rcptcount; long s_datalen; struct auth s_auth; struct batch *batch; FILE *datafp; int mboxfd; int messagefd; u_int32_t queue_id; u_int64_t content_id; }; struct smtpd { char sc_conffile[MAXPATHLEN]; size_t sc_maxsize; #define SMTPD_OPT_VERBOSE 0x00000001 #define SMTPD_OPT_NOACTION 0x00000002 u_int32_t sc_opts; #define SMTPD_CONFIGURING 0x00000001 #define SMTPD_EXITING 0x00000002 #define SMTPD_MDA_PAUSED 0x00000004 #define SMTPD_MTA_PAUSED 0x00000008 #define SMTPD_SMTP_PAUSED 0x00000010 u_int32_t sc_flags; u_int32_t sc_maxconn; int sc_qexpire; struct event sc_ev; int *sc_pipes[PROC_COUNT] [PROC_COUNT]; struct imsgev *sc_ievs[PROC_COUNT]; int sc_instances[PROC_COUNT]; int sc_instance; char *sc_title[PROC_COUNT]; struct passwd *sc_pw; char sc_hostname[MAXHOSTNAMELEN]; TAILQ_HEAD(listenerlist, listener) *sc_listeners; TAILQ_HEAD(maplist, map) *sc_maps, *sc_maps_reload; TAILQ_HEAD(rulelist, rule) *sc_rules, *sc_rules_reload; SPLAY_HEAD(sessiontree, session) sc_sessions; SPLAY_HEAD(msgtree, message) sc_messages; SPLAY_HEAD(ssltree, ssl) *sc_ssl; SPLAY_HEAD(childtree, child) children; SPLAY_HEAD(lkatree, lkasession) lka_sessions; SPLAY_HEAD(mtatree, mta_session) mta_sessions; LIST_HEAD(mdalist, mda_session) mda_sessions; struct stats *stats; }; struct s_parent { time_t start; }; struct s_queue { size_t length; size_t inserts; }; struct s_session { size_t sessions; size_t sessions_active; size_t smtps; size_t smtps_active; size_t starttls; size_t starttls_active; size_t read_error; size_t read_timeout; size_t read_eof; size_t write_error; size_t write_timeout; size_t write_eof; size_t toofast; size_t tempfail; size_t linetoolong; size_t delays; }; struct s_mda { size_t sessions; size_t sessions_active; }; struct s_control { size_t sessions; size_t sessions_active; }; struct stats { struct s_parent parent; struct s_queue queue; struct s_session mta; struct s_mda mda; struct s_session smtp; struct s_control control; }; struct reload { int fd; int ret; }; struct submit_status { u_int64_t id; int code; union submit_path { struct path path; char errormsg[MAX_LINE_SIZE]; } u; enum message_flags flags; struct sockaddr_storage ss; struct message msg; }; struct forward_req { u_int32_t id; u_int8_t status; char pw_name[MAXLOGNAME]; }; struct dns { u_int64_t id; char host[MAXHOSTNAMELEN]; int port; int error; struct sockaddr_storage ss; struct smtpd *env; struct dns *next; }; struct mda_session { LIST_ENTRY(mda_session) entry; struct msgbuf w; struct event ev; time_t birth; u_int64_t content_id; u_int64_t action_id; u_int32_t id; struct aux aux; char *auxraw; FILE *datafp; }; struct deliver { int mode; char to[PATH_MAX]; char user[MAXLOGNAME]; }; struct rulematch { u_int64_t id; struct submit_status ss; }; enum lkasession_flags { F_ERROR = 0x1 }; struct lkasession { SPLAY_ENTRY(lkasession) nodes; u_int32_t id; struct path path; struct deliverylist deliverylist; struct expandtree expandtree; u_int8_t iterations; u_int32_t pending; enum lkasession_flags flags; struct message message; struct submit_status ss; }; enum mta_state { MTA_INVALID_STATE, MTA_INIT, MTA_SECRET, MTA_MX, MTA_CONNECT, MTA_PTR, MTA_PROTOCOL, MTA_DONE }; struct mta_relay { TAILQ_ENTRY(mta_relay) entry; struct sockaddr_storage sa; char fqdn[MAXHOSTNAMELEN]; int used; }; struct recipient { TAILQ_ENTRY(recipient) entry; u_int64_t action_id; char status[128]; char address[1]; /* actually bigger */ }; struct mta_session { SPLAY_ENTRY(mta_session) entry; u_int32_t id; struct smtpd *env; enum mta_state state; time_t birth; u_int64_t content_id; struct aux aux; char *auxraw; TAILQ_HEAD(,recipient) recipients; TAILQ_HEAD(,mta_relay) relays; char *secret; int fd; int datafd; struct event ev; void *pcb; }; /* maps return structures */ struct map_secret { char username[MAX_LINE_SIZE]; char password[MAX_LINE_SIZE]; }; struct map_alias { size_t nbnodes; struct expandtree expandtree; }; struct map_virtual { size_t nbnodes; struct expandtree expandtree; }; extern void (*imsg_callback)(struct smtpd *, struct imsgev *, struct imsg *); /* aliases.c */ int aliases_exist(struct smtpd *, objid_t, char *); int aliases_get(struct smtpd *, objid_t, struct expandtree *, char *); int aliases_vdomain_exists(struct smtpd *, objid_t, char *); int aliases_virtual_exist(struct smtpd *, objid_t, struct path *); int aliases_virtual_get(struct smtpd *, objid_t, struct expandtree *, struct path *); int alias_parse(struct expandnode *, char *); /* authenticate.c */ int authenticate_user(char *, char *); /* bounce.c */ int bounce_session(struct smtpd *, int, struct message *); int bounce_session_switch(struct smtpd *, FILE *, enum session_state *, char *, struct message *); /* log.c */ void log_init(int); void log_verbose(int); void log_warn(const char *, ...) __attribute__ ((format (printf, 1, 2))); void log_warnx(const char *, ...) __attribute__ ((format (printf, 1, 2))); void log_info(const char *, ...) __attribute__ ((format (printf, 1, 2))); void log_debug(const char *, ...) __attribute__ ((format (printf, 1, 2))); __dead void fatal(const char *); __dead void fatalx(const char *); /* dns.c */ void dns_query_a(struct smtpd *, char *, int, u_int64_t); void dns_query_mx(struct smtpd *, char *, int, u_int64_t); void dns_query_ptr(struct smtpd *, struct sockaddr_storage *, u_int64_t); void dns_async(struct smtpd *, struct imsgev *, int, struct dns *); /* expand.c */ int expand_cmp(struct expandnode *, struct expandnode *); void expandtree_increment_node(struct expandtree *, struct expandnode *); void expandtree_decrement_node(struct expandtree *, struct expandnode *); void expandtree_remove_node(struct expandtree *, struct expandnode *); struct expandnode *expandtree_lookup(struct expandtree *, struct expandnode *); void expandtree_free_nodes(struct expandtree *); RB_PROTOTYPE(expandtree, expandnode, nodes, expand_cmp); /* forward.c */ int forwards_get(int, struct expandtree *); /* smtpd.c */ int child_cmp(struct child *, struct child *); SPLAY_PROTOTYPE(childtree, child, entry, child_cmp); void imsg_event_add(struct imsgev *); void imsg_compose_event(struct imsgev *, u_int16_t, u_int32_t, pid_t, int, void *, u_int16_t); void imsg_dispatch(int, short, void *); /* lka.c */ pid_t lka(struct smtpd *); int lkasession_cmp(struct lkasession *, struct lkasession *); SPLAY_PROTOTYPE(lkatree, lkasession, nodes, lkasession_cmp); /* mfa.c */ pid_t mfa(struct smtpd *); /* queue.c */ pid_t queue(struct smtpd *); /* map.c */ void *map_lookup(struct smtpd *, objid_t, char *, enum map_kind); /* mda.c */ pid_t mda(struct smtpd *); /* mta.c */ pid_t mta(struct smtpd *); int mta_session_cmp(struct mta_session *, struct mta_session *); SPLAY_PROTOTYPE(mtatree, mta_session, entry, mta_session_cmp); /* control.c */ pid_t control(struct smtpd *); void session_socket_blockmode(int, enum blockmodes); void session_socket_no_linger(int); int session_socket_error(int); /* enqueue.c */ int enqueue(int, char **); int enqueue_offline(int, char **); /* smtp.c */ pid_t smtp(struct smtpd *); void smtp_resume(struct smtpd *); /* smtp_session.c */ void session_init(struct listener *, struct session *); int session_cmp(struct session *, struct session *); void session_pickup(struct session *); void session_destroy(struct session *); void session_respond(struct session *, char *, ...) __attribute__ ((format (printf, 2, 3))); void session_bufferevent_new(struct session *); SPLAY_PROTOTYPE(sessiontree, session, s_nodes, session_cmp); /* config.c */ #define PURGE_LISTENERS 0x01 #define PURGE_MAPS 0x02 #define PURGE_RULES 0x04 #define PURGE_SSL 0x08 #define PURGE_EVERYTHING 0xff void purge_config(struct smtpd *, u_int8_t); void unconfigure(struct smtpd *); void configure(struct smtpd *); void init_pipes(struct smtpd *); void config_pipes(struct smtpd *, struct peer *, u_int); void config_peers(struct smtpd *, struct peer *, u_int); /* parse.y */ int parse_config(struct smtpd *, const char *, int); int cmdline_symset(char *); /* ssl.c */ void ssl_init(void); void ssl_transaction(struct session *); void ssl_session_init(struct session *); void ssl_session_destroy(struct session *); int ssl_load_certfile(struct smtpd *, const char *, u_int8_t); void ssl_setup(struct smtpd *, struct listener *); int ssl_cmp(struct ssl *, struct ssl *); SPLAY_PROTOTYPE(ssltree, ssl, ssl_nodes, ssl_cmp); /* ssl_privsep.c */ int ssl_ctx_use_private_key(void *, char *, off_t); int ssl_ctx_use_certificate_chain(void *, char *, off_t); /* map.c */ struct map *map_find(struct smtpd *, objid_t); struct map *map_findbyname(struct smtpd *, const char *); /* util.c */ typedef struct arglist arglist; struct arglist { char **list; u_int num; u_int nalloc; }; void addargs(arglist *, char *, ...) __attribute__((format(printf, 2, 3))); int bsnprintf(char *, size_t, const char *, ...) __attribute__ ((format (printf, 3, 4))); int hostname_match(char *, char *); int recipient_to_path(struct path *, char *); int valid_localpart(char *); int valid_domainpart(char *); char *ss_to_text(struct sockaddr_storage *); char *time_to_text(time_t); int secure_file(int, char *, struct passwd *, int); void lowercase(char *, char *, size_t); void sa_set_port(struct sockaddr *, char *); struct path *path_dup(struct path *); u_int64_t generate_uid(void); void fdlimit(double); int availdesc(void); int table_alloc(void ***, int *); void *table_lookup(void **, int, int); void auxsplit(struct aux *, char *); char *rcpt_pretty(struct aux *);