Context Navigation

source: trunk/src/sh_mail.c@ 256

Last change on this file since 256 was 252, checked in by katerina, 15 years ago
Add code to check for stale file records on close() and fclose(), fix sl_close() to handle open stream (ticket #163).
File size: 44.1 KB

Rev	Line
[1]	1	/* SAMHAIN file system integrity testing */
	2	/* Copyright (C) 1999, 2000 Rainer Wichmann */
	3	/* */
	4	/* This program is free software; you can redistribute it */
	5	/* and/or modify */
	6	/* it under the terms of the GNU General Public License as */
	7	/* published by */
	8	/* the Free Software Foundation; either version 2 of the License, or */
	9	/* (at your option) any later version. */
	10	/* */
	11	/* This program is distributed in the hope that it will be useful, */
	12	/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
	13	/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
	14	/* GNU General Public License for more details. */
	15	/* */
	16	/* You should have received a copy of the GNU General Public License */
	17	/* along with this program; if not, write to the Free Software */
	18	/* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
	19
	20	#include "config_xor.h"
	21
	22	#include <stdio.h>
	23	#include <stdlib.h>
	24	#include <string.h>
	25	#include <unistd.h>
	26	#include <pwd.h>
	27	#include <sys/types.h>
	28	#include <sys/stat.h>
	29	#include <fcntl.h>
	30	#include <errno.h>
	31	#include <signal.h>
	32	#include <setjmp.h>
	33
	34	#if defined(SH_WITH_MAIL)
	35
	36	#if TIME_WITH_SYS_TIME
	37	#include <sys/time.h>
	38	#include <time.h>
	39	#else
	40	#if HAVE_SYS_TIME_H
	41	#include <sys/time.h>
	42	#else
	43	#include <time.h>
	44	#endif
	45	#endif
	46
	47
	48	#ifdef HAVE_MEMORY_H
	49	#include <memory.h>
	50	#endif
	51
	52	#include "samhain.h"
	53	#include "sh_error.h"
	54	#include "sh_unix.h"
	55	#include "sh_tiger.h"
	56	#include "sh_mail.h"
	57	#include "sh_utils.h"
	58	#include "sh_fifo.h"
	59	#include "sh_tools.h"
[137]	60	#include "sh_pthread.h"
[215]	61	#include "sh_filter.h"
[214]	62	#include "sh_mail_int.h"
	63	#include "sh_nmail.h"
[1]	64
	65	#undef FIL__
	66	#define FIL__ _("sh_mail.c")
	67	#undef GOOD
	68	#undef BAD
	69
	70	static int failedMail = SL_FALSE;
	71
	72	static dnsrep * return_mx (char *domain);
	73
	74	/*********************************************
	75	* utility function for verifying mails
	76	*********************************************/
	77
	78	typedef struct mail_trail_struct {
	79	char trail_id[2*SH_MINIBUF];
	80	char trail_key[KEY_LEN+1];
	81	struct mail_trail_struct * next;
	82	} mail_trail_type;
	83
	84	static mail_trail_type * mail_trail = NULL;
	85
[20]	86	int sh_mail_sigverify (const char * s)
[1]	87	{
	88	SL_TICKET fd;
	89	long i;
	90	char * buf;
	91	char * bufc;
	92	char key[81];
	93	char number[2*SH_MINIBUF];
	94	char audit_id[2 * SH_MINIBUF];
	95	long numsig;
	96	char key2[KEY_LEN+1];
	97
	98	char * theSig;
	99
	100	mail_trail_type * mail_trail_ptr = NULL;
	101
	102	sh_error_logoff();
	103
	104	ASSERT((s != NULL && sl_strlen(s) < PATH_MAX),
	105	_("(s != NULL && sl_strlen(s) < PATH_MAX)"));
	106
	107	if (s == NULL \|\| sl_strlen(s) >= PATH_MAX)
	108	_exit (EXIT_FAILURE);
	109
	110	/* open the file, then check it
	111	*/
	112	if (0 != sl_is_suid())
	113	{
	114	fprintf(stderr, _("Cannot open file %s in suid mode\n"), s);
	115	_exit (EXIT_FAILURE);
	116	}
[248]	117	if ( SL_ISERROR(fd = sl_open_read (FIL__, __LINE__, s, SL_NOPRIV)))
[1]	118	{
	119	fprintf(stderr, _("Could not open file %s\n"), s);
	120	_exit (EXIT_FAILURE);
	121	}
	122
[170]	123	buf = SH_ALLOC( (size_t)(SH_MSG_BUF+SH_BUFSIZE+1));
	124	bufc = SH_ALLOC( (size_t)(SH_MSG_BUF+SH_MAXBUF+1));
[1]	125
	126	while (1 == 1)
	127	{
	128	buf[0] = '\0';
	129	bufc[0] = '\0';
	130
	131	/* find start of next message
	132	*/
	133	while (0 != sl_strncmp(buf, _("-----BEGIN MESSAGE-----"),
	134	sizeof("-----BEGIN MESSAGE-----")-1))
	135	{
[170]	136	(void) sh_unix_getline (fd, buf, SH_MSG_BUF+SH_BUFSIZE);
[1]	137	if (buf[0] == '\0')
	138	{
	139	/* End of mailbox reached, exit.
	140	*/
	141	(void) fflush(stdout);
	142	_exit (EXIT_SUCCESS);
	143
	144	/* Fix for AIX cc complaint.
	145	*/
	146	/@notreached@/
	147	return 0;
	148	}
	149	}
	150
	151	/* Read message, compress into bufc.
	152	*/
	153	while (1 == 1)
	154	{
[170]	155	(void) sh_unix_getline (fd, buf, SH_MSG_BUF+SH_BUFSIZE);
[1]	156	if (0 == sl_strncmp(buf, _("-----BEGIN SIGNATURE-----"),
	157	sizeof("-----BEGIN SIGNATURE-----")-1))
	158	break;
	159	if (buf[0] == '\0')
	160	_exit (EXIT_FAILURE);
[170]	161	(void) sh_util_compress(bufc, buf, SH_MSG_BUF+SH_MAXBUF-KEY_LEN);
[1]	162	}
	163
	164	/* get signature and number
	165	*/
[34]	166	(void) sh_unix_getline (fd, key, (int)sizeof(key));
[1]	167	key[KEY_LEN] = '\0';
	168
[34]	169	(void) sh_unix_getline (fd, number, (int)sizeof(number));
[1]	170	number[(2*SH_MINIBUF) - 2] = '\0';
	171	numsig = atol (number);
	172	(void) sl_strlcpy (audit_id, &number[7], 2*SH_MINIBUF);
	173
	174	fprintf(stderr, _("Message %06ld Trail %s\n"),
	175	numsig, /@-usedef@/ audit_id /@+usedef@/);
	176
	177	mail_trail_ptr = mail_trail;
	178	while (mail_trail_ptr)
	179	{
	180	if (0 == sl_strcmp(mail_trail_ptr->trail_id, audit_id))
	181	break;
	182	mail_trail_ptr = mail_trail_ptr->next;
	183	}
	184
	185	if (!mail_trail_ptr)
	186	{
	187	if (numsig > 0)
	188	{
[210]	189	fprintf (stderr, "%s",_("ERROR (no key -- cannot check)\n"));
[1]	190	continue;
	191	}
	192	else
	193	{
	194	mail_trail_ptr = SH_ALLOC (sizeof(mail_trail_type));
	195	mail_trail_ptr->next = mail_trail;
	196	mail_trail = mail_trail_ptr;
	197	(void) sl_strlcpy (mail_trail_ptr->trail_id,
	198	audit_id, 2*SH_MINIBUF);
	199	}
	200	}
	201	else if (numsig == 0)
	202	{
[210]	203	fprintf (stderr, "%s",_("ERROR (repeated audit trail)\n"));
[1]	204	continue;
	205	}
	206
	207
	208	if (numsig == 0)
	209	{
	210	sh_util_encode(key, bufc, 1, 'A');
	211	(void) sl_strlcpy (mail_trail_ptr->trail_key, key, KEY_LEN+1);
[210]	212	fprintf (stderr, "%s",_("(unchecked)\n"));
[1]	213	}
	214	else
	215	{
[133]	216	char sigbuf[KEYBUF_SIZE];
	217
[1]	218	/* iterate key
	219	*/
	220	(void) sl_strlcpy(key2, mail_trail_ptr->trail_key, KEY_LEN+1);
	221	for (i = 0; i < numsig; ++i)
	222	{
[133]	223	char hashbuf[KEYBUF_SIZE];
[1]	224	(void) sl_strlcpy (key2,
[133]	225	sh_tiger_hash (key2, TIGER_DATA, KEY_LEN,
	226	hashbuf, sizeof(hashbuf)),
[1]	227	KEY_LEN+1);
	228	}
	229
	230
[133]	231	theSig = sh_util_siggen (key2, bufc, sl_strlen(bufc), sigbuf, sizeof(sigbuf));
[1]	232	if (sl_strncmp (key,
	233	theSig,
	234	KEY_LEN) != 0)
	235	{
[210]	236	fprintf (stderr, "%s",_("(FAILED)\n"));
[1]	237	}
	238	else
	239	{
[210]	240	fprintf (stderr, "%s",_("(passed)\n"));
[1]	241	}
	242
	243	}
	244
	245	} /* end scan mailbox */
	246
	247	/@notreached@/
	248	}
	249
[22]	250	int sh_mail_setNum (const char * str)
[1]	251	{
	252	int i = atoi (str);
	253
	254	SL_ENTER(_("sh_mail_setNum"));
	255
	256	if (i >= 0 && i < SH_FIFO_MAX)
	257	sh.mailNum.alarm_interval = (time_t) i;
	258	else
	259	SL_RETURN ((-1), _("sh_mail_setNum"));
	260	SL_RETURN( (0), _("sh_mail_setNum"));
	261	}
	262
	263
[214]	264	int sh_mail_all_in_one = S_FALSE;
[1]	265
[22]	266	int sh_mail_setFlag (const char * str)
[1]	267	{
	268	int i;
	269	SL_ENTER(_("sh_mail_setFlag"));
[214]	270	i = sh_util_flagval(str, &sh_mail_all_in_one);
[1]	271	SL_RETURN(i, _("sh_mail_setFlag"));
	272	}
	273
	274	static char * mail_subject = NULL;
	275
[22]	276	int set_mail_subject (const char * str)
[1]	277	{
	278	SL_ENTER(_("set_mail_subject"));
	279	if (!str)
	280	SL_RETURN( (-1), _("set_mail_subject"));
	281
	282	if (mail_subject != NULL)
	283	SH_FREE(mail_subject);
	284
	285	if (0 == sl_strncmp(str, _("NULL"), 4))
	286	{
	287	mail_subject = NULL;
	288	SL_RETURN( 0, _("set_mail_subject"));
	289	}
	290
	291	mail_subject = sh_util_strdup(str);
	292	SL_RETURN( (0), _("set_mail_subject"));
	293	}
	294
[214]	295	SH_MUTEX_INIT(mutex_fifo_mail, PTHREAD_MUTEX_INITIALIZER);
[1]	296
[214]	297	SH_FIFO * fifo_mail = NULL;
[1]	298
	299	static
	300	void sh_mail_emptystack (void)
	301	{
	302	char * msg;
	303	size_t len;
	304
	305	SL_ENTER(_("sh_mail_emptystack"));
	306
	307	if (fifo_mail == NULL)
	308	SL_RET0(_("sh_mail_emptystack"));
	309
[214]	310	SH_MUTEX_LOCK(mutex_fifo_mail);
[1]	311	while (NULL != (msg = pop_list(fifo_mail)))
	312	{
	313	len = sl_strlen(msg);
	314	memset(msg, 0, len);
	315	SH_FREE(msg);
	316	}
[214]	317	SH_MUTEX_UNLOCK(mutex_fifo_mail);
[1]	318
	319	SL_RET0(_("sh_mail_emptystack"));
	320	}
	321
	322	/* insert "\r\n" after each 998 char
	323	*/
[214]	324	static char * split_string(const char * str);
[1]	325
[214]	326	/* fixes warning: variable âpâ might be clobbered by âlongjmpâ or âvforkâ*/
	327	static char ** p_dummy;
	328
	329	int sh_mail_pushstack (int severity, const char * msg, const char * alias)
[1]	330	{
	331	char * p;
[214]	332	volatile int retval = 0;
[1]	333	int status;
	334
	335	SL_ENTER(_("sh_mail_pushstack"));
	336
[214]	337	if (msg == NULL \|\| failedMail == SL_TRUE /* \|\| sh.srvmail.name[0] == '\0' */)
[1]	338	SL_RETURN((0), (_("sh_mail_pushstack")));
	339
[214]	340	p = split_string(msg);
	341	/* fixes "variable âpâ might be clobbered by âlongjmpâ or âvforkâ" */
	342	p_dummy = &p;
[1]	343
[214]	344	SH_MUTEX_LOCK(mutex_fifo_mail);
[1]	345
	346	if (fifo_mail == NULL)
	347	{
	348	fifo_mail = SH_ALLOC(sizeof(SH_FIFO));
	349	fifo_init(fifo_mail);
	350	}
[214]	351	status = push_list (fifo_mail, p, severity, alias);
	352	SH_MUTEX_UNLOCK(mutex_fifo_mail);
[1]	353
	354	if (status >= 0)
	355	++sh.mailNum.alarm_last;
	356
	357	SH_FREE(p);
	358
	359	if (sh.mailNum.alarm_last >= sh.mailNum.alarm_interval)
	360	{
[214]	361	BREAKEXIT(sh_nmail_flush);
	362	retval = sh_nmail_flush ();
[1]	363	}
	364
	365	if (status == SH_FIFO_MAX)
	366	retval = -2;
	367	SL_RETURN(retval, (_("sh_mail_pushstack")));
	368	}
	369
	370
	371	/* The mailer.
	372	*/
[131]	373	static int sh_mail_end_conn (FILE * connfile, int fd);
[214]	374	static FILE * sh_mail_start_conn (struct alias * address, int * fd, int * anum);
[1]	375
	376	static
[214]	377	void sh_mail_get_subject(const char * message,
[1]	378	char * mheader, size_t len)
	379	{
	380	st_format rep_serv_tab[] = {
	381	{ 'T', S_FMT_TIME, 0, 0, NULL},
	382	{ 'H', S_FMT_STRING, 0, 0, NULL},
	383	{ 'M', S_FMT_STRING, 0, 0, NULL},
	384	{ 'S', S_FMT_STRING, 0, 0, NULL},
	385	{'\0', S_FMT_ULONG, 0, 0, NULL},
	386	};
	387
	388	char * p;
	389	char * mptr;
	390	char sev[8];
[214]	391	char * msg;
[1]	392
	393	SL_ENTER(_("sh_mail_get_subject"));
	394
	395	(void) sl_strlcpy(mheader, _("Subject: "), len);
	396	if (NULL == strchr(mail_subject, '%'))
	397	{
	398	(void) sl_strlcat(mheader, mail_subject, len);
	399	SL_RET0(_("sh_mail_get_subject"));
	400	}
	401
	402
	403	rep_serv_tab[0].data_ulong = (unsigned long) time(NULL);
	404	rep_serv_tab[1].data_str = sh.host.name;
	405
	406	/* fast forward to the important part
	407	*/
[214]	408	msg = sh_util_strdup(message);
	409
	410	mptr = sl_strstr(msg, _("msg="));
[1]	411	if (mptr)
	412	{
	413	mptr += 4;
	414	rep_serv_tab[2].data_str = mptr;
	415	}
	416	else
[214]	417	rep_serv_tab[2].data_str = msg;
[1]	418
[214]	419	mptr = sl_strstr(msg, _("sev="));
[1]	420	if (mptr)
	421	{
	422	mptr += 5;
	423	sev[0] = *mptr; ++mptr;
	424	sev[1] = *mptr; ++mptr;
	425	sev[2] = *mptr; ++mptr;
	426	sev[3] = *mptr; ++mptr;
	427	sev[4] = '\0';
	428	}
	429	else
	430	{
[214]	431	mptr = msg;
[1]	432	sev[0] = *mptr; ++mptr;
	433	sev[1] = *mptr; ++mptr;
	434	sev[2] = *mptr; ++mptr;
	435	sev[3] = *mptr; ++mptr;
	436	if (*mptr == ' ') {
	437	sev[4] = '\0';
	438	} else {
	439	sev[4] = *mptr; ++mptr;
	440	if (*mptr == ' ') {
	441	sev[5] = '\0';
	442	} else {
	443	sev[5] = *mptr;
	444	sev[6] = '\0';
	445	}
	446	}
	447	}
	448	rep_serv_tab[3].data_str = sev;
	449
	450
	451	p = sh_util_formatted(mail_subject, rep_serv_tab);
	452	(void) sl_strlcat(mheader, p, len);
	453	SH_FREE(p);
[214]	454	SH_FREE(msg);
[1]	455	SL_RET0(_("sh_mail_get_subject"));
	456	}
	457
[214]	458	void sh_mail_signature_block (sh_string * sigMsg, char * recipient,
	459	char * bufcompress)
[1]	460	{
[214]	461	time_t id_audit;
	462	char * theSig;
	463	char ibuf[80];
	464	unsigned int count;
[1]	465
[214]	466	/* ------ signature block ------------------------------------ */
	467
	468	sigMsg = sh_string_add_from_char(sigMsg,
	469	_("-----BEGIN SIGNATURE-----\r\n"));
	470
	471	count = sh_nmail_get_mailkey (recipient, skey->mailkey_new, KEY_LEN+1,
	472	&id_audit);
	473
	474	if (count != 0)
[34]	475	{
[214]	476	char sigbuf[KEYBUF_SIZE];
	477
	478	/* Sign the message with the signature key.
	479	*/
	480	theSig = sh_util_siggen (skey->mailkey_new,
	481	bufcompress, sl_strlen(bufcompress),
	482	sigbuf, sizeof(sigbuf));
	483	sigMsg = sh_string_add_from_char(sigMsg, theSig);
	484	}
	485	else
	486	{
	487	/* reveal first signature key
	488	*/
	489	/* flawfinder: ignore */
	490	(void) sl_strlcpy(skey->crypt, skey->mailkey_new, KEY_LEN+1);
	491
	492	BREAKEXIT(sh_util_encode);
	493	/* flawfinder: ignore */
	494	sh_util_encode(skey->crypt, bufcompress, 0, 'A');
	495
	496	/* flawfinder: ignore */
	497	sigMsg = sh_string_add_from_char(sigMsg, skey->crypt);
	498
	499	/* flawfinder: ignore */
	500	memset (skey->crypt, 0, KEY_LEN);
	501	}
[1]	502
[214]	503	sigMsg = sh_string_add_from_char(sigMsg, "\r\n");
[1]	504
[214]	505	sl_snprintf(ibuf, sizeof(ibuf), _("%06u %010lu::%s\r\n"),
	506	count, (unsigned long) id_audit, sh.host.name);
[1]	507
[214]	508	sigMsg = sh_string_add_from_char(sigMsg, ibuf);
	509	sigMsg = sh_string_add_from_char(sigMsg, _("-----END MESSAGE-----"));
[34]	510
[214]	511	return;
[1]	512	}
	513
[214]	514	int sh_mail_msg (const char * message)
[1]	515	{
	516	char subject[32+32+SH_MINIBUF+2+3+SH_PATHBUF];
	517	char mheader[32+32+SH_MINIBUF+2+3];
	518
[214]	519	sh_string * mailMsg;
	520	sh_string * compMsg;
	521	int status = 0;
	522	volatile int errcount;
[1]	523	size_t wrlen;
[214]	524	volatile int retval = -1;
[1]	525
	526	char * bufcompress;
[214]	527	size_t compressed;
	528
[1]	529	static int failcount = 0;
	530	FILE * connfile = NULL;
	531
	532	struct sigaction old_act;
	533	struct sigaction new_act;
	534
	535	static time_t fail_time = 0;
	536	static time_t success_time = 0;
	537
[131]	538	int ma_socket = -1;
	539
[214]	540	int address_num = 0;
	541	sh_string * theMsg = NULL;
[1]	542
	543	/* #define SH_MAILBUF (256) */
[214]	544	#define SH_MAILBUF 4096
[1]	545
[132]	546	char timebuf[81];
[1]	547
	548	SL_ENTER(_("sh_mail_msg"));
	549
[214]	550	/*
	551	* Return if we cannot mail.
[1]	552	*/
	553	if (failedMail == SL_TRUE)
	554	SL_RETURN((-1), _("sh_mail_msg"));
	555
[214]	556	/*
	557	* Final failure, can't mail for SH_MAX_FAIL hours.
	558	*/
[1]	559	if ( (success_time > 0) && (fail_time > 0) &&
	560	(time(NULL) - success_time) > 3600*SH_MAX_FAIL)
	561	{
	562	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_SRV_FAIL,
[214]	563	_("mail"),
	564	sh_string_str(all_recipients->recipient));
[1]	565	sh_mail_emptystack();
	566	sh.mailNum.alarm_last = 0;
	567	failedMail = SL_TRUE;
	568	SL_RETURN((-1), _("sh_mail_msg"));
	569	}
	570
[214]	571	/*
	572	* Try at most every three seconds to mail if there was a failure.
[1]	573	*/
	574	if ((fail_time > 0) && (time(NULL) - fail_time) < 3/600/)
	575	{
	576	if (failcount > 3)
	577	{
[214]	578	/* -- Save for later. Changed: done by caller. --
	579	* sh_nmail_pushstack (severity, message, alias);
[1]	580	*/
	581	++failcount;
	582
	583	SL_RETURN((-1), _("sh_mail_msg"));
	584	}
	585	else
	586	{
	587	(void) retry_msleep(2, 0);
	588	++failcount;
	589	}
	590	}
	591
	592	/* -- Reset time of last failure. --
	593	*/
	594	fail_time = 0;
	595
	596
[214]	597	/* --------- Build complete message. ------------------------ */
[1]	598
[214]	599	/* Don't flush the queue here, because tag_list doesn't know
	600	* how to filter messages. */
[1]	601
[214]	602	theMsg = sh_string_new_from_lchar(message, strlen(message));
[1]	603
	604	/* ---------- Header ---------------------------------------- */
	605
	606	if (mail_subject == NULL)
	607	{
	608	(void) sl_strlcpy(mheader, _("Subject: "), sizeof(mheader)-5);
[214]	609	(void) sl_strlcat(mheader,
	610	sh_unix_time (0, timebuf, sizeof(timebuf)),
[132]	611	sizeof(mheader)-5);
[1]	612	(void) sl_strlcat(mheader, " ", sizeof(mheader)-5);
	613	(void) sl_strlcat(mheader, sh.host.name, sizeof(mheader)-5);
	614	}
	615	else
	616	{
	617
	618	if (message)
	619	{
	620	sh_mail_get_subject(message, mheader, sizeof(mheader)-5);
	621	}
	622	else
	623	{
	624	(void) sl_strlcpy(mheader, _("Subject: "), sizeof(mheader)-5);
[214]	625	(void) sl_strlcat(mheader,
	626	sh_unix_time (0, timebuf, sizeof(timebuf)),
[132]	627	sizeof(mheader)-5);
[1]	628	(void) sl_strlcat(mheader, " ", sizeof(mheader)-5);
	629	(void) sl_strlcat(mheader, sh.host.name, sizeof(mheader)-5);
	630	}
	631	}
	632
	633	/* RFC 821: Header is terminated by an empty line
	634	*/
	635	(void) sl_strlcat(mheader, "\015\012\015\012", sizeof(mheader));
	636
	637	/* ---------- Message --------------------------------------- */
	638
[132]	639	(void) sl_strlcpy(subject, sh_unix_time (0, timebuf, sizeof(timebuf)),
	640	sizeof(subject));
[1]	641	(void) sl_strlcat(subject, " ", sizeof(subject));
	642	(void) sl_strlcat(subject, sh.host.name, sizeof(subject));
	643	(void) sl_strlcat(subject, "\r\n", sizeof(subject));
	644
	645
[214]	646	mailMsg = sh_string_new (SH_MAILBUF);
	647	compMsg = sh_string_new (SH_MAILBUF);
[1]	648
[214]	649	mailMsg = sh_string_add_from_char(mailMsg, mheader);
	650	mailMsg = sh_string_add_from_char(mailMsg,
	651	_("-----BEGIN MESSAGE-----\r\n"));
[1]	652
[214]	653	mailMsg = sh_string_add_from_char(mailMsg, subject);
	654	mailMsg = sh_string_add (mailMsg, theMsg);
	655	mailMsg = sh_string_add_from_char(mailMsg, "\r\n");
[1]	656
[214]	657	/* ---------- Compressed Message ---------------------------- */
[1]	658
[214]	659	compMsg = sh_string_add_from_char(compMsg, subject);
	660	compMsg = sh_string_add (compMsg, theMsg);
	661	compMsg = sh_string_add_from_char(compMsg, "\r\n");
[1]	662
[214]	663	bufcompress = SH_ALLOC(sh_string_len(compMsg) + KEY_LEN + 1);
	664	bufcompress[0] = '\0';
[1]	665
[214]	666	compressed = sh_util_compress (bufcompress,
	667	sh_string_str(compMsg),
	668	sh_string_len(compMsg) + 1);
[1]	669
	670	/* ---------- Connect ---------------------------------------- */
	671
	672	/* -- Catch (ignore) 'broken pipe'.
	673	*/
	674	new_act.sa_handler = SIG_IGN;
	675	sigemptyset( &new_act.sa_mask ); /* set an empty mask */
	676	new_act.sa_flags = 0; /* init sa_flags */
	677
	678	(void) sigaction (SIGPIPE, &new_act, &old_act);
	679
	680	errcount = 0;
	681
[214]	682	if (sh_mail_all_in_one == S_FALSE)
[1]	683	{
[214]	684	struct alias * address_list;
	685
	686	address_list = all_recipients;
	687
	688	while (address_list)
[1]	689	{
[214]	690	if (address_list->send_mail == 1)
	691	{
	692	connfile = sh_mail_start_conn (address_list,
	693	&ma_socket, &address_num);
[1]	694
[214]	695	if (NULL != connfile)
	696	{
	697	wrlen = fwrite (sh_string_str(mailMsg), 1,
	698	sh_string_len(mailMsg), connfile);
	699	wrlen -= sh_string_len(mailMsg);
	700
	701	if (wrlen == 0)
	702	{
	703	sh_string * sigMsg = sh_string_new (0);
	704
	705	sh_mail_signature_block (sigMsg,
	706	sh_string_str(address_list->recipient),
	707	bufcompress);
	708
	709	wrlen = fwrite (sh_string_str(sigMsg), 1,
	710	sh_string_len(sigMsg), connfile);
	711	wrlen -= sh_string_len(sigMsg);
	712
	713	sh_string_destroy(&sigMsg);
	714	}
	715
	716	if (wrlen == 0)
	717	status = sh_mail_end_conn (connfile, ma_socket);
	718	else
	719	status = -1;
	720	}
	721	if (NULL == connfile \|\| status != 0)
	722	{
	723	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_SRV_FAIL,
	724	_("mail"),
	725	sh_string_str(address_list->recipient));
	726	++errcount;
	727	++sh.statistics.mail_failed;
	728	}
[1]	729	else
[214]	730	{
	731	++sh.statistics.mail_success;
	732	}
	733
	734	if (connfile != NULL)
	735	{
[252]	736	(void) sl_fclose (FIL__, __LINE__, connfile);
[214]	737	connfile = NULL;
	738	}
[1]	739	}
[214]	740	address_list = address_list->all_next;
[1]	741	}
	742	}
	743	else
	744	{
[214]	745	connfile = sh_mail_start_conn (NULL, &ma_socket, &address_num);
	746
[1]	747	if (NULL != connfile)
	748	{
[214]	749	wrlen = fwrite (sh_string_str(mailMsg), 1,
	750	sh_string_len(mailMsg), connfile);
	751	wrlen -= sh_string_len(mailMsg);
	752
[1]	753	if (wrlen == 0)
[214]	754	{
	755	sh_string * sigMsg = sh_string_new (0);
	756
	757	sh_mail_signature_block (sigMsg,
	758	NULL,
	759	bufcompress);
	760
	761	wrlen = fwrite (sh_string_str(sigMsg), 1,
	762	sh_string_len(sigMsg), connfile);
	763	wrlen -= sh_string_len(sigMsg);
	764
	765	sh_string_destroy(&sigMsg);
	766	}
	767
	768	if (wrlen == 0)
[131]	769	status = sh_mail_end_conn (connfile, ma_socket);
[1]	770	else
	771	status = -1;
	772	}
[214]	773
	774	if (NULL == connfile \|\| status != 0)
[1]	775	{
[214]	776	struct alias* ma_address = all_recipients;
	777
	778	while (ma_address)
	779	{
	780	if (ma_address->send_mail == 1)
	781	break;
	782	ma_address = ma_address->all_next;
	783	}
	784
[1]	785	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_SRV_FAIL,
[214]	786	_("mail"), sh_string_str(ma_address->recipient));
[1]	787	errcount = address_num;
	788	++sh.statistics.mail_failed;
	789	}
	790	else
	791	{
	792	++sh.statistics.mail_success;
	793	}
	794
	795	if (connfile != NULL)
	796	{
[252]	797	(void) sl_fclose (FIL__, __LINE__, connfile);
[1]	798	connfile = NULL;
	799	}
	800	}
	801
[214]	802	memset (bufcompress, 0, compressed);
[1]	803	SH_FREE(bufcompress);
	804
[214]	805	memset (sh_string_str(mailMsg), 0, sh_string_len(mailMsg));
	806	memset (sh_string_str(compMsg), 0, sh_string_len(compMsg));
	807	memset (sh_string_str(theMsg), 0, sh_string_len(theMsg));
[1]	808
[214]	809	sh_string_destroy(&mailMsg);
	810	sh_string_destroy(&compMsg);
	811	sh_string_destroy(&theMsg);
	812
[1]	813	/* --- Stay responsible for delivery in case of failure --- */
	814
[214]	815	if (errcount == address_num)
[1]	816	{
[214]	817	rollback_list(fifo_mail);
	818	retval = -1;
[1]	819	}
[214]	820	else
[1]	821	{
[214]	822	mark_list(fifo_mail);
[1]	823	}
	824
	825	/* --- Reset signal. ---
	826	*/
	827	(void) sigaction (SIGPIPE, &old_act, NULL);
	828
	829	if (errcount == address_num)
	830	{
	831	fail_time = time(NULL);
	832	SL_RETURN((retval), _("sh_mail_msg"));
	833	}
[214]	834
[1]	835	success_time = time(NULL);
	836	failcount = 0;
	837
	838	SL_RETURN((0), _("sh_mail_msg"));
	839	}
	840
	841
	842	/*
	843	*
	844	* SMTP CODE BELOW
	845	*
	846	*
	847	*/
	848
	849	#include <ctype.h>
	850	#ifdef HOST_IS_HPUX
	851	#define _XOPEN_SOURCE_EXTENDED
	852	#endif
	853	#include <netdb.h>
	854	#include <sys/types.h>
	855	#include <sys/socket.h>
	856	#include <netinet/in.h>
	857	#ifndef S_SPLINT_S
	858	#include <arpa/inet.h>
	859	#else
	860	#define AF_INET 2
	861	#endif
	862
	863	#define SH_NEED_GETHOSTBYXXX
	864	#include "sh_static.h"
	865
	866	/* missing on HP-UX 10.20 */
	867	#ifndef IPPORT_SMTP
	868	#define IPPORT_SMTP 25
	869	#endif
	870
[137]	871	static int sh_mail_wait(int code, int ma_socket);
[1]	872
	873	static char * relay_host = NULL;
	874
[22]	875	int sh_mail_set_relay (const char * str_s)
[1]	876	{
	877	SL_ENTER(_("sh_mail_set_relay"));
	878
	879	if (str_s == NULL)
	880	SL_RETURN( -1, _("sh_mail_set_relay"));
	881
	882	if (relay_host != NULL)
[34]	883	{
	884	SH_FREE (relay_host);
	885	relay_host = NULL;
	886	}
[1]	887
	888	if (0 == sl_strncmp(str_s, _("NULL"), 4))
	889	{
	890	SL_RETURN( 0, _("sh_mail_set_relay"));
	891	}
	892
[34]	893	relay_host = sh_util_strdup(str_s);
	894
[1]	895	SL_RETURN( 0, _("sh_mail_set_relay"));
	896	}
	897
	898	static char * mail_sender = NULL;
	899
[22]	900	int sh_mail_set_sender (const char *str)
[1]	901	{
	902	if (mail_sender != NULL)
	903	{
	904	SH_FREE (mail_sender);
	905	mail_sender = NULL;
	906	}
	907	if (str != NULL)
	908	{
	909	mail_sender = sh_util_strdup (str);
	910	}
	911	if (mail_sender == NULL)
	912	{
	913	return -1;
	914	}
	915	return 0;
	916	}
	917
[216]	918	static int sh_mail_port = IPPORT_SMTP;
[1]	919
[216]	920	int sh_mail_set_port (const char * str)
	921	{
	922	int i = atoi (str);
	923
	924	SL_ENTER(_("sh_mail_set_port"));
	925
	926	if (i >= 0 && i < 65535)
	927	{
	928	sh_mail_port = i;
	929	}
	930	else
	931	{
	932	sh_mail_port = IPPORT_SMTP;
	933	SL_RETURN ((-1), _("sh_mail_set_port"));
	934	}
	935
	936	SL_RETURN( (0), _("sh_mail_set_port"));
	937	}
	938
[1]	939	/*************************
	940	*
	941	* start connection
[214]	942	* for details on SMTP, see RFC 821
	943	*
	944	* If ma_address == NULL, will send to all marked with
	945	* send_mail=1 in recipient list, else to ma_address.
[1]	946	*/
	947
	948	static time_t time_wait = 300;
	949
[214]	950	static FILE * sh_mail_start_conn (struct alias * ma_address,
	951	int * ma_socket, int * anum)
[1]	952	{
	953	char * address;
[214]	954	int aFlag = 0;
[1]	955
	956	int ecount;
	957
	958	char this_address[256];
	959	char ma_machine[256];
	960	char ma_user[256];
	961	char error_msg[256];
	962	char error_call[SH_MINIBUF];
	963	int error_num = 0;
	964	register int i, j, k;
	965	FILE * connFile = NULL;
	966	struct tm * my_tm;
[131]	967	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R)
	968	struct tm time_tm;
	969	#endif
[1]	970	time_t my_time;
	971	char my_tbuf[128];
	972
	973	int fd;
	974
	975	dnsrep * answers;
	976	mx * result;
	977
	978	SL_ENTER(_("sh_mail_start_conn"));
	979
[131]	980	*ma_socket = -1;
	981	time_wait = 300;
[1]	982
[214]	983	if (ma_address == NULL)
	984	{
	985	aFlag = 1;
	986	ma_address = all_recipients;
[1]	987
[214]	988	while (ma_address)
	989	{
	990	if (ma_address->send_mail == 1)
	991	break;
	992	ma_address = ma_address->all_next;
	993	}
	994	}
[1]	995
[214]	996	if (!ma_address)
[1]	997	{
	998	SL_RETURN( NULL, _("sh_mail_start_conn"));
	999	}
[214]	1000
	1001	address = sh_string_str(ma_address->recipient);
	1002
	1003	TPT(( 0, FIL__, __LINE__, _("msg=<address %s>\n"),
	1004	address));
	1005
	1006	/* ------- split adress ------------------ */
	1007
[1]	1008	if (strchr (address, '@') == NULL) {
	1009	(void) sl_strlcpy(ma_user, address, 256);
	1010	(void) sl_strlcpy(ma_machine, _("localhost"), 256);
	1011	} else {
	1012	i = 0;
	1013	while (i < 255 && address[i] != '@') {
	1014	ma_user[i] = address[i];
	1015	++i;
	1016	}
[214]	1017
[1]	1018	/* adress[i] = '@'
	1019	*/
	1020	ma_user[i] = '\0';
	1021	j = i + 1; k = i; i = 0;
	1022	while (i < 255 && address[i+j] != '\0') {
	1023	ma_machine[i] = address[i+j];
	1024	++i;
	1025	}
	1026	ma_machine[i] = '\0';
	1027	if (address[k] != '@' \|\| address[k+i+1] != '\0')
	1028	{
	1029	SL_RETURN( NULL, _("sh_mail_start_conn"));
	1030	}
	1031	}
	1032
	1033
	1034	if (relay_host != NULL)
	1035	{
	1036	(void) sl_strlcpy (ma_machine, relay_host, sizeof(ma_machine));
	1037	TPT((0, FIL__, __LINE__, _("msg=<user %s machine %s>\n"),
	1038	ma_user, ma_machine));
[216]	1039	fd = connect_port (ma_machine, sh_mail_port,
[1]	1040	error_call, &error_num, error_msg, 256);
	1041	}
	1042	else
	1043	{
[214]	1044	answers = ma_address->mx_list;
	1045	if (!answers)
	1046	{
	1047	answers = return_mx (ma_machine);
	1048	ma_address->mx_list = answers;
	1049	}
	1050
[1]	1051	if (answers)
	1052	{
	1053	result = answers->reply;
	1054	fd = -1;
	1055	for (i = 0; i < answers->count; ++i)
	1056	{
	1057	(void) sl_strlcpy(ma_machine, result[i].address,
	1058	sizeof(ma_machine));
	1059	TPT((0, FIL__, __LINE__,
	1060	_("msg=<user %s mx %s pref %d>\n"),
	1061	ma_user, ma_machine, result[i].pref));
[216]	1062	fd = connect_port (ma_machine, sh_mail_port,
[1]	1063	error_call, &error_num, error_msg, 256);
	1064	if (fd >= 0)
	1065	break;
	1066	}
	1067	}
	1068	else
	1069	{
	1070	(void) sl_strlcpy(error_call, _("return_mx"), SH_MINIBUF);
	1071	(void) sl_strlcpy(error_msg, _("The specified host is unknown: "),
	1072	256);
	1073	(void) sl_strlcat(error_msg, ma_machine, 256);
	1074	fd = -1;
	1075	}
	1076	}
	1077
	1078
	1079	if (fd < 0)
	1080	{
	1081	sh_error_handle ((-1), FIL__, __LINE__, error_num,
	1082	MSG_E_NET, error_msg, error_call,
	1083	_("email"), ma_machine);
	1084	SL_RETURN( NULL, _("sh_mail_start_conn"));
	1085	}
	1086
	1087	/* associate a FILE structure with it
	1088	*/
	1089	connFile = fdopen (fd, "r+");
	1090	if (connFile == NULL)
	1091	{
	1092	TPT(( 0, FIL__, __LINE__, _("msg=<fdopen() failed>\n")));
[252]	1093	(void) sl_close_fd(FIL__, __LINE__, fd);
[1]	1094	SL_RETURN( NULL, _("sh_mail_start_conn"));
	1095	}
	1096
	1097
	1098	/* say HELO to the other socket
	1099	*/
[131]	1100	if (0 == sh_mail_wait (220, fd))
[1]	1101	{
	1102	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_NET,
	1103	_("Timeout on SMTP session init"),
	1104	_("sh_mail_start_conn"),
	1105	_("mail"), sh.host.name);
	1106	TPT(( 0, FIL__, __LINE__, _("msg=<Timeout>\n")));
[252]	1107	(void) sl_fclose(FIL__, __LINE__, connFile);
[1]	1108	SL_RETURN( NULL, _("sh_mail_start_conn"));
	1109	}
	1110
	1111	(void) fflush(connFile);
	1112
	1113	if (0 != is_numeric(sh.host.name))
	1114	{
	1115	TPT(( 0, FIL__, __LINE__, _("msg=<HELO [%s]>%c%c"),
	1116	sh.host.name, 13, 10));
	1117	}
	1118	else
	1119	{
	1120	TPT(( 0, FIL__, __LINE__, _("msg=<HELO %s>%c%c"),
	1121	sh.host.name, 13, 10));
	1122	}
	1123	if (0 != is_numeric(sh.host.name))
	1124	fprintf(connFile, _("HELO [%s]%c%c"), sh.host.name, 13, 10);
	1125	else
	1126	fprintf(connFile, _("HELO %s%c%c"), sh.host.name, 13, 10);
	1127
	1128	(void) fflush(connFile);
	1129
[131]	1130	if (0 == sh_mail_wait(250, fd))
[1]	1131	{
	1132	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_NET,
	1133	_("HELO failed"), _("sh_mail_start_conn"),
	1134	_("mail"), sh.host.name);
	1135
	1136	TPT(( 0, FIL__, __LINE__, _("msg=<Timeout.>\n")));
[252]	1137	(void) sl_fclose(FIL__, __LINE__, connFile);
[1]	1138	SL_RETURN( NULL, _("sh_mail_start_conn"));
	1139	}
	1140
	1141	/* tell them who we are
	1142	*/
	1143	(void) sl_strlcpy (this_address,
	1144	mail_sender ? mail_sender : DEFAULT_SENDER, 256);
	1145	if (NULL == strchr(this_address, '@'))
	1146	{
	1147	(void) sl_strlcat (this_address, "@", 256);
	1148	if (0 != is_numeric(sh.host.name))
	1149	(void) sl_strlcat (this_address, _("example.com"), 256);
	1150	else
	1151	(void) sl_strlcat (this_address, sh.host.name, 256);
	1152	}
	1153
	1154	TPT(( 0, FIL__, __LINE__, _("msg=<MAIL FROM:<%s>>%c%c"),
	1155	this_address, 13, 10));
	1156
	1157	(void) fflush(connFile);
	1158	/@-usedef@/
	1159	fprintf(connFile, _("MAIL FROM:<%s>%c%c"), this_address, 13, 10);
	1160	/@+usedef@/
	1161	(void) fflush(connFile);
	1162
[131]	1163	if (0 == sh_mail_wait(250, fd))
[1]	1164	{
	1165	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_NET,
	1166	_("MAIL FROM failed"), _("sh_mail_start_conn"),
	1167	_("mail"), this_address);
	1168	TPT(( 0, FIL__, __LINE__, _("msg=<Timeout.>\n")));
[252]	1169	(void) sl_fclose(FIL__, __LINE__, connFile);
[1]	1170	SL_RETURN( NULL, _("sh_mail_start_conn"));
	1171	}
	1172
	1173	/* tell them who to send mail to
	1174	*/
[214]	1175	if (aFlag == 0)
[1]	1176	{
	1177	TPT(( 0, FIL__, __LINE__, _("msg=<RCPT TO:<%s>>%c%c"),
	1178	address, 13, 10));
	1179
	1180	(void) fflush(connFile);
	1181	fprintf(connFile, _("RCPT TO:<%s>%c%c"), address, 13, 10);
	1182	(void) fflush(connFile);
	1183
[131]	1184	if (0 == sh_mail_wait(250, fd))
[1]	1185	{
	1186	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_NET,
	1187	_("RCPT TO failed"), _("sh_mail_start_conn"),
	1188	_("mail"), address);
	1189	TPT(( 0, FIL__, __LINE__, _("msg=<Timeout.>\n")));
[252]	1190	(void) sl_fclose(FIL__, __LINE__, connFile);
[1]	1191	SL_RETURN( NULL, _("sh_mail_start_conn"));
	1192	}
[214]	1193	*anum = 1;
[1]	1194	}
	1195	else
	1196	{
[214]	1197	int address_num = 0;
	1198	ecount = 0;
	1199
	1200	ma_address = all_recipients;
	1201
	1202	while (ma_address)
[1]	1203	{
[214]	1204	if (ma_address->send_mail != 1)
	1205	{
	1206	ma_address = ma_address->next;
	1207	continue;
	1208	}
	1209
	1210	++address_num;
	1211
[1]	1212	TPT(( 0, FIL__, __LINE__, _("msg=<RCPT TO:<%s>>%c%c"),
[214]	1213	sh_string_str(ma_address->recipient), 13, 10));
[1]	1214
	1215	(void) fflush(connFile);
[214]	1216	fprintf(connFile, _("RCPT TO:<%s>%c%c"),
	1217	sh_string_str(ma_address->recipient), 13, 10);
[1]	1218	(void) fflush(connFile);
	1219
[131]	1220	if (0 == sh_mail_wait(250, fd))
[1]	1221	{
	1222	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_NET,
	1223	_("RCPT TO failed"), _("sh_mail_start_conn"),
[214]	1224	_("mail"), sh_string_str(ma_address->recipient));
[1]	1225
	1226	TPT(( 0, FIL__, __LINE__, _("msg=<Timeout.>\n")));
	1227	++ecount;
	1228	}
[214]	1229	ma_address = ma_address->next;
[1]	1230	}
[214]	1231
	1232	*anum += address_num;
	1233
[1]	1234	if (ecount == address_num)
	1235	{
[252]	1236	(void) sl_fclose(FIL__, __LINE__, connFile);
[1]	1237	SL_RETURN( NULL, _("sh_mail_start_conn"));
	1238	}
	1239	}
	1240
	1241	/* Send the message
	1242	*/
	1243	TPT(( 0, FIL__, __LINE__, _("msg=<DATA>%c%c"), 13, 10));
	1244
	1245	(void) fflush(connFile);
	1246	fprintf(connFile, _("DATA%c%c"), 13, 10);
	1247	(void) fflush(connFile);
	1248
[131]	1249	if (0 == sh_mail_wait(354, fd))
[1]	1250	{
	1251	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_NET,
	1252	_("DATA failed"), _("sh_mail_start_conn"),
	1253	_("mail"), address);
	1254	TPT(( 0, FIL__, __LINE__, _("msg=<Timeout.>\n")));
[252]	1255	(void) sl_fclose(FIL__, __LINE__, connFile);
[1]	1256	SL_RETURN( NULL, _("sh_mail_start_conn"));
	1257	}
	1258
	1259
	1260	my_time = time(NULL);
[131]	1261	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R)
	1262	my_tm = localtime_r(&my_time, &time_tm);
	1263	#else
[1]	1264	my_tm = localtime(&my_time);
[131]	1265	#endif
[238]	1266
	1267	#if defined(HAVE_STRFTIME_Z)
	1268	(void) strftime(my_tbuf, 127, _("%a, %d %b %Y %H:%M:%S %z"), my_tm);
	1269	#else
[1]	1270	(void) strftime(my_tbuf, 127, _("%a, %d %b %Y %H:%M:%S %Z"), my_tm);
[238]	1271	#endif
[1]	1272
	1273	TPT(( 0, FIL__, __LINE__, _("msg=<From: <%s>%c%cTo: <%s>%c%cDate: %s>%c%c"),
	1274	this_address, 13, 10, address, 13, 10, my_tbuf, 13, 10));
	1275
	1276	(void) fflush(connFile);
	1277	fprintf(connFile,
	1278	_("From: <%s>%c%c"\
	1279	"To: <%s>%c%c"\
	1280	"Date: %s%c%c"),
	1281	this_address, 13, 10,
	1282	address, 13, 10,
	1283	my_tbuf, 13, 10);
	1284
[131]	1285	*ma_socket = fd;
[1]	1286	SL_RETURN( connFile, _("sh_mail_start_conn"));
	1287	}
	1288
	1289	/*************************
	1290	*
	1291	* end connection
	1292	*
	1293	*/
	1294
[131]	1295	static int sh_mail_end_conn (FILE * connFile, int fd)
[1]	1296	{
	1297	SL_ENTER(_("sh_mail_end_conn"));
	1298
	1299	time_wait = 300;
	1300
	1301	(void) fflush(connFile);
	1302	fprintf(connFile, _("%c%c.%c%c"), 13, 10, 13, 10);
	1303	(void) fflush(connFile);
	1304
	1305	TPT(( 0, FIL__, __LINE__, _("msg=<message end written>\n")));
	1306
[131]	1307	if (0 != sh_mail_wait(250, fd))
[1]	1308	{
	1309	(void) fflush(connFile);
	1310	fprintf(connFile, _("QUIT%c%c"), 13, 10);
	1311	(void) fflush(connFile);
	1312	TPT(( 0, FIL__, __LINE__, _("msg=<exit>\n")));
	1313
	1314	SL_RETURN (0, _("sh_mail_end_conn"));
	1315	}
	1316
	1317	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_NET,
	1318	_("QUIT failed"), _("sh_mail_end_conn"),
	1319	_("mail"), _("SMTP server"));
	1320
	1321	TPT(( 0, FIL__, __LINE__, _("msg=<abnormal exit>\n")));
	1322
	1323	SL_RETURN ((-1), _("sh_mail_end_conn"));
	1324	}
	1325
	1326
	1327
	1328	/****************************
	1329	*
	1330	* Handle server replies
	1331	*
	1332	*
	1333	*/
	1334
[131]	1335	static int sh_mail_wait(int code, int ma_socket)
[1]	1336	{
[131]	1337	int rcode, g;
[1]	1338
[131]	1339	char c;
[1]	1340
	1341	char errmsg[128];
	1342
	1343	enum {
	1344	WAIT_CODE_START,
	1345	WAIT_CODE,
	1346	WAIT_NL,
	1347	WAIT_NL_CONT
	1348	} state;
	1349
	1350	time_t waited_time;
	1351
	1352	SL_ENTER(_("mail_wait"));
	1353
	1354	waited_time = time(NULL);
	1355
	1356	/* timeout after 5 minutes
	1357	*/
	1358
	1359	rcode = 0;
	1360	state = WAIT_CODE_START;
	1361
[131]	1362	while (sl_read_timeout_fd (ma_socket, &c, 1, time_wait, SL_FALSE) > 0) {
[1]	1363
[131]	1364	g = (int) c;
	1365
[137]	1366	/*
	1367	if (g == EOF)
[1]	1368	{
	1369	TPT((0, FIL__, __LINE__, _("msg=<mail_wait: EOF>\n")));
	1370	SL_RETURN( 0, _("mail_wait"));
	1371	}
[137]	1372	*/
[1]	1373
	1374	switch(state) {
	1375
	1376	/* wait for start of a numerical code
	1377	*/
	1378	case WAIT_CODE_START:
	1379	if (0 != isspace(g))
	1380	break; /* Skip white space */
	1381	if (0 == isdigit(g))
	1382	return 0; /* No leading number */
	1383	rcode = g-(int)'0'; /* convert to number */
	1384	state = WAIT_CODE;
	1385	break;
	1386
	1387	/* wait for completion of numerical code
	1388	*/
	1389	case WAIT_CODE:
	1390	if (0 != isdigit(g)) {
	1391	rcode = rcode * 10 + (g-(int)'0'); /* next digit */
	1392	break;
	1393	}
	1394	/@+charintliteral@/
	1395	state = ((g == '-') ? WAIT_NL_CONT : WAIT_NL);
	1396	/@-charintliteral@/
	1397	break;
	1398
	1399	/* wait for newline, then return with status code
	1400	*/
	1401	case WAIT_NL:
	1402	/@+charintliteral@/
	1403	if (g != '\n')
	1404	break;
	1405	/@-charintliteral@/
	1406
	1407	TPT((0, FIL__, __LINE__,
	1408	_("msg=<mail_wait: OK got %d (%d) need %d (%d)>\n"),
	1409	rcode, (int)(rcode/100), code, (int)(code/100) ));
	1410	g = ((int)(rcode/100) == (int)(code/100)) ? 1 : 0;
	1411	if (g != 1)
	1412	{
[22]	1413	sl_snprintf(errmsg, sizeof(errmsg),
	1414	_("Bad response (%d), expected %d"), rcode, code);
	1415
[1]	1416	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_NET,
	1417	errmsg, _("sh_mail_wait"),
	1418	_("mail"), _("SMTP server"));
	1419	}
	1420	waited_time = time(NULL) - waited_time;
	1421	time_wait -= waited_time;
	1422	TPT((0, FIL__, __LINE__,
	1423	_("msg=<mail_wait: time_wait reduced to %d sec>\n"),
	1424	(int) time_wait));
	1425	SL_RETURN( (g), _("mail_wait")) ;
	1426
	1427	/* wait for continuation line
	1428	*/
	1429	/@fallthrough@//* no, but splint doesn't understand */
	1430	case WAIT_NL_CONT:
	1431	/@+charintliteral@/
	1432	if (g == '\n')
	1433	state = WAIT_CODE_START; /* There is a continuation line */
	1434	/@-charintliteral@/
	1435	break;
	1436
	1437	default:
	1438
	1439	TPT((0, FIL__, __LINE__, _("msg=<mail_wait: bad>\n")));
	1440	SL_RETURN( 0, _("mail_wait"));
	1441
	1442	}
	1443	}
	1444
	1445	TPT((0, FIL__, __LINE__, _("msg=<mail_wait: failed>\n")));
	1446
	1447	/* Failed, EOF or error on socket */
	1448	SL_RETURN( 0, _("mail_wait"));
	1449	}
	1450
	1451	/* -- function to insert "\r\n" after each 998 chars --
	1452	*/
	1453
	1454	#define SPLIT_AT 998
	1455
[214]	1456	static char * split_string(const char * str)
[1]	1457	{
	1458	size_t size;
	1459	size_t blocks;
	1460	int count = 0;
	1461
	1462	char * p, * p0;
[214]	1463	const char * q;
[1]	1464
	1465	if (!str)
	1466	return NULL;
	1467
[34]	1468	size = strlen(str) + 1;
[1]	1469	blocks = 1 + (size / SPLIT_AT);
	1470
[34]	1471	if (sl_ok_muls(2, blocks) && sl_ok_adds(size, (2*blocks)))
	1472	{
	1473	size = size + (2*blocks);
	1474	}
	1475	else
	1476	{
	1477	/* integer overflow, do not split */
	1478	p = sh_util_strdup(str);
	1479	return p;
	1480	}
	1481
[1]	1482	p = SH_ALLOC(size);
	1483	memset(p, 0, size);
[34]	1484
[1]	1485	p0 = p;
	1486
	1487	q = str;
	1488	while (*q != '\0') {
	1489	p = q;
	1490	++p;
	1491	++q;
	1492	++count;
	1493	if (0 == (count % SPLIT_AT)) {
	1494	count = 0;
	1495	*p = '\r';
	1496	++p;
	1497	*p = '\n';
	1498	++p;
	1499	}
	1500	}
	1501	/* fprintf(stderr, "used = %d\n", strlen(p0)); */
	1502
	1503	return p0;
	1504	}
	1505
	1506
	1507
	1508	/*****************************************************************
	1509	*
	1510	* MX Resolver Routines
	1511	*
	1512	*****************************************************************/
	1513
	1514	#if defined(HAVE_ARPA_NAMESER_H)
	1515
	1516	#include <netinet/in.h>
	1517	#ifdef __APPLE__
	1518	#define BIND_8_COMPAT 1
	1519	#endif
	1520	#ifndef S_SPLINT_S
	1521	#include <arpa/nameser.h>
	1522	#include <resolv.h>
	1523	#endif
	1524	#include <netdb.h>
	1525	#include <sys/socket.h>
	1526	#ifndef S_SPLINT_S
	1527	#include <arpa/inet.h>
	1528	#endif
	1529
	1530	#include "sh_tools.h"
	1531
	1532	#ifndef HFIXEDSZ
	1533	#define HFIXEDSZ 12
	1534	#endif
	1535	#ifndef QFIXEDSZ
	1536	#define QFIXEDSZ 4
	1537	#endif
	1538
	1539	/@unused@//* used in get_mx() which is not parsed by splint */
	1540	static unsigned int get_short (unsigned char * loc)
	1541	{
	1542	unsigned int retval = 0;
	1543	if (loc)
	1544	{
	1545	/* byte order: MSB first
	1546	*/
	1547	/@+charint@/
	1548	retval = (((unsigned char) * loc) * 256) \| ((unsigned char) * (loc + 1));
	1549	/@-charint@/
	1550	}
	1551	return (retval);
	1552	}
	1553
	1554	/* parser errors with splint */
	1555	#ifndef S_SPLINT_S
	1556	static dnsrep * get_mx (char *hostname)
	1557	{
	1558	int ret, length, status;
	1559	mx * result;
[22]	1560	size_t len;
[1]	1561
	1562	typedef union
	1563	{
	1564	HEADER head;
	1565	unsigned char buffer[4096];
	1566	} querybuf;
	1567
[171]	1568	querybuf * reply;
[1]	1569	char expanded[1024];
	1570	unsigned char * comp_dn, * eom;
	1571	HEADER * header;
[34]	1572	int type, rdlength, pref;
[170]	1573	unsigned int count, theindex;
[1]	1574	dnsrep * retval;
	1575
	1576	SL_ENTER(_("get_mx"));
	1577
	1578	if (0 != res_init ())
	1579	SL_RETURN (NULL, _("get_mx"));
	1580
[171]	1581	reply = SH_ALLOC(sizeof(querybuf));
	1582
[1]	1583	errno = 0;
	1584	length = res_query (hostname, C_IN, T_MX,
[171]	1585	(unsigned char *) reply, 4095);
[240]	1586
[1]	1587	if (length < 1)
	1588	{
[132]	1589	char errbuf[SH_ERRBUF_SIZE];
	1590
[1]	1591	/* error handling
	1592	*/
	1593	if (length == -1)
	1594	{
	1595	if (errno == ECONNREFUSED)
	1596	status = ECONNREFUSED;
	1597	else
	1598	status = h_errno;
	1599
	1600	#ifdef FIL__
	1601	sh_error_handle (SH_ERR_ALL, FIL__, __LINE__, status, MSG_E_SUBGEN,
	1602	(errno == ECONNREFUSED) ?
[132]	1603	sh_error_message (status, errbuf, sizeof(errbuf)) :
	1604	sh_tools_errmessage(status, errbuf, sizeof(errbuf)),
[1]	1605	_("res_query"));
	1606	#else
	1607	if (errno == ECONNREFUSED)
[132]	1608	fprintf(stderr, " ERROR: %s: \n", strerror(errno)); /* TESTONLY */
[1]	1609	else
[132]	1610	fprintf(stderr, "HERROR: %s\n", hstrerror(h_errno));/* TESTONLY */
[1]	1611	#endif
	1612	}
[171]	1613	SH_FREE(reply);
[1]	1614	SL_RETURN (NULL, _("get_mx"));
	1615	}
	1616
	1617	ret = 0;
[171]	1618	header = (HEADER *) reply;
[1]	1619
	1620	/* start of data section
	1621	*/
[171]	1622	comp_dn = (unsigned char *) reply + HFIXEDSZ;
[1]	1623
	1624	/* end-of-message
	1625	*/
[171]	1626	eom = (unsigned char *) reply + length;
[1]	1627
	1628	/* HEADER NAME -- must be skipped or decompressed
	1629	* TYPE -- type of data we got back, 16 bit integer
	1630	* CLASS -- class we got back, also a 16 bit integer
	1631	* TTL -- 32 bit time-to-live. just skip this
	1632	* RDLENGTH -- length of the data to follow
	1633	* RDATA -- the data:
	1634	* PREF -- 16 bit preference
	1635	* MX -- name of mail exchanger, must be decompressed
	1636	*/
	1637
	1638	/* Skip the query data.
	1639	* QDCOUNT is the number of entries (unsigned 16 bit int).
	1640	*/
	1641	count = ntohs (header->qdcount);
[170]	1642	for (theindex = 0; theindex < count; ++theindex)
[1]	1643	{
	1644	ret = dn_skipname (comp_dn, eom);
	1645	comp_dn += ret + QFIXEDSZ;
	1646	if (ret < 1 \|\| comp_dn >= eom)
[171]	1647	{
	1648	SH_FREE(reply);
	1649	SL_RETURN (NULL, _("get_mx"));
	1650	}
[1]	1651	}
[240]	1652
[1]	1653	count = ntohs (header->ancount);
	1654	if (count < 1)
[171]	1655	{
	1656	SH_FREE(reply);
	1657	SL_RETURN (NULL, _("get_mx"));
	1658	}
[1]	1659
	1660	retval = SH_ALLOC (sizeof (dnsrep));
	1661	if (!retval)
[171]	1662	{
	1663	SH_FREE(reply);
	1664	SL_RETURN (NULL, _("get_mx"));
	1665	}
	1666
[1]	1667	retval->count = count;
	1668
	1669	/* allocate space for the results */
	1670
[34]	1671	if (!sl_ok_muls(count, sizeof (mx)))
	1672	{
[171]	1673	SH_FREE(reply);
[34]	1674	SH_FREE (retval);
	1675	SL_RETURN (NULL, _("get_mx"));
	1676	}
	1677
[1]	1678	result = SH_ALLOC (count * sizeof (mx));
[34]	1679
[1]	1680	if (!result)
	1681	{
[171]	1682	SH_FREE(reply);
[1]	1683	SH_FREE (retval);
	1684	SL_RETURN (NULL, _("get_mx"));
	1685	}
	1686	retval->reply = result;
	1687
	1688	do
	1689	{
	1690	/* HEADER NAME
	1691	*/
[240]	1692	ret = dn_expand ((unsigned char *) reply, eom, comp_dn,
[1]	1693	(char *) expanded, 1023);
	1694	comp_dn += ret;
	1695	if (ret < 1 \|\| comp_dn >= eom)
	1696	{
[171]	1697	SH_FREE(reply);
[1]	1698	SH_FREE (result);
	1699	SH_FREE (retval);
	1700	SL_RETURN (NULL, _("get_mx"));
	1701	}
	1702
	1703	/* TYPE
	1704	*/
	1705	type = get_short (comp_dn);
	1706	comp_dn += 2;
	1707	if (type != T_MX \|\| comp_dn >= eom)
	1708	{
[171]	1709	SH_FREE(reply);
[1]	1710	SH_FREE (result);
	1711	SH_FREE (retval);
	1712	SL_RETURN (NULL, _("get_mx"));
	1713	}
	1714
[240]	1715
[1]	1716	/* CLASS (re-use 'type' var)
	1717	*/
	1718	type = get_short (comp_dn);
	1719	comp_dn += 2;
	1720	if (comp_dn >= eom)
	1721	{
[171]	1722	SH_FREE(reply);
[1]	1723	SH_FREE (result);
	1724	SH_FREE (retval);
	1725	SL_RETURN (NULL, _("get_mx"));
	1726	}
	1727
[240]	1728
[1]	1729	/* TTL
	1730	*/
	1731	comp_dn += 4;
	1732	if (comp_dn >= eom)
	1733	{
[171]	1734	SH_FREE(reply);
[1]	1735	SH_FREE (result);
	1736	SH_FREE (retval);
	1737	SL_RETURN (NULL, _("get_mx"));
	1738	}
	1739
	1740	/* RDLENGTH
	1741	*/
	1742	rdlength = get_short (comp_dn);
	1743	comp_dn += 2;
	1744	if (rdlength < 1 \|\| comp_dn >= eom)
	1745	{
[171]	1746	SH_FREE(reply);
[1]	1747	SH_FREE (result);
	1748	SH_FREE (retval);
	1749	SL_RETURN (NULL, _("get_mx"));
	1750	}
	1751
	1752	/* RDATA
	1753	*/
	1754	pref = get_short (comp_dn);
	1755	comp_dn += 2;
	1756	if (comp_dn >= eom)
	1757	{
[171]	1758	SH_FREE(reply);
[1]	1759	SH_FREE (result);
	1760	SH_FREE (retval);
	1761	SL_RETURN (NULL, _("get_mx"));
	1762	}
	1763
[240]	1764	ret = dn_expand ((unsigned char *) reply, eom, comp_dn,
[1]	1765	(char *) expanded, 1023);
	1766	comp_dn += ret;
	1767	if (ret < 1)
	1768	{
[171]	1769	SH_FREE(reply);
[1]	1770	SH_FREE (result);
	1771	SH_FREE (retval);
	1772	SL_RETURN (NULL, _("get_mx"));
	1773	}
	1774	count--;
	1775
	1776	/* fill in the struct
	1777	*/
	1778	result[count].pref = pref;
[22]	1779	len = strlen (expanded) + 1;
	1780	result[count].address = SH_ALLOC (len);
	1781	sl_strlcpy (result[count].address, expanded, len);
[1]	1782	}
	1783	while (ret > 0 && comp_dn < eom && count);
	1784
[171]	1785	SH_FREE(reply);
[1]	1786	SL_RETURN (retval, _("get_mx"));
	1787	}
	1788	/* ifndef S_SPLINT_S */
	1789	#endif
	1790
	1791	/* #if defined(HAVE_ARPA_NAMESER_H) */
	1792	#endif
	1793
	1794
	1795	static int comp_mx_pref (const void * a, const void * b)
	1796	{
	1797	const mx * ax = (const mx *) a;
	1798	const mx * bx = (const mx *) b;
	1799
	1800	if (ax->pref > bx->pref)
	1801	return 1;
	1802	else if (ax->pref < bx->pref)
	1803	return -1;
	1804	else
	1805	return 0;
	1806	}
	1807
	1808	/*
	1809	* return_mx returns a list of valid mail exchangers for domain
	1810	*/
	1811	static dnsrep * return_mx (char *domain)
	1812	{
[170]	1813	struct hostent *host;
[1]	1814	dnsrep * answers = NULL;
	1815	mx * result;
[170]	1816	dnsrep * retval;
[22]	1817	char errmsg[128];
	1818	size_t len;
[1]	1819
	1820	SL_ENTER(_("return_mx"));
	1821
	1822	#if defined(HAVE_ARPA_NAMESER_H)
	1823	if (domain != NULL)
	1824	answers = /@-unrecog@/get_mx (domain)/@+unrecog@/;
	1825	#endif
	1826
	1827	if (answers != NULL && answers->count > 0)
	1828	{
	1829	qsort(answers->reply, (size_t) answers->count, sizeof(mx),
	1830	comp_mx_pref);
	1831	SL_RETURN (answers, _("return_mx"));
	1832	}
	1833	else
	1834	{
	1835	if (domain != NULL)
	1836	{
	1837	#if defined(HAVE_ARPA_NAMESER_H)
	1838	#ifdef FIL__
	1839	(void) sl_strlcpy (errmsg, _("No MX record for domain "), 127);
	1840	(void) sl_strlcat (errmsg, domain, 127);
	1841	sh_error_handle (SH_ERR_ALL, FIL__, __LINE__, 0, MSG_E_SUBGEN,
	1842	errmsg,
	1843	_("get_mx"));
	1844	#else
[22]	1845	/* flawfinder: ignore // test code only */
[1]	1846	strcpy (errmsg, /* known to fit */
	1847	_("No MX record for domain "));
	1848	strncat (errmsg, domain, 100);
	1849	errmsg[122] = '\0';
	1850	fprintf(stderr, "Warning: %s\n", errmsg);
	1851	#endif
	1852	#endif
	1853	}
[134]	1854
	1855	SH_MUTEX_LOCK(mutex_resolv);
[170]	1856
	1857	host = NULL;
	1858	retval = NULL;
	1859
[1]	1860	if (domain != NULL)
	1861	host = /@-unrecog@/sh_gethostbyname (domain)/@+unrecog@/;
[134]	1862
	1863	if (host)
	1864	{
	1865	result = SH_ALLOC (sizeof (mx));
	1866	retval = SH_ALLOC (sizeof (dnsrep));
	1867	retval->reply = result;
	1868	retval->count = 1;
	1869	result->pref = 0;
	1870	/@-type@/
	1871	len = strlen (host->h_name) + 1;
	1872	result->address = SH_ALLOC (len);
	1873	sl_strlcpy (result->address, host->h_name, len);
	1874	/@+type@/
	1875	}
	1876	SH_MUTEX_UNLOCK(mutex_resolv);
	1877
[1]	1878	if (!host)
	1879	{
	1880	#ifdef FIL__
	1881	(void) sl_strlcpy (errmsg, _("Unknown host "), 127);
	1882	(void) sl_strlcat (errmsg, domain, 127);
	1883	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
	1884	errmsg,
	1885	_("return_mx"));
	1886	#endif
	1887	SL_RETURN (NULL, _("return_mx"));
	1888	}
[134]	1889
[1]	1890	SL_RETURN (retval, _("return_mx"));
	1891	}
	1892	}
	1893
[214]	1894	int free_mx (dnsrep * answers)
[1]	1895	{
	1896	mx * result;
	1897	int i;
	1898
	1899	SL_ENTER(_("free_mx"));
	1900	if (!answers)
	1901	SL_RETURN (0, _("return_mx"));
	1902
	1903	result = answers->reply;
	1904	for (i = 0; i < answers->count; ++i)
	1905	{
	1906	SH_FREE (result[i].address);
	1907	}
	1908	SH_FREE(result);
	1909	SH_FREE(answers);
	1910	SL_RETURN (0, _("return_mx"));
	1911	}
	1912
	1913	#ifdef TEST_ONLY
	1914	int main(int argc, char * argv[])
	1915	{
	1916	int i;
	1917	dnsrep * answers;
	1918	mx * result;
	1919
	1920	if (argc < 2)
	1921	{
	1922	fprintf(stderr, "Usage: dns <hostname>\n");
	1923	return -1;
	1924	}
	1925	answers = return_mx(argv[1]);
	1926
	1927	if (!answers)
	1928	{
	1929	fprintf(stderr, "No answer\n");
	1930	return -1;
	1931	}
	1932
	1933	if (answers->count > 0)
	1934	{
	1935	result = answers->reply;
	1936	for (i = 0; i < answers->count; ++i)
	1937	{
	1938	fprintf(stderr, "Record %3d: [%3d] %s\n", i,
	1939	result[i].pref, result[i].address);
	1940	}
	1941	}
	1942	else
	1943	{
	1944	fprintf(stderr, "No answer\n");
	1945	free_mx(answers);
	1946	return -1;
	1947	}
	1948	free_mx(answers);
	1949	return (0);
	1950	}
	1951	#endif
	1952
	1953
	1954
	1955	/* if defined(SH_WITH_MAIL) */
	1956	#endif
	1957
	1958
	1959

Note: See TracBrowser for help on using the repository browser.

Download in other formats: