SZS v2.18a

1 files changed, 5360 insertions, 0 deletions

diff --git a/project/dclib/dclib-file.c b/project/dclib/dclib-file.c
new file mode 100644
index 0000000..8a69370
--- /dev/null
+++ b/project/dclib/dclib-file.c
@@ -0,0 +1,5360 @@
+
+/***************************************************************************
+ *                                                                         *
+ *                     _____     ____                                      *
+ *                    |  __ \   / __ \   _     _ _____                     *
+ *                    | |  \ \ / /  \_\ | |   | |  _  \                    *
+ *                    | |   \ \| |      | |   | | |_| |                    *
+ *                    | |   | || |      | |   | |  ___/                    *
+ *                    | |   / /| |   __ | |   | |  _  \                    *
+ *                    | |__/ / \ \__/ / | |___| | |_| |                    *
+ *                    |_____/   \____/  |_____|_|_____/                    *
+ *                                                                         *
+ *                       Wiimms source code library                        *
+ *                                                                         *
+ ***************************************************************************
+ *                                                                         *
+ *        Copyright (c) 2012-2020 by Dirk Clemens <wiimm@wiimm.de>         *
+ *                                                                         *
+ ***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   See file gpl-2.0.txt or http://www.gnu.org/licenses/gpl-2.0.txt       *
+ *                                                                         *
+ ***************************************************************************/
+
+#define _GNU_SOURCE 1
+
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+#include <termios.h>
+#include <utime.h>
+#include <errno.h>
+#include <dirent.h>
+#include <poll.h>
+#include <signal.h>
+#include <sys/wait.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/resource.h>
+
+#include "dclib-basics.h"
+#include "dclib-file.h"
+#include "dclib-debug.h"
+#include "dclib-network.h"
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			termios support			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static struct termios termios_data;
+int termios_valid = 0;
+
+void ResetTermios()
+{
+    if ( termios_valid > 0 )
+	tcsetattr(0,TCSANOW,&termios_data);
+}
+
+static bool LoadTermios()
+{
+    if (!termios_valid)
+    {
+	termios_valid = -1;
+	if ( isatty(0) && !tcgetattr(0,&termios_data) )
+	    termios_valid = 1;
+    }
+    return termios_valid > 0;
+}
+
+bool EnableSingleCharInput()
+{
+    if (!LoadTermios())
+	return false;
+
+    struct termios tios;
+    memcpy(&tios,&termios_data,sizeof(tios));
+    tios.c_lflag &= ~(ICANON|ECHO);
+    tcsetattr(0,TCSANOW,&tios);
+    return true;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			enum FileMode_t			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+ccp GetFileModeStatus
+(
+    char		*buf,		// result buffer
+					// NULL: use a local circulary static buffer
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    FileMode_t		file_mode,	// filemode to print
+    uint		print_mode	// 0: short vector: 1 char for 1 attrib
+					// 1: long mode: keyword for each set attrib
+)
+{
+    struct info_t
+    {
+	FileMode_t	mode;
+	char		ch;
+	ccp		name;
+    };
+
+    static const struct info_t info[] =
+    {
+	{ FM_TEST,	't', "test" },
+	{ FM_SILENT,	's', "silent" },
+	{ FM_IGNORE,	'i', "ignore" },
+	{ FM_MODIFY,	'M', "modify" },
+	{ FM_APPEND,	'A', "append" },
+	{ FM_UPDATE,	'U', "update" },
+	{ FM_OVERWRITE,	'O', "overwrite" },
+	{ FM_NUMBER,	'N', "number" },
+	{ FM_REMOVE,	'R', "remove" },
+	{ FM_MKDIR,	'M', "mkdir" },
+	{ FM_STDIO,	'S', "stdio" },
+	{ FM_TCP,	'I', "tcp" },
+	{ FM_DEV,	'D', "dev" },
+	{ FM_SPC,	'P', "spc" },
+	{ FM_TOUCH,	'H', "touch" },
+	{ FM_TEMP,	'T', "temp" },
+	{0,0,0}
+    };
+
+    if ( print_mode == 0 )
+    {
+	if ( !buf || !buf_size )
+	    buf = GetCircBuf( buf_size = 16 );
+	char *dest = buf, *end = buf + buf_size - 1;
+	const struct info_t *ip;
+	for ( ip = info; ip->mode && dest < end; ip++ )
+	    *dest++ = ip->mode & file_mode ? ip->ch : '-';
+	*dest = 0;
+	return buf;
+    }
+
+    if ( !buf || !buf_size )
+	buf = GetCircBuf( buf_size = 100 );
+
+    char *dest = buf, *end = buf + buf_size - 1;
+    const struct info_t *ip;
+    for ( ip = info; ip->mode && dest < end; ip++ )
+	if ( ip->mode & file_mode )
+	{
+	    if ( dest > buf )
+		*dest++ = ',';
+	    dest = StringCopyE(dest,end,ip->name);
+	}
+    *dest = 0;
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp GetFileOpenMode
+(
+    bool		create,		// false: open, true: create
+    FileMode_t		file_mode	// open modes
+)
+{
+    if ( file_mode & FM_TEST )
+	return "r";
+
+    if (!create)
+	return file_mode & FM_MODIFY ? "r+b" : "rb";
+
+    switch ( (uint)file_mode & (FM_MODIFY|FM_APPEND) )
+    {
+	case FM_MODIFY | FM_APPEND : return "a+b";
+	case FM_MODIFY             : return "w+b";
+	case             FM_APPEND : return "ab";
+	default                    : return "wb";
+    }
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			struct FileAttrib_t		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+FileAttrib_t * ClearFileAttrib
+(
+    FileAttrib_t	* dest		// NULL or destination attribute
+)
+{
+    if (dest)
+	memset(dest,0,sizeof(*dest));
+    return dest;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+FileAttrib_t * TouchFileAttrib
+(
+    FileAttrib_t	* dest		// valid destination attribute
+)
+{
+    DASSERT(dest);
+    dest->mtime = dest->ctime = dest->atime = dest->itime = time(0);
+    return dest;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+FileAttrib_t * SetFileAttrib
+(
+    FileAttrib_t	* dest,		// valid destination attribute
+    const FileAttrib_t	* src_fa,	// NULL or source attribute
+    const struct stat	* src_stat	// NULL or source attribute
+					// only used if 'src_fa==NULL'
+)
+{
+    DASSERT(dest);
+
+    if (src_fa)
+	memcpy(dest,src_fa,sizeof(*dest));
+    else if (src_stat)
+    {
+	memset(dest,0,sizeof(*dest));
+	if ( S_ISREG(src_stat->st_mode) )
+	{
+	    dest->mtime = src_stat->st_mtime;
+	    dest->ctime = src_stat->st_ctime;
+	    dest->itime = dest->mtime > dest->ctime ? dest->mtime : dest->ctime;
+	    dest->atime = src_stat->st_atime;
+	    dest->size  = src_stat->st_size;
+	}
+	dest->mode = src_stat->st_mode;
+    }
+    return dest;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+FileAttrib_t * MaxFileAttrib
+(
+    FileAttrib_t	* dest,		// valid source and destination attribute
+    const FileAttrib_t	* src_fa,	// NULL or second source attribute
+    const struct stat	* src_stat	// NULL or third source attribute
+)
+{
+    DASSERT(dest);
+
+    if (src_fa)
+    {
+	if ( dest->mtime < src_fa->mtime ) dest->mtime = src_fa->mtime;
+	if ( dest->ctime < src_fa->ctime ) dest->ctime = src_fa->ctime;
+	if ( dest->atime < src_fa->atime ) dest->atime = src_fa->atime;
+	if ( dest->itime < src_fa->itime ) dest->itime = src_fa->itime;
+
+	if ( dest->size  < src_fa->size )  dest->size  = src_fa->size;
+
+	dest->mode = src_fa->mode;
+    }
+
+    if (src_stat)
+    {
+	if ( S_ISREG(src_stat->st_mode) )
+	{
+	    if ( dest->mtime < src_stat->st_mtime ) dest->mtime = src_stat->st_mtime;
+	    if ( dest->ctime < src_stat->st_ctime ) dest->ctime = src_stat->st_ctime;
+	    if ( dest->atime < src_stat->st_atime ) dest->atime = src_stat->st_atime;
+
+	    if ( dest->itime < dest->mtime ) dest->itime = dest->mtime;
+	    if ( dest->itime < dest->ctime ) dest->itime = dest->ctime;
+
+	    if ( dest->size  < src_stat->st_size ) dest->size  = src_stat->st_size;
+	}
+	dest->mode = src_stat->st_mode;
+    }
+
+    return dest;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+FileAttrib_t * NormalizeFileAttrib
+(
+    FileAttrib_t	* fa		// valid attribute
+)
+{
+    DASSERT(fa);
+
+    if ( fa->size < 0 )
+	fa->size = 0;
+
+    time_t mtime = fa->mtime;
+    if (!mtime)
+    {
+	mtime = fa->itime;
+	if (!mtime)
+	{
+	    mtime = fa->ctime;
+	    if (!mtime)
+		mtime = fa->atime;
+	}
+    }
+    fa->mtime = mtime;
+
+    if (!fa->itime)
+	fa->itime = fa->ctime > mtime ? fa->ctime : mtime;
+
+    if (!fa->ctime)
+	fa->ctime = fa->itime > mtime ? fa->itime : mtime;
+
+    if (!fa->atime)
+	fa->atime = fa->itime > fa->ctime ? fa->itime : fa->ctime;
+
+    return fa;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////		 simple UNIX+TCP socket connect		///////////////
+///////////////////////////////////////////////////////////////////////////////
+// not stored in dclib-network.c to allow static linking!
+
+int ConnectUnixTCP
+(
+    ccp		fname,		// unix socket filename
+    bool	silent		// true: suppress error messages
+)
+{
+    DASSERT(fname);
+
+
+    //--- check file name
+
+    struct sockaddr_un sa;
+    const uint flen = fname ? strlen(fname)+1 : 0;
+    if ( flen > sizeof(sa.sun_path) )
+    {
+	if (!silent)
+	    ERROR0(ERR_CANT_CONNECT,
+			"Path name to long for UNIX/STREAM socket: %s\n",fname);
+	return -1;
+    }
+
+    memset(&sa,0,sizeof(sa));
+    memcpy(sa.sun_path,fname,flen);
+    sa.sun_family = AF_UNIX;
+
+
+    //--- create socket
+
+    const int sock = socket(AF_UNIX,SOCK_STREAM,0);
+    if ( sock == -1 )
+    {
+	if (!silent)
+	    ERROR1(ERR_CANT_CONNECT,
+			"Can't create UNIX/STREAM socket: %s\n",fname);
+	return -1;
+    }
+
+
+    //--- connect
+
+    if (connect(sock,(struct sockaddr *)&sa,sizeof(sa)))
+    {
+	if (!silent)
+	    ERROR1(ERR_CANT_CONNECT,
+			"Can't connect to UNIX/STREAM socket: %s\n",fname);
+	close(sock);
+	return -1;
+    }
+
+    return sock;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int (*ConnectTCP_Hook)
+(
+    // if set: ConnectNumericTCP() uses ConnectTCP()
+
+    ccp		addr,		// TCP address: ['tcp':] IPv4 [:PORT]
+    int		default_port,	// NULL or default port, if not found in 'addr'
+    bool	silent		// true: suppress error messages
+) = 0;
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanNumericIP4
+(
+    // returns next unread character or NULL on error
+
+    ccp		addr,		// address to scan
+    u32		*r_ipv4,	// not NULL: store result here (local endian)
+    u32		*r_port,	// not NULL: scan port too (local endian)
+    uint	default_port	// return this if no port found
+)
+{
+    if (!addr)
+    {
+     abort:
+	if (r_ipv4)
+	    *r_ipv4 = 0;
+	if (r_port)
+	    *r_port = 0;
+	return 0;
+    }
+
+    u32 num[4] = {0};
+    uint i;
+    ccp ptr = addr;
+    for ( i = 0; i < 4; )
+    {
+	char *end;
+	uint temp = str2ul(ptr,&end,10);
+	if ( !end || end == ptr )
+	    break;
+	num[i++] = temp;
+	ptr = addr = end;
+	if ( *ptr != '.' )
+	    break;
+	ptr++;
+    }
+
+    uint ip4;
+    switch (i)
+    {
+	case 1:
+	    ip4 = num[0];
+	    break;
+
+	case 2:
+	    ip4 = num[0] << 24 | num[1];
+	    break;
+
+	case 3:
+	    ip4 = num[0] << 24 | num[1] << 16 | num[2];
+	    break;
+
+	case 4:
+	    ip4 = num[0] << 24 | num[1] << 16 | num[2] << 8 | num[3];
+	    break;
+
+	default:
+	    goto abort;
+    }
+    if (r_ipv4)
+	*r_ipv4 = ip4;
+
+    if (r_port)
+    {
+	if ( *addr == ':' )
+	{
+	    char *end;
+	    uint num = str2ul(addr+1,&end,10);
+	    if ( end && end > addr+1 && num < 0x10000 )
+	    {
+		addr = end;
+		default_port = num;
+	    }
+	}
+	*r_port = default_port;
+    }
+
+    return (char*)addr;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+mem_t ScanNumericIP4Mem
+(
+    // returns unread character or NullMem on error
+
+    mem_t	addr,		// address to scan
+    u32		*r_ipv4,	// not NULL: store result here (local endian)
+    u32		*r_port,	// not NULL: scan port too (local endian)
+    uint	default_port	// return this if no port found
+)
+{
+    if ( !addr.ptr || !addr.len )
+    {
+     abort:
+	if (r_ipv4)
+	    *r_ipv4 = 0;
+	if (r_port)
+	    *r_port = 0;
+	return NullMem;
+    }
+
+    u32 num[4] = {0};
+    uint i;
+    ccp ptr = addr.ptr;
+    ccp end = ptr + addr.len;
+
+    for ( i = 0; i < 4; )
+    {
+	uint temp;
+	ccp next = ScanNumber(&temp,ptr,end,10,10);
+	if ( !next || next == ptr )
+	    break;
+	num[i++] = temp;
+	addr = BehindMem(addr,next);
+	ptr = addr.ptr;
+	if ( *ptr != '.' )
+	    break;
+	ptr++;
+    }
+
+    uint ip4;
+    switch (i)
+    {
+	case 1:
+	    ip4 = num[0];
+	    break;
+
+	case 2:
+	    ip4 = num[0] << 24 | num[1];
+	    break;
+
+	case 3:
+	    ip4 = num[0] << 24 | num[1] << 16 | num[2];
+	    break;
+
+	case 4:
+	    ip4 = num[0] << 24 | num[1] << 16 | num[2] << 8 | num[3];
+	    break;
+
+	default:
+	    goto abort;
+    }
+    if (r_ipv4)
+	*r_ipv4 = ip4;
+
+    if (r_port)
+    {
+	ptr = addr.ptr;
+	if ( ptr < end && *ptr == ':' )
+	{
+	    ptr++;
+	    uint num;
+	    ccp next = ScanNumber(&num,ptr,end,10,10);
+	    if ( next > ptr && num < 0x10000 )
+	    {
+		addr = BehindMem(addr,next);
+		default_port = num;
+	    }
+	}
+	*r_port = default_port;
+    }
+
+    return addr;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Returns a NETWORK MASK "/a.b.c.d" or as CIDR number "/num" between 0 and 32.
+// An optional slash '/' at the beginning is skipped.
+// Returns modified 'source' if a MASK or CDIR is detected.
+// If no one is detected, source is unmodified and returned mask = ~0.
+
+mem_t ScanNetworkMaskMem ( u32 *mask, mem_t source )
+{
+    u32 m = M1(m);
+    if ( source.ptr && source.len )
+    {
+	ccp ptr = source.ptr;
+	ccp end = ptr + source.len;
+	if ( *ptr == '/' )
+	    ptr++;
+
+	uint num;
+	ccp next = ScanNumber(&num,ptr,end,10,10);
+	if ( next > ptr )
+	{
+	    if ( next < end && *next == '.' )
+	    {
+		// is a network mask
+		source = ScanNumericIP4Mem(BehindMem(source,ptr),&m,0,0);
+	    }
+	    else if ( num <= 32 )
+	    {
+		m = num ? ~(( 1 << (32-num) ) - 1) : 0;
+		source = BehindMem(source,next);
+	    }
+	}
+    }
+
+    if (mask)
+	*mask = m;
+    return source;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ConnectNumericTCP
+(
+    // like ConnectTCP(), but without name resolution (only numeric ip+port)
+
+    ccp		addr,		// TCP address: ['tcp':] IPv4 [:PORT]
+    int		default_port,	// NULL or default port, if not found in 'addr'
+    bool	silent		// true: suppress error messages
+)
+{
+    if (ConnectTCP_Hook)
+	return ConnectTCP_Hook(addr,default_port,silent);
+
+    ccp unix_path = CheckUnixSocketPath(addr,0);
+    if (unix_path)
+	return ConnectUnixTCP(unix_path,silent);
+
+    if ( !strncasecmp(addr,"tcp:",4) )
+	addr += 4;
+
+    u32 ip4, port;
+    ccp end = ScanNumericIP4(addr,&ip4,&port,default_port);
+    if (!end)
+    {
+	if (!silent)
+	    ERROR1(ERR_CANT_CONNECT,
+			"Invalid IPv4 address: %s\n",addr);
+	return -1;
+    }
+
+    int sock = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
+    if ( sock == -1 )
+    {
+	if (!silent)
+	    ERROR1(ERR_CANT_CONNECT,
+			"Can't create socket: %s\n",addr);
+	return -1;
+    }
+
+    struct sockaddr_in sa;
+    sa.sin_family = AF_INET;
+    sa.sin_addr.s_addr = htonl(ip4);
+    sa.sin_port = htons(port);
+
+    if (connect(sock,(struct sockaddr *)&sa,sizeof(sa)))
+    {
+	if (!silent)
+	    ERROR1(ERR_CANT_CONNECT,
+			"Can't connect to %s\n",PrintIP4(0,0,ip4,port) );
+	close(sock);
+	return -1;
+    }
+
+    return sock;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			struct File_t			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void InitializeFile
+(
+   File_t		* f		// file structure
+)
+{
+    DASSERT(f);
+    memset(f,0,sizeof(*f));
+    f->fname = EmptyString;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError ResetFile
+(
+   File_t		* f,		// file structure
+   uint			set_time	// 0: don't set
+					// 1: set time before closing using 'fatt'
+					// 2: set current time before closing
+)
+{
+    DASSERT(f);
+    const enumError err = CloseFile(f,set_time);
+    FreeString(f->fname);
+    if (f->data_alloced)
+	FREE(f->data);
+    InitializeFile(f);
+    return err;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError CloseFile
+(
+   File_t		* f,		// file structure
+   uint			set_time	// 0: don't set
+					// 1: set time before closing using 'fatt'
+					// 2: set current time before closing
+)
+{
+    DASSERT(f);
+    TRACE("CloseFile(%p,%d) fname=%s\n",f,set_time,f->fname);
+
+    if (f->f)
+    {
+	if (!f->is_stdio)
+	{
+	    if ( fclose(f->f) && f->max_err <= ERR_WARNING )
+		f->max_err = ERROR1(ERR_WRITE_FAILED,
+				    "Error while closing file: %s\n",f->fname);
+
+	    if (!f->is_socket)
+	    {
+		if ( f->fmode & FM_TEMP )
+		{
+		    TRACE("UNLINK TEMP %s\n",f->fname);
+		    unlink(f->fname);
+		}
+		else if ( f->is_writing )
+		{
+		    if ( f->max_err > ERR_WARNING )
+		    {
+			TRACE("UNLINK %s\n",f->fname);
+			unlink(f->fname);
+		    }
+		    else if ( set_time == 1 && f->fatt.mtime )
+		    {
+			struct utimbuf ubuf;
+			ubuf.actime  = f->fatt.atime
+				     ? f->fatt.atime : f->fatt.mtime;
+			ubuf.modtime = f->fatt.mtime;
+			utime(f->fname,&ubuf);
+		    }
+		    else if ( set_time > 1 || f->fmode & FM_TOUCH )
+		    {
+			utime(f->fname,0);
+		    }
+		}
+	    }
+	}
+	f->f = 0;
+    }
+
+    return f->max_err;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static bool is_seekable
+(
+    File_t		* F		// file structure
+)
+{
+    const mode_t mode = F->st.st_mode;
+    F->is_seekable = ( S_ISREG(mode) || S_ISBLK(mode) || S_ISCHR(mode) )
+		&& F->st.st_size
+		&& lseek(fileno(F->f),0,SEEK_SET) != (off_t)-1;
+    return F->is_seekable;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError OpenFile
+(
+    File_t		* f,		// file structure
+    bool		initialize,	// true: initialize 'f'
+    ccp			fname,		// file to open
+    FileMode_t		file_mode,	// open modes
+    off_t		limit,		// >0: don't open, if file size > limit
+    ccp			limit_message	// NULL or a with LF terminated text.
+					//   It is printed after the message.
+)
+{
+    DASSERT(f);
+    DASSERT(fname);
+
+    if (initialize)
+	InitializeFile(f);
+    else
+	ResetFile(f,false);
+    f->fmode = file_mode & FM_M_OPEN;
+
+    TRACE("OpenFile(%p,%d,,%s,%llu) [%s] %s\n",
+		f, initialize, GetFileModeStatus(0,0,file_mode,0), (u64)limit,
+		GetFileModeStatus(0,0,f->fmode,1), fname );
+
+
+    //--- test for TCP
+
+    if ( file_mode & FM_TCP && !strncasecmp(fname,"tcp:",4) )
+    {
+	const int fd = ConnectNumericTCP(fname,0,(f->fmode&FM_SILENT)!=0);
+	if ( fd == -1 )
+	    return f->max_err = ERR_CANT_OPEN;
+
+	f->f = fdopen(fd,"rw");
+	f->is_socket = f->is_reading = f->is_writing = true;
+	return f->max_err;
+    }
+
+
+    //--- test for stdin
+
+    if ( *fname == '-' && !fname[1] )
+    {
+	f->fname = MinusString;
+	if ( f->fmode & FM_STDIO )
+	{
+	    f->is_stdio = true;
+	    f->f = stdin;
+	    fstat(fileno(stdin),&f->st);
+	    is_seekable(f);
+	    return ERR_OK;
+	}
+    }
+
+    f->fname = STRDUP(fname);
+
+
+    //--- test 'unix:' prefix
+
+    bool have_unix = file_mode & FM_TCP && !strncasecmp(fname,"unix:",5);
+    if (have_unix)
+	fname += 5;
+
+
+    //--- does file exist?
+
+    for(;;)
+    {
+	if (!stat(fname,&f->st))
+	    break;
+
+	if (have_unix)
+	{
+	    have_unix = false;
+	    fname -= 5;
+	    continue;
+	}
+
+     not_found:
+	memset(&f->st,0,sizeof(f->st));
+	if ( f->fmode & FM_IGNORE )
+	    return f->max_err = ERR_NOT_EXISTS;
+
+	if ( !(f->fmode & FM_SILENT) )
+	    ERROR1(ERR_CANT_OPEN,"Can't find file: %s\n",fname);
+	return f->max_err = ERR_CANT_OPEN;
+    }
+
+
+    //--- UNIX socket -> try STREAM connect
+
+    if (S_ISSOCK(f->st.st_mode))
+    {
+	f->fmode &= ~(FM_REMOVE|FM_TEMP);
+
+	const int fd = ConnectUnixTCP(fname,(f->fmode&FM_SILENT)!=0);
+	if ( fd == -1 )
+	    return f->max_err = ERR_CANT_OPEN;
+
+	f->f = fdopen(fd,"rw");
+	f->is_socket = f->is_reading = f->is_writing = true;
+	return f->max_err;
+    }
+
+    if (have_unix)
+	goto not_found;
+
+
+    //--- check size limit
+
+    SetFileAttrib(&f->fatt,0,&f->st);
+    if ( limit && f->st.st_size > limit )
+    {
+	char sbuf[12], lbuf[12];
+	PrintSize1024(sbuf,sizeof(sbuf),(u64)f->st.st_size,false);
+	PrintSize1024(lbuf,sizeof(lbuf),(u64)limit,false);
+
+	// be tolerant, if both values produce same text
+	if (strcmp(sbuf,lbuf))
+	{
+	    if ( !(f->fmode & FM_SILENT) )
+		ERROR0(ERR_CANT_OPEN,
+			"File too large (size=%s, limit=%s): %s\n%s",
+			sbuf, lbuf, fname,
+			limit_message ? limit_message : "" );
+	    return f->max_err = ERR_CANT_OPEN;
+	}
+    }
+
+
+    //--- open file
+
+    ccp omode = GetFileOpenMode(false,f->fmode);
+    f->f = fopen(fname,omode);
+    TRACE("OpenFile(%s,%s) : [%s], %p\n",
+		fname, omode, GetFileModeStatus(0,0,f->fmode,1), f->f );
+
+    if (!f->f)
+    {
+	if ( !(f->fmode & FM_SILENT) )
+	    ERROR1(ERR_CANT_OPEN,"Can't open file: %s\n",fname);
+	return f->max_err = ERR_CANT_OPEN;
+    }
+
+    f->is_reading = true;
+    if ( f->fmode & FM_MODIFY )
+	f->is_writing = true;
+
+    is_seekable(f);
+    return f->max_err;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError CheckCreateFile
+(
+    // returns:
+    //   ERR_DIFFER:		[FM_STDIO] source is "-" => 'st' is zeroed
+    //	 ERR_WARNING:		[FM_DEV,FM_SOCK,FM_SPC] not a regular file
+    //   ERR_WRONG_FILE_TYPE:	file exists, but is not a regular file
+    //   ERR_ALREADY_EXISTS:	file already exists
+    //   ERR_INVALID_VERSION:	already exists, but FM_NUMBER set => no msg printed
+    //   ERR_CANT_CREATE:	FM_UPDATE is set, but file don't exist
+    //   ERR_OK:		file not exist or can be overwritten
+
+    ccp			fname,		// filename to open
+    FileMode_t		file_mode,	// open modes
+    struct stat		*st		// not NULL: store file status here
+)
+{
+    DASSERT(fname);
+
+    if ( file_mode & FM_STDIO && fname[0] == '-' && !fname[1] )
+    {
+	if (st)
+	    memset(st,0,sizeof(*st));
+	return ERR_DIFFER;
+    }
+
+    struct stat local_st;
+    if (!st)
+	st = &local_st;
+
+    if (!stat(fname,st))
+    {
+	if ( S_ISBLK(st->st_mode) || S_ISCHR(st->st_mode) )
+	{
+	    if ( file_mode & FM_DEV )
+		return ERR_WARNING;
+
+	    if ( !(file_mode & FM_SILENT) )
+		ERROR0( ERR_ALREADY_EXISTS,
+			"Can't write to %s device: %s\n",
+			S_ISBLK(st->st_mode) ? "block" : "character", fname );
+	    return ERR_WRONG_FILE_TYPE;
+	}
+
+	if ( S_ISSOCK(st->st_mode) )
+	{
+	    if ( file_mode & FM_SOCK )
+		return ERR_WARNING;
+
+	    if ( !(file_mode & FM_SILENT) )
+		ERROR0( ERR_ALREADY_EXISTS,
+			"Can't write to UNIX socket: %s\n", fname );
+	    return ERR_WRONG_FILE_TYPE;
+	}
+
+	if (!S_ISREG(st->st_mode))
+	{
+	    if ( file_mode & FM_SPC )
+		return ERR_WARNING;
+
+	    if ( !(file_mode & FM_SILENT) )
+		ERROR0( ERR_WRONG_FILE_TYPE,
+		    "Not a plain file: %s\n", fname );
+	    return ERR_WRONG_FILE_TYPE;
+	}
+
+	if (!( file_mode & (FM_OVERWRITE|FM_REMOVE|FM_UPDATE|FM_APPEND) ))
+	{
+	    if ( file_mode & FM_NUMBER )
+		return ERR_INVALID_VERSION;
+
+	    if ( !(file_mode & FM_SILENT) )
+		ERROR0( ERR_ALREADY_EXISTS,
+		    "File already exists: %s\n", fname );
+	    return ERR_ALREADY_EXISTS;
+	}
+    }
+    else
+    {
+	memset(st,0,sizeof(*st));
+	if ( file_mode & FM_UPDATE )
+	{
+	    if ( !(file_mode & FM_SILENT) )
+		ERROR0(ERR_CANT_CREATE,
+		    "Try to update non existing file: %s\n", fname );
+	    return ERR_CANT_CREATE;
+	}
+    }
+
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError CreateFile
+(
+    File_t		* f,		// file structure
+    bool		initialize,	// true: initialize 'f'
+    ccp			fname,		// file to open
+    FileMode_t		file_mode	// open modes
+)
+{
+    DASSERT(f);
+    DASSERT(fname);
+
+    if (initialize)
+	InitializeFile(f);
+    else
+	ResetFile(f,false);
+    f->fmode = file_mode & FM_M_CREATE;
+
+    noPRINT("CreateFile(%p,%d,,%s) [%s] %s\n",
+		f, initialize, GetFileModeStatus(0,0,file_mode,0),
+		GetFileModeStatus(0,0,f->fmode,1), fname );
+
+
+    //--- test for stdout
+
+    if ( *fname == '-' && !fname[1] )
+    {
+	f->fname = MinusString;
+	if ( f->fmode & FM_STDIO )
+	{
+	    f->is_stdio = true;
+	    f->f = stdout;
+	    fstat(fileno(stdout),&f->st);
+	    is_seekable(f);
+	    return ERR_OK;
+	}
+    }
+
+
+    //--- mode calculations
+
+//    if ( f->fmode & FM_UPDATE )
+//	f->fmode = f->fmode & ~(FM_REMOVE|FM_MKDIR) | FM_OVERWRITE;
+
+    enumError err = CheckCreateFile(fname,f->fmode,&f->st);
+
+    char num_fname[PATH_MAX];
+    if ( err == ERR_INVALID_VERSION )
+    {
+	NumberedFilename(num_fname,sizeof(num_fname),fname,0,0,false);
+	fname = num_fname;
+	err = CheckCreateFile( fname, f->fmode & ~FM_NUMBER, &f->st );
+    }
+
+    f->fname = STRDUP(fname);
+    if ( f->fmode & (FM_MODIFY|FM_APPEND) )
+	SetFileAttrib(&f->fatt,0,&f->st);
+
+    if (err)
+    {
+	if ( err > ERR_WARNING )
+	    return err;
+
+	// is a device, socket or special file
+	err = ERR_OK;
+	f->fmode = f->fmode & ~(FM_REMOVE|FM_TEMP) | FM_OVERWRITE;
+    }
+
+    if ( f->fmode & FM_TEST )
+    {
+	// never create or remove a file in TEST mode.
+	return ERR_OK;
+    }
+
+    if (S_ISSOCK(f->st.st_mode))
+    {
+	const int fd = ConnectUnixTCP(fname,(f->fmode&FM_SILENT)!=0);
+	if ( fd == -1 )
+	    return f->max_err = ERR_CANT_OPEN;
+
+	f->f = fdopen(fd,"rw");
+	f->is_socket = f->is_reading = f->is_writing = true;
+	return ERR_OK;
+    }
+
+    if ( f->st.st_mode && f->fmode & FM_REMOVE )
+    {
+	unlink(fname);
+
+	struct stat st;
+	if (!stat(fname,&st))
+	{
+	    if ( !(f->fmode & FM_SILENT) )
+		ERROR0(ERR_REMOVE_FAILED,"Can't remove file: %s\n",fname);
+	    return f->max_err = ERR_REMOVE_FAILED;
+	}
+    }
+
+    ccp omode = GetFileOpenMode(true,f->fmode);
+    f->f = fopen(fname,omode);
+    noPRINT("CreateFile(%s,%s) : [%s], %p\n",
+		fname, omode, GetFileModeStatus(0,0,f->fmode,1), f->f );
+
+    if ( !f->f )
+    {
+	if ( f->fmode & FM_MKDIR )
+	{
+	    CreatePath(fname,false);
+	    f->f = fopen(fname,omode);
+	}
+
+	if ( !f->f )
+	{
+	    if ( !(f->fmode & FM_SILENT) )
+		ERROR1(ERR_CANT_CREATE,"Can't create file: %s\n",fname);
+	    return f->max_err = ERR_CANT_CREATE;
+	}
+    }
+
+    f->is_writing = true;
+    if ( f->fmode & FM_MODIFY)
+	f->is_reading = true;
+
+    if (!fstat(fileno(f->f),&f->st))
+    {
+	const mode_t mode = f->st.st_mode;
+	f->is_seekable = S_ISREG(mode) || S_ISBLK(mode) || S_ISCHR(mode);
+    }
+
+    return f->max_err;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError WriteFileAt
+(
+    File_t		* F,		// file to write
+    size_t		* cur_offset,	// pointer to current file offset, modified
+    size_t		offset,		// offset to write
+    const void		* data,		// data to write
+    size_t		size		// size of 'data'
+)
+{
+    DASSERT(F);
+    DASSERT(F->f);
+    DASSERT(data||!size);
+    DASSERT(cur_offset);
+
+    if (!size)
+	return ERR_OK;
+
+    if ( offset != *cur_offset )
+    {
+	if (F->is_seekable)
+	{
+	    noPRINT("FSEEK %zx -> %zx\n",*cur_offset,offset);
+	    if (fseek(F->f,offset,SEEK_SET))
+		return ERROR1(ERR_WRITE_FAILED,"Can't set file pointer: %s\n",F->fname);
+	}
+	else if ( offset < *cur_offset )
+	{
+	    noPRINT("FSEEK %zx -> %zx\n",*cur_offset,offset);
+	    return ERROR0(ERR_WRITE_FAILED,
+		"Can't set file pointer on non seekable file: %s\n",F->fname);
+	}
+	else
+	{
+	    char buf[0x8000] = {0};
+	    size_t fill_size = offset - *cur_offset;
+	    while (fill_size)
+	    {
+		const size_t write_size = fill_size < sizeof(buf) ? fill_size : sizeof(buf);
+		noPRINT("FILL/ZERO %zx/%zx\n",write_size,fill_size);
+		const size_t written = fwrite(buf,1,write_size,F->f);
+		if ( written != write_size )
+		    return ERROR1(ERR_WRITE_FAILED,"Writing %zu NULL bytes failed: %s\n",
+				write_size, F->fname );
+		fill_size -= write_size;
+	    }
+	}
+    }
+
+    noPRINT("WRITE %zx @%zx -> %zx\n",size,offset,offset+size);
+    const size_t written = fwrite(data,1,size,F->f);
+    if ( written != size )
+	return ERROR1(ERR_WRITE_FAILED,"Writing %zu bytes at offset %zu failed: %s\n",
+		size,offset,F->fname);
+
+    *cur_offset = offset + size;
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError SetFileSize
+(
+    File_t		* F,		// file to write
+    size_t		* cur_offset,	// pointer to current file offset, modified
+    size_t		size		// offset to write
+)
+{
+    DASSERT(F);
+    DASSERT(F->f);
+    DASSERT(cur_offset);
+
+    fflush(F->f);
+    if (!F->is_seekable)
+	return WriteFileAt(F,cur_offset,size,0,0);
+
+    if (ftruncate(fileno(F->f),size))
+    {
+	if ( F->max_err < ERR_WRITE_FAILED )
+	    F->max_err = ERR_WRITE_FAILED;
+	return ERROR1( ERR_WRITE_FAILED,
+			"Set file size to %llu failed: %s\n",
+			(u64)size, F->fname );
+    }
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError SkipFile
+(
+    File_t		*F,		// file to write
+    size_t		skip		// number of bytes to skip
+)
+{
+    DASSERT(F);
+    DASSERT(F->f);
+
+    if (!skip)
+	return ERR_OK;
+
+    if ( F->is_seekable && !fseek(F->f,skip,SEEK_CUR) )
+	return ERR_OK;
+
+    char buf[0x8000];
+    while ( skip > 0 )
+    {
+	size_t max = skip < sizeof(buf) ? skip : sizeof(buf);
+	size_t stat = fread(buf,1,max,F->f);
+	if (!stat)
+	{
+	    if (feof(F->f))
+		break;
+	    return ERROR1(ERR_READ_FAILED,
+				"Reading %zu to skip failed: %s\n",
+				skip, F->fname );
+	}
+	skip -= stat;
+    }
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError RegisterFileError
+(
+    File_t		* f,		// file structure
+    enumError		new_error	// new error code
+)
+{
+    DASSERT(f);
+    if ( f->max_err < new_error )
+	 f->max_err = new_error;
+    return f->max_err;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+s64 GetFileSize
+(
+    ccp			path1,		// NULL or part 1 of path
+    ccp			path2,		// NULL or part 2 of path
+    s64			not_found_val,	// return value if no regular file found
+    FileAttrib_t	* fatt,		// not NULL: store file attributes
+    bool		fatt_max	// true: store max values to 'fatt'
+)
+{
+    char pathbuf[PATH_MAX];
+    ccp path = PathCatPP(pathbuf,sizeof(pathbuf),path1,path2);
+    TRACE("GetFileSize(%s,%lld)\n",path,not_found_val);
+
+    struct stat st;
+    if ( stat(path,&st) || !S_ISREG(st.st_mode) )
+    {
+	if ( fatt && !fatt_max )
+	    memset(fatt,0,sizeof(*fatt));
+	return not_found_val;
+    }
+
+    if (fatt)
+    {
+	if (fatt_max)
+	    MaxFileAttrib(fatt,0,&st);
+	else
+	    SetFileAttrib(fatt,0,&st);
+    }
+
+    return st.st_size;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError OpenReadFile
+(
+    ccp			path1,		// NULL or part #1 of path
+    ccp			path2,		// NULL or part #2 of path
+    FileMode_t		file_mode,	// open modes
+    off_t		limit,		// >0: don't open, if file size > limit
+    ccp			limit_message,	// NULL or a with LF terminated text.
+					//   It is printed after the message.
+
+    u8			** res_data,	// store alloced data here (always NULL terminated)
+    uint		* res_size,	// not NULL: store data size
+    ccp			* res_fname,	// not NULL: store alloced filename
+    FileAttrib_t	* res_fatt	// not NULL: store file attributes
+)
+{
+    DASSERT( path1 || path2 );
+    DASSERT(res_data);
+
+    *res_data = 0;
+    if (res_size)
+	*res_size = 0;
+    if (res_fname)
+	*res_fname = 0;
+    if (res_fatt)
+	memset(res_fatt,0,sizeof(*res_fatt));
+
+    char pathbuf[PATH_MAX];
+    ccp path = PathCatPP(pathbuf,sizeof(pathbuf),path1,path2);
+    PRINT("OpenReadFile(%s,%s)\n",path,GetFileModeStatus(0,0,file_mode,0));
+
+    File_t F;
+    enumError err = OpenFile(&F,true,path,file_mode,limit,limit_message);
+    if (err)
+	return err;
+
+    uint data_size = F.st.st_size;
+    if (!F.is_seekable)
+	data_size = limit;
+    noPRINT("OpenReadFile() fsize=%u, seekable=%d\n",data_size,F.is_seekable);
+    u8 *data = MALLOC(data_size+1);
+
+    size_t read_size = fread(data,1,data_size,F.f);
+    if ( read_size && !F.is_seekable )
+    {
+	PRINT("non seekable read: %zu\n",read_size);
+	data_size = read_size;
+	data = REALLOC(data,data_size+1);
+    }
+    data[data_size] = 0; // termination for text files
+
+    if ( read_size != data_size )
+    {
+	if (!(file_mode&FM_SILENT))
+	    FILEERROR1(&F,ERR_READ_FAILED,"Read failed: %s\n",path);
+	ResetFile(&F,false);
+	FREE(data);
+	return ERR_READ_FAILED;
+    }
+
+    *res_data = data;
+    if (res_size)
+	*res_size = data_size;
+    if (res_fname)
+    {
+	*res_fname = F.fname;
+	F.fname = EmptyString;
+    }
+    if (res_fatt)
+	SetFileAttrib(res_fatt,&F.fatt,0);
+
+    ResetFile(&F,false);
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError LoadFile
+(
+    ccp			path1,		// NULL or part #1 of path
+    ccp			path2,		// NULL or part #2 of path
+    size_t		skip,		// skip num of bytes before reading
+    void		* data,		// destination buffer, size = 'size'
+    size_t		size,		// size to read
+    int			silent,		// 0: print all error messages
+					// 1: suppress file size warning
+					// 2: suppress all error messages
+    FileAttrib_t	* fatt,		// not NULL: store file attributes
+    bool		fatt_max	// true: store *max* values to 'fatt'
+)
+{
+    ASSERT(data);
+    if (!size)
+	return ERR_OK;
+
+    char pathbuf[PATH_MAX];
+    ccp path = PathCatPP(pathbuf,sizeof(pathbuf),path1,path2);
+    TRACE("LoadFile(%s,%zu,%zu,%d)\n",path,skip,size,silent);
+
+    if (fatt)
+    {
+	struct stat st;
+	if (!stat(path,&st))
+	    UseFileAttrib(fatt,0,&st,fatt_max);
+    }
+
+    FILE * f = fopen(path,"rb");
+    if (!f)
+    {
+	if (silent<2)
+	    ERROR1(ERR_CANT_OPEN,"Can't open file: %s\n",path);
+	return ERR_CANT_OPEN;
+    }
+
+    if ( skip > 0 )
+	fseek(f,skip,SEEK_SET);
+
+    size_t read_stat = fread(data,1,size,f);
+    fclose(f);
+
+    if ( read_stat == size )
+	return ERR_OK;
+
+    enumError err = ERR_READ_FAILED;
+    if ( silent == 1 && size > 0 )
+	err = ERR_WARNING;
+    else if ( silent < 2 )
+	ERROR1(ERR_READ_FAILED,"Can't read file: %s\n",path);
+
+    noPRINT("D=%p, s=%zu/%zu: %s\n",data,read_stat,size,path);
+    if ( read_stat >= 0 && read_stat < size )
+	memset((char*)data+read_stat,0,size-read_stat);
+
+    return err;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError LoadFileAlloc
+(
+    ccp			path1,		// NULL or part #1 of path
+    ccp			path2,		// NULL or part #2 of path
+    size_t		skip,		// skip num of bytes before reading
+    u8			** res_data,	// result: free existing data, store ptr to alloc data
+					// always one more byte is alloced and set to NULL
+    size_t		*  res_size,	// result: size of 'res_data'
+    size_t		max_size,	// >0: a file size limit
+    int			silent,		// 0: print all error messages
+					// 1: suppress file size warning
+					// 2: suppress all error messages
+    FileAttrib_t	* fatt,		// not NULL: store file attributes
+    bool		fatt_max	// true: store max values to 'fatt'
+)
+{
+    DASSERT(res_data);
+    DASSERT(res_size);
+
+    //--- clear return data
+
+    if (res_data)
+	*res_data = 0;
+
+    if (res_size)
+	*res_size = 0;
+
+    if ( fatt && !fatt_max )
+	memset(fatt,0,sizeof(*fatt));
+
+
+    //--- get file size
+
+    char pathbuf[PATH_MAX];
+    ccp path = PathCatPP(pathbuf,sizeof(pathbuf),path1,path2);
+
+    const s64 size = GetFileSize(path,0,-1,0,0);
+    if ( size == -1 )
+    {
+	if ( silent < 2 )
+	    ERROR0(ERR_SYNTAX,"File not found: %s\n",path);
+	return ERR_SYNTAX;
+    }
+
+    if ( max_size && size > max_size )
+    {
+	if ( silent < 2 )
+	    ERROR0(ERR_INVALID_FILE,"File too large: %s\n",path);
+	return ERR_INVALID_FILE;
+    }
+
+    u8 *data = MALLOC(size+1);
+    enumError err = LoadFile(path,0,skip,data,size,silent,fatt,fatt_max);
+    if (err)
+    {
+	FREE(data);
+	return err;
+    }
+
+    if (res_data)
+    {
+	data[size] = 0;
+	*res_data = data;
+    }
+    else
+	FREE(data);
+
+    if (res_size)
+	*res_size = size;
+
+    return err;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError SaveFile
+(
+    ccp			path1,		// NULL or part #1 of path
+    ccp			path2,		// NULL or part #2 of path
+    FileMode_t		file_mode,	// open modes
+    const void		* data,		// data to write
+    uint		data_size,	// size of 'data'
+    FileAttrib_t	* fatt		// not NULL: set timestamps using this attrib
+)
+{
+    DASSERT(data);
+
+    File_t F;
+    enumError err = OpenWriteFile(&F,true,path1,path2,file_mode,data,data_size);
+    if ( err == ERR_OK )
+    {
+	if (fatt)
+	    memcpy(&F.fatt,fatt,sizeof(F.fatt));
+	err = ResetFile(&F,true);
+    }
+    return err;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError OpenWriteFile
+(
+    File_t		* f,		// file structure
+    bool		initialize,	// true: initialize 'f'
+    ccp			path1,		// NULL or part #1 of path
+    ccp			path2,		// NULL or part #2 of path
+    FileMode_t		file_mode,	// open modes
+    const void		* data,		// data to write
+    uint		data_size	// size of 'data'
+)
+{
+    DASSERT(f);
+    DASSERT(data);
+
+    char pathbuf[PATH_MAX];
+    ccp path = PathCatPP(pathbuf,sizeof(pathbuf),path1,path2);
+    TRACE("SaveFile(%s) %s\n",GetFileModeStatus(0,0,file_mode,0),path);
+
+    enumError err = CreateFile(f,true,path,file_mode);
+    if ( err || !f->f )
+    {
+	ResetFile(f,0);
+	return err;
+    }
+
+    const uint written = fwrite(data,1,data_size,f->f);
+    if ( written != data_size )
+    {
+	ERROR1(ERR_WRITE_FAILED,"Write to file failed: %s\n",path);
+	ResetFile(f,0);
+	return ERR_WRITE_FAILED;
+    }
+
+    return ERR_OK;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static int CompareInt ( const int * a, const int *b )
+{
+    DASSERT( a && b );
+    return *a < *b ? -1 : *a > *b;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint CloseAllExcept
+(
+    int		*list,		// exception list of unordered FD, max contain -1
+    uint	n_list,		// number of elements in 'list'
+    int		min,		// close all until and including this fd
+    int		add		// if a FD was found, incremet 'min' to 'fd+add'
+)
+{
+    //--- use a private copy of the except list
+
+    enum { LOCAL_LIST_SIZE = 1000 };
+    int local_list[LOCAL_LIST_SIZE];
+    int *except_list = n_list < LOCAL_LIST_SIZE
+			? local_list : MALLOC((n_list+1)*sizeof(*except_list));
+
+    int *ptr = except_list;
+    while ( n_list-- > 0 )
+    {
+	const int fd = *list++;
+	if ( fd != -1 )
+	    *ptr++ = fd;
+    }
+    *ptr = -1;
+
+    //--- ... and sort it
+
+    n_list = ptr - except_list;
+    if ( n_list > 1 )
+	qsort(except_list,n_list,sizeof(*except_list),(qsort_func)CompareInt);
+
+
+    //--- adjust 'min' and 'add'
+
+    if ( add <= 0 )
+	add = 1;
+    const int temp = ( n_list ? except_list[n_list-1] : 0 ) + add;
+    if ( min < temp )
+	min = temp;
+
+
+    //--- close files
+
+    ptr = except_list;
+    int *end = ptr + n_list;
+    int i, count = 0;
+    for ( i = 0; i <= min; i++ )
+    {
+	while ( ptr < end && *ptr < i )
+	    ptr++;
+	if ( i != *ptr && !close(i) )
+	{
+	    count++;
+	    const int temp = i + add;
+	    if ( min < temp )
+		min = temp;
+	    //printf("closed: %d/%d\n",i,min);
+	}
+    }
+
+    if ( except_list != local_list )
+	FREE(local_list);
+    return count;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////		CopyFile*(),  TransferFile()		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+#undef LOGPRINT
+//#define LOGPRINT PRINT
+#define LOGPRINT noPRINT
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool IsSameFile ( ccp path1, ccp path2 )
+{
+    if (!strcmp(path1,path2))
+	return true;
+
+    struct stat st1, st2;
+    if ( stat(path1,&st1) || stat(path2,&st2) )
+	return false;
+
+    return st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError CopyFileHelper
+(
+    ccp		src,		// source path
+    ccp		dest,		// destination path
+    int		open_flags,	// flags for open()
+    mode_t	open_mode,	// mode for open()
+    uint 	temp_and_move	// >0: ignore open_flags,
+				//     create temp, then move temp to dest
+)
+{
+    LOGPRINT("CopyFileHelper(%x,%x,%d) %s -> %s\n",
+		open_flags, open_mode, temp_and_move>0, src, dest );
+
+    int fd_dest, fd_src;
+    char buf[16*1024], temp[PATH_MAX];
+
+    if ( !dest || !src || !*dest || !*src )
+	return ERR_MISSING_PARAM;
+
+    if (IsSameFile(src,dest))
+	return ERR_OK;
+
+    fd_src = open(src,O_RDONLY);
+    if ( fd_src < 0 )
+	return ERR_CANT_OPEN;
+
+    if (temp_and_move)
+    {
+	StringCat2S(temp,sizeof(temp),dest,"XXXXXX");
+	fd_dest = mkstemp(temp);
+	LOGPRINT("CopyFileHelper(TEMP) %s -> %d\n",temp,fd_dest);
+    }
+    else
+	fd_dest = open(dest,open_mode,open_mode);
+    if ( fd_dest < 0 )
+	goto error;
+
+    ssize_t nread;
+    while ( nread = read(fd_src,buf,sizeof(buf)), nread > 0 )
+    {
+	char *ptr = buf;
+	do
+	{
+	    ssize_t nwritten = write(fd_dest,ptr,nread);
+
+	    if ( nwritten >= 0 )
+	    {
+		nread -= nwritten;
+		ptr   += nwritten;
+	    }
+	    else if ( errno != EINTR )
+		goto error;
+	}
+	while (nread > 0);
+    }
+
+    if ( nread == 0 )
+    {
+	if ( close(fd_dest) < 0 )
+	{
+	    fd_dest = -1;
+	    goto error;
+	}
+	if (temp_and_move)
+	{
+	    chmod(temp,open_mode);
+	    if (rename(temp,dest))
+	    {
+		unlink(temp);
+		goto error;
+	    }
+	}
+	close(fd_src);
+	return ERR_OK;
+    }
+
+  error:;
+    int saved_errno = errno;
+
+    close(fd_src);
+    if ( fd_dest >= 0 )
+    {
+	close(fd_dest);
+	if (temp_and_move)
+	    unlink(temp);
+    }
+
+    errno = saved_errno;
+    return ERR_WRITE_FAILED;
+}
+
+//-----------------------------------------------------------------------------
+
+enumError CopyFile
+(
+    ccp		src,		// source path
+    ccp		dest,		// destination path
+    mode_t	open_mode	// mode for open()
+)
+{
+    return CopyFileHelper(src,dest,O_WRONLY|O_TRUNC|O_EXCL,open_mode,false);
+}
+
+//-----------------------------------------------------------------------------
+
+enumError CopyFileCreate
+(
+    ccp		src,		// source path
+    ccp		dest,		// destination path
+    mode_t	open_mode	// mode for open()
+)
+{
+    return CopyFileHelper(src,dest,O_WRONLY|O_CREAT|O_EXCL,open_mode,false);
+}
+
+//-----------------------------------------------------------------------------
+
+enumError CopyFileTemp
+(
+    ccp		src,		// source path
+    ccp		dest,		// destination path
+    mode_t	open_mode	// mode for open()
+)
+{
+    return CopyFileHelper(src,dest,0,open_mode,true);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError TransferFile
+(
+    ccp			src,		// source path
+    ccp			dest,		// destination path
+    TransferMode_t	tfer_mode,	// transfer mode
+    mode_t		open_mode	// mode for CopyFile*() -> open()
+)
+{
+    if ( !dest || !src || !*dest || !*src )
+	return ERR_MISSING_PARAM;
+
+    if (IsSameFile(src,dest))
+	return ERR_OK;
+
+    if ( tfer_mode & TFMD_J_MOVE1 )
+    {
+	LOGPRINT("TransferFile(MOVE1) %s -> %s\n",src,dest);
+	struct stat st;
+	if ( !stat(src,&st) && st.st_nlink == 1 && !rename(src,dest) )
+	    return true;
+    }
+    else if ( tfer_mode & TFMD_J_MOVE )
+    {
+	LOGPRINT("TransferFile(MOVE) %s -> %s\n",src,dest);
+	if (!rename(src,dest))
+	    return true;
+    }
+
+    if ( tfer_mode & TFMD_J_LINK )
+    {
+	LOGPRINT("TransferFile(RM_DEST) %s\n",dest);
+	if ( tfer_mode & TFMD_J_RM_DEST )
+	    unlink(dest);
+
+	LOGPRINT("TransferFile(LINK) %s -> %s\n",src,dest);
+	if (!link(src,dest))
+	    return true;
+    }
+
+    if ( tfer_mode & TFMD_J_COPY )
+    {
+	LOGPRINT("TransferFile(COPY) %s -> %s\n",src,dest);
+	enumError err = tfer_mode & TFMD_J_RM_DEST
+			? CopyFileTemp(src,dest,open_mode)
+			: CopyFile(src,dest,open_mode);
+	if ( err == ERR_OK )
+	{
+	    if ( tfer_mode & TFMD_J_RM_SRC )
+	    {
+		PRINT("TransferFile(RM_SRC) %s",src);
+		unlink(src);
+	    }
+	    return true;
+	}
+    }
+
+    return ERR_ERROR;
+}
+
+#undef LOGPRINT
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			struct MemFile_t		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+bool IsValidMemFile ( MemFile_t *mf )
+{
+    return mf
+	&& ( mf->data || !mf->size )
+	&& mf->size >= mf->fend
+	&& mf->fend >= mf->fpos;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void DumpMemFile
+(
+    FILE	*f,		// valid output stream
+    int		indent,		// indent of output
+    MemFile_t	*mf		// valid MemFile_t data
+)
+{
+    DASSERT(f);
+    DASSERT(mf);
+
+    indent = NormalizeIndent(indent);
+    fprintf(f,"%*sfpos=0x%x/0x%x, size=0x%x/0x%x, zero=%d, valid=%d\n",
+	indent,"",
+	mf->fpos, mf->fend, mf->size, mf->max_size,
+	mf->zero_extend, IsValidMemFile(mf) );
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool AssertMemFile
+(
+    MemFile_t	*mf		// valid MemFile_t data
+)
+{
+    if (IsValidMemFile(mf))
+	return true;
+
+    if (mf)
+	DumpMemFile(stderr,0,mf);
+    return false;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+u8 * GetDataMemFile
+(
+    // return NULL on err or a pointer to the data posisiton.
+
+    MemFile_t	*mf,		// valid MemFile_t data
+    uint	fpos,		// fpos to read from
+    uint	size		// needed data size
+)
+{
+    DASSERT(mf);
+    uint end = fpos + size;
+    if ( end < fpos || end < size )
+	return 0; // integer overflow
+
+    if ( end > mf->max_size )
+	return 0; // too large
+
+    if ( end > mf->size )
+    {
+	// grow buffer
+	uint new_size = ALIGN32( end + end/10 + 0x1000, 0x1000 );
+	if ( new_size > mf->max_size )
+	     new_size = mf->max_size;
+	DASSERT( new_size >= end );
+	mf->data = REALLOC(mf->data,new_size);
+	DASSERT(mf->data);
+	memset(mf->data+mf->size,0,new_size-mf->size);
+	mf->size = new_size;
+    }
+    DASSERT( end <= mf->size );
+
+    mf->fpos = fpos;
+    if ( mf->fend < end )
+	mf->fend = end;
+    DASSERT(AssertMemFile(mf));
+
+    return mf->data + fpos;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void InitializeMemFile
+(
+    MemFile_t	*mf,		// structure to initialize
+    uint	start_size,	// >0: alloc this for data
+    uint	max_size	// >0: file never grows above 'max_size'
+)
+{
+    DASSERT(mf);
+    memset(mf,0,sizeof(*mf));
+    mf->max_size = max_size ? max_size : M1(mf->max_size);
+
+    if ( start_size > 0 )
+    {
+	GetDataMemFile( mf, 0, start_size < mf->max_size ? start_size : mf->max_size );
+	mf->fend = 0;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetMemFile
+(
+    MemFile_t	*mf		// valid MemFile_t data
+)
+{
+    DASSERT(mf);
+    FREE(mf->data);
+    if (mf->err_name_alloced)
+	FreeString(mf->err_name);
+    InitializeMemFile(mf,0,mf->max_size);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError WriteMemFileAt
+(
+    MemFile_t	*mf,		// valid MemFile_t data
+    uint	fpos,		// fpos to write
+    const void	*data,		// data to write
+    uint	size		// size to write
+)
+{
+    DASSERT(mf);
+    DASSERT(data||!size);
+
+    u8 *dest = GetDataMemFile(mf,fpos,size);
+    if (!dest)
+    {
+	if (mf->err_name)
+	    ERROR0(ERR_WRITE_FAILED,"Memory file is full: %s\n",mf->err_name);
+	return ERR_WRITE_FAILED;
+    }
+
+    mf->eof = false;
+    if (size)
+	memcpy(dest,data,size);
+    mf->fpos = fpos + size;
+    if ( mf->fend < mf->fpos )
+	mf->fend = mf->fpos;
+
+    DASSERT(AssertMemFile(mf));
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint ReadMemFileAt
+(
+    MemFile_t	*mf,		// valid MemFile_t data
+    uint	fpos,		// fpos to read from
+    void	*buf,		// destination buffer
+    uint	size		// size to read
+)
+{
+    DASSERT(mf);
+    DASSERT(buf);
+
+    uint read_count = 0;
+    u8 *dest = buf;
+    if ( fpos < mf->fend )
+    {
+	read_count = mf->fend - fpos;
+	if ( read_count > size )
+	    read_count = size;
+	memcpy(dest,mf->data+fpos,read_count);
+	mf->fpos = fpos + read_count;
+	dest += read_count;
+	size -= read_count;
+    }
+
+    mf->eof = size > 0;
+    if ( mf->eof && mf->zero_extend )
+    {
+	memset(dest,0,size);
+	mf->fpos   += size;
+	read_count += size;
+    }
+
+    return read_count;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError LoadMemFile
+(
+    MemFile_t	*mf,		// MemFile_t data
+    bool	init_mf,	// true: initalize 'mf' first
+
+    ccp		path1,		// NULL or part #1 of path
+    ccp		path2,		// NULL or part #2 of path
+    size_t	skip,		// >0: skip num of bytes before reading
+    size_t	size,		// >0: max size to read; 0: read all (remaining)
+    bool	silent		// true: suppress error messages
+)
+{
+    DASSERT(mf);
+
+    if (init_mf)
+	InitializeMemFile(mf,0,0);
+    else
+	ResetMemFile(mf);
+
+    char pathbuf[PATH_MAX];
+    ccp path = PathCatPP(pathbuf,sizeof(pathbuf),path1,path2);
+    PRINT("LoadMemFile(silent=%d) %s\n",silent,path);
+
+    struct stat st;
+    if (stat(path,&st))
+    {
+	if (!silent)
+	    ERROR1(ERR_CANT_OPEN,"Can't get file status: %s\n",path);
+	return ERR_CANT_OPEN;
+    }
+    UseFileAttrib(&mf->fatt,0,&st,0);
+
+    if ( skip >= st.st_size )
+	return ERR_OK;
+
+    const uint max_size = st.st_size - skip;
+    if ( !size || size > max_size )
+	 size = max_size;
+
+    u8 *dest = GetDataMemFile(mf,0,size);
+    if (!dest)
+    {
+	if (!silent)
+	    ERROR0(ERR_READ_FAILED,"Memory file is too small: %s\n",path);
+	return ERR_READ_FAILED;
+    }
+
+    FILE * f = fopen(path,"rb");
+    if (!f)
+    {
+	if (!silent)
+	    ERROR1(ERR_CANT_OPEN,"Can't open file: %s\n",path);
+	return ERR_CANT_OPEN;
+    }
+
+    if ( skip > 0 )
+	fseek(f,skip,SEEK_SET);
+
+    mf->fend = fread(dest,1,size,f);
+    fclose(f);
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError SaveMemFile
+(
+    MemFile_t	*mf,		// MemFile_t data
+
+    ccp		path1,		// NULL or part #1 of path
+    ccp		path2,		// NULL or part #2 of path
+    FileMode_t	fmode,		// mode for file creation
+    bool	sparse		// true: enable sparse support
+)
+{
+    DASSERT(mf);
+
+    char pathbuf[PATH_MAX];
+    ccp path = PathCatPP(pathbuf,sizeof(pathbuf),path1,path2);
+    PRINT("SaveMemFile(fmode=0x%x,sparse=%d) %u/%u/%u %s\n",
+		fmode, sparse, mf->fpos, mf->fend, mf->size, path );
+
+    File_t F;
+    enumError err = CreateFile(&F,true,path,fmode);
+    if ( err || !F.f )
+    {
+	ResetFile(&F,0);
+	return err;
+    }
+
+    if (!sparse)
+    {
+	const uint written = fwrite(mf->data,1,mf->fend,F.f);
+	if ( written != mf->fend )
+	{
+	    if (!(fmode&FM_SILENT))
+		ERROR1(ERR_WRITE_FAILED,"Write to file failed: %s\n",path);
+	  err_exit:
+	    ResetFile(&F,0);
+	    return ERR_WRITE_FAILED;
+	}
+    }
+    else
+    {
+	enum { BLOCK_SIZE = 512 };
+	char zero[BLOCK_SIZE];
+	memset(zero,0,sizeof(zero));
+
+	size_t cur_offset = 0;
+	uint off = 0;
+	while ( off < mf->fend )
+	{
+	    //--- skip sparse blocks
+
+	    while ( off < mf->fend )
+	    {
+		uint max = mf->fend - off;
+		if ( max > BLOCK_SIZE )
+		     max = BLOCK_SIZE;
+		if (memcmp(mf->data+off,zero,max))
+		    break;
+		off += max;
+	    }
+
+	    //--- search next sparse block
+
+	    uint start = off;
+	    while ( off < mf->fend )
+	    {
+		uint max = mf->fend - off;
+		if ( max > BLOCK_SIZE )
+		     max = BLOCK_SIZE;
+		if (!memcmp(mf->data+off,zero,max))
+		    break;
+		off += max;
+	    }
+
+	    err = WriteFileAt(&F,&cur_offset,start,mf->data+start,off-start);
+	    if (err)
+		goto err_exit;
+	}
+
+	err = SetFileSize(&F,&cur_offset,mf->fend);
+	if (err)
+	    goto err_exit;
+    }
+    return ResetFile(&F,true);
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			TraceLog_t			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+bool OpenTraceLog  ( TraceLog_t *tl )
+{
+    if ( !tl || tl->level < 0 )
+	return false;
+
+    if ( !tl->log && tl->fname )
+    {
+	tl->log = fopen(tl->fname,"wb");
+	if (tl->log)
+	{
+	    fcntl(fileno(tl->log),F_SETFD,FD_CLOEXEC);
+	    fprintf(tl->log,"# %s, pid=%d\n",
+		PrintTimeByFormat("%F %T %z",time(0)), getpid() );
+	}
+    }
+
+    if (!tl->log)
+    {
+	tl->level = -1;
+	return false;
+    }
+
+    return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool TraceLogText ( TraceLog_t *tl, ccp text )
+{
+    if (!OpenTraceLog(tl))
+	return false;
+
+    if (text)
+    {
+	fputs(text,tl->log);
+	fflush(tl->log);
+    }
+    return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool TraceLogPrint ( TraceLog_t *tl, ccp format, ... )
+{
+    if (!OpenTraceLog(tl))
+	return false;
+
+    if (format)
+    {
+	va_list arg;
+	va_start(arg,format);
+	vfprintf(tl->log,format,arg);
+	va_end(arg);
+	fflush(tl->log);
+    }
+    return true;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			struct LineBuffer_t		///////////////
+///////////////////////////////////////////////////////////////////////////////
+#ifndef __APPLE__
+///////////////////////////////////////////////////////////////////////////////
+
+void InitializeLineBuffer ( LineBuffer_t *lb, uint max_buf_size )
+{
+    DASSERT(lb);
+    memset(lb,0,sizeof(*lb));
+    InitializeGrowBuffer(&lb->buf,max_buf_size);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetLineBuffer ( LineBuffer_t *lb )
+{
+    DASSERT(lb);
+    CloseLineBuffer(lb);
+    ResetGrowBuffer(&lb->buf);
+    FREE(lb->line);
+    lb->line = 0;
+    lb->seq_count++;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ClearLineBuffer ( LineBuffer_t *lb )
+{
+    DASSERT(lb);
+    ClearGrowBuffer(&lb->buf);
+    lb->used_lines = 0;
+    lb->seq_count++;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void RedirectLineBuffer
+(
+    LineBuffer_t	*lb,		// valid line buffer
+    FILE		*f,		// output file, if NULL use 'lb->old_fd'
+    int			max_lines	// >=0: max number of redirected lines
+)
+{
+    DASSERT(lb);
+    if ( lb->buf.used && max_lines )
+    {
+	if (!f)
+	    f = lb->old_fp;
+	if (f)
+	{
+	    if ( max_lines < 0 )
+		fwrite(lb->buf.ptr,1,lb->buf.used,f);
+	    else
+	    {
+		mem_t *line;
+		uint n = GetMemListLineBuffer(lb,&line,-max_lines);
+		while ( n-- > 0 )
+		{
+		    fprintf(f,"%.*s\n",line->len-1,line->ptr);
+		    line++;
+		}
+//DEL		fprintf(f,"==> %zd %d\n",
+//DEL			line[-1].ptr + line[-1].len - (ccp)lb->buf.ptr,
+//DEL			lb->buf.used );
+	    }
+
+	    fflush(f);
+	    if ( f == stdout )
+		stdout_seq_count++;
+	}
+    }
+    ClearGrowBuffer(&lb->buf);
+    lb->used_lines = 0;
+    lb->seq_count++;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+LineBuffer_t * OpenLineBuffer
+(
+    LineBuffer_t	*lb,		// line buffer; if NULL, malloc() one
+    bool		init_lb,	// true: initialize 'lb'
+    FILE		**fp_pos,	// NULL or external place of the file pointer
+    uint		max_lines,	// max numbers of lines
+    uint		max_line_size,	// >0: max size of a single line
+    uint		max_buf_size	// >0: max total buffer size
+)
+{
+    if (!lb)
+	lb = MALLOC(sizeof(*lb));
+    else if (!init_lb)
+	ResetLineBuffer(lb);
+    InitializeLineBuffer(lb,max_buf_size);
+
+    DASSERT(lb);
+    if (fp_pos)
+    {
+	lb->old_fp = *fp_pos;
+	lb->old_fp_pos = fp_pos;
+    }
+
+    lb->max_lines = max_lines > 1 ? max_lines : 1;
+    lb->max_line_size = max_line_size;
+    lb->line = MALLOC(lb->max_lines*sizeof(*lb->line));
+
+    static cookie_io_functions_t funcs =
+    {
+	0, // read
+	(cookie_write_function_t*)WriteLineBuffer,
+	0, // seek
+	(cookie_close_function_t*)CloseLineBuffer
+    };
+    lb->fp = fopencookie(lb,"wb",funcs);
+    if ( fp_pos && lb->fp )
+	*fp_pos = lb->fp;
+    return lb;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int CloseLineBuffer ( LineBuffer_t *lb )
+{
+    DASSERT(lb);
+    if (lb->fp)
+    {
+	if ( lb->old_fp_pos && *lb->old_fp_pos == lb->fp )
+	    *lb->old_fp_pos = lb->old_fp;
+	lb->fp = 0;
+    }
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ssize_t WriteLineBuffer ( LineBuffer_t *lb, ccp buf, size_t size )
+{
+    DASSERT(lb);
+
+    if ( lb->redirect > 0 )
+    {
+	if (lb->old_fp)
+	{
+	    ssize_t res = fwrite(buf,1,size,lb->old_fp);
+	    fflush(lb->old_fp);
+	    if ( lb->old_fp == stdout )
+		stdout_seq_count++;
+	    return res;
+	}
+    }
+    else if (size)
+    {
+	if ( lb->open_line && lb->buf.used )
+	    lb->buf.used--;
+
+	if ( lb->buf.max_size )
+	{
+	    const int max_used = lb->buf.max_size - size - 1;
+	    if ( max_used <= 0 )
+	    {
+		ClearGrowBuffer(&lb->buf);
+		buf  -= max_used;
+		size += max_used;
+	    }
+	    else if ( lb->buf.used > max_used )
+	    {
+		u8 *ptr = lb->buf.ptr;
+		u8 *end = ptr + lb->buf.used;
+		ptr += lb->buf.used - max_used;
+		while ( ptr < end )
+		    if ( *ptr++ == '\n' )
+			break;
+		DropGrowBuffer(&lb->buf,ptr-lb->buf.ptr);
+	    }
+	}
+
+	uint new_lines = 0;
+	ccp ptr = buf, end = ptr + size;
+	while ( ptr < end )
+	    if ( *ptr++ == '\n' )
+		new_lines++;
+	lb->line_count += new_lines;
+
+	InsertGrowBuffer(&lb->buf,buf,size);
+	lb->open_line = buf[size-1] != '\n';
+	if (lb->open_line)
+	    InsertCharGrowBuffer(&lb->buf,'\n');
+
+	FixMemListLineBuffer(lb,true);
+	lb->seq_count++;
+	PRINT("WRITE %3zu bytes, is_open: %d, total lines: %d\n",
+		size, lb->open_line, lb->used_lines );
+    }
+    return size;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void FixMemListLineBuffer ( LineBuffer_t *lb, bool force )
+{
+    DASSERT(lb);
+    if (!lb->buf.used)
+	lb->used_lines = 0;
+    else if ( force
+		|| lb->prev_buf_ptr != lb->buf.ptr
+		|| lb->prev_seq_count != lb->seq_count )
+    {
+	u8 *beg = lb->buf.ptr;
+	u8 *ptr = beg + lb->buf.used;
+
+	mem_t *dest = lb->line + lb->max_lines;
+	while ( beg < ptr  && dest > lb->line )
+	{
+	    u8* end = ptr--;
+	    while ( beg < ptr && ptr[-1] != '\n' )
+		ptr--;
+
+	    dest--;
+	    dest->ptr = (ccp)ptr;
+	    dest->len = end - ptr;
+	}
+
+	lb->used_lines = lb->line + lb->max_lines - dest;
+	if ( dest > lb->line )
+	    memmove(lb->line,dest,lb->used_lines*sizeof(*dest));
+
+	if ( ptr > beg )
+	{
+	    // don't use DropGrowBuffer() to hold buf stable
+	    lb->buf.used -= ptr - beg;
+	    lb->buf.ptr = ptr;
+	}
+
+	lb->prev_buf_ptr = lb->buf.ptr;
+	lb->prev_seq_count = lb->seq_count;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint GetMemListLineBuffer
+(
+    // returns the number of elements
+
+    LineBuffer_t	*lb,		// line buffer; if NULL, malloc() one
+    mem_t		**res,		// store pointer to first element here
+    int			max_lines	// !0: limit lines, <0: count from end
+)
+{
+    DASSERT(lb);
+
+    if ( lb->prev_buf_ptr != lb->buf.ptr )
+	FixMemListLineBuffer(lb,false);
+
+    uint pos = 0;
+    if (!max_lines)
+	max_lines = lb->used_lines;
+    else if ( max_lines < 0 )
+    {
+	max_lines = -max_lines;
+	if ( max_lines > lb->used_lines )
+	    max_lines = lb->used_lines;
+	pos = lb->used_lines - max_lines;
+    }
+    else if ( max_lines > lb->used_lines )
+	max_lines = lb->used_lines;
+
+    if (res)
+	*res = lb->line + pos;
+    return max_lines;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint PrintLineBuffer
+(
+    // returns number of written lines
+
+    FILE		*f,		// output stream
+    int			indent,		// indention
+    LineBuffer_t	*lb,		// line buffer; if NULL, malloc() one
+    int			max_lines,	// !0: limit lines, <0: count from end
+    ccp			open_line	// not NULL: append this text for an open line
+)
+{
+    DASSERT(f);
+    DASSERT(lb);
+    indent = NormalizeIndent(indent);
+
+    mem_t *line;
+    uint i, n = GetMemListLineBuffer(lb,&line,max_lines);
+    for ( i = 1; i <= n; i++, line++ )
+	fprintf(f,"%*s%.*s%s\n",
+		indent,"",
+		line->len-1, line->ptr,
+		open_line && i == n && lb->open_line ? open_line : "" );
+    return n;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#endif // !__APPLE__
+///////////////////////////////////////////////////////////////////////////////
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			file helpers			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+int IsDirectory
+(
+    // analyse filename (last char == '/') and stat(fname)
+
+    ccp			fname,		// NULL or path
+    int			answer_if_empty	// answer, if !fname || !*fname
+)
+{
+    if ( !fname || !*fname )
+	return answer_if_empty;
+
+    if ( *fname == '-' && !fname[1] )
+	return false;
+
+    if ( fname[strlen(fname)-1] == '/' )
+	return true;
+
+    struct stat st;
+    return !stat(fname,&st) && S_ISDIR(st.st_mode);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ExistDirectory
+(
+    // check only real file (stat(fname))
+
+    ccp			fname,		// NULL or path
+    int			answer_if_empty	// answer, if !fname || !*fname
+)
+{
+    if ( !fname || !*fname )
+	return answer_if_empty;
+
+    if ( *fname == '-' && !fname[1] )
+	return false;
+
+    struct stat st;
+    return !stat(fname,&st) && S_ISDIR(st.st_mode);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool IsSameFilename ( ccp fn1, ccp fn2 )
+{
+    if ( !fn1 || !fn2 )
+	return false;
+
+    while ( fn1[0] == '.' && fn1[1] == '/' )
+	fn1 += 2;
+    while ( fn2[0] == '.' && fn2[1] == '/' )
+	fn2 += 2;
+
+    return !strcmp(fn1,fn2);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+bool enable_config_search_log = false;
+
+ccp FindConfigFile
+(
+    // returns NULL or found file (alloced)
+
+    FindConfigFile_t mode,	// bit field: select search destinations
+    ccp		share_name,	// NULL or <SHARE>
+    ccp		file_name,	// NULL or <FILENAME>
+    ccp		prog_ext	// <EXT>, if NULL use '.' + <FILENAME>
+)
+{
+    struct stat st;
+    char path[PATH_MAX];
+
+    //--- empty strings like NULL
+
+    if ( share_name && !*share_name ) share_name = progname;
+    if ( file_name  && !*file_name  ) file_name = 0;
+    if ( prog_ext   && !*prog_ext   ) prog_ext = 0;
+
+    if ( file_name && share_name )
+    {
+	//--- the first attemps need FILENAME
+
+	if ( mode & FCF_HOME )
+	{
+	    ccp home = getenv("HOME");
+	    if ( home && *home )
+	    {
+		snprintf(path,sizeof(path),"%s/.%s/%s",home,share_name,file_name);
+		if ( mode & FCF_F_DEBUG )
+		    fprintf(stderr,"SEARCH: %s\n",path);
+		if ( !stat(path,&st) && S_ISREG(st.st_mode) )
+		    return STRDUP(path);
+	    }
+	}
+
+	if ( mode & FCF_REL_SHARE )
+	{
+	    ccp pdir = ProgramDirectory();
+	    if (pdir)
+	    {
+		snprintf(path,sizeof(path),"%s/../share/%s/%s",pdir,share_name,file_name );
+		if ( mode & FCF_F_DEBUG )
+		    fprintf(stderr,"SEARCH: %s\n",path);
+		if ( !stat(path,&st) && S_ISREG(st.st_mode) )
+		    return STRDUP(path);
+	    }
+	}
+
+	if ( mode & FCF_LOC_SHARE )
+	{
+	    snprintf(path,sizeof(path),"/usr/local/share/%s/%s",share_name,file_name);
+	    if ( mode & FCF_F_DEBUG )
+		fprintf(stderr,"SEARCH: %s\n",path);
+	    if ( !stat(path,&st) && S_ISREG(st.st_mode) )
+		return STRDUP(path);
+	}
+
+	if ( mode & FCF_USR_SHARE )
+	{
+	    snprintf(path,sizeof(path),"/usr/share/%s/%s",share_name,file_name);
+	    if ( mode & FCF_F_DEBUG )
+		fprintf(stderr,"SEARCH: %s\n",path);
+	    if ( !stat(path,&st) && S_ISREG(st.st_mode) )
+		return STRDUP(path);
+	}
+    }
+
+    if ( mode & (FCF_PROG_SHARE|FCF_PROG) && ( prog_ext || file_name ) )
+    {
+	ccp ppath = ProgramPathNoExt();
+	if (ppath)
+	{
+	    if ( mode & FCF_PROG_SHARE )
+	    {
+		ccp pdir = ProgramDirectory();
+		noPRINT("pdir=%s\n",pdir);
+		if (pdir)
+		{
+		    ccp fname = strrchr(ppath,'/');
+		    fname = fname ? fname+1 : ppath;
+
+		    if (prog_ext)
+			snprintf(path,sizeof(path),"%s/share/%s%s",
+				pdir, fname, prog_ext );
+		    else
+			snprintf(path,sizeof(path),"%s/share/%s.%s",
+				pdir, fname, file_name );
+		    if ( mode & FCF_F_DEBUG )
+			fprintf(stderr,"SEARCH: %s\n",path);
+		    if ( !stat(path,&st) && S_ISREG(st.st_mode) )
+			return STRDUP(path);
+		}
+	    }
+
+	    if ( mode & FCF_PROG )
+	    {
+		if (prog_ext)
+		    snprintf(path,sizeof(path),"%s%s",ppath,prog_ext);
+		else
+		    snprintf(path,sizeof(path),"%s.%s",ppath,file_name);
+		if ( mode & FCF_F_DEBUG )
+		    fprintf(stderr,"SEARCH: %s\n",path);
+		if ( !stat(path,&st) && S_ISREG(st.st_mode) )
+		    return STRDUP(path);
+	    }
+	}
+    }
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int SearchFiles
+(
+    ccp			path1,	// not NULL: part #1 of base path
+    ccp			path2,	// not NULL: part #2 of base path
+    ccp			match,	// not NULL: filter files by MatchPattern()
+				// if empty: extract from combined path
+    SearchFilesFunc	func,	// callback function, never NULL
+    void		*param	// third parameter of func()
+)
+{
+    DASSERT(func);
+
+    char pathbuf[PATH_MAX];
+    ccp path = PathCatPP(pathbuf,sizeof(pathbuf),path1,path2);
+
+    if ( match && !*match )
+    {
+	match = 0;
+	if ( path != pathbuf )
+	{
+	    // path is modified!
+	    StringCopyS(pathbuf,sizeof(pathbuf),path);
+	    path = pathbuf;
+	}
+
+	char *found = strrchr(pathbuf,'/');
+	if (found)
+	{
+	    if ( found == pathbuf )
+		path = "/";
+	    *found++ = 0;
+	    match = *found ? found : 0;
+	}
+	else
+	{
+	    match = pathbuf;
+	    path = ".";
+	}
+    }
+
+    if ( !path || !*path )
+	path = ".";
+
+    DIR *fdir = opendir(path);
+    int stat = errno;
+
+    if (fdir)
+    {
+	for(;;)
+	{
+	    struct dirent *dent = readdir(fdir);
+	    if (!dent)
+		break;
+
+	    if ( !match || MatchPatternFull(match,dent->d_name) )
+	    {
+		stat = func(path,dent,param);
+		if ( stat < 0 )
+		    break;
+	    }
+	}
+	closedir(fdir);
+    }
+    return stat;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError CreatePath
+(
+    ccp			path,		// path to create
+    bool		is_pure_dir	// true: 'path' don't contains a filename part
+)
+{
+    TRACE("CreatePath(%s)\n",path);
+
+    char buf[PATH_MAX];
+    char *dest = StringCopyS(buf,sizeof(buf)-1,path);
+    if (is_pure_dir)
+    {
+	*dest++ = '/';
+	*dest = 0;
+    }
+    dest = buf;
+
+    for(;;)
+    {
+	// skip slashes
+	while ( *dest == '/' )
+	    dest++;
+
+	// search end of current directory
+	while ( *dest && *dest != '/' )
+	    dest++;
+	if (!*dest)
+	    break;
+
+	*dest = 0;
+	if ( mkdir(buf,0777) && errno != EEXIST && !IsDirectory(buf,0) )
+	{
+	    noTRACE("CREATE-DIR: %s -> err=%d (ENOTDIR=%d)\n",buf,errno,ENOTDIR);
+	    if ( errno == ENOTDIR )
+	    {
+		while ( dest > buf && *dest != '/' )
+		    dest--;
+		if ( dest > buf )
+		    *dest = 0;
+	    }
+	    return ERROR1( ERR_CANT_CREATE_DIR,
+		errno == ENOTDIR
+			? "Not a directory: %s\n"
+			: "Can't create directory: %s\n", buf );
+	}
+	TRACE("CREATE-DIR: %s -> OK\n",buf);
+	*dest++ = '/';
+    }
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError RemoveSource
+(
+    ccp			fname,		// file to remove
+    ccp			dest_fname,	// NULL or dest file name
+					//   If real pathes are same: don't remove
+    bool		print_log,	// true: print a log message
+    bool		testmode	// true: don't remove, log only
+)
+{
+    DASSERT(fname);
+    if (dest_fname)
+    {
+	if (!strcmp(fname,dest_fname))
+	    return ERR_OK;
+
+	char p1[PATH_MAX], p2[PATH_MAX];
+	if ( realpath(fname,p1) && realpath(dest_fname,p2) && !strcmp(p1,p2) )
+	    return ERR_OK;
+    }
+
+    if ( print_log || testmode )
+	fprintf( stdlog ? stdlog : stdout,
+		"%sREMOVE %s\n",
+		testmode ? "WOULD " : "", fname );
+
+    return !testmode && unlink(fname)
+	? ERROR1( ERR_CANT_REMOVE, "Can't remove source file: %s\n", fname )
+	: ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * FindFilename
+(
+    // Find the last part of the path, trailing '/' are ignored
+    // return poiner to found string
+
+    ccp		path,			// path to analyze, valid string
+    uint	* result_len		// not NULL: return length of found string
+)
+{
+    DASSERT(path);
+
+    ccp end = path + strlen(path);
+    if ( end > path && end[-1] == '/' )
+	 end--;
+
+    ccp start = end;
+    while ( start > path && start[-1] != '/' )
+	start--;
+    if (result_len)
+	*result_len = end - start;
+    return (char*)start;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint NumberedFilename
+(
+    // return used index number or 0, if not modified.
+
+    char		* buf,		// destination buffer
+    size_t		bufsize,	// size of 'buf'
+    ccp			source,		// source filename, may be part of 'buf'
+					// if NULL or empty:
+    ccp			ext,		// not NULL & not empty: file extension ('.ext')
+    uint		ext_mode,	// only relevant, if 'ext' is neither NULL not empty
+					//   0: use 'ext' only for detection
+					//   1: replace 'source' extension by 'ext'
+					//   2: append 'ext' if 'source' differ
+					//   3: append 'ext' always
+    bool		detect_stdio	// true: don't number "-"
+)
+{
+    //--- analyse stdin/stdout
+
+    char *end = StringCopyS(buf,bufsize,source);
+    if ( !source || !*source || detect_stdio && *source == '-' && !source[1] )
+	return 0;
+
+
+    //--- analyse parameter 'ext'
+
+    uint ext_len = 0;
+    if ( ext && *ext )
+    {
+	ext_len = strlen(ext);
+	if ( ext_mode >= 3 )
+	{
+	    // append extension always
+	    StringCopyE(end,buf+bufsize,ext);
+	}
+	else if ( end - buf <= ext_len || memcmp(end-ext_len,ext,ext_len) )
+	{
+	    // extensions differ
+	    if (!ext_mode)
+		ext_len = 0;
+	    else if  ( ext_mode == 2 )
+		StringCopyE(end,buf+bufsize,ext);
+	    else
+	    {
+		char *slash = strrchr(buf,'/');
+		char *point = strrchr(buf,'.');
+		if ( point && ( !slash || point > slash ) )
+		    end = point;
+		StringCopyE(end,buf+bufsize,ext);
+	    }
+	}
+    }
+
+
+    //--- does files exist? => if not: return without numbering
+
+    struct stat st;
+    if (stat(buf,&st))
+	return 0;
+
+
+
+    //--- split filename into dir + name + index + ext
+
+    char temp[PATH_MAX];
+
+    ccp dir = buf, search_dir;
+    uint dir_len;
+    ccp name = strrchr(buf,'/');
+    if (name)
+    {
+	dir_len = name++ - dir;
+	StringCopyS(temp,sizeof(temp),buf);
+	if ( dir_len < sizeof(temp) )
+	    temp[dir_len] = 0;
+	search_dir = temp;
+	dir_len++;
+    }
+    else
+    {
+	name = buf;
+	dir_len = 0;
+	dir = "";
+	search_dir = ".";
+    }
+
+    uint name_len;
+    if (ext_len)
+    {
+	name_len = strlen(name);
+	if ( ext_len >= name_len )
+	    goto find_ext;
+
+	name_len -= ext_len;
+	ext = name + name_len;
+    }
+    else
+    {
+     find_ext:
+	ext = strrchr(name,'.');
+	if ( ext && ext > name )
+	{
+	    name_len = ext - name;
+	    ext_len = strlen(ext);
+	}
+	else
+	{
+	    name_len = strlen(name);
+	    ext_len = 0;
+	    ext = "";
+	}
+    }
+
+    ccp ptr = name + name_len - 1;
+    while ( ptr >= name && *ptr >= '0' && *ptr <= '9' )
+	ptr--;
+    name_len = ++ptr - name;
+    uint index = strtoul(ptr,0,10);
+
+    PRINT("|%s| : |%.*s|%.*s|#%u|%.*s|\n",
+	search_dir, dir_len, dir, name_len, name, index, ext_len, ext );
+
+
+    //--- iterate directory to find highest index
+
+    DIR *fdir = opendir(search_dir);
+    if (fdir)
+    {
+	for(;;)
+	{
+	    struct dirent *dent = readdir(fdir);
+	    if (!dent)
+		break;
+
+	    ccp fname = dent->d_name;
+	    const uint fname_len = strlen(fname);
+	    if ( fname_len > name_len + ext_len
+		&& !strncasecmp(name,fname,name_len) )
+	    {
+		ccp fext = fname + fname_len - ext_len;
+		if (!strncasecmp(ext,fext,ext_len))
+		{
+		    char *end;
+		    uint idx = strtoul(fname+name_len,&end,10);
+		    if ( end == fext && idx > index )
+			index = idx;
+		}
+	    }
+	}
+	closedir(fdir);
+    }
+
+
+    //--- create new filename
+
+    index++;
+    snprintf(temp,sizeof(temp),"%.*s%u%s",name_len,name,index,ext);
+    StringCopyE(buf+dir_len,buf+bufsize,temp);
+
+    return index;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			normalize filenames		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * NormalizeFileName
+(
+    // returns a pointer to the NULL terminator within 'buf'
+
+    char		* buf,		// valid destination buffer
+    uint		buf_size,	// size of buf
+    ccp			source,		// NULL or source
+    bool		allow_slash,	// true: allow '/' in source
+    bool		is_utf8		// true: enter UTF-8 mode
+)
+{
+    DASSERT(buf);
+    DASSERT(buf_size>1);
+
+    char *dest = buf, *end = buf + buf_size - 1;
+    TRACE("NormalizeFileName(%s,%d)\n",source,allow_slash);
+
+    if (source)
+    {
+     #ifdef __CYGWIN__
+	if (allow_slash)
+	{
+	    const int drv_len = IsWindowsDriveSpec(source);
+	    if (drv_len)
+	    {
+		dest = StringCopyE(dest,end,"/cygdrive/c/");
+		if ( dest < end )
+		    dest[-2] = tolower((int)*source);
+		source += drv_len;
+	    }
+	}
+     #endif
+
+	bool skip_space = true;
+	while ( *source && dest < end )
+	{
+	    unsigned char ch = *source++;
+	    if ( ch == ':' )
+	    {
+		if (!skip_space)
+		    *dest++ = ' ';
+		if ( dest + 2 <= end )
+		{
+		    *dest++ = '-';
+		    *dest++ = ' ';
+		}
+		skip_space = true;
+	    }
+	    else
+	    {
+		if ( isalnum(ch)
+			|| ( is_utf8
+				? ch >= 0x80
+				:    ch == 0xe4 // ä
+				  || ch == 0xf6 // ö
+				  || ch == 0xfc // ü
+				  || ch == 0xdf // ß
+				  || ch == 0xc4 // Ä
+				  || ch == 0xd6 // Ö
+				  || ch == 0xdc // Ü
+			    )
+			|| strchr("_+-=%'\"$%&,.!()[]{}<>",ch)
+			|| ch == '/' && allow_slash )
+		{
+		    *dest++ = ch;
+		    skip_space = false;
+		}
+	     #ifdef __CYGWIN__
+		else if ( ch == '\\' && allow_slash )
+		{
+		    *dest++ = '/';
+		    skip_space = false;
+		}
+	     #endif
+		else if (!skip_space)
+		{
+		    *dest++ = ' ';
+		    skip_space = true;
+		}
+	    }
+	}
+    }
+    if ( dest > buf && dest[-1] == ' ' )
+	dest--;
+
+    DASSERT( dest <= end );
+    *dest = 0;
+    return dest;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef __CYGWIN__
+
+ uint IsWindowsDriveSpec
+ (
+    // returns the length of the found windows drive specification (0|2|3)
+
+    ccp			src		// valid string
+ )
+ {
+    DASSERT(src);
+
+    if ( ( *src >= 'a' && *src <= 'z' || *src >= 'A' && *src <= 'Z' )
+	&& src[1] == ':' )
+    {
+	if (!src[2])
+	    return 2;
+
+	if ( src[2] == '/' || src[2] == '\\' )
+	    return 3;
+    }
+    return 0;
+ }
+
+#endif // __CYGWIN__
+
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef __CYGWIN__
+
+ uint NormalizeFilenameCygwin
+ (
+    // returns a pointer to the NULL terminator within 'buf'
+
+    char		* buf,		// valid destination buffer
+    uint		buf_size,	// size of buf
+    ccp			src		// NULL or source
+ )
+ {
+    static char prefix[] = "/cygdrive/";
+
+    if ( buf_size < sizeof(prefix) + 5 || !src )
+    {
+	*buf = 0;
+	return 0;
+    }
+
+    char * end = buf + buf_size - 1;
+    char * dest = buf;
+
+    if (   ( *src >= 'a' && *src <= 'z' || *src >= 'A' && *src <= 'Z' )
+	&& src[1] == ':'
+	&& ( src[2] == 0 || src[2] == '/' || src[2] == '\\' ))
+    {
+	memcpy(buf,prefix,sizeof(prefix));
+	dest = buf + sizeof(prefix)-1;
+	*dest++ = tolower((int)*src); // cygwin needs the '(int)'
+	*dest = 0;
+	if (IsDirectory(buf,false))
+	{
+	    *dest++ = '/';
+	    src += 2;
+	    if (*src)
+		src++;
+	}
+	else
+	    dest = buf;
+    }
+    ASSERT( dest < buf + buf_size );
+
+    while ( dest < end && *src )
+	if ( *src == '\\' )
+	{
+	    *dest++ = '/';
+	    src++;
+	}
+	else
+	    *dest++ = *src++;
+
+    *dest = 0;
+    ASSERT( dest < buf + buf_size );
+    return dest - buf;
+ }
+
+#endif // __CYGWIN__
+
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef __CYGWIN__
+
+ char * AllocNormalizedFilenameCygwin
+ (
+    // returns an alloced buffer with the normalized filename
+
+    ccp source				// NULL or string
+ )
+ {
+    char buf[PATH_MAX];
+    const uint len = NormalizeFilenameCygwin(buf,sizeof(buf),source);
+    char * result = MEMDUP(buf,len); // MEMDUP allocs +1 byte and set it to NULL
+    DASSERT(buf[len]==0);
+    return result;
+ }
+
+#endif // __CYGWIN__
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    FDList_t			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void ClearFDList ( FDList_t *fdl )
+{
+    DASSERT(fdl);
+
+    fdl->max_fd = -1;
+    FD_ZERO(&fdl->readfds);
+    FD_ZERO(&fdl->writefds);
+    FD_ZERO(&fdl->exceptfds);
+
+    fdl->poll_used = 0;
+    fdl->n_sock = 0;
+
+    fdl->now_usec = GetTimeUSec(false);
+    fdl->timeout_usec = M1(fdl->timeout_usec);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void InitializeFDList ( FDList_t *fdl, bool use_poll )
+{
+    DASSERT(fdl);
+    memset(fdl,0,sizeof(*fdl));
+    fdl->use_poll = use_poll;
+    ClearFDList(fdl);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetFDList ( FDList_t *fdl )
+{
+    DASSERT(fdl);
+    FREE(fdl->poll_list);
+    InitializeFDList(fdl,fdl->use_poll);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct pollfd * AllocFDList ( FDList_t *fdl, uint n )
+{
+    DASSERT(fdl);
+    uint min_size = fdl->poll_used + n;
+    if ( fdl->poll_size < min_size )
+    {
+	fdl->poll_size = ( min_size/0x18 + 2 ) * 0x20;
+	DASSERT( fdl->poll_size >= min_size );
+	fdl->poll_list = REALLOC(fdl->poll_list,fdl->poll_size*sizeof(*fdl->poll_list));
+    }
+    DASSERT( fdl->poll_used + n <= fdl->poll_size );
+
+    struct pollfd *ptr = fdl->poll_list + fdl->poll_used;
+    fdl->poll_used += n;
+    memset(ptr,0,n*sizeof(*ptr));
+    return ptr;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void AnnounceFDList ( FDList_t *fdl, uint n )
+{
+    if (fdl->use_poll)
+    {
+	AllocFDList(fdl,n);
+	fdl->poll_used -= n;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint AddFDList
+(
+    // returns the pool-index if available, ~0 otherwise
+
+    FDList_t	*fdl,	// valid socket list
+    int		sock,	// socket to add
+    uint	events	// bit field: POLLIN|POLLOUT|POLLERR
+)
+{
+    if ( sock == -1 || !(events&(POLLIN|POLLOUT|POLLERR)) )
+	return ~0;
+
+    fdl->n_sock++;
+    if ( fdl->max_fd < sock )
+	fdl->max_fd = sock;
+
+    DASSERT(fdl);
+    if (fdl->use_poll)
+    {
+	struct pollfd *pp = AllocFDList(fdl,1);
+	DASSERT(pp);
+	pp->fd = sock;
+	pp->events = events;
+	return pp - fdl->poll_list;
+    }
+
+    noPRINT("ADD-SOCK %d = %x\n",sock,events);
+    if ( events & POLLIN )
+	FD_SET(sock,&fdl->readfds);
+    if ( events & POLLOUT )
+	FD_SET(sock,&fdl->writefds);
+    if ( events & POLLERR )
+	FD_SET(sock,&fdl->exceptfds);
+    return ~0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint GetEventFDList
+(
+    // returns bit field: POLLIN|POLLOUT|POLLERR
+
+    FDList_t	*fdl,		// valid socket list
+    int		sock,		// socket to look for
+    uint	poll_index	// if use_poll: use the index for a fast search
+)
+{
+    if ( sock == -1 )
+	return 0;
+
+    DASSERT(fdl);
+    if (fdl->use_poll)
+    {
+	const struct pollfd *pp = fdl->poll_list;
+	if ( poll_index < fdl->poll_used && pp[poll_index].fd == sock )
+	    return pp[poll_index].revents;
+
+	const struct pollfd *pend = pp + fdl->poll_used;
+	for ( ; pp < pend; pp++ )
+	    if ( pp->fd == sock )
+		return pp->revents;
+	return 0;
+    }
+
+    uint revents = 0;
+    if (FD_ISSET(sock,&fdl->readfds))
+	revents |= POLLIN;
+    if (FD_ISSET(sock,&fdl->writefds))
+	revents |= POLLOUT;
+    if (FD_ISSET(sock,&fdl->exceptfds))
+	revents |= POLLERR;
+    return revents;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+int WaitFDList
+(
+    FDList_t	*fdl		// valid socket list
+)
+{
+    DASSERT(fdl);
+
+    int stat;
+    u64 now_usec = GetTimeUSec(false);
+
+    if (fdl->use_poll)
+    {
+	int timeout;
+	if ( fdl->timeout_usec > now_usec )
+	{
+	    u64 delta = ( fdl->timeout_usec - now_usec ) / 1000;
+	    timeout = delta > 0x7fffffffull ? -1 : delta;
+	}
+	else
+	    timeout = 0;
+
+	stat = poll( fdl->poll_list, fdl->poll_used, timeout );
+    }
+    else
+    {
+	struct timeval tv, *ptv = &tv;
+	if ( fdl->timeout_usec > now_usec )
+	{
+	    const u64 delta = fdl->timeout_usec - now_usec;
+	    if ( delta > 1000000ull * 0x7fffffffull )
+		ptv = NULL;
+	    else
+	    {
+		tv.tv_sec  = delta / 1000000;
+		tv.tv_usec = delta % 1000000;
+	    }
+	}
+	else
+	    tv.tv_sec = tv.tv_usec = 0;
+
+//DEL	fprintf(stderr,"#SELECT %lld: ptv=%d: %lu.%06lu\n",
+//DEL			fdl->timeout_usec-now_usec, ptv!=0, tv.tv_sec, tv.tv_usec );
+	stat = select( fdl->max_fd+1, &fdl->readfds, &fdl->writefds,
+			&fdl->exceptfds, ptv );
+    }
+
+    fdl->now_usec = GetTimeUSec(false);
+    fdl->cur_usec = fdl->now_usec - now_usec;
+    fdl->wait_usec += fdl->cur_usec;
+    fdl->wait_count++;
+    return stat;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int PWaitFDList
+(
+    FDList_t	*fdl,		// valid socket list
+    const sigset_t	*sigmask	// NULL or signal mask
+)
+{
+    DASSERT(fdl);
+
+ #ifdef __APPLE__
+    // [[2do]] ??? untested work around
+    if (fdl->use_poll)
+    {
+	sigset_t origmask;
+	if (sigmask)
+	    sigprocmask(SIG_SETMASK,sigmask,&origmask);
+	const int stat = WaitFDList(fdl);
+	if (sigmask)
+	    sigprocmask(SIG_SETMASK,&origmask,NULL);
+	return stat;
+    }
+ #endif
+
+    struct timespec ts, *pts = &ts;
+    u64 now_usec = GetTimeUSec(false);
+    if ( fdl->timeout_usec > now_usec )
+    {
+	const u64 delta = fdl->timeout_usec - now_usec;
+	if ( delta > 1000000ull * 0x7fffffffull )
+	    pts = NULL;
+	else
+	{
+	    ts.tv_sec  = delta / 1000000;
+	    ts.tv_nsec = delta % 1000000 * 1000;
+	}
+    }
+    else
+	ts.tv_sec = ts.tv_nsec = 0;
+
+ #ifdef __APPLE__
+    const int stat = pselect( fdl->max_fd+1, &fdl->readfds, &fdl->writefds,
+				&fdl->exceptfds, pts, sigmask );
+ #else
+    const int stat = fdl->use_poll
+		? ppoll( fdl->poll_list, fdl->poll_used, pts, sigmask )
+		: pselect( fdl->max_fd+1, &fdl->readfds, &fdl->writefds,
+				&fdl->exceptfds, pts, sigmask );
+ #endif
+
+    fdl->now_usec = GetTimeUSec(false);
+    fdl->cur_usec = fdl->now_usec - now_usec;
+    fdl->wait_usec += fdl->cur_usec;
+    fdl->wait_count++;
+    return stat;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+mem_t CheckUnixSocketPathMem
+(
+    mem_t	src,	    // NULL or source path to analyse
+    int		tolerance   // <1: 'unix:', 'file:', '/', './' and '../' detected
+			    //  1: not 'NAME:' && at relast one '/'
+			    //  2: not 'NAME:'
+)
+{
+    if ( src.ptr && src.len )
+    {
+	ccp ptr = src.ptr;
+	ccp end = ptr + src.len;
+
+	switch (*ptr)
+	{
+	    case '/':
+		return src;
+
+	    case '.':
+		{
+		    ccp s = ptr+1;
+		    if ( s < end && *s == '.' )
+			s++;
+		    if ( s < end && *s == '/' )
+			return src;
+		}
+		break;
+
+	    case 'f':
+		if ( end-ptr >= 5 && !memcmp(ptr,"file:",5) )
+		    return RightMem(src,-5);
+
+	    case 'u':
+		if ( end-ptr >= 5 && !memcmp(ptr,"unix:",5) )
+		    return RightMem(src,-5);
+	    break;
+	}
+
+	if ( tolerance > 0 )
+	{
+	    while ( ptr < end && isalnum((int)*ptr) )
+		ptr++;
+	    if ( ptr < end && *ptr != ':' && ( tolerance > 1 || strchr(ptr,'/')) )
+		return BehindMem(src,ptr);
+	}
+    }
+
+    return NullMem;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp CheckUnixSocketPath
+(
+    ccp		src,	    // NULL or source path to analyse
+    int		tolerance   // <1: 'unix:', 'file:', '/', './' and '../' detected
+			    //  1: not 'NAME:' && at relast one '/'
+			    //  2: not 'NAME:'
+)
+{
+    mem_t res = CheckUnixSocketPathMem(MemByString(src),tolerance);
+    return res.ptr;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			Catch Output			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+int CatchIgnoreOutput
+(
+    struct CatchOutput_t *ctrl,		// control struct incl. data
+    int			call_mode	// 0:init, 1:new data, 2:term
+)
+{
+    DASSERT(ctrl);
+    ClearGrowBuffer(&ctrl->buf);
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetCatchOutput ( CatchOutput_t *co, uint n )
+{
+    while ( n-- > 0 )
+    {
+	if ( co->pipe_fd[0] != -1 )
+	{
+	    close(co->pipe_fd[0]);
+	    co->pipe_fd[0] = -1;
+	}
+
+	if ( co->pipe_fd[1] != -1 )
+	{
+	    close(co->pipe_fd[1]);
+	    co->pipe_fd[1] = -1;
+	}
+
+	ResetGrowBuffer(&co->buf);
+	co++;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError CatchOutput
+(
+    ccp			command,	// command to execute
+    int			argc,		// num(arguments) in 'argv'; -1: argv is NULL terminated
+    char *const*	argv,		// list of arguments
+
+    CatchOutputFunc	stdout_func,	// NULL or function to catch stdout
+    CatchOutputFunc	stderr_func,	// NULL or function to catch stderr
+    void		*user_ptr,	// NULL or user defined parameter
+    bool		silent		// true: suppress error messages
+)
+{
+    if ( !command || !*command )
+	return ERR_NOTHING_TO_DO;
+
+
+    //--- setup streams & pipes
+
+    uint n_catch_out = 0;
+    CatchOutput_t catch_out[2];
+    memset(catch_out,0,sizeof(catch_out));
+
+    uint i;
+    for ( i = 1; i <= 2; i++ )
+    {
+	CatchOutputFunc func = i==1 ? stdout_func : stderr_func;
+	if (!func)
+	    continue;
+
+	CatchOutput_t *co = catch_out + n_catch_out++;
+	co->mode = i;
+	co->func = func;
+	co->user_ptr = user_ptr;
+	InitializeGrowBuffer(&co->buf,16*KiB);
+
+	if ( pipe(co->pipe_fd) == -1 )
+	{
+	    ResetCatchOutput(catch_out,n_catch_out);
+	    if (!silent)
+		ERROR1(ERR_CANT_CREATE,"Can't create pipe\n");
+	    return ERR_CANT_CREATE;
+	}
+    }
+
+
+    //--- setup arguments
+
+    if (!argv)
+	argc = 0;
+    else if ( argc < 0 )
+	for ( argc = 0; argv[argc]; argc++ )
+	    ;
+
+    const uint local_args_size = 100;
+    char *local_args[local_args_size+2];
+    char **args = local_args;
+    if ( argc >= local_args_size )
+	args = MALLOC((argc+2)*sizeof(*args));
+
+    char **destarg = args;
+    *destarg++ = (char*)command;
+
+    for ( i = 0; i < argc; i++ )
+	*destarg++ = argv[i];
+    *destarg = 0;
+
+    #ifdef TEST
+    {
+	printf("EXEC '%s' [argc=%u]\n",command,argc);
+	uint i;
+	for ( i = 0; i < argc+2; i++ )
+	    printf("%3d: %s\n",i,args[i]);
+    }
+    #endif
+
+
+    //--- fork
+
+    enumError err = ERR_OK;
+
+    int fork_stat = fork();
+    if ( fork_stat < 0 )
+    {
+	if (!silent)
+	    ERROR1(ERR_ERROR,"Can't fork: %s\n",command);
+	err = ERR_ERROR;
+    }
+    else if (fork_stat)
+    {
+	PRINT("WAIT FOR %d\n",fork_stat);
+
+	CatchOutput_t *co, *co_end = catch_out + n_catch_out;
+	for ( co = catch_out; co < co_end; co++ )
+	{
+	    DASSERT(co->func);
+	    co->func(co,0);
+	    close(co->pipe_fd[1]);  // close childs (write) end
+	    co->pipe_fd[1] = -1;
+	}
+
+	FDList_t fdl;
+	InitializeFDList(&fdl,false);
+	char buf[0x1000];
+
+	for(;;)
+	{
+	    ClearFDList(&fdl);
+	    fdl.timeout_usec = GetTimeUSec(false) + 60*USEC_PER_SEC;
+	    for ( co = catch_out; co < co_end; co++ )
+		AddFDList(&fdl,co->pipe_fd[0],POLLIN);
+	    if ( fdl.max_fd == -1 )
+		break;
+
+	    const int stat = WaitFDList(&fdl);
+	    if ( stat > 0 )
+	    {
+		for ( co = catch_out; co < co_end; co++ )
+		{
+		    int fd = co->pipe_fd[0];
+		    uint event = GetEventFDList(&fdl,fd,0);
+		    if ( event & POLLIN )
+		    {
+			ssize_t read_size = read(fd,buf,sizeof(buf));
+			PRINT("READ %d[%d], %zd bytes\n",co->mode,fd,read_size);
+			if ( read_size > 0 )
+			{
+			    PrepareGrowBuffer(&co->buf,read_size,true);
+			    InsertGrowBuffer(&co->buf,buf,read_size);
+			    if (co->func)
+				co->func(co,1);
+			}
+			else
+			{
+			    close(fd);
+			    co->pipe_fd[0] = -1;
+			}
+		    }
+		}
+	    }
+	}
+	ResetFDList(&fdl);
+
+	int wait_stat;
+	for(;;)
+	{
+	    int pid = waitpid(fork_stat,&wait_stat,0);
+
+	    PRINT("RESUME: %d = %x: exited=%d, wait_stat=%d [%s]\n",
+		wait_stat, wait_stat, WIFEXITED(wait_stat),
+		WEXITSTATUS(wait_stat), GetErrorName(WEXITSTATUS(wait_stat),"?") );
+	    if ( pid == fork_stat )
+		break;
+	}
+
+	for ( co = catch_out; co < co_end; co++ )
+	    if (co->func)
+		co->func(co,2);
+	ResetCatchOutput(catch_out,n_catch_out);
+
+	if (WIFEXITED(wait_stat))
+	    return WEXITSTATUS(wait_stat);
+	if (!silent)
+	    ERROR1(ERR_SYNTAX,"Child teminated with error: %s\n",command);
+	return ERR_SYNTAX;
+    }
+    else
+    {
+	PRINT("CHILD\n");
+
+	CatchOutput_t *co, *co_end = catch_out + n_catch_out;
+	for ( co = catch_out; co < co_end; co++ )
+	{
+	    close(co->pipe_fd[0]);  // close parents (read) end
+	    co->pipe_fd[0] = -1;
+
+	    if ( dup2(co->pipe_fd[1],co->mode) == -1 )
+	    {
+		if (!silent)
+		    ERROR1(ERR_CANT_CREATE,"dup2(,%d) failed: %s\n",
+				co->mode, command );
+		_exit(ERR_CANT_CREATE);
+	    }
+	}
+
+	execvp(command,args);
+	if (!silent)
+	    ERROR1(ERR_CANT_CREATE,"Can't create process: %s\n",command);
+	_exit(ERR_CANT_CREATE);
+    }
+
+    if ( args != local_args )
+	FREE(args);
+    return err;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError CatchOutputLine
+(
+    ccp			command_line,	// command line to execute
+    CatchOutputFunc	stdout_func,	// NULL or function to catch stdout
+    CatchOutputFunc	stderr_func,	// NULL or function to catch stderr
+    void		*user_ptr,	// NULL or user defined parameter
+    bool		silent		// true: suppress error messages
+)
+{
+    SplitArg_t sa;
+    ScanSplitArg(&sa,true,command_line,0,0);
+
+    enumError err = ERR_SYNTAX;
+    if ( sa.argc > 1 )
+	err = CatchOutput( sa.argv[1], sa.argc-2, sa.argv+2,
+				stdout_func, stderr_func, user_ptr, silent );
+    ResetSplitArg(&sa);
+    return err;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			scan sections			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+bool FindSection
+(
+    // search file until next section found
+    //  => read line and store data into 'si'
+    //  => return TRUE, if section found
+
+    SectionInfo_t	*si,		// valid section info
+    char		*buf,		// use this buffer for line scanning
+    uint		buf_size,	// size of 'buf'
+    bool		scan_buf	// true: buffer contains already a valid
+					//       and NULL terminated line
+)
+{
+    DASSERT(si);
+    DASSERT(si->f);
+    DASSERT(buf);
+    DASSERT( buf_size > 10 );
+
+    FreeString(si->section);
+    FreeString(si->path);
+    si->section = si->path = 0;
+    si->index = -1;
+    ResetParamField(&si->param);
+
+    buf_size--;
+    for(;;)
+    {
+	if ( !scan_buf && !fgets(buf,buf_size,si->f) )
+	    break;
+	buf[buf_size] = 0;
+	scan_buf = false;
+
+	char *ptr = buf;
+	while ( *ptr > 0 && *ptr <= ' ' )
+	    ptr++;
+
+	if ( *ptr != '[' )
+	    continue;
+
+	ccp sect = ++ptr;
+	while ( isalnum((int)*ptr) || *ptr == '-' || *ptr == '_' )
+	    ptr++;
+
+	ccp path = ptr;
+	if ( *ptr == '/' )
+	{
+	    *ptr++ = 0;
+	    path = ptr;
+	    while ( *ptr > ' ' && *ptr != ':' && *ptr != ']' )
+		ptr++;
+	}
+
+	int index = -1;
+	if ( *ptr == ':' )
+	{
+	    *ptr++ = 0;
+	    index = str2ul(ptr,&ptr,10);
+	}
+
+	if ( *ptr != ']' )
+	    continue;
+	*ptr = 0;
+
+	si->section = STRDUP(sect);
+	if (*path)
+	    si->path = STRDUP(path);
+	si->index = index;
+	return true;
+    }
+
+    return false;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanSections
+(
+    // return the last returned value by On*()
+
+    FILE	*f,		// source file
+    SectionFunc	OnSection,	// not NULL: call this function for each section
+				// on result: <0: abort, 0:next section, 1:scan param
+    SectionFunc	OnParams,	// not NULL: call this function after param scan
+				// on result: <0: abort, continue
+    void	*user_param	// user defined parameter
+
+)
+{
+    DASSERT(f);
+
+    SectionInfo_t si;
+    memset(&si,0,sizeof(si));
+    si.f = f;
+    si.user_param = user_param;
+    InitializeParamField(&si.param);
+    si.param.free_data = true;
+
+    int stat = 0;
+    char buf[10000];
+    bool scan_buf = false;
+    while (FindSection(&si,buf,sizeof(buf),scan_buf))
+    {
+	scan_buf = false;
+	if (OnSection)
+	{
+	    int stat = OnSection(&si);
+	    if ( stat < 0 )
+		break;
+	    if (!stat)
+		continue;
+	}
+
+	if (!OnParams)
+	    continue;
+
+	// scan param
+
+	while (fgets(buf,sizeof(buf)-1,f))
+	{
+	    buf[sizeof(buf)-1] = 0;
+	    char *ptr = buf;
+	    while ( *ptr > 0 && *ptr <= ' ' )
+		ptr++;
+	    if ( *ptr == '[' )
+	    {
+		scan_buf = true;
+		break;
+	    }
+
+	    //--- scan name
+	    ccp name = ptr;
+	    while ( *ptr > ' ' && *ptr != '=' )
+		ptr++;
+	    char *name_end = ptr;
+
+	    //--- scan param
+	    while ( *ptr == ' ' || *ptr == '\t' )
+		ptr++;
+	    if ( *ptr != '=' )
+		continue;
+	    if ( *++ptr == ' ' ) // skip max 1 space
+		ptr++;
+
+	    ccp value = ptr;
+	    while ( *ptr && *ptr != '\n' && *ptr != '\r' )
+		ptr++;
+
+	    *name_end = *ptr = 0;
+	    InsertParamField(&si.param,name,false,0,STRDUP(value));
+	}
+
+	stat = OnParams(&si);
+	if ( stat < 0 )
+	    break;
+    }
+
+    FreeString(si.section);
+    FreeString(si.path);
+    ResetParamField(&si.param);
+    return stat;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			scan configuration		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError RestoreState
+(
+    const RestoreStateTab_t
+			*table,		// section table, terminated by name==0
+    void		*data,		// file data, modified, terminated by NULL or LF
+    uint		size,		// size of file data
+    RestoreStateLog_t	log_mode,	// print warnings (bit field)
+    FILE		*log_file,	// error file; if NULL use stderr
+    cvp			user_param	// pointer provided by user
+)
+{
+    DASSERT(data||!size);
+    if (!size)
+	return ERR_OK;
+
+    if (!log_file)
+	log_file = stderr;
+
+    char *ptr = data;
+    char *end = ptr + size;
+    if ( !*end && *end != '\n' )
+	end[-1] = 0;
+
+    while ( ptr < end )
+    {
+	//--- search next section
+
+	while ( ptr < end && (uchar)*ptr <= ' ' )
+	    ptr++;
+	if ( *ptr != '[' )
+	{
+	    while ( ptr < end && *ptr && *ptr != '\n' )
+		ptr++;
+	    if ( ptr < end )
+		ptr++;
+	    continue;
+	}
+
+	ccp sect = ++ptr;
+	while ( isalnum((int)*ptr) || *ptr == '-' || *ptr == '_' )
+	    ptr++;
+
+	ccp path = ptr;
+	if ( *ptr == '/' )
+	{
+	    *ptr++ = 0;
+	    path = ptr;
+	    while ( isalnum((int)*ptr) || *ptr == '-' || *ptr == '_' || *ptr == '/' )
+		ptr++;
+	}
+
+	int index = -1;
+	if ( *ptr == ':' )
+	{
+	    *ptr++ = 0;
+	    index = strtoul(ptr,0,10);
+	}
+	*ptr = 0;
+
+	const RestoreStateTab_t *tab;
+	for ( tab = table; tab->name; tab++ )
+	    if (!strcmp(tab->name,sect))
+		break;
+
+	if (!tab->name)
+	{
+	    if ( log_mode & RSL_WARNINGS )
+		fprintf(log_file,"! #RESTORE: Unknown section: %s\n",sect);
+	    continue;
+	}
+
+	TRACE("SECT: [%s/%s:%d]\n",sect,path,index);
+	if (!tab->func) // no need to analyse section
+	    continue;
+
+
+	//--- scan name=value
+
+	RestoreState_t rs;
+	rs.sect		= sect;
+	rs.path		= path;
+	rs.index	= index;
+	rs.user_param	= user_param;
+	rs.user_info	= 0;
+	rs.log_mode	= log_mode;
+	rs.log_file	= log_file;
+	InitializeParamField(&rs.param);
+
+	while ( ptr < end )
+	{
+	    //--- next line
+	    while ( ptr < end && *ptr && *ptr != '\n' )
+		ptr++;
+
+	    //--- skip lines and blanks
+	    while ( ptr < end && (uchar)*ptr <= ' ' )
+		ptr++;
+
+	    if ( *ptr == '[' )
+		break;
+
+	    //--- scan name
+	    ccp name = ptr;
+	    while ( isalnum((int)*ptr) || *ptr == '-' || *ptr == '_' || *ptr == '@' )
+		ptr++;
+	    char *name_end = ptr;
+
+	    //--- scan param
+	    while ( *ptr == ' ' || *ptr == '\t' )
+		ptr++;
+	    if ( *ptr != '=' )
+		continue;
+	    if ( *++ptr == ' ' ) // skip max 1 space
+		ptr++;
+
+	    ccp value = ptr;
+	    while ( (uchar)*ptr >= ' ' || *ptr == '\t' )
+		ptr++;
+
+	    *name_end = *ptr = 0;
+	    InsertParamField(&rs.param,name,false,0,value);
+	}
+
+	#ifdef TEST0
+	{
+	    ParamFieldItem_t *ptr = rs.param.field, *end;
+	    for ( end = ptr + rs.param.used; ptr < end; ptr++ )
+		printf("%4u: %20s = %s|\n",ptr->num,ptr->key,(ccp)ptr->data);
+	}
+	#endif
+
+	tab->func(&rs,tab->user_table);
+	if ( log_mode & RSL_UNUSED_NAMES )
+	{
+	    ParamFieldItem_t *ptr = rs.param.field, *end;
+	    for ( end = ptr + rs.param.used; ptr < end; ptr++ )
+		if (!ptr->num)
+		{
+		    const uint len = strlen((ccp)ptr->data);
+		    if ( len > 20 )
+			fprintf(log_file,"! #RESTORE[%s]: Unused: %s [%u] %.20s...\n",
+				PrintRestoreStateSection(&rs),
+				ptr->key, len, (ccp)ptr->data );
+		    else
+			fprintf(log_file,"! #RESTORE[%s]: Unused: %s [%u] %s\n",
+				PrintRestoreStateSection(&rs),
+				ptr->key, len, (ccp)ptr->data );
+		}
+	}
+	ResetParamField(&rs.param);
+    }
+
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PrintRestoreStateSection ( const RestoreState_t *rs )
+{
+    // print into cyclic buffer
+    DASSERT(rs);
+
+    uint len = strlen(rs->sect) + strlen(rs->path) + 2;
+
+    char index[20];
+    *index = 0;
+    if ( rs->index >= 0 )
+	len += snprintf(index,sizeof(index),":%u",rs->index);
+
+    char *buf = GetCircBuf(len);
+    if (*rs->path)
+	snprintf(buf,len,"%s/%s%s",rs->sect,rs->path,index);
+    else
+	snprintf(buf,len,"%s%s",rs->sect,index);
+
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+ParamFieldItem_t * GetParamField
+(
+    const RestoreState_t *rs,		// valid restore-state structure
+    ccp			name		// name of member
+)
+{
+    DASSERT(rs);
+    DASSERT(name);
+
+    ParamFieldItem_t *it = FindParamField(&rs->param,name);
+    if (it)
+	it->num++;
+    else if ( rs->log_mode & RSL_MISSED_NAMES )
+	fprintf(rs->log_file,"! #RESTORE[%s]: Missed: %s\n",
+		PrintRestoreStateSection(rs), name );
+
+    return it;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int GetParamFieldINT
+(
+    const RestoreState_t *rs,		// valid restore-state structure
+    ccp			name,		// name of member
+    int			not_found	// return this value if not found
+)
+{
+    DASSERT(rs);
+    DASSERT(name);
+
+    ParamFieldItem_t *it = GetParamField(rs,name);
+    return it ? str2l((ccp)it->data,0,10) : not_found;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint GetParamFieldUINT
+(
+    const RestoreState_t *rs,		// valid restore-state structure
+    ccp			name,		// name of member
+    uint		not_found	// return this value if not found
+)
+{
+    DASSERT(rs);
+    DASSERT(name);
+
+    ParamFieldItem_t *it = GetParamField(rs,name);
+    return it ? str2ul((ccp)it->data,0,10) : not_found;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+u64 GetParamFieldS64
+(
+    const RestoreState_t *rs,		// valid restore-state structure
+    ccp			name,		// name of member
+    s64			not_found	// return this value if not found
+)
+{
+    DASSERT(rs);
+    DASSERT(name);
+
+    ParamFieldItem_t *it = GetParamField(rs,name);
+    return it ? str2ll((ccp)it->data,0,10) : not_found;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+u64 GetParamFieldU64
+(
+    const RestoreState_t *rs,		// valid restore-state structure
+    ccp			name,		// name of member
+    u64			not_found	// return this value if not found
+)
+{
+    DASSERT(rs);
+    DASSERT(name);
+
+    ParamFieldItem_t *it = GetParamField(rs,name);
+    return it ? str2ull((ccp)it->data,0,10) : not_found;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+float GetParamFieldFLOAT
+(
+    const RestoreState_t *rs,		// valid restore-state structure
+    ccp			name,		// name of member
+    float		not_found	// return this value if not found
+)
+{
+    DASSERT(rs);
+    DASSERT(name);
+
+    ParamFieldItem_t *it = GetParamField(rs,name);
+    return it ? strtof((ccp)it->data,0) : not_found;
+}
+
+//-----------------------------------------------------------------------------
+
+double GetParamFieldDBL
+(
+    const RestoreState_t *rs,		// valid restore-state structure
+    ccp			name,		// name of member
+    double		not_found	// return this value if not found
+)
+{
+    DASSERT(rs);
+    DASSERT(name);
+
+    ParamFieldItem_t *it = GetParamField(rs,name);
+    return it ? strtod((ccp)it->data,0) : not_found;
+}
+
+//-----------------------------------------------------------------------------
+
+long double GetParamFieldLDBL
+(
+    const RestoreState_t *rs,		// valid restore-state structure
+    ccp			name,		// name of member
+    long double		not_found	// return this value if not found
+)
+{
+    DASSERT(rs);
+    DASSERT(name);
+
+    ParamFieldItem_t *it = GetParamField(rs,name);
+    return it ? strtold((ccp)it->data,0) : not_found;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+int GetParamFieldBUF
+(
+    // returns >=0: length of read data; -1:nothing done (not_found==NULL)
+
+    char		*buf,		// buffer to store result
+    uint		buf_size,	// size of buffer
+
+    const RestoreState_t *rs,		// valid restore-state structure
+    ccp			name,		// name of member
+    EncodeMode_t	decode,		// decoding mode, fall back to OFF
+					// supported: STRING, UTF8, BASE64, BASE64X
+    ccp			not_found	// not NULL: store this value if not found
+)
+{
+    DASSERT(buf);
+    DASSERT(buf_size>1);
+    DASSERT(rs);
+    DASSERT(name);
+
+    ParamFieldItem_t *it = GetParamField(rs,name);
+    if (!it)
+	return not_found ? StringCopyS(buf,buf_size,not_found) - buf : -1;
+
+    return DecodeByMode(buf,buf_size,(ccp)it->data,-1,decode);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+mem_t GetParamFieldMEM
+(
+    // Returns the decoded 'source'. Result is NULL-terminated.
+    // It points either to 'buf' or is alloced (on buf==NULL or to less space)
+    // If alloced (mem.ptr!=buf) => call FreeMem(&mem)
+
+    char		*buf,		// buffer to store result
+    uint		buf_size,	// size of buffer
+
+    const RestoreState_t *rs,		// valid restore-state structure
+    ccp			name,		// name of member
+    EncodeMode_t	decode,		// decoding mode, fall back to OFF
+					// supported: STRING, UTF8, BASE64, BASE64X
+    mem_t		not_found	// not NULL: return this value
+)
+{
+    DASSERT(rs);
+    DASSERT(name);
+
+    ParamFieldItem_t *it = GetParamField(rs,name);
+    return it
+	? DecodeByModeMem(buf,buf_size,(ccp)it->data,-1,decode)
+	: not_found;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////		save + restore config by table		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void DumpStateTable
+(
+    FILE	*f,		// valid output file
+    int		indent,
+    const SaveRestoreTab_t
+		*srt		// list of variables
+)
+{
+    if ( !f || !srt )
+	return;
+
+    indent = NormalizeIndent(indent);
+    for ( ; srt->type != SRT__TERM; srt++ )
+    {
+	if ( srt->type == SRT__IS_LIST )
+	{
+	    if ( srt->name )
+		fprintf(f,"%*s# %s\n",indent,"",srt->name);
+	    else
+		putc('\n',f);
+	}
+	else
+	fprintf(f,"%*s%4u %4u *%-3u %2u %2u %s\n",
+		indent,"",
+		srt->offset, srt->size, srt->n_elem, srt->type, srt->emode,
+		srt->name ? srt->name : "-" );
+    }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void print_scs_name ( FILE *f, int fw, int use_tab, ccp format, ... )
+	__attribute__ ((__format__(__printf__,4,5)));
+
+static void print_scs_name ( FILE *f, int fw, int use_tab, ccp format, ... )
+{
+    va_list arg;
+    va_start(arg,format);
+    const int len = vfprintf(f,format,arg);
+    va_end(arg);
+
+    if (use_tab)
+    {
+	const int tablen = ( use_tab - len ) / 8;
+	fprintf(f,"%.*s= ", tablen<0 ? 0 : tablen, Tabs20 );
+    }
+    else
+	fprintf(f,"%*s= ", len < fw ? fw-len : 0, "" );
+}
+
+//-----------------------------------------------------------------------------
+
+void SaveCurrentStateByTable
+(
+    FILE	*f,		// valid output file
+    cvp		data0,		// valid pointer to source struct
+    const SaveRestoreTab_t
+		*srt,		// list of variables
+    ccp		prefix,		// NULL or prefix for names
+    uint	fw_name		// field width of name, 0=AUTO
+				// tabs are used for multiple of 8 and for AUTO
+)
+{
+    DASSERT(data0);
+    DASSERT(srt);
+    if ( !f || !data0 || !srt )
+	return;
+
+    if (!prefix)
+	prefix = EmptyString;
+    const uint prelen = strlen(prefix);
+
+    if (!fw_name)
+    {
+	const SaveRestoreTab_t *ptr;
+	for ( ptr = srt; ptr->type != SRT__TERM; ptr++ )
+	    if (ptr->name)
+	    {
+		int slen = strlen(ptr->name);
+		switch(srt->type)
+		{
+		    case SRT_STRING_FIELD:
+		    case SRT_PARAM_FIELD:
+			slen += 3;
+			break;
+		}
+
+		if ( fw_name < slen )
+		    fw_name = slen;
+	    }
+	fw_name += prelen;
+	fw_name = (fw_name+7)/8*8;
+    }
+
+    const int use_tab = (fw_name&7) ? 0 : (fw_name/8)*8+7;
+
+    //-------------------------------------------------------------------------
+
+    u64 get_uint ( const u8* data, int idx, const SaveRestoreTab_t *srt )
+    {
+	DASSERT(srt);
+	DASSERT(srt->var);
+
+	switch(srt->size)
+	{
+	    case 1: return ((u8*) (data+srt->offset))[idx];
+	    case 2: return ((u16*)(data+srt->offset))[idx];
+	    case 4: return ((u32*)(data+srt->offset))[idx];
+	    case 8: return ((u64*)(data+srt->offset))[idx];
+	}
+	return 0;
+    }
+
+    //-------------------------------------------------------------------------
+
+    s64 get_int ( const u8* data, int idx, const SaveRestoreTab_t *srt )
+    {
+	DASSERT(srt);
+	DASSERT(srt->var);
+
+	switch(srt->size)
+	{
+	    case 1: return ((s8*) (data+srt->offset))[idx];
+	    case 2: return ((s16*)(data+srt->offset))[idx];
+	    case 4: return ((s32*)(data+srt->offset))[idx];
+	    case 8: return ((s64*)(data+srt->offset))[idx];
+	}
+	return 0;
+    }
+
+    //-------------------------------------------------------------------------
+
+    void save_string ( FILE *f, ccp src, int slen, EncodeMode_t emode )
+    {
+	char buf[4000];
+	mem_t res = EncodeByModeMem(buf,sizeof(buf),src,slen,emode);
+
+	fwrite(res.ptr,1,res.len,f);
+	fputc('\n',f);
+	if ( res.ptr != buf )
+	    FreeMem(&res);
+    }
+
+    //-------------------------------------------------------------------------
+
+    const u8 *data = data0;
+
+    for ( ; srt->type != SRT__TERM; srt++ )
+    {
+      if ( srt->type == SRT__IS_LIST )
+      {
+	if ( srt->name )
+	    fprintf(f,"# %s\n",srt->name);
+	else
+	    putc('\n',f);
+	continue;
+      }
+
+      if (!srt->name)
+	continue;
+
+      if ( srt->type < SRT__IS_LIST )
+	print_scs_name(f,fw_name,use_tab,"%s%s",prefix,srt->name);
+
+      switch(srt->type)
+      {
+	case SRT_BOOL:
+	    if ( srt->n_elem > 1 )
+	    {
+		uint i;
+		for ( i = 0; i < srt->n_elem; i++ )
+		    fprintf(f,"%s%u", i ? "," : "", get_uint(data,i,srt)!=0 );
+		fputc('\n',f);
+	    }
+	    else
+		fprintf(f,"%u\n",get_uint(data,0,srt)!=0);
+	    break;
+
+	case SRT_UINT:
+	    if ( srt->n_elem > 1 )
+	    {
+		uint i;
+		for ( i = 0; i < srt->n_elem; i++ )
+		    fprintf(f,"%s%llu", i ? "," : "", get_uint(data,i,srt) );
+		fputc('\n',f);
+	    }
+	    else
+		fprintf(f,"%llu\n",get_uint(data,0,srt));
+	    break;
+
+	case SRT_HEX:
+	    if ( srt->n_elem > 1 )
+	    {
+		uint i;
+		for ( i = 0; i < srt->n_elem; i++ )
+		    fprintf(f,"%s%#llx", i ? "," : "", get_uint(data,i,srt) );
+		fputc('\n',f);
+	    }
+	    else
+		fprintf(f,"%#llx\n",get_uint(data,0,srt));
+	    break;
+
+	case SRT_INT:
+	    if ( srt->n_elem > 1 )
+	    {
+		uint i;
+		for ( i = 0; i < srt->n_elem; i++ )
+		    fprintf(f,"%s%lld", i ? "," : "", get_int(data,i,srt) );
+		fputc('\n',f);
+	    }
+	    else
+		fprintf(f,"%lld\n",get_int(data,0,srt));
+	    break;
+
+	case SRT_FLOAT:
+	    switch(srt->size)
+	    {
+	     case sizeof(float):
+		{
+		    uint i;
+		    for ( i = 0; i < srt->n_elem; i++ )
+			fprintf(f,"%s%.8g", i ? "," : "",
+				    ((float*)(data+srt->offset))[i] ); 
+		}
+		break;
+
+	     case sizeof(double):
+		{
+		    uint i;
+		    for ( i = 0; i < srt->n_elem; i++ )
+			fprintf(f,"%s%.16g", i ? "," : "",
+				    ((double*)(data+srt->offset))[i] ); 
+		}
+		break;
+
+	     case sizeof(long double):
+		{
+		    uint i;
+		    for ( i = 0; i < srt->n_elem; i++ )
+			fprintf(f,"%s%.20Lg", i ? "," : "",
+				    ((long double*)(data+srt->offset))[i] ); 
+		}
+		break;
+
+	      default:
+		fputs("0.0",f);
+	    }
+	    fputc('\n',f);
+	    break;
+
+	case SRT_XFLOAT:
+	    switch(srt->size)
+	    {
+	     case sizeof(float):
+		{
+		    uint i;
+		    for ( i = 0; i < srt->n_elem; i++ )
+			fprintf(f,"%s%a", i ? "," : "",
+				    ((float*)(data+srt->offset))[i] ); 
+		}
+		break;
+
+	     case sizeof(double):
+		{
+		    uint i;
+		    for ( i = 0; i < srt->n_elem; i++ )
+			fprintf(f,"%s%a", i ? "," : "",
+				    ((double*)(data+srt->offset))[i] ); 
+		}
+		break;
+
+	     case sizeof(long double):
+		{
+		    uint i;
+		    for ( i = 0; i < srt->n_elem; i++ )
+			fprintf(f,"%s%La", i ? "," : "",
+				    ((long double*)(data+srt->offset))[i] ); 
+		}
+		break;
+
+	      default:
+		fputs("0.0",f);
+	    }
+	    fputc('\n',f);
+	    break;
+
+	//-----
+
+	case SRT_STRING_SIZE:
+	    save_string(f,(char*)(data+srt->offset),-1,srt->emode);
+	    break;
+
+	case SRT_STRING_ALLOC:
+	    save_string(f,*(ccp*)(data+srt->offset),-1,srt->emode);
+	    break;
+
+	case SRT_MEM:
+	{
+	    mem_t *mem = (mem_t*)(data+srt->offset);
+	    save_string(f,mem->ptr,mem->len,srt->emode);
+	    break;
+	}
+
+	//-----
+
+	case SRT_STRING_FIELD:
+	{
+	    print_scs_name(f,fw_name,use_tab,"%s%s@n",prefix,srt->name);
+	    const StringField_t *sf = (StringField_t*)(data+srt->offset);
+	    fprintf(f,"%u\n",sf->used);
+
+	    int i;
+	    ccp *ptr = sf->field;
+	    for ( i = 0; i < sf->used; i++, ptr++ )
+	    {
+		print_scs_name(f,fw_name,use_tab,"%s%s@%u",prefix,srt->name,i);
+		save_string(f,*ptr,-1,srt->emode);
+	    }
+	    break;
+	}
+
+	case SRT_PARAM_FIELD:
+	{
+	    print_scs_name(f,fw_name,use_tab,"%s%s@n",prefix,srt->name);
+	    const ParamField_t *pf = (ParamField_t*)(data+srt->offset);
+	    fprintf(f,"%u\n",pf->used);
+
+	    int i;
+	    ParamFieldItem_t *ptr = pf->field;
+	    for ( i = 0; i < pf->used; i++, ptr++ )
+	    {
+		print_scs_name(f,fw_name,use_tab,"%s%s@%u",prefix,srt->name,i);
+		fprintf(f,"%d ",ptr->num);
+		save_string(f,ptr->key,-1,srt->emode);
+	    }
+	    break;
+	}
+      }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void RestoreStateByTable
+(
+    RestoreState_t		*rs,	// info data, can be modified (cleaned after call)
+    void			*data0,	// valid pointer to destination struct
+    const SaveRestoreTab_t	*srt,	// list of variables
+    ccp				prefix	// NULL or prefix for names
+)
+{
+    DASSERT(rs);
+    DASSERT(srt);
+
+    char buf[4000];
+    if (!prefix)
+	prefix = EmptyString;
+
+    for ( ; srt->type != SRT__TERM; srt++ )
+    {
+      if ( srt->type == SRT__IS_LIST || !srt->name )
+	continue;
+
+      const u8 *data = data0;
+
+      if ( srt->type < SRT__IS_LIST )
+	StringCat2S(buf,sizeof(buf),prefix,srt->name);
+
+      switch(srt->type)
+      {
+	case SRT_BOOL:
+	case SRT_UINT:
+	case SRT_HEX:
+	{
+	    ParamFieldItem_t *it = GetParamField(rs,buf);
+	    if (!it)
+		break;
+
+	    char *src = (char*)it->data;
+	    u8 *val = (u8*)(data+srt->offset);
+	    uint i = 0;
+	    while (*src)
+	    {
+		u64 num = str2ull(src,&src,10);
+		switch(srt->size)
+		{
+		    case 1: *(u8*) val = num; break;
+		    case 2: *(u16*)val = num; break;
+		    case 4: *(u32*)val = num; break;
+		    case 8: *(u64*)val = num; break;
+		}
+		if ( ++i == srt->n_elem )
+		    break;
+		val += srt->size;
+		if ( *src == ',' )
+		    src++;
+	    }
+	    break;
+	}
+
+	case SRT_INT:
+	{
+	    ParamFieldItem_t *it = GetParamField(rs,buf);
+	    if (!it)
+		break;
+
+	    char *src = (char*)it->data;
+	    u8 *val = (u8*)(data+srt->offset);
+	    uint i = 0;
+	    while (*src)
+	    {
+		s64 num = str2ll(src,&src,10);
+		switch(srt->size)
+		{
+		    case 1: *(s8*) val = num; break;
+		    case 2: *(s16*)val = num; break;
+		    case 4: *(s32*)val = num; break;
+		    case 8: *(s64*)val = num; break;
+		}
+		if ( ++i == srt->n_elem )
+		    break;
+		val += srt->size;
+		if ( *src == ',' )
+		    src++;
+	    }
+	    break;
+	}
+
+	case SRT_FLOAT:
+	case SRT_XFLOAT:
+	{
+	    ParamFieldItem_t *it = GetParamField(rs,buf);
+	    if (!it)
+		break;
+
+	    char *src = (char*)it->data;
+	    u8 *val = (u8*)(data+srt->offset);
+	    uint i = 0;
+	    while (*src)
+	    {
+		switch(srt->size)
+		{
+		    case sizeof(float):		*(float*)val = strtof(src,&src); break;
+		    case sizeof(double):	*(double*)val = strtod(src,&src); break;
+		    case sizeof(long double):	*(long double*)val = strtold(src,&src); break;
+		}
+		if ( ++i == srt->n_elem )
+		    break;
+		val += srt->size;
+		if ( *src == ',' )
+		    src++;
+	    }
+	    break;
+	}
+
+	//-----
+
+	case SRT_STRING_SIZE:
+	{
+	    char *val = (char*)(data+srt->offset);
+	    mem_t res = GetParamFieldMEM(buf,sizeof(buf),rs,buf,
+						srt->emode,MemByString(val));
+	    StringCopyS(val,srt->size,res.ptr);
+	    if ( res.ptr != buf && res.ptr != val )
+		FreeString(res.ptr);
+	    break;
+	}
+
+	case SRT_STRING_ALLOC:
+	{
+	    ccp *val = (ccp*)(data+srt->offset);
+	    mem_t res = GetParamFieldMEM(buf,sizeof(buf),rs,buf,
+						srt->emode,MemByString0(*val));
+	    if ( res.ptr != *val )
+	    {
+		FreeString(*val);
+		*val = MEMDUP(res.ptr,res.len);
+	    }
+	    else if ( res.ptr != buf )
+		FreeString(res.ptr);
+	    break;
+	}
+
+	case SRT_MEM:
+	{
+	    mem_t *val = (mem_t*)(data+srt->offset);
+	    mem_t res  = GetParamFieldMEM(buf,sizeof(buf),rs,buf,srt->emode,*val);
+	    if ( res.ptr != val->ptr )
+	    {
+		FreeString(val->ptr);
+		*val = res.ptr == buf ? DupMem(res) : res;
+	    }
+	    else if ( res.ptr != buf )
+		FreeString(res.ptr);
+	    break;
+	}
+
+	//-----
+
+	case SRT_STRING_FIELD:
+	{
+	    StringField_t *sf = (StringField_t*)(data+srt->offset);
+	    ResetStringField(sf);
+
+	    snprintf(buf,sizeof(buf),"%s%s@n",prefix,srt->name);
+	    const int n = GetParamFieldINT(rs,buf,0);
+	    int i;
+	    for ( i = 0; i < n; i++ )
+	    {
+		snprintf(buf,sizeof(buf),"%s%s@%u",prefix,srt->name,i);
+		mem_t res = GetParamFieldMEM(buf,sizeof(buf),rs,buf,srt->emode,NullMem);
+		InsertStringField(sf,res.ptr,res.ptr!=buf);
+	    }
+	    break;
+	}
+
+	case SRT_PARAM_FIELD:
+	{
+	    ParamField_t *sf = (ParamField_t*)(data+srt->offset);
+	    ResetParamField(sf);
+
+	    snprintf(buf,sizeof(buf),"%s%s@n",prefix,srt->name);
+	    const int n = GetParamFieldINT(rs,buf,0);
+	    int i;
+	    for ( i = 0; i < n; i++ )
+	    {
+		snprintf(buf,sizeof(buf),"%s%s@%u",prefix,srt->name,i);
+		ParamFieldItem_t *it = GetParamField(rs,buf);
+		if (it)
+		{
+		    char *str;
+		    const int num = strtol((ccp)it->data,&str,10);
+		    if ( *str == ' ' ) // space should always exist
+			str++;
+
+		    mem_t res = DecodeByModeMem(buf,sizeof(buf),str,-1,srt->emode);
+		    InsertParamField(sf,res.ptr,false,num,0);
+		    if ( res.ptr != buf )
+			FreeString(res.ptr);
+		}
+	    }
+	    break;
+	}
+      }
+    }    
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			scan socket type		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+bool ScanSocketInfo
+(
+    // Syntax: [ PREFIX ',' ]... [ PREFIX ':' ] address
+    // returns TRUE, if a protocol or a type is found
+
+    socket_info_t	*si,		// result, not NULL, will be initialized
+    ccp			address,	// address to analyze
+    uint		tolerance	// tolerace:
+					//   0: invalid without prefix
+					//   1: analyse beginning of address part:
+					//	'/' or './' or '../'	-> AF_UNIX
+					//   2: estimate type
+					//	'/' before first ':'	-> AF_UNIX
+					//	1.2 | 1.2.3 | 1.2.3.4	-> AF_INET
+					//	a HEX:IP combi		-> AF_INET6
+					//	domain name		-> AF_INET_ANY
+)
+{
+    DASSERT(si);
+    InitializeSocketInfo(si);
+
+    if (!address)
+	return false;
+
+    while ( *address && (uchar)*address <= ' ' )
+	address++;
+
+    static const KeywordTab_t keytab[] =
+    {
+	{ -1,		"STREAM",	0,		SOCK_STREAM },
+	{ -1,		"DGRAM",	"DATAGRAM",	SOCK_DGRAM },
+
+	{ AF_UNIX,	"UNIX",		"FILE",		-1 },
+	{ AF_UNIX,	"UNIX-TCP",	"FILE-TCP",	SOCK_STREAM },
+	 { AF_UNIX,	"UNIX-STREAM",	"FILE-STREAM",	SOCK_STREAM },
+	{ AF_UNIX,	"UNIX-UDP",	"FILE-UDP",	SOCK_DGRAM },
+	 { AF_UNIX,	"UNIX-DGRAM",	"FILE-DGRAM",	SOCK_DGRAM },
+	 { AF_UNIX,	"UNIX-DATAGRAM","FILE-DATAGRAM",SOCK_DGRAM },
+	{ AF_UNIX,	"UNIX-SEQ",	"FILE-SEQ",	SOCK_SEQPACKET },
+	 { AF_UNIX,	"SEQ",		0,		SOCK_SEQPACKET },
+
+	{ AF_INET_ANY,	"IP",		0,		-1 },
+	{ AF_INET_ANY,	"TCP",		0,		SOCK_STREAM },
+	{ AF_INET_ANY,	"UDP",		0,		SOCK_DGRAM },
+	{ AF_INET_ANY,	"RAW",		0,		SOCK_RAW },
+
+	{ AF_INET,	"IP4",		"IPV4",		-1 },
+	{ AF_INET,	"TCP4",		"TCPV4",	SOCK_STREAM },
+	{ AF_INET,	"UDP4",		"UDPV4",	SOCK_DGRAM },
+	{ AF_INET,	"RAW4",		"RAWV4",	SOCK_RAW },
+
+	{ AF_INET6,	"IP6",		"IPV6",		-1 },
+	{ AF_INET6,	"TCP6",		"TCPV6",	SOCK_STREAM },
+	{ AF_INET6,	"UDP6",		"UDPV6",	SOCK_DGRAM },
+	{ AF_INET6,	"RAW6",		"RAWV6",	SOCK_RAW },
+
+	{0,0,0,0}
+    };
+
+    bool ok = false;
+    int proto = -1;
+    int type  = -1;
+    ccp start = address;
+    for(;;)
+    {
+	char namebuf[10];
+	char *dest = namebuf;
+	ccp ptr = start;
+	while ( dest < namebuf + sizeof(namebuf) - 1
+	    && isalnum((int)*ptr) || *ptr == '-' )
+	{
+	    *dest++ = *ptr++;
+	}
+	if ( ptr == start || *ptr != ',' &&  *ptr != ':' )
+	    break;
+
+	*dest = 0;
+	int abbrev;
+	const KeywordTab_t *k = ScanKeyword(&abbrev,namebuf,keytab);
+	if ( !k || abbrev )
+	    break;
+
+	if ( k->id == AF_INET_ANY ? ( proto == -1 ) : ( k->id >= 0 ) )
+	    proto = k->id;
+	if ( k->opt >= 0 )
+	    type = k->opt;
+
+	noPRINT("%3lld %3lld |%s|%s| -> %d,%d\n",
+		k->id, k->opt, k->name1, k->name2 ? k->name2 : "",
+		proto, type );
+	start = ptr;
+	if ( *start++ == ':' )
+	{
+	    ok = true;
+	    break;
+	}
+    }
+
+    if (!ok)
+    {
+	start = address;
+	proto = -1;
+	type  = -1;
+    }
+
+    if ( proto < 0 && tolerance > 0 )
+    {
+	if ( *start == '/' || !memcmp(start,"./",2) || !memcmp(start,"../",3) )
+	{
+	    proto = AF_UNIX;
+	    goto proto_found;
+	}
+
+	if ( tolerance > 1 )
+	{
+	    ccp colon = strchr(start,':');
+	    if (!colon)
+		colon = start + strlen(start);
+
+	    //--- test for UNIX
+
+	    ccp slash = strchr(start,'/');
+	    if ( slash && slash < colon )
+	    {
+		proto = AF_UNIX;
+		goto proto_found;
+	    }
+
+	    //--- test for IPv4
+
+	    ccp ptr = start;
+	    uint count = 0;
+	    while ( ptr < colon )
+	    {
+		const char ch = *ptr;
+		if ( ch == '.' )
+		    count++;
+		else if ( ch < '0' || ch > '9' )
+		    break;
+		ptr++;
+	    }
+	    if ( ptr == colon && count < 4 )
+	    {
+		proto = AF_INET;
+		if ( count > 0 )
+		    goto proto_found;
+	    }
+
+	    //--- test for IPv6
+
+	    ptr = start;
+	    const bool have_bracket = *ptr == '[';
+	    if (have_bracket)
+		ptr++;
+	    count = 0;
+	    while (*ptr)
+	    {
+		const char ch = *ptr;
+		if ( ch == ':' )
+		    count++;
+		else if ( ch != '.'
+			&& !( ch >= '0' && ch <= '9' )
+			&& !( ch >= 'A' && ch <= 'F' )
+			&& !( ch >= 'a' && ch <= 'f' )
+			)
+		{
+		    break;
+		}
+		ptr++;
+	    }
+	    if ( count > 1 && count < 8 && ( !have_bracket || *ptr == ']' ))
+	    {
+		proto = AF_INET6;
+		goto proto_found;
+	    }
+
+	    //--- test for a domain name
+
+	    ptr = start;
+	    count = 0;
+	    ccp beg_name = ptr;
+	    while ( ptr < colon )
+	    {
+		const int ch = *ptr;
+		if ( ptr > beg_name && ch == '.' )
+		{
+		    count++;
+		    beg_name = ptr+1;
+		}
+		else if ( ptr == beg_name ? !isalpha(ch) : !isalnum(ch) )
+		    break;
+		ptr++;
+	    }
+	    if ( count > 0 && ptr == colon )
+	    {
+		proto = AF_INET_ANY;
+		goto proto_found;
+	    }
+	}
+    }
+
+    if ( proto || type )
+    {
+     proto_found:
+	si->is_valid	= true;
+	si->protocol	= proto;
+	si->type	= type;
+	si->address	= start;
+    }
+    //printf(">>> v=%d {%d,%d}: %s\n",ok,proto,type,start);
+    return si->is_valid;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PrintSocketInfo ( int protocol, int type )
+{
+    switch (protocol)
+    {
+      case AF_UNIX:
+	switch(type)
+	{
+	  case SOCK_STREAM:	return "unix-tcp:";
+	  case SOCK_DGRAM:	return "unix-udp:";
+	  case SOCK_SEQPACKET:	return "unix-seq:";
+	  default:		return "unix:";
+	}
+	break;
+
+      case AF_INET:
+	switch(type)
+	{
+	  case SOCK_STREAM:	return "tcp4:";
+	  case SOCK_DGRAM:	return "udp4:";
+	  case SOCK_RAW:	return "raw4:";
+	  default:		return "ipv4:";
+	}
+	break;
+
+      case AF_INET6:
+	switch(type)
+	{
+	  case SOCK_STREAM:	return "tcp6:";
+	  case SOCK_DGRAM:	return "udp6:";
+	  case SOCK_RAW:	return "raw6:";
+	  default:		return "ipv6:";
+	}
+	break;
+
+      case AF_INET_ANY:
+	switch(type)
+	{
+	  case SOCK_STREAM:	return "tcp:";
+	  case SOCK_DGRAM:	return "udp:";
+	  case SOCK_RAW:	return "raw:";
+	  default:		return "ip:";
+	}
+	break;
+    };
+
+    return "";
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			stat_file_count_t		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+stat_file_count_t stat_file_count = {0};
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint CountOpenFiles()
+{
+    DIR *fdir = opendir("/proc/self/fd");
+    if (fdir)
+    {
+	uint count = 0;
+	for(;;)
+	{
+	    struct dirent *dent = readdir(fdir);
+	    if (!dent)
+		break;
+	    if (dent->d_name[0] != '.' )
+		count++;
+	}
+	closedir(fdir);
+
+	stat_file_count.cur_files = count;
+	if ( stat_file_count.max_files < count )
+	     stat_file_count.max_files = count;
+    }
+
+    return stat_file_count.cur_files;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void RegisterFileId ( int fd )
+{
+    if ( (int)stat_file_count.max_files <= fd )
+	stat_file_count.max_files = fd+1;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void UpdateOpenFiles ( bool count_current )
+{
+    struct rlimit rlim;
+    if (!getrlimit(RLIMIT_NOFILE,&rlim))
+    {
+	stat_file_count.cur_limit = rlim.rlim_cur;
+	stat_file_count.max_limit = rlim.rlim_max;
+    }
+
+    if ( count_current || !stat_file_count.max_files )
+	CountOpenFiles();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint SetOpenFilesLimit ( uint limit )
+{
+    struct rlimit rlim;
+    if (!getrlimit(RLIMIT_NOFILE,&rlim))
+    {
+	rlim.rlim_cur = limit;
+	setrlimit(RLIMIT_NOFILE,&rlim);
+    }
+
+    UpdateOpenFiles(false);
+    return stat_file_count.cur_limit;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PrintOpenFiles ( bool count_current )
+{
+    if (!stat_file_count.cur_limit)
+	UpdateOpenFiles(count_current);
+    else if (count_current)
+	CountOpenFiles();
+
+    return PrintCircBuf("cur=%u, max=%u, limit=%u/%u",
+	stat_file_count.cur_files,
+	stat_file_count.max_files,
+	stat_file_count.cur_limit,
+	stat_file_count.max_limit );
+};
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////				END			///////////////
+///////////////////////////////////////////////////////////////////////////////
+