Context Navigation

source: trunk/src/sh_utils.c@ 318

Last change on this file since 318 was 305, checked in by katerina, 14 years ago
Fix for ticker #226 (incorrect handling of missing files when secondary schedule is active).
File size: 52.4 KB

Rev	Line
[1]	1	/* SAMHAIN file system integrity testing */
	2	/* Copyright (C) 1999, 2000 Rainer Wichmann */
	3	/* */
	4	/* This program is free software; you can redistribute it */
	5	/* and/or modify */
	6	/* it under the terms of the GNU General Public License as */
	7	/* published by */
	8	/* the Free Software Foundation; either version 2 of the License, or */
	9	/* (at your option) any later version. */
	10	/* */
	11	/* This program is distributed in the hope that it will be useful, */
	12	/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
	13	/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
	14	/* GNU General Public License for more details. */
	15	/* */
	16	/* You should have received a copy of the GNU General Public License */
	17	/* along with this program; if not, write to the Free Software */
	18	/* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
	19
	20	#include "config_xor.h"
	21
	22
	23	#include <stdlib.h>
	24	#include <stdio.h>
	25	#include <string.h>
	26	#include <ctype.h>
	27	#include <unistd.h>
	28
	29	#if TIME_WITH_SYS_TIME
	30	#include <sys/time.h>
	31	#include <time.h>
	32	#else
	33	#if HAVE_SYS_TIME_H
	34	#include <sys/time.h>
	35	#else
	36	#include <time.h>
	37	#endif
	38	#endif
	39
	40
	41	#include "samhain.h"
	42	#include "sh_error.h"
	43	#include "sh_utils.h"
	44	#include "sh_unix.h"
	45	#include "sh_tiger.h"
	46	#include "sh_entropy.h"
[137]	47	#include "sh_pthread.h"
[1]	48
	49	#undef FIL__
	50	#define FIL__ _("sh_utils.c")
	51
	52	UINT32 ErrFlag[2];
	53
[20]	54	int sh_util_flagval(const char * c, int * fval)
[1]	55	{
	56	SL_ENTER(_("sh_util_flagval"));
	57	if (c == NULL)
	58	SL_RETURN( (-1), _("sh_util_flagval"));
	59	if ( c[0] == '1' \|\| c[0] == 'y' \|\| c[0] == 'Y' \|\|
	60	c[0] == 't' \|\| c[0] == 'T')
	61	{
	62	*fval = S_TRUE;
	63	SL_RETURN( (0), _("sh_util_flagval"));
	64	}
	65	if ( c[0] == '0' \|\| c[0] == 'n' \|\| c[0] == 'N' \|\|
	66	c[0] == 'f' \|\| c[0] == 'F')
	67	{
	68	*fval = S_FALSE;
	69	SL_RETURN( (0), _("sh_util_flagval"));
	70	}
	71	SL_RETURN( (-1), _("sh_util_flagval"));
	72	}
	73
	74	int sh_util_timeout_check (SH_TIMEOUT * sh_timer)
	75	{
	76	UINT64 now = (UINT64) time(NULL);
	77	UINT64 dif;
	78
	79	if (sh_timer->flag_ok == S_FALSE)
	80	{
	81	/* first time
	82	*/
	83	if (sh_timer->time_last == 0)
	84	{
	85	sh_timer->time_last = now;
	86	return S_TRUE;
	87	}
	88	/* later on
	89	*/
	90	dif = now - sh_timer->time_last;
	91	if (dif < sh_timer->time_dist)
	92	{
	93	return S_FALSE;
	94	}
	95	sh_timer->time_last = now;
	96	return S_TRUE;
	97	}
	98	sh_timer->time_last = now;
	99	return S_FALSE;
	100	}
	101
	102	static int sh_ask_update = S_FALSE;
	103
[20]	104	int sh_util_set_interactive(const char * str)
[1]	105	{
[20]	106	(void) str;
[1]	107
[20]	108	sh_ask_update = S_TRUE;
	109
[1]	110	sh_unix_setnodeamon(NULL);
	111
	112	return 0;
	113	}
	114
	115	#if !defined(STDIN_FILENO)
	116	#define STDIN_FILENO 0
	117	#endif
	118	#if !defined(STDERR_FILENO)
	119	#define STDERR_FILENO 0
	120	#endif
	121
[305]	122	int sh_util_ask_update(const char * path)
[1]	123	{
	124	int inchar, c;
	125	int i = S_TRUE;
	126	char * tmp = NULL;
	127
	128	SL_ENTER(_("sh_util_ask_update"));
	129
	130	if (sh_ask_update != S_TRUE)
	131	{
	132	SL_RETURN(i, _("sh_util_ask_update"));
	133	}
	134
	135	#ifdef HAVE_TTYNAME
	136	if (!ttyname(STDIN_FILENO))
	137	{
	138	if (NULL != ttyname(STDERR_FILENO))
	139	{
	140	if (NULL == freopen(ttyname(STDERR_FILENO), "r", stdin))
	141	{
	142	sh_error_handle ((-1), FIL__, __LINE__, 0,
	143	MSG_E_SUBGEN,
	144	_("Cannot continue: stdin is not a terminal"),
	145	_("sh_util_ask_update"));
	146	exit(EXIT_FAILURE);
	147	}
	148	}
	149	else
	150	{
	151	sh_error_handle ((-1), FIL__, __LINE__, 0,
	152	MSG_E_SUBGEN,
	153	_("Cannot continue: stdin is not a terminal"),
	154	_("sh_util_ask_update"));
	155	exit(EXIT_FAILURE);
	156	}
	157	}
	158	#endif
	159
	160	if (sh_ask_update == S_TRUE)
	161	{
	162	tmp = sh_util_safe_name (path);
	163	fprintf (stderr, _("Update %s [Y/n] ? "), tmp);
	164	SH_FREE(tmp);
	165	while (1 == 1)
	166	{
	167	c = fgetc(stdin); inchar = c;
	168	/@+charintliteral@/
	169	while (c != '\n' && c != EOF)
	170	c = fgetc(stdin);
	171	/* fprintf(stderr, "CHAR (1): %c\n", inchar); */
	172	if (inchar == 'Y' \|\| inchar == 'y' \|\| inchar == '\n')
	173	{
	174	break;
	175	}
	176	else if (inchar == 'n' \|\| inchar == 'N')
	177	{
	178	i = S_FALSE;
	179	break;
	180	}
	181	else
	182	{
[210]	183	fprintf(stderr, "%s", _("Please answer y(es) or n(o)\n"));
[1]	184	}
	185	/@-charintliteral@/
	186	}
	187	}
	188
	189	SL_RETURN(i, _("sh_util_ask_update"));
	190	}
	191
[22]	192	int sh_util_hidesetup(const char * c)
[1]	193	{
	194	int i;
	195	SL_ENTER(_("sh_util_hidesetup"));
	196	i = sh_util_flagval(c, &(sh.flag.hidefile));
	197
	198	SL_RETURN(i, _("sh_util_hidesetup"));
	199	}
[68]	200
	201	char * sh_util_acl_compact(char * buf, ssize_t len)
	202	{
	203	unsigned char * p = (unsigned char *) buf;
	204	int state = 0;
	205	ssize_t rem = 0;
	206	char * out;
	207
	208	SH_VALIDATE_NE(buf, NULL);
	209	SH_VALIDATE_GE(len, 0);
	210
	211	out = SH_ALLOC(len + 1);
	212
	213	while (*p != '\0') {
	214
	215	/* -- not at start or after newline
	216	*/
	217	if (state == 1) {
	218	if (p == '\n' \|\| p == ' ' \|\| p == '\t' \|\| p == '#') {
	219	while (*p != '\n') {
	220	++p;
	221	if (*p == '\0') {
	222	goto exit_it;
	223	}
	224	}
	225	out[rem] = ','; ++rem;
	226	while (p[1] == '\n') ++p; /* scan over consecutive newlines */
	227	state = 0;
	228	if (p[1] == '\0') {
	229	if (rem > 0) out[rem-1] = '\0';
	230	break;
	231	}
	232	}
	233	else {
	234	if (p <= 0x7F && isgraph((int) p)) {
	235	out[rem] = (char) *p; ++rem;
	236	}
	237	}
	238	}
	239
	240	/* -- at start or after newline
	241	*/
	242	else /* if (state == 0) */ {
	243	if (0 == strncmp((char *) p, "user", 4)) {
	244	out[rem] = 'u'; ++rem;
	245	p += 3; state = 1;
	246	} else if (0 == strncmp((char *) p, "group", 5)) {
	247	out[rem] = 'g'; ++rem;
	248	p += 4; state = 1;
	249	} else if (0 == strncmp((char *) p, "mask", 4)) {
	250	out[rem] = 'm'; ++rem;
	251	p += 3; state = 1;
	252	} else if (0 == strncmp((char *) p, "other", 5)) {
	253	out[rem] = 'o';
	254	p += 4; state = 1; ++rem;
	255	} else if (*p == '\0') {
	256	if (rem > 0) { out[rem-1] = '\0'; }
	257	break;
	258	} else {
	259	if (p <= 0x7F && isprint((int) p)) {
	260	out[rem] = (char) *p; ++rem;
	261	}
	262	}
	263	state = 1;
	264	}
	265	++p;
	266	}
	267	exit_it:
	268	out[rem] = '\0';
	269	return out;
	270	}
[76]	271
	272
	273	char * sh_util_strdup_l (const char * str, size_t len)
	274	{
	275	char * p = NULL;
	276
	277	SL_ENTER(_("sh_util_strdup_l"));
	278
	279	SH_VALIDATE_NE(str, NULL);
	280	SH_VALIDATE_NE(len, 0);
	281
	282	if (sl_ok_adds (len, 1))
	283	{
	284	p = SH_ALLOC (len + 1);
[167]	285	(void) memcpy (p, str, len+1);
[76]	286	}
	287	else
	288	{
	289	safe_fatal(_("integer overflow in sh_util_strdup_l"), FIL__, __LINE__);
	290	}
	291	SL_RETURN( p, _("sh_util_strdup_l"));
	292	}
	293
[1]	294	char * sh_util_strdup (const char * str)
	295	{
	296	char * p = NULL;
	297	size_t len;
	298
	299	SL_ENTER(_("sh_util_strdup"));
	300
[25]	301	SH_VALIDATE_NE(str, NULL);
	302
	303	len = sl_strlen(str);
	304	p = SH_ALLOC (len + 1);
[167]	305	(void) memcpy (p, str, len+1);
[25]	306
[1]	307	SL_RETURN( p, _("sh_util_strdup"));
	308	}
	309
	310	/* by the eircom.net computer incident
	311	* response team
	312	*/
	313	char * sh_util_strsep (char *str, const char delim)
	314	{
[170]	315	char ret, c;
	316	const char *d;
[1]	317
	318	SL_ENTER(_("sh_util_strsep"));
	319	ret = *str;
	320
[25]	321	SH_VALIDATE_NE(ret, NULL);
[1]	322
	323	for (c = str; c != '\0'; c++) {
[170]	324	for (d = delim; *d != '\0'; d++) {
[1]	325	if (c == d) {
	326	*c = '\0';
	327	*str = c + 1;
	328	SL_RETURN(ret, _("sh_util_strsep"));
	329	}
	330	}
	331	}
	332
	333	/* If we get to here, there's no delimiters in the string */
	334	*str = NULL;
	335	SL_RETURN(ret, _("sh_util_strsep"));
	336	}
	337
	338
[13]	339	/* returned string must be free'd by caller.
[1]	340	*/
	341	char * sh_util_formatted (const char * formatt, st_format * ftab)
	342	{
	343	struct tm * time_ptr;
	344	size_t size;
	345	size_t isiz;
	346	char * fmt = NULL;
	347	char * p;
	348	char * q;
	349	char * outstr;
	350	int i;
	351	int j;
	352	time_t inpp;
	353
[13]	354	char * clist[16] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
	355	NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
[1]	356	int nn = 0;
	357
	358	SL_ENTER(_("sh_util_formatted"));
	359
[13]	360	if (formatt == NULL \|\| ftab == NULL \|\| *formatt == '\0')
[1]	361	SL_RETURN(NULL, _("sh_util_formatted"));
	362
	363	/* -- save the format (we overwrite it !!) --
	364	*/
	365	size = sl_strlen(formatt);
	366
[34]	367	if (!sl_ok_adds(size, 1))
	368	SL_RETURN(NULL, _("sh_util_formatted"));
[13]	369
[34]	370	++size;
	371	fmt = SH_ALLOC(size);
	372	(void) sl_strlcpy(fmt, formatt, size);
	373
[1]	374	p = fmt;
	375
	376	j = 0;
[13]	377	while (ftab[j].fchar != '\0') {
	378	if (ftab[j].type != S_FMT_STRING)
	379	ftab[j].data_str = NULL;
	380	++j;
	381	}
	382
[1]	383	while (p != NULL && *p != '\0' && NULL != (q = strchr(p, '%')))
	384	{
	385	++q;
	386
	387	/* fprintf(stderr, "p == %s q == %s\n", p, q); */
	388
	389	/* -- end of string is a '%' --
	390	*/
	391	if (*q == '\0')
	392	{
	393	--q;
	394	*q = '\0';
	395	break;
	396	}
	397
	398	i = 0;
	399	j = 0;
	400
	401	/* -- search the format char in input table --
	402	* put (nn < 16) here -> all remaining %foo will be
	403	* converted to %%
	404	*/
	405	while (ftab[j].fchar != '\0' && nn < 16)
	406	{
	407	if (ftab[j].fchar == *q)
	408	{
	409	/* -- Convert it to a string format (%s). --
	410	*/
	411	*q = 's'
	412	;
	413	i = 1;
	414
[13]	415	switch(ftab[j].type) {
	416
	417	case S_FMT_STRING:
[1]	418	{
	419	isiz = sl_strlen(ftab[j].data_str);
[34]	420	if (isiz > 0 && sl_ok_adds(size, isiz))
[1]	421	{
	422	size += isiz;
	423	clist[nn] = ftab[j].data_str;
	424	++nn;
	425	}
	426	else
	427	*q = '%';
[13]	428	goto endsrch;
[1]	429	}
[13]	430	break;
	431
	432	case S_FMT_ULONG:
[1]	433	{
	434	ftab[j].data_str = (char *) SH_ALLOC(64);
	435	/@-bufferoverflowhigh@/
	436	sprintf (ftab[j].data_str, "%lu", /* known to fit */
	437	ftab[j].data_ulong);
	438	/@+bufferoverflowhigh@/
	439	isiz = sl_strlen(ftab[j].data_str);
[34]	440	if (isiz > 0 && sl_ok_adds(size, isiz))
[1]	441	{
	442	size += isiz;
	443	clist[nn] = ftab[j].data_str;
	444	++nn;
	445	}
	446	else
	447	*q = '%';
[13]	448	goto endsrch;
[1]	449	}
[13]	450	break;
	451
	452	case S_FMT_LONG:
[1]	453	{
	454	ftab[j].data_str = (char *) SH_ALLOC(64);
	455	/@-bufferoverflowhigh@/
	456	sprintf (ftab[j].data_str, "%ld", /* known to fit */
	457	ftab[j].data_long);
	458	/@+bufferoverflowhigh@/
	459	isiz = sl_strlen(ftab[j].data_str);
[34]	460	if (isiz > 0 && sl_ok_adds(size, isiz))
[1]	461	{
	462	size += isiz;
	463	clist[nn] = ftab[j].data_str;
	464	++nn;
	465	}
	466	else
	467	*q = '%';
[13]	468	goto endsrch;
[1]	469	}
[13]	470	break;
	471
	472	case S_FMT_TIME:
[1]	473	{
	474	ftab[j].data_str = (char *) SH_ALLOC(64);
	475	inpp = (time_t)ftab[j].data_ulong;
	476	if (inpp != 0)
	477	{
	478	time_ptr = localtime (&(inpp));
	479	if (time_ptr != NULL)
	480	(void) strftime(ftab[j].data_str, 64,
	481	_("%d-%m-%Y %H:%M:%S"), time_ptr);
	482	else
	483	(void) sl_strlcpy(ftab[j].data_str,
	484	_("00-00-0000 00:00:00"), 64);
	485	}
	486	else
	487	{
	488	(void) sl_strlcpy(ftab[j].data_str,
	489	_("(None)"), 64);
	490	}
	491	isiz = sl_strlen(ftab[j].data_str);
[34]	492	if (isiz > 0 && sl_ok_adds(size, isiz))
[1]	493	{
	494	size += isiz;
	495	clist[nn] = ftab[j].data_str;
	496	++nn;
	497	}
	498	else
	499	*q = '%';
[13]	500	goto endsrch;
[1]	501	}
[13]	502	break;
[1]	503
[13]	504	default:
	505	/* do nothing */;
	506	}
	507
[1]	508	}
[13]	509	++j;
[1]	510	}
	511
[13]	512	endsrch:
	513
	514	p = q;
	515
[1]	516	/* -- not found -- */
	517	if (i == 0)
	518	{
	519	*q = '%';
	520	++p;
	521	}
[13]	522
[1]	523	}
	524
	525	/* -- Format string evaluated.
	526	clist[] List of strings
	527	size Total size of format string + clist[] strings
	528	-- */
	529
	530	/* -- closing '\0' --
	531	*/
[34]	532	if (sl_ok_adds(size, 1))
	533	size++;
[1]	534	outstr = (char *) SH_ALLOC(size);
	535
	536	/* -- print it --
	537	*/
	538	(void) sl_snprintf( outstr, size, fmt,
	539	clist[0], clist[1], clist[2], clist[3],
	540	clist[4], clist[5], clist[6], clist[7],
	541	clist[8], clist[9], clist[10], clist[11],
	542	clist[12], clist[13], clist[14], clist[15]);
[34]	543	outstr[size-1] = '\0';
	544
[1]	545	/* -- cleanup --
	546	*/
	547	j = 0;
[13]	548	while (ftab[j].fchar != '\0') {
	549	if (ftab[j].type != S_FMT_STRING && ftab[j].data_str != NULL)
	550	SH_FREE(ftab[j].data_str);
	551	++j;
	552	}
[1]	553	SH_FREE(fmt);
	554
	555	SL_RETURN(outstr, _("sh_util_formatted"));
	556	}
	557
[93]	558	/* read a hexchar, return int value (0-15)
	559	* can't inline (AIX)
[1]	560	*/
[12]	561	int sh_util_hexchar( const char c )
[1]	562	{
	563	/@+charint@/
	564	if ( c >= '0' && c <= '9' )
	565	return c - '0';
	566	else if ( c >= 'a' && c <= 'f' )
	567	return c - 'a' + 10;
	568	else if ( c >= 'A' && c <= 'F' )
	569	return c - 'A' + 10;
	570	else return -1;
	571	/@-charint@/
	572	}
	573
[137]	574	char * sh_util_charhex( unsigned char i , char * i2h)
[93]	575	{
	576	int j, k;
	577
	578	j = i / 16;
	579	k = i - (j*16);
	580
	581	if (j < 10) i2h[0] = '0'+j;
	582	else i2h[0] = 'A'+(j-10);
	583
	584	if (k < 10) i2h[1] = '0'+k;
	585	else i2h[1] = 'A'+(k-10);
	586
	587	return i2h;
	588	}
	589
[1]	590	/* read a hexadecimal key, convert to binary
	591	*/
[12]	592	int sh_util_hextobinary (char * binary, const char * hex, int bytes)
[1]	593	{
	594	int i = 0, j, k, l = 0;
[13]	595	char c;
[1]	596
[13]	597	#define SH_HEXCHAR(x, y) \
	598	c = (x); \
	599	if ( c >= '0' && c <= '9' ) \
	600	y = c - '0'; \
	601	else if ( c >= 'a' && c <= 'f' ) \
	602	y = c - 'a' + 10; \
	603	else if ( c >= 'A' && c <= 'F' ) \
	604	y = c - 'A' + 10; \
	605	else \
	606	SL_RETURN((-1), _("sh_util_hextobinary"))
	607
	608
[1]	609	SL_ENTER(_("sh_util_hextobinary"));
	610
[34]	611	if (bytes < 2)
	612	SL_RETURN((-1), _("sh_util_hextobinary"));
	613
	614	while (i < (bytes-1))
[1]	615	{
[13]	616	SH_HEXCHAR(hex[i], k);
	617	SH_HEXCHAR(hex[i+1], j);
	618
	619	binary[l] = (char)(k * 16 + j);
	620	++l; i+= 2;
[1]	621	}
	622
	623	SL_RETURN((0), _("sh_util_hextobinary"));
	624	}
	625
	626	static void copy_four (unsigned char * dest, UINT32 in)
	627	{
	628	UINT32 i, j;
	629	int count;
	630
	631	SL_ENTER(_("copy_four"));
	632	for (count = 0; count < 4; ++count)
	633	{
	634	i = in / 256;
	635	j = in - (i*256);
	636	dest[count] = (unsigned char) j;
	637	in = i;
	638	}
	639	SL_RET0(_("copy_four"));
	640	}
	641
	642	/* compute HMAC-TIGER
	643	*/
	644	static char * sh_util_hmac_tiger (char * hexkey,
[133]	645	char * text, size_t textlen,
	646	char * res, size_t len)
[1]	647	{
	648	static char opad[KEY_BLOCK] = {
	649	(char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C,
	650	(char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C,
	651	(char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C,
	652	(char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C, (char)0x5C
	653	};
	654	static char ipad[KEY_BLOCK] = {
	655	(char)0x36, (char)0x36, (char)0x36, (char)0x36, (char)0x36, (char)0x36,
	656	(char)0x36, (char)0x36, (char)0x36, (char)0x36, (char)0x36, (char)0x36,
	657	(char)0x36, (char)0x36, (char)0x36, (char)0x36, (char)0x36, (char)0x36,
	658	(char)0x36, (char)0x36, (char)0x36, (char)0x36, (char)0x36, (char)0x36
	659	};
[11]	660	static char zap[KEY_BLOCK] = {
	661	(char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00,
	662	(char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00,
	663	(char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00,
	664	(char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00
	665	};
[1]	666	char K[KEY_BLOCK];
	667	char outer[KEY_BLOCK];
	668	char * inner;
	669	UINT32 * h1;
	670	UINT32 * h2;
	671	UINT32 cc[KEY_LEN/4];
[133]	672	UINT32 kbuf[KEY_BYT/sizeof(UINT32)];
	673	char hashbuf[KEYBUF_SIZE];
[1]	674
[133]	675
[1]	676	size_t i;
	677
	678	SL_ENTER(_("sh_util_hmac_tiger"));
	679	ASSERT((KEY_BLOCK <= (KEY_LEN/2)), _("KEY_BLOCK <= (KEY_LEN/2)"))
	680
	681	if (KEY_BLOCK > (KEY_LEN/2))
	682	{
[137]	683	(void) sh_tiger_hash (NULL, TIGER_DATA, 0, hashbuf, sizeof(hashbuf));
	684	sl_strlcpy(res, hashbuf, len);
[1]	685	SL_RETURN(res, _("sh_util_hmac_tiger"));
	686	}
	687
[11]	688	memcpy (K, zap, KEY_BLOCK);
[1]	689
	690	if (sh_util_hextobinary (K, hexkey, KEY_LEN) < 0)
	691	{
[137]	692	(void) sh_tiger_hash (NULL, TIGER_DATA, 0, hashbuf, sizeof(hashbuf));
	693	sl_strlcpy(res, hashbuf, len);
[1]	694	SL_RETURN(res, _("sh_util_hmac_tiger"));
	695	}
	696
[34]	697	if (sl_ok_adds(textlen, KEY_BLOCK))
	698	{
	699	inner = (char *) SH_ALLOC (textlen + KEY_BLOCK);
[1]	700
[34]	701	for (i = 0; i < KEY_BLOCK; ++i)
	702	{
	703	outer[i] = K[i] ^ opad[i];
	704	inner[i] = K[i] ^ ipad[i];
	705	}
	706	for (i = KEY_BLOCK; i < (KEY_BLOCK+textlen); ++i)
	707	{
	708	inner[i] = text[i - KEY_BLOCK];
	709	}
[1]	710	}
[34]	711	else
[1]	712	{
[34]	713	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
	714	_("integer overflow"),
	715	_("sh_util_hmac_tiger"));
[137]	716	(void) sh_tiger_hash (NULL, TIGER_DATA, 0, hashbuf, sizeof(hashbuf));
	717	sl_strlcpy(res, hashbuf, len);
[34]	718	SL_RETURN(res, _("sh_util_hmac_tiger"));
[1]	719	}
	720
	721	/* now compute the hash
	722	*/
	723	h1 = sh_tiger_hash_uint32 ( outer,
	724	TIGER_DATA,
[133]	725	KEY_BLOCK,
	726	kbuf, KEY_BYT/sizeof(UINT32));
[1]	727	for (i = 0; i < (KEY_LEN/8); ++i)
	728	{
	729	/* cc[i] = h1[i]; */
	730	copy_four ( (unsigned char *) &(cc[i]), h1[i]);
	731	}
	732
	733	h2 = sh_tiger_hash_uint32 ( inner,
	734	TIGER_DATA,
[133]	735	(unsigned long) KEY_BLOCK+textlen,
	736	kbuf, KEY_BYT/sizeof(UINT32));
[1]	737	for (i = KEY_LEN/8; i < (KEY_LEN/4); ++i)
	738	{
	739	copy_four ( (unsigned char *) &(cc[i]), h2[i - (KEY_LEN/8)]);
	740	/* cc[i] = h2[i - (KEY_LEN/8)]; */
	741	}
	742	SH_FREE(inner);
	743
[133]	744	(void) sh_tiger_hash ((char *) &cc[0],
	745	TIGER_DATA,
	746	(unsigned long) (KEY_LEN/4 * sizeof(UINT32)),
	747	hashbuf, sizeof(hashbuf));
[1]	748
[133]	749	sl_strlcpy(res, hashbuf, len);
[1]	750	SL_RETURN(res, _("sh_util_hmac_tiger"));
	751	}
	752
	753	static char * sh_util_hash_tiger ( char * hexkey,
[137]	754	char * text, size_t textlen,
[133]	755	char * res, size_t len)
[1]	756	{
	757	char h2[2*KEY_LEN+1];
[137]	758	char hashbuf[KEYBUF_SIZE];
	759
[1]	760	SL_ENTER(_("sh_util_hash_tiger"));
	761
	762	(void) sl_strlcpy(h2, hexkey, KEY_LEN+1);
[133]	763	(void) sl_strlcat(h2,
	764	sh_tiger_hash(text, TIGER_DATA,
	765	(unsigned long) textlen,
	766	hashbuf, sizeof(hashbuf)),
[137]	767	2*KEY_LEN+1
[133]	768	);
[1]	769
[133]	770	(void) sh_tiger_hash(h2, TIGER_DATA, 2*KEY_LEN, hashbuf, sizeof(hashbuf));
[1]	771
[133]	772	sl_strlcpy(res, hashbuf, len);
[1]	773	SL_RETURN(res, _("sh_util_hash_tiger"));
	774	}
	775
	776	/* --- compute signature on data ---
	777	*/
	778	#define TYPE_HMAC 0
	779	#define TYPE_HASH 1
	780
	781	static int sigtype = TYPE_HMAC;
	782
[22]	783	int sh_util_sigtype (const char * c)
[1]	784	{
	785	SL_ENTER(_("sh_util_sigtype"));
	786	if (c == NULL)
	787	SL_RETURN( -1, _("sh_util_sigtype"));
	788
	789	if (0 == strcmp(_("HMAC-TIGER"), c))
	790	sigtype = TYPE_HMAC;
	791	else if (0 == strcmp(_("HASH-TIGER"), c))
	792	sigtype = TYPE_HASH;
	793	else
	794	SL_RETURN( -1, _("sh_util_sigtype"));
	795
	796	SL_RETURN( 0, _("sh_util_sigtype"));
	797	}
	798
	799	char * sh_util_siggen (char * hexkey,
[133]	800	char * text, size_t textlen,
	801	char * res, size_t len)
[1]	802	{
	803	char * p;
	804
	805	SL_ENTER(_("sh_util_siggen"));
	806	if (sigtype == TYPE_HMAC)
	807	p = sh_util_hmac_tiger (hexkey,
[133]	808	text, textlen, res, len);
[1]	809	else
	810	p = sh_util_hash_tiger (hexkey,
[133]	811	text, textlen, res, len);
[1]	812	SL_RETURN(p, _("sh_util_siggen"));
	813	}
	814
	815
	816	/* a simple compressor
	817	*/
[214]	818	size_t sh_util_compress (char * dest, char * src, size_t dest_size)
[1]	819	{
	820	char * add;
	821	char * get;
	822	size_t count = 0;
	823	size_t dest_end;
	824
	825	SL_ENTER(_("sh_util_compress"));
	826
	827	if (dest_size == 0)
	828	SL_RETURN((0), _("sh_util_compress"));
	829
	830	if ((dest == NULL) \|\| (src == NULL))
	831	SL_RETURN((0), _("sh_util_compress"));
	832
	833	dest_end = sl_strlen(dest);
	834
	835	if (dest_end > dest_size)
	836	SL_RETURN((0), _("sh_util_compress"));
	837
	838	add = &dest[dest_end];
	839	get = src;
	840
	841	while (count < (dest_size-dest_end))
	842	{
	843	if (isalnum((int) *get))
	844	{
	845	add = get;
	846	++add;
	847	++count;
	848	}
	849	++get;
	850	if (*get == '\0' && (count < (dest_size-dest_end)))
	851	/* end of src reached */
	852	{
	853	add = get; /* copy the '\0' */
	854	break; /* and stop copying */
	855	}
	856	}
	857
	858	dest[dest_size-1] = '\0'; /* paranoia */
[214]	859	SL_RETURN((count), _("sh_util_compress")); /* no of chars copied */
[1]	860	}
	861
	862
	863	/* copy the four least significant bytes
	864	*/
	865	void sh_util_cpylong (char * dest, const char * src, int len )
	866	{
	867	int i, j;
	868	union
	869	{
	870	long l;
	871	char c[sizeof(long)];
	872	} u;
[290]	873	#ifdef WORDS_BIGENDIAN
	874	unsigned char swap;
	875	unsigned char * ii = (unsigned char *) dest;
	876	#endif
[1]	877
	878	SL_ENTER(_("sh_util_cpylong"));
	879
	880	u.l = 1;
	881
	882	/* MSB is first
	883	*/
	884	if (sizeof(long)>4 &&/@+charint@/(u.c[sizeof(long)-1] == 1)/@-charint@/)
	885	{
	886	j = (int) (sizeof(long)-4);
	887	for (i = 0; i < j; ++i) ++src;
	888	}
	889
	890	i = 0;
	891
	892	while (i < 4)
	893	{
	894	dest = (src);
	895	++dest; ++src;
	896	if (i == (len-1)) break;
	897	++i;
	898	}
[290]	899	#ifdef WORDS_BIGENDIAN
	900	swap = ii[0]; ii[0] = ii[3]; ii[3] = swap;
	901	swap = ii[1]; ii[1] = ii[2]; ii[2] = swap;
	902	#endif
[1]	903	SL_RET0(_("sh_util_cpylong"));
	904	}
	905
	906	/* This is a maximally equidistributed combined Tausworthe
	907	* generator. The sequence is,
	908	*
	909	* x_n = (s1_n ^ s2_n ^ s3_n)
	910	*
	911	* s1_{n+1} = (((s1_n & 4294967294) <<12) ^ (((s1_n <<13) ^ s1_n) >>19))
	912	* s2_{n+1} = (((s2_n & 4294967288) << 4) ^ (((s2_n << 2) ^ s2_n) >>25))
	913	* s3_{n+1} = (((s3_n & 4294967280) <<17) ^ (((s3_n << 3) ^ s3_n) >>11))
	914	*
	915	* computed modulo 2^32. In the three formulas above '^' means
	916	* exclusive-or (C-notation), not exponentiation. Note that the
	917	* algorithm relies on the properties of 32-bit unsigned integers (it
	918	* is formally defined on bit-vectors of length 32).
	919	*
	920	* Stolen from GSL (GNU scientific library) and modified somewhat.
	921	* I am using UINT32, which is guaranteed to be 32 bits. Also made
	922	* sure that the initialization vector is valid.
	923	*/
	924
	925
	926	/* interval [0, 4294967296]
	927	*/
	928	static UINT32 taus_get_long (void *vstate)
	929	{
	930	UINT32 * state = (UINT32 *) vstate;
	931
[137]	932	/*
[1]	933	if (skey->rngI == BAD)
	934	(void)taus_seed();
[137]	935	*/
[1]	936
	937	#define TAUSWORTHE(s,a,b,c,d) ((s &c) <<d) ^ (((s <<a) ^s) >>b)
	938	/@+ignorequals@/
	939	state[0] = TAUSWORTHE (state[0], 13, 19, 4294967294UL, 12);
	940	state[1] = TAUSWORTHE (state[1], 2, 25, 4294967288UL, 4);
	941	state[2] = TAUSWORTHE (state[2], 3, 11, 4294967280UL, 17);
	942	/@-ignorequals@/
	943	return (state[0] ^ state[1] ^ state[2]);
	944	}
	945
	946	/* Hide the internal state of the PRNG by using its output as
	947	* input for a one-way hash function.
	948	*/
[11]	949
[137]	950	UINT32 taus_get ()
[1]	951	{
[156]	952	#define TAUS_SAMPLE 12
	953
	954	UINT32 taus_svec[TAUS_SAMPLE];
[1]	955	UINT32 retval;
	956	UINT32 * res;
[156]	957	UINT32 * res_vec = &(skey->res_vec[0]);
[13]	958	static int res_num = 0;
[1]	959	register int i;
[133]	960	UINT32 kbuf[KEY_BYT/sizeof(UINT32)];
[1]	961
[137]	962	SH_MUTEX_LOCK_UNSAFE(mutex_skey);
[13]	963	if (res_num > 0)
	964	{
	965	retval = res_vec[res_num];
	966	res_num = (res_num == 5) ? 0 : (res_num + 1);
[137]	967	SH_MUTEX_UNLOCK_UNSAFE(mutex_skey); /* alternative path */
[13]	968	return retval;
	969	}
[137]	970	SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
[13]	971
[137]	972	(void)taus_seed();
[1]	973
[137]	974	SH_MUTEX_LOCK_UNSAFE(mutex_skey);
[156]	975	for (i = 0; i < (TAUS_SAMPLE/3); ++i)
	976	{
	977	taus_svec[i*3] = taus_get_long (&(skey->rng0[0]));
	978	taus_svec[i*3+1] = taus_get_long (&(skey->rng1[0]));
	979	taus_svec[i*3+2] = taus_get_long (&(skey->rng2[0]));
	980	}
[137]	981	SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
	982
[11]	983	res = sh_tiger_hash_uint32 ( (char *) &taus_svec[0],
[1]	984	TIGER_DATA,
[156]	985	(unsigned long)(TAUS_SAMPLE * sizeof(UINT32)),
[133]	986	kbuf, KEY_BYT/sizeof(UINT32));
[1]	987
[137]	988	SH_MUTEX_LOCK_UNSAFE(mutex_skey);
[13]	989	for (i = 1; i < 6; ++i)
[11]	990	{
[13]	991	res_vec[i] = res[i];
[11]	992	}
[156]	993	retval = res[0];
[13]	994	res_num = 1;
[137]	995	SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
[1]	996
[156]	997	memset(taus_svec, '\0', TAUS_SAMPLE * sizeof(UINT32));
[1]	998
	999	return retval;
	1000	}
	1001
	1002	/* interval [0,1)
	1003	*/
	1004	double taus_get_double (void *vstate)
	1005	{
	1006	return taus_get_long (vstate) / (4294967296.0 + 1.0) ;
	1007	}
	1008
	1009	#define LCG(n) ((69069 * n) & 0xffffffffUL)
	1010
	1011	/* TAKE CARE: state[0], state[1], state[2] must be > 2,8,16, respectively
	1012	*/
	1013	static void taus_set_from_ulong (void *vstate, unsigned long int s)
	1014	{
	1015	UINT32 state = (UINT32 ) vstate;
	1016
	1017	if (s == 0)
	1018	s = 1; /* default seed is 1 */
	1019
	1020	state[0] = (UINT32)(LCG (s) \| (UINT32) 0x03);
	1021	state[1] = (UINT32)(LCG (state[0]) \| (UINT32) 0x09);
	1022	state[2] = (UINT32)(LCG (state[1]) \| (UINT32) 0x17);
	1023
	1024	/* 'warm up'
	1025	*/
	1026	(void) taus_get_long (state);
	1027	(void) taus_get_long (state);
	1028	(void) taus_get_long (state);
	1029	(void) taus_get_long (state);
	1030	(void) taus_get_long (state);
	1031	(void) taus_get_long (state);
	1032
	1033	return;
	1034	}
	1035
	1036	static void taus_set_from_state (void vstate, void init_state)
	1037	{
	1038	UINT32 state = (UINT32 ) vstate;
	1039	UINT32 state0 = (UINT32 ) init_state;
	1040
	1041	state[0] = state0[0] \| (UINT32) 0x03;
	1042	state[1] = state0[1] \| (UINT32) 0x09;
	1043	state[2] = state0[2] \| (UINT32) 0x17;
	1044
	1045	return;
	1046	}
	1047
	1048
	1049	int taus_seed ()
	1050	{
	1051	char bufx[9 * sizeof(UINT32) + 1];
	1052	int status;
	1053	static unsigned long seed_time = 0;
[137]	1054	unsigned long gtime;
[1]	1055
	1056	SL_ENTER(_("taus_seed"));
	1057
	1058	if (skey->rngI == GOOD)
	1059	{
[137]	1060	if ( (sh_unix_longtime () - seed_time) < 7200)
[1]	1061	SL_RETURN( (0), _("taus_seed"));
	1062	}
	1063
	1064	seed_time = sh_unix_longtime ();
	1065
	1066	status = sh_entropy (24, bufx);
	1067
	1068	if (!SL_ISERROR(status))
	1069	{
[137]	1070	SH_MUTEX_LOCK_UNSAFE(mutex_skey);
[1]	1071	memcpy (&skey->rng0[0], &bufx[0], 2*sizeof(UINT32));
	1072	memcpy (&skey->rng1[0], &bufx[2sizeof(UINT32)], 2sizeof(UINT32));
	1073	memcpy (&skey->rng2[0], &bufx[4sizeof(UINT32)], 2sizeof(UINT32));
	1074	memset (bufx, 0, 9 * sizeof(UINT32) + 1);
	1075
	1076	skey->rng0[2] = 0;
	1077	skey->rng1[2] = 0;
	1078	skey->rng2[2] = 0;
	1079
	1080	taus_set_from_state( &(skey->rng0[0]), &(skey->rng0[0]));
	1081	taus_set_from_state( &(skey->rng1[0]), &(skey->rng1[0]));
	1082	taus_set_from_state( &(skey->rng2[0]), &(skey->rng2[0]));
	1083
[137]	1084	skey->rngI = GOOD;
	1085	SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
[1]	1086	SL_RETURN( (0), _("taus_seed"));
	1087	}
	1088
	1089	sh_error_handle ((-1), FIL__, __LINE__, status, MSG_ES_ENT,
	1090	_("sh_entropy"));
	1091
	1092	/* emergency backup - unsafe !
	1093	*/
	1094	#ifdef HAVE_GETTIMEOFDAY
[137]	1095	gtime = sh_unix_notime();
[1]	1096	#else
[137]	1097	gtime = seed_time;
[1]	1098	#endif
[137]	1099
	1100	SH_MUTEX_LOCK_UNSAFE(mutex_skey);
	1101	taus_set_from_ulong ( &(skey->rng0[0]), LCG (gtime) );
[1]	1102	taus_set_from_ulong ( &(skey->rng1[0]), LCG (skey->rng0[0]) );
	1103	taus_set_from_ulong ( &(skey->rng2[0]), LCG (skey->rng1[0]) );
	1104	skey->rngI = BAD;
[137]	1105	SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
[1]	1106
	1107	SL_RETURN( (-1), _("taus_seed"));
	1108	}
	1109
	1110	/@+charint@/
	1111	static unsigned char new_key[] = { 0xA7,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xA7 };
	1112	/@-charint@/
	1113	static void copy_four (unsigned char * dest, UINT32 in);
	1114
[20]	1115	int sh_util_set_newkey (const char * new_in)
[1]	1116	{
	1117	size_t i, j = 0;
	1118	size_t len;
	1119	SL_TICKET fp;
	1120	SL_TICKET fout;
	1121	char * key;
	1122	char * path;
[22]	1123	char * outpath = NULL;
[1]	1124	unsigned char * image = NULL;
	1125	long s = 0;
	1126	long ilen = 0;
	1127	long ii, k = 0;
	1128	UINT32 * h1;
[22]	1129	char * new = NULL;
[1]	1130
	1131	if (0 != sl_is_suid())
	1132	{
[210]	1133	fprintf(stderr, "%s", _("ERROR: insufficient privilege\n"));
[1]	1134	_exit (EXIT_FAILURE);
	1135	/@notreached@/
	1136	return -1; /* braindead MAC OSX compiler needs this */
	1137	}
	1138
[20]	1139	if (new_in == NULL \|\| new_in[0] == '\0')
[1]	1140	{
[210]	1141	fprintf(stderr, "%s",
[1]	1142	_("ERROR: no key given\n Argument must be 'key@path'\n"));
	1143	_exit (EXIT_FAILURE);
	1144	/@notreached@/
	1145	return -1;
	1146	}
[20]	1147
	1148	if (NULL == (new = malloc(strlen(new_in) + 1)))
	1149	goto bail_mem;
	1150	sl_strncpy(new, new_in, strlen(new_in) + 1);
	1151
[1]	1152	key = new;
	1153	len = strlen(new);
	1154	for (i = 1; i < (len-2); ++i)
	1155	{
	1156	if (new[i] == '@' && new[i+1] == '/')
	1157	{
	1158	j = i+1; new[i] = '\0'; break;
	1159	}
	1160	}
	1161	if (j == 0)
	1162	{
[210]	1163	fprintf(stderr, "%s",
[1]	1164	_("ERROR: no path to executable given\n Argument must be 'key@path'\n"));
[22]	1165	free(new);
[1]	1166	_exit (EXIT_FAILURE);
	1167	/@notreached@/
	1168	return -1;
	1169	}
	1170	else
	1171	path = &new[j];
[22]	1172
	1173	len = strlen(path) + 1 + 4;
[1]	1174	/@-usedef@/
[22]	1175	if (NULL == (outpath = malloc(len)))
[1]	1176	goto bail_mem;
	1177	/@-usedef@/
[22]	1178	sl_snprintf (outpath, len, _("%s.out"), path);
[1]	1179
[248]	1180	fp = sl_open_read(FIL__, __LINE__, path, SL_NOPRIV);
[1]	1181	if (SL_ISERROR(fp))
	1182	{
	1183	fprintf(stderr,
	1184	_("ERROR: cannot open %s for read (errnum = %ld)\n"), path, fp);
[22]	1185	free(new); free (outpath);
[1]	1186	_exit (EXIT_FAILURE);
	1187	/@notreached@/
	1188	return -1;
	1189	}
	1190
[248]	1191	fout = sl_open_write(FIL__, __LINE__, outpath, SL_NOPRIV);
[1]	1192	if (SL_ISERROR(fout))
	1193	{
	1194	fprintf(stderr,
	1195	_("ERROR: cannot open %s (errnum = %ld)\n"), outpath, fout);
[22]	1196	free(new); free (outpath);
[1]	1197	_exit (EXIT_FAILURE);
	1198	/@notreached@/
	1199	return -1;
	1200	}
	1201
	1202
	1203	image = malloc (4096);
	1204	if (!image)
	1205	goto bail_mem;
	1206	while (0 < (ii = sl_read (fp, &image[s], 4096)))
	1207	{
	1208	ilen += ii;
	1209	s += 4096;
	1210	image = realloc (image, (size_t) (4096 + s));
	1211	if (!image)
	1212	goto bail_mem;
	1213	}
	1214
	1215	printf(_("%ld bytes read\n"), ilen);
	1216
	1217
	1218	for (k = 0; k < (ilen - 8); ++k)
	1219	{
	1220	if (image[k] == new_key[0] &&
	1221	image[k+1] == new_key[1] &&
	1222	image[k+2] == new_key[2] &&
	1223	image[k+3] == new_key[3] &&
	1224	image[k+4] == new_key[4] &&
	1225	image[k+5] == new_key[5] &&
	1226	image[k+6] == new_key[6] &&
	1227	image[k+7] == new_key[7])
	1228	{
[133]	1229	UINT32 kbuf[KEY_BYT/sizeof(UINT32)];
	1230
[210]	1231	printf("%s", _("old key found\n"));
[1]	1232	h1 = sh_tiger_hash_uint32 (key, TIGER_DATA,
[133]	1233	(unsigned long)strlen(key),
	1234	kbuf, KEY_BYT/sizeof(UINT32));
[1]	1235	copy_four( (unsigned char *) &(image[k]), h1[0]);
	1236	copy_four( (unsigned char *) &(image[k+4]), h1[1]);
	1237	(void) sl_write (fout, image, ilen);
	1238	(void) sl_close (fout);
	1239	printf(_("new file %s written\n"), outpath);
[22]	1240	free(new); free (outpath); free(image);
[1]	1241	_exit (EXIT_SUCCESS);
	1242	/@notreached@/
	1243	return 0;
	1244	}
	1245	}
	1246
[210]	1247	fprintf(stderr, "%s",
[1]	1248	_("ERROR: old key not found\n"));
[22]	1249	free(new); free (outpath); free(image);
[1]	1250	_exit (EXIT_FAILURE);
	1251	/@notreached@/
	1252	return -1;
	1253
	1254
	1255	bail_mem:
[210]	1256	fprintf(stderr, "%s",
[1]	1257	_("ERROR: out of memory\n"));
[22]	1258	if (new) free(new);
	1259	if (outpath) free (outpath);
	1260	if (image) free (image);
[1]	1261	_exit (EXIT_FAILURE);
	1262	/@notreached@/
	1263	return -1;
	1264	}
	1265
	1266
	1267
	1268
	1269	/* A simple en-/decoder, based on Vernam cipher. We use the
	1270	* message as salt to hide the key by obtaining a different one-time
	1271	* pad each time.
	1272	* Should be safe against a listener on the network, but not against someone
	1273	* with read access to the binary.
	1274	*/
	1275	void sh_util_encode (char * data, char * salt, int mode, char fill)
	1276	{
	1277	static char cc1[17] = N_("0123456789ABCDEF");
	1278	char cc[17] = "\0";
	1279	register int i, j, j1 = 0, j2 = 0, j3;
	1280	char * dez;
[133]	1281	char hashbuf[KEYBUF_SIZE];
[1]	1282
	1283	SL_ENTER(_("sh_util_encode"));
	1284
	1285	/* init
	1286	*/
	1287	(void) sl_strlcpy( cc, _(cc1), sizeof(cc));
	1288
	1289	/* max 128 bits keyspace
	1290	*/
	1291	memset (skey->vernam, (int)fill, KEY_LEN+1);
	1292
	1293	dez = (char *) &(skey->ErrFlag[0]);
	1294	sh_util_cpylong (skey->vernam, dez, 4);
	1295	dez = (char *) &(skey->ErrFlag[1]);
	1296	sh_util_cpylong (&skey->vernam[4], dez, 4);
	1297
	1298	skey->vernam[KEY_LEN] = '\0';
	1299
	1300	(void) sl_strlcpy(skey->vernam,
[133]	1301	sh_tiger_hash(skey->vernam, TIGER_DATA, KEY_LEN,
	1302	hashbuf, sizeof(hashbuf)),
[1]	1303	KEY_LEN+1);
	1304
	1305	(void) sl_strlcpy(skey->vernam,
[133]	1306	sh_util_hmac_tiger (skey->vernam, salt, strlen(salt),
	1307	hashbuf, sizeof(hashbuf)),
	1308	KEY_LEN+1);
[1]	1309
	1310	(void) sl_strlcpy(skey->vernam,
[133]	1311	sh_util_hmac_tiger (skey->vernam, (char*) new_key, 8,
	1312	hashbuf, sizeof(hashbuf)),
[1]	1313	KEY_LEN+1);
	1314
	1315	/* The following routine adds/subtracts data[j] and vernam[j] mod 16.
	1316	*/
	1317	j = 0;
	1318	while (j < KEY_LEN)
	1319	{
	1320	for (i = 0; i < 16; ++i)
	1321	{
	1322	if (cc[i] == data[j]) j1 = i;
	1323	if (cc[i] == skey->vernam[j]) j2 = i;
	1324	}
	1325	if (mode == 0)
	1326	{
	1327	j3 = j1 + j2;
	1328	if (j3 > 15) j3 -= 16;
	1329	data[j] = cc[j3];
	1330	}
	1331	else
	1332	{
	1333	j3 = j1 - j2;
	1334	if (j3 < 0) j3 += 16;
	1335	data[j] = cc[j3];
	1336	}
	1337	++j;
	1338	}
	1339	SL_RET0(_("sh_util_encode"));
	1340	}
	1341
	1342	/* server mode
	1343	*/
[20]	1344	int sh_util_setserver (const char * dummy)
[1]	1345	{
	1346	SL_ENTER(_("sh_util_setserver"));
	1347
[20]	1348	(void) dummy;
	1349	sh.flag.isserver = GOOD;
[1]	1350	SL_RETURN((0),_("sh_util_setserver"));
	1351	}
	1352
	1353
[20]	1354	int sh_util_setlooptime (const char * str)
[1]	1355	{
	1356	int i = atoi (str);
	1357
	1358	SL_ENTER(_("sh_util_setlooptime"));
	1359
	1360	if (i >= 0 && i < INT_MAX) {
	1361	sh.looptime = i;
	1362	SL_RETURN((0),_("sh_util_setlooptime"));
	1363	} else {
	1364	sh_error_handle ((-1), FIL__, __LINE__, EINVAL, MSG_EINVALS,
	1365	_("loop time"), str);
	1366	SL_RETURN((-1),_("sh_util_setlooptime"));
	1367	}
	1368	}
	1369
	1370	#if defined (SH_WITH_CLIENT) \|\| defined (SH_STANDALONE)
[20]	1371	int sh_util_setchecksum (const char * str)
[1]	1372	{
	1373	static int reject = 0;
	1374
	1375	SL_ENTER(_("sh_util_setchecksum"));
	1376
	1377	if (reject == 1)
	1378	SL_RETURN((0), _("sh_util_setchecksum"));
	1379	reject = 1;
	1380
	1381	if (sl_strncmp (str, _("init"), sizeof("init")-1) == 0)
	1382	{
	1383	sh.flag.checkSum = SH_CHECK_INIT;
	1384	}
	1385	else if (sl_strncmp (str, _("update"), sizeof("update")-1) == 0)
	1386	{
	1387	if (S_TRUE == file_is_remote())
	1388	{
	1389	sh_error_handle ((-1), FIL__, __LINE__, EINVAL, MSG_EINVALS,
	1390	_("checksum testing"), str);
	1391	SL_RETURN((-1), _("sh_util_setchecksum"));
	1392	}
	1393	else
	1394	{
	1395	sh.flag.checkSum = SH_CHECK_CHECK;
	1396	sh.flag.update = S_TRUE;
	1397	}
	1398	}
	1399	else if (sl_strncmp (str, _("check"), sizeof("check")-1) == 0)
	1400	{
	1401	sh.flag.checkSum = SH_CHECK_CHECK;
	1402	}
	1403	/*
	1404	else if (sl_strncmp (str, _("update"), sizeof("update")-1) == 0)
	1405	{
	1406	sh.flag.checkSum = SH_CHECK_INIT;
	1407	sh.flag.update = S_TRUE;
	1408	}
	1409	*/
	1410	else if (sl_strncmp (str, _("none"), sizeof("none")-1) == 0)
	1411	{
	1412	sh.flag.checkSum = SH_CHECK_NONE;
	1413	}
	1414	else
	1415	{
	1416	sh_error_handle ((-1), FIL__, __LINE__, EINVAL, MSG_EINVALS,
	1417	_("checksum testing"), str);
	1418	SL_RETURN((-1), _("sh_util_setchecksum"));
	1419	}
	1420	SL_RETURN((0), _("sh_util_setchecksum"));
	1421	}
	1422	#endif
	1423
	1424	/@+charint@/
	1425	unsigned char TcpFlag[8][PW_LEN+1] = {
	1426	#if (POS_TF == 1)
	1427	{ 0xF7,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xF7,0x00 },
	1428	#endif
	1429	{ 0xFF,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xFF,0x00 },
	1430	#if (POS_TF == 2)
	1431	{ 0xF7,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xF7,0x00 },
	1432	#endif
	1433	{ 0xFF,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xFF,0x00 },
	1434	#if (POS_TF == 3)
	1435	{ 0xF7,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xF7,0x00 },
	1436	#endif
	1437	{ 0xFF,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xFF,0x00 },
	1438	#if (POS_TF == 4)
	1439	{ 0xF7,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xF7,0x00 },
	1440	#endif
	1441	{ 0xFF,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xFF,0x00 },
	1442	#if (POS_TF == 5)
	1443	{ 0xF7,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xF7,0x00 },
	1444	#endif
	1445	{ 0xFF,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xFF,0x00 },
	1446	#if (POS_TF == 6)
	1447	{ 0xF7,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xF7,0x00 },
	1448	#endif
	1449	{ 0xFF,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xFF,0x00 },
	1450	#if (POS_TF == 7)
	1451	{ 0xF7,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xF7,0x00 },
	1452	#endif
	1453	{ 0xFF,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xFF,0x00 },
	1454	#if (POS_TF == 8)
	1455	{ 0xF7,0xC3,0x12,0xAA,0xAA,0x12,0xC3,0xF7,0x00 },
	1456	#endif
	1457	};
	1458	/@-charint@/
	1459
	1460	/* initialize a key to a random value
	1461	* rev 0.8
	1462	*/
	1463	int sh_util_keyinit (char * buf, long size)
	1464	{
	1465	UINT32 bufy[6];
	1466	int i;
	1467	int status = 0;
	1468	char * p;
[133]	1469	char hashbuf[KEYBUF_SIZE];
[1]	1470
	1471	SL_ENTER(_("sh_util_keyinit"));
	1472
	1473	ASSERT((size <= KEY_LEN+1), _("size <= KEY_LEN+1"))
	1474
	1475	if (size > KEY_LEN+1)
	1476	size = KEY_LEN+1;
	1477
	1478	/* seed / re-seed the PRNG if required
	1479	*/
	1480	status = taus_seed ();
	1481
	1482	if (status == -1)
	1483	sh_error_handle ((-1), FIL__, __LINE__, -1, MSG_ES_KEY1,
	1484	_("taus_seed"));
	1485
	1486	for (i = 0; i < 6; ++i)
[170]	1487	bufy[i] = taus_get();
[1]	1488
	1489	p = sh_tiger_hash ((char *) bufy, TIGER_DATA,
[133]	1490	(unsigned long)(6*sizeof(UINT32)),
	1491	hashbuf, sizeof(hashbuf));
[1]	1492
	1493	i = sl_strlcpy(buf, p, (size_t)size);
	1494
	1495	memset (bufy, 0, 6*sizeof(UINT32));
	1496
	1497	if ((status == 0) && (!SL_ISERROR(i)) )
	1498	SL_RETURN((0),_("sh_util_keyinit"));
	1499
	1500	if (SL_ISERROR(i))
	1501	sh_error_handle ((-1), FIL__, __LINE__, i, MSG_ES_KEY2,
	1502	_("sl_strlcpy"));
	1503
	1504	SL_RETURN((-1),_("sh_util_keyinit"));
	1505	}
	1506
	1507	#if defined(SH_WITH_CLIENT) \|\| defined(SH_STANDALONE)
	1508
	1509	static unsigned char sh_obscure_index[256];
[76]	1510	static int sh_obscure_no_check = S_FALSE;
[1]	1511
[68]	1512	int sh_util_valid_utf8 (const unsigned char * str)
	1513	{
[76]	1514	const int sh_val_utf8_1 = 1;
	1515	const int sh_val_utf8_2 = 2;
	1516	const int sh_val_utf8_3 = 3;
	1517	const int sh_val_utf8_4 = 4;
	1518
[170]	1519	size_t len = strlen((const char *)str);
[68]	1520	size_t l = 0;
[76]	1521	int typ = 0;
	1522	unsigned char c = '\0';
	1523	unsigned char c2[2] = { 0x00, 0x00 };
	1524	unsigned char c3[3] = { 0x00, 0x00, 0x00 };
[68]	1525
[76]	1526
[68]	1527	#define SH_VAL_UTF8_1 ((c != '\0') && ((c & 0x80) == 0x00))
	1528	#define SH_VAL_UTF8_2 ((c != '\0') && ((c & 0xE0) == 0xC0)) /* 110x xxxx */
	1529	#define SH_VAL_UTF8_3 ((c != '\0') && ((c & 0xF0) == 0xE0)) /* 1110 xxxx */
	1530	#define SH_VAL_UTF8_4 ((c != '\0') && ((c & 0xF8) == 0xF0)) /* 1111 0xxx */
	1531	#define SH_VAL_UTF8_N ((c != '\0') && ((c & 0xC0) == 0x80)) /* 10xx xxxx */
[76]	1532	#define SH_VAL_BAD ((c == '"') \|\| (c == '\t') \|\| (c == '\b') \|\| \
	1533	(c == '\f') \|\| (c == '\n') \|\| \
[68]	1534	(c == '\r') \|\| (c == '\v') \|\| iscntrl((int) c) \|\| \
	1535	(c != ' ' && !isgraph ((int) c)))
	1536
	1537	while(l < len)
	1538	{
	1539	c = str[l];
	1540
	1541	if (SH_VAL_UTF8_1)
	1542	{
[76]	1543	if (!(SH_VAL_BAD && (sh_obscure_index[c] != 1)))
	1544	{
	1545	typ = sh_val_utf8_1;
	1546	++l; continue;
	1547	}
	1548	else
	1549	{
	1550	return S_FALSE;
	1551	}
[68]	1552	}
	1553	else if (SH_VAL_UTF8_2)
	1554	{
[76]	1555	typ = sh_val_utf8_2;
	1556	c2[0] = c;
	1557	if ((c & 0x3e) != 0x00) /* !(overlong 2-byte seq.) */
	1558	{
	1559	++l;
	1560	if (l != len) {
	1561	c = str[l];
	1562	if(SH_VAL_UTF8_N) {
	1563	c2[1] = c;
	1564	++l; continue;
	1565	}
	1566	else {
	1567	return S_FALSE;
	1568	}
	1569	}
	1570	else {
	1571	return S_FALSE;
	1572	}
	1573	}
	1574	else
	1575	{
	1576	return S_FALSE; /* overlong 2-byte seq. */
	1577	}
[68]	1578	}
	1579	else if (SH_VAL_UTF8_3)
	1580	{
[76]	1581	typ = sh_val_utf8_3;
	1582	c3[0] = c;
[68]	1583	++l; if (l == len) return S_FALSE; c = str[l];
	1584	if(!SH_VAL_UTF8_N) return S_FALSE;
	1585	if (((str[l-1] & 0x1F) == 0x00) && ((c & 0x60) == 0x00))
	1586	return S_FALSE; /* overlong 3-byte seq. */
[76]	1587	c3[1] = c;
[68]	1588	++l; if (l == len) return S_FALSE; c = str[l];
	1589	if(!SH_VAL_UTF8_N) return S_FALSE;
[76]	1590	c3[2] = c;
[68]	1591	++l; continue;
	1592	}
	1593	else if (SH_VAL_UTF8_4)
	1594	{
[76]	1595	typ = sh_val_utf8_4;
[68]	1596	++l; if (l == len) return S_FALSE; c = str[l];
	1597	if(!SH_VAL_UTF8_N) return S_FALSE;
	1598	if (((str[l-1] & 0x0F) == 0x00) && ((c & 0x70) == 0x00))
	1599	return S_FALSE; /* overlong 4-byte seq. */
	1600	++l; if (l == len) return S_FALSE; c = str[l];
	1601	if(!SH_VAL_UTF8_N) return S_FALSE;
	1602	++l; if (l == len) return S_FALSE; c = str[l];
	1603	if(!SH_VAL_UTF8_N) return S_FALSE;
	1604	++l; continue;
	1605	}
	1606	return S_FALSE;
	1607	}
[76]	1608
	1609	/* last character is invisible (space or else)
	1610	*/
	1611	if (typ == sh_val_utf8_1)
	1612	{
	1613	if (c != ' ')
	1614	return S_TRUE;
	1615	else
	1616	return S_FALSE;
	1617	}
	1618	else if (typ == sh_val_utf8_2)
	1619	{
	1620	if (c2[0] == 0xC2 && c2[1] == 0xA0) /* nbsp */
	1621	return S_FALSE;
	1622	else
	1623	return S_TRUE;
	1624	}
	1625	else if (typ == sh_val_utf8_3)
	1626	{
	1627	if (c3[0] == 0xE2)
	1628	{
	1629	if (c3[1] == 0x80 && c3[2] >= 0x80 && c3[2] <= 0x8F)
	1630	return S_FALSE; /* various spaces, left-to-right, right-to-left */
	1631	else if (c3[1] == 0x80 && (c3[2] == 0xA8 \|\| c3[2] == 0xA9 \|\|
	1632	c3[2] == 0xAD \|\| c3[2] == 0xAF))
	1633	return S_FALSE; /* line sep, para sep, zw word joiner, nnbsp */
	1634	else if (c3[1] == 0x81 && (c3[2] == 0xA0 \|\| c3[2] == 0xA1 \|\|
	1635	c3[2] == 0x9F))
	1636	return S_FALSE; /* word joiner, function app, math space */
	1637	else
	1638	return S_TRUE;
	1639	}
	1640	else if (c3[0] == 0xE3 && c3[1] == 0x80 && c3[2] == 0x80)
	1641	{
	1642	return S_FALSE; /* ideographic space */
	1643	}
	1644	else if (c3[0] == 0xEF && c3[1] == 0xBB && c3[2] == 0xBF)
	1645	{
	1646	return S_FALSE; /* zwnbsp */
	1647	}
	1648	else
	1649	{
	1650	return S_TRUE;
	1651	}
	1652	}
	1653	else
	1654	{
	1655	return S_TRUE;
	1656	}
[68]	1657	}
	1658
	1659
[22]	1660	int sh_util_obscure_ok (const char * str)
[1]	1661	{
	1662	unsigned long i;
[22]	1663	char * endptr = NULL;
[1]	1664
[29]	1665	SL_ENTER(_("sh_util_obscure_ok"));
[1]	1666
	1667	if (0 == sl_strncmp("all", str, 3))
	1668	{
	1669	for (i = 0; i < 255; ++i)
	1670	{
	1671	sh_obscure_index[i] = (unsigned char)1;
	1672	}
[76]	1673	sh_obscure_no_check = S_TRUE;
[29]	1674	SL_RETURN(0, _("sh_util_obscure_ok"));
[1]	1675	}
	1676
[76]	1677	sh_obscure_no_check = S_FALSE;
	1678
[1]	1679	for (i = 0; i < 255; ++i)
	1680	{
	1681	sh_obscure_index[i] = (unsigned char)0;
	1682	}
	1683
[22]	1684	i = strtoul (str, &endptr, 0);
	1685	if (i > 255)
	1686	{
[29]	1687	SL_RETURN(-1, _("sh_util_obscure_ok"));
[22]	1688	}
	1689	sh_obscure_index[i] = (unsigned char)1;
	1690	if (*endptr == ',')
	1691	++endptr;
	1692
[1]	1693	while (*endptr != '\0')
	1694	{
	1695	i = strtoul (endptr, &endptr, 0);
	1696	if (i > 255)
	1697	{
[29]	1698	SL_RETURN(-1, _("sh_util_obscure_ok"));
[1]	1699	}
	1700	sh_obscure_index[i] = (unsigned char)1;
	1701	if (*endptr == ',')
	1702	++endptr;
	1703	}
[29]	1704	SL_RETURN(0, _("sh_util_obscure_ok"));
[1]	1705	}
	1706
[68]	1707	static int sh_obscure_check_utf8 = S_FALSE;
	1708
	1709	int sh_util_obscure_utf8 (const char * c)
	1710	{
	1711	int i;
	1712	SL_ENTER(_("sh_util_obscure_utf8"));
	1713	i = sh_util_flagval(c, &(sh_obscure_check_utf8));
[76]	1714	if (sh_obscure_check_utf8 == S_TRUE)
	1715	sh_obscure_no_check = S_FALSE;
[68]	1716	SL_RETURN(i, _("sh_util_obscure_utf8"));
	1717	}
	1718
	1719
[1]	1720	int sh_util_obscurename (ShErrLevel level, char * name_orig, int flag)
	1721	{
[29]	1722	unsigned char * name = (unsigned char *) name_orig;
[1]	1723	char * safe;
	1724	unsigned int i;
[76]	1725	size_t len = 0;
[1]	1726
	1727	SL_ENTER(_("sh_util_obscurename"));
	1728
	1729	ASSERT_RET((name != NULL), _("name != NULL"), (0))
	1730
[76]	1731	if (sh_obscure_no_check == S_FALSE)
[68]	1732	{
[76]	1733	if (sh_obscure_check_utf8 != S_TRUE)
[68]	1734	{
[76]	1735	/* -- Check name. --
	1736	*/
	1737	while (*name != '\0')
	1738	{
	1739	if ( (name) > 0x7F \|\| (name) == '"' \|\| (*name) == '\t' \|\|
	1740	(name) == '\b' \|\| (name) == '\f' \|\|
	1741	(name) == '\n' \|\| (name) == '\r' \|\|
	1742	(name) == '\v' \|\| iscntrl((int) name) \|\|
	1743	((name) != ' ' && !isgraph ((int) name)) )
	1744	{
	1745	i = (unsigned char) *name;
	1746	if (sh_obscure_index[i] != (unsigned char)1)
	1747	{
	1748	goto err;
	1749	}
	1750	}
	1751	name++; ++len;
	1752	}
	1753
	1754	/* Check for blank at end of name
	1755	*/
	1756	if ((len > 0) && (name_orig[len-1] == ' '))
	1757	{
	1758	goto err;
	1759	}
[68]	1760	}
[76]	1761	else
[1]	1762	{
[76]	1763	if (S_FALSE == sh_util_valid_utf8(name))
[1]	1764	{
[68]	1765	goto err;
[1]	1766	}
[76]	1767	SL_RETURN((0),_("sh_util_obscurename"));
[1]	1768	}
	1769	}
[76]	1770
[1]	1771	SL_RETURN((0),_("sh_util_obscurename"));
[68]	1772
	1773	err:
[76]	1774
[68]	1775	if (flag == S_TRUE)
	1776	{
	1777	safe = sh_util_safe_name (name_orig);
	1778	sh_error_handle (level, FIL__, __LINE__, 0, MSG_FI_OBSC,
	1779	safe);
	1780	SH_FREE(safe);
	1781	}
	1782	SL_RETURN((-1),_("sh_util_obscurename"));
[1]	1783	}
[68]	1784
[1]	1785	#endif
	1786
	1787	/* returns freshly allocated memory, return value should be free'd
	1788	*/
[34]	1789	char * sh_util_dirname(const char * fullpath)
[1]	1790	{
	1791	char * retval;
[34]	1792	size_t len;
[93]	1793	char * tmp;
[1]	1794
[34]	1795	SL_ENTER(_("sh_util_dirname"));
[1]	1796
	1797	ASSERT_RET ((fullpath != NULL), _("fullpath != NULL"), (NULL))
[93]	1798	ASSERT_RET ((fullpath == '/'), _("fullpath == '/'"), (NULL))
[1]	1799
[93]	1800	retval = sh_util_strdup(fullpath);
[1]	1801
[93]	1802	tmp = retval;
	1803	while (*tmp == '/') ++tmp;
[34]	1804
[93]	1805	/* (1) only leading slashes -- return exact copy
	1806	*/
	1807	if (*tmp == '\0')
	1808	{
	1809	SL_RETURN(retval, _("sh_util_dirname"));
	1810	}
	1811
	1812	/* (2) there are non-slash characters, so delete trailing slashes
	1813	*/
	1814	len = sl_strlen (retval); /* retval[len] is terminating '\0' */
	1815
	1816	while (len > 1 && retval[len-1] == '/') /* delete trailing slash */
	1817	{
	1818	retval[len-1] = '\0';
	1819	--len;
	1820	}
	1821
	1822	/* (3) now delete all non-slash characters up to the preceding slash
	1823	*/
	1824	while (len > 1 && retval[len-1] != '/') {
	1825	retval[len-1] = '\0';
[34]	1826	--len;
[1]	1827	}
	1828
[93]	1829	/* (4a) only leading slashes left, so return this
[1]	1830	*/
[93]	1831	if (&(retval[len]) == tmp)
	1832	{
	1833	SL_RETURN(retval, _("sh_util_dirname"));
[34]	1834	}
[1]	1835
[93]	1836	/* (4b) strip trailing slash(es) of parent directory
	1837	*/
	1838	while (len > 1 && retval[len-1] == '/') {
	1839	retval[len-1] = '\0';
	1840	--len;
	1841	}
	1842	SL_RETURN(retval, _("sh_util_dirname"));
[1]	1843
	1844	}
	1845
	1846	/* returns freshly allocated memory, return value should be free'd
	1847	*/
[34]	1848	char * sh_util_basename(const char * fullpath)
[1]	1849	{
[93]	1850	char * retval = NULL;
	1851	const char * tmp;
	1852	char * tmp2;
	1853	char * c;
	1854	size_t len;
[1]	1855
[34]	1856	SL_ENTER(_("sh_util_basename"));
[1]	1857
	1858	ASSERT_RET ((fullpath != NULL), _("fullpath != NULL"), (NULL))
	1859
[93]	1860	tmp = fullpath; while (*tmp == '/') ++tmp;
	1861	if (*tmp == '\0')
[34]	1862	{
[93]	1863	retval = sh_util_strdup(fullpath);
[34]	1864	}
	1865	else
	1866	{
[93]	1867	tmp2 = sh_util_strdup(tmp);
	1868	len = sl_strlen (tmp2);
	1869
	1870	while (len > 1 && tmp2[len-1] == '/')
[34]	1871	{
[93]	1872	tmp2[len-1] = '\0';
	1873	--len;
	1874	}
	1875
	1876	c = strrchr(tmp2, '/');
	1877	if (c)
	1878	{
[34]	1879	retval = sh_util_strdup(++c);
[93]	1880	SH_FREE(tmp2);
[34]	1881	}
	1882	else
	1883	{
[93]	1884	retval = tmp2;
[34]	1885	}
	1886	}
[1]	1887
[34]	1888	SL_RETURN(retval, _("sh_util_basename"));
[1]	1889	}
	1890
[185]	1891	#define SH_ESCAPE_SPACE 1
	1892	#define SH_DONT_ESCAPE_SPACE 0
	1893	char * sh_util_safe_name_int (const char * name, int escape_space);
	1894
	1895	char * sh_util_safe_name (const char * name)
	1896	{
	1897	return sh_util_safe_name_int (name, SH_ESCAPE_SPACE);
	1898	}
	1899
	1900	char * sh_util_safe_name_keepspace (const char * name)
	1901	{
	1902	return sh_util_safe_name_int (name, SH_DONT_ESCAPE_SPACE);
	1903	}
	1904
[1]	1905	/* returns freshly allocated memory, return value should be free'd
	1906	*/
[185]	1907	char * sh_util_safe_name_int (const char * name, int escape_space)
[1]	1908	{
	1909	register int i = 0;
	1910	const char * p;
	1911	char * retval;
	1912	char oct[32];
	1913	char format[16];
[34]	1914	size_t len;
[1]	1915
	1916	SL_ENTER(_("sh_util_safe_name"));
	1917
	1918	if (name == NULL)
	1919	{
	1920	/* return an allocated array
	1921	*/
	1922	retval = SH_ALLOC(7);
	1923	(void) sl_strlcpy(retval, _("(null)"), 7);
	1924	SL_RETURN(retval, _("sh_util_safe_name"));
	1925	}
	1926
	1927	/*
	1928	ASSERT_RET ((name != NULL), _("name != NULL"), _("NULL"))
	1929	*/
	1930
[34]	1931	len = sl_strlen(name);
	1932	p = name;
	1933
[1]	1934	#ifdef SH_USE_XML
[34]	1935	if (sl_ok_muls (6, len) && sl_ok_adds ((6*len), 2))
	1936	{ retval = SH_ALLOC(6 * len + 2); }
	1937	else
	1938	{
	1939	/* return an allocated array
	1940	*/
	1941	retval = SH_ALLOC(11);
	1942	(void) sl_strlcpy(retval, _("(overflow)"), 11);
	1943	SL_RETURN(retval, _("sh_util_safe_name"));
	1944	}
[1]	1945	#else
[34]	1946	if (sl_ok_muls (4, len) && sl_ok_adds ((4*len), 2))
	1947	{ retval = SH_ALLOC(4 * len + 2); }
	1948	else
	1949	{
	1950	/* return an allocated array
	1951	*/
	1952	retval = SH_ALLOC(11);
	1953	(void) sl_strlcpy(retval, _("(overflow)"), 11);
	1954	SL_RETURN(retval, _("sh_util_safe_name"));
	1955	}
[1]	1956	#endif
	1957
	1958	(void) sl_strncpy(format, _("%c%03o"), 16);
	1959
	1960	while (*p != '\0') {
	1961	/* Most frequent cases first
	1962	*/
	1963	if ( ((p) >= 'a' && (p) <= 'z') \|\| ((p) == '/') \|\| ((p) == '.') \|\|
	1964	((p) >= '0' && (p) <= '9') \|\|
	1965	((p) >= 'A' && (p) <= 'Z')) {
	1966	retval[i] = *p;
	1967	} else if ( (p) == '\\') { / backslash */
	1968	retval[i] = '\\'; ++i;
	1969	retval[i] = '\\';
	1970	} else if ( (p) == '\n') { / newline */
	1971	retval[i] = '\\'; ++i;
	1972	retval[i] = 'n';
	1973	} else if ( (p) == '\b') { / backspace */
	1974	retval[i] = '\\'; ++i;
	1975	retval[i] = 'b';
	1976	} else if ( (p) == '\r') { / carriage return */
	1977	retval[i] = '\\'; ++i;
	1978	retval[i] = 'r';
	1979	} else if ( (p) == '\t') { / horizontal tab */
	1980	retval[i] = '\\'; ++i;
	1981	retval[i] = 't';
	1982	} else if ( (p) == '\v') { / vertical tab */
	1983	retval[i] = '\\'; ++i;
	1984	retval[i] = 'v';
	1985	} else if ( (p) == '\f') { / form-feed */
	1986	retval[i] = '\\'; ++i;
	1987	retval[i] = 'f';
	1988	#ifdef WITH_DATABASE
	1989	} else if ( (p) == '\'') { / single quote */
	1990	retval[i] = '\\'; ++i;
	1991	retval[i] = '\'';
	1992	#endif
	1993	} else if ( (p) == ' ') { / space */
[185]	1994	if (escape_space) {
	1995	retval[i] = '\\'; ++i;
	1996	retval[i] = ' ';
	1997	}
	1998	else {
	1999	retval[i] = *p;
	2000	}
[1]	2001	#ifdef SH_USE_XML
	2002	} else if ( (p) == '"') { / double quote */
	2003	retval[i] = '&'; ++i;
	2004	retval[i] = 'q'; ++i;
	2005	retval[i] = 'u'; ++i;
	2006	retval[i] = 'o'; ++i;
	2007	retval[i] = 't'; ++i;
	2008	retval[i] = ';';
	2009	} else if ( (p) == '&') { / ampersand */
	2010	retval[i] = '&'; ++i;
	2011	retval[i] = 'a'; ++i;
	2012	retval[i] = 'm'; ++i;
	2013	retval[i] = 'p'; ++i;
	2014	retval[i] = ';';
	2015	} else if ( (p) == '<') { / left angle */
	2016	retval[i] = '&'; ++i;
	2017	retval[i] = 'l'; ++i;
	2018	retval[i] = 't'; ++i;
	2019	retval[i] = ';';
	2020	} else if ( (p) == '>') { / right angle */
	2021	retval[i] = '&'; ++i;
	2022	retval[i] = 'g'; ++i;
	2023	retval[i] = 't'; ++i;
	2024	retval[i] = ';';
	2025	#else
	2026	} else if ( (p) == '"') { / double quote */
	2027	retval[i] = '\\'; ++i;
	2028	retval[i] = '\"';
	2029	#endif
	2030	} else if (!isgraph ((int) p)) { / not printable */
	2031	/@-bufferoverflowhigh -formatconst@/
[22]	2032	/* flawfinder: ignore */
[1]	2033	sprintf(oct, format, '\\', /* known to fit */
	2034	(unsigned char) *p);
	2035	/@+bufferoverflowhigh +formatconst@/
	2036	retval[i] = oct[0]; ++i;
	2037	retval[i] = oct[1]; ++i;
	2038	retval[i] = oct[2]; ++i;
	2039	retval[i] = oct[3];
	2040	} else {
	2041	retval[i] = *p;
	2042	}
	2043	++p;
	2044	++i;
	2045	}
	2046	retval[i] = '\0';
	2047	SL_RETURN(retval, _("sh_util_safe_name"));
	2048	}
	2049
[149]	2050	int sh_util_isnum (const char *str)
[1]	2051	{
[149]	2052	const char *p = str;
[1]	2053
	2054	SL_ENTER(_("sh_util_isnum"));
	2055
	2056	ASSERT_RET ((str != NULL), _("str != NULL"), (-1))
	2057
	2058	while (p) {
	2059	if (!isdigit((int) *p) )
	2060	SL_RETURN((-1), _("sh_util_isnum"));
	2061	++p;
	2062	}
	2063	SL_RETURN((0), _("sh_util_isnum"));
	2064	}
	2065
[149]	2066	char * sh_util_strconcat (const char * arg1, ...)
[1]	2067	{
[34]	2068	size_t length, l2;
[1]	2069	char * s;
	2070	char * strnew;
	2071	va_list vl;
	2072
	2073	SL_ENTER(_("sh_util_strconcat"));
	2074
	2075	ASSERT_RET ((arg1 != NULL), _("arg1 != NULL"), (NULL))
	2076
	2077	length = sl_strlen (arg1) + 1;
	2078
	2079	va_start (vl, arg1);
	2080	s = va_arg (vl, char * );
	2081	while (s != NULL)
	2082	{
[34]	2083	l2 = sl_strlen (s);
	2084	if (sl_ok_adds(length, l2))
	2085	length += l2;
	2086	else
	2087	SL_RETURN(NULL, _("sh_util_strconcat"));
[1]	2088	s = va_arg (vl, char * );
	2089	}
	2090	va_end (vl);
	2091
[34]	2092	if (sl_ok_adds(length, 2))
	2093	strnew = SH_ALLOC( length + 2 );
	2094	else
	2095	SL_RETURN(NULL, _("sh_util_strconcat"));
	2096
[1]	2097	strnew[0] = '\0';
	2098
	2099	(void) sl_strlcpy (strnew, arg1, length + 2);
	2100
	2101	va_start (vl, arg1);
	2102	s = va_arg (vl, char * );
	2103	while (s)
	2104	{
	2105	(void) sl_strlcat (strnew, s, length + 2);
	2106	s = va_arg (vl, char * );
	2107	}
	2108	va_end (vl);
	2109
	2110	SL_RETURN(strnew, _("sh_util_strconcat"));
	2111	}
	2112
[167]	2113	static const char bto64_0[] = N_("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789()");
	2114	static char bto64[65] = { '\0' };
[1]	2115
[167]	2116
[226]	2117	size_t sh_util_base64_enc (unsigned char * out,
	2118	const unsigned char * instr,
[167]	2119	size_t lin)
	2120	{
	2121	int ll;
	2122	unsigned char a, b, c;
	2123	size_t len = 0;
	2124	size_t j = 0;
	2125
	2126	start:
	2127	if (bto64[0] != '\0')
	2128	{
	2129	if (instr && *instr)
	2130	{
	2131	if (lin == 0)
[170]	2132	lin = strlen((const char *)instr);
[167]	2133
	2134	do {
	2135	ll = 0;
	2136
	2137	if (len < lin)
	2138	{ a = *instr; ++instr; ++len; ++ll; }
	2139	else
	2140	{ a = 0; }
	2141	if (len < lin)
	2142	{ b = *instr; ++instr; ++len; ++ll; }
	2143	else
	2144	{ b = 0; }
	2145	if (len < lin)
	2146	{ c = *instr; ++instr; ++len; ++ll; }
	2147	else
	2148	{ c = 0; }
	2149
	2150	*out = bto64[ a >> 2 ];
	2151	++j; ++out;
	2152	*out = bto64[ ((a & 0x03) << 4) \| ((b & 0xf0) >> 4) ];
	2153	++j; ++out;
	2154	*out = (unsigned char) (ll > 1 ? bto64[ ((b & 0x0f) << 2) \| ((c & 0xc0) >> 6) ] : '?');
	2155	++j; ++out;
	2156	*out = (unsigned char) (ll > 2 ? bto64[ c & 0x3f ] : '?');
	2157	++j; ++out;
	2158	} while (len < lin);
	2159	}
	2160	*out = '\0';
	2161	return j;
	2162	}
	2163
	2164	memcpy(bto64, _(bto64_0), 65);
	2165	goto start;
	2166	}
	2167
	2168	size_t sh_util_base64_enc_alloc (char *out, const char in, size_t inlen)
	2169	{
	2170	size_t outlen = SH_B64_SIZ(inlen);
	2171
	2172	if (inlen > outlen) /* overflow */
	2173	{
	2174	*out = NULL;
	2175	return 0;
	2176	}
	2177
	2178	*out = SH_ALLOC(outlen);
[170]	2179	return sh_util_base64_enc((unsigned char )out, (const unsigned char *)in, inlen);
[167]	2180	}
	2181
[226]	2182	size_t sh_util_base64_dec (unsigned char *out,
	2183	const unsigned char *in,
[167]	2184	size_t lin)
	2185	{
	2186	size_t i;
	2187	unsigned char c;
	2188	unsigned char b;
	2189	size_t lout = 0;
	2190	int w = 0;
	2191
	2192	if (out && in)
	2193	{
	2194	if (lin == 0)
[170]	2195	lin = strlen((const char *)in);
[167]	2196
	2197	for (i = 0; i < lin; i++)
	2198	{
	2199	c = *in; ++in;
	2200	b = 0;
	2201
	2202	if ((c >= 'A') && (c <= 'Z'))
	2203	{
	2204	b = (c - 'A');
	2205	}
	2206	else if ((c >= 'a') && (c <= 'z'))
	2207	{
	2208	b = (c - 'a' + 26);
	2209	}
	2210	else if ((c >= '0') && (c <= '9'))
	2211	{
	2212	b = (c - '0' + 52);
	2213	}
	2214	else if (c == '(' \|\| c == '+')
	2215	{
	2216	b = 62;
	2217	}
	2218	else if (c == ')' \|\| c == '/')
	2219	{
[170]	2220	b = 63;
[167]	2221	}
	2222	else if (c == '?' \|\| c == '=')
	2223	{
	2224	/* last byte was written to, but will now get
	2225	* truncated
	2226	*/
	2227	if (lout > 0) --lout;
	2228	break;
	2229	}
	2230
	2231	if (w == 0)
	2232	{
	2233	*out = (b << 2) & 0xfc;
	2234	++lout;
	2235	}
	2236	else if (w == 1)
	2237	{
	2238	*out \|= (b >> 4) & 0x03;
	2239	++out;
	2240	*out = (b << 4) & 0xf0;
	2241	++lout;
	2242	}
	2243	else if (w == 2)
	2244	{
	2245	*out \|= (b >> 2) & 0x0f;
	2246	++out;
	2247	*out = (b << 6) & 0xc0;
	2248	++lout;
	2249	}
	2250	else if (w == 3)
	2251	{
	2252	*out \|= b & 0x3f;
	2253	++out;
	2254	}
	2255
	2256	++w;
	2257
	2258	if (w == 4)
	2259	{
	2260	w = 0;
	2261	}
	2262	}
	2263	*out = '\0';
	2264	}
	2265	return lout;
	2266	}
	2267
	2268	size_t sh_util_base64_dec_alloc (unsigned char *out, const unsigned char in,
	2269	size_t lin)
	2270	{
	2271	size_t lout = 3 * (lin / 4) + 2;
	2272
	2273	*out = SH_ALLOC(lout);
	2274
	2275	return sh_util_base64_dec (*out, in, lin);
	2276	}
	2277
	2278
[1]	2279	#ifdef HAVE_REGEX_H
	2280
	2281	#include <regex.h>
	2282
	2283	int sh_util_regcmp (char * regex_str, char * in_str)
	2284	{
	2285	#if defined(REG_ESPACE)
	2286	int status = REG_ESPACE;
	2287	#else
	2288	int status = -1;
	2289	#endif
	2290	regex_t preg;
	2291	char * errbuf;
	2292
	2293	SL_ENTER(_("sh_util_regcmp"));
	2294
	2295	status = regcomp(&preg, regex_str, REG_NOSUB\|REG_EXTENDED);
	2296
	2297	if (status == 0)
	2298	{
	2299	if ((status = regexec(&preg, in_str, 0, NULL, 0)) == 0)
	2300	{
	2301	regfree (&preg);
	2302	SL_RETURN((0), _("sh_util_regcmp"));
	2303	}
	2304	}
	2305
	2306	if (status != 0 && status != REG_NOMATCH)
	2307	{
[34]	2308	errbuf = SH_ALLOC(BUFSIZ);
[1]	2309	(void) regerror(status, &preg, errbuf, BUFSIZ);
[34]	2310	errbuf[BUFSIZ-1] = '\0';
[1]	2311	sh_error_handle ((-1), FIL__, __LINE__, status, MSG_E_REGEX,
	2312	errbuf, regex_str);
	2313	SH_FREE(errbuf);
	2314	}
	2315
	2316	regfree (&preg);
	2317	SL_RETURN((-1), _("sh_util_regcmp"));
	2318	}
	2319
	2320	#endif
	2321
	2322
	2323
	2324
	2325
	2326
	2327
	2328

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

Download in other formats: