Context Navigation

source: branches/samhain-2_2-branch/src/sh_tools.c@ 259

Last change on this file since 259 was 34, checked in by rainer, 19 years ago
Code cleanup and minor fixes
File size: 40.1 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
23	#include <stdio.h>
24	#include <stdlib.h>
25	#include <string.h>
26	#include <ctype.h>
27
28	/* Must be early on FreeBSD
29	*/
30	#include <sys/types.h>
31
32	#ifdef HAVE_MEMORY_H
33	#include <memory.h>
34	#endif
35
36	#ifdef HAVE_SYS_SELECT_H
37	#include <sys/select.h>
38	#endif
39
40	#ifdef HAVE_UNISTD_H
41	#include <errno.h>
42	#include <signal.h>
43	#include <setjmp.h>
44	#include <pwd.h>
45	#include <grp.h>
46	#include <sys/stat.h>
47	#include <sys/resource.h>
48	#include <fcntl.h>
49	#include <sys/wait.h>
50	#include <unistd.h>
51	#endif
52
53	#include <sys/socket.h>
54
55	#ifdef HOST_IS_HPUX
56	#define _XOPEN_SOURCE_EXTENDED
57	#endif
58	#include <netinet/in.h>
59	#include <arpa/inet.h>
60	#include <netdb.h>
61
62	#ifndef FD_SET
63	#define NFDBITS 32
64	#define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] \|= (1 << ((n) % NFDBITS)))
65	#define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
66	#define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
67	#endif /* !FD_SET */
68	#ifndef FD_SETSIZE
69	#define FD_SETSIZE 32
70	#endif
71	#ifndef FD_ZERO
72	#define FD_ZERO(p) memset((char )(p), '\0', sizeof((p)))
73	#endif
74
75
76	#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
77	#include <sys/mman.h>
78	#endif
79
80	#define SH_REAL_SET
81
82	#include "samhain.h"
83	#include "sh_mem.h"
84	#include "sh_error.h"
85	#include "sh_tools.h"
86	#include "sh_utils.h"
87	#include "sh_tiger.h"
88	#define SH_NEED_GETHOSTBYXXX
89	#include "sh_static.h"
90
91	#undef FIL__
92	#define FIL__ _("sh_tools.c")
93
94	#ifdef SH_ENCRYPT
95	#include "rijndael-api-fst.h"
96	char * errorExplain (int err_num)
97	{
98	if (err_num == BAD_KEY_DIR)
99	return (_("Key direction is invalid"));
100	else if (err_num == BAD_KEY_MAT)
101	return (_("Key material not of correct length"));
102	else if (err_num == BAD_KEY_INSTANCE)
103	return (_("Key passed is not valid"));
104	else if (err_num == BAD_CIPHER_MODE)
105	return (_("Params struct passed to cipherInit invalid"));
106	else if (err_num == BAD_CIPHER_STATE)
107	return (_("Cipher in wrong state"));
108	else if (err_num == BAD_BLOCK_LENGTH)
109	return (_("Bad block length"));
110	else if (err_num == BAD_CIPHER_INSTANCE)
111	return (_("Bad cipher instance"));
112	else if (err_num == BAD_DATA)
113	return (_("Data contents are invalid"));
114	else
115	return (_("Unknown error"));
116	}
117
118	#endif
119
120	/* --- recode all \blah escapes to '=XX' format, and also code all
121	* remaining unprintable chars ---
122	*/
123	#define SH_PUT_4(p, a, b, c) (p)[0] = (a); (p)[1] = (b); (p)[2] = (c);
124
125	char * sh_tools_safe_name (const char * instr, int flag)
126	{
127	unsigned char c, d;
128	const char * p;
129	char tmp[4];
130	char * outstr;
131	size_t len = 1;
132	int i = 0;
133	unsigned char val_octal = '\0';
134	static char ctable[16] = { '0', '1', '2', '3', '4', '5', '6', '7',
135	'8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
136
137	SL_ENTER(_("sh_tools_safe_name"));
138
139	if (instr)
140	{
141	len = strlen(instr);
142	if (sl_ok_muls (3, len) && sl_ok_adds ((3*len), 4))
143	{
144	len = (3 * len) + 4;
145	p = instr;
146	}
147	else
148	{
149	len = 1;
150	p = NULL;
151	}
152	}
153	else
154	{
155	p = NULL;
156	}
157
158	outstr = SH_ALLOC(len);
159
160	outstr[0] = '\0';
161	tmp[3] = '\0';
162
163	#if !defined(SH_USE_XML)
164	(void) flag; /* fix compiler warning */
165	#endif
166
167	if (!p)
168	goto end;
169
170	while (*p)
171	{
172	c = *p;
173
174	if (*p == '\n')
175	{
176	outstr[i] = ' '; ++i; ++p;
177	continue;
178	}
179
180	#ifdef SH_USE_XML
181	if (flag == 1)
182	{
183	if ((*p) == '"')
184	{
185	SH_PUT_4(&outstr[i], '=', '2', '2');
186	i+=3; ++p;
187	continue;
188	}
189	else if ((*p) == '&')
190	{
191	SH_PUT_4(&outstr[i], '=', '2', '6');
192	i+=3; ++p;
193	continue;
194	}
195	else if ((*p) == '<')
196	{ /* left angle */
197	SH_PUT_4(&outstr[i], '=', '3', 'c');
198	i+=3; ++p;
199	continue;
200	}
201	else if ((*p) == '>')
202	{ /* right angle */
203	SH_PUT_4(&outstr[i], '=', '3', 'e');
204	i+=3; ++p;
205	continue;
206	}
207	}
208	#endif
209
210	if ( (p) != '\\' && (p) != '&' && (p) != '=' && (p) != '\'')
211	{
212	outstr[i] = *p; ++i;
213	++p;
214
215	if (c < 31 \|\| c > 126)
216	{
217	--i;
218	d = c % 16; c = c / 16;
219	outstr[i] = '='; ++i;
220	outstr[i] = ctable[c]; ++i;
221	outstr[i] = ctable[d]; ++i;
222	}
223
224	continue;
225	}
226	else if ((*p) == '\'')
227	{
228	SH_PUT_4(&outstr[i], '=', '2', '7');
229	i+=3; ++p;
230	}
231	else if (*p == '=')
232	{
233	if (p[1] != '"' && p[1] != '<')
234	{
235	SH_PUT_4(&outstr[i], '=', '3', 'd');
236	i+=3; ++p;
237	}
238	else
239	{ outstr[i] = *p; ++i; ++p; }
240	}
241	else if (*p == '\\')
242	{
243	++p;
244	if (!p)
245	break;
246	if (!(*p))
247	break;
248
249	c = *p;
250
251	switch (*p) {
252	case '\\':
253	SH_PUT_4(&outstr[i], '=', '5', 'c');
254	i+=3; ++p;
255	break;
256	case 'n':
257	SH_PUT_4(&outstr[i], '=', '0', 'a');
258	i+=3; ++p;
259	break;
260	case 'b':
261	SH_PUT_4(&outstr[i], '=', '0', '8');
262	i+=3; ++p;
263	break;
264	case 'r':
265	SH_PUT_4(&outstr[i], '=', '0', 'd');
266	i+=3; ++p;
267	break;
268	case 't':
269	SH_PUT_4(&outstr[i], '=', '0', '9');
270	i+=3; ++p;
271	break;
272	case 'v':
273	SH_PUT_4(&outstr[i], '=', '0', 'b');
274	i+=3; ++p;
275	break;
276	case 'f':
277	SH_PUT_4(&outstr[i], '=', '0', 'c');
278	i+=3; ++p;
279	break;
280	case '\'':
281	SH_PUT_4(&outstr[i], '=', '2', '7');
282	i+=3; ++p;
283	break;
284	case '"': /* also encode quoted '"' */
285	SH_PUT_4(&outstr[i], '=', '2', '2');
286	i+=3; ++p;
287	break;
288	case ' ':
289	SH_PUT_4(&outstr[i], '=', '2', '0');
290	i+=3; ++p;
291	break;
292	default:
293	if (strlen(p) < 3) /* certainly not an octal number, skip */
294	{
295	p += strlen(p);
296	}
297	else
298	{
299	tmp[0] = p[0]; tmp[1] = p[1]; tmp[2] = p[2];
300	val_octal = (unsigned char) strtoul(tmp, (char **)NULL, 8);
301	if (val_octal != '\0') {
302	c = val_octal;
303	d = c % 16; c = c / 16;
304	outstr[i] = '='; ++i;
305	outstr[i] = ctable[c]; ++i;
306	outstr[i] = ctable[d]; ++i;
307	}
308	p += 3;
309	}
310	}
311	}
312	else if (*p == '&')
313	{
314	++p;
315	if (!p \|\| !(*p))
316	{
317	outstr[i] = '&'; ++i;
318	break;
319	}
320
321	if (p[0] == 'a' && p[1] == 'm' && p[2] == 'p' && p[3] == ';')
322	{
323	SH_PUT_4(&outstr[i], '=', '2', '6');
324	i+=3; p += 4;
325	}
326	else if (p[0] == 'q' && p[1] == 'u' && p[2] == 'o' && p[3] == 't' &&
327	p[4] == ';')
328	{
329	SH_PUT_4(&outstr[i], '=', '2', '2');
330	i+=3; p += 5;
331	}
332	else if (p[0] == 'l' && p[1] == 't' && p[2] == ';')
333	{
334	SH_PUT_4(&outstr[i], '=', '3', 'c');
335	i+=3; p += 3;
336	}
337	else if (p[0] == 'g' && p[1] == 't' && p[2] == ';')
338	{
339	SH_PUT_4(&outstr[i], '=', '3', 'e');
340	i+=3; p += 3;
341	}
342	else /* conserve the '&' */
343	{
344	outstr[i] = '&'; ++i;
345	}
346	}
347	else
348	{
349	outstr[i] = *p; ++i;
350	++p;
351	}
352	} /* while (p && p) /
353
354	end:
355
356	outstr[i] = '\0';
357	SL_RETURN( outstr, _("sh_tools_safe_name"));
358	}
359
360
361	/* extern int h_errno; */
362
363	char * sh_tools_errmessage (int tellme)
364	{
365
366	#ifdef HOST_NOT_FOUND
367	if (tellme == HOST_NOT_FOUND)
368	return _("The specified host is unknown: ");
369	#endif
370	#ifdef NO_ADDRESS
371	if (tellme == NO_ADDRESS)
372	return _("The requested name is valid but does not have an IP address: ");
373	#endif
374	#ifdef NO_RECOVERY
375	if (tellme == NO_RECOVERY)
376	return _("A non-recoverable name server error occurred: ");
377	#endif
378	#ifdef TRY_AGAIN
379	if (tellme == TRY_AGAIN)
380	return _("A temporary error occurred on an authoritative name server. The specified host is unknown: ");
381	#endif
382	return _("Unknown error");
383	}
384
385	int is_numeric (const char * address)
386	{
387	int j;
388	int len = sl_strlen(address);
389
390	for (j = 0; j < len; ++j)
391	if ( (address[j] < '0' \|\| address[j] > '9') && address[j] != '.')
392	return (1 == 0);
393	return (1 == 1);
394	}
395
396	#if defined (SH_WITH_SERVER)
397
398	int get_open_max ()
399	{
400	int value;
401
402	#ifdef _SC_OPEN_MAX
403	value = sysconf (_SC_OPEN_MAX);
404	#else
405	#ifdef OPEN_MAX
406	value = OPEN_MAX;
407	#else
408	value = _POSIX_OPEN_MAX;
409	#endif
410	#endif
411
412	if (value < 0)
413	value = 8; /* POSIX lower limit */
414
415	if (value > 4096)
416	value = 4096;
417
418	return value;
419	}
420
421	#endif
422
423	typedef struct _sin_cache {
424	char * address;
425	struct sockaddr_in sin;
426	struct _sin_cache * next;
427	} sin_cache;
428
429	static sin_cache * conn_cache = NULL;
430	static int cached_addr = 0;
431
432	void delete_cache()
433	{
434	sin_cache * check_cache = conn_cache;
435	sin_cache * old_entry = conn_cache;
436
437	SL_ENTER(_("delete_cache"));
438
439	while (check_cache != NULL)
440	{
441	old_entry = check_cache;
442	check_cache = check_cache->next;
443	SH_FREE(old_entry->address);
444	SH_FREE(old_entry);
445	}
446
447	cached_addr = 0;
448
449	conn_cache = NULL;
450	SL_RET0(_("delete_cache"));
451	}
452
453	int DoReverseLookup = S_TRUE;
454
455	int set_reverse_lookup (const char * c)
456	{
457	return sh_util_flagval(c, &DoReverseLookup);
458	}
459
460	int connect_port (char * address, int port,
461	char * ecall, int * errnum, char * errmsg, int errsiz)
462	{
463	struct in_addr haddr; /* host address from numeric */
464	/* host details returned by the DNS */
465	struct hostent *host_entry = NULL;
466	struct sockaddr_in sinr; /* socket to the remote host */
467
468	char * host_name;
469
470	int fd = (-1);
471	int status;
472	int fail = 0;
473	int cached = 0;
474
475	int retval;
476
477	sin_cache * check_cache = conn_cache;
478
479	SL_ENTER(_("connect_port"));
480
481	/* paranoia -- should not happen
482	*/
483	if (cached_addr > 128)
484	delete_cache();
485
486	if (check_cache != NULL)
487	{
488	while (check_cache && check_cache->address)
489	{
490	if ( 0 == sl_strncmp(check_cache->address,
491	address, sl_strlen(address)))
492	{
493	memcpy (&sinr, &(check_cache->sin), sizeof(struct sockaddr_in));
494	sinr.sin_family = AF_INET;
495	sinr.sin_port = htons (port);
496	cached = 1;
497	break;
498	}
499	if (check_cache->next)
500	check_cache = check_cache->next;
501	else
502	check_cache = NULL;
503	}
504	}
505
506	/* only use gethostbyname() if neccessary
507	*/
508	if (cached == 0)
509	{
510	#ifdef HAVE_INET_ATON
511	if (0 == inet_aton(address, &haddr))
512	#else
513	if ((unsigned long)-1 == (haddr.s_addr = inet_addr(address)))
514	#endif
515	{
516
517	host_entry = sh_gethostbyname(address);
518
519	if (host_entry == NULL \|\| host_entry->h_addr == NULL)
520	{
521	sl_strlcpy(ecall, _("gethostbyname"), SH_MINIBUF);
522	#ifndef NO_H_ERRNO
523	*errnum = h_errno;
524	#else
525	*errnum = 666;
526	#endif
527	sl_strlcpy(errmsg, sh_tools_errmessage (*errnum), errsiz);
528	sl_strlcat(errmsg, address, errsiz);
529	fail = (-1);
530	}
531	else
532	{
533	sinr.sin_family = AF_INET;
534	sinr.sin_port = htons (port);
535	sinr.sin_addr = (struct in_addr ) host_entry->h_addr;
536
537
538	/* reverse DNS lookup
539	*/
540	if (DoReverseLookup == S_TRUE)
541	{
542	if (host_entry->h_name == NULL)
543	{
544	host_name = SH_ALLOC(1);
545	host_name[0] = '\0';
546	}
547	else
548	{
549	host_name = sh_util_strdup(host_entry->h_name);
550	}
551
552	host_entry = sh_gethostbyaddr ((char *) &sinr.sin_addr,
553	sizeof(struct in_addr),
554	AF_INET);
555	if (host_entry == NULL \|\| host_entry->h_name == NULL)
556	{
557	sl_strlcpy(ecall, _("gethostbyaddr"), SH_MINIBUF);
558	#ifndef NO_H_ERRNO
559	*errnum = h_errno;
560	#else
561	*errnum = 666;
562	#endif
563	sl_strlcpy(errmsg,
564	sh_tools_errmessage (*errnum), errsiz);
565	sl_strlcat(errmsg,
566	inet_ntoa ((struct in_addr ) &(sinr.sin_addr)),
567	errsiz);
568	fail = (-1);
569	}
570	else
571	{
572	*errnum = 0;
573	if (sl_strlen(host_entry->h_name) == 0 \|\|
574	(*errnum = sl_strcmp(host_name,host_entry->h_name)) != 0)
575	{
576	if (*errnum)
577	sl_strlcpy(ecall, _("strcmp"), SH_MINIBUF);
578	else
579	sl_strlcpy(ecall, _("strlen"), SH_MINIBUF);
580	sl_strlcpy(errmsg, _("Reverse lookup failed."),
581	errsiz);
582	sl_strlcat(errmsg, address, errsiz);
583	sl_strlcat(errmsg, _(" vs "), errsiz);
584	sl_strlcat(errmsg,
585	inet_ntoa ((struct in_addr ) &(sinr.sin_addr)),
586	errsiz);
587	fail = -1;
588	}
589	}
590
591	SH_FREE(host_name);
592	}
593	}
594	}
595
596	else /* address was numeric */
597	{
598	sinr.sin_family = AF_INET;
599	sinr.sin_port = htons (port);
600	sinr.sin_addr = haddr;
601	}
602
603
604	if (fail != -1)
605	{
606	/* put it into the cache
607	*/
608	check_cache = SH_ALLOC(sizeof(sin_cache));
609	check_cache->address = SH_ALLOC(sl_strlen(address) + 1);
610	sl_strlcpy (check_cache->address, address, sl_strlen(address) + 1);
611	memcpy(&(check_cache->sin), &sinr, sizeof(struct sockaddr_in));
612	++cached_addr;
613
614	if (conn_cache)
615	{
616	if (conn_cache->next)
617	check_cache->next = conn_cache->next;
618	else
619	check_cache->next = NULL;
620	conn_cache->next = check_cache;
621	}
622	else
623	{
624	check_cache->next = NULL;
625	conn_cache = check_cache;
626	}
627	}
628	}
629
630
631	if (fail != (-1))
632	{
633	fd = socket(AF_INET, SOCK_STREAM, 0);
634	if (fd < 0) {
635	fail = (-1);
636	status = errno;
637	sl_strlcpy(ecall, _("socket"), SH_MINIBUF);
638	*errnum = status;
639	sl_strlcpy(errmsg, sh_error_message (status), errsiz);
640	sl_strlcat(errmsg, _(", address "), errsiz);
641	sl_strlcat(errmsg, address, errsiz);
642	}
643	}
644
645	if (fail != (-1)) {
646
647	if ( retry_connect(FIL__, __LINE__, fd,
648	(struct sockaddr *) &sinr, sizeof(sinr)) < 0)
649	{
650	status = errno;
651	sl_strlcpy(ecall, _("connect"), SH_MINIBUF);
652	*errnum = status;
653	sl_strlcpy(errmsg, sh_error_message (status), errsiz);
654	sl_strlcat(errmsg, _(", address "), errsiz);
655	sl_strlcat(errmsg, address, errsiz);
656	close(fd);
657	fail = (-1);
658	}
659	}
660
661	retval = (fail < 0) ? (-1) : fd;
662	SL_RETURN(retval, _("connect_port"));
663	}
664
665	int connect_port_2 (char * address1, char * address2, int port,
666	char * ecall, int * errnum, char * errmsg, int errsiz)
667	{
668	int retval = (-1);
669
670	SL_ENTER(_("connect_port_2"));
671
672	errmsg[0] = '\0';
673	*errnum = 0;
674
675	if (address1 != NULL && address1[0] != '\0')
676	retval = connect_port (address1, port,
677	ecall, errnum,
678	errmsg, errsiz);
679
680	if (retval < 0 && address2 != NULL && address2[0] != '\0')
681	{
682	/* can't use sh_error_handle here, as this would cause an infinite
683	* loop if called from sh_unix_time
684	*/
685	TPT(( 0, FIL__, __LINE__, _("msg=<Using alternative server %s.>\n"),
686	address2));
687	retval = connect_port (address2, port,
688	ecall, errnum,
689	errmsg, errsiz);
690	}
691
692	if ((retval < 0) &&
693	(address1 == NULL \|\| address1[0] == '\0') &&
694	(address1 == NULL \|\| address1[0] == '\0'))
695	{
696	sl_strlcpy(ecall, _("connect_port_2"), SH_MINIBUF);
697	sl_strlcpy(errmsg, _("No server address known"), errsiz);
698	}
699	SL_RETURN(retval, _("connect_port_2"));
700	/* return retval; */
701	}
702
703	#if defined(HAVE_NTIME) \|\| defined(SH_WITH_CLIENT) \|\| defined(SH_WITH_SERVER)
704	static
705	int sh_write_select(int type, int sockfd,
706	char *buf, int nbytes,
707	int * w_error, int timeout)
708	{
709	int countbytes, count;
710	fd_set fds;
711	struct timeval tv;
712	int select_now;
713	int num_sel;
714
715	struct sigaction new_act;
716	struct sigaction old_act;
717
718	SL_ENTER(_("sh_write_select"));
719
720	/* ignore SIGPIPE (instead get EPIPE if connection is closed)
721	*/
722	new_act.sa_handler = SIG_IGN;
723	sigemptyset( &new_act.sa_mask ); /* set an empty mask */
724	new_act.sa_flags = 0; /* init sa_flags */
725	sigaction (SIGPIPE, &new_act, &old_act);
726
727	FD_ZERO(&fds);
728	FD_SET(sockfd, &fds);
729
730	countbytes = 0;
731	tv.tv_sec = 1;
732	tv.tv_usec = 0;
733	select_now = 0;
734
735	*w_error = 0;
736
737	while ( countbytes < nbytes ) {
738
739	FD_ZERO(&fds);
740	FD_SET(sockfd, &fds);
741
742	if (type == SH_DO_WRITE)
743	{
744	if ( (num_sel = select (sockfd+1, NULL, &fds, NULL, &tv)) == -1)
745	{
746	if (sig_raised == 1)
747	{
748	sig_raised = 2;
749	continue;
750	}
751	if ( errno == EINTR) /* try again */
752	continue;
753	*w_error = errno;
754	TPT(( 0, FIL__, __LINE__, _("msg=<select: %s>\n"),
755	sh_error_message(*w_error)));
756	sigaction (SIGPIPE, &old_act, NULL);
757	SL_RETURN( countbytes, _("sh_write_select"));
758	}
759	}
760	else
761	{
762	if ( (num_sel = select (sockfd+1, &fds, NULL, NULL, &tv)) == -1)
763	{
764	if (sig_raised == 1)
765	{
766	sig_raised = 2;
767	continue;
768	}
769	if ( errno == EINTR ) /* try again */
770	continue;
771	*w_error = errno;
772	TPT(( 0, FIL__, __LINE__, _("msg=<select: %s>\n"),
773	sh_error_message(*w_error)));
774	sigaction (SIGPIPE, &old_act, NULL);
775	SL_RETURN( countbytes, _("sh_write_select"));
776	}
777	}
778
779	/* on Linux, timeout is modified to reflect the amount of
780	* time not slept
781	*/
782	tv.tv_sec = 1;
783	tv.tv_usec = 0;
784
785
786	/* let's not hang on forever
787	*/
788	if (num_sel == 0)
789	{
790	++select_now; /* timeout */
791	if ( select_now > timeout ) /* 5 minutes */
792	{
793	#ifdef ETIMEDOUT
794	*w_error = ETIMEDOUT;
795	#else
796	*w_error = 0;
797	#endif
798	sigaction (SIGPIPE, &old_act, NULL);
799	TPT(( 0, FIL__, __LINE__, _("msg=<Timeout>\n")));
800	SL_RETURN( countbytes, _("sh_write_select"));
801	}
802	}
803
804	if ( FD_ISSET (sockfd, &fds) )
805	{
806	if (type == SH_DO_WRITE)
807	count = write (sockfd, buf, nbytes-countbytes);
808	else
809	count = read (sockfd, buf, nbytes-countbytes);
810
811	if (count > 0)
812	{
813	countbytes += count;
814	buf += count; /* move buffer pointer forward */
815	if (countbytes < nbytes) FD_SET( sockfd, &fds );
816	}
817	else if (count < 0 && errno == EINTR)
818	{
819	FD_SET( sockfd, &fds );
820	}
821	else if (count < 0)
822	{
823	*w_error = errno;
824	sigaction (SIGPIPE, &old_act, NULL);
825	TPT(( 0, FIL__, __LINE__, _("msg=<count < 0>\n")));
826	SL_RETURN( countbytes, _("sh_write_select"));
827	}
828	else /* count == 0 */
829	{
830	*w_error = errno;
831	sigaction (SIGPIPE, &old_act, NULL);
832	TPT(( 0, FIL__, __LINE__, _("msg=<count == 0>\n")));
833	SL_RETURN( countbytes, _("sh_write_select"));
834	}
835	}
836	}
837
838
839	/* restore signal handler
840	*/
841	sigaction (SIGPIPE, &old_act, NULL);
842
843	*w_error = 0;
844
845	TPT(( 0, FIL__, __LINE__, _("msg=<count = %d>\n"), countbytes));
846	SL_RETURN( countbytes, _("sh_write_select"));
847	}
848	#endif
849
850	#if defined (SH_WITH_CLIENT) \|\| defined(SH_WITH_SERVER)
851	unsigned long write_port (int sockfd, char *buf, unsigned long nbytes,
852	int * w_error, int timeout)
853	{
854	unsigned long bytes;
855	char errmsg[256];
856
857	SL_ENTER(_("write_port"));
858
859	bytes = sh_write_select(SH_DO_WRITE, sockfd, buf, nbytes, w_error, timeout);
860	if (*w_error != 0)
861	{
862	sl_strlcpy(errmsg, sh_error_message (*w_error), sizeof(errmsg));
863	sh_error_handle((-1), FIL__, __LINE__, *w_error, MSG_TCP_NETRP,
864	errmsg, (long) sockfd, _("write_port"));
865	}
866	SL_RETURN( bytes, _("write_port"));
867	}
868	#endif
869
870	#if defined(HAVE_NTIME) \|\| defined(SH_WITH_CLIENT) \|\| defined(SH_WITH_SERVER)
871
872	unsigned long read_port (int sockfd, char *buf, unsigned long nbytes,
873	int * w_error, int timeout)
874	{
875	unsigned long bytes;
876	char errmsg[256];
877
878	SL_ENTER(_("read_port"));
879
880	bytes = sh_write_select(SH_DO_READ, sockfd, buf, nbytes, w_error, timeout);
881	if (*w_error != 0)
882	{
883	sl_strlcpy(errmsg, sh_error_message (*w_error), sizeof(errmsg));
884	sh_error_handle((-1), FIL__, __LINE__, *w_error, MSG_TCP_NETRP,
885	errmsg, (long) sockfd, _("read_port"));
886	}
887	SL_RETURN( bytes, _("read_port"));
888	}
889	#endif
890
891	#if defined(SH_WITH_CLIENT) \|\| defined(SH_WITH_SERVER)
892
893	int check_request_nerr (char * have, char * need)
894	{
895	SL_ENTER(_("check_request_nerr"));
896	ASSERT_RET((have != NULL && need != NULL),
897	_("have != NULL && need != NULL"), (-1))
898
899	if ( (have[0] == need[0]) && (have[1] == need[1]) &&
900	(have[2] == need[2]) && (have[3] == need[3]))
901	SL_RETURN(0, _("check_request_nerr"));
902	SL_RETURN((-1), _("check_request_nerr"));
903	}
904	#endif
905
906	#if defined (SH_WITH_CLIENT) \|\| defined(SH_WITH_SERVER)
907
908	int check_request (char * have, char * need)
909	{
910	char first[21], second[5];
911	int i;
912
913	SL_ENTER(_("check_request"));
914	i = check_request_nerr (have, need);
915
916	if (i == 0)
917	SL_RETURN(0, _("check_request"));
918
919	for (i = 0; i < 4; ++i)
920	{
921	second[i] = need[i];
922	sprintf(&first[i4], _("%c%03o"), / known to fit */
923	'\\', (unsigned char) have[i]);
924	}
925
926	first[20] = '\0'; second[4] = '\0';
927
928	sh_error_handle((-1), FIL__, __LINE__, EINVAL, MSG_E_NETST,
929	second, first);
930	SL_RETURN((-1), _("check_request"));
931	}
932	#endif
933
934	#if defined (SH_WITH_SERVER)
935
936	int check_request_s (char * have, char * need, char * clt)
937	{
938	char first[21], second[5];
939	int i;
940
941	SL_ENTER(_("check_request_s"));
942	i = check_request_nerr (have, need);
943
944	if (i == 0)
945	SL_RETURN( (0), _("check_request_s"));
946
947	for (i = 0; i < 4; ++i)
948	{
949	second[i] = need[i];
950	sprintf(&first[i4], _("%c%03o"), / known to fit */
951	'\\', (unsigned char) have[i]);
952	}
953	first[20] = '\0'; second[4] = '\0';
954	sh_error_handle((-1), FIL__, __LINE__, EINVAL, MSG_E_NETST1,
955	second, first, clt);
956	SL_RETURN( (-1), _("check_request_s"));
957	}
958	#endif
959
960	#if defined (SH_WITH_CLIENT) \|\| defined (SH_WITH_SERVER)
961
962	void get_header (unsigned char * head, unsigned long * bytes, char * u)
963	{
964	SL_ENTER(_("get_header"));
965
966	*bytes =
967	(256 * (unsigned int)head[1] + (unsigned int)head[2]);
968
969	if (u != NULL)
970	{
971	u[0] = head[3];
972	u[1] = head[4];
973	u[2] = head[5];
974	u[3] = head[6];
975	u[4] = '\0';
976	}
977
978	SL_RET0(_("get_header"));
979	}
980	#endif
981
982	#if defined(SH_WITH_CLIENT) \|\| defined(SH_WITH_SERVER)
983
984	#ifdef SH_ENCRYPT_2
985	#define TRANS_BYTES 65120
986	#else
987	#define TRANS_BYTES 65280
988	#endif
989
990	void put_header (unsigned char * head, int protocol,
991	unsigned long * length, char * u)
992	{
993
994	/* static long transfer_limit = (8 * SH_BUFSIZE); V0.8 */
995	static unsigned long transfer_limit = TRANS_BYTES + 6 + KEY_LEN;
996
997	SL_ENTER(_("put_header"));
998
999	head[0] = protocol;
1000
1001	ASSERT((length < transfer_limit), _("length < transfer_limit"))
1002
1003	if (*length > transfer_limit)
1004	*length = transfer_limit;
1005
1006	head[1] = (unsigned int)(*length/256);
1007	head[2] = (unsigned int)(length-256 head[1]);
1008	if (u == NULL)
1009	{
1010	head[3] = 0x01;
1011	head[4] = 0x01;
1012	head[5] = 0x01;
1013	head[6] = 0x01;
1014	}
1015	else
1016	{
1017	head[3] = u[0];
1018	head[4] = u[1];
1019	head[5] = u[2];
1020	head[6] = u[3];
1021	}
1022
1023	SL_RET0(_("put_header"));
1024	}
1025	#endif
1026
1027	/* ------------------------------------------
1028	*
1029	* version 2 client/server protocol
1030	*
1031	* ------------------------------------------
1032	*
1033	* header : flag size[2]
1034	*
1035	* payload: random_pad[8] protocol[4] size[4] payload[payload_size] padding
1036	*
1037	* full_size <= 8192; payload_size <= 8176 (51116); msg_size <= 8128 (50816)
1038	* (msg_size = payload_size - key_len = payload_size - 48)
1039	*/
1040
1041	/*
1042	* only SH_V2_FULLSIZE is used, and only once
1043	*/
1044	#if 0
1045	#ifdef SH_WITH_SERVER
1046	#define SH_V2_FULLSIZE 240
1047	#define SH_V2_PAYLOAD 224
1048	#define SH_V2_MESSAGE 176
1049	#else
1050	#define SH_V2_FULLSIZE 1024
1051	#define SH_V2_PAYLOAD 1008
1052	#define SH_V2_MESSAGE 960
1053	#endif
1054	#endif
1055	#define SH_V2_FULLSIZE 1024
1056
1057	#ifdef SH_ENCRYPT
1058	#include "rijndael-api-fst.h"
1059	#endif
1060
1061	void sh_tools_show_header (unsigned char * head, char sign)
1062	{
1063	#define SH_IS_ASCII(c) (((c) & ~0x7f) == 0)
1064
1065
1066	int msg_size = (256 * (unsigned int)head[1] + (unsigned int)head[2]);
1067	char code[32];
1068	char * p = &code[0];
1069
1070	memset (code, ' ', 32); /* space */
1071
1072	if ((head[0] & SH_PROTO_SRP) != 0) { p[0]='S';p[1]='R';p[2]='P';}
1073	p += 4;
1074	if ((head[0] & SH_PROTO_MSG) != 0) { p[0]='M';p[1]='S';p[2]='G';}
1075	p += 4;
1076	if ((head[0] & SH_PROTO_BIG) != 0) { p[0]='B';p[1]='I';p[2]='G';}
1077	p += 4;
1078	if ((head[0] & SH_PROTO_END) != 0) { p[0]='E';p[1]='N';p[2]='D';}
1079	p += 4;
1080	if ((head[0] & SH_PROTO_ENC) != 0) { p[0]='E';p[1]='N';p[2]='C';}
1081	p += 4;
1082	if ((head[0] & SH_PROTO_EN2) != 0) { p[0]='E';p[1]='N';p[2]='2';}
1083	code[23] = '\0';
1084
1085	if (SH_IS_ASCII(head[3]) && isalpha(head[3]) &&
1086	SH_IS_ASCII(head[4]) && isalpha(head[4]) &&
1087	SH_IS_ASCII(head[5]) && isalpha(head[5]) &&
1088	SH_IS_ASCII(head[6]) && isalpha(head[6])) {
1089	fprintf(stderr, "%c %3o %s %5d %c %c %c %c\n", sign,
1090	head[0], code, msg_size, head[3], head[4], head[5], head[6]);
1091	} else {
1092	fprintf(stderr, "%c %3o %s %5d %2X %2X %2X %2X\n", sign,
1093	head[0], code, msg_size, head[3], head[4], head[5], head[6]);
1094	}
1095	return;
1096	}
1097
1098	#ifdef SH_ENCRYPT
1099	/*
1100	* #define DEBUG_EN2
1101	*
1102	* ingest version 1 7-byte header and payload, return version2 header/payload
1103	* last 4 bytes of outgoing header are set to dummy value
1104	*/
1105	char * sh_tools_makePack (unsigned char * header,
1106	char * payload, unsigned long payload_size,
1107	keyInstance * keyInstE)
1108	{
1109	UINT32 rpad[3];
1110	unsigned char head[16];
1111	double epad;
1112	unsigned long i_epad = 0;
1113	unsigned long i_blk = payload_size / 16;
1114	unsigned long i_blkmax = SH_V2_FULLSIZE / 16;
1115	unsigned long pads = 0;
1116	size_t full_size;
1117	char * full_ret;
1118
1119	char * p;
1120	RIJ_BYTE inBlock[B_SIZ];
1121	RIJ_BYTE outBlock[B_SIZ];
1122	int j;
1123	cipherInstance cipherInst;
1124	int err_num;
1125	int blkfac;
1126	int oflow = 0;
1127
1128	/*
1129	SL_REQUIRE (i_blk*16 == payload_size, _("payload_size % 16 != 0"));
1130	*/
1131	if ((i_blk * 16) != payload_size) ++i_blk;
1132	#ifdef DEBUG_EN2
1133	fprintf(stderr, "SEND <%d> blocks <%d>\n", payload_size, i_blk);
1134	#endif
1135	/* random_pad
1136	*/
1137	rpad[1] = taus_get (&(skey->rng0[0]), &(skey->rng1[0]), &(skey->rng2[0]));
1138	memcpy (head, &rpad[1], 4);
1139	rpad[0] = taus_get (&(skey->rng0[0]), &(skey->rng1[0]), &(skey->rng2[0]));
1140	memcpy (&head[4], &rpad[0], 4);
1141	rpad[2] = taus_get (&(skey->rng0[0]), &(skey->rng1[0]), &(skey->rng2[0]));
1142	memcpy (&head[8], &rpad[2], 4);
1143
1144	/* protocol
1145	*/
1146	/* memcpy (&head[8], &header[3], 4); */
1147
1148	/* size (payload)
1149	*/
1150	head[12] = header[1];
1151	head[13] = header[2];
1152	head[14] = '\0';
1153	head[15] = '\0';
1154
1155	if (i_blk < i_blkmax)
1156	{
1157	pads = i_blkmax - i_blk;
1158	/* memcpy((char ) &rpad[2], &head[12], 4); /
1159	epad = taus_get_double (&rpad);
1160	#ifdef DEBUG_EN2
1161	fprintf(stderr, "PAD1 <%d> <%f>\n", pads, epad);
1162	#endif
1163	i_epad = (unsigned long) (pads * epad);
1164	#ifdef DEBUG_EN2
1165	fprintf(stderr, "PAD2 <%d> <%d>\n", i_epad, (i_epad*16));
1166	#endif
1167	}
1168
1169	full_size = 16; /* head */
1170	if (sl_ok_muls(i_blk, 16) && sl_ok_adds(full_size, (i_blk*16)))
1171	full_size = full_size + (i_blk16); / payload */
1172	else
1173	oflow = 1;
1174	if (sl_ok_adds(full_size, (i_epad*16)))
1175	full_size = full_size + (i_epad16); / pad */
1176	else
1177	i_epad = 0;
1178
1179	if (oflow)
1180	{
1181	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
1182	_("integer overflow"),
1183	_("sh_tools_makePack"));
1184	}
1185
1186	full_ret = SH_ALLOC(full_size);
1187	memcpy(full_ret, head, 16);
1188	if (payload != NULL && !oflow)
1189	{
1190	memcpy(&full_ret[16], payload, payload_size);
1191	}
1192	if ((i_blk*16) > payload_size && !oflow)
1193	{
1194	#ifdef DEBUG_EN2
1195	fprintf(stderr, "SEN2 <%d>\n", (i_blk*16) - payload_size);
1196	#endif
1197	memset(&full_ret[16+payload_size], '\0', (i_blk*16) - payload_size);
1198	payload_size = i_blk * 16;
1199	}
1200	memset(&full_ret[16+payload_size], '\0', i_epad*16);
1201	#ifdef DEBUG_EN2
1202	fprintf(stderr, "SEN3 <%d> <%d>\n", full_size, i_epad*16);
1203	#endif
1204
1205	/* rewrite header
1206	*/
1207	header[1] = (unsigned int)(full_size/256);
1208	header[2] = (unsigned int)(full_size - (256 * header[1]));
1209	/* don't erase protocol from header
1210	memset(&header[3], '\0', 4);
1211	*/
1212	p = full_ret; blkfac = full_size / 16;
1213
1214	err_num = cipherInit (&cipherInst, MODE_CBC, NULL);
1215
1216	if (err_num < 0)
1217	{
1218	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
1219	errorExplain(err_num),
1220	_("sh_tools_makePack: cipherInit"));
1221	}
1222	for (j = 0; j < blkfac; ++j)
1223	{
1224	memcpy(inBlock, p, B_SIZ);
1225	err_num = blockEncrypt(&cipherInst, keyInstE,
1226	inBlock, 128 * BNUM, outBlock);
1227	if (err_num < 0)
1228	{
1229	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
1230	errorExplain(err_num),
1231	_("sh_tools_makePack: blockEncrypt"));
1232	}
1233	memcpy(p, outBlock, B_SIZ);
1234	p += B_SIZ;
1235	}
1236
1237	return full_ret;
1238	}
1239
1240	/* write a 7-byte header and return payload as expected by version 1
1241	* last 4 bytes of incoming header are dummy
1242	*/
1243	char * sh_tools_revertPack (unsigned char * header, char * message,
1244	keyInstance * keyInstD,
1245	unsigned long message_size)
1246	{
1247	unsigned long msg_size;
1248	char * msg_ret;
1249
1250	char * p;
1251	RIJ_BYTE inBlock[B_SIZ];
1252	RIJ_BYTE outBlock[B_SIZ];
1253	int j;
1254	cipherInstance cipherInst;
1255	int err_num;
1256	int blkfac;
1257
1258	msg_size = (256 * (unsigned int)header[1] + (unsigned int)header[2]);
1259	#ifdef DEBUG_EN2
1260	fprintf(stderr, "RECV <%lu>\n", msg_size);
1261	#endif
1262	if (msg_size > message_size) {
1263	msg_size = message_size;
1264	#ifdef DEBUG_EN2
1265	fprintf(stderr, "RECV TRUNC1 <%lu>\n", msg_size);
1266	#endif
1267	}
1268
1269	p = message; blkfac = msg_size / 16;
1270
1271	err_num = cipherInit (&cipherInst, MODE_CBC, NULL);
1272
1273	if (err_num < 0)
1274	{
1275	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
1276	errorExplain(err_num),
1277	_("sh_tools_revertPack: cipherInit"));
1278	}
1279	for (j = 0; j < blkfac; ++j)
1280	{
1281	memcpy(inBlock, p, B_SIZ);
1282	err_num = blockDecrypt(&cipherInst, keyInstD,
1283	inBlock, 128 * BNUM, outBlock);
1284	if (err_num < 0)
1285	{
1286	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
1287	errorExplain(err_num),
1288	_("sh_tools_revertPack: blockDecrypt"));
1289	}
1290	memcpy(p, outBlock, B_SIZ);
1291	p += B_SIZ;
1292	}
1293
1294	/* rewrite size in header
1295	*/
1296	header[1] = message[12];
1297	header[2] = message[13];
1298	msg_size = (256 * (unsigned int)header[1] + (unsigned int)header[2]);
1299
1300	if (msg_size > (message_size-16))
1301	{
1302	msg_size = message_size-16;
1303	header[1] = (unsigned int)(msg_size/256);
1304	header[2] = (unsigned int)(msg_size - (256 * header[1]));
1305	#ifdef DEBUG_EN2
1306	fprintf(stderr, "RECV TRUNC2 <%lu>\n", msg_size);
1307	#endif
1308	}
1309	#ifdef DEBUG_EN2
1310	fprintf(stderr, "REC2 <%lu>\n", msg_size);
1311	#endif
1312	/* protocol
1313	*/
1314	/* memcpy(&header[3], &message[8], 4); */
1315
1316	/* payload
1317	*/
1318	msg_ret = SH_ALLOC(msg_size+1);
1319	if (msg_size > 0)
1320	{
1321	memcpy(msg_ret, &message[16], msg_size);
1322	}
1323	msg_ret[msg_size] = '\0';
1324	#ifdef DEBUG_EN2
1325	fprintf(stderr, "REC3 <%lu>\n", msg_size);
1326	#endif
1327	SH_FREE(message);
1328
1329	return msg_ret;
1330	}
1331	#endif
1332
1333	int sh_tools_hash_add(char * key, char * buf, int buflen)
1334	{
1335	char * theSig;
1336
1337	SL_ENTER(_("sh_tools_hash_add"));
1338
1339	theSig = sh_util_siggen (key, buf, buflen);
1340	sl_strlcat(buf, theSig, buflen + KEY_LEN + 1);
1341
1342	SL_RETURN((0), _("sh_tools_hash_add"));
1343	}
1344
1345
1346	/* return 0 (== FALSE) if no match, else 1 (== TRUE)
1347	*/
1348	int sh_tools_hash_vfy(char * key, char * buf, int buflen)
1349	{
1350	char hash[KEY_LEN+1];
1351	register int i;
1352	char * theSig;
1353
1354	SL_ENTER(_("sh_tools_hash_vfy"));
1355
1356	theSig = sh_util_siggen (key, buf, buflen);
1357	sl_strlcpy(hash, theSig, KEY_LEN+1);
1358
1359	for (i = 0; i < KEY_LEN; ++i)
1360	{
1361	if (buf[buflen + i] != hash[i])
1362	SL_RETURN((0), _("sh_tools_hash_vfy"));
1363	}
1364
1365	SL_RETURN((1), _("sh_tools_hash_vfy"));
1366	}
1367
1368	/* ------------------------------------------ */
1369
1370	#if defined (SH_WITH_SERVER)
1371
1372	/* add a checksum to a buffer; put checksum in front
1373	*/
1374	char * hash_me (char * key, char * buf, int buflen)
1375	{
1376	char hash[KEY_LEN+1];
1377	char * temp = NULL;
1378	register int i;
1379	int total = 0;
1380	char * theSig;
1381
1382
1383	SL_ENTER(_("hash_me"));
1384
1385	#ifdef DEBUG_EN2
1386	fprintf(stderr, "hash_me <%s> <%d>\n",
1387	(key == NULL) ? "NULL" : key, buflen);
1388	#endif
1389	/* key = H(NSRV,NCLT,SK)
1390	*/
1391	ASSERT_RET((key != NULL), _("key != NULL"), (NULL));
1392	ASSERT_RET((buflen >= 0), _("buflen >= 0"), (NULL));
1393
1394	theSig = sh_util_siggen (key, buf, buflen);
1395	sl_strlcpy(hash, theSig, KEY_LEN+1);
1396
1397	if (sl_ok_adds(buflen, KEY_LEN))
1398	{
1399	total = KEY_LEN + buflen;
1400	temp = SH_ALLOC (total);
1401
1402	for (i = 0; i < KEY_LEN; ++i)
1403	temp[i] = hash[i];
1404
1405	for (i = 0; i < buflen; ++i)
1406	temp[i+KEY_LEN] = buf[i];
1407	}
1408	else
1409	{
1410	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
1411	_("integer overflow"),
1412	_("hash_me"));
1413	temp = sh_util_strdup(buf);
1414	}
1415	SL_RETURN(temp, _("hash_me"));
1416	}
1417	#endif
1418
1419	#if defined(SH_WITH_CLIENT) \|\| defined(SH_WITH_SERVER)
1420
1421	/* verify the checksum of a buffer; checksum comes first
1422	*/
1423	int hash_check(char * key,
1424	char * buf, int buflen)
1425	{
1426	char hash[KEY_LEN+1];
1427	register int i;
1428	char * theSig;
1429
1430	SL_ENTER(_("hash_check"));
1431
1432	#ifdef DEBUG_EN2
1433	fprintf(stderr, "hash_check <%s> <%d>\n",
1434	(key == NULL) ? "NULL" : key, buflen);
1435	#endif
1436	theSig = sh_util_siggen (key, &buf[KEY_LEN], buflen-KEY_LEN);
1437	sl_strlcpy(hash, theSig, KEY_LEN+1);
1438
1439	for (i = 0; i < KEY_LEN; ++i)
1440	{
1441	if (buf[i] != hash[i])
1442	SL_RETURN((-1), _("hash_check"));
1443	}
1444	SL_RETURN((0), _("hash_check"));
1445	}
1446
1447	#endif
1448
1449	#if defined (SH_WITH_SERVER)
1450
1451	char * get_client_conf_file (char * peer, unsigned long * length)
1452	{
1453	char * ret;
1454	int status;
1455	struct stat buf;
1456	char * base;
1457	size_t size;
1458
1459	SL_ENTER(_("get_client_conf_file"));
1460
1461	base = sh_util_strdup(DEFAULT_DATAROOT);
1462
1463	size = sl_strlen(base);
1464	if (sl_ok_adds(size, sl_strlen(peer)))
1465	size += sl_strlen(peer);
1466	if (sl_ok_adds(size, 6))
1467	size += 6;
1468
1469	ret = SH_ALLOC(size);
1470	sl_strlcpy(ret, base, size);
1471	sl_strlcat(ret, _("/rc."), size);
1472	sl_strlcat(ret, peer, size);
1473
1474	status = retry_stat (FIL__, __LINE__, ret, &buf);
1475
1476	if (status == 0)
1477	goto lab_end;
1478	else
1479	sh_error_handle(SH_ERR_WARN, FIL__, __LINE__, status, MSG_E_ACCESS,
1480	(long) sh.effective.uid, ret);
1481
1482	sl_strlcpy(ret, base, size);
1483	sl_strlcat(ret, "/rc", size);
1484
1485	status = retry_stat (FIL__, __LINE__, ret, &buf);
1486
1487	if (status == 0)
1488	goto lab_end;
1489	else
1490	sh_error_handle(SH_ERR_ERR, FIL__, __LINE__, status, MSG_E_ACCESS,
1491	(long) sh.effective.uid, ret);
1492
1493	SH_FREE(base);
1494	SH_FREE(ret);
1495	*length=0;
1496	SL_RETURN(NULL, _("get_client_conf_file"));
1497
1498	lab_end:
1499	if (buf.st_size > 0x7fffffff)
1500	{
1501	sh_error_handle(SH_ERR_ERR, FIL__, __LINE__, status, MSG_E_SUBGEN,
1502	_("File too large"), _("get_client_conf_file"));
1503	SH_FREE(base);
1504	SL_RETURN(NULL, _("get_client_conf_file"));
1505	}
1506	*length = (unsigned long) buf.st_size;
1507	SH_FREE(base);
1508	SL_RETURN(ret, _("get_client_conf_file"));
1509	}
1510
1511	char * get_client_data_file (char * peer, unsigned long * length)
1512	{
1513	char * ret;
1514	int status;
1515	struct stat buf;
1516
1517	char * base;
1518	size_t size;
1519
1520	SL_ENTER(_("get_client_data_file"));
1521
1522	base = sh_util_strdup(DEFAULT_DATAROOT);
1523
1524	size = sl_strlen(base);
1525	if (sl_ok_adds(size, sl_strlen(peer)))
1526	size += sl_strlen(peer);
1527	if (sl_ok_adds(size, 8))
1528	size += 8;
1529
1530	ret = SH_ALLOC(size);
1531	sl_strlcpy(ret, base, size);
1532	sl_strlcat(ret, _("/file."), size);
1533	sl_strlcat(ret, peer, size);
1534
1535	status = retry_stat (FIL__, __LINE__, ret, &buf);
1536
1537	if (status == 0)
1538	goto lab1_end;
1539	else
1540	sh_error_handle(SH_ERR_WARN, FIL__, __LINE__, status, MSG_E_ACCESS,
1541	(long) sh.effective.uid, ret);
1542
1543
1544	sl_strlcpy(ret, base, size);
1545	sl_strlcat(ret, _("/file"), size);
1546
1547	status = retry_stat (FIL__, __LINE__, ret, &buf);
1548
1549	if (status == 0)
1550	goto lab1_end;
1551	else
1552	sh_error_handle(SH_ERR_WARN, FIL__, __LINE__, status, MSG_E_ACCESS,
1553	(long) sh.effective.uid, ret);
1554
1555
1556	*length = 0;
1557	SH_FREE(base);
1558	SH_FREE(ret);
1559	SL_RETURN(NULL, _("get_client_data_file"));
1560
1561	lab1_end:
1562	if (buf.st_size > 0x7fffffff)
1563	{
1564	sh_error_handle(SH_ERR_ERR, FIL__, __LINE__, status, MSG_E_SUBGEN,
1565	_("File too large"), _("get_client_data_file"));
1566	SH_FREE(base);
1567	SL_RETURN(NULL, _("get_client_data_file"));
1568	}
1569	*length = (unsigned long) buf.st_size;
1570	SH_FREE(base);
1571	SL_RETURN(ret, _("get_client_data_file"));
1572
1573	}
1574	#endif
1575
1576	#if defined(SH_WITH_CLIENT) \|\| defined(SH_WITH_SERVER) \|\| defined(SH_STEALTH) \|\| defined(WITH_GPG) \|\| defined(WITH_PGP)
1577
1578	/* --------- secure temporary file ------------ */
1579
1580	SL_TICKET open_tmp ()
1581	{
1582	SL_TICKET fd;
1583	UINT32 ticks;
1584	char * file;
1585	struct stat buf;
1586	int error;
1587	int status = BAD;
1588	char * my_tmp_dir;
1589
1590	SL_ENTER(_("open_tmp"));
1591
1592	#if defined(SH_TMPDIR)
1593	my_tmp_dir = sh_util_strdup(SH_TMPDIR);
1594	#else
1595	#if defined(SH_WITH_SERVER)
1596	my_tmp_dir = sh_util_strdup(DEFAULT_LOGDIR);
1597	#else
1598	my_tmp_dir = sh_util_strdup(sh.effective.home);
1599	#endif
1600	#endif
1601
1602	if (0 != tf_trust_check (my_tmp_dir, SL_YESPRIV))
1603	{
1604	dlog(1, FIL__, __LINE__,
1605	_("The directory for temporary files: %s is untrusted, i.e. an\nuntrusted user owns or can write to some directory in the path.\n"),
1606	my_tmp_dir);
1607	sh_error_handle ((-1), FIL__, __LINE__, EACCES, MSG_TRUST,
1608	(long) sh.effective.uid,
1609	my_tmp_dir);
1610	SH_FREE(my_tmp_dir);
1611	aud_exit (FIL__, __LINE__, EXIT_FAILURE);
1612	}
1613
1614	do {
1615
1616	/* create random filename in effective users home directory
1617	*/
1618	ticks = taus_get (&(skey->rng0[0]), &(skey->rng1[0]), &(skey->rng2[0]));
1619	if (my_tmp_dir[0] == '/' && my_tmp_dir[1] == '\0')
1620	file = sh_util_strconcat (my_tmp_dir,
1621	sh_tiger_hash( (char *) &ticks, TIGER_DATA, 4),
1622	NULL);
1623	else
1624	file = sh_util_strconcat (my_tmp_dir,
1625	"/",
1626	sh_tiger_hash( (char *) &ticks, TIGER_DATA, 4),
1627	NULL);
1628
1629	/* check whether it already exists (paranoia)
1630	*/
1631	errno = 0;
1632	status = retry_lstat(FIL__, __LINE__, file, &buf);
1633	error = errno;
1634
1635	if ( (status < 0) && (error == ENOENT) ) /* file does not exist */
1636	status = GOOD;
1637	else if (status < 0) /* unexpected error condition */
1638	{
1639	SH_FREE (file);
1640	SH_FREE(my_tmp_dir);
1641	TPT(( 0, FIL__, __LINE__, _("msg=<Unexpected error %d>\n"), error));
1642	SL_RETURN((-1), _("open_tmp"));
1643	}
1644	else /* file exists */
1645	{
1646	status = BAD;
1647	TPT(( 0, FIL__, __LINE__, _("msg=<Temporary file exists already>\n")));
1648	}
1649
1650	if (status == GOOD)
1651	{
1652	if (0 == tf_trust_check (file, SL_YESPRIV))
1653	status = GOOD;
1654	else
1655	{
1656	status = BAD;
1657	TPT(( 0, FIL__, __LINE__, _("msg=<Temporary file untrusted>\n")));
1658	}
1659	}
1660
1661	if (status == BAD)
1662	SH_FREE (file);
1663
1664	} while (status == BAD);
1665
1666	fd = sl_open_safe_rdwr (file, SL_YESPRIV);
1667	if (SL_ISERROR(fd))
1668	{
1669	sh_error_handle(SH_ERR_ALL, FIL__, __LINE__, fd, MSG_E_SUBGEN,
1670	_("Error opening temporary file"), _("open_tmp"));
1671	TPT(( 0, FIL__, __LINE__, _("msg=<Error %d temporary file %s>\n"),
1672	fd, file));
1673	}
1674
1675
1676	SH_FREE (file);
1677	SH_FREE(my_tmp_dir);
1678
1679	if (!SL_ISERROR(fd)) {
1680	sl_unlink(fd);
1681	}
1682
1683	if (!SL_ISERROR(fd))
1684	SL_RETURN((fd), _("open_tmp"));
1685	else
1686	SL_RETURN((-1), _("open_tmp"));
1687	}
1688
1689
1690	int close_tmp (SL_TICKET fd)
1691	{
1692	SL_ENTER(_("close_tmp"));
1693
1694	if (SL_ISERROR(sl_close (fd)))
1695	SL_RETURN((-1), _("close_tmp"));
1696	SL_RETURN((0), _("close_tmp"));
1697	}
1698
1699	int rewind_tmp (SL_TICKET fd)
1700	{
1701	SL_ENTER(_("rewind_tmp"));
1702
1703	if (SL_ISERROR(sl_rewind (fd)))
1704	SL_RETURN((-1), _("rewind_tmp"));
1705	SL_RETURN((0), _("rewind_tmp"));
1706	}
1707	#endif

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

Download in other formats: