Context Navigation

source: trunk/src/sh_forward.c@ 479

Last change on this file since 479 was 407, checked in by katerina, 12 years ago
Fix for tickets #309, #310.
File size: 150.3 KB

Line
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 <string.h>
23	#include <stdio.h>
24	#include <stdlib.h>
25
26
27	/* Must be early on FreeBSD
28	*/
29	#include <sys/types.h>
30
31	/* must be .le. than (1020 * 64)
32	* (see sh_tools.c -- put_header)
33	*
34	* also: must be (N * 16), otherwise
35	* binary files cannot be transferred encrypted
36	*
37	* 65280 = (1020*64)
38	* #define TRANS_BYTES 8000 V0.8
39	*/
40	#ifdef SH_ENCRYPT_2
41	#define TRANS_BYTES 65120
42	#else
43	#define TRANS_BYTES 65280
44	#endif
45
46	/* timeout for session key
47	*/
48	#define TIMEOUT_KEY 7200
49
50	/* max time between connection attempts
51	*/
52	#define TIMEOUT_CON 2048
53
54	/* #undef SRP_DEBUG */
55	/* #define SRP_DEBUG */
56
57	#ifdef HAVE_MEMORY_H
58	#include <memory.h>
59	#endif
60
61	#if TIME_WITH_SYS_TIME
62	#include <sys/time.h>
63	#include <time.h>
64	#else
65	#if HAVE_SYS_TIME_H
66	#include <sys/time.h>
67	#else
68	#include <time.h>
69	#endif
70	#endif
71
72	/*
73	#ifdef TM_IN_SYS_TIME
74	#include <sys/time.h>
75	#else
76	#include <time.h>
77	#endif
78	*/
79
80	#ifdef HAVE_SYS_SELECT_H
81	#include <sys/select.h>
82	#endif
83
84	#ifdef HAVE_UNISTD_H
85	#include <errno.h>
86	#include <signal.h>
87	#include <setjmp.h>
88	#include <pwd.h>
89	#include <grp.h>
90	#include <sys/stat.h>
91	#include <sys/resource.h>
92	#include <fcntl.h>
93	#include <sys/wait.h>
94	#include <unistd.h>
95	#endif
96
97	#ifndef FD_SET
98	#define NFDBITS 32
99	#define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] \|= (1 << ((n) % NFDBITS)))
100	#define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
101	#define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
102	#endif /* !FD_SET */
103	#ifndef FD_SETSIZE
104	#define FD_SETSIZE 32
105	#endif
106	#ifndef FD_ZERO
107	#define FD_ZERO(p) memset((char )(p), '\0', sizeof((p)))
108	#endif
109
110	#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
111	#include <sys/mman.h>
112	#endif
113
114
115	#include <netdb.h>
116	#include <sys/types.h>
117	#include <netinet/in.h>
118	#include <sys/socket.h>
119	#ifndef S_SPLINT_S
120	#include <arpa/inet.h>
121	#endif
122
123	#include "sh_ipvx.h"
124	#include "samhain.h"
125	#include "sh_tiger.h"
126	#include "sh_utils.h"
127	#include "sh_unix.h"
128	#include "sh_forward.h"
129	#include "sh_srp.h"
130	#include "sh_fifo.h"
131	#include "sh_tools.h"
132	#include "sh_entropy.h"
133	#include "sh_html.h"
134	#include "sh_nmail.h"
135	#include "sh_socket.h"
136	#define SH_NEED_GETHOSTBYXXX
137	#include "sh_static.h"
138
139	#ifdef SH_ENCRYPT
140	#include "rijndael-api-fst.h"
141	char * sh_tools_makePack (unsigned char * header,
142	char * payload, unsigned long payload_size,
143	keyInstance * keyInstE);
144	char * sh_tools_revertPack (unsigned char * header, char * message,
145	keyInstance * keyInstE,
146	unsigned long message_size);
147	#endif
148
149	/* define this if you want to debug the client/server communication */
150	/* #define SH_DBG_PROT 1 */
151
152	#ifdef SH_DBG_PROT
153	#define SH_SHOWPROT(c,d) sh_tools_show_header((c), (d))
154	#else
155	#define SH_SHOWPROT(c,d)
156	#endif
157
158	/* the port client will be connecting to
159	*/
160	#ifndef SH_DEFAULT_PORT
161	#define SH_DEFAULT_PORT 49777
162	#endif
163
164	#ifndef SH_SELECT_REPEAT
165	#define SH_SELECT_REPEAT 60
166	#endif
167
168	#ifndef SH_HEADER_SIZE
169	#define SH_HEADER_SIZE 7
170	#endif
171
172	#ifndef SH_CHALLENGE_SIZE
173	#define SH_CHALLENGE_SIZE 9
174	#endif
175
176	#undef FIL__
177	#define FIL__ _("sh_forward.c")
178
179	int clt_class = (-1);
180
181	extern int flag_err_debug;
182	extern int flag_err_info;
183
184	#ifndef SH_STANDALONE
185
186	#if defined(WITH_TRACE) \|\| defined(WITH_TPT)
187	char * hu_trans(const char * ihu)
188	{
189	static char ohu[17];
190	sprintf(ohu, _("%c%03o"), '\\', /* known to fit */
191	(unsigned char) ihu[0]);
192	sprintf(&(ohu[4]), _("%c%03o"), '\\', /* known to fit */
193	(unsigned char) ihu[1]);
194	sprintf(&(ohu[8]), _("%c%03o"), '\\', /* known to fit */
195	(unsigned char) ihu[2]);
196	sprintf(&(ohu[12]), _("%c%03o"), '\\', /* known to fit */
197	(unsigned char) ihu[3]);
198	ohu[16] = '\0';
199	return ohu;
200	}
201	#endif
202
203	static int StripDomain = S_TRUE;
204
205	int sh_forward_set_strip (const char * str)
206	{
207	static int fromcl = 0;
208	char dummy[2] = "F";
209
210	if (fromcl == 1)
211	return 0;
212
213	if (str == NULL)
214	{
215	fromcl = 1;
216	return (sh_util_flagval(dummy, &StripDomain));
217	}
218	else
219	return (sh_util_flagval(str, &StripDomain));
220	}
221
222	#include <ctype.h>
223
224	const char * sh_strip_domain (char *name)
225	{
226	char * first;
227	static char name_2[SH_MINIBUF+1];
228	register int i = 0;
229
230	SL_ENTER(_("sh_strip_domain"));
231
232	if (StripDomain == S_FALSE \|\| (first = strchr(name, '.')) == NULL)
233	{
234	SL_RETURN( name, _("sh_strip_domain"));
235	}
236	else
237	{
238
239	/* check whether it is in dotted number format
240	* --> last part must be kept
241	*/
242	if (0 != sh_ipvx_is_numeric(name))
243	{
244	SL_RETURN( name, _("sh_strip_domain"));
245	/*
246	i = sl_strlen(name) - 1;
247	while (name[i] != '.' && i >= 0)
248	--i;
249	if (name[i] == '.') ++i;
250	sl_strlcpy( name_2, &name[i], SH_MINIBUF +1 );
251	*/
252	}
253	else
254	{
255	first = name;
256	while (i < SH_MINIBUF && first != '.' && first != '\0')
257	{
258	name_2[i] = *first;
259	++first; ++i;
260	}
261	name_2[i] = '\0';
262	}
263	}
264
265	SL_RETURN( name_2, _("sh_strip_domain"));
266	}
267
268	/* #ifndef SH_STANDALONE */
269	#endif
270
271	#ifndef USE_SRP_PROTOCOL
272	static
273	void sh_passwd (char * salt, char * password, char * nounce, char *hash)
274	{
275
276	char *combi;
277	size_t len;
278	register int i;
279	unsigned char * dez = NULL;
280	char hashbuf[KEYBUF_SIZE];
281
282	if (password == NULL)
283	dez = (unsigned char *) &(skey->pw[0]);
284	else if (sl_strlen(password) < PW_LEN)
285	{
286	fprintf(stderr, _("Password has less than %d chars !\n"),
287	PW_LEN);
288	_exit(EXIT_FAILURE);
289	}
290
291	if (password == NULL)
292	{
293	/* --- copy password ---
294	*/
295	for (i = 0; i < PW_LEN; ++i)
296	{
297	skey->vernam[i] = (char)(*dez);
298	++dez;
299	}
300	(void) sl_strlcpy (skey->vernam,
301	sh_tiger_hash(skey->vernam, TIGER_DATA, PW_LEN,
302	hashbuf, sizeof(hashbuf)),
303	KEY_LEN+1);
304	}
305	else
306	{
307	(void) sl_strlcpy (skey->vernam, password, KEY_LEN+1);
308	}
309
310	len = sl_strlen(salt) + 1;
311	if (sl_ok_adds(len, sl_strlen(skey->vernam)))
312	len += sl_strlen(skey->vernam);
313	if (nounce != NULL && sl_ok_adds(len, sl_strlen(nounce)))
314	len += sl_strlen(nounce);
315
316	/* H(s,P)
317	*/
318	combi = SH_ALLOC(len);
319	(void) sl_strlcpy (combi, salt, len);
320	(void) sl_strlcat (combi, skey->vernam, len);
321	if (nounce != NULL)
322	(void) sl_strlcat (combi, nounce, len);
323	(void) sl_strlcpy (hash,
324	sh_tiger_hash(combi, TIGER_DATA,
325	(unsigned long) sl_strlen(combi),
326	hashbuf, sizeof(hashbuf)),
327	KEY_LEN+1);
328
329	/*
330	fprintf(stderr, "DD: A: <%s>\n", salt);
331	fprintf(stderr, "DD: P: <%s>\n", skey->pw);
332	fprintf(stderr, "DD: V: <%s>\n", skey->vernam);
333	fprintf(stderr, "DD: C: <%s>\n", combi);
334	fprintf(stderr, "DD: H: <%s>\n", hash);
335	*/
336
337	SH_FREE (combi);
338	hash[KEY_LEN] = '\0';
339	return;
340	}
341	#endif
342
343	#if defined(SH_WITH_CLIENT) \|\| defined(SH_WITH_SERVER)
344
345	static int count_dev_server = 0;
346
347	void reset_count_dev_server(void)
348	{
349	count_dev_server = 0;
350	return;
351	}
352
353	int sh_forward_setlogserver (const char * address)
354	{
355	SL_ENTER(_("sh_forward_setlogserver"));
356
357	if (address != NULL && count_dev_server < 2
358	&& sl_strlen(address) < SH_PATHBUF && sl_strlen(address) > 0)
359	{
360	if (count_dev_server == 0)
361	(void) sl_strlcpy (sh.srvexport.name, address, SH_PATHBUF);
362	else
363	(void) sl_strlcpy (sh.srvexport.alt, address, SH_PATHBUF);
364
365	++count_dev_server;
366	SL_RETURN (0, _("sh_forward_setlogserver"));
367	}
368	SL_RETURN (-1, _("sh_forward_setlogserver"));
369	}
370
371	static
372	int sh_forward_send_intern (int mysocket, char protocol, char * micro,
373	char * msgbuf, unsigned long length, int docrypt)
374	{
375	unsigned long numbytes, countbytes;
376	int flag_err = 0;
377	unsigned char head[SH_HEADER_SIZE];
378	char * outbuf;
379
380	#ifdef SH_ENCRYPT
381
382	unsigned long blkfac;
383	int rem;
384	unsigned long length2;
385	char * msg2buf = NULL;
386	char * p, * q;
387	RIJ_BYTE inBlock[B_SIZ];
388	RIJ_BYTE outBlock[B_SIZ];
389	unsigned long j;
390	cipherInstance cipherInst;
391	int err_num;
392	char expbuf[SH_ERRBUF_SIZE];
393	#else
394	docrypt = SL_FALSE; /* dummy to fix compiler warning */
395	#endif
396
397	SL_ENTER(_("sh_forward_send_intern"));
398
399	#ifdef SH_ENCRYPT
400	if ((S_TRUE == docrypt) && ((protocol & SH_PROTO_EN2) != (char)0))
401	{
402	put_header (head, (int)protocol, &length, micro);
403	msg2buf = sh_tools_makePack (head, msgbuf, length,
404	&(skey->keyInstE));
405	/@-usedef@/
406	length = (unsigned long) (256 * (unsigned int)head[1] +
407	(unsigned int)head[2]);
408	/@+usedef@/
409	outbuf = msg2buf;
410	}
411	else if ((S_TRUE == docrypt) && ((protocol & SH_PROTO_ENC) != (char)0))
412	{
413	blkfac = length/B_SIZ;
414	rem = (int) (length - (B_SIZ * blkfac));
415	length2 = (B_SIZ * blkfac);
416	if ((rem > 0) && (length2+B_SIZ) > length2)
417	length2 += B_SIZ;
418	else
419	rem = 0;
420
421	msg2buf = SH_ALLOC((size_t)length2);
422	p = msgbuf;
423	q = msg2buf;
424
425	err_num = cipherInit (&cipherInst, (RIJ_BYTE)MODE_CBC, NULL);
426
427	if (err_num < 0)
428	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
429	errorExplain(err_num, expbuf, sizeof(expbuf)),
430	_("sh_forward_send_intern: cipherInit"));
431
432
433	for (j = 0; j < blkfac; ++j)
434	{
435	memcpy(inBlock, p, B_SIZ);
436	err_num = blockEncrypt(&cipherInst, &(skey->keyInstE),
437	inBlock, 128 * BNUM, outBlock);
438	if (err_num < 0)
439	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
440	errorExplain(err_num, expbuf, sizeof(expbuf)),
441	_("sh_forward_send_intern: blockEncrypt"));
442	memcpy(q, outBlock, B_SIZ);
443	p += B_SIZ;
444	q += B_SIZ;
445	}
446	if (rem > 0)
447	{
448	memset(inBlock, 0, B_SIZ);
449	memcpy(inBlock, p, (size_t)rem);
450	err_num = blockEncrypt(&cipherInst, &(skey->keyInstE),
451	inBlock, 128 * BNUM, outBlock);
452	if (err_num < 0)
453	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
454	errorExplain(err_num, expbuf, sizeof(expbuf)),
455	_("sh_forward_send_intern: blockEncrypt"));
456	memcpy(q, outBlock, B_SIZ);
457	/* q += B_SIZ; // never read */
458	}
459
460	outbuf = msg2buf;
461	length = length2;
462	put_header (head, (int)protocol, &length, micro);
463	}
464	else
465	{
466	outbuf = msgbuf;
467	put_header (head, (int)protocol, &length, micro);
468	}
469	#else
470	outbuf = msgbuf;
471	put_header (head, (int)protocol, &length, micro);
472	#endif
473
474	SH_SHOWPROT(head,'>');
475
476	numbytes = SH_HEADER_SIZE;
477	countbytes = write_port (mysocket,
478	(char *) head, numbytes,
479	&flag_err, 300);
480
481	if (countbytes == numbytes && outbuf != NULL)
482	{
483	numbytes = (length);
484	countbytes = write_port (mysocket,
485	outbuf, numbytes,
486	&flag_err, 300);
487	}
488
489	#ifdef SH_ENCRYPT
490	/@-usedef@/
491	if (msg2buf != NULL)
492	SH_FREE(msg2buf);
493	/@+usedef@/
494	#endif
495
496	if (countbytes == numbytes)
497	{
498	SL_RETURN( 0, _("sh_forward_send_intern"));
499	}
500	else
501	{
502	SL_RETURN( flag_err, _("sh_forward_send_intern"));
503	}
504	}
505	static
506	int sh_forward_send (int mysocket, char protocol, char * micro,
507	char * msgbuf, unsigned long length)
508	{
509	int i;
510	SL_ENTER(_("sh_forward_send"));
511	TPT(( 0, FIL__, __LINE__, _("msg=<Send.>\n")));
512	i = sh_forward_send_intern (mysocket, protocol, micro,
513	msgbuf, length, S_FALSE);
514	SL_RETURN(i, _("sh_forward_send"));
515	}
516	static
517	int sh_forward_send_crypt (int mysocket, char protocol, char * micro,
518	char * msgbuf, unsigned long length)
519	{
520	int i;
521	SL_ENTER(_("sh_forward_send_crypt"));
522	#ifdef SH_ENCRYPT
523	TPT(( 0, FIL__, __LINE__, _("msg=<Send encrypted.>\n")));
524	#else
525	TPT(( 0, FIL__, __LINE__, _("msg=<Send.>\n")));
526	#endif
527	i = sh_forward_send_intern (mysocket, protocol, micro,
528	msgbuf, length, S_TRUE);
529	SL_RETURN(i, _("sh_forward_send_crypt"));
530	}
531
532
533	/* receive answer, add a trailing NULL to terminate string
534	* rev 0.8
535	*/
536	static
537	long sh_forward_receive_intern (int mysocket, char protocol, char * micro,
538	char * msgbuf, unsigned long length,
539	int docrypt)
540	{
541	unsigned long numbytes, countbytes;
542	int flag_err = -1;
543	unsigned char head[SH_HEADER_SIZE];
544
545	#ifdef SH_ENCRYPT
546
547	unsigned long head_length;
548	unsigned long blkfac;
549	/* unsigned long length2; */
550	char * p, * q, * tmp;
551	RIJ_BYTE inBlock[B_SIZ];
552	RIJ_BYTE outBlock[B_SIZ];
553	unsigned long j;
554	cipherInstance cipherInst;
555	int err_num;
556	char expbuf[SH_ERRBUF_SIZE];
557	#else
558	docrypt = SL_FALSE; /* dummy to fix compiler warning */
559	#endif
560
561	SL_ENTER(_("sh_forward_receive_intern"));
562
563	#ifdef SH_ENCRYPT
564	/* make sure length is not multiple of B_SIZ, see below
565	*/
566	ASSERT_RET((length % B_SIZ != 0), _("length % 16 != 0"), flag_err);
567	#endif
568
569	if (micro != NULL)
570	micro[4] = '\0';
571
572	if (msgbuf != NULL)
573	msgbuf[0] = '\0';
574
575	numbytes = SH_HEADER_SIZE;
576	countbytes = read_port (mysocket,
577	(char *) head, numbytes,
578	&flag_err, 300);
579
580	if (countbytes != numbytes)
581	{
582	TPT(( 0, FIL__, __LINE__, _("msg=<countbytes != numbytes>\n")));
583	SL_RETURN(flag_err, _("sh_forward_receive_intern"));
584	}
585	/@-usedef +ignoresigns@/
586	else if (msgbuf == NULL)
587	{
588	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
589	_("msgbuf is NULL"), _("sh_forward_receive_intern"));
590	SL_RETURN((-1), _("sh_forward_receive_intern"));
591	}
592	else if (head[0] != protocol &&
593	(head[0] & SH_PROTO_SRP) == (char)0 /* not set */)
594	{
595	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_MISMATCH);
596	SL_RETURN((-1), _("sh_forward_receive_intern"));
597	}
598	/@+usedef -ignoresigns@/
599	else
600	{
601	get_header (head, &numbytes, micro);
602	SH_SHOWPROT(head, '<');
603
604	if (numbytes > 0)
605	{
606	numbytes = (numbytes > length ? length : numbytes);
607
608	countbytes = read_port (mysocket,
609	msgbuf, numbytes,
610	&flag_err, 300);
611
612	if (countbytes < length)
613	msgbuf[countbytes] = '\0';
614	else
615	msgbuf[length-1] = '\0';
616
617	if (flag_err != 0)
618	{
619	TPT(( 0, FIL__, __LINE__, _("msg=<read error>\n")));
620	SL_RETURN((-1), _("sh_forward_receive_intern"));
621	}
622	}
623	}
624
625	#ifdef SH_ENCRYPT
626	if ((S_TRUE == docrypt) && ((protocol & SH_PROTO_EN2) != (char)0))
627	{
628	tmp = SH_ALLOC((size_t)length);
629	memcpy(tmp, msgbuf, (size_t)length);
630	tmp = sh_tools_revertPack (head, tmp, &(skey->keyInstD), countbytes);
631
632	head_length = (unsigned long) (256 * (unsigned int)head[1] +
633	(unsigned int)head[2]);
634
635	/*
636	* revertPack returns header with length <= (original_length-16), so
637	* the following msgbuf[length] = '\0' is always safe.
638	* Nevertheless, check for proper length.
639	*/
640	if (head_length <= (length-1))
641	length = head_length;
642	else
643	--length;
644
645	memcpy(msgbuf, tmp, (size_t)length);
646	msgbuf[length] = '\0';
647	SH_FREE(tmp);
648	if (countbytes == numbytes)
649	{
650	countbytes = length; /* to avoid error on return, see below */
651	}
652	numbytes = length;
653	}
654	else if ((S_TRUE == docrypt) && ((protocol & SH_PROTO_ENC) != (char)0))
655	{
656	/* Decrypt only complete blocks. If there is an incomplete block,
657	* something is wrong anyway.
658	* Decrypt in place.
659	*/
660	blkfac = countbytes/B_SIZ;
661
662	p = msgbuf;
663	q = msgbuf;
664
665	err_num = cipherInit (&cipherInst, (RIJ_BYTE)MODE_CBC, NULL);
666
667	if (err_num < 0)
668	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
669	errorExplain(err_num, expbuf, sizeof(expbuf)),
670	_("sh_forward_receive_intern: cipherInit"));
671
672	/* here we want to have (length % B_SIZ != 0), such that the
673	* terminating '\0' cannot be overwritten
674	*/
675	for (j = 0; j < blkfac; ++j)
676	{
677	memcpy(inBlock, p, B_SIZ);
678	err_num = blockDecrypt(&cipherInst, &(skey->keyInstD),
679	inBlock, 128 * BNUM, outBlock);
680	if (err_num < 0)
681	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
682	errorExplain(err_num, expbuf, sizeof(expbuf)),
683	_("sh_forward_receive_intern: blockDecrypt"));
684	memcpy(q, outBlock, B_SIZ);
685	p += B_SIZ;
686	q += B_SIZ;
687	}
688	}
689	#endif
690
691	if (countbytes == numbytes)
692	{
693	SL_RETURN(((long)numbytes), _("sh_forward_receive_intern"));
694	}
695	else
696	{
697	TPT(( 0, FIL__, __LINE__, _("msg=<short read>\n")));
698	SL_RETURN(flag_err, _("sh_forward_receive_intern"));
699	}
700	}
701
702	static
703	long sh_forward_receive (int mysocket, char protocol, char * micro,
704	char * msgbuf, unsigned long length)
705	{
706	long i;
707	SL_ENTER(_("sh_forward_receive"));
708	TPT(( 0, FIL__, __LINE__, _("msg=<Receive.>\n")));
709	i = sh_forward_receive_intern (mysocket, protocol, micro,
710	msgbuf, length, S_FALSE);
711	SL_RETURN(i, _("sh_forward_receive"));
712	}
713
714	static
715	long sh_forward_receive_crypt (int mysocket, char protocol, char * micro,
716	char * msgbuf, unsigned long length)
717	{
718	long i;
719	SL_ENTER(_("sh_forward_receive_crypt"));
720	#ifdef SH_ENCRYPT
721	TPT(( 0, FIL__, __LINE__, _("msg=<Receive encrypted.>\n")));
722	#else
723	TPT(( 0, FIL__, __LINE__, _("msg=<Receive.>\n")));
724	#endif
725	i = sh_forward_receive_intern (mysocket, protocol, micro,
726	msgbuf, length, S_TRUE);
727	SL_RETURN(i, _("sh_forward_receive"));
728	}
729
730	/**************************************************
731	*
732	*
733	* C L I E N T
734	*
735	*
736	***************************************************/
737
738
739	#include <time.h>
740
741	static SH_FIFO * fifo = NULL;
742
743	static long sh_forward_try (char * errmsg);
744
745	static unsigned int ServerPort = SH_DEFAULT_PORT;
746
747	int sh_forward_server_port (const char * str)
748	{
749	unsigned long l;
750	char * endptr;
751
752	SL_ENTER(_("sh_forward_server_port"));
753
754	l = strtoul (str, &endptr, 0);
755	if (l > 65535 \|\| endptr == str)
756	{
757	SL_RETURN (-1, _("sh_forward_server_port"));
758	}
759	ServerPort = (unsigned int) l;
760	SL_RETURN (0, _("sh_forward_server_port"));
761	}
762
763	long sh_forward (char * errmsg)
764	{
765	static int have_server = GOOD;
766	long status;
767	char * popmsg;
768	static int failed = GOOD;
769
770	SL_ENTER(_("sh_forward"));
771
772	/* --- No log server available. ---
773	*/
774	if (have_server == GOOD && sh.srvexport.name[0] == '\0')
775	{
776	have_server = BAD;
777	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_NONAME);
778	SL_RETURN (-1, _("sh_forward"));
779	}
780	else if (have_server == BAD)
781	{
782	SL_RETURN (-1, _("sh_forward"));
783	}
784
785	/* --- Allocate fifo. ---
786	*/
787	if (fifo == NULL)
788	{
789	fifo = SH_ALLOC(sizeof(SH_FIFO));
790	fifo_init(fifo);
791	}
792
793	/* --- Check for messages on the queue, and send them first. ---
794	*/
795	while (NULL != (popmsg = pop_list(fifo)) )
796	{
797	status = sh_forward_try (popmsg);
798	if (status != 0)
799	{
800	(void) push_tail_list (fifo, popmsg, 0, NULL);
801	SH_FREE(popmsg);
802	if (SH_FIFO_MAX == push_list (fifo, errmsg, 0,NULL))
803	{
804	SL_RETURN (-2, _("sh_forward"));
805	}
806	SL_RETURN (-1, _("sh_forward"));
807	}
808	SH_FREE(popmsg);
809	}
810
811	/* --- Now send the error message. ---
812	*/
813	status = sh_forward_try (errmsg);
814	if (status != 0)
815	{
816	if (failed == GOOD)
817	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_SRV_FAIL,
818	_("log server"),
819	sh.srvexport.name);
820	failed = BAD;
821	if (SH_FIFO_MAX == push_list (fifo, errmsg, 0, NULL))/* push on stack */
822	{
823	SL_RETURN (-2, _("sh_forward"));
824	}
825	SL_RETURN (-1, _("sh_forward"));
826	}
827
828	failed = GOOD;
829	SL_RETURN (0, _("sh_forward"));
830	}
831
832	static long sh_forward_try_impl (char * errmsg, char what);
833
834	static long sh_forward_try (char * errmsg)
835	{
836	long i;
837	SL_ENTER(_("sh_forward_try"));
838	i = sh_forward_try_impl (errmsg, (char)SH_PROTO_MSG);
839	SL_RETURN(i, _("sh_forward_try"));
840	}
841
842	long sh_forward_req_file (char * file)
843	{
844	long i;
845	char tmp_file[8];
846	SL_ENTER(_("sh_forward_req_file"));
847	(void) sl_strlcpy(tmp_file, file, 8);
848	i = sh_forward_try_impl (tmp_file, (char)SH_PROTO_BIG);
849	SL_RETURN(i, _("sh_forward_req_file"));
850	}
851
852	static unsigned long sh_throttle_delay = 0;
853
854	int sh_forward_set_throttle_delay (const char * c)
855	{
856	long val;
857
858	SL_ENTER(_("sh_forward_set_throttle_delay"));
859
860	val = strtol (c, (char **)NULL, 10);
861	if (val < 0)
862	SL_RETURN( (-1), _("sh_forward_set_throttle_delay"));
863
864	val = (val > 1000) ? 1000 : val;
865
866	sh_throttle_delay = (unsigned long) val;
867	SL_RETURN( (0), _("sh_forward_set_throttle_delay"));
868	}
869
870
871	static long sh_forward_try_impl (char * errmsg, char what)
872	{
873	static int initialized = BAD;
874	static int conn_state = GOOD;
875	int sockfd;
876	int flag_err;
877	char * answer;
878
879	unsigned char theProto;
880
881	char hash[KEY_LEN+1];
882	size_t len;
883	char * buffer;
884	#ifdef SH_ENCRYPT_2
885	size_t pos; /* for the server command */
886	#endif
887	char head_u[5];
888
889	char nsrv[KEY_LEN+1];
890	char nclt[KEY_LEN+1];
891	SL_TICKET sfd = -1;
892	int transfercount;
893
894	char foo_M1[KEY_LEN+1];
895	UINT32 ticks;
896
897	char error_msg[256];
898	char error_call[SH_MINIBUF];
899	int error_num = 0;
900
901	#ifdef USE_SRP_PROTOCOL
902	char u_real[SH_CHALLENGE_SIZE];
903	char * foo_A;
904	char * foo_Sc;
905	char * M;
906	#else
907	char nounce[KEY_LEN+1];
908	char temp[2*KEY_LEN+1];
909	char nonce_u[KEY_LEN+1];
910	#endif
911
912	#ifdef SH_ENCRYPT
913	int err_num;
914	char expbuf[SH_ERRBUF_SIZE];
915	#endif
916
917	static time_t time_now = 1200;
918	static time_t time_last = 0;
919
920	static time_t timeout_val = 1;
921	char hashbuf[KEYBUF_SIZE];
922	char sigbuf[KEYBUF_SIZE];
923
924	SL_ENTER(_("sh_forward_try_impl"));
925
926	/* --- No message to transmit. ---
927	*/
928	if (errmsg == NULL && initialized == GOOD)
929	SL_RETURN( 0, _("sh_forward_try_impl"));
930
931	/* --- Connection in bad state. ---
932	*/
933	if (initialized == BAD \|\| conn_state == BAD)
934	{
935	timeout_val =
936	(time_t)((timeout_val > TIMEOUT_CON) ? TIMEOUT_CON : timeout_val);
937
938	/* --- Retry bad attempt only after some time. ---
939	*/
940	time_now = time (NULL);
941	if ((time_now - time_last) < timeout_val)
942	{
943	TPT(( 0, FIL__, __LINE__, _("msg=<Within deadtime, no retry.>\n")));
944	SL_RETURN( (-1), _("sh_forward_try_impl"));
945	}
946	TPT(( 0, FIL__, __LINE__, _("msg=<Retry.>\n")));
947	}
948	time_last = time (NULL);
949
950
951	/* --- Try to connect to log server. ---
952	*/
953	error_call[0] = '\0';
954
955	sockfd = connect_port_2 (sh.srvexport.name, sh.srvexport.alt,
956	ServerPort,
957	error_call, &error_num, error_msg, 256);
958
959	if (sockfd < 0)
960	{
961	conn_state = BAD;
962	timeout_val *= 2;
963	sh_error_handle ((-1), FIL__, __LINE__, error_num,
964	MSG_E_NET, error_msg, error_call,
965	_("export"), sh.srvexport.name);
966	SL_RETURN( (-1), _("sh_forward_try_impl"));
967	}
968
969	conn_state = GOOD;
970
971	/*************************
972	*
973	* initialization
974	*
975	*/
976
977	flag_err = 0;
978	answer = SH_ALLOC(512);
979	MLOCK(answer, 512);
980
981
982	#ifndef USE_SRP_PROTOCOL
983
984	/**************************************************
985	*
986	* --- challenge/response authentication ---
987	*
988	**************************************************/
989
990	if (initialized == BAD)
991	{
992	theProto = (unsigned char) SH_PROTO_SRP;
993
994	TPT(( 0, FIL__, __LINE__, _("msg=<c/r: entry>\n")));
995
996	(void) sl_strlcpy (answer, sh.host.name, 512);
997
998	flag_err = sh_forward_send (sockfd, (char) theProto, _("SALT"),
999	answer, (unsigned long)sl_strlen(answer));
1000
1001	TPT(( 0, FIL__, __LINE__, _("msg=<c/r: sent SALT, flag_err = %d>\n"),
1002	flag_err));
1003
1004	/* get nonce from server
1005	*/
1006	if (flag_err == 0)
1007	{
1008	flag_err = (int) sh_forward_receive (sockfd, (char)theProto, head_u,
1009	answer, 511);
1010	flag_err = (flag_err < 0) ? flag_err : 0;
1011	TPT(( 0, FIL__, __LINE__,
1012	_("msg=<c/r: rcvt nonce, flag_err = %d>\n"),
1013	flag_err));
1014	}
1015
1016	/* entry point for jump from message forward if session key must
1017	* be re-initialized
1018	*/
1019	initBlock:
1020
1021	if (0 == check_request (head_u, _("INIT")) &&
1022	flag_err == 0 &&
1023	sl_strlen(answer) > KEY_LEN )
1024	(void) sl_strlcpy(nounce, &answer[KEY_LEN], KEY_LEN+1);
1025	else
1026	flag_err = (-1);
1027
1028	TPT(( 0, FIL__, __LINE__, _("msg=<c/r: rcvt INIT, flag_err = %d>\n"),
1029	flag_err));
1030
1031	/* verify random nonce v from server H(v, P)v
1032	*/
1033	sh_passwd (nounce, NULL, NULL, temp);
1034	if ( 0 != sl_strncmp(temp, answer, KEY_LEN))
1035	flag_err = (-1);
1036
1037	TPT(( 0, FIL__, __LINE__, _("msg=<c/r: vrfy nonce, flag_err = %d>\n"),
1038	flag_err));
1039
1040
1041	/* --- Create own nonce. ---
1042	*/
1043	ticks = (UINT32) taus_get ();
1044
1045	(void) sl_strlcpy(nonce_u,
1046	sh_tiger_hash((char *) &ticks,
1047	TIGER_DATA,
1048	(unsigned long)sizeof(UINT32),
1049	hashbuf, sizeof(hashbuf)),
1050	KEY_LEN+1);
1051
1052	/* --- Form the message H(H(u,v),P)u ---
1053	*/
1054	(void) sl_strlcpy(temp, nonce_u, 2*KEY_LEN+1);
1055	(void) sl_strlcat(temp, nounce, 2*KEY_LEN+1);
1056	(void) sl_strlcpy(temp,
1057	sh_tiger_hash(temp,
1058	TIGER_DATA,
1059	(unsigned long)sl_strlen(temp),
1060	hashbuf, sizeof(hashbuf)),
1061	KEY_LEN+1);
1062	sh_passwd (temp, NULL, NULL, foo_M1);
1063	(void) sl_strlcpy(temp, foo_M1, 2*KEY_LEN+1);
1064	(void) sl_strlcat(temp, nonce_u, 2*KEY_LEN+1);
1065
1066	/* --- Send it to server. ---
1067	*/
1068	if (flag_err == 0)
1069	{
1070	flag_err = (int) sh_forward_send (sockfd,
1071	(char)(theProto\|SH_PROTO_SRP),
1072	_("PASS"), temp,
1073	(unsigned long)sl_strlen(temp));
1074	TPT(( 0, FIL__, __LINE__, _("msg=<c/r: sent PASS, flag_err = %d>\n"),
1075	flag_err));
1076	}
1077
1078	if (flag_err == 0)
1079	{
1080	flag_err = (int)sh_forward_receive (sockfd,
1081	(char)(theProto\|SH_PROTO_SRP),
1082	head_u, answer, 511);
1083	sh_passwd (nounce, NULL, nonce_u, foo_M1);
1084	(void) sl_strlcpy (skey->session, foo_M1, KEY_LEN+1);
1085	#ifdef SH_ENCRYPT
1086	err_num = makeKey(&(skey->keyInstE),
1087	(RIJ_BYTE)DIR_ENCRYPT, 192, skey->session);
1088	if (err_num < 0)
1089	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
1090	errorExplain(err_num, expbuf, sizeof(expbuf)),
1091	_("sh_forward_try_impl: makeKey"));
1092
1093	err_num = makeKey(&(skey->keyInstD),
1094	(RIJ_BYTE)DIR_DECRYPT, 192, skey->session);
1095	if (err_num < 0)
1096	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
1097	errorExplain(err_num, expbuf, sizeof(expbuf)),
1098	_("sh_forward_try_impl: make_key"));
1099	#endif
1100	initialized = GOOD;
1101	}
1102
1103	if (initialized == BAD)
1104	{
1105	timeout_val *= 2;
1106	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_NOAUTH);
1107	memset(answer, 0, 512);
1108	MUNLOCK(answer, 512);
1109	SH_FREE(answer);
1110	SL_RETURN( (-1), _("sh_forward_try_impl"));
1111	}
1112	else
1113	{
1114	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_AUTH);
1115	}
1116	}
1117
1118	#else
1119
1120
1121	/* This is the SRP authenticated key exchange protocol.
1122	* Produces a session key skey->session.
1123	*/
1124	if (initialized == BAD)
1125	{
1126	TPT(( 0, FIL__, __LINE__, _("msg=<srp: entry>\n")));
1127
1128	theProto = SH_PROTO_SRP;
1129
1130	sl_strlcpy (answer, sh.host.name, 512);
1131	flag_err = sh_forward_send (sockfd, theProto, _("SALT "),
1132	answer, sl_strlen(answer));
1133
1134	TPT(( 0, FIL__, __LINE__, _("msg=<srp: sent SALT, flag_err = %d>\n"),
1135	flag_err));
1136
1137	if (flag_err == 0)
1138	{
1139	flag_err = sh_forward_receive (sockfd, theProto, head_u,
1140	answer, 511);
1141	flag_err = (flag_err < 0) ? flag_err : 0;
1142	TPT(( 0, FIL__, __LINE__,
1143	_("msg=<srp: rcvt nonce, flag_err = %d>\n"),
1144	flag_err));
1145	}
1146
1147	/* Entry point for jump from message forward if session key must
1148	* be re-initialized.
1149	*/
1150	initBlock:
1151	TPT(( 0, FIL__, __LINE__, _("msg=<srp: INIT>\n")));
1152
1153	if (flag_err == 0 &&
1154	(0 == check_request (head_u, _("INIT"))))
1155	{
1156	if (0 != sh_srp_init())
1157	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_EBGN);
1158	else /* if (0 == sh_srp_init()) */
1159	{
1160	TPT(( 0, FIL__, __LINE__, _("msg=<srp: bignum initialized>\n")));
1161
1162	sh_srp_x (answer, NULL); /* x password */
1163	sh_srp_make_a (); /* a random number */
1164	foo_A = sh_srp_A(); /* g^a */
1165
1166	TPT(( 0, FIL__, __LINE__, _("msg=<srp: A = %s>\n"), foo_A));
1167
1168	if (foo_A == NULL)
1169	flag_err = (-1);
1170
1171	if (flag_err == 0)
1172	flag_err = sh_forward_send (sockfd,
1173	(theProto\|SH_PROTO_SRP),
1174	_("PC01"),
1175	foo_A, sl_strlen(foo_A)+1);
1176	if (flag_err == 0)
1177	{
1178	flag_err = sh_forward_receive (sockfd,
1179	(theProto\|SH_PROTO_SRP),
1180	head_u,
1181	answer, 511);
1182	flag_err = (flag_err < 0) ? flag_err : 0;
1183	TPT(( 0, FIL__, __LINE__, _("msg=<srp: B = %s>\n"), answer));
1184	TPT(( 0, FIL__, __LINE__, _("msg=<srp: u = %03o-%03o-%03o-%03o>\n"), head_u[0], head_u[1], head_u[2], head_u[3]));
1185	}
1186
1187	/* u nounce */
1188	/* B answer */
1189	/* S = (B-g^x)^(a+ux) */
1190
1191	if (flag_err == 0)
1192	{
1193	if (0 != sh_srp_check_zero (answer))
1194	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_EZERO);
1195	else /* if (0 != sh_srp_check_zero (answer)) */
1196	{
1197	sl_strlcpy(u_real, sh_tiger_hash(head_u, TIGER_DATA, 4,
1198	hashbuf, sizeof(hashbuf)),
1199	SH_CHALLENGE_SIZE);
1200	foo_Sc = sh_srp_S_c (u_real, answer);
1201
1202	TPT(( 0, FIL__, __LINE__, _("msg=<srp: U = %s>\n"),
1203	u_real));
1204	TPT(( 0, FIL__, __LINE__, _("msg=<srp:Sc = %s>\n"),
1205	foo_Sc));
1206
1207	/* --- Now send H(A,B,H(Sc)) and check. ---
1208	*/
1209	if (foo_Sc != NULL && 0 == sh_srp_check_zero (foo_Sc))
1210	{
1211	sh_srp_M(foo_A,
1212	answer,
1213	sh_tiger_hash(foo_Sc,
1214	TIGER_DATA,
1215	sl_strlen(foo_Sc),
1216	hashbuf, sizeof(hashbuf)),
1217	foo_M1, KEY_LEN+1);
1218
1219
1220	TPT(( 0, FIL__, __LINE__, _("msg=<srp:M1 = %s>\n"),
1221	foo_M1));
1222
1223	flag_err = sh_forward_send(sockfd,
1224	(theProto\|SH_PROTO_SRP),
1225	_("PC02"),
1226	foo_M1, KEY_LEN+1);
1227	}
1228	else
1229	{
1230	flag_err = (-1);
1231	}
1232
1233	if (flag_err == 0)
1234	{
1235	flag_err =sh_forward_receive(sockfd,
1236	(theProto\|SH_PROTO_SRP),
1237	head_u,
1238	answer, 511);
1239	flag_err = (flag_err < 0) ? flag_err : 0;
1240	TPT(( 0, FIL__, __LINE__, _("msg=<srp: M = %s>\n"),
1241	answer));
1242	}
1243
1244	if (flag_err == 0 &&
1245	(0 == check_request (head_u, _("PARP"))))
1246	{
1247	/* ------ verify M2 = H(A, M1, K) --------
1248	*/
1249	char M_buf[KEY_LEN+1];
1250	M = sh_srp_M (foo_A, foo_M1,
1251	sh_tiger_hash(foo_Sc,
1252	TIGER_DATA,
1253	sl_strlen(foo_Sc),
1254	hashbuf, sizeof(hashbuf)),
1255	M_buf, sizeof(M_buf)
1256	);
1257	if (M != NULL &&
1258	0 == sl_strncmp (answer, M, KEY_LEN+1))
1259	{
1260	sl_strlcpy (skey->session,
1261	sh_tiger_hash(foo_Sc,
1262	TIGER_DATA,
1263	sl_strlen(foo_Sc),
1264	hashbuf, sizeof(hashbuf)),
1265	KEY_LEN+1);
1266	TPT(( 0, FIL__, __LINE__,
1267	_("msg=<srp: Key = %s>\n"),
1268	skey->session));
1269
1270	#ifdef SH_ENCRYPT
1271	err_num = makeKey(&(skey->keyInstE),
1272	DIR_ENCRYPT,
1273	192, skey->session);
1274	if (err_num < 0)
1275	sh_error_handle((-1), FIL__, __LINE__, -1,
1276	MSG_E_SUBGEN,
1277	errorExplain(err_num, expbuf, sizeof(expbuf)),
1278	_("sh_forward_try_impl: makeKey"));
1279	err_num = makeKey(&(skey->keyInstD),
1280	DIR_DECRYPT,
1281	192, skey->session);
1282	if (err_num < 0)
1283	sh_error_handle((-1), FIL__, __LINE__, -1,
1284	MSG_E_SUBGEN,
1285	errorExplain(err_num, expbuf, sizeof(expbuf)),
1286	_("sh_forward_try_impl: makeKey"));
1287	#endif
1288	initialized = GOOD;
1289	}
1290	}
1291	if (foo_Sc != NULL)
1292	SH_FREE(foo_Sc);
1293	}
1294	}
1295	if (foo_A != NULL)
1296	SH_FREE(foo_A);
1297	sh_srp_exit();
1298	}
1299	}
1300
1301	if (initialized == BAD)
1302	{
1303	timeout_val *= 2;
1304	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_NOAUTH);
1305	memset(answer, '\0', 512);
1306	MUNLOCK(answer, 512);
1307	SH_FREE(answer);
1308	SL_RETURN( (-1), _("sh_forward_try_impl"));
1309	}
1310	else
1311	{
1312	if (flag_err_info == SL_TRUE)
1313	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_AUTH);
1314	}
1315	}
1316
1317	#endif
1318
1319	/* no message, just session key negotiated
1320	*/
1321	if (errmsg == NULL)
1322	{
1323	timeout_val = 1;
1324	memset(answer, 0, 512);
1325	MUNLOCK(answer, 512);
1326	SH_FREE(answer);
1327	TPT(( 0, FIL__, __LINE__, _("msg=<No message.>\n")));
1328	SL_RETURN( (0), _("sh_forward_try_impl"));
1329	}
1330	else if (what == (char)SH_PROTO_BIG)
1331	{
1332	MUNLOCK(answer, 512);
1333	SH_FREE (answer);
1334	answer = SH_ALLOC(TRANS_BYTES + 256);
1335	MLOCK(answer, TRANS_BYTES + 256);
1336	TPT(( 0, FIL__, __LINE__, _("msg=<File transfer.>\n")));
1337	}
1338
1339
1340	(void) sl_strlcpy (answer, sh_util_siggen(skey->session,
1341	sh.host.name,
1342	sl_strlen(sh.host.name),
1343	sigbuf, sizeof(sigbuf)),
1344	KEY_LEN+1);
1345	TPT((0, FIL__, __LINE__, _("msg=<host %s>\n"), sh.host.name));
1346	TPT((0, FIL__, __LINE__, _("msg=<ckey %s>\n"), skey->session));
1347	TPT((0, FIL__, __LINE__, _("msg=<sign %s>\n"), answer));
1348
1349
1350	(void) sl_strlcat (answer, sh.host.name, 512);
1351
1352	TPT((0, FIL__, __LINE__, _("msg=<mesg %s>\n"), answer));
1353
1354	/***********************************************
1355	*
1356	* send the message
1357	*
1358	*/
1359
1360	if (what == (char) SH_PROTO_MSG)
1361	{
1362	theProto = (unsigned char)SH_PROTO_MSG;
1363
1364	/* say HELO
1365	*/
1366
1367	flag_err = sh_forward_send (sockfd,
1368	(char)theProto, _("HELO"),
1369	answer,
1370	(unsigned long)sl_strlen(answer));
1371	TPT(( 0, FIL__, __LINE__, _("msg=<Sent %s, status %d.>\n"),
1372	answer, flag_err));
1373	if (flag_err == 0)
1374	{
1375	/* --- Get challenge. ---
1376	*/
1377	flag_err = (int) sh_forward_receive (sockfd,
1378	(char)SH_PROTO_MSG, head_u,
1379	answer, 255);
1380	TPT(( 0, FIL__, __LINE__, _("msg=<Rcvt %s, u %s, status %d.>\n"),
1381	answer, hu_trans(head_u), flag_err));
1382	flag_err = (flag_err < 0) ? flag_err : 0;
1383
1384	if (flag_err == 0)
1385	{
1386
1387	/* --- Re-negotiate key. ---
1388	*/
1389	if (0 == check_request_nerr(head_u, _("INIT")))
1390	{
1391	flag_err = 0;
1392	initialized = BAD;
1393	goto initBlock;
1394	}
1395
1396	else if (0 == check_request(head_u, _("TALK")))
1397	{
1398
1399	/* --- Save the challenge. ---
1400	*/
1401	(void) sl_strlcpy(nsrv, answer, KEY_LEN + 1);
1402
1403	/* --- Hash(msg,challenge,sessionkey). ---
1404	*/
1405	len = sl_strlen(errmsg) + sl_strlen(answer)
1406	+ KEY_LEN + 1;
1407	len = (size_t)((len < 256) ? 256 : len);
1408	buffer = SH_ALLOC(len);
1409	MLOCK(buffer, len);
1410	(void) sl_strlcpy(buffer, errmsg, len);
1411	(void) sl_strlcat(buffer, answer, len);
1412	(void) sl_strlcpy(hash,
1413	sh_util_siggen (skey->session,
1414	buffer,
1415	sl_strlen(buffer),
1416	sigbuf, sizeof(sigbuf)),
1417	KEY_LEN+1);
1418	TPT((0, FIL__, __LINE__, _("msg=<sign %s.>\n"),
1419	sh_util_siggen(skey->session, buffer,
1420	sl_strlen(buffer), sigbuf, sizeof(sigbuf))));
1421
1422	(void) sl_strlcpy(buffer, errmsg, len);
1423	(void) sl_strlcat(buffer, hash, len);
1424
1425	flag_err =
1426	sh_forward_send_crypt (sockfd,
1427	#ifdef SH_ENCRYPT
1428	#ifdef SH_ENCRYPT_2
1429	(char)(SH_PROTO_MSG\|SH_PROTO_ENC\|SH_PROTO_EN2),
1430	#else
1431	(char)(SH_PROTO_MSG\|SH_PROTO_ENC),
1432	#endif
1433	#else
1434	(char)(SH_PROTO_MSG),
1435	#endif
1436	_("MESG"),
1437	buffer,
1438	(unsigned long)(sl_strlen(buffer)+1));
1439	TPT(( 0, FIL__, __LINE__,
1440	_("msg=<Sent %s, status %d.>\n"),
1441	answer, flag_err));
1442
1443	/* --- Get confirmation. ---
1444	*/
1445	if (flag_err == 0)
1446	{
1447	flag_err = (int)
1448	sh_forward_receive_crypt (sockfd,
1449	#ifdef SH_ENCRYPT
1450	#ifdef SH_ENCRYPT_2
1451	(char)(SH_PROTO_MSG\|SH_PROTO_ENC\|SH_PROTO_EN2\|SH_PROTO_END),
1452	#else
1453	(char)(SH_PROTO_MSG\|SH_PROTO_ENC\|SH_PROTO_END),
1454	#endif
1455	#else
1456	(char)(SH_PROTO_MSG\|SH_PROTO_END),
1457	#endif
1458	head_u,
1459	answer, 255);
1460	TPT(( 0, FIL__, __LINE__,
1461	_("msg=<Rcvt %s, u %s, status %d.>\n"),
1462	answer, hu_trans(head_u), flag_err));
1463	flag_err = (flag_err < 0) ? flag_err : 0;
1464	}
1465
1466
1467	/* --- Check confirmation. ---
1468	*/
1469	if (flag_err == 0)
1470	{
1471	/* CLIENT CONF RECV
1472	*
1473	* first KEY_LEN bytes must be
1474	* sig(skey->session (errmsg nsrv))
1475	*
1476	*/
1477	(void) sl_strlcpy(buffer, errmsg, len);
1478	(void) sl_strlcat(buffer, nsrv, len);
1479	flag_err = sl_strncmp(answer,
1480	sh_util_siggen(skey->session,
1481	buffer,
1482	sl_strlen(buffer),
1483	sigbuf, sizeof(sigbuf)),
1484	KEY_LEN);
1485	TPT((0, FIL__, __LINE__, _("msg=<sign %s.>\n"),
1486	sh_util_siggen(skey->session, buffer,
1487	sl_strlen(buffer), sigbuf, sizeof(sigbuf))));
1488
1489	if (flag_err != 0)
1490	{
1491	#ifdef ENOMSG
1492	flag_err = ENOMSG;
1493	#else
1494	flag_err = EIO;
1495	#endif
1496	sh_error_handle((-1), FIL__, __LINE__, flag_err,
1497	MSG_TCP_NOCONF);
1498	}
1499	else
1500	{
1501	#ifdef SH_ENCRYPT_2
1502	/* --- SERVER CMD --- */
1503	if (answer[KEY_LEN] != '\0' &&
1504	sl_strlen(answer) > (2*KEY_LEN))
1505	{
1506	pos = sl_strlen(answer) - (2*KEY_LEN);
1507	/*
1508	* buffer is >= 256
1509	* answer has <= 255 bytes
1510	*/
1511	(void) sl_strlcpy(buffer, &answer[KEY_LEN],
1512	pos+1);
1513	flag_err =
1514	sl_strncmp(&answer[KEY_LEN+pos],
1515	sh_util_siggen(skey->session,
1516	buffer,
1517	pos,
1518	sigbuf, sizeof(sigbuf)),
1519	KEY_LEN);
1520
1521	TPT((0, FIL__, __LINE__,
1522	_("CONF RECV <%d> <%s>\n"),
1523	flag_err, &answer[KEY_LEN]));
1524
1525	if (flag_err != 0) {
1526	sh_error_handle((-1), FIL__, __LINE__,
1527	flag_err,
1528	MSG_TCP_NOCONF);
1529	}
1530	#ifdef SH_WITH_CLIENT
1531	else {
1532	sh_socket_server_cmd(buffer);
1533	}
1534	#endif
1535	flag_err = 0;
1536
1537	} else {
1538
1539	TPT((0, FIL__, __LINE__,
1540	_("CONF RECV <0> <[null]>\n")));
1541
1542	}
1543	/* --- SERVER CMD END --- */
1544	#endif
1545	if (flag_err_debug == SL_TRUE)
1546	sh_error_handle((-1), FIL__, __LINE__, 0,
1547	MSG_TCP_CONF);
1548	}
1549	}
1550
1551	memset(buffer, 0, len);
1552	MUNLOCK(buffer, len);
1553	SH_FREE(buffer);
1554	}
1555	else
1556	{
1557	/* --- Unexpected reply from server. ---
1558	*/
1559	sh_error_handle((-1), FIL__, __LINE__, 0,
1560	MSG_TCP_UNEXP);
1561	flag_err = (-1);
1562	}
1563	}
1564	}
1565	}
1566
1567
1568	else if (what == (char)SH_PROTO_BIG)
1569	{
1570	theProto = (unsigned char) SH_PROTO_BIG;
1571
1572	/* --- Say HELO ---
1573	*/
1574	flag_err = sh_forward_send (sockfd, (char) theProto, _("HELO"),
1575	answer, (unsigned long)sl_strlen(answer));
1576	TPT(( 0, FIL__, __LINE__, _("msg=<Sent %s, status %d.>\n"),
1577	answer, flag_err));
1578
1579	if (flag_err == 0)
1580	{
1581	/* --- Get NSRV. ---
1582	*/
1583	flag_err = (int) sh_forward_receive (sockfd,
1584	(char)SH_PROTO_BIG, head_u,
1585	answer, 255);
1586	TPT(( 0, FIL__, __LINE__, _("msg=<Rcvt %s, u %s, status %d.>\n"),
1587	answer, hu_trans(head_u), flag_err));
1588	flag_err = (flag_err < 0) ? flag_err : 0;
1589	}
1590
1591	if (flag_err == 0)
1592	{
1593
1594	/* --- Re-negotiate key. ---
1595	*/
1596	if (0 == check_request_nerr(head_u, _("INIT")))
1597	{
1598	flag_err = 0;
1599	initialized = BAD;
1600	goto initBlock;
1601	}
1602
1603
1604	else if (0 == check_request(head_u, _("NSRV")))
1605	{
1606	#ifdef SH_ENCRYPT
1607	/* --- Set encryption flag. ---
1608	*/
1609	#ifdef SH_ENCRYPT_2
1610	theProto =
1611	(unsigned char)(SH_PROTO_BIG \| SH_PROTO_ENC \| SH_PROTO_EN2);
1612	#else
1613	theProto = (unsigned char)(SH_PROTO_BIG \| SH_PROTO_ENC);
1614	#endif
1615	#endif
1616
1617	(void) sl_strlcpy(nsrv, answer, KEY_LEN+1);
1618
1619	/* --- Generate a nonce. ---
1620	*/
1621	ticks = (UINT32) taus_get ();
1622
1623	(void) sl_strlcpy(nclt,
1624	sh_tiger_hash((char *) &ticks,
1625	TIGER_DATA,
1626	(unsigned long)sizeof(UINT32),
1627	hashbuf, sizeof(hashbuf)),
1628	KEY_LEN+1);
1629
1630	/* --- Compute H(nsrv, nclt, skey). ---
1631	*/
1632	buffer = sh_util_strconcat (nsrv, nclt,
1633	skey->session, NULL);
1634	(void)sl_strlcpy(foo_M1,
1635	sh_tiger_hash(buffer, TIGER_DATA,
1636	(unsigned long)sl_strlen(buffer),
1637	hashbuf, sizeof(hashbuf)),
1638	KEY_LEN+1);
1639	memset (buffer, 0, sl_strlen(buffer));
1640
1641	/* --- Send (nclt, msg) ---
1642	*/
1643	(void) sl_strlcpy(buffer, nclt, KEY_LEN+1);
1644	(void) sl_strlcat(buffer, errmsg, KEY_LEN+5);
1645
1646	#ifndef SH_ENCRYPT
1647	buffer[KEY_LEN+4] = theProto;
1648	buffer[KEY_LEN+5] = '\0';
1649	sh_tools_hash_add(foo_M1, buffer, KEY_LEN+5);
1650	#endif
1651
1652	flag_err =
1653	sh_forward_send_crypt (sockfd, (char) theProto, _("NCLT"),
1654	buffer,
1655	(unsigned long) sl_strlen(buffer));
1656
1657	TPT(( 0, FIL__, __LINE__, _("msg=<Sent %s, status %d.>\n"),
1658	buffer, flag_err));
1659	SH_FREE (buffer);
1660	}
1661	}
1662
1663	if (flag_err == 0)
1664	{
1665	/* --- Receive the file. ---
1666	*/
1667
1668	/* --- Open a temporary file. ---
1669	*/
1670
1671	if ( (sfd = open_tmp ()) < 0)
1672	{
1673	flag_err = (-1);
1674	sh_error_handle((-1), FIL__, __LINE__, flag_err, MSG_TCP_EFIL);
1675	}
1676	else
1677	{
1678	/* --- Read from socket into tmp file. ---
1679	*/
1680	transfercount = 0;
1681	/* flag_err = 0; // never read */
1682
1683	do {
1684	flag_err = (int)
1685	sh_forward_receive_crypt (sockfd,
1686	#ifdef SH_ENCRYPT
1687	#ifdef SH_ENCRYPT_2
1688	(char)(SH_PROTO_BIG\|SH_PROTO_EN2\|SH_PROTO_ENC),
1689	#else
1690	(char)(SH_PROTO_BIG\|SH_PROTO_ENC),
1691	#endif
1692	#else
1693	(char)(SH_PROTO_BIG),
1694	#endif
1695	head_u,
1696	answer,
1697	TRANS_BYTES + 255);
1698
1699	TPT(( 0, FIL__, __LINE__,
1700	_("msg=<Received: %d bytes, marked %s.>\n"),
1701	flag_err, hu_trans(head_u)));
1702
1703	if (flag_err > 0 && 0 == check_request_nerr(head_u, _("FILE")))
1704	{
1705	if (0 == hash_check (foo_M1, answer, flag_err))
1706	{
1707	(void) sl_write(sfd, &answer[KEY_LEN],
1708	flag_err-KEY_LEN);
1709	++transfercount;
1710	/***
1711	*** --- Delay for throughput throttling ---
1712	***/
1713	if (sh_throttle_delay > 0)
1714	retry_msleep(sh_throttle_delay/1000, sh_throttle_delay % 1000);
1715	/***
1716	*** --- End delay ---
1717	***/
1718	flag_err =
1719	sh_forward_send_crypt (sockfd, (char) theProto,
1720	_("RECV"),
1721	nclt,
1722	(unsigned long)sl_strlen(nclt));
1723
1724	}
1725	else
1726	{
1727	TPT(( 0, FIL__, __LINE__,
1728	_("msg=<File transfer: Hash check failed.>\n")));
1729	break;
1730	}
1731	}
1732	else
1733	{
1734	TPT(( 0, FIL__, __LINE__,
1735	_("msg=<File transfer: No more data.>\n")));
1736	break;
1737	}
1738	} while (transfercount < 32000); /* 64 Mbyte */
1739
1740	if (0 == check_request_nerr(head_u, _("EEOT")) &&
1741	0 < flag_err &&
1742	0 == hash_check (foo_M1, answer, (int)sl_strlen(answer)))
1743	{
1744	flag_err =
1745	sh_forward_send_crypt (sockfd, (char) theProto,
1746	_("EOTE"),
1747	nclt,
1748	(unsigned int) sl_strlen(nclt));
1749
1750	(void) rewind_tmp (sfd);
1751	(void) sl_sync(sfd);
1752	if (flag_err_info == SL_TRUE)
1753	sh_error_handle((-1), FIL__, __LINE__, flag_err, MSG_TCP_FOK);
1754	}
1755	else
1756	{
1757	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_FBAD);
1758	(void) sl_close (sfd);
1759	sfd = (-1);
1760	}
1761
1762	(void) sl_close_fd (FIL__, __LINE__, sockfd);
1763	memset(answer, 0, TRANS_BYTES + 256);
1764	MUNLOCK(answer, TRANS_BYTES + 256);
1765	SH_FREE(answer);
1766	timeout_val = 1;
1767
1768	SL_RETURN( (sfd), _("sh_forward_try_impl"));
1769	}
1770	}
1771
1772	(void) sl_close_fd (FIL__, __LINE__, sockfd);
1773	memset(answer, 0, TRANS_BYTES + 256);
1774	MUNLOCK(answer, TRANS_BYTES + 256);
1775	SH_FREE(answer);
1776	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_FBAD);
1777	timeout_val *= 2;
1778
1779	SL_RETURN( (-1), _("sh_forward_try_impl"));
1780	}
1781
1782
1783
1784	(void) sl_close_fd (FIL__, __LINE__, sockfd);
1785	memset(answer, 0, 512);
1786	MUNLOCK(answer, 512);
1787	SH_FREE(answer);
1788
1789	#ifndef EIO
1790	#define EIO 5
1791	#endif
1792
1793
1794	#ifdef SH_ERROR_H
1795	if (flag_err != 0)
1796	{
1797	char errbuf[SH_ERRBUF_SIZE];
1798	conn_state = BAD;
1799	timeout_val *= 2;
1800	if (flag_err < 0 \|\| NULL == sh_error_message(flag_err, errbuf, sizeof(errbuf)))
1801	flag_err = EIO;
1802	sh_error_handle((-1), FIL__, __LINE__, flag_err, MSG_TCP_ECONN,
1803	sh_error_message(flag_err, errbuf, sizeof(errbuf)));
1804	SL_RETURN( (-1), _("sh_forward_try_impl"));
1805	}
1806	#endif
1807	timeout_val = 1;
1808
1809	SL_RETURN( (0), _("sh_forward_try_impl"));
1810	}
1811
1812	/* #ifdef SH_WITH_CLIENT */
1813	#endif
1814
1815
1816	#if defined (SH_WITH_SERVER)
1817
1818	#ifndef USE_SRP_PROTOCOL
1819
1820	int sh_forward_make_client (const char * str)
1821	{
1822	/* char * safer; */
1823	char key[KEY_LEN+1];
1824	unsigned char in[PW_LEN+1];
1825	int i = 0, j, k, l = 0;
1826	char hashbuf[KEYBUF_SIZE];
1827
1828	if (sl_strlen(str) != (PW_LEN * 2))
1829	{
1830	fprintf(stderr,
1831	_("Input must be a %d digit hexadecimal number"\
1832	" (only 0-9, a-f, A-F allowed in input)\n"),
1833	(PW_LEN * 2));
1834	_exit(EXIT_FAILURE);
1835	}
1836
1837	while (i < (PW_LEN * 2))
1838	{
1839	k = sh_util_hexchar(str[i]); j = sh_util_hexchar(str[i+1]);
1840	if (k != -1 && j != -1)
1841	{
1842	in[l] = (k * 16 + j);
1843	++l; i+= 2;
1844	}
1845	else
1846	{
1847	fprintf(stderr, _("Invalid char %c\n"), str[i]);
1848	_exit(EXIT_FAILURE);
1849	}
1850	}
1851	in[PW_LEN] = '\0';
1852
1853	sl_strlcpy ((char *)key,
1854	sh_tiger_hash ((char*)in, TIGER_DATA, PW_LEN,
1855	hashbuf, sizeof(hashbuf)),
1856	KEY_LEN+1);
1857	key[KEY_LEN] = '\0';
1858
1859	fprintf(stdout, _("Client entry: Client=HOSTNAME@00000000@%s\n"),
1860	key);
1861	fflush(stdout);
1862
1863	_exit(EXIT_SUCCESS);
1864	return 0;
1865	}
1866
1867	#else
1868
1869	int sh_forward_make_client (const char * str)
1870	{
1871	char * foo_v;
1872
1873	char salt[17];
1874	char key[KEY_LEN+1];
1875	char in[PW_LEN];
1876	int i = 0, j, k, l = 0;
1877	char hashbuf[KEYBUF_SIZE];
1878
1879	if (sl_strlen(str) != (PW_LEN*2))
1880	{
1881	fprintf(stderr,
1882	_("Input must be a %d digit hexadecimal number"\
1883	" (only 0-9, a-f, A-F allowed in input)\n"),
1884	(PW_LEN*2));
1885	_exit(EXIT_FAILURE);
1886	}
1887
1888	while (i < (PW_LEN*2))
1889	{
1890	k = sh_util_hexchar(str[i]); j = sh_util_hexchar(str[i+1]);
1891	if (k != -1 && j != -1)
1892	{
1893	in[l] = (k * 16 + j);
1894	++l; i+= 2;
1895	}
1896	else
1897	{
1898	fprintf(stderr, _("Invalid char %c\n"), str[i]);
1899	_exit(EXIT_FAILURE);
1900	}
1901	}
1902
1903
1904	if (0 == sh_srp_init())
1905	{
1906	sh_util_keyinit(key, KEY_LEN);
1907	sl_strlcpy(salt, sh_tiger_hash(key, TIGER_DATA, KEY_LEN,
1908	hashbuf, sizeof(hashbuf)),
1909	17);
1910	sh_srp_x (salt, in);
1911	foo_v = sh_srp_verifier ();
1912	fprintf(stdout, _("Client=HOSTNAME@%s@%s\n"),
1913	salt, foo_v);
1914	fflush(stdout);
1915	SH_FREE(foo_v);
1916	sh_srp_exit();
1917	_exit(EXIT_SUCCESS);
1918	}
1919	fprintf(stdout, "%s",_("ERROR initializing BigNum library.\n"));
1920	fflush (stdout);
1921	_exit(EXIT_FAILURE);
1922	return -1;
1923	}
1924	#endif
1925
1926
1927	int sh_forward_create_password (const char * dummy)
1928	{
1929	UINT32 val[2];
1930	char output[KEY_LEN+1];
1931	char hashbuf[KEYBUF_SIZE];
1932
1933	val[0] = taus_get ();
1934	val[1] = taus_get ();
1935
1936	sl_strlcpy (output,
1937	sh_tiger_hash((char )(&val[0]), TIGER_DATA, 2sizeof(UINT32),
1938	hashbuf, sizeof(hashbuf)),
1939	KEY_LEN);
1940
1941	output[16] = '\0';
1942
1943	fprintf(stdout, _("%s\n"), output);
1944	fflush (stdout);
1945
1946	if (dummy)
1947	_exit(EXIT_SUCCESS);
1948	else
1949	_exit(EXIT_SUCCESS);
1950	return (0); /* avoid compiler warning */
1951	}
1952
1953	/* #if defined (SH_WITH_SERVER) */
1954	#endif
1955
1956	/**************************************************
1957	*
1958	*
1959	* S E R V E R
1960	*
1961	*
1962	***************************************************/
1963
1964	#ifdef SH_WITH_SERVER
1965
1966	#include "sh_readconf.h"
1967
1968
1969	#define CONN_FREE 0
1970	#define CONN_READING 1
1971	#define CONN_SENDING 2
1972	#define CONN_PAUSE 3
1973	#define CONN_BUSY 4
1974
1975	char * clt_stat[] = {
1976	N_("Inactive"),
1977	N_("Started"),
1978	N_("ILLEGAL"),
1979	N_("FAILED"),
1980	N_("Exited"),
1981	N_("PANIC"),
1982	N_("POLICY"),
1983	N_("File_transfer"),
1984	N_("Message"),
1985	N_("TIMEOUT_EXCEEDED"),
1986	N_("Suspended"),
1987	N_("Filecheck"),
1988	};
1989
1990	#include <time.h>
1991
1992	/* in sh_html.h:
1993	* typedef struct client_entry {
1994	* } client_t;
1995	*/
1996
1997	#include "zAVLTree.h"
1998
1999	static char * sh_tolower (char * s)
2000	{
2001	char * ret = s;
2002	if (s)
2003	{
2004	for (; *s; ++s)
2005	{
2006	s = tolower((unsigned char) s);
2007	}
2008	}
2009	return ret;
2010	}
2011
2012	/* Function to return the key for indexing
2013	* the argument
2014	*/
2015	zAVLKey sh_avl_key (void const * arg)
2016	{
2017	const client_t * sa = (const client_t *) arg;
2018	return (zAVLKey) sa->hostname;
2019	}
2020
2021	zAVLTree * all_clients = NULL;
2022
2023	void sh_forward_html_write()
2024	{
2025	SL_ENTER(_("sh_forward_html_write"));
2026	sh_html_write(all_clients);
2027	SL_RET0(_("sh_forward_html_write"));
2028	}
2029
2030
2031	int sh_forward_use_clt_class (const char * c)
2032	{
2033	int i;
2034	SL_ENTER(_("sh_forward_use_clt_class"));
2035	i = sh_util_flagval(c, &(sh.flag.client_class));
2036	SL_RETURN(i, _("sh_forward_use_clt_class"));
2037	}
2038
2039	int sh_forward_use_clt_sev (const char * c)
2040	{
2041	int i;
2042	SL_ENTER(_("sh_forward_use_clt_sev"));
2043	i = sh_util_flagval(c, &(sh.flag.client_severity));
2044	SL_RETURN(i, _("sh_forward_use_clt_sev"));
2045	}
2046
2047
2048	/* the destructor
2049	*/
2050	void free_client(void * inptr)
2051	{
2052	client_t * here;
2053
2054	SL_ENTER(_("free_client"));
2055	if (inptr == NULL)
2056	SL_RET0(_("free_client"));
2057	else
2058	here = (client_t *) inptr;
2059
2060	if (here->hostname != NULL)
2061	SH_FREE(here->hostname);
2062	if (here->salt != NULL)
2063	SH_FREE(here->salt);
2064	if (here->verifier != NULL)
2065	SH_FREE(here->verifier);
2066	SH_FREE(here);
2067	SL_RET0(_("free_client"));
2068	}
2069
2070
2071	int sh_forward_register_client (const char * str)
2072	{
2073	client_t * newclt;
2074	client_t * testclt;
2075
2076	const char * ptr;
2077	int sepnum = 0;
2078	int sep[2];
2079	register int i = 0;
2080	int siz_str = 0;
2081
2082	SL_ENTER(_("sh_forward_register_client"));
2083
2084	ptr = str;
2085	while (*ptr) {
2086	if (*ptr == '@' && sepnum < 2 )
2087	{
2088	sep[sepnum] = i;
2089	++sepnum;
2090	}
2091	++ptr; ++i;
2092	}
2093
2094	if (all_clients == NULL)
2095	{
2096	all_clients = zAVLAllocTree (sh_avl_key, zAVL_KEY_STRING);
2097	if (all_clients == NULL)
2098	{
2099	(void) safe_logger (0, 0, NULL);
2100	aud__exit(FIL__, __LINE__, EXIT_FAILURE);
2101	}
2102	}
2103
2104	if ((sepnum == 2) && (sep[0] > 0) && (sep[1] > sep[0]))
2105	{
2106	newclt = SH_ALLOC (sizeof(client_t));
2107	newclt->hostname = SH_ALLOC (sep[0]+1);
2108	newclt->salt = SH_ALLOC (sep[1]-sep[0]);
2109	newclt->verifier = SH_ALLOC (sl_strlen(str)-sep[1]+1);
2110	newclt->exit_flag = 0;
2111	newclt->dead_flag = 0;
2112	#ifdef SH_ENCRYPT
2113	#ifdef SH_ENCRYPT_2
2114	newclt->encf_flag = SH_PROTO_ENC\|SH_PROTO_EN2;
2115	newclt->ency_flag = SH_PROTO_ENC\|SH_PROTO_EN2;
2116	#else
2117	newclt->encf_flag = SH_PROTO_ENC;
2118	newclt->ency_flag = SH_PROTO_ENC;
2119	#endif
2120	#else
2121	newclt->encf_flag = 0;
2122	newclt->ency_flag = 0;
2123	#endif
2124	newclt->session_key[0] = '\0';
2125	newclt->last_connect = (time_t) 0;
2126	newclt->session_key_timer = (time_t) 0;
2127	newclt->status_now = CLT_INACTIVE;
2128	for (i = 0; i < CLT_MAX; ++i)
2129	newclt->status_arr[i] = CLT_INACTIVE;
2130	(void) sh_unix_time(0, newclt->timestamp[CLT_INACTIVE], TIM_MAX);
2131
2132	/* truncate */
2133	sl_strlcpy(newclt->hostname, &str[0], sep[0]+1);
2134	sh_tolower(newclt->hostname);
2135
2136	/* truncate */
2137	sl_strlcpy(newclt->salt, &str[sep[0]+1], sep[1]-sep[0]);
2138	sl_strlcpy(newclt->verifier, &str[sep[1]+1], sl_strlen(str)-sep[1]+1);
2139
2140	testclt = (client_t *) zAVLSearch (all_clients, newclt->hostname);
2141
2142	if (testclt != NULL)
2143	{
2144	SH_FREE(testclt->verifier);
2145	siz_str = strlen (newclt->verifier) + 1;
2146	testclt->verifier = SH_ALLOC (siz_str);
2147	sl_strlcpy(testclt->verifier, newclt->verifier, siz_str);
2148
2149	SH_FREE(testclt->salt);
2150	siz_str = strlen (newclt->salt) + 1;
2151	testclt->salt = SH_ALLOC (siz_str);
2152	sl_strlcpy(testclt->salt, newclt->salt, siz_str);
2153
2154	testclt->dead_flag = 0;
2155
2156	free_client(newclt);
2157	SL_RETURN( 0, _("sh_forward_register_client"));
2158	}
2159	else
2160	{
2161	if (0 == zAVLInsert (all_clients, newclt))
2162	{
2163	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_CREG,
2164	newclt->hostname,
2165	newclt->salt, newclt->verifier);
2166	SL_RETURN( 0, _("sh_forward_register_client"));
2167	}
2168	}
2169	}
2170	SL_RETURN (-1, _("sh_forward_register_client"));
2171	}
2172
2173	typedef struct {
2174	int state;
2175	int fd;
2176	char * buf;
2177	unsigned char head[SH_HEADER_SIZE];
2178	char challenge[SH_CHALLENGE_SIZE];
2179	char peer[SH_MINIBUF+1];
2180	client_t * client_entry;
2181	char * K;
2182	char * M1;
2183	char * A;
2184	int headcount;
2185	unsigned long bytecount;
2186	unsigned long bytes_to_send;
2187	unsigned long bytes_to_get;
2188	int pass;
2189	unsigned long timer;
2190
2191	char * FileName;
2192	unsigned long FileLength;
2193	unsigned long FileSent;
2194	char FileType[5];
2195
2196	struct sh_sockaddr addr_peer;
2197	} sh_conn_t;
2198
2199
2200	static char zap_challenge[SH_CHALLENGE_SIZE] = { 0 };
2201
2202	void sh_forward_do_free (sh_conn_t * conn)
2203	{
2204	SL_ENTER(_("sh_forward_do_free"));
2205
2206	if (conn->K != NULL)
2207	{
2208	SH_FREE(conn->K);
2209	conn->K = NULL;
2210	}
2211	if (conn->A != NULL)
2212	{
2213	SH_FREE(conn->A);
2214	conn->A = NULL;
2215	}
2216	if (conn->M1 != NULL)
2217	{
2218	SH_FREE(conn->M1);
2219	conn->M1 = NULL;
2220	}
2221	if (conn->buf != NULL)
2222	{
2223	SH_FREE(conn->buf);
2224	conn->buf = NULL;
2225	}
2226	if (conn->fd != (-1))
2227	{
2228	sl_close_fd (FIL__, __LINE__, conn->fd);
2229	conn->fd = -1;
2230	}
2231	memcpy(conn->challenge, zap_challenge, SH_CHALLENGE_SIZE);
2232	conn->state = CONN_FREE;
2233	conn->headcount = 0;
2234	conn->bytecount = 0;
2235	conn->bytes_to_send = 0;
2236	conn->bytes_to_get = 0;
2237	conn->pass = 0;
2238	conn->timer = 0;
2239	conn->client_entry = NULL;
2240
2241	if (conn->FileName != NULL)
2242	{
2243	SH_FREE(conn->FileName);
2244	conn->FileName = NULL;
2245	}
2246	conn->FileLength = 0;
2247	conn->FileSent = 0;
2248	conn->FileType[0] = '\0';
2249	conn->FileType[1] = '\0';
2250	conn->FileType[2] = '\0';
2251	conn->FileType[3] = '\0';
2252	conn->FileType[4] = '\0';
2253
2254	--server_status.conn_open;
2255
2256	SL_RET0(_("sh_forward_do_free"));
2257	}
2258
2259	/****************************************
2260	*
2261	* -- Reconfiguration. --
2262	*
2263	* (1) Mark all clients as 'dead'.
2264	* (2) Reload configuration - clients
2265	* in config are non-dead now.
2266	* (3) Remove all clients still
2267	* marked as 'dead'.
2268	*/
2269
2270	/* -- Mark all clients as dead.
2271	*/
2272	void sh_forward_mark_dead (void)
2273	{
2274	zAVLCursor avlcursor;
2275	client_t * item;
2276
2277	SL_ENTER(_("sh_forward_mark_dead"));
2278
2279	for (item = (client_t *) zAVLFirst(&avlcursor, all_clients); item;
2280	item = (client_t *) zAVLNext(&avlcursor))
2281	{
2282	item->dead_flag = 1;
2283	}
2284	SL_RET0(_("sh_forward_mark_dead"));
2285	}
2286
2287
2288	/* -- Clean tree from dead clients.
2289	*/
2290	void sh_forward_clean_tree (void)
2291	{
2292	zAVLCursor avlcursor;
2293	client_t * item;
2294
2295	SL_ENTER(_("sh_forward_clean_tree"));
2296
2297	repeat_search:
2298
2299	for (item = (client_t *) zAVLFirst(&avlcursor, all_clients); item;
2300	item = (client_t *) zAVLNext(&avlcursor))
2301	{
2302	if (item->dead_flag == 1)
2303	{
2304	zAVLDelete (all_clients, item->hostname);
2305	free_client (item);
2306	goto repeat_search;
2307	}
2308	}
2309	SL_RET0(_("sh_forward_clean_tree"));
2310	}
2311
2312	/*
2313	*
2314	**********************************************/
2315
2316
2317
2318	/* -- SERVER SEND FUNKTION. --
2319	*/
2320	void sh_forward_prep_send_int (sh_conn_t * conn,
2321	char * msg, unsigned long length,
2322	char * u, char protocol,
2323	int docrypt)
2324	{
2325	/* register unsigned long i; */
2326	unsigned long length2;
2327
2328	#ifdef SH_ENCRYPT
2329	unsigned long blkfac = 0;
2330	int rem = 0;
2331	char * p, * q;
2332	RIJ_BYTE inBlock[B_SIZ];
2333	RIJ_BYTE outBlock[B_SIZ];
2334	unsigned int j;
2335	cipherInstance cipherInst;
2336	int err_num;
2337	char expbuf[SH_ERRBUF_SIZE];
2338	#else
2339	(void) docrypt;
2340	#endif
2341
2342	SL_ENTER(_("sh_forward_prep_send_int"));
2343
2344	TPT((0, FIL__, __LINE__, _("msg=<%s>, docrypt=<%d>\n"), msg, docrypt ));
2345
2346	#ifdef SH_ENCRYPT
2347	if ((S_TRUE == docrypt) && ((protocol & SH_PROTO_EN2) != 0) )
2348	{
2349	length2 = length;
2350	}
2351	else if ((S_TRUE == docrypt) && ((protocol & SH_PROTO_ENC) != 0) )
2352	{
2353	blkfac = length/B_SIZ;
2354	rem = length - (B_SIZ * blkfac);
2355	length2 = (B_SIZ * blkfac);
2356	if (rem > 0 && (length2 + B_SIZ) > length2)
2357	length2 += B_SIZ;
2358	else
2359	rem = 0;
2360	}
2361	else
2362	{
2363	length2 = length;
2364	}
2365	#else
2366	length2 = length;
2367	#endif
2368
2369	conn->headcount = 0;
2370	conn->bytecount = 0;
2371	conn->bytes_to_send = 0;
2372	conn->bytes_to_get = 0;
2373
2374	if (conn->buf != NULL)
2375	{
2376	SH_FREE(conn->buf);
2377	conn->buf = NULL;
2378	}
2379
2380
2381	put_header (conn->head, protocol, &length2, u);
2382	SH_SHOWPROT(conn->head,'>');
2383
2384	TPT((0, FIL__, __LINE__, _("msg=<put_header done>\n") ));
2385
2386	if (msg == NULL)
2387	length2 = 0;
2388
2389	#ifdef SH_ENCRYPT
2390	if ((S_TRUE == docrypt) && ((protocol & SH_PROTO_EN2) != 0))
2391	{
2392	TPT((0, FIL__, __LINE__, _("encrypting (version 2)\n")));
2393
2394	conn->buf = sh_tools_makePack (conn->head, msg, length2,
2395	&(conn->client_entry->keyInstE));
2396	}
2397	else if (msg == NULL)
2398	{
2399	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
2400	_("msg is NULL"),
2401	_("sh_forward_prep_send_int: cipherInit"));
2402	}
2403	else if ((S_TRUE == docrypt) && ((protocol & SH_PROTO_ENC) != 0) &&
2404	((length2 + 1) > length2))
2405	{
2406	conn->buf = SH_ALLOC(length2 + 1);
2407
2408	p = msg;
2409	q = conn->buf;
2410
2411	TPT((0, FIL__, __LINE__, _("encrypting (version 1)\n")));
2412
2413	err_num = cipherInit (&cipherInst, MODE_CBC, NULL);
2414	if (err_num < 0)
2415	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
2416	errorExplain(err_num, expbuf, sizeof(expbuf)),
2417	_("sh_forward_prep_send_int: cipherInit"));
2418
2419	for (j = 0; j < blkfac; ++j)
2420	{
2421	memcpy(inBlock, p, B_SIZ);
2422	err_num = blockEncrypt(&cipherInst, &(conn->client_entry->keyInstE),
2423	inBlock, 128 * BNUM, outBlock);
2424	if (err_num < 0)
2425	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
2426	errorExplain(err_num, expbuf, sizeof(expbuf)),
2427	_("sh_forward_prep_send_int: blockEncrypt"));
2428	memcpy(q, outBlock, B_SIZ);
2429	p += B_SIZ;
2430	q += B_SIZ;
2431	}
2432	if (rem > 0)
2433	{
2434	/* incomplete block at end
2435	*/
2436	memset(inBlock, '\0', B_SIZ);
2437	memcpy(inBlock, p, rem);
2438	err_num = blockEncrypt(&cipherInst, &(conn->client_entry->keyInstE),
2439	inBlock, 128 * BNUM, outBlock);
2440	if (err_num < 0)
2441	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
2442	errorExplain(err_num, expbuf, sizeof(expbuf)),
2443	_("sh_forward_prep_send_int: blockEncrypt"));
2444	memcpy(q, outBlock, B_SIZ);
2445	/* q += B_SIZ; // never read */
2446	}
2447
2448	TPT((0, FIL__, __LINE__, _("msg=<encryption done>\n") ));
2449	}
2450	else
2451	{
2452	if ((length2 + 1) < length2) --length2;
2453	conn->buf = SH_ALLOC(length2 + 1);
2454
2455	memcpy(conn->buf, msg, length2);
2456	/*
2457	for (i = 0; i < length2; ++i)
2458	conn->buf[i] = msg[i];
2459	*/
2460	conn->buf[length2] = '\0';
2461	TPT((0, FIL__, __LINE__, _("msg=<no encryption done>\n") ));
2462	}
2463	#else
2464	if ((length2 + 1) < length2) --length2;
2465	conn->buf = SH_ALLOC(length2 + 1);
2466
2467	memcpy(conn->buf, msg, length2);
2468	/*
2469	for (i = 0; i < length; ++i)
2470	conn->buf[i] = msg[i];
2471	*/
2472	conn->buf[length2] = '\0';
2473	TPT((0, FIL__, __LINE__, _("msg=<no encryption done>\n") ));
2474	#endif
2475
2476	conn->state = CONN_SENDING;
2477	SL_RET0(_("sh_forward_prep_send_int"));
2478	}
2479
2480	/* -- Send/Receive. --
2481	*/
2482	void sh_forward_prep_send (sh_conn_t * conn,
2483	char * msg, unsigned long length,
2484	char * u, char protocol)
2485	{
2486	SL_ENTER(_("sh_forward_prep_send"));
2487	sh_forward_prep_send_int (conn, msg, length, u, protocol, S_FALSE);
2488	SL_RET0(_("sh_forward_prep_send"));
2489	}
2490
2491	void sh_forward_prep_send_crypt (sh_conn_t * conn,
2492	char * msg, unsigned long length,
2493	char * u, char protocol)
2494	{
2495	SL_ENTER(_("sh_forward_prep_send_crypt"));
2496	sh_forward_prep_send_int (conn, msg, length, u, protocol, S_TRUE);
2497	SL_RET0(_("sh_forward_prep_send_crypt"));
2498	}
2499
2500	/* #include <sys/times.h> */
2501
2502	#if defined(WITH_EXTERNAL)
2503	#include "sh_extern.h"
2504	#endif
2505
2506	/* -- Update the client status. --
2507	*
2508	* Update the status array for the client,
2509	* and eventually call external program.
2510	*/
2511	static void status_update (client_t * conn, int status)
2512	{
2513	#if defined(WITH_EXTERNAL)
2514	char msg[2 * SH_MINIBUF + TIM_MAX + 3];
2515	#endif
2516
2517	SL_ENTER(_("status_update"));
2518
2519	if (conn == NULL \|\|
2520	status < 0 \|\| status >= CLT_MAX)
2521	SL_RET0(_("status_update"));
2522
2523	conn->status_now = status;
2524	conn->status_arr[status] = status;
2525	(void) sh_unix_time(0, conn->timestamp[status], TIM_MAX);
2526
2527	#if defined(WITH_EXTERNAL)
2528	sl_snprintf(msg, sizeof(msg), _("%s %s %s"),
2529	conn->hostname, conn->timestamp[status], _(clt_stat[status]));
2530	sh_ext_execute('s', 'r', 'v', msg, 0);
2531	#endif
2532
2533	SL_RET0(_("status_update"));
2534	}
2535
2536	static time_t time_client_limit = 86400;
2537
2538	int sh_forward_set_time_limit (const char * c)
2539	{
2540	long val;
2541
2542	SL_ENTER(_("sh_forward_set_time_limit"));
2543
2544	val = strtol (c, (char **)NULL, 10);
2545	if (val <= 0)
2546	SL_RETURN( (-1), _("sh_forward_set_time_limit"));
2547
2548	time_client_limit = (time_t) val;
2549	SL_RETURN( (0), _("sh_forward_set_time_limit"));
2550	}
2551
2552
2553	/* -- Check for time limit exceeded. --
2554	*/
2555	static int client_time_check(void)
2556	{
2557	zAVLCursor avlcursor;
2558	client_t * item;
2559
2560	SL_ENTER(_("client_time_check"));
2561
2562	if (time_client_limit == (time_t) 0)
2563	SL_RETURN( 0, _("client_time_check"));
2564
2565	for (item = (client_t *) zAVLFirst(&avlcursor, all_clients); item;
2566	item = (client_t *) zAVLNext(&avlcursor))
2567	{
2568	if (item->exit_flag == 0 && item->last_connect != (time_t) 0)
2569	{
2570	if ( (time(NULL) - item->last_connect) > time_client_limit)
2571	{
2572	if (item->status_now != CLT_TOOLONG)
2573	{
2574	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_TIMEXC,
2575	item->hostname);
2576	status_update (item, CLT_TOOLONG);
2577	}
2578	}
2579	}
2580	}
2581	SL_RETURN( 0, _("client_time_check"));
2582	}
2583
2584	static int lookup_err = SH_ERR_SEVERE;
2585
2586	int sh_forward_lookup_level (const char * c)
2587	{
2588	int ci = sh_error_convert_level (c);
2589
2590	SL_ENTER(_("sh_forward_lookup_level"));
2591
2592	if (ci >= 0)
2593	{
2594	lookup_err = ci;
2595	SL_RETURN( 0, _("sh_forward_lookup_level"));
2596	}
2597	else
2598	SL_RETURN( (-1), _("sh_forward_lookup_level"));
2599	}
2600
2601	#ifndef MAXHOSTNAMELEN
2602	#define MAXHOSTNAMELEN 127
2603	#endif
2604
2605	int check_addr (const char * claim, struct sh_sockaddr * addr_peer)
2606	{
2607	char h_name[MAXHOSTNAMELEN + 1];
2608	char h_peer[MAXHOSTNAMELEN + 1];
2609	char h_peer_IP[SH_IP_BUF];
2610	char tmp_peer_IP[SH_IP_BUF];
2611	char * canonical;
2612	char numeric[SH_IP_BUF];
2613
2614	SL_ENTER(_("check_addr"));
2615
2616	if (claim == NULL)
2617	{
2618	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
2619	_("NULL input"), _("check_addr"));
2620	SL_RETURN ((-1), _("check_addr"));
2621	}
2622
2623	/* Make sure we have the canonical name for the client
2624	*/
2625	canonical = sh_ipvx_canonical(claim, numeric, sizeof(numeric));
2626
2627	/* copy canonical name into h_name
2628	*/
2629	if (canonical != NULL)
2630	{
2631	sl_strlcpy(h_name, canonical, MAXHOSTNAMELEN + 1);
2632	SH_FREE(canonical);
2633	}
2634	else
2635	{
2636	sh_error_handle(lookup_err, FIL__, __LINE__, 0, MSG_TCP_RESCLT,
2637	claim);
2638	SL_RETURN ((0), _("check_addr"));
2639	}
2640
2641
2642	/* get canonical name of socket peer
2643	*/
2644	canonical = sh_ipvx_addrtoname(addr_peer);
2645
2646	if (canonical)
2647	{
2648	if (0 == sl_strcmp(canonical, _("localhost")))
2649	sl_strlcpy(h_peer, sh.host.name, MAXHOSTNAMELEN + 1);
2650	else
2651	sl_strlcpy(h_peer, canonical, MAXHOSTNAMELEN + 1);
2652	SH_FREE(canonical);
2653	}
2654	else
2655	{
2656	sh_ipvx_ntoa (tmp_peer_IP, sizeof(tmp_peer_IP), addr_peer);
2657	sh_error_handle(lookup_err, FIL__, __LINE__, 0, MSG_TCP_RESPEER,
2658	claim, tmp_peer_IP);
2659	SL_RETURN ((0), _("check_addr"));
2660	}
2661
2662	sh_ipvx_ntoa (h_peer_IP, sizeof(h_peer_IP), addr_peer);
2663
2664	#if 0
2665	if (S_FALSE == DoReverseLookup)
2666	{
2667	SL_RETURN ((0), _("check_addr"));
2668	}
2669	#endif
2670
2671	/* reverse lookup
2672	*/
2673	if (0 == sh_ipvx_reverse_check_ok (h_peer, ServerPort, addr_peer))
2674	{
2675	sh_ipvx_ntoa (tmp_peer_IP, sizeof(tmp_peer_IP), addr_peer);
2676
2677	sh_error_handle(lookup_err, FIL__, __LINE__, 0, MSG_TCP_LOOKERS,
2678	claim, h_peer, tmp_peer_IP);
2679	SL_RETURN ((0), _("check_addr"));
2680	}
2681
2682	/* Check whether claim and peer are identical
2683	*/
2684
2685	sh_tolower(h_peer); /* Canonical name of what the peer is */
2686	sh_tolower(h_name); /* Canonical name of what the peer claims */
2687
2688	if ((0 == sl_strcmp(h_peer, h_name)) \|\| (0 == sl_strcmp(h_peer_IP, h_name)))
2689	{
2690	SL_RETURN ((0), _("check_addr"));
2691	}
2692	#if !defined(USE_IPVX)
2693	else
2694	{
2695	struct hostent * he = sh_gethostbyname(h_peer);
2696	int i = 0;
2697	int flag = 0;
2698
2699	while (he->h_aliases[i] != NULL)
2700	{
2701	if (0 == sl_strcmp(sh_tolower(he->h_aliases[i]), h_name))
2702	{
2703	flag = 1;
2704	break;
2705	}
2706	++i;
2707	}
2708	if (flag == 0)
2709	sh_error_handle(lookup_err, FIL__, __LINE__, 0, MSG_TCP_LOOKUP,
2710	claim, h_peer);
2711	}
2712	#endif
2713
2714	SL_RETURN ((0), _("check_addr"));
2715	}
2716
2717	static int UseSocketPeer = S_FALSE;
2718
2719	int set_socket_peer (const char * c)
2720	{
2721	return sh_util_flagval(c, &UseSocketPeer);
2722	}
2723
2724
2725	/* -- Search register. --
2726	*/
2727	client_t * search_register(sh_conn_t * conn, int pos)
2728	{
2729	client_t * this_client;
2730	char peer_ip[SH_IP_BUF];
2731	char numerical[SH_IP_BUF];
2732	char peer_name[MAXHOSTNAMELEN+1];
2733	char * search_string;
2734
2735	struct sh_sockaddr peer_addr;
2736	char * canonical;
2737
2738	SL_ENTER(_("search_register"));
2739
2740	if (UseSocketPeer == S_TRUE)
2741	{
2742	memcpy(&peer_addr, &(conn->addr_peer), sizeof(struct sh_sockaddr));
2743	sh_ipvx_ntoa (peer_ip, sizeof(peer_ip), &peer_addr);
2744
2745	/* get canonical name of socket peer
2746	*/
2747	canonical = sh_ipvx_canonical(peer_ip, numerical, sizeof(numerical));
2748
2749	if (canonical != NULL)
2750	{
2751	if (0 == sl_strcmp(canonical, _("localhost")))
2752	sl_strlcpy(peer_name, sh.host.name, MAXHOSTNAMELEN + 1);
2753	else
2754	sl_strlcpy(peer_name, canonical, MAXHOSTNAMELEN + 1);
2755	SH_FREE(canonical);
2756	}
2757
2758	if (0 == sh_ipvx_reverse_check_ok (peer_name, ServerPort, &peer_addr))
2759	{
2760	sl_strlcpy(peer_name, peer_ip, MAXHOSTNAMELEN + 1);
2761	}
2762
2763	search_string = peer_name;
2764	}
2765	else
2766	{
2767	search_string = &(conn->buf[pos]);
2768
2769	if (0 != check_addr (search_string, &(conn->addr_peer)))
2770	{
2771	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_BADCONN,
2772	_("Reverse lookup failed"), search_string);
2773	sh_forward_do_free (conn);
2774	SL_RETURN( NULL, _("search_register"));
2775	}
2776	}
2777
2778	sh_tolower(search_string);
2779
2780	/* ---- search the register -----
2781	*/
2782	this_client = zAVLSearch(all_clients, search_string);
2783
2784	if (this_client == NULL)
2785	{
2786	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_BADCONN,
2787	_("Not in client list"), search_string);
2788	sh_forward_do_free (conn);
2789	SL_RETURN( NULL, _("search_register"));
2790	}
2791	if (this_client->exit_flag == 1)
2792	{
2793	TPT((0, FIL__, __LINE__, _("msg=<this_client->exit_flag == 1>\n")));
2794	this_client->session_key_timer = (time_t) 0;
2795	this_client->session_key[0] = '\0';
2796	this_client->exit_flag = 0;
2797	}
2798	TPT((0, FIL__, __LINE__, _("msg=<search_register: client %s>\n"),
2799	this_client->hostname));
2800	TPT((0, FIL__, __LINE__, _("msg=<search_register: key %s>\n"),
2801	this_client->session_key));
2802	SL_RETURN( this_client, _("search_register"));
2803	}
2804
2805
2806	/************************************************************************
2807	*
2808	* Here we check the message received, and decide on the answer to send
2809	* (if any). The connection is in CONN_PAUSED state, thus we must:
2810	* (i) define the proper reaction
2811	* (ii) reset to CONN_READING or CONN_WRITING or CONN_FREE
2812	* (iii) eventually reset the connection entry
2813	*
2814	*************************************************************************/
2815	static
2816	void check_protocol(sh_conn_t * conn, int state)
2817	{
2818	client_t * this_client;
2819
2820	char * cmd;
2821
2822	char hash[SH_MAXMSGLEN + KEY_LEN + KEY_LEN + 1];
2823	char * buffer;
2824
2825	int clt_sev;
2826	char * ptok;
2827
2828	UINT32 ticks;
2829	size_t len;
2830	int i;
2831	char * test;
2832	char u[5] = "OOOO";
2833
2834	SL_TICKET sfd = -1;
2835	char * read_buf = 0;
2836	char * send_buf;
2837	int bytes;
2838
2839	#ifdef SH_ENCRYPT
2840	int blkfac;
2841	int rem;
2842	int send_bytes;
2843	int err_num;
2844	char expbuf[SH_ERRBUF_SIZE];
2845	#endif
2846
2847
2848	#ifdef USE_SRP_PROTOCOL
2849	char * foo_B;
2850	char * foo_Ss;
2851	#endif
2852	char hashbuf[KEYBUF_SIZE];
2853	char sigbuf[KEYBUF_SIZE];
2854
2855	SL_ENTER(_("check_protocol"));
2856
2857	/* seed / re-seed the PRNG if required
2858	*/
2859	(void) taus_seed();
2860
2861
2862	/* protocols:
2863	* -- (iii) file transfer
2864	* -- (ii) authenticated message transfer
2865	* -- (i) SRP key exchange
2866	*/
2867
2868	/* --------- FILE TRANSFER -----------
2869	*/
2870	if ( (conn->head[0] & SH_PROTO_SRP) == 0 &&
2871	(conn->head[0] & SH_PROTO_BIG) != 0 /* is set */ )
2872	{
2873
2874	if (state == SH_DO_READ) /* finished reading */
2875	{
2876	TPT(( 0, FIL__, __LINE__, _("msg=<File transfer - entry.>\n")));
2877
2878	/* -- Client requests challenge. --
2879	*/
2880	if (0 == check_request_nerr ((char *) &(conn->head[3]), _("HELO")))
2881	{
2882
2883	TPT(( 0, FIL__, __LINE__,
2884	_("msg=<File transfer - HELO (1).>\n")));
2885
2886	if (conn->buf == NULL \|\| sl_strlen(conn->buf) <= KEY_LEN)
2887	{
2888	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_NOCLT);
2889	sh_forward_do_free (conn);
2890	SL_RET0(_("check_protocol"));
2891	}
2892
2893	/* ---- search the register -----
2894	*/
2895
2896	this_client = search_register (conn, KEY_LEN);
2897	if (this_client == NULL)
2898	SL_RET0(_("check_protocol"));
2899
2900	/* ---- force authentication -----
2901	*/
2902
2903	if (this_client->session_key[0] == '\0' \|\|
2904	(time(NULL) - this_client->session_key_timer)
2905	> (time_t) TIMEOUT_KEY )
2906	{
2907	/* fake an auth request and jump there
2908	*/
2909	conn->head[0] = (conn->head[0] \| SH_PROTO_SRP);
2910	conn->head[3] = 'S';
2911	conn->head[4] = 'A';
2912	conn->head[5] = 'L';
2913	conn->head[6] = 'T';
2914	if (flag_err_info == SL_TRUE)
2915	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_FAUTH,
2916	&(conn->buf[KEY_LEN]));
2917	len = sl_strlen(&(conn->buf[KEY_LEN])) + 1;
2918	/* &(conn->buf[KEY_LEN]) is hostname */
2919	/* may overlap, thus only memmove is correct */
2920	memmove(conn->buf, &(conn->buf[KEY_LEN]), len);
2921	this_client->session_key[0] = '\0';
2922	this_client->session_key_timer = (time_t) 1;
2923	goto servInit;
2924	}
2925
2926	/* --- check whether hostname is properly signed ---
2927	*/
2928	if (conn->K != NULL)
2929	{
2930	SH_FREE(conn->K);
2931	conn->K = NULL;
2932	}
2933
2934	/* FIXME
2935	len = sl_strlen(&(conn->buf[KEY_LEN])) + 1;
2936	if (sl_ok_adds(len, KEY_LEN))
2937	len += KEY_LEN;
2938	len = (len < (KEY_LEN+1)) ? (KEY_LEN+1) : len;
2939	*/
2940	conn->K = SH_ALLOC(KEY_LEN+1);
2941
2942	sl_strlcpy (conn->K,
2943	sh_util_siggen(this_client->session_key,
2944	&(conn->buf[KEY_LEN]),
2945	sl_strlen(&(conn->buf[KEY_LEN])),
2946	sigbuf, sizeof(sigbuf)),
2947	KEY_LEN+1);
2948	TPT((0, FIL__, __LINE__, _("msg=<host %s>\n"),
2949	&(conn->buf[KEY_LEN])));
2950	TPT((0, FIL__, __LINE__, _("msg=<ckey %s>\n"),
2951	this_client->session_key));
2952	TPT((0, FIL__, __LINE__, _("msg=<sign %s.>\n"),
2953	sh_util_siggen(this_client->session_key,
2954	&(conn->buf[KEY_LEN]),
2955	sl_strlen(&(conn->buf[KEY_LEN])),
2956	sigbuf, sizeof(sigbuf))));
2957
2958	if (0 != sl_strncmp(conn->K, conn->buf, KEY_LEN))
2959	{
2960	TPT((0, FIL__, __LINE__, _("msg=<clt %s>\n"), conn->buf));
2961	TPT((0, FIL__, __LINE__, _("msg=<srv %s>\n"), conn->K));
2962	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_BADCONN,
2963	_("Signature mismatch"),
2964	&(conn->buf[KEY_LEN]));
2965
2966	this_client->session_key_timer =
2967	time(NULL) - (2*TIMEOUT_KEY);
2968
2969	sh_forward_do_free (conn);
2970	SL_RET0(_("check_protocol"));
2971	}
2972	SH_FREE(conn->K);
2973	conn->K = NULL;
2974
2975	/* --- create and send a nonce ---
2976	*/
2977
2978	conn->client_entry = this_client;
2979	sl_strlcpy (conn->peer, &(conn->buf[KEY_LEN]), SH_MINIBUF+1);
2980
2981	ticks = (UINT32) taus_get ();
2982
2983	if (conn->K != NULL)
2984	{
2985	SH_FREE(conn->K);
2986	conn->K = NULL;
2987	}
2988	conn->K = SH_ALLOC(KEY_LEN+1);
2989	sl_strlcpy (conn->K,
2990	sh_tiger_hash ((char *) &ticks,
2991	TIGER_DATA, sizeof(UINT32),
2992	hashbuf, sizeof(hashbuf)),
2993	KEY_LEN+1);
2994
2995	TPT((0, FIL__, __LINE__, _("msg=<send nonce>\n")));
2996	sh_forward_prep_send (conn, conn->K, KEY_LEN+1, _("NSRV"),
2997	SH_PROTO_BIG);
2998	}
2999
3000	/* --- Client has send a message. Check state and message. ---
3001	*/
3002	else if (0 == check_request_nerr((char *)&(conn->head[3]), _("NCLT")) &&
3003	conn->client_entry != NULL &&
3004	sl_strlen(conn->buf) > KEY_LEN &&
3005	conn->K != NULL)
3006	{
3007
3008	TPT(( 0, FIL__, __LINE__,
3009	_("msg=<File transfer - NCLT (3).>\n")));
3010
3011	/* --- get client nonce and compute hash ---
3012	*/
3013	if (conn->A != NULL)
3014	{
3015	SH_FREE(conn->A);
3016	conn->A = NULL;
3017	}
3018	conn->A = SH_ALLOC(3*KEY_LEN+1);
3019	sl_strlcpy (conn->A, conn->K, KEY_LEN+1);
3020	sl_strlcat(conn->A, conn->buf, /* truncate */
3021	2*KEY_LEN+1);
3022	sl_strlcat(conn->A, conn->client_entry->session_key,
3023	3*KEY_LEN+1);
3024	sl_strlcpy (conn->K, sh_tiger_hash(conn->A,TIGER_DATA,3*KEY_LEN,
3025	hashbuf, sizeof(hashbuf)),
3026	KEY_LEN+1);
3027	SH_FREE(conn->A);
3028	conn->A = NULL;
3029
3030
3031	#ifdef SH_ENCRYPT
3032	if ((conn->client_entry->encf_flag != 0) &&
3033	((conn->head[0] & SH_PROTO_ENC) == 0))
3034	{
3035	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_MISENC,
3036	_("file download"),
3037	#ifdef SH_ENCRYPT_2
3038	_("version2"),
3039	#else
3040	_("version1"),
3041	#endif
3042	_("none"));
3043	if (sl_strlen(conn->buf) > (KEY_LEN + 5)) {
3044	if (sh_tools_hash_vfy(conn->K, conn->buf, KEY_LEN+5)) {
3045	if (conn->buf[KEY_LEN+4] == conn->head[0]) {
3046	/* conn->client_entry->encf_flag = 0 / ; / FIXME */
3047	}
3048	}
3049	}
3050	}
3051	else if ((conn->client_entry->encf_flag != 0) &&
3052	((conn->head[0] & SH_MASK_ENC) !=
3053	conn->client_entry->encf_flag))
3054	{
3055	sh_error_handle(SH_ERR_NOTICE, FIL__, __LINE__, 0,
3056	MSG_TCP_MISENC,
3057	_("file download"),
3058	#ifdef SH_ENCRYPT_2
3059	_("version2"),
3060	#else
3061	_("version1"),
3062	#endif
3063	((conn->head[0] & SH_PROTO_EN2) == SH_PROTO_EN2) ? _("version2") : _("version1")
3064	);
3065	conn->client_entry->encf_flag =
3066	(conn->head[0] & SH_MASK_ENC);
3067	}
3068	#else
3069	if ((conn->head[0] & SH_PROTO_ENC) != 0)
3070	{
3071	sh_error_handle((-1), FIL__, __LINE__, 0,
3072	MSG_TCP_MISENC,
3073	_("file download"),
3074	_("none"),
3075	((conn->head[0] & SH_PROTO_EN2) == SH_PROTO_EN2) ? _("version2") : _("version1"));
3076	}
3077	#endif
3078
3079
3080	/* ---- K = H(NSRV, NCLT, session_key) -------
3081	*/
3082
3083	if (conn->FileName != NULL)
3084	{
3085	SH_FREE(conn->FileName);
3086	conn->FileName = NULL;
3087	}
3088
3089	if (0 == sl_strncmp (_("CONF"), &(conn->buf[KEY_LEN]), 4))
3090	{
3091	strcpy(conn->FileType, _("CONF")); /* known to fit */
3092	conn->FileName = get_client_conf_file(conn->peer,
3093	&(conn->FileLength));
3094	conn->FileSent = 0;
3095	}
3096	else if (0 == sl_strncmp (_("DATA"), &(conn->buf[KEY_LEN]), 4))
3097	{
3098	strcpy(conn->FileType, _("DATA")); /* known to fit */
3099	conn->FileName = get_client_data_file(conn->peer,
3100	&(conn->FileLength));
3101	conn->FileSent = 0;
3102	}
3103	else
3104	{
3105	ptok = sh_util_safe_name(&(conn->buf[KEY_LEN]));
3106	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_FFILE,
3107	conn->peer,
3108	ptok);
3109	SH_FREE(ptok);
3110	status_update (conn->client_entry, CLT_FAILED);
3111	sh_forward_do_free (conn);
3112	}
3113
3114	bytes = -1;
3115
3116	if (conn != NULL && conn->FileName != NULL)
3117	{
3118	sfd = sl_open_read(FIL__, __LINE__,
3119	conn->FileName, SL_YESPRIV);
3120	if (!SL_ISERROR(sfd))
3121	{
3122	read_buf = SH_ALLOC(TRANS_BYTES);
3123	bytes = sl_read (sfd, read_buf, TRANS_BYTES);
3124	sl_close(sfd);
3125	}
3126
3127	else
3128	{
3129	sh_error_handle((-1), FIL__, __LINE__, sfd,
3130	MSG_E_ACCESS,
3131	(long) geteuid(),
3132	conn->FileName);
3133	}
3134	if (bytes >= 0)
3135	{
3136	#ifdef SH_ENCRYPT
3137	/* need to send N * B_SIZ bytes
3138	*/
3139	blkfac = bytes / B_SIZ;
3140	rem = bytes - (blkfac * B_SIZ);
3141	if (rem != 0)
3142	{
3143	memset(&read_buf[bytes], '\n', (B_SIZ-rem));
3144	++blkfac;
3145	send_bytes = blkfac * B_SIZ;
3146	}
3147	else
3148	send_bytes = bytes;
3149
3150	send_buf = hash_me(conn->K, read_buf,
3151	send_bytes);
3152
3153	sh_forward_prep_send_crypt (conn, send_buf,
3154	send_bytes+KEY_LEN,
3155	_("FILE"),
3156	SH_PROTO_BIG\|conn->client_entry->encf_flag);
3157	#else
3158	send_buf = hash_me(conn->K, read_buf, bytes);
3159	sh_forward_prep_send_crypt (conn, send_buf,
3160	bytes+KEY_LEN,
3161	_("FILE"), SH_PROTO_BIG);
3162	#endif
3163	conn->FileSent += bytes;
3164	if (send_buf != NULL)
3165	{
3166	SH_FREE(send_buf);
3167	}
3168	SH_FREE(read_buf);
3169	}
3170	}
3171
3172	if (conn == NULL \|\| conn->FileName == NULL \|\|
3173	SL_ISERROR(sfd) \|\| bytes < 0)
3174	{
3175	sh_error_handle((-1), FIL__, __LINE__, sfd, MSG_TCP_NFILE,
3176	conn->peer,
3177	(conn->FileName == NULL) ?
3178	_("(NULL)") : conn->FileName);
3179	status_update (conn->client_entry, CLT_FAILED);
3180	sh_forward_do_free (conn);
3181	}
3182
3183	}
3184
3185	else if (0 == check_request_nerr((char *)&(conn->head[3]),
3186	_("RECV")) &&
3187	conn->client_entry != NULL &&
3188	conn->K != NULL &&
3189	conn->FileName != NULL)
3190	{
3191
3192	TPT(( 0, FIL__, __LINE__,
3193	_("msg=<File transfer - RCVT (5+).>\n")));
3194
3195	if (conn->FileSent == conn->FileLength)
3196	{
3197	send_buf = hash_me(conn->K, conn->peer,
3198	sl_strlen(conn->peer));
3199	#ifdef SH_ENCRYPT
3200	sh_forward_prep_send_crypt (conn, send_buf,
3201	sl_strlen(conn->peer)+KEY_LEN,
3202	_("EEOT"),
3203	SH_PROTO_BIG\|conn->client_entry->encf_flag);
3204	#else
3205	sh_forward_prep_send_crypt (conn, send_buf,
3206	sl_strlen(conn->peer)+KEY_LEN,
3207	_("EEOT"),
3208	SH_PROTO_BIG);
3209	#endif
3210	SH_FREE(send_buf);
3211	}
3212	else
3213	{
3214	bytes = -1;
3215	sfd = sl_open_read(FIL__, __LINE__,
3216	conn->FileName, SL_YESPRIV);
3217	if (!SL_ISERROR(sfd))
3218	{
3219	read_buf = SH_ALLOC(TRANS_BYTES);
3220	sl_seek (sfd, (off_t) conn->FileSent);
3221	bytes = sl_read (sfd, read_buf, TRANS_BYTES);
3222	sl_close(sfd);
3223	}
3224	else
3225	{
3226	sh_error_handle((-1), FIL__, __LINE__, sfd,
3227	MSG_E_ACCESS,
3228	(long) geteuid(),
3229	conn->FileName);
3230	}
3231	if (bytes >= 0)
3232	{
3233	#ifdef SH_ENCRYPT
3234	/* need to send N * B_SIZ bytes
3235	*/
3236	blkfac = bytes / B_SIZ;
3237	rem = bytes - (blkfac * B_SIZ);
3238	if (rem != 0)
3239	{
3240	memset(&read_buf[bytes], '\n', (B_SIZ-rem));
3241	++blkfac;
3242	send_bytes = blkfac * B_SIZ;
3243	}
3244	else
3245	send_bytes = bytes;
3246
3247	send_buf = hash_me(conn->K, read_buf,
3248	send_bytes);
3249
3250	sh_forward_prep_send_crypt (conn, send_buf,
3251	send_bytes+KEY_LEN,
3252	_("FILE"),
3253	SH_PROTO_BIG\|conn->client_entry->encf_flag);
3254	#else
3255
3256	send_buf = hash_me(conn->K, read_buf, bytes);
3257	sh_forward_prep_send_crypt (conn, send_buf,
3258	bytes+KEY_LEN,
3259	_("FILE"),
3260	SH_PROTO_BIG);
3261	#endif
3262
3263	conn->FileSent += bytes;
3264	SH_FREE(send_buf);
3265	SH_FREE(read_buf);
3266	}
3267	else
3268	{
3269	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_NFILE,
3270	conn->peer,
3271	(conn->FileName == NULL) ?
3272	_("(NULL)") : conn->FileName);
3273	status_update (conn->client_entry, CLT_FAILED);
3274	sh_forward_do_free (conn);
3275	}
3276	}
3277	}
3278
3279
3280	else if (0 == check_request_nerr((char *)&(conn->head[3]),
3281	_("EOTE")) &&
3282	conn->client_entry != NULL)
3283	{
3284
3285	TPT(( 0, FIL__, __LINE__,
3286	_("msg=<File transfer - EOTE (7).>\n")));
3287
3288	if (flag_err_info == SL_TRUE)
3289	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_OKFILE,
3290	conn->peer);
3291
3292	if ((conn->client_entry->status_now != CLT_SUSPEND) &&
3293	(conn->client_entry->status_now != CLT_TOOLONG))
3294	{ status_update (conn->client_entry, CLT_FILE); }
3295	else
3296	{ conn->client_entry->session_key[0] = '\0'; }
3297	conn->client_entry->last_connect = time (NULL);
3298	sh_forward_do_free (conn);
3299	}
3300
3301
3302	/* client does something unexpected
3303	*/
3304	else /* ---- ??? ----- */
3305	{
3306	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_FINV,
3307	1, conn->pass, conn->peer,
3308	'\\', conn->head[3], '\\',conn->head[4],
3309	'\\', conn->head[5], '\\',conn->head[6]);
3310	status_update (conn->client_entry, CLT_FAILED);
3311	sh_forward_do_free (conn);
3312	}
3313	}
3314
3315	else if (state == SH_DO_WRITE) /* finished writing */
3316	{
3317	TPT(( 0, FIL__, __LINE__, _("msg=<File transfer - (wait).>\n")));
3318
3319	/* challenge is sent, now wait for message from client
3320	*/
3321	conn->headcount = 0;
3322	conn->bytecount = 0;
3323	conn->bytes_to_send = 0;
3324	conn->bytes_to_get = 0;
3325	if (conn->buf != NULL)
3326	{
3327	SH_FREE(conn->buf);
3328	conn->buf = NULL;
3329	}
3330	conn->state = CONN_READING;
3331	}
3332	SL_RET0(_("check_protocol"));
3333	}
3334
3335	/* --------- message exchange -----------
3336	*/
3337	if ((conn->head[0] & SH_PROTO_SRP) == 0 &&
3338	(conn->head[0] & SH_PROTO_MSG) != 0 /* is set */ )
3339	{
3340
3341	if (state == SH_DO_READ) /* finished reading */
3342	{
3343
3344	TPT(( 0, FIL__, __LINE__, _("msg=<Message transfer - entry.>\n")));
3345
3346	/* client requests challenge
3347	*/
3348	if (0 == check_request_nerr ((char *)&(conn->head[3]), _("HELO")))
3349	{
3350
3351	TPT(( 0, FIL__, __LINE__,
3352	_("msg=<Message transfer - HELO (1).>\n")));
3353
3354	if (conn->buf == NULL \|\| sl_strlen(conn->buf) <= KEY_LEN )
3355	{
3356	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_NOCLT);
3357	sh_forward_do_free (conn);
3358	SL_RET0(_("check_protocol"));
3359	}
3360
3361	TPT(( 0, FIL__, __LINE__, _("msg=<Rcvt %s.>\n"), conn->buf));
3362
3363	/* ---- search the register -----
3364	*/
3365	this_client = search_register (conn, KEY_LEN);
3366	if (NULL == this_client)
3367	SL_RET0(_("check_protocol"));
3368
3369	/* ---- force authentication -----
3370	*/
3371	if ( (this_client->session_key[0] == '\0') \|\|
3372	((time(NULL)-this_client->session_key_timer)
3373	> (time_t) TIMEOUT_KEY)
3374	)
3375	{
3376
3377	/* fake an auth request and jump there
3378	*/
3379	conn->head[0] = (conn->head[0] \| SH_PROTO_SRP);
3380	conn->head[3] = 'S';
3381	conn->head[4] = 'A';
3382	conn->head[5] = 'L';
3383	conn->head[6] = 'T';
3384	if (flag_err_info == SL_TRUE)
3385	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_FAUTH,
3386	&(conn->buf[KEY_LEN]));
3387	len = sl_strlen(&(conn->buf[KEY_LEN])) + 1;
3388	/* &(conn->buf[KEY_LEN]) is hostname */
3389	/* may overlap, thus only memmove is correct */
3390	memmove(conn->buf, &(conn->buf[KEY_LEN]), len);
3391	this_client->session_key[0] = '\0';
3392	this_client->session_key_timer = (time_t) 1;
3393
3394	goto servInit;
3395	}
3396
3397	/* check whether hostname is properly signed
3398	*/
3399	if (conn->K != NULL)
3400	{
3401	SH_FREE(conn->K);
3402	conn->K = NULL;
3403	}
3404	/* FIXME len = sl_strlen(&(conn->buf[KEY_LEN])) + KEY_LEN + 1; */
3405	conn->K = SH_ALLOC(KEY_LEN + 1);
3406
3407	sl_strlcpy (conn->K,
3408	sh_util_siggen(this_client->session_key,
3409	&(conn->buf[KEY_LEN]),
3410	sl_strlen(&(conn->buf[KEY_LEN])),
3411	sigbuf, sizeof(sigbuf)),
3412	KEY_LEN+1);
3413	TPT((0, FIL__, __LINE__, _("msg=<host %s>\n"),
3414	&(conn->buf[KEY_LEN])));
3415	TPT((0, FIL__, __LINE__, _("msg=<ckey %s>\n"),
3416	this_client->session_key));
3417	TPT((0, FIL__, __LINE__, _("msg=<sign %s>\n"), conn->K));
3418
3419	if (0 != sl_strncmp(conn->K, conn->buf, KEY_LEN))
3420	{
3421	TPT(( 0, FIL__, __LINE__, _("msg=<Rcvt %s>\n"), conn->buf));
3422	TPT(( 0, FIL__, __LINE__, _("msg=<Want %s>\n"), conn->K));
3423	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_BADCONN,
3424	_("Signature mismatch"),
3425	&(conn->buf[KEY_LEN]));
3426
3427	this_client->session_key_timer =
3428	time(NULL) - (2*TIMEOUT_KEY);
3429
3430	sh_forward_do_free (conn);
3431	SL_RET0(_("check_protocol"));
3432	}
3433	SH_FREE(conn->K);
3434	conn->K = NULL;
3435
3436	/* -- create a nonce and send it --
3437	*/
3438
3439	conn->client_entry = this_client;
3440	sl_strlcpy (conn->peer, &(conn->buf[KEY_LEN]), SH_MINIBUF+1);
3441
3442	ticks = (UINT32) taus_get ();
3443
3444	test = (char *) &ticks;
3445	sh_util_cpylong (conn->challenge, test, 4);
3446	conn->challenge[4] = '\0';
3447	for (i = 0; i < 4; ++i)
3448	if (conn->challenge[i] == '\0')
3449	conn->challenge[i] = 0x01;
3450
3451	sh_forward_prep_send (conn, conn->challenge, 5, _("TALK"),
3452	SH_PROTO_MSG);
3453	TPT(( 0, FIL__, __LINE__, _("msg=<Sent %s.>\n"),
3454	hu_trans(conn->challenge)));
3455	}
3456
3457	/* Client has send a message. Check whether we are in proper
3458	* state, and verify message.
3459	*/
3460	else if (0 ==
3461	check_request_nerr((char *)&(conn->head[3]), _("MESG")) &&
3462	conn->client_entry != NULL &&
3463	conn->client_entry->session_key[0] != '\0' &&
3464	(len = sl_strlen(conn->buf) - KEY_LEN) > 0 &&
3465	sl_strlen(conn->challenge) == 4)
3466	{
3467	TPT(( 0, FIL__, __LINE__,
3468	_("msg=<Message transfer - MESG (3).>\n")));
3469
3470	#ifdef SH_ENCRYPT
3471	if (conn->client_entry->encf_flag == 0) {
3472	conn->client_entry->ency_flag = 0;
3473	}
3474	if ((conn->client_entry->ency_flag != 0) &&
3475	((conn->head[0] & SH_PROTO_ENC) == 0))
3476	{
3477	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_MISENC,
3478	_("message transfer"),
3479	#ifdef SH_ENCRYPT_2
3480	_("version2"),
3481	#else
3482	_("version1"),
3483	#endif
3484	_("none"));
3485	/* conn->client_entry->ency_flag = 0; */
3486	}
3487	else if ((conn->client_entry->ency_flag != 0) &&
3488	((conn->head[0] & SH_MASK_ENC) !=
3489	conn->client_entry->ency_flag))
3490	{
3491	sh_error_handle(SH_ERR_NOTICE, FIL__, __LINE__, 0,
3492	MSG_TCP_MISENC,
3493	_("message transfer"),
3494	#ifdef SH_ENCRYPT_2
3495	_("version2"),
3496	#else
3497	_("version1"),
3498	#endif
3499	((conn->head[0] & SH_PROTO_EN2) == SH_PROTO_EN2) ? _("version2") : _("version1"));
3500	conn->client_entry->ency_flag =
3501	(conn->head[0] & SH_MASK_ENC);
3502	}
3503	#else
3504	if ((conn->head[0] & SH_PROTO_ENC) != 0)
3505	{
3506	sh_error_handle((-1), FIL__, __LINE__, 0,
3507	MSG_TCP_MISENC,
3508	_("message transfer"),
3509	_("none"),
3510	((conn->head[0] & SH_PROTO_EN2) == SH_PROTO_EN2) ? _("version2") : _("version1"));
3511	}
3512	#endif
3513
3514	TPT(( 0, FIL__, __LINE__, _("msg=<Rcvt %s.>\n"), conn->buf));
3515	/* get hash from message end, truncate message
3516	*/
3517	sl_strlcpy(hash, &(conn->buf[len]), KEY_LEN+1);
3518	conn->buf[len] = '\0';
3519
3520	/* verify hash
3521	*/
3522	buffer = sh_util_strconcat(conn->buf, conn->challenge, NULL);
3523	i = sl_strncmp(hash,
3524	sh_util_siggen(conn->client_entry->session_key,
3525	buffer,
3526	sl_strlen(buffer),
3527	sigbuf, sizeof(sigbuf)),
3528	KEY_LEN);
3529	TPT((0, FIL__, __LINE__, _("msg=<sign %s.>\n"),
3530	sh_util_siggen(conn->client_entry->session_key,
3531	buffer,
3532	sl_strlen(buffer),
3533	sigbuf, sizeof(sigbuf))));
3534
3535
3536	if (0 != i)
3537	{
3538	TPT((0, FIL__, __LINE__, _("msg=<update status>\n")));
3539	status_update (conn->client_entry, CLT_FAILED);
3540	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_BADCONN,
3541	_("Msg signature mismatch"), conn->peer);
3542	conn->client_entry->session_key_timer =
3543	time(NULL) - (2*TIMEOUT_KEY);
3544	sh_forward_do_free (conn);
3545	SL_RET0(_("check_protocol"));
3546	}
3547	else
3548	{
3549	conn->client_entry->last_connect = time (NULL);
3550
3551	if (NULL != sl_strstr(conn->buf, _("EXIT")))
3552	{
3553	TPT((0, FIL__, __LINE__, _("msg=<update status>\n")));
3554	conn->client_entry->exit_flag = 1;
3555	status_update (conn->client_entry, CLT_EXITED);
3556	}
3557	else if (NULL != sl_strstr(conn->buf, _("PANIC")))
3558	{
3559	TPT((0, FIL__, __LINE__, _("msg=<update status>\n")));
3560	status_update (conn->client_entry, CLT_PANIC);
3561	}
3562	else if (NULL != sl_strstr(conn->buf, _("SUSPEND")))
3563	{
3564	TPT((0, FIL__, __LINE__, _("msg=<update status>\n")));
3565	status_update (conn->client_entry, CLT_SUSPEND);
3566	}
3567	else if (NULL != sl_strstr(conn->buf, _("POLICY")))
3568	{
3569	TPT((0, FIL__, __LINE__, _("msg=<update status>\n")));
3570	status_update (conn->client_entry, CLT_POLICY);
3571	}
3572	else if (NULL != sl_strstr(conn->buf,
3573	_("File check completed")))
3574	{
3575	TPT((0, FIL__, __LINE__, _("msg=<update status>\n")));
3576	status_update (conn->client_entry, CLT_CHECK);
3577	}
3578	else if (NULL != sl_strstr(conn->buf, _("START")))
3579	{
3580	TPT((0, FIL__, __LINE__, _("msg=<update status>\n")));
3581	sh_socket_add2reload (conn->client_entry->hostname);
3582	if (conn->client_entry->status_now == CLT_SUSPEND) {
3583	status_update (conn->client_entry, CLT_ILLEGAL);
3584	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_ILL,
3585	conn->peer);
3586	}
3587	else
3588	status_update (conn->client_entry, CLT_STARTED);
3589	}
3590	else
3591	{
3592	TPT((0, FIL__, __LINE__, _("msg=<update status>\n")));
3593	if (NULL != sl_strstr(conn->buf,
3594	_("Runtime configuration reloaded")))
3595	{
3596	sh_socket_add2reload (conn->client_entry->hostname);
3597	}
3598	status_update (conn->client_entry, CLT_MSG);
3599	}
3600
3601	TPT((0, FIL__, __LINE__, _("msg=<status updated>\n")));
3602	clt_sev = atoi(conn->buf);
3603	clt_class = (-1);
3604	ptok = strchr(conn->buf, '?');
3605	if (ptok != NULL)
3606	{
3607	++ptok;
3608	if (ptok != NULL && sh.flag.client_class == S_TRUE)
3609	clt_class = atoi(ptok); /* is a global */
3610	ptok = strchr(ptok, '?');
3611	if (ptok != NULL)
3612	++ptok;
3613	}
3614	if (sh.flag.client_severity == S_FALSE)
3615	clt_sev = (-1);
3616
3617	/* here we expect an xml formatted message, thus we don't
3618	escape xml special chars (flag == 0) */
3619	ptok =
3620	sh_tools_safe_name ((ptok!=NULL) ? ptok : conn->buf, 0);
3621
3622	/* push client name to error routine
3623	*/
3624	#if defined(SH_WITH_SERVER) && defined(HAVE_LIBPRELUDE)
3625	{
3626	char peer_ip[SH_IP_BUF];
3627	sh_ipvx_ntoa(peer_ip, sizeof(peer_ip), &(conn->addr_peer));
3628	sh_error_set_peer_ip( peer_ip );
3629	}
3630	#endif
3631	sh_error_set_peer(sh_strip_domain (conn->peer));
3632	sh_error_handle(clt_sev, FIL__, __LINE__, 0, MSG_TCP_MSG,
3633	sh_strip_domain (conn->peer),
3634	ptok);
3635	sh_error_set_peer(NULL);
3636	#if defined(SH_WITH_SERVER) && defined(HAVE_LIBPRELUDE)
3637	sh_error_set_peer_ip(NULL);
3638	#endif
3639
3640	TPT((0, FIL__, __LINE__, _("msg=<%s>\n"), ptok));
3641	SH_FREE(ptok);
3642	clt_class = (-1);
3643	}
3644	memset(buffer, '\0', sl_strlen(buffer));
3645	SH_FREE(buffer);
3646
3647	/* SERVER CONF SEND
3648	*/
3649	buffer = sh_util_strconcat(conn->buf,
3650	conn->challenge,
3651	NULL);
3652	sl_strlcpy(hash,
3653	sh_util_siggen ( conn->client_entry->session_key,
3654	buffer,
3655	sl_strlen(buffer),
3656	sigbuf, sizeof(sigbuf)),
3657	KEY_LEN+1);
3658
3659	/* --- SERVER CMD --- */
3660	cmd = sh_socket_check (conn->peer);
3661
3662	if (cmd != NULL)
3663	{
3664	/* max cmd size is SH_MAXMSGLEN bytes
3665	*/
3666	sl_strlcpy(&hash[KEY_LEN], cmd, SH_MAXMSGLEN);
3667	sl_strlcat(&hash[KEY_LEN],
3668	sh_util_siggen ( conn->client_entry->session_key,
3669	&hash[KEY_LEN],
3670	sl_strlen(&hash[KEY_LEN]),
3671	sigbuf, sizeof(sigbuf)),
3672	SH_MAXMSGLEN+KEY_LEN+1);
3673
3674	TPT((0, FIL__, __LINE__, _("CONF SEND <0> <%s>\n"),
3675	&hash[KEY_LEN]));
3676
3677	} else {
3678
3679	TPT((0, FIL__, __LINE__, _("CONF SEND <0> <[NULL]>\n")));
3680
3681	}
3682	/* --- SERVER CMD END --- */
3683
3684	TPT((0, FIL__, __LINE__, _("msg=<sign %s.>\n"),
3685	sh_util_siggen(conn->client_entry->session_key,
3686	buffer,
3687	sl_strlen(buffer),
3688	sigbuf, sizeof(sigbuf))));
3689
3690	#ifdef SH_ENCRYPT
3691	sh_forward_prep_send_crypt (conn, hash,
3692	sl_strlen(hash) /* KEY_LEN */,
3693	_("CONF"),
3694	SH_PROTO_MSG\|SH_PROTO_END\|conn->client_entry->ency_flag);
3695	#else
3696	sh_forward_prep_send_crypt (conn, hash,
3697	sl_strlen(hash) /* KEY_LEN */,
3698	_("CONF"),
3699	SH_PROTO_MSG\|SH_PROTO_END);
3700	#endif
3701
3702	memset(buffer, '\0', sl_strlen(buffer));
3703	SH_FREE(buffer);
3704
3705	/* sh_forward_do_free (conn); */
3706	}
3707
3708	/* client does something unexpected
3709	*/
3710	else /* ---- ??? ----- */
3711	{
3712	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_FINV,
3713	2, conn->pass, conn->peer,
3714	'\\', conn->head[3], '\\',conn->head[4],
3715	'\\', conn->head[5], '\\',conn->head[6]);
3716	status_update (conn->client_entry, CLT_FAILED);
3717	conn->client_entry->session_key_timer =
3718	time(NULL) - (2*TIMEOUT_KEY);
3719	sh_forward_do_free (conn);
3720	}
3721	}
3722	else if (state == SH_DO_WRITE) /* finished writing */
3723	{
3724	if (0 != (conn->head[0] & SH_PROTO_END))
3725	{
3726	if (flag_err_debug == SL_TRUE)
3727	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_OKMSG,
3728	sh_strip_domain (conn->peer));
3729	sh_forward_do_free (conn);
3730	SL_RET0(_("check_protocol"));
3731	}
3732
3733	TPT(( 0, FIL__, __LINE__, _("msg=<Msg transfer - (wait).>\n")));
3734
3735	/* challenge is sent, now wait for message from client
3736	*/
3737	conn->headcount = 0;
3738	conn->bytecount = 0;
3739	conn->bytes_to_send = 0;
3740	conn->bytes_to_get = 0;
3741	if (conn->buf != NULL)
3742	{
3743	SH_FREE(conn->buf);
3744	conn->buf = NULL;
3745	}
3746	conn->state = CONN_READING;
3747	}
3748	TPT((0, FIL__, __LINE__, _("msg=<return>\n") ));
3749	SL_RET0(_("check_protocol"));
3750	}
3751
3752	/* --------- authentication -----------
3753	*/
3754
3755	/* entry point for jump from message forward if session key must
3756	* be re-initialized
3757	*/
3758	servInit:
3759
3760	if ( (conn->head[0] & SH_PROTO_SRP) != 0 /* is set */ )
3761	{
3762
3763	#ifndef USE_SRP_PROTOCOL
3764
3765	if (state == SH_DO_READ) /* finished reading */
3766	{
3767	TPT((0, FIL__, __LINE__, _("msg=<Authentication - entry.>\n")));
3768
3769	/* first pass -- client request salt
3770	*/
3771	if (conn->pass == 1)
3772	{
3773
3774	TPT((0, FIL__, __LINE__,
3775	_("msg=<Authentication - SALT (1).>\n")));
3776
3777	if (conn->buf == NULL \|\| sl_strlen(conn->buf) == 0)
3778	{
3779	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_NOCLT);
3780	sh_forward_do_free (conn);
3781	SL_RET0(_("check_protocol"));
3782	}
3783
3784
3785	/* search the register
3786	*/
3787
3788	this_client = search_register (conn, 0);
3789	if (NULL == this_client)
3790	SL_RET0(_("check_protocol"));
3791
3792
3793	conn->client_entry = this_client;
3794	sl_strlcpy (conn->peer, conn->buf, SH_MINIBUF+1);
3795
3796	if (0 != check_request_s((char *)&(conn->head[3]),
3797	_("SALT"),conn->peer))
3798	{
3799	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_BADCONN,
3800	_("No salt requested"), conn->peer);
3801	status_update (conn->client_entry, CLT_FAILED);
3802	conn->client_entry->session_key_timer =
3803	time(NULL) - (2*TIMEOUT_KEY);
3804	sh_forward_do_free (conn);
3805	SL_RET0(_("check_protocol"));
3806	}
3807
3808
3809	/* -- create server nounce v --
3810	*/
3811	ticks = (UINT32) taus_get ();
3812
3813	if (conn->A != NULL)
3814	{
3815	SH_FREE(conn->A);
3816	conn->A = NULL;
3817	}
3818	conn->A = SH_ALLOC(KEY_LEN+1);
3819
3820	sl_strlcpy(conn->A,
3821	sh_tiger_hash((char *) &ticks,
3822	TIGER_DATA, sizeof(UINT32),
3823	hashbuf, sizeof(hashbuf)),
3824	KEY_LEN+1);
3825	u[0] = 'I'; u[1] = 'N'; u[2] = 'I'; u[3] = 'T'; u[4] = '\0';
3826
3827	if (conn->M1 != NULL)
3828	{
3829	SH_FREE(conn->M1);
3830	conn->M1 = NULL;
3831	}
3832	conn->M1 = SH_ALLOC(2*KEY_LEN+1);
3833
3834	/* compute hash key H(v(server), P)v(server)
3835	*/
3836	sh_passwd (conn->A, conn->client_entry->verifier,
3837	NULL, conn->M1);
3838
3839	sl_strlcat(conn->M1, conn->A, 2*KEY_LEN+1);
3840
3841
3842	/* --- send H(v(server), P)v(server) ----
3843	*/
3844	sh_forward_prep_send (conn,
3845	conn->M1,
3846	sl_strlen(conn->M1),
3847	u,
3848	(conn->head[0]\|SH_PROTO_SRP));
3849
3850	SH_FREE(conn->M1);
3851	conn->M1 = NULL;
3852	}
3853
3854	/* client -- third pass
3855	* Message is H(H(u,v),P)u
3856	*
3857	* A := v, verifier := H(password),
3858	*/
3859	else if (conn->pass == 3 &&
3860	conn->client_entry != NULL)
3861	{
3862
3863	TPT((0, FIL__, __LINE__,
3864	_("msg=<Authentication - PASS (3).>\n")));
3865
3866	if (0 != check_request_s((char *) &(conn->head[3]), _("PASS"),
3867	conn->peer) \|\|
3868	sl_strlen(conn->buf) <= KEY_LEN \|\|
3869	conn->A == NULL)
3870	{
3871	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_BADCONN,
3872	_("Invalid client request"), conn->peer);
3873	status_update (conn->client_entry, CLT_FAILED);
3874	conn->client_entry->session_key_timer =
3875	time(NULL) - (2*TIMEOUT_KEY);
3876	sh_forward_do_free (conn);
3877	SL_RET0(_("check_protocol"));
3878	}
3879
3880	/* store random nonce u from client
3881	*/
3882	if (conn->K != NULL)
3883	{
3884	SH_FREE(conn->K);
3885	conn->K = NULL;
3886	}
3887	conn->K = SH_ALLOC(KEY_LEN+1);
3888	sl_strlcpy(conn->K, &(conn->buf[KEY_LEN]), KEY_LEN+1);
3889
3890	/* verify random nonce u from client
3891	*/
3892	if (conn->M1 != NULL)
3893	{
3894	SH_FREE(conn->M1);
3895	conn->M1 = NULL;
3896	}
3897	conn->M1 = sh_util_strconcat(conn->K, conn->A, NULL);
3898
3899	TPT((0, FIL__, __LINE__, _("msg=<c/r: K = %s>\n"), conn->K));
3900	TPT((0, FIL__, __LINE__, _("msg=<c/r: A = %s>\n"), conn->A));
3901	TPT((0, FIL__, __LINE__, _("msg=<c/r: M = %s>\n"), conn->M1));
3902
3903	sl_strlcpy(hash, sh_tiger_hash (conn->M1,
3904	TIGER_DATA,
3905	sl_strlen(conn->M1),
3906	hashbuf, sizeof(hashbuf)),
3907	KEY_LEN+1);
3908	sh_passwd (hash, conn->client_entry->verifier, NULL, conn->M1);
3909
3910	TPT((0, FIL__, __LINE__, _("msg=<c/r: H = %s>\n"), hash));
3911	TPT((0, FIL__, __LINE__, _("msg=<c/r: P = %s>\n"), conn->M1));
3912
3913	if ( 0 != sl_strncmp(conn->M1, conn->buf, KEY_LEN))
3914	{
3915	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_BADCONN,
3916	_("Session key mismatch"), conn->peer);
3917	status_update (conn->client_entry, CLT_FAILED);
3918	conn->client_entry->session_key_timer =
3919	time(NULL) - (2*TIMEOUT_KEY);
3920	sh_forward_do_free (conn);
3921	SL_RET0(_("check_protocol"));
3922	}
3923
3924
3925	/* ---- compute hash key H(v, P, u) ----
3926	*/
3927
3928	sh_passwd (conn->A, conn->client_entry->verifier, conn->K,
3929	conn->M1);
3930
3931	sl_strlcpy(conn->client_entry->session_key,
3932	conn->M1, KEY_LEN+1);
3933	TPT((0, FIL__, __LINE__, _("msg=<c/r: Key = %s>\n"),
3934	conn->client_entry->session_key));
3935
3936	#ifdef SH_ENCRYPT
3937	err_num = makeKey(&(conn->client_entry->keyInstE),
3938	DIR_ENCRYPT, 192,
3939	conn->client_entry->session_key);
3940	if (err_num < 0)
3941	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
3942	errorExplain(err_num, expbuf, sizeof(expbuf)),
3943	_("check_protocol: makeKey"));
3944	err_num = makeKey(&(conn->client_entry->keyInstD),
3945	DIR_DECRYPT, 192,
3946	conn->client_entry->session_key);
3947	if (err_num < 0)
3948	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
3949	errorExplain(err_num, expbuf, sizeof(expbuf)),
3950	_("check_protocol: makeKey"));
3951	#endif
3952
3953	if (conn->K != NULL) SH_FREE (conn->K);
3954	conn->K = NULL;
3955	if (conn->A != NULL) SH_FREE (conn->A);
3956	conn->A = NULL;
3957	if (conn->M1 != NULL) SH_FREE (conn->M1);
3958	conn->M1 = NULL;
3959
3960	/* if (conn->client_entry->status_now == CLT_STARTED */
3961	if (((conn->client_entry->status_now != CLT_INACTIVE) &&
3962	(conn->client_entry->status_now != CLT_EXITED) &&
3963	(conn->client_entry->status_now != CLT_SUSPEND))
3964	&& conn->client_entry->session_key_timer > (time_t) 1)
3965	{
3966	status_update (conn->client_entry, CLT_ILLEGAL);
3967	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_ILL,
3968	conn->peer);
3969	}
3970	else if (conn->client_entry->session_key_timer == (time_t) 0)
3971	{
3972	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_NEW,
3973	conn->peer);
3974	if (conn->client_entry->status_now != CLT_SUSPEND)
3975	status_update (conn->client_entry, CLT_STARTED);
3976	}
3977
3978	conn->client_entry->session_key_timer = time (NULL);
3979	conn->client_entry->last_connect = time (NULL);
3980
3981	/* put in read state
3982	*/
3983	sh_forward_prep_send (conn,
3984	_("AUTH"),
3985	5,
3986	_("AUTH"),
3987	(conn->head[0]\|SH_PROTO_SRP));
3988
3989	}
3990	else
3991	{
3992	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_FINV,
3993	3, conn->pass, conn->peer,
3994	'\\', conn->head[3], '\\', conn->head[4],
3995	'\\', conn->head[5], '\\', conn->head[6]);
3996	sh_forward_do_free (conn);
3997	}
3998	}
3999
4000	#else
4001	/* use SRP */
4002
4003
4004	if (state == SH_DO_READ) /* finished reading */
4005	{
4006
4007	TPT((0, FIL__, __LINE__, _("msg=<Authentication - entry.>\n")));
4008
4009	/* first pass -- client request salt
4010	*/
4011	if (conn->pass == 1)
4012	{
4013	TPT((0, FIL__, __LINE__,
4014	_("msg=<Authentication - SALT (1).>\n")));
4015
4016	if (conn->buf == NULL)
4017	{
4018	sh_error_handle( (-1), FIL__, __LINE__, 0, MSG_TCP_NOCLT);
4019	sh_forward_do_free (conn);
4020	SL_RET0(_("check_protocol"));
4021	}
4022
4023	/* search the register
4024	*/
4025	this_client = search_register(conn, 0);
4026	if (NULL == this_client)
4027	SL_RET0(_("check_protocol"));
4028
4029	conn->client_entry = this_client;
4030	sl_strlcpy (conn->peer, conn->buf, SH_MINIBUF+1);
4031
4032	if (0 != check_request_s((char *)&(conn->head[3]), _("SALT"),
4033	conn->peer))
4034	{
4035	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_BADCONN,
4036	_("No salt requested"), conn->peer);
4037	status_update (conn->client_entry, CLT_FAILED);
4038	conn->client_entry->session_key_timer =
4039	time(NULL) - (2*TIMEOUT_KEY);
4040	sh_forward_do_free (conn);
4041	SL_RET0(_("check_protocol"));
4042	}
4043
4044
4045	u[0] = 'I'; u[1] = 'N'; u[2] = 'I'; u[3] = 'T'; u[4] = '\0';
4046
4047	sh_forward_prep_send (conn,
4048	conn->client_entry->salt,
4049	sl_strlen(conn->client_entry->salt),
4050	u,
4051	(conn->head[0]\|SH_PROTO_SRP));
4052	}
4053
4054	/* client has sent A -- third pass
4055	*/
4056	else if (conn->pass == 3 &&
4057	conn->client_entry != NULL)
4058	{
4059
4060	TPT((0, FIL__, __LINE__,
4061	_("msg=<Authentication - PC01 (3).>\n")));
4062
4063	if (0 != check_request_s((char *)&(conn->head[3]),_("PC01"),conn->peer)\|\|
4064	conn->buf == NULL
4065	)
4066	{
4067	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_BADCONN,
4068	_("Invalid client request"), conn->peer);
4069	status_update (conn->client_entry, CLT_FAILED);
4070	conn->client_entry->session_key_timer =
4071	time(NULL) - (2*TIMEOUT_KEY);
4072	sh_forward_do_free (conn);
4073	SL_RET0(_("check_protocol"));
4074	}
4075
4076	if (0 != sh_srp_init())
4077	{
4078	status_update (conn->client_entry, CLT_FAILED);
4079	sh_error_handle(SH_ERR_SEVERE, FIL__, __LINE__, 0,
4080	MSG_TCP_EBGN);
4081	sh_forward_do_free (conn);
4082	SL_RET0(_("check_protocol"));
4083	}
4084
4085
4086	/* check A, only send B if correct
4087	*/
4088	if ( sl_strlen(conn->buf) < SH_BUFSIZE &&
4089	0 == sh_srp_check_zero (conn->buf) )
4090	{
4091	len = sl_strlen(conn->buf)+1;
4092
4093	if (conn->A != NULL)
4094	{
4095	SH_FREE(conn->A);
4096	conn->A = NULL;
4097	}
4098	conn->A = SH_ALLOC(len);
4099	sl_strlcpy (conn->A, conn->buf, len);
4100
4101	/*
4102	* compute B
4103	*/
4104	if (0 != sh_srp_make_a ()) /* b random number */
4105	{
4106	status_update (conn->client_entry, CLT_FAILED);
4107
4108	sh_error_handle(SH_ERR_SEVERE, FIL__, __LINE__, 0,
4109	MSG_TCP_EBGN);
4110	sh_srp_exit();
4111	sh_forward_do_free (conn);
4112	SL_RET0(_("check_protocol"));
4113	}
4114
4115	foo_B = sh_srp_B /* B = v + g^b */
4116	(conn->client_entry->verifier);
4117
4118	if (foo_B == NULL)
4119	{
4120	status_update (conn->client_entry, CLT_FAILED);
4121
4122	sh_error_handle(SH_ERR_SEVERE, FIL__, __LINE__, 0,
4123	MSG_TCP_EBGN);
4124	sh_srp_exit();
4125	sh_forward_do_free (conn);
4126	SL_RET0(_("check_protocol"));
4127	}
4128
4129	TPT((0, FIL__, __LINE__, _("msg=<srp: A = %s>\n"), conn->A));
4130	TPT((0, FIL__, __LINE__, _("msg=<srp: B = %s>\n"), foo_B));
4131
4132	/*
4133	* create nonce u
4134	*/
4135	ticks = (UINT32) taus_get ();
4136
4137	test = (char *) &ticks;
4138	sh_util_cpylong (u, test, 4); /* u nounce */
4139	u[4] = '\0';
4140	sl_strlcpy(conn->challenge,
4141	sh_tiger_hash(u, TIGER_DATA, 4, hashbuf, sizeof(hashbuf)),
4142	SH_CHALLENGE_SIZE);
4143
4144	TPT((0, FIL__, __LINE__, _("msg=<srp: u = %03o-%03o-%03o-%03o>\n"), u[0], u[1], u[2], u[3]));
4145	TPT((0, FIL__, __LINE__, _("msg=<srp: U = %s>\n"),
4146	conn->challenge));
4147
4148	/*
4149	* compute the session key K and M1 = Hash(A,B,K)
4150	*/
4151	foo_Ss = sh_srp_S_s (conn->challenge,
4152	conn->A,
4153	conn->client_entry->verifier);
4154
4155	if (foo_Ss == NULL \|\| 0 != sh_srp_check_zero (foo_Ss))
4156	{
4157	status_update (conn->client_entry, CLT_FAILED);
4158
4159	sh_error_handle(SH_ERR_SEVERE, FIL__, __LINE__, 0,
4160	MSG_TCP_EBGN);
4161	sh_srp_exit();
4162	sh_forward_do_free (conn);
4163	SL_RET0(_("check_protocol"));
4164	}
4165
4166	if (conn->K != NULL)
4167	{
4168	SH_FREE(conn->K);
4169	conn->K = NULL;
4170	}
4171	conn->K = SH_ALLOC(KEY_LEN+1);
4172	sl_strlcpy(conn->K,
4173	sh_tiger_hash(foo_Ss, TIGER_DATA,
4174	sl_strlen(foo_Ss),
4175	hashbuf, sizeof(hashbuf)),
4176	KEY_LEN+1);
4177
4178	if (conn->M1 != NULL)
4179	{
4180	SH_FREE(conn->M1);
4181	conn->M1 = NULL;
4182	}
4183	conn->M1 = SH_ALLOC(KEY_LEN+1);
4184	sh_srp_M (conn->A, foo_B, conn->K, conn->M1, KEY_LEN+1);
4185
4186	TPT((0, FIL__, __LINE__, _("msg=<srp:Ss = %s>\n"), foo_Ss));
4187	TPT((0, FIL__, __LINE__, _("msg=<srp: K = %s>\n"), conn->K));
4188	TPT((0, FIL__, __LINE__, _("msg=<srp:M1 = %s>\n"),conn->M1));
4189
4190	/*
4191	* send B
4192	*/
4193	sh_forward_prep_send (conn,
4194	foo_B,
4195	sl_strlen(foo_B)+1,
4196	u,
4197	(conn->head[0]\|SH_PROTO_SRP));
4198	if (foo_Ss != NULL)
4199	{
4200	SH_FREE(foo_Ss);
4201	foo_Ss = NULL;
4202	}
4203	if (foo_B != NULL)
4204	{
4205	SH_FREE(foo_B);
4206	foo_B = NULL;
4207	}
4208	}
4209	else
4210	{
4211	status_update (conn->client_entry, CLT_FAILED);
4212
4213	sh_error_handle(SH_ERR_SEVERE, FIL__, __LINE__, 0,
4214	MSG_TCP_EZERO);
4215	sh_forward_do_free (conn);
4216	}
4217
4218	sh_srp_exit();
4219	}
4220
4221	/* client has sent M1 -- fifth pass
4222	*/
4223	else if (conn->pass == 5 &&
4224	conn->client_entry != NULL)
4225	{
4226	TPT((0, FIL__, __LINE__,
4227	_("msg=<Authentication - PC02 (5).>\n")));
4228
4229	/* check that the state is valid
4230	*/
4231	if (0 != check_request_s((char *)&(conn->head[3]), _("PC02"),
4232	conn->peer) \|\|
4233	conn->A == NULL \|\| conn->K == NULL \|\| conn->M1 == NULL)
4234	{
4235	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_BADCONN,
4236	_("Invalid client request"), conn->peer);
4237	status_update (conn->client_entry, CLT_FAILED);
4238	conn->client_entry->session_key_timer =
4239	time(NULL) - (2*TIMEOUT_KEY);
4240	sh_forward_do_free (conn);
4241	SL_RET0(_("check_protocol"));
4242	}
4243
4244	/* ------ verify M1 = H(A, B, K) -------
4245	* ----- send M2 = H(A, M1, K) -------
4246	*/
4247	if (conn->buf != NULL &&
4248	sl_strncmp(conn->buf, conn->M1, KEY_LEN) == 0)
4249	{
4250	/*
4251	* send M2
4252	*/
4253	char M_buf[KEY_LEN+1];
4254	sh_forward_prep_send (conn,
4255	sh_srp_M (conn->A, conn->M1, conn->K,
4256	M_buf, sizeof(M_buf)),
4257	KEY_LEN+1,
4258	_("PARP"),
4259	(conn->head[0]\|SH_PROTO_SRP));
4260
4261	if (conn->A != NULL) SH_FREE(conn->A); conn->A = NULL;
4262	if (conn->M1 != NULL) SH_FREE(conn->M1); conn->M1 = NULL;
4263	sl_strlcpy(conn->client_entry->session_key,
4264	conn->K, KEY_LEN+1);
4265	TPT((0, FIL__, __LINE__, _("msg=<key %s>\n"),
4266	conn->client_entry->session_key));
4267
4268	#ifdef SH_ENCRYPT
4269	err_num = makeKey(&(conn->client_entry->keyInstE),
4270	DIR_ENCRYPT, 192,
4271	conn->client_entry->session_key);
4272	if (err_num < 0)
4273	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
4274	errorExplain(err_num, expbuf, sizeof(expbuf)),
4275	_("sh_forward_prep_send_int: makeKey"));
4276	err_num = makeKey(&(conn->client_entry->keyInstD),
4277	DIR_DECRYPT, 192,
4278	conn->client_entry->session_key);
4279	if (err_num < 0)
4280	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
4281	errorExplain(err_num, expbuf, sizeof(expbuf)),
4282	_("sh_forward_prep_send_int: makeKey"));
4283	#endif
4284
4285	if (conn->K != NULL) SH_FREE(conn->K); conn->K = NULL;
4286
4287	conn->client_entry->last_connect = time (NULL);
4288
4289	if (((conn->client_entry->status_now != CLT_INACTIVE) &&
4290	(conn->client_entry->status_now != CLT_EXITED) &&
4291	(conn->client_entry->status_now != CLT_SUSPEND))
4292	&& conn->client_entry->session_key_timer > (time_t) 1)
4293	{
4294	status_update (conn->client_entry, CLT_ILLEGAL);
4295
4296	sh_error_handle((-1), FIL__, __LINE__, 0,
4297	MSG_TCP_ILL,
4298	conn->peer);
4299	}
4300	else if (conn->client_entry->session_key_timer == (time_t) 0)
4301	{
4302	sh_error_handle((-1), FIL__, __LINE__, 0,
4303	MSG_TCP_NEW,
4304	conn->peer);
4305	if (conn->client_entry->status_now != CLT_SUSPEND)
4306	status_update (conn->client_entry, CLT_STARTED);
4307	}
4308	conn->client_entry->session_key_timer = time (NULL);
4309
4310	}
4311	else
4312	{
4313	status_update (conn->client_entry, CLT_FAILED);
4314	conn->client_entry->session_key_timer =
4315	time(NULL) - (2*TIMEOUT_KEY);
4316
4317	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_BADCONN,
4318	_("Session key mismatch"), conn->peer);
4319	sh_forward_do_free (conn);
4320	}
4321	}
4322
4323	else
4324	{
4325	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_FINV,
4326	4, conn->pass, conn->peer,
4327	'\\', conn->head[3], '\\', conn->head[4],
4328	'\\', conn->head[5], '\\', conn->head[6]);
4329	sh_forward_do_free (conn);
4330	}
4331	}
4332
4333	#endif
4334
4335	else if (state == SH_DO_WRITE) /* finished writing */
4336	{
4337	TPT((0, FIL__, __LINE__, _("msg=<Authentication -- (wait).>\n")));
4338
4339	conn->headcount = 0;
4340	conn->bytecount = 0;
4341	conn->bytes_to_send = 0;
4342	conn->bytes_to_get = 0;
4343	if (conn->buf != NULL)
4344	{
4345	SH_FREE(conn->buf);
4346	conn->buf = NULL;
4347	}
4348	conn->state = CONN_READING;
4349	}
4350	}
4351	SL_RET0(_("check_protocol"));
4352	}
4353
4354
4355	/***********************************************************
4356	*
4357	* SERVER RECEIVE FUNCTION
4358	*
4359	***********************************************************
4360	*/
4361	int sh_forward_do_read (sh_conn_t * conn)
4362	{
4363	unsigned long byteread; /* bytes read */
4364
4365	#ifdef SH_ENCRYPT
4366
4367	unsigned long blkfac = 0;
4368	/* unsigned long length2; */
4369	char * p = NULL, * q = NULL;
4370	RIJ_BYTE inBlock[B_SIZ];
4371	RIJ_BYTE outBlock[B_SIZ];
4372	unsigned int j;
4373	cipherInstance cipherInst;
4374	int err_num;
4375	char expbuf[SH_ERRBUF_SIZE];
4376	#endif
4377
4378	SL_ENTER(_("sh_forward_do_read"));
4379
4380	if (conn->state == CONN_SENDING)
4381	{
4382	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_SYNC,
4383	conn->peer);
4384	SL_RETURN( (-1), _("sh_forward_do_read"));
4385	}
4386
4387	if (conn->headcount < SH_HEADER_SIZE)
4388	{
4389	conn->bytes_to_get = SH_HEADER_SIZE - conn->headcount;
4390	byteread = read (conn->fd, &(conn->head[conn->headcount]),
4391	conn->bytes_to_get);
4392	if (byteread > 0 \|\| errno == EINTR)
4393	{
4394	if (byteread > 0)
4395	conn->headcount += byteread;
4396	if (conn->headcount == SH_HEADER_SIZE)
4397	{
4398	conn->bytes_to_get =
4399	(256 * (unsigned int)conn->head[1] +
4400	(unsigned int)conn->head[2]);
4401	SH_SHOWPROT(conn->head, '<');
4402	conn->bytecount = 0;
4403	}
4404	}
4405	else
4406	{
4407	goto conn_reset;
4408	}
4409	SL_RETURN( (0), _("sh_forward_do_read"));
4410	}
4411
4412
4413	/* limit message size
4414	*/
4415	/*
4416	conn->bytes_to_get =
4417	(conn->bytes_to_get > (16*SH_BUFSIZE - 1)) ?
4418	(16*SH_BUFSIZE - 1) : conn->bytes_to_get;
4419	*/
4420	conn->bytes_to_get = (conn->bytes_to_get > TRANS_BYTES) ?
4421	TRANS_BYTES : conn->bytes_to_get;
4422
4423	if (conn->headcount == SH_HEADER_SIZE && conn->bytes_to_get > 0)
4424	{
4425	if ((conn->bytecount > 0) && (conn->bytes_to_get > conn->bytecount))
4426	{
4427	/* do nothing */;
4428	}
4429	else
4430	{
4431	if (conn->buf != NULL)
4432	SH_FREE (conn->buf);
4433	conn->buf = SH_ALLOC(conn->bytes_to_get + 1); /* <= TRANS_BYTES+1 */
4434	conn->bytecount = 0;
4435	}
4436
4437	byteread = read (conn->fd, &(conn->buf[conn->bytecount]),
4438	conn->bytes_to_get - conn->bytecount);
4439	if (byteread > 0 \|\| errno == EINTR)
4440	{
4441	if (byteread > 0)
4442	conn->bytecount += byteread;
4443	if (conn->bytecount == conn->bytes_to_get)
4444	{
4445	++conn->pass;
4446	/* always terminate with NULL - we might use sl_strcmp()
4447	*/
4448	conn->buf[conn->bytecount] = '\0';
4449	conn->state = CONN_PAUSE;
4450
4451	#ifdef SH_ENCRYPT
4452	if ((conn->head[0] & SH_PROTO_EN2) != 0) /* if encrypted */
4453	{
4454	conn->buf =
4455	sh_tools_revertPack (conn->head, conn->buf,
4456	&(conn->client_entry->keyInstD),
4457	conn->bytecount);
4458	}
4459	else if ((conn->head[0] & SH_PROTO_ENC) != 0) /* if encrypted */
4460	{
4461	/* Decrypt only complete blocks.
4462	* If there is an incomplete block,
4463	* something is wrong anyway.
4464	* Decrypt in place.
4465	*/
4466	blkfac = conn->bytecount / B_SIZ;
4467	/* length2 = (B_SIZ * blkfac); */
4468	p = conn->buf;
4469	q = conn->buf;
4470
4471	err_num = cipherInit (&cipherInst, MODE_CBC, NULL);
4472	if (err_num < 0)
4473	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
4474	errorExplain(err_num, expbuf, sizeof(expbuf)),
4475	_("sh_forward_do_read: cipherInit"));
4476
4477	for (j = 0; j < blkfac; ++j)
4478	{
4479	memcpy(inBlock, p, B_SIZ);
4480	err_num = blockDecrypt(&cipherInst,
4481	&(conn->client_entry->keyInstD),
4482	inBlock, 128 * BNUM, outBlock);
4483	if (err_num < 0)
4484	sh_error_handle((-1), FIL__, __LINE__, -1,
4485	MSG_E_SUBGEN,
4486	errorExplain(err_num, expbuf, sizeof(expbuf)),
4487	_("sh_forward_do_read: blockDecrypt"));
4488	memcpy(q, outBlock, B_SIZ);
4489	p += 16;
4490	q += 16;
4491	}
4492	}
4493	#endif
4494
4495	/* ------ HERE CALL check_protocol(conn) ------- */
4496	check_protocol(conn, SH_DO_READ);
4497	}
4498	}
4499	else
4500	{
4501	goto conn_reset;
4502	}
4503	}
4504
4505	else if (conn->headcount == SH_HEADER_SIZE && conn->bytes_to_get == 0)
4506	{
4507	if (conn->buf != NULL)
4508	SH_FREE (conn->buf);
4509	conn->buf = NULL;
4510	conn->bytecount = 0;
4511	++conn->pass;
4512	conn->state = CONN_PAUSE;
4513	/* fprintf(stderr, "\n** FIXME null read *\n\n"); /
4514	/* ------ HERE CALL check_protocol(conn) ------- */
4515	check_protocol(conn, SH_DO_READ);
4516	}
4517
4518	SL_RETURN( (0), _("sh_forward_do_read"));
4519
4520	conn_reset:
4521	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_RESET,
4522	conn->peer);
4523	sh_forward_do_free ( conn );
4524	SL_RETURN( (-1), _("sh_forward_do_read"));
4525	}
4526
4527	#if !defined(O_NONBLOCK)
4528	#if defined(O_NDELAY)
4529	#define O_NONBLOCK O_NDELAY
4530	#else
4531	#define O_NONBLOCK 0
4532	#endif
4533	#endif
4534
4535	/* send to the client
4536	*/
4537	int sh_forward_do_write (sh_conn_t * conn)
4538	{
4539	int flags;
4540	long arg = 0;
4541	long bytesent; /* bytes read */
4542
4543	SL_ENTER(_("sh_forward_do_write"));
4544
4545	/* ---- consistency check ------
4546	*/
4547	if (conn->state == CONN_READING)
4548	{
4549	sh_error_handle( (-1), FIL__, __LINE__, 0, MSG_TCP_SYNC,
4550	conn->peer);
4551	SL_RETURN( (-1), _("sh_forward_do_write"));
4552	}
4553
4554
4555	flags = retry_fcntl (FIL__, __LINE__, conn->fd, F_GETFL, arg);
4556	retry_fcntl (FIL__, __LINE__, conn->fd, F_SETFL, flags\|O_NONBLOCK);
4557
4558	/* ---- send the header ------
4559	*/
4560	if (conn->headcount < SH_HEADER_SIZE)
4561	{
4562	conn->bytes_to_send = SH_HEADER_SIZE - conn->headcount;
4563	bytesent = write (conn->fd,
4564	&(conn->head[conn->headcount]),
4565	conn->bytes_to_send);
4566	if (bytesent >= 0 \|\| errno == EINTR \|\| errno == EAGAIN)
4567	{
4568	if (bytesent > 0)
4569	conn->headcount += bytesent;
4570	if (conn->headcount == SH_HEADER_SIZE)
4571	{
4572	conn->bytes_to_send =
4573	(256 * (int)conn->head[1] + (int)conn->head[2]);
4574	}
4575	}
4576	else
4577	{
4578	goto conn_reset_w;
4579	}
4580	if (conn->fd >= 0)
4581	retry_fcntl (FIL__, __LINE__, conn->fd, F_SETFL, flags);
4582	SL_RETURN( (0), _("sh_forward_do_write"));
4583	}
4584
4585
4586	/* ---- send the body ------
4587	*/
4588
4589	if (conn->headcount == SH_HEADER_SIZE && conn->bytes_to_send > 0 &&
4590	conn->buf != NULL)
4591	{
4592	bytesent = write (conn->fd, &(conn->buf[conn->bytecount]),
4593	conn->bytes_to_send - conn->bytecount);
4594	if (bytesent >= 0 \|\| errno == EINTR \|\| errno == EAGAIN)
4595	{
4596	if (bytesent > 0)
4597	conn->bytecount += bytesent;
4598	if (conn->bytecount == conn->bytes_to_send)
4599	{
4600	++conn->pass;
4601	conn->state = CONN_PAUSE;
4602	/* ------ HERE CALL check_protocol(conn) ------- */
4603	check_protocol(conn, SH_DO_WRITE);
4604	}
4605	}
4606	else
4607	{
4608	goto conn_reset_w;
4609	}
4610	}
4611
4612	else if (conn->headcount == SH_HEADER_SIZE && conn->bytes_to_send == 0)
4613	{
4614	++conn->pass;
4615	conn->state = CONN_PAUSE;
4616	/* fprintf(stderr, "\n** FIXME null write *\n\n"); /
4617	/* ------ HERE CALL check_protocol(conn) ------- */
4618	check_protocol(conn, SH_DO_WRITE);
4619	}
4620
4621	if (conn->fd >= 0)
4622	retry_fcntl (FIL__, __LINE__, conn->fd, F_SETFL, flags);
4623	SL_RETURN( (0), _("sh_forward_do_write"));
4624
4625	conn_reset_w:
4626	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_RESET,
4627	conn->peer);
4628	sh_forward_do_free ( conn );
4629	SL_RETURN( (-1), _("sh_forward_do_write"));
4630	}
4631
4632	/* accept a connection from a client
4633	*/
4634	#include <syslog.h>
4635	#ifdef SH_USE_LIBWRAP
4636	#include <tcpd.h>
4637
4638	#ifndef ALLOW_SEVERITY
4639	#define ALLOW_SEVERITY LOG_INFO
4640	#define DENY_SEVERITY LOG_WARNING
4641	#endif
4642
4643	int allow_severity;
4644	int deny_severity;
4645	#endif
4646
4647	int sh_forward_accept (int sock, sh_conn_t * newconn)
4648	{
4649	int errflag;
4650	int rc;
4651	struct sh_sockaddr addr;
4652	#ifdef SH_USE_LIBWRAP
4653	struct request_info request;
4654	char errbuf[128];
4655	char daemon[128];
4656	#endif
4657
4658	/* handle AIX (size_t addrlen) in wrapper
4659	*/
4660	int addrlen = sizeof(addr);
4661
4662	SL_ENTER(_("sh_forward_accept"));
4663
4664	rc = retry_accept(FIL__, __LINE__, sock, &addr, &addrlen);
4665
4666	if (rc >= 0)
4667	{
4668
4669	if (addrlen == 0)
4670	{
4671	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
4672	_("Connecting entity unknown"), _("accept"));
4673	newconn->fd = -1;
4674	newconn->state = CONN_FREE;
4675	sl_close_fd(FIL__, __LINE__, rc);
4676	SL_RETURN( (-1), _("sh_forward_accept"));
4677	}
4678
4679	#ifdef SH_USE_LIBWRAP
4680	sl_strlcpy(daemon, SH_INSTALL_NAME, sizeof(daemon));
4681	request_init(&request, RQ_DAEMON, daemon, RQ_FILE, rc, 0);
4682	fromhost(&request);
4683	if (!hosts_access(&request))
4684	{
4685	sl_strlcpy(errbuf, _("Refused connection from "), sizeof(errbuf));
4686	sl_strlcat(errbuf, eval_client(&request), sizeof(errbuf));
4687
4688	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
4689	errbuf, _("libwrap"));
4690	newconn->fd = -1;
4691	newconn->state = CONN_FREE;
4692	sl_close_fd(FIL__, __LINE__, rc);
4693	SL_RETURN( (-1), _("sh_forward_accept"));
4694	}
4695	#endif
4696
4697	memcpy (&(newconn->addr_peer), &addr, sizeof(struct sh_sockaddr));
4698
4699	/* prepare for usage of connection
4700	*/
4701	(void) retry_fcntl( FIL__, __LINE__, rc, F_SETFD, 1 );
4702	newconn->fd = rc;
4703	newconn->state = CONN_READING;
4704	newconn->timer = (unsigned long) time (NULL);
4705
4706	if (flag_err_info == SL_TRUE)
4707	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_CNEW, newconn->fd);
4708
4709	SL_RETURN( (0), _("sh_forward_accept"));
4710	}
4711	else
4712	{
4713	char err_buf[SH_ERRBUF_SIZE];
4714	errflag = errno;
4715	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
4716	sh_error_message(errflag,err_buf, sizeof(err_buf)), _("accept"));
4717	newconn->fd = -1;
4718	newconn->state = CONN_FREE;
4719	SL_RETURN( (-1), _("sh_forward_accept"));
4720	}
4721	}
4722
4723	extern char sh_sig_msg[64]; /* defined in sh_unix.c */
4724
4725	/* ------------ port and interface -------
4726	*/
4727	static unsigned int server_port = SH_DEFAULT_PORT;
4728
4729	int sh_forward_set_port (const char * str)
4730	{
4731	int retval = 0;
4732	unsigned long i;
4733	char * endptr;
4734
4735	SL_ENTER(_("sh_forward_set_port"));
4736	i = strtoul (str, &endptr, 0);
4737	if (endptr == str) {
4738	retval = -1;
4739	} else if (i > 65535) {
4740	retval = -1;
4741	} else {
4742	server_port = i;
4743	}
4744	SL_RETURN( (retval), _("sh_forward_set_port"));
4745	}
4746
4747	static struct sh_sockaddr server_interface;
4748	static int use_server_interface = 0;
4749
4750	int sh_forward_set_interface (const char * str)
4751	{
4752	if (0 == strcmp(str, _("INADDR_ANY")))
4753	{
4754	use_server_interface = 0;
4755	return 0;
4756	}
4757
4758	if (0 == sh_ipvx_aton(str, &server_interface))
4759	{
4760	use_server_interface = 0;
4761	return -1;
4762	}
4763
4764	use_server_interface = 1;
4765	return 0;
4766	}
4767
4768	/* ------------ print error --------------
4769	*/
4770	struct sock_err_st {
4771	char msg[128];
4772	int errnum;
4773	int port;
4774	int line;
4775	int euid;
4776	};
4777
4778	static struct sock_err_st sock_err[2];
4779
4780	void sh_forward_printerr(char * str, int errnum, unsigned int port, int line)
4781	{
4782	int slot = 0;
4783
4784	if (port != server_port)
4785	slot = 1;
4786	if (str == NULL)
4787	sock_err[slot].msg[0] = '\0';
4788	else
4789	sl_strlcpy(sock_err[slot].msg, str, 128);
4790	sock_err[slot].errnum = errnum;
4791	sock_err[slot].port = port;
4792	sock_err[slot].line = line;
4793	sock_err[slot].euid = (int) geteuid();
4794	}
4795
4796	int sh_forward_printerr_final(int slot)
4797	{
4798	char errbuf[SH_ERRBUF_SIZE];
4799
4800	SL_ENTER(_("sh_forward_printerr_final"));
4801	if (sock_err[slot].msg[0] != '\0')
4802	{
4803	dlog(1, FIL__, __LINE__,
4804	_("Could not set up the listening socket for the server because of the\nfollowing error: %s\nPossible reasons include:\n - insufficient privilege for UID %d, or\n - the port %d is already used by another program.\n"),
4805	sh_error_message(sock_err[slot].errnum, errbuf, sizeof(errbuf)),
4806	sock_err[slot].euid,
4807	sock_err[slot].port);
4808	sh_error_handle((-1), FIL__, sock_err[slot].line,
4809	sock_err[slot].errnum, MSG_EXIT_ABORTS,
4810	sh_error_message(sock_err[slot].errnum, errbuf, sizeof(errbuf)),
4811	sh.prg_name,
4812	sock_err[slot].msg);
4813	SL_RETURN((-1), _("sh_forward_printerr_final"));
4814	}
4815	SL_RETURN(0, _("sh_forward_printerr_final"));
4816	}
4817
4818	#define TIME_OUT_DEF 900
4819	static unsigned long time_out_val = TIME_OUT_DEF;
4820
4821	int sh_forward_set_timeout (const char * c)
4822	{
4823	long val;
4824
4825	SL_ENTER(_("sh_forward_set_time_out"));
4826
4827	val = strtol (c, (char **)NULL, 10);
4828
4829	if (val == 0)
4830	{
4831	val = TIME_OUT_DEF;
4832	}
4833	else if (val < 0)
4834	{
4835	time_out_val = TIME_OUT_DEF;
4836	SL_RETURN( (-1), _("sh_forward_set_time_out"));
4837	}
4838
4839	time_out_val = (unsigned long) val;
4840	SL_RETURN( (0), _("sh_forward_set_time_out"));
4841	}
4842
4843
4844	static sh_conn_t * conns = NULL;
4845	static int maxconn = 0; /* maximum number of simultaneous connections */
4846
4847
4848	#ifdef INET_SYSLOG
4849	#define INET_SUSPEND_TIME 180 /* equal to 3 minutes */
4850	#define SH_MINSOCK_DEFAULT 3
4851	int create_syslog_socket (int flag);
4852	static int recv_syslog_socket (int fd);
4853	static int syslog_sock[SH_SOCKMAX] = { -1 };
4854	static int syslog_sock_n = 0;
4855	#else
4856	#define SH_MINSOCK_DEFAULT 2
4857	#endif
4858
4859	static int SH_MINSOCK = SH_MINSOCK_DEFAULT;
4860	extern int pf_unix_fd;
4861
4862	/* the tcp socket, and the function to establish it
4863	*/
4864	static int sh_tcp_sock[SH_SOCKMAX] = { -1 };
4865	static int sh_tcp_sock_n = 0;
4866
4867	static int do_socket(int domain, int type, int protocol,
4868	struct sockaddr * sa, int salen)
4869	{
4870	int sock = -1;
4871	int errnum = 0;
4872	int flag = 1; /* non-zero to enable an option */
4873
4874	/* fprintf(stderr, "FIXME IPVX: bind addr %s (%d) :%d\n",
4875	sh_ipvx_print_sockaddr (sa, domain), salen,
4876	sh_ipvx_get_port(sa, domain)); */
4877
4878	/* create the socket, bind() it and listen()
4879	*/
4880	if ((sock = socket(domain, type, protocol)) < 0 )
4881	{
4882	errnum = errno;
4883	sh_forward_printerr (_("socket"), errnum, server_port, __LINE__);
4884	return -1;
4885	}
4886	(void) retry_fcntl( FIL__, __LINE__, sock, F_SETFD, 1 );
4887
4888	if ( setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
4889	(void *) &flag, sizeof(flag)) < 0 )
4890	{
4891	errnum = errno;
4892	sh_forward_printerr (_("setsockopt"), errnum, server_port, __LINE__);
4893	sl_close_fd (FIL__, __LINE__, sock);
4894	return -1;
4895	}
4896
4897	if ( bind(sock, (struct sockaddr *) sa, salen) < 0)
4898	{
4899	if (errno != EADDRINUSE)
4900	{
4901	errnum = errno;
4902	sh_forward_printerr (_("bind"), errnum, server_port, __LINE__);
4903	sl_close_fd (FIL__, __LINE__, sock);
4904	return -1;
4905	}
4906	else
4907	{
4908	sl_close_fd (FIL__, __LINE__, sock);
4909	return -2;
4910	}
4911	}
4912
4913	if ( retry_fcntl( FIL__, __LINE__, sock, F_SETFL, O_NONBLOCK ) < 0 )
4914	{
4915	errnum = errno;
4916	sh_forward_printerr (_("fcntl"), errnum, server_port, __LINE__);
4917	sl_close_fd (FIL__, __LINE__, sock);
4918	return -1;
4919	}
4920
4921	if ( listen(sock, 64) < 0)
4922	{
4923	errnum = errno;
4924	sh_forward_printerr (_("listen"), errnum, server_port, __LINE__);
4925	sl_close_fd (FIL__, __LINE__, sock);
4926	return -1;
4927	}
4928
4929	return sock;
4930	}
4931
4932	int sh_create_tcp_socket (void)
4933	{
4934	#if defined(USE_IPVX)
4935	struct addrinfo *ai;
4936	struct addrinfo *p;
4937	struct addrinfo hints;
4938	char port[32];
4939	#else
4940	struct sockaddr_in addr;
4941	int addrlen = sizeof(addr);
4942	#endif
4943
4944	int sock = -1;
4945
4946	SL_ENTER(_("sh_create_tcp_socket"));
4947
4948	sh_forward_printerr (NULL, 0, server_port, __LINE__);
4949
4950	#if defined(USE_IPVX)
4951	if (use_server_interface == 0)
4952	{
4953	memset (&hints, '\0', sizeof (hints));
4954	hints.ai_flags = AI_PASSIVE \| AI_ADDRCONFIG;
4955	hints.ai_socktype = SOCK_STREAM;
4956	hints.ai_family = AF_UNSPEC;
4957	sl_snprintf(port, sizeof(port), "%d", server_port);
4958
4959	if (getaddrinfo (NULL, port, &hints, &ai) != 0)
4960	{
4961	int errnum = errno;
4962	sh_forward_printerr (_("getaddrinfo"), errnum, server_port, __LINE__);
4963	sl_close_fd (FIL__, __LINE__, sock);
4964	SL_RETURN((-1), _("sl_create_tcp_socket"));
4965	}
4966
4967	p = ai;
4968
4969	while (p != NULL && sh_tcp_sock_n < SH_SOCKMAX)
4970	{
4971	sock = do_socket(p->ai_family, p->ai_socktype, p->ai_protocol,
4972	p->ai_addr, p->ai_addrlen);
4973
4974	if (sock >= 0) {
4975	if (sh_tcp_sock_n < SH_SOCKMAX) {
4976	sh_tcp_sock[sh_tcp_sock_n] = sock;
4977	++sh_tcp_sock_n;
4978	}
4979	else {
4980	sl_close_fd (FIL__, __LINE__, sock);
4981	}
4982	} else if (sock == -1) {
4983	freeaddrinfo (ai);
4984	goto end;
4985	}
4986	p = p->ai_next;
4987	}
4988
4989	freeaddrinfo (ai);
4990	}
4991	else
4992	{
4993	sh_ipvx_set_port(&server_interface, server_port);
4994
4995	sock = do_socket(server_interface.ss_family, SOCK_STREAM, 0,
4996	sh_ipvx_sockaddr_cast(&server_interface),
4997	SH_SS_LEN(server_interface));
4998
4999	if (sock >= 0) {
5000	sh_tcp_sock[0] = sock;
5001	sh_tcp_sock_n = 1;
5002	}
5003	}
5004	#else
5005	if (use_server_interface == 0)
5006	addr.sin_addr.s_addr = INADDR_ANY;
5007	else
5008	memcpy(&addr, sh_ipvx_sockaddr_cast(&server_interface), addrlen);
5009	addr.sin_family = AF_INET;
5010	addr.sin_port = htons(server_port);
5011
5012	sock = do_socket(AF_INET, SOCK_STREAM, 0, (struct sockaddr *) &addr, addrlen);
5013
5014	if (sock >= 0) {
5015	sh_tcp_sock[0] = sock;
5016	sh_tcp_sock_n = 1;
5017	}
5018
5019	#endif
5020
5021	#if defined(USE_IPVX)
5022	end:
5023	#endif
5024	if (sh_tcp_sock_n > 1)
5025	SH_MINSOCK += (sh_tcp_sock_n - 1);
5026
5027	SL_RETURN((sh_tcp_sock_n), _("sl_create_tcp_socket"));
5028	}
5029
5030	/*****************************************
5031	*
5032	* This is the server main loop.
5033	*
5034	* The server is set up for listening, and
5035	* and starts a select() loop.
5036	*
5037	*****************************************/
5038
5039	void sh_receive()
5040	{
5041	#ifdef SH_USE_XML
5042	extern int sh_log_file (char * message, char * inet_peer);
5043	#endif
5044
5045	/* Use volatile to circumvent a gcc4 problem on RH/CentOS 4.8 (?) */
5046	volatile int sock = -1;
5047	sh_conn_t * cx;
5048	fd_set readset;
5049	fd_set writeset;
5050	struct timeval tv;
5051	int num_sel;
5052	int errnum;
5053	int nowconn;
5054	int status;
5055	int high_fd = -1;
5056	register int i;
5057	long dummy = 0;
5058	unsigned long time_now;
5059	unsigned long time_last = 0;
5060	unsigned long time_out = time_out_val;
5061
5062	time_t told;
5063	time_t tcurrent;
5064
5065	unsigned long tchkold;
5066
5067	int setsize_fd;
5068
5069	int sock_tcp[2];
5070	int sock_unix;
5071	#ifdef INET_SYSLOG
5072	int sock_log[2];
5073	#endif
5074
5075	SL_ENTER(_("sh_receive"));
5076
5077	if ( sh_forward_printerr_final(0) < 0)
5078	{
5079	aud_exit(FIL__, __LINE__, EXIT_FAILURE);
5080	}
5081
5082	sock = sh_tcp_sock[0];
5083
5084	/* ****************************************************************
5085	*
5086	* This is a non-forking server. We use select() on the listen()
5087	* socket to watch for new connections. For new connections, accept()
5088	* will return a new socket that is put in the read/write filesets.
5089	* Data about active connections are kept in the 'conns' table.
5090	*
5091	******************************************************************/
5092
5093	/* The table to hold info on sockets.
5094	* We reserve 6 file descriptors for misc. use.
5095	* The POSIX lower limit on open files seems to be eight.
5096	*/
5097	maxconn = get_open_max() - 6;
5098
5099	/* ugly fix for FreeBSD compiler warning; casting FD_SETSIZE in the
5100	* conditional expression does not suppress the warning... */
5101	setsize_fd = (int)FD_SETSIZE;
5102	maxconn = (setsize_fd < maxconn) ? setsize_fd : maxconn;
5103
5104	if (maxconn < 0 \|\| !sl_ok_muls(maxconn, sizeof(sh_conn_t)))
5105	{
5106	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_START_SRV,
5107	0, sock);
5108	aud_exit (FIL__, __LINE__, EXIT_FAILURE);
5109	}
5110	conns = SH_ALLOC (sizeof(sh_conn_t) * maxconn);
5111
5112	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_START_SRV,
5113	(maxconn-1), sock);
5114
5115	/* timer
5116	*/
5117	tcurrent = (unsigned long) time (NULL);
5118	told = tcurrent;
5119
5120	tchkold = tcurrent;
5121
5122	for (i = SH_MINSOCK; i < maxconn; ++i)
5123	{
5124	conns[i].buf = NULL;
5125	conns[i].K = NULL;
5126	conns[i].A = NULL;
5127	conns[i].M1 = NULL;
5128	conns[i].FileName = NULL;
5129	conns[i].fd = -1;
5130	sh_forward_do_free ( &conns[i]);
5131	}
5132
5133	/* status init
5134	*/
5135	server_status.conn_open = 0;
5136	server_status.conn_total = 0;
5137	server_status.conn_max = maxconn-1;
5138	server_status.start = time (NULL);
5139	server_status.last = (time_t) 0;
5140
5141	nowconn = 1;
5142	tv.tv_sec = 5;
5143	tv.tv_usec = 0;
5144
5145	/* conns[0] is the listen() socket. Always in read mode.
5146	*/
5147	sock = 0;
5148
5149	sock_tcp[0] = 0;
5150	while (sock < sh_tcp_sock_n)
5151	{
5152	conns[sock].fd = sh_tcp_sock[sock];
5153	conns[sock].state = CONN_READING;
5154	/* high_fd = (sh_tcp_sock[sock] > high_fd) ? sh_tcp_sock[sock] : high_fd; */
5155	++sock;
5156	}
5157	sock_tcp[1] = sock;
5158
5159	conns[sock].fd = pf_unix_fd;
5160	conns[sock].state = CONN_READING;
5161	/* high_fd = (pf_unix_fd > high_fd) ? pf_unix_fd : high_fd; */
5162
5163	sock_unix = sock;
5164
5165	++sock;
5166
5167	#ifdef INET_SYSLOG
5168	conns[sock].fd = -1;
5169
5170	if ( sh_forward_printerr_final(1) < 0)
5171	{
5172	SH_FREE(conns);
5173	conns = NULL;
5174	aud_exit(FIL__, __LINE__, EXIT_FAILURE);
5175	}
5176
5177	sock_log[0] = sock;
5178	sock_log[1] = sock;
5179
5180	if (syslog_sock_n > 0)
5181	{
5182	int s2;
5183	for (s2 = 0; s2 < syslog_sock_n; ++s2)
5184	{
5185	conns[sock].fd = syslog_sock[s2];
5186	conns[sock].state = CONN_READING;
5187	/* high_fd = (high_fd > conns[sock].fd) ? high_fd : conns[sock].fd; */
5188	++sock;
5189	}
5190	sock_log[1] = sock;
5191
5192	}
5193	#endif
5194
5195	sh_html_write(all_clients);
5196
5197	/* This is the select() loop.
5198	*/
5199	while (1 == 1)
5200	{
5201
5202	if (sig_raised > 0)
5203	{
5204	TPT((0, FIL__, __LINE__, _("msg=<Process a signal.>\n")))
5205
5206	if (sig_termfast == 1) /* SIGTERM */
5207	{
5208	TPT((0, FIL__, __LINE__, _("msg=<Terminate.>\n")));
5209	strncpy (sh_sig_msg, _("SIGTERM"), 20);
5210	--sig_raised; --sig_urgent;
5211	aud_exit (FIL__, __LINE__, EXIT_SUCCESS);
5212	}
5213
5214	if (sig_config_read_again == 1)
5215	{
5216	TPT((0, FIL__, __LINE__, _("msg=<Re-read configuration.>\n")));
5217	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_RECONF);
5218
5219
5220	/* -- Delete the name server cache. --
5221	*/
5222
5223	delete_cache();
5224	#if defined(WITH_EXTERNAL)
5225	/* -- Delete list of external tasks. --
5226	*/
5227	(void) sh_ext_cleanup();
5228	#endif
5229	#if defined(SH_WITH_MAIL)
5230	sh_nmail_free();
5231	#endif
5232	/* - mark all clients dead
5233	* - read configuration file
5234	* - remove clients still dead
5235	*/
5236	sh_forward_mark_dead ();
5237
5238	reset_count_dev_console();
5239	reset_count_dev_time();
5240	sl_trust_purge_user();
5241
5242	(void) sh_readconf_read ();
5243
5244	for (i = SH_MINSOCK; i < maxconn; ++i)
5245	if (conns[i].state != CONN_FREE &&
5246	conns[i].client_entry != NULL &&
5247	conns[i].client_entry->dead_flag == 1)
5248	sh_forward_do_free ( &conns[i]);
5249	sh_forward_clean_tree ();
5250
5251	sig_config_read_again = 0;
5252	--sig_raised;
5253	}
5254
5255	if (sig_fresh_trail == 1) /* SIGIOT */
5256	{
5257	/* Logfile access
5258	*/
5259	#ifdef SH_USE_XML
5260	sh_log_file (NULL, NULL);
5261	#endif
5262	TPT((0, FIL__, __LINE__, _("msg=<Logfile stop/restart.>\n")));
5263	sh_error_only_stderr (S_TRUE);
5264	sh_unix_rm_lock_file(sh.srvlog.name);
5265	retry_msleep(3, 0);
5266	sh.flag.log_start = S_TRUE;
5267	sh_error_only_stderr (S_FALSE);
5268	sig_fresh_trail = 0;
5269	--sig_raised;
5270	}
5271
5272
5273	if (sig_terminate == 1 && nowconn < 2) /* SIGQUIT */
5274	{
5275	TPT((0, FIL__, __LINE__, _("msg=<Terminate.>\n")));
5276	strncpy (sh_sig_msg, _("SIGQUIT"), 20);
5277	--sig_raised; --sig_urgent;
5278	aud_exit (FIL__, __LINE__, EXIT_SUCCESS);
5279	}
5280
5281
5282	if (sig_debug_switch == 1) /* SIGUSR1 */
5283	{
5284	TPT((0, FIL__, __LINE__, _("msg=<Debug switch.>\n")));
5285	sh_error_dbg_switch();
5286	sig_debug_switch = 0;
5287	--sig_raised;
5288	}
5289
5290	if (sig_suspend_switch > 0) /* SIGUSR2 */
5291	{
5292	TPT((0, FIL__, __LINE__, _("msg=<Suspend switch.>\n")));
5293	if (sh_global_suspend_flag == 1) {
5294	sh_global_suspend_flag = 0;
5295	} else {
5296	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_SUSPEND,
5297	sh.prg_name);
5298	sh_global_suspend_flag = 1;
5299	}
5300	--sig_suspend_switch;
5301	--sig_raised; --sig_urgent;
5302	}
5303
5304	sig_raised = (sig_raised < 0) ? 0 : sig_raised;
5305	sig_urgent = (sig_urgent < 0) ? 0 : sig_urgent;
5306	TPT((0, FIL__, __LINE__, _("msg=<End signal processing.>\n")));
5307	}
5308
5309	if (sh_global_suspend_flag == 1)
5310	{
5311	(void) retry_msleep (1, 0);
5312	continue;
5313	}
5314
5315	/* Recompute the descriptor set. select() modifies it,
5316	* thus we update it using the info from the connection table.
5317	* Also recompute the number of open connections.
5318	*/
5319	FD_ZERO( &readset );
5320	FD_ZERO( &writeset );
5321	high_fd = conns[0].fd;
5322
5323	for (sock = sock_tcp[0]; sock < sock_tcp[1]; ++sock)
5324	{
5325	FD_SET(conns[sock].fd, &readset );
5326	high_fd = (high_fd > conns[sock].fd) ? high_fd : conns[sock].fd;
5327	}
5328
5329	if (conns[sock_unix].fd > -1)
5330	{
5331	FD_SET(conns[sock_unix].fd, &readset );
5332	high_fd = (high_fd > conns[sock_unix].fd) ? high_fd : conns[sock_unix].fd;
5333	}
5334
5335	#ifdef INET_SYSLOG
5336	for (sock = sock_log[0]; sock < sock_log[1]; ++sock)
5337	{
5338	if (conns[sock].fd > -1)
5339	{
5340	FD_SET(conns[sock].fd, &readset );
5341	high_fd = (high_fd > conns[sock].fd) ? high_fd : conns[sock].fd;
5342	}
5343	}
5344	#endif
5345
5346	time_now = (unsigned long) time (NULL);
5347	nowconn = 1;
5348
5349	for (i = SH_MINSOCK; i < maxconn; ++i)
5350	{
5351	/* eliminate timed out connections
5352	*/
5353	if (conns[i].state != CONN_FREE)
5354	{
5355	if (time_now-conns[i].timer > time_out)
5356	{
5357	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_TIMOUT,
5358	conns[i].peer);
5359	sh_forward_do_free ( &conns[i]);
5360	}
5361	else
5362	++nowconn;
5363	}
5364
5365
5366	if (conns[i].state == CONN_READING)
5367	{
5368	FD_SET(conns[i].fd, &readset);
5369	high_fd = (high_fd < conns[i].fd ? conns[i].fd : high_fd);
5370	}
5371	else if (conns[i].state == CONN_SENDING)
5372	{
5373	FD_SET(conns[i].fd, &writeset);
5374	high_fd = (high_fd < conns[i].fd ? conns[i].fd : high_fd);
5375	}
5376	}
5377
5378	/* -- Exponentially reduce timeout limit if more than 1/2 full. --
5379	*/
5380	/* Eliminate this, will cause problems when too much clients are
5381	* starting up. */
5382	#if 0
5383	if (nowconn > (maxconn/2))
5384	time_out = ( (time_out/2) > 1) ? (time_out/2) : 1;
5385	else
5386	time_out = time_out_val;
5387	#endif
5388
5389
5390	/* -- Do the select(). --
5391	*/
5392	num_sel = select(high_fd+1, &readset, &writeset, NULL, &tv);
5393	errnum = errno;
5394
5395	/* reset timeout - modified by select() on some systems
5396	*/
5397	tv.tv_sec = 5;
5398	tv.tv_usec = 0;
5399
5400
5401	if ( (time_now - time_last) > 2L)
5402	{
5403	time_last = time_now;
5404	if (sh_html_write(all_clients) < 0)
5405	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_HTML);
5406	}
5407
5408
5409	/* Error handling.
5410	*/
5411	if ( num_sel < 0 ) /* some error */
5412	{
5413	char errbuf[SH_ERRBUF_SIZE];
5414
5415	if (sig_raised == 1)
5416	{
5417	sig_raised = 2;
5418	continue;
5419	}
5420
5421	if ( errnum == EINTR)
5422	continue; /* try again */
5423
5424	if ( errnum == EBADF)
5425	{
5426	/* seek and destroy the bad fd
5427	*/
5428	for (i = SH_MINSOCK; i < high_fd; ++i)
5429	{
5430	if ((conns[i].state == CONN_READING) \|\|
5431	(conns[i].state == CONN_SENDING))
5432	{
5433	if (-1 == retry_fcntl(FIL__, __LINE__,
5434	conns[i].fd, F_GETFL, dummy))
5435	sh_forward_do_free ( &conns[i]);
5436	}
5437	}
5438	continue;
5439	}
5440
5441	sh_error_handle((-1), FIL__, __LINE__, errnum, MSG_EXIT_ABORTS,
5442	sh_error_message(errnum, errbuf, sizeof(errbuf)),
5443	sh.prg_name,
5444	_("select"));
5445	aud_exit(FIL__, __LINE__, EXIT_FAILURE );
5446	}
5447
5448
5449	/* log the timestamp
5450	*/
5451	if ((tcurrent - told) > sh.looptime )
5452	{
5453	told = tcurrent;
5454	#ifdef MEM_DEBUG
5455	sh_mem_check();
5456	sh_unix_count_mlock();
5457	#else
5458	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_STAMP);
5459	#endif
5460	}
5461
5462	#if defined(SH_WITH_MAIL)
5463	/*
5464	* flush the mail queue
5465	*/
5466	if (tcurrent - sh.mailTime.alarm_last > sh.mailTime.alarm_interval)
5467	{
5468	TPT((0, FIL__, __LINE__, _("msg=<Flush mail queue.>\n")))
5469	(void) sh_nmail_flush ();
5470	sh.mailTime.alarm_last = tcurrent;
5471	}
5472	#endif
5473	#ifdef MEM_DEBUG
5474	sh_mem_dump();
5475	#endif
5476
5477	tcurrent = (unsigned long) time (NULL);
5478
5479	/* check for time limit exceeded
5480	*/
5481	if ((tcurrent - tchkold) > (unsigned int) 3 )
5482	{
5483	tchkold = tcurrent;
5484	client_time_check(/* all_clients */);
5485	/* reset cache */
5486	sh_userid_destroy();
5487	}
5488
5489	/* seed / re-seed the PRNG if required
5490	*/
5491	(void) taus_seed();
5492
5493	/* select() timeout handling.
5494	*/
5495	if ( num_sel == 0 ) /* timeout - no connection */
5496	{
5497	if (sh_html_write(all_clients) < 0)
5498	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_HTML);
5499	continue;
5500	}
5501
5502	/* New connection.
5503	*/
5504	for (sock = sock_tcp[0]; sock < sock_tcp[1]; ++sock)
5505	{
5506	if ( FD_ISSET(conns[sock].fd , &readset )) /* a new connection */
5507	{
5508	--num_sel;
5509	status = 0;
5510	if (nowconn < maxconn && sig_terminate == 0 && sig_termfast == 0)
5511	{
5512	/* Find a free slot to accept the connection
5513	*/
5514	i = SH_MINSOCK;
5515	while (i < maxconn)
5516	{
5517	if (conns[i].state == CONN_FREE)
5518	{
5519	/* Here we run the accept() and copy the peer to
5520	* the free slot.
5521	*/
5522	status = sh_forward_accept(conns[sock].fd, &conns[i]);
5523
5524	if (status == 0)
5525	{
5526	high_fd =
5527	(high_fd > conns[i].fd ? high_fd : conns[i].fd);
5528	++server_status.conn_open;
5529	++server_status.conn_total;
5530	server_status.last = time (NULL);
5531	}
5532	break;
5533	}
5534	++i;
5535	}
5536	}
5537	/* This re-runs select to accept data on the new
5538	* connection, rather than first dealing with old
5539	* connections.
5540	*/
5541	if (status == 0)
5542	continue;
5543	}
5544	}
5545
5546	/* check for commands on the socket
5547	*/
5548	if (conns[sock_unix].fd > (-1) && FD_ISSET(conns[sock_unix].fd , &readset ))
5549	{
5550	sh_socket_poll();
5551	}
5552
5553	#ifdef INET_SYSLOG
5554	for (sock = sock_log[0]; sock < sock_log[1]; ++sock)
5555	{
5556	if (conns[sock].fd > (-1) && FD_ISSET(conns[sock].fd , &readset ))
5557	{
5558	recv_syslog_socket (conns[sock].fd);
5559	}
5560	}
5561	#endif
5562
5563	/* Check for pending read/write on the rest of the sockets.
5564	*/
5565	for ( i = SH_MINSOCK; num_sel > 0 && i < maxconn; ++i )
5566	{
5567	if (sig_termfast == 1)
5568	break;
5569
5570	cx = &conns[i];
5571	if ( cx->state == CONN_READING &&
5572	FD_ISSET( cx->fd, &readset ) )
5573	{
5574	--num_sel;
5575	sh_forward_do_read ( cx );
5576	}
5577	else if ( cx->state == CONN_SENDING &&
5578	FD_ISSET( cx->fd, &writeset ) )
5579	{
5580	--num_sel;
5581	sh_forward_do_write ( cx );
5582	}
5583	}
5584	/* continue */
5585	}
5586	/* notreached */
5587	}
5588
5589	void free_client_tree (void)
5590	{
5591	SL_ENTER(_("free_client_tree"));
5592	zAVLFreeTree (all_clients, free_client);
5593	SL_RET0(_("free_client_tree"));
5594	}
5595
5596	void sh_forward_free_all ()
5597	{
5598	register int i;
5599
5600	SL_ENTER(_("sh_forward_free_all"));
5601
5602	if (conns != NULL)
5603	for (i = SH_MINSOCK; i < maxconn; ++i)
5604	{
5605	sh_forward_do_free ( &conns[i]);
5606	}
5607
5608
5609	free_client_tree ();
5610
5611	if (conns != NULL)
5612	SH_FREE (conns);
5613
5614	SL_RET0(_("sh_forward_free_all"));
5615	}
5616
5617	#ifdef INET_SYSLOG
5618
5619	/* Unlike Linux / FreeBSD, most systems don't define the stuff below
5620	* in syslog.h
5621	*/
5622
5623	#ifndef LOG_FAC
5624	#define LOG_FAC(p) (((p) & LOG_FACMASK) >> 3)
5625	#endif
5626
5627	#ifndef LOG_PRI
5628	#define LOG_PRI(p) ((p) & LOG_PRIMASK)
5629	#endif
5630
5631	typedef struct sh_code {
5632	char *c_name;
5633	int c_val;
5634	} SH_CODE;
5635
5636	SH_CODE sh_facilitynames[] =
5637	{
5638	#ifdef LOG_AUTH
5639	{ N_("auth"), LOG_AUTH },
5640	#endif
5641	#ifdef LOG_AUTHPRIV
5642	{ N_("authpriv"), LOG_AUTHPRIV },
5643	#endif
5644	#ifdef LOG_CRON
5645	{ N_("cron"), LOG_CRON },
5646	#endif
5647	#ifdef LOG_DAEMON
5648	{ N_("daemon"), LOG_DAEMON },
5649	#endif
5650	#ifdef LOG_FTP
5651	{ N_("ftp"), LOG_FTP },
5652	#endif
5653	#ifdef LOG_KERN
5654	{ N_("kern"), LOG_KERN },
5655	#endif
5656	#ifdef LOG_LPR
5657	{ N_("lpr"), LOG_LPR },
5658	#endif
5659	#ifdef LOG_MAIL
5660	{ N_("mail"), LOG_MAIL },
5661	#endif
5662	#ifdef INTERNAL_MARK
5663	{ N_("mark"), INTERNAL_MARK }, /* INTERNAL */
5664	#endif
5665	#ifdef LOG_NEWS
5666	{ N_("news"), LOG_NEWS },
5667	#endif
5668	#ifdef LOG_AUTH
5669	{ N_("security"), LOG_AUTH }, /* DEPRECATED */
5670	#endif
5671	#ifdef LOG_SYSLOG
5672	{ N_("syslog"), LOG_SYSLOG },
5673	#endif
5674	#ifdef LOG_USER
5675	{ N_("user"), LOG_USER },
5676	#endif
5677	#ifdef LOG_UUCP
5678	{ N_("uucp"), LOG_UUCP },
5679	#endif
5680	#ifdef LOG_LOCAL0
5681	{ N_("local0"), LOG_LOCAL0 },
5682	#endif
5683	#ifdef LOG_LOCAL1
5684	{ N_("local1"), LOG_LOCAL1 },
5685	#endif
5686	#ifdef LOG_LOCAL2
5687	{ N_("local2"), LOG_LOCAL2 },
5688	#endif
5689	#ifdef LOG_LOCAL3
5690	{ N_("local3"), LOG_LOCAL3 },
5691	#endif
5692	#ifdef LOG_LOCAL4
5693	{ N_("local4"), LOG_LOCAL4 },
5694	#endif
5695	#ifdef LOG_LOCAL5
5696	{ N_("local5"), LOG_LOCAL5 },
5697	#endif
5698	#ifdef LOG_LOCAL6
5699	{ N_("local6"), LOG_LOCAL6 },
5700	#endif
5701	#ifdef LOG_LOCAL7
5702	{ N_("local7"), LOG_LOCAL7 },
5703	#endif
5704	{ NULL, -1 }
5705	};
5706
5707
5708	SH_CODE sh_prioritynames[] =
5709	{
5710	#ifdef LOG_ALERT
5711	{ N_("alert"), LOG_ALERT },
5712	#endif
5713	#ifdef LOG_CRIT
5714	{ N_("crit"), LOG_CRIT },
5715	#endif
5716	#ifdef LOG_DEBUG
5717	{ N_("debug"), LOG_DEBUG },
5718	#endif
5719	#ifdef LOG_EMERG
5720	{ N_("emerg"), LOG_EMERG },
5721	#endif
5722	#ifdef LOG_ERR
5723	{ N_("err"), LOG_ERR },
5724	#endif
5725	#ifdef LOG_ERR
5726	{ N_("error"), LOG_ERR }, /* DEPRECATED */
5727	#endif
5728	#ifdef LOG_INFO
5729	{ N_("info"), LOG_INFO },
5730	#endif
5731	#ifdef INTERNAL_NOPRI
5732	{ N_("none"), INTERNAL_NOPRI }, /* INTERNAL */
5733	#endif
5734	#ifdef LOG_NOTICE
5735	{ N_("notice"), LOG_NOTICE },
5736	#endif
5737	#ifdef LOG_EMERG
5738	{ N_("panic"), LOG_EMERG }, /* DEPRECATED */
5739	#endif
5740	#ifdef LOG_WARNING
5741	{ N_("warn"), LOG_WARNING }, /* DEPRECATED */
5742	#endif
5743	#ifdef LOG_WARNING
5744	{ N_("warning"), LOG_WARNING },
5745	#endif
5746	{ NULL, -1 }
5747	};
5748
5749	static int enable_syslog_socket = S_FALSE;
5750
5751	static int recv_syslog_socket (int fd)
5752	{
5753	static time_t return_next = 0;
5754	int priority = 0;
5755	int fac, pri;
5756	int i;
5757	char * cfac = NULL;
5758	char * cpri = NULL;
5759	int res;
5760	char * tmp;
5761	char * bptr;
5762	char * ptr = NULL;
5763	char buf[1048];
5764	struct sockaddr_in from;
5765	char errbuf[SH_ERRBUF_SIZE];
5766
5767	struct sh_sockaddr ss;
5768	struct sockaddr * sa = (struct sockaddr *) &from;
5769	char namebuf[SH_BUFSIZE];
5770
5771	/* The 6th argument in recvfrom is socklen_t in Linux and BSD,
5772	* but *int everywhere else. Because socklen_t is unsigned int, there
5773	* should be no problem as long as sizeof(struct sockaddr_in) < INT_MAX ...
5774	*/
5775	unsigned int fromlen = sizeof(from);
5776
5777	if (enable_syslog_socket == S_FALSE)
5778	return 0;
5779
5780	SL_ENTER(_("recv_syslog_socket"));
5781
5782	if (return_next > 0)
5783	{
5784	if ( (time(NULL) - return_next) < 2)
5785	SL_RETURN( 0, _("recv_syslog_socket"));
5786	else
5787	return_next = 0;
5788	}
5789
5790	res = recvfrom(fd, buf, 1047, 0, (struct sockaddr *) &from, &fromlen);
5791
5792	sh_ipvx_save(&ss, sa->sa_family, (struct sockaddr *) &from);
5793	sh_ipvx_ntoa(namebuf, sizeof(namebuf), &ss);
5794
5795	if (res > 0)
5796	{
5797	res = (res < 1047) ? res : 1047;
5798	buf[res] = '\0';
5799	if (res > 1 && buf[res-1] == '\n')
5800	buf[res-1] = '\0';
5801
5802	/* here we expect an xml formatted message, thus we don't
5803	escape xml special chars (flag == 0) */
5804	/* commented out to not escape twice */
5805	/* bptr = sh_tools_safe_name(buf, 0); */
5806	bptr = buf;
5807
5808	if (!bptr \|\| !(*bptr))
5809	{
5810	res = errno;
5811	TPT(( 0, FIL__, __LINE__, _("msg=<UDP error: %d>\n"), res));
5812	sh_error_handle((-1), FIL__, __LINE__, res, MSG_ERR_SYSLOG,
5813	sh_error_message(res, errbuf, sizeof(errbuf)),
5814	namebuf);
5815	SL_RETURN( (-1), _("recv_syslog_socket"));
5816	}
5817
5818	TPT(( 0, FIL__, __LINE__, _("msg=<UDP message from %s>\n"), namebuf ));
5819
5820	ptr = bptr;
5821	i = 0;
5822	if (*ptr == '<')
5823	{
5824	++ptr; ++i;
5825	while (i < res &&
5826	(unsigned char) ptr > 47 && (unsigned char) ptr < 58)
5827	{
5828	priority = 10 * priority + (*ptr - '0');
5829	++ptr;
5830	++i;
5831	}
5832	if (*ptr == '>')
5833	++ptr;
5834	}
5835	fac = LOG_FAC(priority);
5836	i = 0;
5837	while (sh_facilitynames[i].c_name != NULL)
5838	{
5839	if (sh_facilitynames[i].c_val == (fac<<3))
5840	{ cfac = sh_util_strdup(_(sh_facilitynames[i].c_name)); break; }
5841	++i;
5842	}
5843	pri = LOG_PRI(priority);
5844	i = 0;
5845	while (sh_prioritynames[i].c_name != NULL)
5846	{
5847	if (sh_prioritynames[i].c_val == pri)
5848	{ cpri = sh_util_strdup(_(sh_prioritynames[i].c_name)); break; }
5849	++i;
5850	}
5851
5852	/* here we do not expect an xml formatted message, thus we escape
5853	xml special chars (flag == 1) */
5854	tmp = sh_tools_safe_name (ptr, 1);
5855	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_INET_SYSLOG,
5856	namebuf,
5857	(cfac == NULL) ? _("none") : cfac,
5858	(cpri == NULL) ? _("none") : cpri,
5859	(tmp == NULL) ? _("none") : tmp);
5860	if (cfac != NULL)
5861	SH_FREE(cfac);
5862	if (cpri != NULL)
5863	SH_FREE(cpri);
5864	SH_FREE(tmp);
5865	/* SH_FREE(bptr); */
5866	}
5867
5868	else if (res < 0 && errno != EINTR)
5869	{
5870	res = errno;
5871	TPT(( 0, FIL__, __LINE__, _("msg=<UDP error: %d>\n"), res));
5872	sh_error_handle((-1), FIL__, __LINE__, res, MSG_ERR_SYSLOG,
5873	sh_error_message(res, errbuf, sizeof(errbuf)),
5874	namebuf);
5875
5876	/* don't accept anything the next 2 seconds
5877	*/
5878	return_next = time(NULL);
5879	SL_RETURN( (-1), _("recv_syslog_socket"));
5880	}
5881	SL_RETURN( (0), _("recv_syslog_socket"));
5882	}
5883
5884	int set_syslog_active(const char * c)
5885	{
5886	return sh_util_flagval(c, &enable_syslog_socket);
5887	}
5888
5889	static int do_syslog_socket(int domain, int type, int protocol,
5890	struct sockaddr * sa, int salen)
5891	{
5892	int flag = 1; /* non-zero to enable an option */
5893	int sock;
5894	int errnum;
5895	int res;
5896
5897	/* create the socket, bind() it and listen()
5898	*/
5899	sock = socket(domain, type, protocol);
5900
5901	if (sock < 0)
5902	{
5903	errnum = errno;
5904	sh_forward_printerr (_("syslog socket"), errnum, 514, __LINE__);
5905	return -1;
5906	}
5907	(void) retry_fcntl( FIL__, __LINE__, sock, F_SETFD, 1 );
5908
5909	if ( setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
5910	(void *) &flag, sizeof(flag)) < 0 )
5911	{
5912	errnum = errno;
5913	sh_forward_printerr (_("syslog setsockopt SO_REUSEADDR"),
5914	errnum, 514, __LINE__);
5915	return -1;
5916	}
5917
5918	#if defined(SO_BSDCOMPAT)
5919	if ( setsockopt(sock, SOL_SOCKET, SO_BSDCOMPAT,
5920	(void *) &flag, sizeof(flag)) < 0 )
5921	{
5922	errnum = errno;
5923	sh_forward_printerr (_("syslog setsockopt SO_BSDCOMPAT"),
5924	errnum, 514, __LINE__);
5925	return -1;
5926	}
5927	#endif
5928
5929	res = bind(sock, sa, salen);
5930
5931	if ( res < 0)
5932	{
5933	errnum = errno;
5934	sh_forward_printerr (_("syslog bind"), errnum, 514, __LINE__);
5935	sl_close_fd(FIL__, __LINE__, sock);
5936	return -1;
5937	}
5938	return sock;
5939	}
5940
5941	/* callerFlag == S_TRUE means override the enable_syslog_socket flag
5942	*/
5943	int create_syslog_socket (int callerFlag)
5944	{
5945	int sock;
5946
5947	#if defined(USE_IPVX)
5948	struct addrinfo *ai;
5949	struct addrinfo *p;
5950	struct addrinfo hints;
5951	#else
5952	struct sockaddr_in addr;
5953	int addrlen = sizeof(addr);
5954	#endif
5955
5956	SL_ENTER(_("create_syslog_socket"));
5957
5958	if (callerFlag == S_FALSE)
5959	{
5960	if (enable_syslog_socket == S_FALSE && syslog_sock_n > 0)
5961	{
5962	/* user does not wish to use this facility
5963	*/
5964	TPT(( 0, FIL__, __LINE__, _("msg=<close syslog socket>\n")));
5965	for (sock = 0; sock < syslog_sock_n; ++sock)
5966	{
5967	sl_close_fd(FIL__, __LINE__, syslog_sock[sock]);
5968	syslog_sock[0] = -1;
5969	}
5970	}
5971	SL_RETURN((-1), _("create_syslog_socket"));
5972	}
5973
5974	sh_forward_printerr (NULL, 0, 514, __LINE__);
5975
5976	#if !defined(USE_IPVX)
5977
5978	memset(&addr, 0, sizeof(addr));
5979	addr.sin_family = AF_INET;
5980	addr.sin_port = htons(514);
5981
5982	sock = do_syslog_socket(AF_INET, SOCK_DGRAM, 0,
5983	(struct sockaddr *) &addr, addrlen);
5984
5985	if (sock >= 0) {
5986	syslog_sock[0] = sock;
5987	syslog_sock_n = 1;
5988	}
5989
5990	#else
5991	memset (&hints, '\0', sizeof (hints));
5992	hints.ai_flags = AI_PASSIVE \| AI_ADDRCONFIG;
5993	hints.ai_socktype = SOCK_DGRAM;
5994	if (getaddrinfo (NULL, "syslog", &hints, &ai) != 0)
5995	{
5996	int errnum = errno;
5997	sh_forward_printerr (_("getaddrinfo"), errnum, 514, __LINE__);
5998	SL_RETURN((-1), _("create_syslog_socket"));
5999	}
6000
6001	p = ai;
6002
6003	while (p != NULL && syslog_sock_n < SH_SOCKMAX)
6004	{
6005	sock = do_syslog_socket(p->ai_family, p->ai_socktype, p->ai_protocol,
6006	p->ai_addr, p->ai_addrlen);
6007
6008	if (sock >= 0) {
6009	if (syslog_sock_n < SH_SOCKMAX) {
6010	syslog_sock[syslog_sock_n] = sock;
6011	++syslog_sock_n;
6012	}
6013	else {
6014	sl_close_fd (FIL__, __LINE__, sock);
6015	}
6016	} else if (sock == -1) {
6017	freeaddrinfo (ai);
6018	goto end;
6019	}
6020	p = p->ai_next;
6021	}
6022	freeaddrinfo (ai);
6023
6024	end:
6025	#endif
6026	if (syslog_sock_n > 1)
6027	SH_MINSOCK += (syslog_sock_n - 1);
6028
6029	SL_RETURN((syslog_sock_n), _("create_syslog_socket"));
6030	}
6031	/* #ifdef INET_SYSLOG */
6032	#endif
6033
6034
6035
6036	/* #ifdef SH_WITH_SERVER */
6037	#endif
6038
6039
6040
6041
6042
6043

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

Download in other formats: