�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FGIX_INETD%2F'>GIX_INETD</a>/<a href='?path=%2Fbig%2FGIX_INETD%2Fsrc%2F'>src</a>/</p><hr><h3>✏️ Editing: ginetd.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>#include &lt;sys/types.h&gt;
#include &lt;sys/ipc.h&gt;
#include &lt;sys/time.h&gt;
#include &lt;sys/shm.h&gt;
#include &lt;sys/stat.h&gt;
#include &lt;sys/sem.h&gt;
#include &lt;sys/msg.h&gt;
#include &lt;sys/file.h&gt;
#include &lt;sys/wait.h&gt;
#include &lt;sys/sysinfo.h&gt;
#include &lt;sys/socket.h&gt;
#include &lt;sys/ioctl.h&gt;
#include &lt;sys/vfs.h&gt;
#include &lt;stdio.h&gt;
#include &lt;ctype.h&gt;
#include &lt;signal.h&gt;
#include &lt;inttypes.h&gt;
#include &lt;time.h&gt;
#include &lt;errno.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;unistd.h&gt;
#include &lt;dirent.h&gt;
#include &lt;string.h&gt;
#include &lt;poll.h&gt;
#include &lt;strings.h&gt;
#include &lt;sys/time.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;pwd.h&gt;
#include &lt;grp.h&gt;
#include &lt;zlib.h&gt;
#include &lt;stdarg.h&gt;
#include &lt;linux/if_packet.h&gt;
#include &lt;sys/socket.h&gt;
#include &lt;netinet/in.h&gt;
#include &lt;arpa/inet.h&gt;
#include &lt;net/ethernet.h&gt;
#include &lt;netinet/ip.h&gt;
#include &lt;netinet/udp.h&gt;
#include &lt;net/if.h&gt;
#include &lt;netdb.h&gt;
#include &lt;openssl/ssl.h&gt;
#include &quot;gimapd_config.h&quot;
#include &quot;base32.h&quot;
#include &quot;gix_img.h&quot;
#include &quot;sysdefs.h&quot;
#include &quot;webtool.h&quot;
#include &quot;tools.h&quot;

char prefix[1024];

#pragma pack(push,1)
struct gix_udphdr
{
  u_int16_t source;           /* source port */
  u_int16_t dest;           /* destination port */
  u_int16_t len;            /* udp length */
  u_int16_t check;             /* udp checksum */
};
#pragma pack(pop)


#define ROOT_DNS_ENTRY &quot;a.root-servers.net&quot;
#define DNS_PACKET_SIZE 2048

#define DNS_QUERY_TYPE_A     0x01
#define DNS_QUERY_TYPE_NS    0x02
#define DNS_QUERY_TYPE_CNAME 0x05
#define DNS_QUERY_TYPE_SOA   0x06
#define DNS_QUERY_TYPE_MX    0x0F
#define DNS_QUERY_TYPE_TXT   0x10
#define DNS_QUERY_TYPE_AAAA  0x1C

void logger(char *prefix, const char *fmt, ...);
int parse_label(unsigned char *request,int cur_index,unsigned char *label){
        unsigned char len;

        while ( (len = (unsigned char)request[cur_index++]) &gt; 0 ){
                if ( (len &amp; 0xC0) == 0xC0 ){
                        len = (unsigned char)request[cur_index++];
                        // printf(&quot;New-Index: %d\n&quot;);
                        parse_label(request,len,label);
                        return(cur_index);
                }
                strncat(label,&amp;request[cur_index],(int)len);
                strcat(label,&quot;.&quot;);
                cur_index += len;
        }
        return(cur_index);
}


double process_dns(char *server_address){
        int sock;
        int sock_in;
        int retval;
        int id;
        unsigned char request[DNS_PACKET_SIZE];
        unsigned short *_id;
        struct addrinfo hints, *res;
        unsigned char *opcode;
        unsigned char *rcode;
        unsigned short *qcount;
        unsigned short *ancount;
        unsigned short *nscount;
        unsigned short *arcount;
        unsigned short *qtype;
        unsigned short *qclass;
        uint32_t *ttl;
        unsigned short *rdlength;
        time_t start_time;
        time_t end_time;
        struct sockaddr_in socky4;
        struct sockaddr_in6 socky6;
        struct sockaddr *socky;
        char domain_copy[1024];
        char *ptr,*ptr2;
        int cur_index;
        int hd_end;
        int slen;
        char *strtok_hlp;
        struct pollfd fds[1];
	double _start, _end;
	struct timeval start;
	struct timeval end;

	strcpy(domain_copy,ROOT_DNS_ENTRY);
	bzero(request,DNS_PACKET_SIZE);

	_id = (unsigned short *)&amp;request[0];

	id = getpid();
	
	*_id = id;

	cur_index = 2;	
		

       opcode  = &amp;request[cur_index++];
        rcode   = &amp;request[cur_index++];
        qcount  = (unsigned short *)&amp;request[cur_index]; cur_index += 2;
        ancount = (unsigned short *)&amp;request[cur_index]; cur_index += 2;
        nscount = (unsigned short *)&amp;request[cur_index]; cur_index += 2;
        arcount = (unsigned short *)&amp;request[cur_index]; cur_index += 2;

        hd_end = cur_index;

        memset(&amp;hints,0,sizeof(hints));

        hints.ai_family   = AF_UNSPEC;
        hints.ai_socktype = SOCK_DGRAM;
        hints.ai_protocol = IPPROTO_UDP;
        hints.ai_flags    = AI_NUMERICHOST;

        if ( getaddrinfo(server_address,&quot;53&quot;,&amp;hints,&amp;res) != 0 ){
		logger(prefix,&quot;[PROCESS_DNS] GETADDRINFO failed!\n&quot;);
                return(-1.0);
        }

	sock = socket(res-&gt;ai_family, res-&gt;ai_socktype, res-&gt;ai_protocol);
	if ( sock &lt; 0 ){
		logger(prefix,&quot;[PROCESS_DNS] Cannot create socket (%s)\n&quot;,strerror(errno));
		return(-2.0);
	}

	if ( res-&gt;ai_family == AF_INET ){
                socky4.sin_family = AF_INET;
                socky4.sin_addr.s_addr = INADDR_ANY;
                socky4.sin_port = htons(0);
                socky = (struct sockaddr *)&amp;socky4;
                slen  = sizeof(socky4);
        }

        if ( res-&gt;ai_family == AF_INET6 ){
                bzero(&amp;socky6,sizeof(socky6));
                socky6.sin6_family = AF_INET6;
                socky6.sin6_addr   = in6addr_any;
		socky6.sin6_port    = htons(0);
                socky = (struct sockaddr *)&amp;socky6;
                slen  = sizeof(socky6);
        }

	


        if ( bind(sock,socky,slen) &lt; 0 ){
                close(sock);
		logger(prefix,&quot;[PROCESS_DNS] BIND failed! (%s)\n&quot;,strerror(errno));
                return(-3.0);
        }


	*opcode  = htons(0x100); // recursion, normal query, ...everything standard
	*rcode   = 0x00;
	*qcount  = htons(0x01);
	*ancount = htons(0x00);
	*nscount = htons(0x00);
	*arcount = htons(0x00);

	ptr2 = domain_copy;

        while ( (ptr = strtok_r(ptr2,&quot;.&quot;,&amp;strtok_hlp)) != NULL ){
                ptr2 = NULL;
                unsigned char len;
                len = strlen(ptr);
                request[cur_index] = len;
                cur_index++;
                bcopy(ptr,&amp;request[cur_index],(int)len);
                cur_index += (int)len;
        }
        request[cur_index] = 0x00;
        cur_index++;
        qtype  = (unsigned short *)&amp;request[cur_index];
        qclass = (unsigned short *)&amp;request[cur_index+2];

        *qtype  = htons(DNS_QUERY_TYPE_A);
        *qclass = htons(0x01);

        cur_index += 4;
	logger(prefix,&quot;[PROCESS_DNS] Sending request to: [%s]\n&quot;,server_address);

	gettimeofday(&amp;start,NULL);
        if ( res-&gt;ai_family == AF_INET6 ) socky6.sin6_port = htons(53);
        if ( res-&gt;ai_family == AF_INET )  socky4.sin_port = htons(53);
	retval = sendto(sock,request,cur_index,0,res-&gt;ai_addr,res-&gt;ai_addrlen);
	if ( retval &lt; 0 ){
		close(sock);
		logger(prefix,&quot;[PROCESS_DNS] SENDTO failed (%s)\n&quot;,strerror(errno));
		return(-9.0);
	}	

	if ( res-&gt;ai_family == AF_INET  ){ socky = (struct sockaddr *)&amp;socky4; }
	if ( res-&gt;ai_family == AF_INET6 ){ socky = (struct sockaddr *)&amp;socky6; }

		
	while ( 1 ){
		fds[0].fd = sock;
		fds[0].events = POLLIN;
		fds[0].revents = 0;

		gettimeofday(&amp;end,NULL);

		if ( (end.tv_sec - start.tv_sec) &gt; 3 ) break;

		retval = poll(fds,1,2000);
		if ( retval &lt; 0 ){
                	close(sock);
			logger(prefix,&quot;[PROCESS_DNS] REQUEST HAD ERROR! (%s)\n&quot;,strerror(errno));
       		         return(-10.0);
		}
		if ( retval == 0 ){
                	close(sock);
			logger(prefix,&quot;[PROCESS_DNS] REQUEST TIMED OUT\n&quot;);
       		         return(-20.0);
		}
		if ( retval == 1 ){
			logger(prefix,&quot;[PROCESS_DNS] POLL Returned: %d\n&quot;,fds[0].revents);
			slen = sizeof(struct sockaddr);
			retval = recvfrom(sock,request,DNS_PACKET_SIZE,MSG_WAITALL,socky,&amp;slen);
			if ( retval &gt; 4 ){
				char **nsl;
				int dnscount;
				char remote_ip[1024];
				int remote_port;
				int i;
				int q_count, an_count,ns_count, ar_count, q_type, q_class, an_ttl, an_rdlength;
				char label[DNS_PACKET_SIZE];
				if ( *_id != id ){
					logger(prefix,&quot;[PROCESS_DNS] Not our packet %d != %d\n&quot;,id,*_id);
					continue;
				}
				if ( res-&gt;ai_family == AF_INET ){
					remote_port = ntohs(socky4.sin_port);
					inet_ntop(AF_INET,&amp;(socky4.sin_addr),remote_ip,1024);
				}
				if ( res-&gt;ai_family == AF_INET6 ){
					remote_port = ntohs(socky6.sin6_port);
					inet_ntop(AF_INET,&amp;(socky6.sin6_addr),remote_ip,1024);
				}
				q_count  = (int) ntohs(*qcount);
				an_count = (int) ntohs(*ancount);
				ns_count = (int) ntohs(*nscount);
				ar_count = (int) ntohs(*arcount);
				logger(prefix,&quot;[PROCESS_DNS] Packet from [%s]:%d Q_COUNT: %d, AN_COUNT: %d, NS_COUNT: %d\n&quot;,remote_ip,remote_port,q_count,an_count,ns_count);

				for ( i = 0; i &lt; q_count; i++ ){
					unsigned char len;
					bzero(label,DNS_PACKET_SIZE);
					cur_index = parse_label(request,cur_index,label);
					qtype  = (unsigned short *) &amp;request[cur_index]; cur_index+=2;
					qclass = (unsigned short *) &amp;request[cur_index]; cur_index+=2;
					q_type  = ntohs(*qtype);
					q_class = ntohs(*qclass);
					logger(prefix,&quot;[PROCESS_DNS] [Q ]Label: [%s] TYPE: %d, CLASS: %d\n&quot;,label,q_type,q_class);
				}

				if ( an_count &lt; 1 ){
					logger(prefix,&quot;[PROCESS_DNS] Packet from [%s]:%d ...but no answer\n&quot;,remote_ip,remote_port);
					close(sock);
					gettimeofday(&amp;end,NULL);
					_start = ((double)start.tv_sec)* 1000000.0 + ((double)start.tv_usec);
					_end = ((double)end.tv_sec)* 1000000.0 + ((double)end.tv_usec);
						
					logger(prefix,&quot;[PROCESS_DNS] TOTAL processing time: %.02g ms\n&quot;,(_end - _start)/1000.0);
					return((_end - _start)/1000.0 + 1000.0);
						
				}
				// We asume a correct answer...if ancount &gt; 0
				dnscount = 0;
				for ( i = 0; i &lt; an_count; i++ ){
					unsigned char len;
					bzero(label,DNS_PACKET_SIZE);
					cur_index = parse_label(request,cur_index,label);
					qtype    = (unsigned short *) &amp;request[cur_index]; cur_index+=2;
					qclass   = (unsigned short *) &amp;request[cur_index]; cur_index+=2;
					ttl      = (uint32_t *) &amp;request[cur_index]; cur_index+=4;
					rdlength = (unsigned short *) &amp;request[cur_index]; cur_index+=2;
					q_type       = ntohs(*qtype);
					q_class      = ntohs(*qclass);
					an_ttl       = ntohl((unsigned long)*ttl);
					an_rdlength  = ntohs(*rdlength);
					logger(prefix,&quot;[PROCESS_DNS] [AN]Label: [%s] TYPE: %d, CLASS: %d TTL: %d, LENGTH: %d, OFFSET: 0x%04X\n&quot;,label,q_type,q_class,an_ttl,an_rdlength,cur_index);
					if ( q_type == DNS_QUERY_TYPE_A ){
						unsigned char a,b,c,d;
						bzero(label,DNS_PACKET_SIZE);
						/*
						parse_label(request,cur_index,label);
						*/
						a = (unsigned char) request[cur_index];
						b = (unsigned char) request[cur_index+1];
						c = (unsigned char) request[cur_index+2];
						d = (unsigned char) request[cur_index+3];
						sprintf(label,&quot;%d.%d.%d.%d&quot;,a,b,c,d);
						logger(prefix,&quot;[PROCESS_DNS] [AN] NSDNAME: [%s]\n&quot;,label);
						nsl[dnscount] = strdup(label);
						if ( strlen(nsl[dnscount]) &gt; 0 ){
							char *ptr;
							ptr = nsl[dnscount];
							if ( ptr[strlen(ptr)-1] == &#039;.&#039; ) ptr[strlen(ptr)-1] = &#039;\0&#039;;
						}
						dnscount++;
					}
					cur_index += an_rdlength;
				}
	
				break;

			}
		}
	
	}


		

	close(sock);
	gettimeofday(&amp;end,NULL);

	_start = ((double)start.tv_sec)* 1000000.0 + ((double)start.tv_usec);
	_end = ((double)end.tv_sec)* 1000000.0 + ((double)end.tv_usec);
		
	logger(prefix,&quot;[PROCESS_DNS] TOTAL processing time: %.02g ms\n&quot;,(_end - _start)/1000.0);
	return((_end - _start)/1000.0);
	
}



u_int16_t ip_checksum(u_int8_t *data, int len){
	u_int32_t sum;
	u_int32_t hhigh;
	u_int16_t low;
	u_int16_t high;
	u_int16_t val;
	int i;

	sum = 0x0000;

	for ( i = 0; i &lt; len; i += 2 ){
		low = (u_int16_t)data[i];
		high = (u_int16_t)data[i+1];
		sum += low + (high &lt;&lt; 8);
	}
	hhigh = sum &gt;&gt; 16;
	sum &amp;= 0xffff;
	sum += hhigh;
	

	sum ^= 0xffff;

	return((u_int16_t)sum);
}


#define udp_checksum(a,b,c) _udp_checksum(__FILE__,__LINE__,(a),(b),(c))

u_int16_t _udp_checksum(char *file, int line, u_int8_t *data, int len, struct ip *ip){
       int i;
        u_int16_t sum1;
        u_int32_t sum2;
        u_int16_t helper;
        u_int16_t helper2;
        u_int16_t x_udp_checksum;
	u_int16_t udp_len;
	u_int8_t  pseudoheader[12];
        sum1 = 0x0000;
        sum2 = 0x00000000;
	bzero(pseudoheader,12);
	memcpy(pseudoheader,&amp;(ip-&gt;ip_src.s_addr),4);
	memcpy(&amp;pseudoheader[4],&amp;(ip-&gt;ip_dst.s_addr),4);
	pseudoheader[9] = ip-&gt;ip_p;
	udp_len = htons((short)len);
	memcpy(&amp;pseudoheader[10],&amp;udp_len,2);
	// logger(prefix,&quot;[%s:%d] Calculating Checksum for %d Bytes [0x%08lX] UDP-Length: %d\n&quot;,file,line,len,data,ntohs(udp_len));

	for ( i = 0; i &lt; 12; i+=2 ){
                helper = (pseudoheader[i] &lt;&lt; 8) + pseudoheader[i+1];
                sum1 += helper;
                sum2 += helper;
	}
        for ( i = 0; i &lt; len; i+=2 ){
                helper = (data[i] &lt;&lt; 8) + data[i+1];
                sum1 += helper;
                sum2 += helper;
        }
        while ( (( sum2 &amp; 0xFFFF0000 ) &gt;&gt; 16) ){
                u_int16_t highpart;
                highpart = (( sum2 &amp; 0xFFFF0000 ) &gt;&gt; 16);
                sum2 = highpart + sum1;
                sum1 += highpart;
        }
        x_udp_checksum = ~sum1;
	return(htons(x_udp_checksum));
}






int _lock_file(char *file, int line, char *filepath){
        int fd;
        fd = open(filepath,O_RDWR | O_CREAT, 0600);
        if ( fd &lt; 0 ) return(-1);
	logger(prefix,&quot;LOCKING [%s] (%d) (%s:%d)\n&quot;,filepath,fd,file,line);

        if ( flock(fd,LOCK_EX) &lt; 0 ){
                close(fd);
                return(-1);
        }
        return(fd);
}

void _unlock_file(char *file, int line, int fd){
        flock(fd,LOCK_UN);
        close(fd);
	logger(prefix,&quot;UNLOCKING  (%d) (%s:%d)\n&quot;,fd,file,line);
}

#define lock_file(a)	_lock_file(__FILE__,__LINE__,(a))
#define unlock_file(a)  _unlock_file(__FILE__,__LINE__,(a))

struct dhcp_features {
	char is_dedicated; // 0...was a new request broadcast, 1...was a dedicated 
	char wants_dhcp; // 0...A simple BOOTP-REQUEST
	char wants_broadcast; //  Reply not on unicast, but multicast (Use same address as was used originally --&gt; also on ethernet level)

	u_int8_t *class_id; // Option 60 value
	u_int8_t class_id_len;
	u_int8_t *hostname; // Option 12 value
	u_int8_t hostname_len;
	u_int8_t source_mac[6];
	u_int8_t source_ip[4];

	u_int8_t o_wants_optlist[256]; // Max
	u_int8_t o_wants_optlist_len;
};

int check_option_set(struct dhcp_features *fett,u_int8_t option){
	int index;
	for ( index = 0; index &lt; fett-&gt;o_wants_optlist_len; index++ ){
		if ( option == fett-&gt;o_wants_optlist[index] ) return(1);
	}	
	return(0);
}

void free_features(struct dhcp_features *fett){
	if ( fett-&gt;class_id != NULL ){ free(fett-&gt;class_id); fett-&gt;class_id = NULL; }
	if ( fett-&gt;hostname != NULL ){ free(fett-&gt;hostname); fett-&gt;hostname = NULL; }
}


#pragma pack(push,1)
struct bootp_packet {
	u_int8_t op;
	u_int8_t htype;
	u_int8_t hlen;
	u_int8_t hops;
	u_int32_t xid;
	u_int16_t secs;
	u_int16_t flags;
	u_int32_t ciaddr;
	u_int32_t yiaddr;
	u_int32_t siaddr;
	u_int32_t giaddr;
	u_int8_t chaddr[16];
	u_int8_t sname[64];
	u_int8_t file[128];
};
#pragma pack(pop) 

u_int8_t ether_bcast[6];
u_int8_t dhcp_magic_cookie[] = { 0x63, 0x82, 0x53, 0x63 };
u_int8_t ethernet_broadcast[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
u_int8_t ip_broadcast[] = { 255, 255, 255, 255 };

#define DEFAULT_GIX_INETD_UPDATESERVER &quot;2001:4100:0:65::1&quot;
char *GIX_INETD_UPDATESERVER;
#define GIX_INETD_VERSION &quot;GIX-INETD-ADMIN-SERVER 3.41-TDS&quot;
#define CONFIG_FILE &quot;/big/GIX_INETD/conf/ginetd.conf&quot;
#define LOG_FILE    &quot;/big/GIX_INETD/logs/ginetd.log&quot;
#define INETD_KEY   0xCAFE1970
#define INETD_KEY2 0xDAFE1970
#define INETD_OPTIONS 0xAFFE1970
#define MAX_CONNS   8192
#define MAX_BACKLOG 10
#define MAX_TFTP_SESSIONS 64
#define TFTP_TIMEOUT 10 // 60 seconds timeout for TFTP-Request
#define TFTP_DEFAULT_PACKSIZE 512 
// #define TFTP_DEFAULT_PACKSIZE 20000 
#define TFTP_MAX_PACKSIZE 1408
// #define TFTP_MAX_PACKSIZE 20000


char *dump_mac_addr(u_int8_t *mac){
	static char retval[32];
	sprintf(retval,&quot;%02X:%02X:%02X:%02X:%02X:%02X&quot;, mac[0], mac[1], mac[2], mac[3],mac[4], mac[5]);
	return(retval);
}

#define DHCP_T_DISCOVER 1
#define DHCP_T_OFFER    2
#define DHCP_T_REQUEST  3
#define DHCP_T_DECLINE  4
#define DHCP_T_ACK      5
#define DHCP_T_NACK     6
#define DHCP_T_RELEASE  7
#define DHCP_T_INFORM   8

char *dhcp_message_type(int typ){
	static char retval[64];
	switch (typ ){
		case 1:
			return(&quot;DHCPDISCOVER&quot;);	
			break;
		case 2:
			return(&quot;DHCPOFFER&quot;);	
			break;
		case 3:
			return(&quot;DHCPREQUEST&quot;);	
			break;
		case 4:
			return(&quot;DHCPDECLINE&quot;);	
			break;
		case 5:
			return(&quot;DHCPACK&quot;);	
			break;
		case 6:
			return(&quot;DHCPNAK&quot;);	
			break;
		case 7:
			return(&quot;DHCPRELEASE&quot;);	
			break;
		case 8:
			return(&quot;DHCPINFORM&quot;);	
			break;
		case 9:
			return(&quot;DHCPFORCERENEW&quot;);	
			break;
		case 10:	
			return(&quot;DHCPLEASEQUERY&quot;);
			break;
		case 11:	
			return(&quot;DHCPLEASEUNASSIGNED&quot;);
			break;
		case 12:	
			return(&quot;DHCPLEASEUNKNOWN&quot;);
			break;
		case 13:	
			return(&quot;DHCPLEASEACTIVE&quot;);
			break;
		case 14:	
			return(&quot;DHCPBULKLEASEQUERY&quot;);
			break;
		case 15:	
			return(&quot;DHCPLEASEQUERYDONE&quot;);
			break;
		case 16:	
			return(&quot;DHCPACTIVELEASEQUERY&quot;);
			break;
		case 17:	
			return(&quot;DHCPLEASEQUERYSTATUS&quot;);
			break;
		case 18:	
			return(&quot;DHCPTLS&quot;);
			break;
		default:
			sprintf(retval,&quot;UNKNOWN(%d)&quot;,typ);
			break;
	}	
	return(retval);
}



struct sockaddr_in *check_valid_ipv4(char *addr,short port,int sock_type){
	static struct sockaddr_in socky;
	struct addrinfo *res;
	struct addrinfo hints;
	char _port[12];
	bzero(&amp;hints,sizeof(hints));
	hints.ai_family   = AF_INET;
#ifdef AI_NUMERICHOST
	hints.ai_flags    = AI_NUMERICHOST;
#endif
	hints.ai_socktype = sock_type;
	sprintf(_port,&quot;%d&quot;,(int)port);
	if ( getaddrinfo(addr,_port,&amp;hints,&amp;res)  ){
		return(NULL);
	} else {
		memcpy( (void *)&amp;socky,(void *)res-&gt;ai_addr,res-&gt;ai_addrlen);
		freeaddrinfo(res);	
		return(&amp;socky);
	}
}
struct sockaddr_in6 *check_valid_ipv6(char *addr,short port,int sock_type ){
	static struct sockaddr_in6 socky;
	struct addrinfo *res;
	struct addrinfo hints;
	char _port[12];
	bzero(&amp;hints,sizeof(hints));
	hints.ai_family   = AF_INET6;
#ifdef AI_NUMERICHOST
	hints.ai_flags    = AI_NUMERICHOST;
#endif
	hints.ai_socktype = sock_type;
	sprintf(_port,&quot;%d&quot;,(int)port);
	if ( getaddrinfo(addr,_port,&amp;hints,&amp;res)  ){
		return(NULL);
	} else {
		memcpy( (void *)&amp;socky,(void *)res-&gt;ai_addr,res-&gt;ai_addrlen);
		freeaddrinfo(res);	
		return(&amp;socky);
	}
}



#ifdef IPV6_V6ONLY
#define FRAG_SIZE st.f_frsize
#else
#define FRAG_SIZE 4096
#endif

#define CTRL_SHM 0xAFFE0000


#define MAX_BUFFER 4096


void start_tftp();
void start_dhcp();

int shm_id;
int webserver_pid;
int entries;
int global_index;
int connection_index;
int semid;
int semid2;
int shmid_options;
int msg_id;

char my_hostname[1024];

#define TFTP_REQUEST_READ  0
#define TFTP_REQUEST_WRITE 1


struct gix_inetd_options *gix_options = NULL;


#define DHCP_IP_LEASES_FILE &quot;/big/GIX_INETD/run/dhcp_leases.v4&quot;
#define DHCP_IP_LEASES_FILE_TMP &quot;/big/GIX_INETD/run/dhcp_leases.v4~&quot;
#define DHCP_IP_LEASES_FILE_LOCK &quot;/big/GIX_INETD/run/dhcp_leases.lock&quot;
#define DHCP_IP6_LEASES_FILE &quot;/big/GIX_INETD/run/dhcp_leases.v6&quot;
#define DHCP_IP6_LEASES_FILE_TMP &quot;/big/GIX_INETD/run/dhcp_leases.v6~&quot;
#define DHCP_IP6_LEASES_FILE_LOCK &quot;/big/GIX_INETD/run/dhcp_leases.lock&quot;

#define DHCP_MAX_OPTSIZE 1024

#pragma pack(push,1)
struct dhcp_ip_file_entry_t {
	u_int8_t mac[6];
	u_int8_t ip[4];
	time_t created;
	time_t changed;
	time_t expiry;
	u_int16_t optlen;
	u_int8_t opts[];

};
struct dhcp_ip6_file_entry_t {
	u_int8_t mac[6];
	struct sockaddr_in6 ip6;
	time_t created;
	time_t changed;
	time_t expiry;
	u_int16_t optlen;
	u_int8_t opts[];
};
#pragma pack(pop)

// No locking is required here, as there is only a single process accessing the files :-)

/* All return 0 on success */

int dhcp_check_ipv4_valid_lease(int idx, u_int8_t *mac, u_int32_t *retaddr);

struct dhcp_ip_file_entry_t *dhcp_ip_get_entry(u_int8_t *mac_addr){
	FILE *in;
	int lockfd;
	static struct dhcp_ip_file_entry_t *entry;
	static u_int8_t dummy_buffer[sizeof(struct dhcp_ip_file_entry_t) + DHCP_MAX_OPTSIZE];
	entry = (struct dhcp_ip_file_entry_t *) dummy_buffer;
#ifdef DEBUG_DHCP
	logger(prefix,&quot;[%s] GETTING ENTRY for [%s]\n&quot;,DHCP_IP_LEASES_FILE,dump_mac_addr(mac_addr));
#endif
	lockfd = lock_file(DHCP_IP_LEASES_FILE_LOCK);
	in = fopen(DHCP_IP_LEASES_FILE,&quot;r&quot;);
	if ( in == NULL ){ unlock_file(lockfd);  return(NULL); }
	while ( fread(entry,sizeof(struct dhcp_ip_file_entry_t),1,in) == 1 ){
		int totlen;
		totlen = ((int) entry-&gt;optlen) + sizeof(struct dhcp_ip_file_entry_t);
		if ( entry-&gt;optlen ){
			fread(entry-&gt;opts,entry-&gt;optlen,1,in); // Read options
		}
		if ( memcmp(mac_addr,entry-&gt;mac,6) == 0 ){
			fclose(in);
			unlock_file(lockfd);
			return(entry);
		}
	}
	fclose(in);
	unlock_file(lockfd);
	return(NULL);	
}
int dhcp_ip_invalid_entry(u_int8_t *mac_addr,time_t new_timeout){
	struct stat st;
	FILE *in;
	FILE *out;
	int lockfd;
	int entries, cleaned, success;
	struct dhcp_ip_file_entry_t *dummy;
	u_int8_t dummy_buffer[sizeof(struct dhcp_ip_file_entry_t) + DHCP_MAX_OPTSIZE];
	dummy = (struct dhcp_ip_file_entry_t *) dummy_buffer;
#ifdef DEBUG_DHCP
	logger(prefix,&quot;[%s] REFRESHING ENTRY for [%s] (Timeout: %ld)\n&quot;,DHCP_IP_LEASES_FILE,dump_mac_addr(mac_addr),new_timeout);
#endif
	lockfd = lock_file(DHCP_IP_LEASES_FILE_LOCK);
	if ( stat(DHCP_IP_LEASES_FILE,&amp;st) == 0 ){ // File exists
		in = fopen(DHCP_IP_LEASES_FILE,&quot;r&quot;);
		if ( in == NULL ){
			logger(prefix,&quot;FATAL: Cannot open leases-file [%s] for reading\n&quot;,DHCP_IP_LEASES_FILE);
			unlock_file(lockfd);
			return(-2);
		}
		unlink(DHCP_IP_LEASES_FILE_TMP);
		out = fopen(DHCP_IP_LEASES_FILE_TMP,&quot;w&quot;);
		if ( out == NULL ){
			fclose(in);
			logger(prefix,&quot;FATAL: Cannot open leases-file [%s] for writing\n&quot;,DHCP_IP_LEASES_FILE_TMP);
			unlock_file(lockfd);
			return(-3);
		}
		entries = 0;
		cleaned = 0;
		success = 0;
		while ( fread(dummy,sizeof(struct dhcp_ip_file_entry_t),1,in) == 1 ){
			int totlen;
			totlen = ((int) dummy-&gt;optlen) + sizeof(struct dhcp_ip_file_entry_t);
			if ( dummy-&gt;optlen ){
				fread(dummy-&gt;opts,dummy-&gt;optlen,1,in); // Read options
			}
			entries++;
			if ( memcmp(mac_addr,dummy-&gt;mac,6) == 0 ){
				success = 1;
				bzero(dummy-&gt;mac,6); // Make invalid...so the IP is locked for the interval of the new timeout MAC is 00:00:00:00:00:00
				dummy-&gt;changed = time(NULL);
				dummy-&gt;expiry  = time(NULL) + new_timeout;
			}
			if ( dummy-&gt;expiry &lt; time(NULL) ){
				cleaned++;
#ifdef DEBUG_DHCP
				logger(prefix,&quot;Kicking out expired entry for [%s]\n&quot;,dump_mac_addr(dummy-&gt;mac));
#endif
			} else {
				fwrite(dummy,totlen,1,out);
			}
		}
		fclose(in);
		fclose(out);
#ifdef DEBUG_DHCP
		logger(prefix,&quot;Kept %d of %d entries. Update_successfull: %d\n&quot;,entries - cleaned, entries,success);
#endif
		unlink(DHCP_IP_LEASES_FILE);
		rename(DHCP_IP_LEASES_FILE_TMP,DHCP_IP_LEASES_FILE);
		unlock_file(lockfd);
		return(success);
	} else {
		unlock_file(lockfd);
		return(-1); // No file...no entry :-)
	}
	
}
int dhcp_ip_refresh_entry(u_int8_t *mac_addr,time_t new_timeout){
	struct stat st;
	FILE *in;
	FILE *out;
	int lockfd;
	int entries, cleaned, success;
	struct dhcp_ip_file_entry_t *dummy;
	u_int8_t dummy_buffer[sizeof(struct dhcp_ip_file_entry_t) + DHCP_MAX_OPTSIZE];
	dummy = (struct dhcp_ip_file_entry_t *) dummy_buffer;
#ifdef DEBUG_DHCP
	logger(prefix,&quot;[%s] REFRESHING ENTRY for [%s] (Timeout: %ld)\n&quot;,DHCP_IP_LEASES_FILE,dump_mac_addr(mac_addr),new_timeout);
#endif
	lockfd = lock_file(DHCP_IP_LEASES_FILE_LOCK);
	if ( stat(DHCP_IP_LEASES_FILE,&amp;st) == 0 ){ // File exists
		in = fopen(DHCP_IP_LEASES_FILE,&quot;r&quot;);
		if ( in == NULL ){
			logger(prefix,&quot;FATAL: Cannot open leases-file [%s] for reading\n&quot;,DHCP_IP_LEASES_FILE);
			unlock_file(lockfd);
			return(-2);
		}
		unlink(DHCP_IP_LEASES_FILE_TMP);
		out = fopen(DHCP_IP_LEASES_FILE_TMP,&quot;w&quot;);
		if ( out == NULL ){
			fclose(in);
			logger(prefix,&quot;FATAL: Cannot open leases-file [%s] for writing\n&quot;,DHCP_IP_LEASES_FILE_TMP);
			unlock_file(lockfd);
			return(-3);
		}
		entries = 0;
		cleaned = 0;
		success = 0;
		while ( fread(dummy,sizeof(struct dhcp_ip_file_entry_t),1,in) == 1 ){
			int totlen;
			totlen = ((int) dummy-&gt;optlen) + sizeof(struct dhcp_ip_file_entry_t);
			if ( dummy-&gt;optlen ){
				fread(dummy-&gt;opts,dummy-&gt;optlen,1,in); // Read options
			}
			entries++;
			if ( memcmp(mac_addr,dummy-&gt;mac,6) == 0 ){
				success = 1;
				dummy-&gt;changed = time(NULL);
				dummy-&gt;expiry  = time(NULL) + new_timeout;
			}
			if ( dummy-&gt;expiry &lt; time(NULL) ){
				cleaned++;
#ifdef DEBUG_DHCP
				logger(prefix,&quot;Kicking out expired entry for [%s]\n&quot;,dump_mac_addr(dummy-&gt;mac));
#endif
			} else {
				fwrite(dummy,totlen,1,out);
			}
		}
		fclose(in);
		fclose(out);
#ifdef DEBUG_DHCP
		logger(prefix,&quot;Kept %d of %d entries. Update_successfull: %d\n&quot;,entries - cleaned, entries,success);
#endif
		unlink(DHCP_IP_LEASES_FILE);
		rename(DHCP_IP_LEASES_FILE_TMP,DHCP_IP_LEASES_FILE);
		unlock_file(lockfd);
		return(success);
	} else {
		unlock_file(lockfd);
		return(-1); // No file...no entry :-)
	}
	
}

int dhcp_ip_add_entry(struct dhcp_ip_file_entry_t *req){
	FILE *in;
	FILE *out;
	struct stat st;
	int entries;
	int cleaned;
	int lockfd;
	u_int8_t dummy_buffer[sizeof(struct dhcp_ip_file_entry_t) + DHCP_MAX_OPTSIZE];
	struct dhcp_ip_file_entry_t *dummy;
#ifdef DEBUG_DHCP
	logger(prefix,&quot;[%s] ADDING ENTRY for [%s]\n&quot;,DHCP_IP_LEASES_FILE,dump_mac_addr(req-&gt;mac));
#endif
	dummy = (struct dhcp_ip_file_entry_t *) dummy_buffer;
	if ( dhcp_ip_get_entry(req-&gt;mac) != NULL ) return(-1); // Entry already exists
	lockfd = lock_file(DHCP_IP_LEASES_FILE_LOCK);
	if ( stat(DHCP_IP_LEASES_FILE,&amp;st) == 0 ){ // File exists
		in = fopen(DHCP_IP_LEASES_FILE,&quot;r&quot;);
		if ( in == NULL ){
			logger(prefix,&quot;FATAL: Cannot open leases-file [%s] for reading\n&quot;,DHCP_IP_LEASES_FILE);
			unlock_file(lockfd);
			return(-2);
		}
		unlink(DHCP_IP_LEASES_FILE_TMP);
		out = fopen(DHCP_IP_LEASES_FILE_TMP,&quot;w&quot;);
		if ( out == NULL ){
			fclose(in);
			logger(prefix,&quot;FATAL: Cannot open leases-file [%s] for writing\n&quot;,DHCP_IP_LEASES_FILE_TMP);
			unlock_file(lockfd);
			return(-3);
		}
		entries = 0;
		cleaned = 0;
		while ( fread(dummy,sizeof(struct dhcp_ip_file_entry_t),1,in) == 1 ){
			int totlen;
			totlen = ((int) dummy-&gt;optlen) + sizeof(struct dhcp_ip_file_entry_t);
			if ( dummy-&gt;optlen ){
				fread(dummy-&gt;opts,dummy-&gt;optlen,1,in); // Read options
			}
			entries++;
			if ( dummy-&gt;expiry &lt; time(NULL) ){
				cleaned++;
#ifdef DEBUG_DHCP
				logger(prefix,&quot;Kicking out expired entry for [%s]\n&quot;,dump_mac_addr(dummy-&gt;mac));
#endif
			} else {
				fwrite(dummy,totlen,1,out);
			}
		}
		fclose(in);
#ifdef DEBUG_DHCP
		logger(prefix,&quot;Kept %d of %d entries\n&quot;,entries - cleaned, entries);
#endif
	} else {
		unlink(DHCP_IP_LEASES_FILE_TMP);
		out = fopen(DHCP_IP_LEASES_FILE_TMP,&quot;w&quot;);
		if ( out == NULL ){
			logger(prefix,&quot;FATAL: Cannot open leases-file [%s] for writing\n&quot;,DHCP_IP_LEASES_FILE_TMP);
			unlock_file(lockfd);
			return(-3);
		}
	}
	fwrite(req,sizeof(struct dhcp_ip_file_entry_t),1,out);
	if ( req-&gt;optlen ){
		fwrite(req-&gt;opts,req-&gt;optlen,1,out);
	}
	fclose(out);
	unlink(DHCP_IP_LEASES_FILE);
	rename(DHCP_IP_LEASES_FILE_TMP,DHCP_IP_LEASES_FILE);
	unlock_file(lockfd);
	return(0);	
}
int dhcp_ip_remove_entry_by_ip(u_int8_t *ip_addr){
	FILE *in;
	FILE *out;
	int lockfd;
	struct dhcp_ip_file_entry_t *dummy;
	u_int8_t dummy_buffer[sizeof(struct dhcp_ip_file_entry_t) + DHCP_MAX_OPTSIZE];
	 dummy = (struct dhcp_ip_file_entry_t *) dummy_buffer;
#ifdef DEBUG_DHCP
	char ip_helper[64];
	inet_ntop(AF_INET,ip_addr,ip_helper,64);
	logger(prefix,&quot;[%s] REMOVING ENTRY for [%s]\n&quot;,DHCP_IP_LEASES_FILE,ip_helper);
#endif
	lockfd = lock_file(DHCP_IP_LEASES_FILE_LOCK);
	in = fopen(DHCP_IP_LEASES_FILE,&quot;r&quot;);
	if ( in == NULL ){ unlock_file(lockfd);  return(0); }// Emtpy file :-)
	unlink(DHCP_IP_LEASES_FILE_TMP);
	out = fopen(DHCP_IP_LEASES_FILE_TMP,&quot;w&quot;);
	if ( out == NULL ){
		fclose(in);
		logger(prefix,&quot;FATAL: Cannot open leases-file [%s] for writing\n&quot;,DHCP_IP_LEASES_FILE_TMP);
		unlock_file(lockfd);
		return(-1);
	}		
	while ( fread(dummy,sizeof(struct dhcp_ip_file_entry_t),1,in) == 1 ){
		int totlen;
		totlen = ((int) dummy-&gt;optlen) + sizeof(struct dhcp_ip_file_entry_t);
		if ( dummy-&gt;optlen ){
			fread(dummy-&gt;opts,dummy-&gt;optlen,1,in); // Read options
		}
		
		if ( memcmp(ip_addr,dummy-&gt;ip,4) == 0 || dummy-&gt;expiry &lt; time(NULL) ){
#ifdef DEBUG_DHCP
			logger(prefix,&quot;Kicking out expired/matching entry for [%s]\n&quot;,dump_mac_addr(dummy-&gt;mac));
#endif
		} else {
			fwrite(dummy,totlen,1,out);
		}
	}
	fclose(in);
	fclose(out);
	unlink(DHCP_IP_LEASES_FILE);	
	rename(DHCP_IP_LEASES_FILE_TMP,DHCP_IP_LEASES_FILE);
	unlock_file(lockfd);
	return(0);	
}

int dhcp_ip_remove_entry_by_mac(u_int8_t *mac_addr){
	FILE *in;
	FILE *out;
	int lockfd;
	struct dhcp_ip_file_entry_t *dummy;
	u_int8_t dummy_buffer[sizeof(struct dhcp_ip_file_entry_t) + DHCP_MAX_OPTSIZE];
	 dummy = (struct dhcp_ip_file_entry_t *) dummy_buffer;
#ifdef DEBUG_DHCP
	logger(prefix,&quot;[%s] REMOVING ENTRY for [%s]\n&quot;,DHCP_IP_LEASES_FILE,dump_mac_addr(mac_addr));
#endif
	lockfd = lock_file(DHCP_IP_LEASES_FILE_LOCK);
	in = fopen(DHCP_IP_LEASES_FILE,&quot;r&quot;);
	if ( in == NULL ){ unlock_file(lockfd); return(0); }// Emtpy file :-)
	unlink(DHCP_IP_LEASES_FILE_TMP);
	out = fopen(DHCP_IP_LEASES_FILE_TMP,&quot;w&quot;);
	if ( out == NULL ){
		fclose(in);
		logger(prefix,&quot;FATAL: Cannot open leases-file [%s] for writing\n&quot;,DHCP_IP_LEASES_FILE_TMP);
		unlock_file(lockfd);
		return(-1);
	}		
	while ( fread(dummy,sizeof(struct dhcp_ip_file_entry_t),1,in) == 1 ){
		int totlen;
		totlen = ((int) dummy-&gt;optlen) + sizeof(struct dhcp_ip_file_entry_t);
		if ( dummy-&gt;optlen ){
			fread(dummy-&gt;opts,dummy-&gt;optlen,1,in); // Read options
		}
		if ( memcmp(mac_addr,dummy-&gt;mac,6) == 0 || dummy-&gt;expiry &lt; time(NULL) ){
#ifdef DEBUG_DHCP
			logger(prefix,&quot;Kicking out expired/matching entry for [%s]\n&quot;,dump_mac_addr(dummy-&gt;mac));
#endif
		} else {
			fwrite(dummy,totlen,1,out);
		}
	}
	fclose(in);
	fclose(out);
	unlink(DHCP_IP_LEASES_FILE);	
	rename(DHCP_IP_LEASES_FILE_TMP,DHCP_IP_LEASES_FILE);
	unlock_file(lockfd);
	return(0);	
}


#define MAX_DHCP_INTERFACES 32
#define MAX_DHCP_BOOTFILES  128
#define MAX_DHCP_HOSTS	4096
#define MAX_DHCP_DENY_MACS	1024
#define MAX_DHCP_DNS_SERVERS 8

#define DHCP_DEFAULT_PORT_IN  67
#define DHCP_DEFAULT_PORT_OUT 68
#define DHCP_DEFAULT_LEASE_TIME 21600 // 6 hours

struct dhcp_interface_config {

	int index; // Index of interface in if_config-list
	time_t leasetime; 
	u_int8_t mac[6];
	int socket;
	int send_socket;
	struct sockaddr_ll saddr_l;

	struct sockaddr_in ip_me;
	struct sockaddr_in ip_router;
	struct sockaddr_in ip_netmask;
	struct sockaddr_in ip_broadcast;
	struct sockaddr_in ip_range_start;
	struct sockaddr_in ip_range_end;
	char ip_default_bootimage[1024];
	char ip_domain[256];
	char ip_tftp_server[256]; // FQDN or hostname
	struct sockaddr_in ip_nameserver[MAX_DHCP_DNS_SERVERS];
	int ip_nameservers;
	unsigned short ip_port_in;  
	unsigned short ip_port_out; 
	char ip_default_optlist[256];
	int ip_default_optlist_len;

	struct sockaddr_in6 ip6_me;
	struct sockaddr_in6 ip6_router;
	int ip6_prefixlen;
	struct sockaddr_in6 ip6_range_start;
	struct sockaddr_in6 ip6_range_end;
	char ip6_default_bootimage[1024];
	char ip6_domain[256];
	char ip6_tftp_server[256]; // FQDN or hostname
	struct sockaddr_in6 ip6_nameserver[MAX_DHCP_DNS_SERVERS];
	int ip6_nameservers;
	unsigned short ip6_port_in;  
	unsigned short ip6_port_out; 
	char ip6_default_optlist[256];
	int ip6_default_optlist_len;
};

/*
 * [PXEClient:Arch:00000:UNDI:002001]...
 */
void  _send_udp_response_ip(char *file, int line, int idx,u_int8_t  dhcp_type, struct dhcp_features *features,struct bootp_packet *bootp, struct sockaddr_in *found_ip, char *bootfile);

#define send_udp_response_ip(idx, dhcp_type, features, bootp, found_ip, bootfile) _send_udp_response_ip(__FILE__,__LINE__,(idx), (dhcp_type), (features), (bootp), (found_ip), (bootfile))

struct dhcp_bootfile_config {
	char def;         // If no matching architecture can be found...use this bootfile 1
	char bootimage[256];
	char class_id[128];
};

struct dhcp_host_config {
	struct ether_addr mac;  // 48 Bits of network-address
	struct sockaddr_in ip_addr;
	struct sockaddr_in6 ip6_addr;
	char bootfile[512];
	char ip_default_optlist[256];
	int ip_default_optlist_len;
	char ip6_default_optlist[256];
	int ip6_default_optlist_len;
};

struct dhcp_deny_config {
	struct ether_addr mac;  // 48 Bits of network-address, which are ignored by this DHCP-Server
};


struct tftp_request {
	int packsize;
	char kind_request;
	char active;
	time_t started;
	time_t lastaction;
	char ipname[1024];
	int port;
	int addr_family;
	char filename[1024];
	size_t offset;	
	size_t cur_packet;	
	size_t fullsize;
	int sock;
	int fd;
	int options;
};

struct gix_inetd_options {
	int debug;

	char have_own_dns[1024];
	char tftp_enabled;
	int tftp_requests_read;
	int tftp_requests_write;
	char tftp_readonly;
	char tftp_root[1024];
	int tftp_port;
	int tftp_pid;
	struct tftp_request tr[MAX_TFTP_SESSIONS];

	char dhcp_enabled;
	struct dhcp_interface_config dhcp_interface[MAX_DHCP_INTERFACES];
	struct dhcp_bootfile_config dhcp_bootfile[MAX_DHCP_BOOTFILES];
	struct dhcp_host_config dhcp_host[MAX_DHCP_HOSTS];
	struct dhcp_deny_config dhcp_deny[MAX_DHCP_DENY_MACS];
	int  dhcp_interfaces;
	int  dhcp_bootfiles;
	int  dhcp_hosts;
	int  dhcp_denials;
	int  dhcp_pid;
};






struct interface_config *if_config;
int if_count;




u_int8_t *get_my_mac(char *iname){
	static u_int8_t retval[6];
	int i;
	for ( i = 0; i &lt; if_count; i++ ){
		if ( if_config[i].addrtype == AF_PACKET &amp;&amp; strcmp(if_config[i].ethname,iname) == 0 ){
			sscanf(if_config[i].addr,&quot;%02X:%02X:%02X:%02X:%02X:%02X&quot;,
				&amp;retval[0], &amp;retval[1], &amp;retval[2], &amp;retval[3], &amp;retval[4], &amp;retval[5]);
			return(retval);
		}
	}
	return(NULL);
}


#define TEST_PING  1
#define TEST_HTTP  2
#define TEST_HTTPS 3
#define TEST_POP3  4
#define TEST_SMTP  5


char *get_interface_address(char *ifname, int addrfamily){
	int i;
	for ( i = 0; i &lt; if_count; i++ ){
		if ( if_config[i].addrtype == addrfamily &amp;&amp; strcmp(ifname,if_config[i].ethname) == 0 ) return(if_config[i].addr);
	}

	return(&quot;&quot;);
}




char *get_diskname(char *dev){
	static char retval[32];
	char copy[1024];
	char *help;
	char *ptr;
	int r_major, r_minor;
	FILE *fp;
	char buf[1024];


	if ( *dev == &#039;/&#039; ){ // A path...we look in /etc/fstab
		fp = fopen(&quot;/etc/fstab&quot;,&quot;r&quot;);
		if ( fp == NULL ) return(&quot;n.a.&quot;);
		while ( fgets(buf,1024,fp) != NULL ){
			help = buf;
			ptr = strtok_r(buf,&quot;\t \r\n&quot;,&amp;help);
			if ( ptr == NULL ) continue;
			if ( strncmp(ptr,&quot;/dev/&quot;,5) == 0 ) ptr += 5;
			strcpy(retval,ptr);
			ptr = strtok_r(NULL,&quot;\t \r\n&quot;,&amp;help);
			if ( ptr == NULL ) continue;
			if ( strcmp(ptr,dev) == 0 ){
				fclose(fp);
				return(retval);
			}

		}
		fclose(fp);
		return(&quot;n.a.&quot;);
	}


	strcpy(copy,dev);
	help = copy;
	ptr = strtok_r(copy,&quot;: \t\r\n&quot;,&amp;help);
	if ( ptr == NULL ) return(&quot;n.A.&quot;);	
	r_major = atoi(ptr);
	ptr = strtok_r(NULL,&quot;: \t\r\n&quot;,&amp;help);
	if ( ptr == NULL ) return(&quot;N.a.&quot;);	
	r_minor = atoi(ptr);
	
	fp = fopen(&quot;/proc/diskstats&quot;,&quot;r&quot;);
	if ( fp == NULL ) return(&quot;N.A.&quot;);
	while ( fgets(buf,1024,fp) != NULL ){
		int major, minor;
		char *ptr;
		help = buf;
		ptr = strtok_r(buf,&quot;\t \r\n&quot;,&amp;help);
		if ( ptr == NULL ) continue;
		major = atoi(ptr);
		ptr = strtok_r(NULL,&quot;\t \r\n&quot;,&amp;help);
		if ( ptr == NULL ) continue;
		minor = atoi(ptr);
		ptr = strtok_r(NULL,&quot;\t \r\n&quot;,&amp;help);
		if ( ptr == NULL ) continue;
		if ( major == r_major &amp;&amp; minor == r_minor ){
			strcpy(retval,ptr);
			fclose(fp);
			return(retval);
		}
	}
	fclose(fp);

	return(&quot;n.a.&quot;);
}



struct test_info {
	int test_kind;
	char remote_name[1024];
	char url[1024];
	int port;
	int addr_family; // AF_INET, AT_INET6
	
	
};

char *convert_bytes(double inp,char *prefix){
	static char retval[1024];

	sprintf(retval,&quot;%d&amp;nbsp;%s&quot;,(int)inp,prefix);
	if ( inp &gt; 1024.0 ) sprintf(retval,&quot;%.02f&amp;nbsp;k%s&quot;,inp/1024.0,prefix);
	if ( inp &gt; (1024.0*1024.0) ) sprintf(retval,&quot;%.02f&amp;nbsp;M%s&quot;,inp/(1024.0*1024.0),prefix);
	if ( inp &gt; (1024.0*1024.0*1024.0) ) sprintf(retval,&quot;%.02f&amp;nbsp;G%s&quot;,inp/(1024.0*1024.0*1024.0),prefix);
	if ( inp &gt; (1024.0*1024.0*1024.0*1024.0) ) sprintf(retval,&quot;%.02f&amp;nbsp;T%s&quot;,inp/(1024.0*1024.0*1024.0*1024.0),prefix);
	return(retval);
}


struct fsinfo {
	char path[1024];
};

struct ethinfo {
	char ifname[64];
	char if_mac[128];
	char if_ipv4[64];
	char if_ipv6[256];
	struct timeval stamp1;	
	struct timeval stamp2;	

	long long bytes_receive_1;
	long long bytes_receive_2;
	char bytes_receive_t[64];
	double bytes_receive_sec;
	char bytes_receive_sec_t[64];

	long long packets_receive_1;
	long long packets_receive_2;
	char packets_receive_t[64];
	double packets_receive_sec;
	char packets_receive_sec_t[64];

	long long error_receive_1;
	long long error_receive_2;
	char error_receive_t[64];
	double error_receive_sec;
	char error_receive_sec_t[64];

	long long drop_receive_1;
	long long drop_receive_2;
	char drop_receive_t[64];
	double drop_receive_sec;
	char drop_receive_sec_t[64];

	long long bytes_transmit_1;
	long long bytes_transmit_2;
	char bytes_transmit_t[64];
	double bytes_transmit_sec;
	char bytes_transmit_sec_t[64];

	long long packets_transmit_1;
	long long packets_transmit_2;
	char packets_transmit_t[64];
	double packets_transmit_sec;
	char packets_transmit_sec_t[64];

	long long error_transmit_1;
	long long error_transmit_2;
	char error_transmit_t[64];
	double error_transmit_sec;
	char error_transmit_sec_t[64];

	long long drop_transmit_1;
	long long drop_transmit_2;
	char drop_transmit_t[64];
	double drop_transmit_sec;
	char drop_transmit_sec_t[64];

	long long colls_1;
	long long colls_2;
	char colls_t[64];
	double colls_sec;
	char colls_sec_t[64];

	double timestamp_calc;
};


struct process_info {
	int pid;
	int ppid;
	char program[256];
	unsigned long vmsize;
	char vmtext[32];
	long priority;
	long nice;
	unsigned long utime;
	unsigned long stime;
	struct timeval stamp;
	unsigned long utime2; // After sleeping 0.5 secs --&gt; Check ticks again
	unsigned long stime2; // After sleeping 0.5 secs --&gt; Check ticks again
	struct timeval stamp2; // To get the exact 0.5 seconds :-)
	time_t ptime;
	time_t starttime;
	double cpu_usage;
	long num_threads;
	long rss;
	int cpu;
};







char *gix_display_uptime(time_t starttime,char *pathname, char *buf){
        struct stat st;
        time_t tim;
        int seconds;

        if ( starttime == 0 &amp;&amp; pathname == NULL){
                // We want system uptime
                struct sysinfo sys;
                sysinfo(&amp;sys);
                seconds   = sys.uptime;
                // r_seconds = sys.uptime;
        } else {
                if ( pathname != NULL ){
                        if ( stat(pathname,&amp;st) != 0 ){
                                tim = time(NULL);
                                seconds = 0;
                        } else {
                                seconds = time(NULL) - st.st_mtime;
                        }
                } else {
                        seconds = time(NULL) - starttime;
                }
        }
        strcpy(buf,&quot;&quot;);
        if ( seconds &gt; (365 * 24 * 3600) ){
                if ( seconds / (365 * 24 * 3600) == 1 )
                        sprintf(&amp;buf[strlen(buf)],&quot;%d year &quot;,seconds / (365 * 24 * 3600) );
                else
                        sprintf(&amp;buf[strlen(buf)],&quot;%d years &quot;,seconds / (365 * 24 * 3600) );
                seconds -= (seconds / (365 * 24 * 3600)) * (365 * 24 * 3600);
        }
        if ( seconds &gt; (7 * 24 * 3600) ){
                if ( seconds / (7 * 24 * 3600)  == 1 )
                        sprintf(&amp;buf[strlen(buf)],&quot;%d week &quot;,seconds / (7 * 24 * 3600) );
                else
                        sprintf(&amp;buf[strlen(buf)],&quot;%d weeks &quot;,seconds / (7 * 24 * 3600) );
                seconds -= (seconds / (7 * 24 * 3600)) * (7 * 24 * 3600);
        }
        if ( seconds &gt; ( 24 * 3600) ){
                if ( seconds / (24 * 3600)  == 1 )
                        sprintf(&amp;buf[strlen(buf)],&quot;%d day &quot;,seconds / (24 * 3600) );
                else
                        sprintf(&amp;buf[strlen(buf)],&quot;%d days &quot;,seconds / (24 * 3600) );
                seconds -= (seconds / (24 * 3600)) * (24 * 3600);
        }
        if ( seconds &gt; (  3600) ){
                if ( seconds / 3600  == 1 )
                        sprintf(&amp;buf[strlen(buf)],&quot;%d hour &quot;,seconds / ( 3600) );
                else
                        sprintf(&amp;buf[strlen(buf)],&quot;%d hours &quot;,seconds / ( 3600) );
                seconds -= (seconds / ( 3600)) * ( 3600);
        }
        if ( seconds &gt; (  60) ){
                if ( (seconds / 60) == 1 )
                        sprintf(&amp;buf[strlen(buf)],&quot;%d minute &quot;,seconds / ( 60) );
                else
                        sprintf(&amp;buf[strlen(buf)],&quot;%d minutes &quot;,seconds / ( 60) );
                seconds -= (seconds / ( 60)) * ( 60);
        }
        if ( seconds == 1 )
                sprintf(&amp;buf[strlen(buf)],&quot;%d second&quot;,seconds );
        else
                sprintf(&amp;buf[strlen(buf)],&quot;%d seconds&quot;,seconds );
        return(buf);

}



struct connection {
	int sock;
	int pid;
	int cpid; // Child-PID i.e.: The program executed
	char source[128];
	char target[128];
	unsigned  port;
	unsigned  t_port;
	time_t created;
	time_t lastin;
};

struct server {
        unsigned short port;
        time_t timeout;
	time_t data_timeout;
        char cmdline[1024];
        int max_conns;
        int pid;
	unsigned short family;  // AF_INET or AF_INET6
	time_t reset;
	int connections;
	int total_count;
	struct connection co[MAX_CONNS];
};

char *month_name[] = { &quot;Jan&quot;, &quot;Feb&quot;, &quot;Mar&quot;, &quot;Apr&quot;, &quot;May&quot;, &quot;Jun&quot;, &quot;Jul&quot;, &quot;Aug&quot;, &quot;Sep&quot;, &quot;Oct&quot;, &quot;Nov&quot;, &quot;Dec&quot; };
char *wday_name[]  = { &quot;Sun&quot;, &quot;Mon&quot;, &quot;Tue&quot;, &quot;Wed&quot;, &quot;Thu&quot;, &quot;Fri&quot;, &quot;Sat&quot; };


char *ctime_o(time_t *tim, char *retbuf){
        struct tm tm;

        gmtime_r(tim,&amp;tm);

        sprintf(retbuf,&quot;%s, %d %s %04d %02d:%02d:%02d GMT&quot;,
                wday_name[tm.tm_wday], tm.tm_mday, month_name[tm.tm_mon], tm.tm_year + 1900,
                tm.tm_hour, tm.tm_min, tm.tm_sec);
        return(retbuf);
}



struct server *servlist;



void logger(char *prefix, const char *fmt, ...){
	char p[102400]; 
	struct stat st;
	FILE *log;
	va_list ap;
	struct timeval tv;
	struct tm _tm;
	struct tm *tm;
	char datestamp[512];
	gettimeofday(&amp;tv,NULL);
	tm = localtime_r(&amp;tv.tv_sec,&amp;_tm);



	sprintf(datestamp,&quot;[%04d-%02d-%02d %02d:%02d:%02d.%06d]{%d} (%s)&quot;,
		tm-&gt;tm_year + 1900, tm-&gt;tm_mon + 1, tm-&gt;tm_mday,
		tm-&gt;tm_hour, tm-&gt;tm_min, tm-&gt;tm_sec, tv.tv_usec,
		getpid(), prefix == NULL ? &quot;NULL&quot; : prefix );

	va_start(ap,fmt);
	vsnprintf(p,102400,fmt,ap);
	va_end(ap);

	log = fopen(LOG_FILE,&quot;a&quot;);
	if ( log == NULL ) return;
	// while ( flock(fileno(log),LOCK_EX)  &amp;&amp; errno == EINTR );
	fprintf(log,&quot;%s %s&quot;,datestamp,p);
	fflush(log);	
	// while ( flock(fileno(log),LOCK_UN)  &amp;&amp; errno == EINTR );
	fclose(log);
#ifndef DEBUG_DHCP
	if ( stat(LOG_FILE,&amp;st) == 0 &amp;&amp; st.st_size &gt; (10 * 1024 * 1024 )){
		char newname[1024];
		sprintf(newname,&quot;%s_%04d-%02d-%02d_%02d_%02d_%02d&quot;,LOG_FILE,tm-&gt;tm_year + 1900, tm-&gt;tm_mon + 1, tm-&gt;tm_mday, tm-&gt;tm_hour, tm-&gt;tm_min, tm-&gt;tm_sec);
		rename(LOG_FILE,newname);
	}	
#endif	
}

void init_defaults_dhcp(struct dhcp_interface_config *interface){
		u_int8_t *macaddr;
		interface-&gt;ip_port_in   = (unsigned short) DHCP_DEFAULT_PORT_IN;
		interface-&gt;ip_port_out  = (unsigned short) DHCP_DEFAULT_PORT_OUT;
		interface-&gt;ip6_port_in  = (unsigned short) DHCP_DEFAULT_PORT_IN;
		interface-&gt;ip6_port_out = (unsigned short) DHCP_DEFAULT_PORT_OUT;
		interface-&gt;leasetime    = DHCP_DEFAULT_LEASE_TIME;
		macaddr = get_my_mac(if_config[interface-&gt;index].ethname);
		if ( macaddr == NULL ){
			logger(prefix,&quot;WARNING: Cannot get MAC-Address for interface [%s]\n&quot;,if_config[interface-&gt;index].ethname);
		} else {
			memcpy(interface-&gt;mac,macaddr,6);	
			logger(prefix,&quot;INFO: MAC-Address of interface [%s] is [%s]\n&quot;,if_config[interface-&gt;index].ethname,dump_mac_addr(interface-&gt;mac));
		}
}

int _gzip_string(char *file, int line, char *in, char *out){
	FILE *tmp;
	gzFile gz;
	int newfd;
	int ori_size;
	int retval;
	struct stat st;

	ori_size = strlen(in);
	tmp = tmpfile();
	if ( tmp == NULL ) return(-1);
	gz = gzdopen(fileno(tmp),&quot;w&quot;);
	if ( gz == NULL ){ fclose(tmp); return(-2); }
	retval = gzwrite(gz,in,ori_size);
	if ( retval != ori_size ){ fclose(tmp); return(-3); }
	newfd = dup(fileno(tmp));	
	gzclose(gz);
	if ( fstat(newfd,&amp;st) ){ close(newfd); return(-4); }
	bzero(out,st.st_size + 1);	
	if ( lseek(newfd,(off_t)0,SEEK_SET) == (off_t) -1 ){
		close(newfd); 
		return(-5);
	}
	if ( read(newfd,out,st.st_size) != st.st_size ){
		close(newfd); 
		return(-6);
	}
	close(newfd);
	logger(prefix,&quot;GZIP(%s:%d): [%d] --&gt; [%d]\n&quot;,file,line,strlen(in),st.st_size);
	return(st.st_size);
}

#define gzip_string(a,b) _gzip_string(__FILE__,__LINE__,(a),(b))


int _m_kill(char *file, int line, int pid, int sig){
	// logger(prefix,&quot;[%s: %d] KILLER PROCESS(%d) --&gt; %d, Signal: %d\n&quot;,file,line,getpid(),pid,sig);
	if ( pid ) kill(pid,sig);
}

#define m_kill(a,b) _m_kill(__FILE__,__LINE__,(a),(b))

static int comparer(const void *_p1, const void *_p2){
	struct process_info *p1;
	struct process_info *p2;
	unsigned long time1,time2;

	p1 = (struct process_info *)_p1;
	p2 = (struct process_info *)_p2;

	if ( p1-&gt;cpu_usage != p2-&gt;cpu_usage ){
		return((int) ((p2-&gt;cpu_usage - p1-&gt;cpu_usage) * 100.0) );
	} else {
		return(p2-&gt;ptime - p1-&gt;ptime);
	}


}
static int comparer_eth(const void *_p1, const void *_p2){
	struct ethinfo *p1;
	struct ethinfo *p2;

	p1 = (struct ethinfo *)_p1;
	p2 = (struct ethinfo *)_p2;
	return(strcmp(p1-&gt;ifname,p2-&gt;ifname));
}

void send_valid_header(FILE *ss, char *referer){
	time_t tim;
	char dater[1024];

	tim = time(NULL);
	fprintf(ss,&quot;HTTP/1.1 200 OK\r\n&quot;);
	if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
	fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
	fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
	fprintf(ss,&quot;WWW-Authenticate: Basic realm=\&quot;GIX-INETD-Admin\&quot;\r\n&quot;);
	fprintf(ss,&quot;Connection: close\r\n&quot;);
	fprintf(ss,&quot;Content-Type: text/plain\r\n\r\n&quot;);
	return;
}


struct socket_info {
	char local_addr[256];
	char remote_addr[256];
	unsigned int local_port;	
	unsigned int remote_port;	
	int family;
	int state;
	unsigned long inode;
	unsigned short timer_kind;
	unsigned long timer_value;
	int uid;
	int pid;
	int protocol;
};

char *procnet[] = { &quot;/proc/net/tcp&quot; , &quot;/proc/net/tcp6&quot;, &quot;/proc/net/udp&quot;, &quot;/proc/net/udp6&quot;, &quot;/proc/net/unix&quot;,  NULL };


char *get_ipv4(char *addr){
	static char raddr[256];
	unsigned int a;
	unsigned int b;
	unsigned int c;
	unsigned int d;
	if ( sscanf(addr,&quot;%02X%02X%02X%02X&quot;,&amp;a,&amp;b,&amp;c,&amp;d) != 4 ){
		return(&quot;0.0.0.0&quot;);
	} else {
		sprintf(raddr,&quot;%d.%d.%d.%d&quot;,d,c,b,a);
		return(raddr);
	}
}

#define SOCK6_ADDR socky.sin6_addr.s6_addr

char *get_ipv6(char *addr){
	unsigned int addrlist[16];
	static char raddr[256];
	struct sockaddr_in6 socky;
	if ( sscanf(addr,&quot;%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X&quot;,
		&amp;addrlist[3], &amp;addrlist[2], &amp;addrlist[1], &amp;addrlist[0],
		&amp;addrlist[7], &amp;addrlist[6], &amp;addrlist[5], &amp;addrlist[4],
		&amp;addrlist[11], &amp;addrlist[10], &amp;addrlist[9], &amp;addrlist[8],
		&amp;addrlist[15], &amp;addrlist[14], &amp;addrlist[13], &amp;addrlist[12]) != 16 ){
		return(&quot;invalid&quot;);
	} else {
		int i;
		for ( i = 0; i &lt; 16; i ++ ){
			SOCK6_ADDR[i] = (unsigned char) addrlist[i];
		}
		bzero(raddr,256);
		/*
		sprintf(raddr,&quot;%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X&quot;,
			SOCK6_ADDR[0],SOCK6_ADDR[1],SOCK6_ADDR[2],SOCK6_ADDR[3],
			SOCK6_ADDR[4],SOCK6_ADDR[5],SOCK6_ADDR[6],SOCK6_ADDR[7],
			SOCK6_ADDR[8],SOCK6_ADDR[9],SOCK6_ADDR[10],SOCK6_ADDR[11],
			SOCK6_ADDR[12],SOCK6_ADDR[13],SOCK6_ADDR[14],SOCK6_ADDR[15]);
		*/
		inet_ntop(AF_INET6,&amp;(socky.sin6_addr),raddr,256);	
		return(raddr);
	}
			
}

struct socket_info *get_socket_info(unsigned long inode, int rpid){
	static struct socket_info si;
	unsigned char local[256];
	unsigned char remote[256];
	unsigned char _state[16];
	unsigned int local_port;
	unsigned int remote_port;
	unsigned long timer_value;
	unsigned int timer_kind;
	unsigned long f_inode;
	int uid; 
	int state;
	int fi;
	FILE *fp;
	char buf[1024];

	bzero(&amp;si,sizeof( si));
	for ( fi = 0; procnet[fi] != NULL; fi++ ){
		fp = fopen(procnet[fi],&quot;r&quot;);
		if ( fp == NULL ){
			logger(&quot;SOCKINFO&quot;,&quot;WARNING(%s:%d): Cannot open [%s]\n&quot;,__FILE__,__LINE__,procnet[fi]);
			return(NULL);
		}	
		while ( fgets(buf,1024,fp) != NULL ){
			char *ptr;
			char *help;
			help = buf;
			bzero(local,sizeof(local));
			bzero(remote,sizeof(remote));
			bzero(_state,sizeof(_state));
			state = 0;
			local_port = 0;	
			remote_port = 0;	
			f_inode = 0;	
			timer_value = 0;	
			timer_kind = 0;	
			if ( strcmp(procnet[fi],&quot;/proc/net/udp&quot;) == 0 || strcmp(procnet[fi],&quot;/proc/net/udp6&quot;) == 0 ) {
				ptr = strtok_r(buf,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // INDEX
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // LOCAL
				strcpy(local,ptr);
				ptr = &amp;local[strlen(local)-1]; 
				while ( ptr &gt; (char *)&amp;local[0] &amp;&amp; *ptr != &#039;:&#039; ) ptr--;
				if ( *ptr != &#039;:&#039; ) continue; // Headline is skipped
				*ptr = &#039;\0&#039;;
				ptr++;
				if ( sscanf(ptr,&quot;%04X&quot;,&amp;local_port) != 1 ) continue;
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // REMOTE
				strcpy(remote,ptr);
				ptr = &amp;remote[strlen(remote)-1]; 
				while ( ptr &gt; (char *)&amp;remote[0] &amp;&amp; *ptr != &#039;:&#039; ) ptr--;
				if ( *ptr != &#039;:&#039; ) continue; // Headline is skipped
				*ptr = &#039;\0&#039;;
				ptr++;
				if ( sscanf(ptr,&quot;%04X&quot;,&amp;remote_port) != 1 ) continue;
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // STATE
				strcpy(_state,ptr);
				sscanf(_state,&quot;%02X&quot;,&amp;state);
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // TX-Q, RX-Q
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // TM-&gt;WHEN
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // RET
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // UID
				uid = atoi(ptr);
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // TIMEOUT
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // INODE
				f_inode = atol(ptr);
			}
			if ( strcmp(procnet[fi],&quot;/proc/net/unix&quot;) == 0 ){
				ptr = strtok_r(buf,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // NUM
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // REF
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // PROT
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // FLAGS
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // TYPE
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // State
				if ( sscanf(ptr,&quot;%02X&quot;,&amp;state) != 1 ) continue;
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // Inode
				f_inode = atol(ptr);
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // Inode
				strcpy(local,ptr);
			}
			if ( strcmp(procnet[fi],&quot;/proc/net/tcp&quot;) == 0 || strcmp(procnet[fi],&quot;/proc/net/tcp6&quot;) == 0 ) {
				ptr = strtok_r(buf,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // INDEX
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // LOCAL
				strcpy(local,ptr);
				ptr = &amp;local[strlen(local)-1]; 
				while ( ptr &gt; (char *)&amp;local[0] &amp;&amp; *ptr != &#039;:&#039; ) ptr--;
				if ( *ptr != &#039;:&#039; ) continue; // Headline is skipped
				*ptr = &#039;\0&#039;;
				ptr++;
				if ( sscanf(ptr,&quot;%04X&quot;,&amp;local_port) != 1 ) continue;
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // REMOTE
				strcpy(remote,ptr);
				ptr = &amp;remote[strlen(remote)-1]; 
				while ( ptr &gt; (char *)&amp;remote[0] &amp;&amp; *ptr != &#039;:&#039; ) ptr--;
				if ( *ptr != &#039;:&#039; ) continue; // Headline is skipped
				*ptr = &#039;\0&#039;;
				ptr++;
				if ( sscanf(ptr,&quot;%04X&quot;,&amp;remote_port) != 1 ) continue;
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // STATE
				strcpy(_state,ptr);
				sscanf(_state,&quot;%02X&quot;,&amp;state);
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // NIX
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // TIMER
				if ( sscanf(ptr,&quot;%02X:%08lX&quot;,&amp;timer_kind,&amp;timer_value) != 2 ) continue;
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // SOMETHING
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // UID
				uid = atoi(ptr);
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // TIMEOUT
				ptr = strtok_r(NULL,&quot; \t\r\n&quot;,&amp;help);
				if ( ptr == NULL ) continue; // INODE
				f_inode = atol(ptr);
			}
			if ( f_inode == inode ){
				logger(&quot;SOCKINFO&quot;,&quot;[%ld] Local: [%s]:%d Remote: [%s]:%d State: [%s] %d Timer: [%d] Value: [%ld] UID: %d Inode: %ld\n&quot;,inode,local,local_port,remote,remote_port,_state,state,timer_kind,timer_value,uid,f_inode);	
				if ( strcmp(procnet[fi],&quot;/proc/net/tcp6&quot;) == 0 ){
					// Convert IPv4
					si.family = AF_INET6;
					si.state = state;
					si.uid = uid;
					si.timer_value = timer_value;
					si.timer_kind = timer_kind;
					si.local_port = local_port;					
					si.remote_port = remote_port;					
					si.protocol = SOCK_STREAM;
					strcpy(si.local_addr,get_ipv6(local));
					strcpy(si.remote_addr,get_ipv6(remote));
					fclose(fp);
					return(&amp;si);
				}
				if ( strcmp(procnet[fi],&quot;/proc/net/udp6&quot;) == 0 ){
					// Convert IPv4
					si.family = AF_INET6;
					si.state = state;
					si.uid = uid;
					si.timer_value = timer_value;
					si.timer_kind = timer_kind;
					si.local_port = local_port;					
					si.remote_port = remote_port;					
					si.protocol = SOCK_DGRAM;
					strcpy(si.local_addr,get_ipv4(local));
					strcpy(si.remote_addr,get_ipv4(remote));
					fclose(fp);
					return(&amp;si);
				}
				if ( strcmp(procnet[fi],&quot;/proc/net/tcp&quot;) == 0 ){
					// Convert IPv4
					si.family = AF_INET;
					si.state = state;
					si.uid = uid;
					si.timer_value = timer_value;
					si.timer_kind = timer_kind;
					si.local_port = local_port;					
					si.remote_port = remote_port;					
					si.protocol = SOCK_STREAM;
					strcpy(si.local_addr,get_ipv4(local));
					strcpy(si.remote_addr,get_ipv4(remote));
					fclose(fp);
					return(&amp;si);
				}
				if ( strcmp(procnet[fi],&quot;/proc/net/udp&quot;) == 0 ){
					// Convert IPv4
					si.family = AF_INET;
					si.state = state;
					si.uid = uid;
					si.timer_value = timer_value;
					si.timer_kind = timer_kind;
					si.local_port = local_port;					
					si.remote_port = remote_port;					
					si.protocol = SOCK_DGRAM;
					strcpy(si.local_addr,get_ipv4(local));
					strcpy(si.remote_addr,get_ipv4(remote));
					fclose(fp);
					return(&amp;si);
				}
				if ( strcmp(procnet[fi],&quot;/proc/net/unix&quot;) == 0 ){
					// Convert IPv4
					si.family = AF_UNIX;
					si.state = state;
					si.uid = uid;
					si.timer_value = 0;
					si.timer_kind = 0;
					si.local_port = 0;
					si.remote_port = 0;
					si.protocol = -1;
					strcpy(si.local_addr,local);
					strcpy(si.remote_addr,&quot;&quot;);
					fclose(fp);
					return(&amp;si);
				}
			}
		}
		fclose(fp);
	}

	return(NULL);
}

int sem_lock(int sem_id){
        struct sembuf ops;
	int retval;
	// logger(prefix,&quot;SEM_LOCK (Current-Value: %d)\n&quot;,semctl(semid,0,GETVAL));
        ops.sem_num = 0;
        ops.sem_flg = 0;
        ops.sem_op  = -1;
	while (  (retval = semop(sem_id,&amp;ops,1)) &lt; 0 &amp;&amp; errno == EINTR );
	// logger(prefix,&quot;SEM_LOCK finished (Retval: %d) Error: [%s] NEWVAL: %d\n&quot;,retval, retval &lt; 0 ? strerror(errno) : &quot;no error&quot; ,semctl(semid,0,GETVAL));
        return(retval);
}
int sem_unlock(int sem_id){
        struct sembuf ops;
	int retval;
	// logger(prefix,&quot;SEM_UNLOCK (Current-Value: %d)\n&quot;,semctl(semid,0,GETVAL));
        ops.sem_num = 0;
        ops.sem_flg = 0;
        ops.sem_op  = 1;
	while (  (retval = semop(sem_id,&amp;ops,1)) &lt; 0 &amp;&amp; errno == EINTR );
	// logger(prefix,&quot;SEM_UNLOCK finished (Retval: %d) Error: [%s] NEWVAL: %d\n&quot;,retval, retval &lt; 0 ? strerror(errno) : &quot;no error&quot;,semctl(semid,0,GETVAL) );
        return(retval);
}
int sem_set(int sem_id,int val){
        struct sembuf ops;
        ops.sem_num = 0;
        ops.sem_flg = 0;
        ops.sem_op  = val;
        return(semop(sem_id,&amp;ops,1));
}

#define CCON servlist[global_index].co[connection_index]
#define CSERVER servlist[global_index]

void main_reaper(){
	int status;
	int pid;
	while ( (pid = wait(&amp;status)) &lt; 0 );
	// logger(prefix,&quot;Process %d exited with Status: %d\n&quot;,pid,status);
}



struct message {
	int pid;
	char mtext[1];	
};
void slave_reaper(int sig, siginfo_t *siginfo, void *context ){
	struct message mess;
	int status;
	int pid;
	while ( (pid = wait(&amp;status)) &lt; 0 );
	// logger(prefix,&quot;WHILE_WAIT AT SLOT %d --&gt; %d received iIGCHLD [Child: %d]\n&quot;,global_index,getpid(),pid);
	
	mess.pid = (long)pid;
	mess.mtext[0] = &#039;C&#039;;
	msgsnd(msg_id, &amp;mess, sizeof(struct message), 0);
	return;
}

void garbage_collect(){
	int pid;
	int wstatus;
	struct message mess;
	char exit_msg[64];
	while ( (pid = waitpid(-1,&amp;wstatus,WNOHANG)) &gt; 0 ){
		sprintf(exit_msg,&quot;OTHER REASON (0x%08X)&quot;,wstatus); 
		if ( WIFEXITED(wstatus) ){
			sprintf(exit_msg,&quot;NORMAL EXIT&quot;);
		}
		if ( WIFSIGNALED(wstatus) ){
			sprintf(exit_msg,&quot;RECEIVED SIGNAL %d, Core-Dump: [%s]&quot;,WTERMSIG(wstatus), WCOREDUMP(wstatus) ? &quot;yes&quot; : &quot;no&quot; );
		}
		if ( WIFSTOPPED(wstatus) ){
			sprintf(exit_msg,&quot;RECEIVED STOP-SIGNAL&quot;);
		}
#ifdef WIFCONTINUED
		if ( WIFCONTINUED(wstatus) ){
			sprintf(exit_msg,&quot;RECEIVED CONT-SIGNAL&quot;);
		}
#endif
		logger(prefix,&quot;GARBAGE-COLLECT Found PID: %d, EXIT-STATUS: %d REASON: [%s]\n&quot;,pid,WEXITSTATUS(wstatus),exit_msg);
		mess.pid = (long)pid;
		mess.mtext[0] = &#039;C&#039;;
		msgsnd(msg_id, &amp;mess, sizeof(struct message), 0);
	}
}


void server_reaper(int sig, siginfo_t *siginfo, void *context){
	struct message mess;
	int status;
	int pid;
	while ( (pid = waitpid(-1,&amp;status,WNOHANG)) &gt; 0 ){
		mess.pid = (long)pid;
		mess.mtext[0] = &#039;C&#039;;
		msgsnd(msg_id, &amp;mess, sizeof(struct message), 0);
	}
	return;
}

void server_reaper_process(){
	struct message mess;
	int status;
	int pid;
	int i;
	semid = semget(INETD_KEY + global_index,1,0);
	semid2 = semget(INETD_KEY2 + global_index,1,0);
	servlist = (struct server *)shmat(shm_id,NULL,0);
	msg_id = msgget(INETD_KEY + global_index,0);
	logger(prefix,&quot;SERVER_REAPER_PROCESS for slot [%d] starting SEMID: %d, SEMID2: %d, Servlist: 0x%08lX\n&quot;,global_index,semid,semid2,servlist);
	while ( 1 ){
		int retval;
		// logger(prefix,&quot;START_WAIT AT SLOT %d [%d]\n&quot;,global_index,getpid());
		/*
		while ( (pid = waitpid(-1,&amp;status,WNOHANG)) &lt; 0 ){
			logger(prefix,&quot;POLLED_WAIT AT SLOT %d, ERRNO: %d [%s]\n&quot;,global_index,errno,strerror(errno));
			sleep(1);
		}
		*/
		bzero(&amp;mess,sizeof(struct message));
		retval = msgrcv(msg_id, &amp;mess,sizeof(struct message),0,0);
		pid = (int) mess.pid;
		sem_lock(semid2);
		for ( i = 0; i &lt; MAX_CONNS; i++ ){
			if ( CSERVER.co[i].cpid == pid  ){
				if ( CSERVER.co[i].port != 0 ){
					logger(prefix,&quot;RECEIVED MESSAGE --&gt; CPID: %d Index: %d\n&quot;,pid,i);
					m_kill(CSERVER.co[i].pid,SIGTERM);
					CSERVER.connections--;
					sem_unlock(semid);
					CSERVER.co[i].port = 0;	
				}
			}
			if ( CSERVER.co[i].pid == pid ){
					logger(prefix,&quot;RECEIVED MESSAGE --&gt; PID: %d Index: %d\n&quot;,pid,i);
				logger(prefix,&quot;Connection [%s:%d] closed (%d Seconds active)\n&quot;,
					CSERVER.co[i].source,CSERVER.co[i].port,time(NULL) - CSERVER.co[i].created);
				if ( CSERVER.co[i].port != 0 ){
					CSERVER.connections--;
					sem_unlock(semid);
					CSERVER.co[i].port = 0;	
				}
				m_kill(CSERVER.co[i].cpid,SIGTERM);
				m_kill(CSERVER.co[i].cpid,SIGHUP);
				m_kill(CSERVER.co[i].cpid,SIGKILL);
				CSERVER.co[i].cpid = 0;	
			}
		}
		sem_unlock(semid2);
	}
	return;
}

#define TYPE_HTML 0
#define TYPE_CSS  1
#define TYPE_AJAX 2
#define HTML_MIME &quot;text/html&quot;
#define CSS_MIME &quot;text/css&quot;
#define AJAX_MIME &quot;text/plain&quot;

void call_webserver(int sock, char *pwd){
	FILE *ss;
	int html_done;
	char buf[102400];
	char temp[1024];
	char temp2[1024];
	char etag[256];
	char referer[1024];
	int content_length;
	int authok;
	int valid;
	char url[128];
	time_t tim;
	char dater[64];
	char *ptr;
	int lines;
	int type_req;
	char method[16];
	char boundary[256];
	char *content;

	gix_options = (struct gix_inetd_options *)shmat(shmid_options,NULL,0);
	if ( gix_options == NULL ){
		logger(prefix,&quot;FATAL(%s:%d) Cannot attach shared-memory\n&quot;,__FILE__,__LINE__);
		shutdown(sock,SHUT_RDWR);
		close(sock);
		return;
	}

	servlist = (struct server *)shmat(shm_id,NULL,0);
	if ( servlist == NULL ){
		logger(prefix,&quot;Cannot attach SHM!\n&quot;);
		shutdown(sock,SHUT_RDWR);
		close(sock);
		return;
	}
	// logger(prefix,&quot;CALLED ADMIN PWD: [%s]\n&quot;,pwd);
	authok = 0;
	valid  = 0;
	{
		int on;
		struct linger linny;
		linny.l_onoff = 1;
		linny.l_linger = 3; // 3 seconds and than die :-)
		if ( setsockopt(sock,SOL_SOCKET,SO_LINGER,&amp;linny,sizeof(linny)) ){
			logger(prefix,&quot;WARNING: cannot set socket to linger-timeout 3\n&quot;);
		}	
		on = 1;
		if ( setsockopt(sock,SOL_SOCKET,SO_KEEPALIVE,&amp;on,sizeof(on)) ){
			logger(prefix,&quot;WARNING: cannot set socket to KEEP-ALIVE\n&quot;);
		}	
		

	}
	ss = fdopen(sock,&quot;w+&quot;);
	lines = 0;
	bzero(etag,256);	
	strcpy(referer,&quot;&quot;);
	strcpy(method,&quot;&quot;);
	content_length = 0;
	bzero(boundary,256);
	while ( fgets(buf,102400,ss) != NULL ){
		if ( buf[strlen(buf)-1] == &#039;\r&#039; || buf[strlen(buf)-1] == &#039;\n&#039; )  buf[strlen(buf)-1] = &#039;\0&#039;;
		if ( buf[strlen(buf)-1] == &#039;\r&#039; || buf[strlen(buf)-1] == &#039;\n&#039; )  buf[strlen(buf)-1] = &#039;\0&#039;;
		if ( lines == 0 ){
			if ( strncasecmp(buf,&quot;POST&quot;,4) == 0 ){
			 strcpy(method,&quot;POST&quot;);
			 valid = 1;
			 ptr = &amp;buf[4];
			 while ( *ptr &amp;&amp; ( *ptr == &#039; &#039; || *ptr == &#039;\t&#039; ) ) ptr++;
			 strcpy(url,ptr);
			 ptr = url;
			 while ( *ptr &amp;&amp; ( *ptr != &#039; &#039; &amp;&amp; *ptr != &#039;\t&#039; ) ) ptr++;
			 *ptr = &#039;\0&#039;;
			}
			if ( strncasecmp(buf,&quot;GET&quot;,3) == 0 ){
			 strcpy(method,&quot;GET&quot;);
			 valid = 1;
			 ptr = &amp;buf[3];
			 while ( *ptr &amp;&amp; ( *ptr == &#039; &#039; || *ptr == &#039;\t&#039; ) ) ptr++;
			 strcpy(url,ptr);
			 ptr = url;
			 while ( *ptr &amp;&amp; ( *ptr != &#039; &#039; &amp;&amp; *ptr != &#039;\t&#039; ) ) ptr++;
			 *ptr = &#039;\0&#039;;
			}
			if ( strncasecmp(buf,&quot;OPTIONS&quot;,7) == 0 ){
			 strcpy(method,&quot;OPTIONS&quot;);
			 valid = 1;
			 ptr = &amp;buf[7];
			 while ( *ptr &amp;&amp; ( *ptr == &#039; &#039; || *ptr == &#039;\t&#039; ) ) ptr++;
			 strcpy(url,ptr);
			 ptr = url;
			 while ( *ptr &amp;&amp; ( *ptr != &#039; &#039; &amp;&amp; *ptr != &#039;\t&#039; ) ) ptr++;
			 *ptr = &#039;\0&#039;;
			}
		}
		lines++;
		if ( strncasecmp(buf,&quot;Content-Type:&quot;,strlen(&quot;Content-Type:&quot;)) == 0 ){
			char *ptr2;
			ptr = &amp;buf[strlen(&quot;Content-Type:&quot;)];
			while ( *ptr &amp;&amp; ( *ptr == &#039; &#039; || *ptr == &#039;\t&#039; ) ) ptr++;
			strcpy(temp,ptr);
			ptr2 = temp;
			while ( *ptr2 &amp;&amp; !isspace(*ptr2) ) ptr2++;
			*ptr2 = &#039;\0&#039;;
			ptr += strlen(temp);
			if ( temp[strlen(temp)-1] == &#039;;&#039; ) temp[strlen(temp)-1] = &#039;\0&#039;;
			// logger(prefix,&quot;HTML------------&gt; PTR:     [%s]\n&quot;,ptr);
			// logger(prefix,&quot;HTML------------&gt; CONTENT: [%s]\n&quot;,temp);
			if ( strcasecmp(temp,&quot;multipart/form-data&quot;) == 0 ) {
				ptr2 = strstr(ptr,&quot;boundary=&quot;);
				if ( ptr2 != NULL ){
					ptr = ptr2 + strlen(&quot;boundary=&quot;);
					strcpy(boundary,ptr);
					ptr = boundary;
					while ( *ptr &amp;&amp; !isspace(*ptr) &amp;&amp; *ptr != &#039;;&#039; ) ptr++;
					*ptr = &#039;\0&#039;;	
					ptr = boundary;
					// logger(prefix,&quot;HTML------------&gt; BOUNDARY: [%s]\n&quot;,boundary);
				}	
			}
			
		}
		if ( strncasecmp(buf,&quot;Content-Length:&quot;,strlen(&quot;Content-Length:&quot;)) == 0 ){
			ptr = &amp;buf[strlen(&quot;Content-Length:&quot;)];
			while ( *ptr &amp;&amp; ( *ptr == &#039; &#039; || *ptr == &#039;\t&#039; ) ) ptr++;
			content_length = atoi(ptr);
		}
		if ( strncasecmp(buf,&quot;Authorization:&quot;,strlen(&quot;Authorization:&quot;)) == 0 ){
			ptr = &amp;buf[strlen(&quot;Authorization:&quot;)];
			while ( *ptr &amp;&amp; ( *ptr == &#039; &#039; || *ptr == &#039;\t&#039; ) ) ptr++;
			strcpy(temp,ptr);	
			ptr = temp;
			while ( *ptr &amp;&amp; ( *ptr != &#039; &#039; &amp;&amp; *ptr != &#039;\t&#039; ) ) ptr++;
			*ptr = &#039;\0&#039;;
			if ( strcasecmp(temp,&quot;basic&quot;) == 0 ){
				unsigned char credentials[128];
			
				int len;
				ptr++;
				while ( *ptr &amp;&amp; ( *ptr == &#039; &#039; || *ptr == &#039;\t&#039; ) ) ptr++;
				strcpy(temp2,ptr);
				ptr = temp2;
				while ( *ptr &amp;&amp; ( *ptr != &#039; &#039; &amp;&amp; *ptr != &#039;\t&#039; ) ) ptr++;
				*ptr = &#039;\0&#039;;
				len = debase64(temp2,credentials);
				// logger(prefix,&quot;AUTH-BASE64: [%s] --&gt; [%s], should be: [*:%s]\n&quot;,temp2,credentials,pwd);	
				ptr = strtok(credentials,&quot;:&quot;);
				if ( ptr != NULL ){
					// We do not care about user :-)		
					ptr = strtok(NULL,&quot;:&quot;);
					if ( ptr != NULL ){
						if ( strcmp(ptr,pwd) == 0 ) authok = 1;
					}
				}
			}
		}
		if ( strncasecmp(buf,&quot;Referer:&quot;,strlen(&quot;Referer:&quot;)) == 0 ){
			char gaense;
			int slashes;
			ptr = &amp;buf[strlen(&quot;Referer:&quot;)];
			while ( *ptr &amp;&amp; ( *ptr == &#039; &#039; || *ptr == &#039;\t&#039; ) ) ptr++;
			strcpy(referer,ptr);
			slashes = 0;
			ptr = referer;
			while ( *ptr ){
				if ( *ptr == &#039;/&#039; ) slashes++;
				if ( slashes == 3 ) break;
				ptr++;
			}
			*ptr = &#039;\0&#039;;
			
		}
		if ( strncasecmp(buf,&quot;If-None-Match:&quot;,strlen(&quot;If-None-Match:&quot;)) == 0 ){
			char gaense;
			ptr = &amp;buf[strlen(&quot;If-None-Match:&quot;)];
			while ( *ptr &amp;&amp; ( *ptr == &#039; &#039; || *ptr == &#039;\t&#039; ) ) ptr++;
			if ( *ptr == &#039;\&quot;&#039; || *ptr == &#039;\&#039;&#039; ){
				ptr++;
				strcpy(etag,ptr);
				if ( etag[strlen(etag)-1] == &#039;\&quot;&#039; || etag[strlen(etag)-1] == &#039;\&#039;&#039; ) etag[strlen(etag)-1] = &#039;\0&#039;;
			} else {
				strcpy(etag,ptr);
			}
		}
		if ( strlen(buf) &lt; 1 ) break;
		// logger(prefix,&quot;HTML&lt;&lt; [%s]\n&quot;,buf);
	}	
	// logger(prefix,&quot;HTML-----------------------------------\n&quot;);
	logger(prefix,&quot;HTML &lt;&lt; METHOD: [%s] C-LENGTH: %d, URL: [%s] Auth-OK: [%d] Valid-Request: [%d] ETAG: [%s] Referer: [%s] BOUNDARY: [%s]\n&quot;,method,content_length,url,authok,valid,etag,referer,boundary);
	if ( content_length ){
		content = (char *)malloc(content_length + 1);
		if ( fread(content,1,content_length,ss) != content_length ){
			tim = time(NULL);
			fprintf(ss,&quot;HTTP/1.1 401 Authorization Required\r\n&quot;);
			if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
			fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
			fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
			fprintf(ss,&quot;WWW-Authenticate: Basic realm=\&quot;GIX-INETD-Admin\&quot;\r\n&quot;);
			fprintf(ss,&quot;Connection: close\r\n&quot;);
			fprintf(ss,&quot;Content-Type: text/html\r\n\r\n&quot;);
			fprintf(ss,&quot;&lt;H1&gt;Access denied&lt;/H1&gt;\r\n&quot;);
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}
	}
	if ( strcmp(method,&quot;POST&quot;) == 0 ){
		char ACTION[32];
		struct multi *mul;
		int multis;
		int idx;

		multis = load_multis(content,content_length,boundary);
		for ( idx = 0; idx &lt; multis; idx++ ){
			mul = read_multi_index(idx);
			logger(prefix,&quot;MULTI[%d] Name: [%s](%d Bytes) --&gt; [%.20s]\n&quot;,idx,mul-&gt;name,mul-&gt;size,mul-&gt;content);
		}
		

		mul = read_multi(&quot;ACTION&quot;);
		if ( mul == NULL ){
			logger(prefix,&quot;NO ACTION specified!\n&quot;);
			tim = time(NULL);
			fprintf(ss,&quot;HTTP/1.1 401 Authorization Required\r\n&quot;);
			if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
			fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
			fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
			fprintf(ss,&quot;WWW-Authenticate: Basic realm=\&quot;GIX-INETD-Admin\&quot;\r\n&quot;);
			fprintf(ss,&quot;Connection: close\r\n&quot;);
			fprintf(ss,&quot;Content-Type: text/html\r\n\r\n&quot;);
			fprintf(ss,&quot;&lt;H1&gt;Access denied&lt;/H1&gt;\r\n&quot;);
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}
		strcpy(ACTION,mul-&gt;content);
		logger(prefix,&quot;REQUESTED ACTION: [%s]\n&quot;,ACTION);	

		if ( strcmp(ACTION,&quot;SAVE_CONFIG&quot;) == 0 ){
			char FILENAME[1024];
			char fname[1024];
			FILE *fp;

			send_valid_header(ss,referer);

			mul = read_multi(&quot;FILE&quot;);
			if ( mul == 0 ){
				fprintf(ss,&quot;ERR[No FILE specified]\r\n&quot;);
				fflush(ss);
				shutdown(sock,SHUT_RDWR);
				fclose(ss);
				return;
			}
			strcpy(FILENAME,mul-&gt;content);
			sprintf(fname,&quot;/big/GIX_INETD/conf/%s&quot;,FILENAME);
			logger(prefix,&quot;Using file: [%s]\n&quot;,fname);

			mul = read_multi(&quot;DATA&quot;);
			if ( mul == 0 ){
				fprintf(ss,&quot;ERR[No DATA specified]\r\n&quot;);
				fflush(ss);
				shutdown(sock,SHUT_RDWR);
				fclose(ss);
				return;
			}
			logger(prefix,&quot;Saving %d Bytes to [%s]\n&quot;,mul-&gt;size,fname);

			unlink(fname);

			fp = fopen(fname,&quot;w&quot;);
			if ( fp == NULL ){
				fprintf(ss,&quot;ERR[Cannot open &#039;%s&#039;]\r\n&quot;,fname);
				fflush(ss);
				shutdown(sock,SHUT_RDWR);
				fclose(ss);
				return;
			}
			fwrite(mul-&gt;content,1,mul-&gt;size,fp);
			fclose(fp);

			fprintf(ss,&quot;OK[Configuration saved]\r\n&quot;);
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}
		if ( strcmp(ACTION,&quot;LOAD_CONFIG&quot;) == 0 ){
			char FILENAME[1024];
			char fname[1024];
			struct stat st;
			char *json;
			FILE *fp;

			send_valid_header(ss,referer);

			mul = read_multi(&quot;FILE&quot;);
			if ( mul == 0 ){
				fprintf(ss,&quot;ERR[No FILE specified]\r\n&quot;);
				fflush(ss);
				shutdown(sock,SHUT_RDWR);
				fclose(ss);
				return;
			}
			strcpy(FILENAME,mul-&gt;content);
			sprintf(fname,&quot;/big/GIX_INETD/conf/%s&quot;,FILENAME);
			logger(prefix,&quot;Reading file: [%s]\n&quot;,fname);
			if ( stat(fname,&amp;st) ){
				fprintf(ss,&quot;ERR[Cannot stat &#039;%s&#039;]\r\n&quot;,fname);
				fflush(ss);
				shutdown(sock,SHUT_RDWR);
				fclose(ss);
				return;
			}
			json = (char *)malloc(st.st_size+1);
			bzero(json,st.st_size+1);
		
			fp = fopen(fname,&quot;r&quot;);
			if ( fp == NULL ){
				fprintf(ss,&quot;ERR[Cannot open &#039;%s&#039;]\r\n&quot;,fname);
				fflush(ss);
				shutdown(sock,SHUT_RDWR);
				fclose(ss);
				return;
			}
			fread(json,1,st.st_size,fp);
			fclose(fp);
			if ( json[strlen(json)-1] == &#039;\r&#039; || json[strlen(json)-1] == &#039;\n&#039; ) json[strlen(json)-1] = &#039;\0&#039;;
			if ( json[strlen(json)-1] == &#039;\r&#039; || json[strlen(json)-1] == &#039;\n&#039; ) json[strlen(json)-1] = &#039;\0&#039;;
			fprintf(ss,&quot;OK[%s]\r\n&quot;,json);
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}
		
		send_valid_header(ss,referer);
		logger(prefix,&quot;NO valid ACTION specified!\n&quot;);
		fprintf(ss,&quot;ERR[No valid action!]\r\n&quot;);
		fflush(ss);
		shutdown(sock,SHUT_RDWR);
		fclose(ss);
		return;
		
	}
	
	

	if ( strcmp(method,&quot;OPTIONS&quot;) == 0 ){
		// logger(prefix,&quot;HTML&gt;&gt; HTTP/1.1 204 No content\r\n&quot;);
		fprintf(ss,&quot;HTTP/1.1 204 No content\r\n&quot;);
		if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
		if ( strlen(referer)) logger(prefix,&quot;HTML&gt;&gt; Access-Control-Allow-Origin: %s\r\n&quot;,referer);
		// logger(prefix,&quot;HTML&gt;&gt; Access-Control-Allow-Methods: POST, GET, OPTIONS\r\n&quot;);
		fprintf(ss,&quot;Access-Control-Allow-Methods: POST, GET, OPTIONS\r\n&quot;);
		// logger(prefix,&quot;HTML&gt;&gt; Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
		fprintf(ss,&quot;Access-Control-Allow-Headers: Authorization, Content-Type\r\n&quot;);
		// logger(prefix,&quot;HTML&gt;&gt; Access-Control-Allow-Headers: Authorization, Content-Type\r\n&quot;);
		fprintf(ss,&quot;Access-Control-Allow-Credentials: true\r\n&quot;);
		// logger(prefix,&quot;HTML&gt;&gt; Access-Control-Allow-Credentials: true\r\n&quot;);
		fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
		// logger(prefix,&quot;HTML&gt;&gt; Server: %s\r\n&quot;,GIX_INETD_VERSION);
		fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
		// logger(prefix,&quot;HTML&gt;&gt; Connection: close\r\n\r\n&quot;);
		fprintf(ss,&quot;Connection: close\r\n\r\n&quot;);
		fflush(ss);
		logger(prefix,&quot;OPTIONS-HEADER processed...\n&quot;);
		shutdown(sock,SHUT_RDWR);
		fclose(ss);
		return;
	}

	if ( valid == 0 ){
		tim = time(NULL);
		fprintf(ss,&quot;HTTP/1.1 401 Authorization Required\r\n&quot;);
		if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
		fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
		fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
		fprintf(ss,&quot;WWW-Authenticate: Basic realm=\&quot;GIX-INETD-Admin\&quot;\r\n&quot;);
		fprintf(ss,&quot;Connection: close\r\n&quot;);
		fprintf(ss,&quot;Content-Type: text/html\r\n\r\n&quot;);
		fprintf(ss,&quot;&lt;H1&gt;Access denied&lt;/H1&gt;\r\n&quot;);
		fflush(ss);
		shutdown(sock,SHUT_RDWR);
		fclose(ss);
		return;
	}

	// Only version asking is allowed :-)
	if ( strcmp(url,&quot;/version&quot;) == 0 ){
		fprintf(ss,&quot;HTTP/1.1 200 OK\r\n&quot;);
		if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
		fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
		fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
		fprintf(ss,&quot;Connection: close\r\n&quot;);
		fprintf(ss,&quot;Content-Type: text/plain;\r\n\r\n&quot;);
		fprintf(ss,&quot;OK[{\&quot;hostname\&quot;:\&quot;%s\&quot;,\&quot;version\&quot;:\&quot;%s\&quot;}]\r\n&quot;,my_hostname,GIX_INETD_VERSION);
		fflush(ss);
		shutdown(sock,SHUT_RDWR);
		fclose(ss);
		return;
	}

	if ( authok == 0 ){
		tim = time(NULL);
		fprintf(ss,&quot;HTTP/1.1 401 Authorization Required\r\n&quot;);
		if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
		fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
		fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
		fprintf(ss,&quot;WWW-Authenticate: Basic realm=\&quot;GIX-INETD-Admin\&quot;\r\n&quot;);
		fprintf(ss,&quot;Connection: close\r\n&quot;);
		fprintf(ss,&quot;Content-Type: text/html\r\n\r\n&quot;);
		fprintf(ss,&quot;&lt;H1&gt;Access denied&lt;/H1&gt;\r\n&quot;);
		fflush(ss);
		shutdown(sock,SHUT_RDWR);
		fclose(ss);
		return;
	}
	if ( strcmp(url,&quot;/version_s&quot;) == 0 ){
		fprintf(ss,&quot;HTTP/1.1 200 OK\r\n&quot;);
		if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
		fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
		fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
		fprintf(ss,&quot;Connection: close\r\n&quot;);
		fprintf(ss,&quot;Content-Type: text/plain;\r\n\r\n&quot;);
		fprintf(ss,&quot;OK[{\&quot;hostname\&quot;:\&quot;%s\&quot;,\&quot;version\&quot;:\&quot;%s\&quot;}]\r\n&quot;,my_hostname,GIX_INETD_VERSION);
		fflush(ss);
		shutdown(sock,SHUT_RDWR);
		fclose(ss);
		return;
	}
	if ( strncmp(url,&quot;/update_version/&quot;,strlen(&quot;/update_version/&quot;)) == 0 ){
		char tempfile[1024];
		char filelist[1024];
		char buf[1024];
		int retval;
		FILE *in, *out;

		fprintf(ss,&quot;HTTP/1.1 200 OK\r\n&quot;);
		if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
		fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
		fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
		fprintf(ss,&quot;Connection: close\r\n&quot;);
		fprintf(ss,&quot;Content-Type: text/plain;\r\n\r\n&quot;);

		sprintf(tempfile,&quot;/tmp/dirlist_ginetd_%d.data&quot;,getpid());
		sprintf(filelist,&quot;/tmp/list_ginetd_%d.data&quot;,getpid());
		unlink(tempfile);
		unlink(filelist);
		ftp_list(GIX_INETD_UPDATESERVER,&quot;/big/GIX_INETD/src&quot;,tempfile);
		logger(prefix,&quot;Getting directory-list from [%s] Path: [%s] --&gt; %d\n&quot;,GIX_INETD_UPDATESERVER,tempfile,retval);
		
		in = fopen(tempfile,&quot;r&quot;);
		if ( in == NULL ){
			unlink(tempfile);
			unlink(filelist);
			fprintf(ss,&quot;ERR[Cannot open &#039;%s&#039; for reading]\r\n&quot;,tempfile);
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}		
		out = fopen(filelist,&quot;w&quot;);
		if ( out == NULL ){
			unlink(tempfile);
			unlink(filelist);
			fprintf(ss,&quot;ERR[Cannot open &#039;%s&#039; for writing]\r\n&quot;,filelist);
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}
		while ( fgets(buf,1024,in) != NULL ){
			char *ptr;
			if ( buf[strlen(buf)-1] == &#039;\r&#039; || buf[strlen(buf)-1] == &#039;\n&#039; ) buf[strlen(buf)-1] = &#039;\0&#039;;
			if ( buf[strlen(buf)-1] == &#039;\r&#039; || buf[strlen(buf)-1] == &#039;\n&#039; ) buf[strlen(buf)-1] = &#039;\0&#039;;
			ptr = &amp;buf[strlen(buf)-1];
			while ( ptr &gt; buf &amp;&amp; !isspace(*ptr) ) ptr--;
			if ( isspace(*ptr) ) ptr++;
			if ( strcmp(ptr,&quot;Makefile&quot;) == 0 ){
				fprintf(out,&quot;%s\n&quot;,ptr);
			}
			if ( strcmp(ptr,&quot;update.sh&quot;) == 0 ){
				fprintf(out,&quot;%s\n&quot;,ptr);
			}
			if ( strlen(ptr) &gt; 2 &amp;&amp; ( strcmp(&amp;ptr[strlen(ptr)-2],&quot;.c&quot;) == 0 || strcmp(&amp;ptr[strlen(ptr)-2],&quot;.h&quot;) == 0 ) ){
				fprintf(out,&quot;%s\n&quot;,ptr);
			}
		}
		fclose(in);
		fclose(out);
		unlink(tempfile);
		in = fopen(filelist,&quot;r&quot;);
		if ( in == NULL ){
			unlink(tempfile);
			unlink(filelist);
			fprintf(ss,&quot;ERR[Cannot open &#039;%s&#039; for reading]\r\n&quot;,filelist);
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}		
		while ( fgets(buf,1024,in) != NULL ){
			char fname[1024];
			if ( buf[strlen(buf)-1] == &#039;\r&#039; || buf[strlen(buf)-1] == &#039;\n&#039; ) buf[strlen(buf)-1] = &#039;\0&#039;;
			if ( buf[strlen(buf)-1] == &#039;\r&#039; || buf[strlen(buf)-1] == &#039;\n&#039; ) buf[strlen(buf)-1] = &#039;\0&#039;;
			sprintf(fname,&quot;/big/GIX_INETD/src/%s&quot;,buf);
			logger(prefix,&quot;UPDATE...Getting: [%s]\n&quot;,fname);
			ftp_get(GIX_INETD_UPDATESERVER,fname,fname);	
		}
		fclose(in);
		


		logger(prefix,&quot;Starting update...\n&quot;);
		chdir(&quot;/big/GIX_INETD/src&quot;);
		system(&quot;make clean ; make &gt; /tmp/make.log 2&gt;&amp;1&quot;);
		// Ok we have the list :-)
			
		fprintf(ss,&quot;OK[Update will be done...]\r\n&quot;);
		fflush(ss);
		shutdown(sock,SHUT_RDWR);
		fclose(ss);
		return;
	}
	tim = time(NULL);
        if ( strcmp(url,&quot;/favicon.ico&quot;) == 0 ){
		if ( strlen(etag) &amp;&amp; strcmp(etag,gix_img_gixicon_etag) == 0 ){
			// logger(prefix,&quot;HTML --&gt; Sending ETAG-OK Header\n&quot;);
			fprintf(ss,&quot;HTTP/1.1 304 Not Modified\r\n&quot;);
			if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
			fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
			fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
			fprintf(ss,&quot;Connection: close\r\n&quot;);
			fprintf(ss,&quot;ETag: \&quot;%s\&quot;\r\n\r\n&quot;,etag);
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}
		fprintf(ss,&quot;HTTP/1.1 200 OK\r\n&quot;);
		if ( strlen(referer) )fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
		fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
		fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
		fprintf(ss,&quot;Connection: close\r\n&quot;);
		fprintf(ss,&quot;Accept-Ranges: bytes\r\n&quot;);
		fprintf(ss,&quot;Content-Length: %d\r\n&quot;,gix_img_gixicon_len);
		fprintf(ss,&quot;ETag: \&quot;%s\&quot;\r\n&quot;,gix_img_gixicon_etag);
		fprintf(ss,&quot;Content-Type: image/x-icon\r\n\r\n&quot;);
		fwrite(gix_img_gixicon_bin,1,gix_img_gixicon_len,ss);
		fflush(ss);
		shutdown(sock,SHUT_RDWR);
		fclose(ss);
		return;
	}
        if ( strcmp(url,&quot;/gix_logo.png&quot;) == 0 ){
		if ( strlen(etag) &amp;&amp; strcmp(etag,gix_img_gixlogo_etag) == 0 ){
			// logger(prefix,&quot;HTML --&gt; Sending ETAG-OK Header\n&quot;);
			fprintf(ss,&quot;HTTP/1.1 304 Not Modified\r\n&quot;);
			if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
			fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
			fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
			fprintf(ss,&quot;Connection: close\r\n&quot;);
			fprintf(ss,&quot;ETag: \&quot;%s\&quot;\r\n\r\n&quot;,etag);
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}
		fprintf(ss,&quot;HTTP/1.1 200 OK\r\n&quot;);
		if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
		fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
		fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
		fprintf(ss,&quot;Connection: close\r\n&quot;);
		fprintf(ss,&quot;Accept-Ranges: bytes\r\n&quot;);
		fprintf(ss,&quot;Content-Length: %d\r\n&quot;,gix_img_gixlogo_len);
		fprintf(ss,&quot;ETag: \&quot;%s\&quot;\r\n&quot;,gix_img_gixlogo_etag);
		fprintf(ss,&quot;Content-Type: image/png\r\n\r\n&quot;);
		fwrite(gix_img_gixlogo_bin,1,gix_img_gixlogo_len,ss);
		fflush(ss);
		shutdown(sock,SHUT_RDWR);
		fclose(ss);
		return;
	}
        if ( strcmp(url,&quot;/led_orange.gif&quot;) == 0 ){
		if ( strlen(etag) &amp;&amp; strcmp(etag,gix_img_led_orange_etag) == 0 ){ 
			// logger(prefix,&quot;HTML --&gt; Sending ETAG-OK Header\n&quot;);
			fprintf(ss,&quot;HTTP/1.1 304 Not Modified\r\n&quot;);
			if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
			fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
			fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
			fprintf(ss,&quot;Connection: close\r\n&quot;);
			fprintf(ss,&quot;ETag: \&quot;%s\&quot;\r\n\r\n&quot;,etag);
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}
		fprintf(ss,&quot;HTTP/1.1 200 OK\r\n&quot;);
		if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
		fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
		fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
		fprintf(ss,&quot;Connection: close\r\n&quot;);
		fprintf(ss,&quot;Accept-Ranges: bytes\r\n&quot;);
		fprintf(ss,&quot;Content-Length: %d\r\n&quot;,gix_img_led_orange_len);
		fprintf(ss,&quot;ETag: \&quot;%s\&quot;\r\n&quot;,gix_img_led_orange_etag);
		fprintf(ss,&quot;Content-Type: image/gif\r\n\r\n&quot;);
		fwrite(gix_img_led_orange_bin,1,gix_img_led_orange_len,ss);
		fflush(ss);
		shutdown(sock,SHUT_RDWR);
		fclose(ss);
		return;
	}
        if ( strcmp(url,&quot;/led_red.gif&quot;) == 0 ){
		if ( strlen(etag) &amp;&amp; strcmp(etag,gix_img_led_red_etag) == 0 ){ 
			// logger(prefix,&quot;HTML --&gt; Sending ETAG-OK Header\n&quot;);
			fprintf(ss,&quot;HTTP/1.1 304 Not Modified\r\n&quot;);
			if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
			fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
			fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
			fprintf(ss,&quot;Connection: close\r\n&quot;);
			fprintf(ss,&quot;ETag: \&quot;%s\&quot;\r\n\r\n&quot;,etag);
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}
		fprintf(ss,&quot;HTTP/1.1 200 OK\r\n&quot;);
		if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
		fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
		fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
		fprintf(ss,&quot;Connection: close\r\n&quot;);
		fprintf(ss,&quot;Accept-Ranges: bytes\r\n&quot;);
		fprintf(ss,&quot;Content-Length: %d\r\n&quot;,gix_img_led_red_len);
		fprintf(ss,&quot;ETag: \&quot;%s\&quot;\r\n&quot;,gix_img_led_red_etag);
		fprintf(ss,&quot;Content-Type: image/gif\r\n\r\n&quot;);
		fwrite(gix_img_led_red_bin,1,gix_img_led_red_len,ss);
		fflush(ss);
		shutdown(sock,SHUT_RDWR);
		fclose(ss);
		return;
	}
        if ( strcmp(url,&quot;/led_blue.gif&quot;) == 0 ){
		if ( strlen(etag) &amp;&amp; strcmp(etag,gix_img_led_red_etag) == 0 ){ 
			// logger(prefix,&quot;HTML --&gt; Sending ETAG-OK Header\n&quot;);
			fprintf(ss,&quot;HTTP/1.1 304 Not Modified\r\n&quot;);
			if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
			fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
			fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
			fprintf(ss,&quot;Connection: close\r\n&quot;);
			fprintf(ss,&quot;ETag: \&quot;%s\&quot;\r\n\r\n&quot;,etag);
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}
		fprintf(ss,&quot;HTTP/1.1 200 OK\r\n&quot;);
		if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
		fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
		fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
		fprintf(ss,&quot;Connection: close\r\n&quot;);
		fprintf(ss,&quot;Accept-Ranges: bytes\r\n&quot;);
		fprintf(ss,&quot;Content-Length: %d\r\n&quot;,gix_img_led_blue_len);
		fprintf(ss,&quot;ETag: \&quot;%s\&quot;\r\n&quot;,gix_img_led_blue_etag);
		fprintf(ss,&quot;Content-Type: image/gif\r\n\r\n&quot;);
		fwrite(gix_img_led_blue_bin,1,gix_img_led_blue_len,ss);
		fflush(ss);
		shutdown(sock,SHUT_RDWR);
		fclose(ss);
		return;
	}
        if ( strcmp(url,&quot;/led_green.gif&quot;) == 0 ){
		if ( strlen(etag) &amp;&amp; strcmp(etag,gix_img_led_red_etag) == 0 ){ 
			// logger(prefix,&quot;HTML --&gt; Sending ETAG-OK Header\n&quot;);
			fprintf(ss,&quot;HTTP/1.1 304 Not Modified\r\n&quot;);
			if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
			fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
			fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
			fprintf(ss,&quot;Connection: close\r\n&quot;);
			fprintf(ss,&quot;ETag: \&quot;%s\&quot;\r\n\r\n&quot;,etag);
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}
		fprintf(ss,&quot;HTTP/1.1 200 OK\r\n&quot;);
		if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
		fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
		fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
		fprintf(ss,&quot;Connection: close\r\n&quot;);
		fprintf(ss,&quot;Accept-Ranges: bytes\r\n&quot;);
		fprintf(ss,&quot;Content-Length: %d\r\n&quot;,gix_img_led_green_len);
		fprintf(ss,&quot;ETag: \&quot;%s\&quot;\r\n&quot;,gix_img_led_green_etag);
		fprintf(ss,&quot;Content-Type: image/gif\r\n\r\n&quot;);
		fwrite(gix_img_led_green_bin,1,gix_img_led_green_len,ss);
		fflush(ss);
		shutdown(sock,SHUT_RDWR);
		fclose(ss);
		return;
	}
        if ( strcmp(url,&quot;/empty.gif&quot;) == 0 ){
		if ( strlen(etag) &amp;&amp; strcmp(etag,gix_img_empty_etag) == 0 ){ 
			// logger(prefix,&quot;HTML --&gt; Sending ETAG-OK Header\n&quot;);
			fprintf(ss,&quot;HTTP/1.1 304 Not Modified\r\n&quot;);
			if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
			fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
			fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
			fprintf(ss,&quot;Connection: close\r\n&quot;);
			fprintf(ss,&quot;ETag: \&quot;%s\&quot;\r\n\r\n&quot;,etag);
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}
		fprintf(ss,&quot;HTTP/1.1 200 OK\r\n&quot;);
		if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
		fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
		fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
		fprintf(ss,&quot;Connection: close\r\n&quot;);
		fprintf(ss,&quot;Accept-Ranges: bytes\r\n&quot;);
		fprintf(ss,&quot;Content-Length: %d\r\n&quot;,gix_img_empty_len);
		fprintf(ss,&quot;ETag: \&quot;%s\&quot;\r\n&quot;,gix_img_empty_etag);
		fprintf(ss,&quot;Content-Type: image/gif\r\n\r\n&quot;);
		fwrite(gix_img_empty_bin,1,gix_img_empty_len,ss);
		fflush(ss);
		shutdown(sock,SHUT_RDWR);
		fclose(ss);
		return;
	}
        if ( strcmp(url,&quot;/new_rotator_small.gif&quot;) == 0 ){
		if ( strlen(etag) &amp;&amp; strcmp(etag,gix_img_new_rotator_small_etag) == 0 ){ 
			// logger(prefix,&quot;HTML --&gt; Sending ETAG-OK Header\n&quot;);
			fprintf(ss,&quot;HTTP/1.1 304 Not Modified\r\n&quot;);
			if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
			fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
			fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
			fprintf(ss,&quot;Connection: close\r\n&quot;);
			fprintf(ss,&quot;ETag: \&quot;%s\&quot;\r\n\r\n&quot;,etag);
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}
		fprintf(ss,&quot;HTTP/1.1 200 OK\r\n&quot;);
		if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
		fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
		fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
		fprintf(ss,&quot;Connection: close\r\n&quot;);
		fprintf(ss,&quot;Accept-Ranges: bytes\r\n&quot;);
		fprintf(ss,&quot;Content-Length: %d\r\n&quot;,gix_img_new_rotator_small_len);
		fprintf(ss,&quot;ETag: \&quot;%s\&quot;\r\n&quot;,gix_img_new_rotator_small_etag);
		fprintf(ss,&quot;Content-Type: image/gif\r\n\r\n&quot;);
		fwrite(gix_img_new_rotator_small_bin,1,gix_img_new_rotator_small_len,ss);
		fflush(ss);
		shutdown(sock,SHUT_RDWR);
		fclose(ss);
		return;
	}
        if ( strcmp(url,&quot;/new_rotator_big.gif&quot;) == 0 ){
		if ( strlen(etag) &amp;&amp; strcmp(etag,gix_img_new_rotator_big_etag) == 0 ){ 
			// logger(prefix,&quot;HTML --&gt; Sending ETAG-OK Header\n&quot;);
			fprintf(ss,&quot;HTTP/1.1 304 Not Modified\r\n&quot;);
			if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
			fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
			fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
			fprintf(ss,&quot;Connection: close\r\n&quot;);
			fprintf(ss,&quot;ETag: \&quot;%s\&quot;\r\n\r\n&quot;,etag);
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}
		fprintf(ss,&quot;HTTP/1.1 200 OK\r\n&quot;);
		if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
		fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
		fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
		fprintf(ss,&quot;Connection: close\r\n&quot;);
		fprintf(ss,&quot;Accept-Ranges: bytes\r\n&quot;);
		fprintf(ss,&quot;Content-Length: %d\r\n&quot;,gix_img_new_rotator_big_len);
		fprintf(ss,&quot;ETag: \&quot;%s\&quot;\r\n&quot;,gix_img_new_rotator_big_etag);
		fprintf(ss,&quot;Content-Type: image/gif\r\n\r\n&quot;);
		fwrite(gix_img_new_rotator_big_bin,1,gix_img_new_rotator_big_len,ss);
		fflush(ss);
		shutdown(sock,SHUT_RDWR);
		fclose(ss);
		return;
	}
	fprintf(ss,&quot;HTTP/1.1 200 OK\r\n&quot;);
	if ( strlen(referer)) fprintf(ss,&quot;Access-Control-Allow-Origin: %s\r\n&quot;,referer);
	fprintf(ss,&quot;Date: %s\r\n&quot;,ctime_o(&amp;tim,dater));
	fprintf(ss,&quot;Server: %s\r\n&quot;,GIX_INETD_VERSION);
	fprintf(ss,&quot;Connection: close\r\n&quot;);
	type_req = TYPE_HTML;
	if ( strstr(url,&quot;/ajax/&quot;) != NULL ) type_req = TYPE_AJAX;
	if ( strcmp(url,&quot;/style.css&quot;) == 0  ) type_req = TYPE_CSS;

	if ( type_req == TYPE_CSS ){
		fprintf(ss,&quot;Content-Type: text/css\r\n\r\n&quot;);
		fprintf(ss,&quot;div.fixed_download {\n&quot;);
		fprintf(ss,&quot; display: block;\n&quot;);
		fprintf(ss,&quot; visibility: hidden;\n&quot;);
		fprintf(ss,&quot; z-index: 13;\n&quot;);
		fprintf(ss,&quot; position: fixed;\n&quot;);
		fprintf(ss,&quot; top: 5%;\n&quot;);
		fprintf(ss,&quot; left: 5%;\n&quot;);
		fprintf(ss,&quot; width: 90%;\n&quot;);
		fprintf(ss,&quot; height: 90%;\n&quot;);
		fprintf(ss,&quot; border: 1px solid black;\n&quot;);
		fprintf(ss,&quot; box-shadow: 10px 15px 20px black;\n&quot;);
		fprintf(ss,&quot; padding: 5px;\n&quot;);
		fprintf(ss,&quot; overflow: auto;\n&quot;);
		fprintf(ss,&quot; background-color: rgba(0,0,0,0.9);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.mainbody {\n&quot;);
		fprintf(ss,&quot; background-color: rgb(200,200,200);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.headline {\n&quot;);
		fprintf(ss,&quot; left: 5%%;\n&quot;);
		fprintf(ss,&quot; right: 5%%;\n&quot;);
		fprintf(ss,&quot; z-index: 10;\n&quot;);
		fprintf(ss,&quot; border: 1px solid black;\n&quot;);
		fprintf(ss,&quot; position:  fixed;\n&quot;);
		fprintf(ss,&quot; top: 10px;\n&quot;);
		fprintf(ss,&quot; margin-right: auto;\n&quot;);
		fprintf(ss,&quot; margin-left: auto;\n&quot;);
		fprintf(ss,&quot; background-color: rgb(180,180,180);\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 24px;\n&quot;);
		fprintf(ss,&quot; width: 90%%;\n&quot;);
		fprintf(ss,&quot; padding: 4px;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.rotator_div {\n&quot;);
		// fprintf(ss,&quot; border: 1px solid green;\n&quot;);
		// fprintf(ss,&quot; width: 100px;\n&quot;);
		// fprintf(ss,&quot; height: 100px;\n&quot;);
		fprintf(ss,&quot; padding-left: 40%%;\n&quot;);
		fprintf(ss,&quot; padding-right: 10px;\n&quot;);
		fprintf(ss,&quot; padding-top: 25px;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.fd_div {\n&quot;);
		fprintf(ss,&quot; max-height: 500px;\n&quot;);
		fprintf(ss,&quot; overflow-y: auto;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.table_list2 {\n&quot;);
		fprintf(ss,&quot; position: relative;\n&quot;);
		fprintf(ss,&quot; background-color: grey;\n&quot;);
		// fprintf(ss,&quot; width: 90%%;\n&quot;);
		fprintf(ss,&quot; height: 85%%;\n&quot;);
		// fprintf(ss,&quot; left: 5%%;\n&quot;);
		fprintf(ss,&quot; top: 5%%;\n&quot;);
		fprintf(ss,&quot; border: 1px solid white;\n&quot;);
		fprintf(ss,&quot; overflow-y: auto;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.table_list {\n&quot;);
		fprintf(ss,&quot; position: relative;\n&quot;);
		fprintf(ss,&quot; background-color: grey;\n&quot;);
		// fprintf(ss,&quot; width: 90%%;\n&quot;);
		fprintf(ss,&quot; height: 85%%;\n&quot;);
		// fprintf(ss,&quot; left: 5%%;\n&quot;);
		fprintf(ss,&quot; top: 5%%;\n&quot;);
		fprintf(ss,&quot; border: 1px solid white;\n&quot;);
		fprintf(ss,&quot; overflow-y: auto;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.headliner {\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 20px;\n&quot;);
		fprintf(ss,&quot; font-weight: bold;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;.gcanvas1 {\n&quot;);
		// fprintf(ss,&quot; width: 400;\n&quot;);
		// fprintf(ss,&quot; height: 100;\n&quot;);
		fprintf(ss,&quot; border: 1px solid black;\n&quot;);
		fprintf(ss,&quot; background-color: white;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;.ethlist {\n&quot;);
		// fprintf(ss,&quot; max-height: 300px;\n&quot;);
		// fprintf(ss,&quot; overflow-y: auto;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;.mainscreen {\n&quot;);
		fprintf(ss,&quot; left: 5%%;\n&quot;);
		fprintf(ss,&quot; right: 5%%;\n&quot;);
		fprintf(ss,&quot; z-index: 10;\n&quot;);
		fprintf(ss,&quot; overflow-y: auto;\n&quot;);
		fprintf(ss,&quot; position:  fixed;\n&quot;);
		fprintf(ss,&quot; margin-right: auto;\n&quot;);
		fprintf(ss,&quot; margin-left: auto;\n&quot;);
		fprintf(ss,&quot; background-color: rgb(180,180,180);\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 16px;\n&quot;);
		fprintf(ss,&quot; padding: 10px;\n&quot;);
		fprintf(ss,&quot; border: 1px solid black;\n&quot;);
		fprintf(ss,&quot; width: 90%%;\n&quot;);
		fprintf(ss,&quot; max-height: 70%%;\n&quot;);
		fprintf(ss,&quot; top: 15%%;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.procinfo {\n&quot;);
		fprintf(ss,&quot;  height: 400px;\n&quot;);
		fprintf(ss,&quot;  overflow-y: scroll;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.theadbig {\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 24px;\n&quot;);
		fprintf(ss,&quot; color: white;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.thead1s {\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 12px;\n&quot;);
		fprintf(ss,&quot; color: red;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.input1s {\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 12px;\n&quot;);
		fprintf(ss,&quot; color: red;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.input2s {\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 12px;\n&quot;);
		fprintf(ss,&quot; color: black;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.input2serror {\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 12px;\n&quot;);
		fprintf(ss,&quot; border: 2px solid red;\n&quot;);
		fprintf(ss,&quot; color: red;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.thead2s {\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 12px;\n&quot;);
		fprintf(ss,&quot; color: black;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.thead2sw {\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 12px;\n&quot;);
		fprintf(ss,&quot; color: orange;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.thead2slink {\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 12px;\n&quot;);
		fprintf(ss,&quot; cursor: pointer;\n&quot;);
		fprintf(ss,&quot; color: blue;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.thead2slink:hover {\n&quot;);
		fprintf(ss,&quot; font-weight: bold;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.thead3s {\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 12px;\n&quot;);
		fprintf(ss,&quot; color: blue;\n&quot;);
		fprintf(ss,&quot; cursor: pointer;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.thead3s:hover {\n&quot;);
		fprintf(ss,&quot; font-weight: bold;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.thead4s {\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 12px;\n&quot;);
		fprintf(ss,&quot; color: green;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.thead1 {\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 14px;\n&quot;);
		fprintf(ss,&quot; color: red;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.thead2 {\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 14px;\n&quot;);
		fprintf(ss,&quot; color: black;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.thead2link {\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 14px;\n&quot;);
		fprintf(ss,&quot; color: blue;\n&quot;);
		fprintf(ss,&quot; cursor: pointer;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.thead2links {\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 12px;\n&quot;);
		fprintf(ss,&quot; color: blue;\n&quot;);
		fprintf(ss,&quot; cursor: pointer;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.thead2link:hover {\n&quot;);
		fprintf(ss,&quot; font-weight: bold;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.thead3 {\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 14px;\n&quot;);
		fprintf(ss,&quot; font-weight: bold;\n&quot;);
		fprintf(ss,&quot; color: green;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.thead10 {\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 14px;\n&quot;);
		fprintf(ss,&quot; cursor: pointer;\n&quot;);
		fprintf(ss,&quot; color: red;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.thead20 {\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 14px;\n&quot;);
		fprintf(ss,&quot; cursor: pointer;\n&quot;);
		fprintf(ss,&quot; color: black;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.thead30 {\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 14px;\n&quot;);
		fprintf(ss,&quot; font-weight: bold;\n&quot;);
		fprintf(ss,&quot; cursor: pointer;\n&quot;);
		fprintf(ss,&quot; color: green;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.thead20s {\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 12px;\n&quot;);
		fprintf(ss,&quot; cursor: pointer;\n&quot;);
		fprintf(ss,&quot; color: black;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.thead30s {\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 12px;\n&quot;);
		fprintf(ss,&quot; font-weight: bold;\n&quot;);
		fprintf(ss,&quot; cursor: pointer;\n&quot;);
		fprintf(ss,&quot; color: green;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.info_div {\n&quot;);
		fprintf(ss,&quot;  position: fixed;\n&quot;);
		fprintf(ss,&quot;  padding: 4px;\n&quot;);
		fprintf(ss,&quot;  z-index: 13;\n&quot;);
		fprintf(ss,&quot;  border: 1px solid black;\n&quot;);
		fprintf(ss,&quot;  top: 10%%;\n&quot;);
		fprintf(ss,&quot;  left: 5%%;\n&quot;);
		fprintf(ss,&quot;  width: 90%%;\n&quot;);
		fprintf(ss,&quot;  height: 80%%;\n&quot;);
		fprintf(ss,&quot;  box-shadow: 10px 15px 20px black;\n&quot;);
		fprintf(ss,&quot;  background-color: rgba(0,0,0,0.9);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.footer {\n&quot;);
		fprintf(ss,&quot; position:  fixed;\n&quot;);
		fprintf(ss,&quot; z-index: 10;\n&quot;);
		fprintf(ss,&quot; border: 1px solid black;\n&quot;);
		fprintf(ss,&quot; background-color: rgb(180,180,180);\n&quot;);
		fprintf(ss,&quot; left: 5%%;\n&quot;);
		fprintf(ss,&quot; right: 5%%;\n&quot;);
		fprintf(ss,&quot; margin-right: auto;\n&quot;);
		fprintf(ss,&quot; margin-left: auto;\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 16px;\n&quot;);
		fprintf(ss,&quot; top: 90%%;\n&quot;);
		fprintf(ss,&quot; width: 90%%;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.filemanagerclose2 {\n&quot;);
		fprintf(ss,&quot;  font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot;  color: white;\n&quot;);
		fprintf(ss,&quot;  font-size: 48px;\n&quot;);
		fprintf(ss,&quot;  font-weight: bold;\n&quot;);
		fprintf(ss,&quot;  cursor: pointer;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.filemanagerclose2:hover {\n&quot;);
		fprintf(ss,&quot;  color: green;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.standard_buttons {\n&quot;);
		fprintf(ss,&quot; background-color: #DD2211;\n&quot;);
		fprintf(ss,&quot; border: none;\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 12px;\n&quot;);
		fprintf(ss,&quot; text-align: center;\n&quot;);
		fprintf(ss,&quot; text-decoration: none;\n&quot;);
		fprintf(ss,&quot; display: inline-block;\n&quot;);
		fprintf(ss,&quot; color: white;\n&quot;);
		fprintf(ss,&quot; padding: 2px 5px;\n&quot;);
		fprintf(ss,&quot; cursor: pointer;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.standard_buttons:hover {\n&quot;);
		fprintf(ss,&quot; font-weight: bold;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.standard_button {\n&quot;);
		fprintf(ss,&quot; background-color: #DD2211;\n&quot;);
		fprintf(ss,&quot; border: none;\n&quot;);
		fprintf(ss,&quot; font-family: Optima, Geneva, sans-serif;\n&quot;);
		fprintf(ss,&quot; font-size: 14px;\n&quot;);
		fprintf(ss,&quot; text-align: center;\n&quot;);
		fprintf(ss,&quot; text-decoration: none;\n&quot;);
		fprintf(ss,&quot; display: inline-block;\n&quot;);
		fprintf(ss,&quot; color: white;\n&quot;);
		fprintf(ss,&quot; padding: 4px 10px;\n&quot;);
		fprintf(ss,&quot; cursor: pointer;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.standard_button:hover {\n&quot;);
		fprintf(ss,&quot; font-weight: bold;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.l_image {\n&quot;);
		fprintf(ss,&quot; cursor: pointer;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.l_image:hover {\n&quot;);
		fprintf(ss,&quot; border: 1px solid black;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;.simple_div: {\n&quot;);
		fprintf(ss,&quot; border: 1px solid black;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);


		fflush(ss);
		shutdown(sock,SHUT_RDWR);
		fclose(ss);
		return;
	}
	if ( type_req == TYPE_AJAX ){
		char command[256];
		char argument[256];
		char *ptr;
		fprintf(ss,&quot;Content-Type: %s\r\n&quot;,AJAX_MIME);
		ptr = &amp;url[strlen(&quot;/ajax/&quot;)];
		bzero(command,256);
		strcpy(command,ptr);
		ptr = command;
		while ( *ptr &amp;&amp; ( *ptr != &#039;/&#039; )) ptr++;
		*ptr = &#039;\0&#039;;
		ptr++;
		strcpy(argument,ptr);
		logger(prefix,&quot;AJAX-COMMAND: [%s] Argument: [%s]\n&quot;,command,argument);	


		if ( strcmp(command,&quot;SET_TFTP_ENABLE&quot;) == 0 ){
			gix_options-&gt;tftp_enabled = atoi(argument);
			fprintf(ss,&quot;\r\n[OK]\r\n&quot;); 
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}
		if ( strcmp(command,&quot;SET_DHCP_ENABLE&quot;) == 0 ){
			logger(prefix,&quot;Setting DHCP_ENABLED TO VALUE: %d\n&quot;,atoi(argument));
			gix_options-&gt;dhcp_enabled = atoi(argument);
			fprintf(ss,&quot;\r\n[OK]\r\n&quot;); 
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}
		if ( strcmp(command,&quot;SET_TFTP_READONLY&quot;) == 0 ){
			gix_options-&gt;tftp_readonly = atoi(argument);
			fprintf(ss,&quot;\r\n[OK]\r\n&quot;); 
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}
		if ( strcmp(command,&quot;SET_TFTP_ROOT&quot;) == 0 ){
			strcpy(gix_options-&gt;tftp_root,argument);
			fprintf(ss,&quot;\r\n[OK]\r\n&quot;); 
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}



		if ( strcmp(command,&quot;CONNSLIST&quot;) == 0 ){
			int idx,i;
			char *result;
			char line[1024];
			idx = atoi(argument);
			if ( idx &gt;= entries ){
				fprintf(ss,&quot;\r\nERR[Bad Index]\r\n&quot;);
				fflush(ss);
				shutdown(sock,SHUT_RDWR);
				fclose(ss);
				return;
			}
			result = strdup(&quot;[&quot;);
			sem_lock(semid2);
			for ( i = 0; i &lt; MAX_CONNS; i++ ){
				if ( servlist[idx].co[i].port != 0 ){
					struct tm *tm;
					char procfile[1024];
					char cmdline[1024];
					char stack[128];
					char cwd[512];
					char data[128];
					char exe[128];
					char lib[128];
					size_t _io_read;
					size_t _io_write;
					double io_read;
					double io_write;
					double io_read_sec;
					double io_write_sec;
					char io_read_text[1024];
					char io_write_text[1024];
					char io_read_sec_text[1024];
					char io_write_sec_text[1024];
					char source_addr_text[128];	
					char target_addr_text[128];	
					char netstat_file[1024];
					char tcp_state[16];
					char tcp_timeout[32];
					double helper;
					double diff;
					int threads;
					char *ptr;
					FILE *fp;


					strcpy(netstat_file,&quot;&quot;);
					strcpy(tcp_state,&quot;UNKNOWN&quot;);	
					strcpy(tcp_timeout,&quot;UNKNOWN&quot;);	
					bzero(lib,sizeof(lib));
					bzero(exe,sizeof(exe));
					bzero(stack,sizeof(stack));
					bzero(data,sizeof(data));
					bzero(procfile,sizeof(procfile));
					bzero(cmdline,sizeof(cmdline));
					bzero(io_read_text,sizeof(io_read_text));
					bzero(io_write_text,sizeof(io_write_text));
					bzero(io_read_sec_text,sizeof(io_read_sec_text));
					bzero(io_write_sec_text,sizeof(io_write_sec_text));
					bzero(source_addr_text,sizeof(source_addr_text));
					bzero(target_addr_text,sizeof(target_addr_text));
					bzero(cwd,512);


					sprintf(procfile,&quot;/proc/%d/cwd&quot;,servlist[idx].co[i].cpid);
					if ( readlink(procfile,cwd,512) &lt; 0 ){
						logger(prefix,&quot;####################### Failed to read symlink [%s]\n&quot;,procfile);
						strcpy(cwd,&quot;n.a.&quot;);
					}
					
					if ( servlist[idx].family == AF_INET6 ){
						int j;
				        	struct addrinfo *res;
       						struct addrinfo hints;
						struct sockaddr_in6 sin6;
						sprintf(netstat_file,&quot;/proc/net/tcp6&quot;);
						bzero(&amp;hints,sizeof(hints));
						hints.ai_family   = AF_INET6;
						hints.ai_flags    = AI_NUMERICHOST;
						hints.ai_socktype = SOCK_STREAM;
						if ( getaddrinfo(servlist[idx].co[i].source,NULL,&amp;hints,&amp;res)  ){
							logger(prefix,&quot;##################### FAILED TO CONVERT: [%s]\n&quot;,servlist[idx].co[i].source);
						} else {
							unsigned char hlp[16];
							unsigned long *x0,*x2,*x3,*x4;
							memcpy( (void *)&amp;sin6,(void *)res-&gt;ai_addr,res-&gt;ai_addrlen);
							hlp[0] = (unsigned char) sin6.sin6_addr.s6_addr[3];
							hlp[1] = (unsigned char) sin6.sin6_addr.s6_addr[2];
							hlp[2] = (unsigned char) sin6.sin6_addr.s6_addr[1];
							hlp[3] = (unsigned char) sin6.sin6_addr.s6_addr[0];
							hlp[4] = (unsigned char) sin6.sin6_addr.s6_addr[7];
							hlp[5] = (unsigned char) sin6.sin6_addr.s6_addr[6];
							hlp[6] = (unsigned char) sin6.sin6_addr.s6_addr[5];
							hlp[7] = (unsigned char) sin6.sin6_addr.s6_addr[4];
							hlp[8] = (unsigned char) sin6.sin6_addr.s6_addr[11];
							hlp[9] = (unsigned char) sin6.sin6_addr.s6_addr[10];
							hlp[10] = (unsigned char) sin6.sin6_addr.s6_addr[9];
							hlp[11] = (unsigned char) sin6.sin6_addr.s6_addr[8];
							hlp[12] = (unsigned char) sin6.sin6_addr.s6_addr[15];
							hlp[13] = (unsigned char) sin6.sin6_addr.s6_addr[14];
							hlp[14] = (unsigned char) sin6.sin6_addr.s6_addr[13];
							hlp[15] = (unsigned char) sin6.sin6_addr.s6_addr[12];
							strcpy(source_addr_text,&quot;&quot;);
							for ( j = 0; j &lt; 16; j++ ){
								sprintf(&amp;source_addr_text[strlen(source_addr_text)],&quot;%02X&quot;,(unsigned char) hlp[j]);
							}	
							sprintf(&amp;source_addr_text[strlen(source_addr_text)],&quot;:%04X&quot;,(unsigned int)servlist[idx].co[i].port);
							// logger(prefix,&quot;ADDRESS_CONV_SOURCE ********** [%s]:[%d] --&gt; [%s]\n&quot;,servlist[idx].co[i].source,servlist[idx].co[i].port,source_addr_text);
						}
						if ( getaddrinfo(servlist[idx].co[i].target,NULL,&amp;hints,&amp;res)  ){
							logger(prefix,&quot;##################### FAILED TO CONVERT: [%s]\n&quot;,servlist[idx].co[i].target);
						} else {
							unsigned char hlp[16];
							unsigned long *x0,*x2,*x3,*x4;
							memcpy( (void *)&amp;sin6,(void *)res-&gt;ai_addr,res-&gt;ai_addrlen);
							hlp[0] = (unsigned char) sin6.sin6_addr.s6_addr[3];
							hlp[1] = (unsigned char) sin6.sin6_addr.s6_addr[2];
							hlp[2] = (unsigned char) sin6.sin6_addr.s6_addr[1];
							hlp[3] = (unsigned char) sin6.sin6_addr.s6_addr[0];
							hlp[4] = (unsigned char) sin6.sin6_addr.s6_addr[7];
							hlp[5] = (unsigned char) sin6.sin6_addr.s6_addr[6];
							hlp[6] = (unsigned char) sin6.sin6_addr.s6_addr[5];
							hlp[7] = (unsigned char) sin6.sin6_addr.s6_addr[4];
							hlp[8] = (unsigned char) sin6.sin6_addr.s6_addr[11];
							hlp[9] = (unsigned char) sin6.sin6_addr.s6_addr[10];
							hlp[10] = (unsigned char) sin6.sin6_addr.s6_addr[9];
							hlp[11] = (unsigned char) sin6.sin6_addr.s6_addr[8];
							hlp[12] = (unsigned char) sin6.sin6_addr.s6_addr[15];
							hlp[13] = (unsigned char) sin6.sin6_addr.s6_addr[14];
							hlp[14] = (unsigned char) sin6.sin6_addr.s6_addr[13];
							hlp[15] = (unsigned char) sin6.sin6_addr.s6_addr[12];
							strcpy(target_addr_text,&quot;&quot;);
							for ( j = 0; j &lt; 16; j++ ){
								sprintf(&amp;target_addr_text[strlen(target_addr_text)],&quot;%02X&quot;,(unsigned char) hlp[j]);
							}	
							sprintf(&amp;target_addr_text[strlen(target_addr_text)],&quot;:%04X&quot;,(unsigned int)servlist[idx].co[i].t_port);
							// logger(prefix,&quot;ADDRESS_CONV_TARGET ********** [%s]:[%d] --&gt; [%s]\n&quot;,servlist[idx].co[i].target,servlist[idx].co[i].t_port,target_addr_text);
						}
					}	
					if ( servlist[idx].family == AF_INET ){
						int j;
				        	struct addrinfo *res;
       						struct addrinfo hints;
						struct sockaddr_in sin4;
						sprintf(netstat_file,&quot;/proc/net/tcp&quot;);
						bzero(&amp;hints,sizeof(hints));
						hints.ai_family   = AF_INET;
						hints.ai_flags    = AI_NUMERICHOST;
						hints.ai_socktype = SOCK_STREAM;
						if ( getaddrinfo(servlist[idx].co[i].source,NULL,&amp;hints,&amp;res)  ){
							logger(prefix,&quot;##################### FAILED TO CONVERT: [%s]\n&quot;,servlist[idx].co[i].source);
						} else {
							unsigned char hlp[16];
							unsigned long *x0,*x2,*x3,*x4;
							memcpy( (void *)&amp;sin4,(void *)res-&gt;ai_addr,res-&gt;ai_addrlen);
							hlp[0] = (unsigned char) (( sin4.sin_addr.s_addr &amp; 0xFF000000 ) &gt;&gt; 24 );
							hlp[1] = (unsigned char) (( sin4.sin_addr.s_addr &amp; 0x00FF0000 ) &gt;&gt; 16 );
							hlp[2] = (unsigned char) (( sin4.sin_addr.s_addr &amp; 0x0000FF00 ) &gt;&gt; 8 );
							hlp[3] = (unsigned char) (( sin4.sin_addr.s_addr &amp; 0x000000FF ) );
							strcpy(source_addr_text,&quot;&quot;);
							for ( j = 0; j &lt; 4; j++ ){
								sprintf(&amp;source_addr_text[strlen(source_addr_text)],&quot;%02X&quot;,(unsigned char) hlp[j]);
							}	
							sprintf(&amp;source_addr_text[strlen(source_addr_text)],&quot;:%04X&quot;,(unsigned int)servlist[idx].co[i].port);
							// logger(prefix,&quot;ADDRESS_CONV_SOURCE ********** [%s]:[%d] --&gt; [%s]\n&quot;,servlist[idx].co[i].source,servlist[idx].co[i].port,source_addr_text);
						}
						if ( getaddrinfo(servlist[idx].co[i].target,NULL,&amp;hints,&amp;res)  ){
							logger(prefix,&quot;##################### FAILED TO CONVERT: [%s]\n&quot;,servlist[idx].co[i].target);
						} else {
							unsigned char hlp[16];
							unsigned long *x0,*x2,*x3,*x4;
							memcpy( (void *)&amp;sin4,(void *)res-&gt;ai_addr,res-&gt;ai_addrlen);
							hlp[0] = (unsigned char) (( sin4.sin_addr.s_addr &amp; 0xFF000000 ) &gt;&gt; 24 );
							hlp[1] = (unsigned char) (( sin4.sin_addr.s_addr &amp; 0x00FF0000 ) &gt;&gt; 16 );
							hlp[2] = (unsigned char) (( sin4.sin_addr.s_addr &amp; 0x0000FF00 ) &gt;&gt; 8 );
							hlp[3] = (unsigned char) (( sin4.sin_addr.s_addr &amp; 0x000000FF ) );
							strcpy(target_addr_text,&quot;&quot;);
							for ( j = 0; j &lt; 4; j++ ){
								sprintf(&amp;target_addr_text[strlen(target_addr_text)],&quot;%02X&quot;,(unsigned char) hlp[j]);
							}	
							sprintf(&amp;target_addr_text[strlen(target_addr_text)],&quot;:%04X&quot;,(unsigned int)servlist[idx].co[i].t_port);
							// logger(prefix,&quot;ADDRESS_CONV_TARGET ********** [%s]:[%d] --&gt; [%s]\n&quot;,servlist[idx].co[i].target,servlist[idx].co[i].t_port,target_addr_text);
						}
					}	
					if ( strlen(netstat_file) &amp;&amp; (fp = fopen(netstat_file,&quot;r&quot;)) != NULL ){
						char buf[1024];
						while ( fgets(buf,1024,fp) != NULL ){
							int state;
							int timer_mode;
							unsigned long timer_value;
							if ( strstr(buf,&quot;:&quot;) == NULL ) continue;
							ptr = strtok(buf,&quot; \t\r\n&quot;);
							if ( ptr == NULL ) continue;
							ptr = strtok(NULL,&quot; \t\r\n&quot;);
							if ( ptr == NULL ) continue;
							if ( strcmp(ptr,target_addr_text) != 0 ) continue;
							ptr = strtok(NULL,&quot; \t\r\n&quot;);
							if ( ptr == NULL ) continue;
							if ( strcmp(ptr,source_addr_text) != 0 ) continue;
							ptr = strtok(NULL,&quot; \t\r\n&quot;);
							if ( ptr == NULL ) continue;
							sscanf(ptr,&quot;%02X&quot;,&amp;state);
							ptr = strtok(NULL,&quot; \t\r\n&quot;);
							if ( ptr == NULL ) continue;
							ptr = strtok(NULL,&quot; \t\r\n&quot;);
							if ( ptr == NULL ) continue;
							sscanf(ptr,&quot;%02X:%08lX&quot;,&amp;timer_mode,&amp;timer_value);
							// logger(prefix,&quot;NETSTAT_CONV_(%s) --&gt; [0x%02X] Timer: [0x%02X] Timer-Value: [0x%08lX]\n&quot;,netstat_file,state,timer_mode,timer_value);
							switch ( timer_mode ){
								case 0: sprintf(tcp_timeout,&quot;&quot;);
									break;
								case 1: sprintf(tcp_timeout,&quot;Retrans.&amp;nbsp;%d&amp;nbsp;s&quot;,timer_value);
									break;
								case 2: sprintf(tcp_timeout,&quot;Other&amp;nbsp;%d&amp;nbsp;s&quot;,timer_value);
									break;
								case 3: sprintf(tcp_timeout,&quot;TIME_WAIT&amp;nbsp;%d&amp;nbsp;s&quot;,timer_value);
									break;
								case 4: sprintf(tcp_timeout,&quot;ZERO_WIN&amp;nbsp;%d&amp;nbsp;s&quot;,timer_value);
									break;
								default: 
									sprintf(tcp_timeout,&quot;[0x%02X]&amp;nbsp;%d&amp;nbsp;s&quot;,timer_mode,timer_value);
									break;
							}
							switch ( state ){
									case 0x01: 
										strcpy(tcp_state,&quot;ESTABLISHED&quot;);
										break;
									case 0x02: 
										strcpy(tcp_state,&quot;SYN_SENT&quot;);
										break;
									case 0x03: 
										strcpy(tcp_state,&quot;SYN_RECV&quot;);
										break;
									case 0x04: 
										strcpy(tcp_state,&quot;FIN_WAIT1&quot;);
										break;
									case 0x05: 
										strcpy(tcp_state,&quot;FIN_WAIT2&quot;);
										break;
									case 0x06: 
										strcpy(tcp_state,&quot;TIME_WAIT&quot;);
										break;
									case 0x07: 
										strcpy(tcp_state,&quot;CLOSE&quot;);
										break;
									case 0x08: 
										strcpy(tcp_state,&quot;CLOSE_WAIT&quot;);
										break;
									case 0x09: 
										strcpy(tcp_state,&quot;LAST_ACK&quot;);
										break;
									case 0x0A: 
										strcpy(tcp_state,&quot;LISTEN&quot;);
										break;
									case 0x0B: 
										strcpy(tcp_state,&quot;CLOSING&quot;);
										break;
									default: 
										sprintf(tcp_state,&quot;UNKNOWN(%02X)&quot;,state);
										break;
							}
						}
						fclose(fp);
					}
						
					sprintf(stack,&quot;- kB&quot;);
					sprintf(data,&quot;- kB&quot;);
					sprintf(exe,&quot;- kB&quot;);
					threads = 1;
					sprintf(procfile,&quot;/proc/%d/status&quot;,servlist[idx].co[i].cpid);
					fp = fopen(procfile,&quot;r&quot;);
					if ( fp != NULL ){
						while ( fgets(cmdline,1024,fp) != NULL ){
							if ( strncmp(cmdline,&quot;VmData:&quot;,strlen(&quot;VmData:&quot;)) == 0 ){
								ptr = &amp;cmdline[strlen(&quot;VmData:&quot;)];
								while ( *ptr &amp;&amp; (*ptr == &#039; &#039; || *ptr == &#039;\t&#039; ) ) ptr++;
								strcpy(data,ptr);
								ptr = &amp;data[strlen(data)-1];
								while ( ptr &gt; data &amp;&amp; ( *ptr == &#039;\r&#039; || *ptr == &#039;\n&#039; ) )ptr--;
								if ( ptr &gt; data ) ptr++;
								*ptr = &#039;\0&#039;;
								continue;
							}
							if ( strncmp(cmdline,&quot;VmStk:&quot;,strlen(&quot;VmStk:&quot;)) == 0 ){
								ptr = &amp;cmdline[strlen(&quot;VmStk:&quot;)];
								while ( *ptr &amp;&amp; (*ptr == &#039; &#039; || *ptr == &#039;\t&#039; ) ) ptr++;
								strcpy(stack,ptr);
								ptr = &amp;stack[strlen(stack)-1];
								while ( ptr &gt; stack &amp;&amp; ( *ptr == &#039;\r&#039; || *ptr == &#039;\n&#039; ) )ptr--;
								if ( ptr &gt; stack ) ptr++;
								*ptr = &#039;\0&#039;;
								continue;
							}
							if ( strncmp(cmdline,&quot;VmExe:&quot;,strlen(&quot;VmExe:&quot;)) == 0 ){
								ptr = &amp;cmdline[strlen(&quot;VmExe:&quot;)];
								while ( *ptr &amp;&amp; (*ptr == &#039; &#039; || *ptr == &#039;\t&#039; ) ) ptr++;
								strcpy(exe,ptr);
								ptr = &amp;exe[strlen(exe)-1];
								while ( ptr &gt; exe &amp;&amp; ( *ptr == &#039;\r&#039; || *ptr == &#039;\n&#039; ) )ptr--;
								if ( ptr &gt; exe ) ptr++;
								*ptr = &#039;\0&#039;;
								continue;
							}
							if ( strncmp(cmdline,&quot;VmLib:&quot;,strlen(&quot;VmLib:&quot;)) == 0 ){
								ptr = &amp;cmdline[strlen(&quot;VmLib:&quot;)];
								while ( *ptr &amp;&amp; (*ptr == &#039; &#039; || *ptr == &#039;\t&#039; ) ) ptr++;
								strcpy(lib,ptr);
								ptr = &amp;lib[strlen(lib)-1];
								while ( ptr &gt; lib &amp;&amp; ( *ptr == &#039;\r&#039; || *ptr == &#039;\n&#039; ) )ptr--;
								if ( ptr &gt; lib ) ptr++;
								*ptr = &#039;\0&#039;;
								continue;
							}
						}
						fclose(fp);
					}
					sprintf(procfile,&quot;/proc/%d/io&quot;,servlist[idx].co[i].cpid);
					fp = fopen(procfile,&quot;r&quot;);
					_io_read  = 0;
					_io_write = 0;
					if ( fp != NULL ){
						while ( fgets(cmdline,1024,fp) != NULL ){
							if ( strncmp(cmdline,&quot;rchar:&quot;,strlen(&quot;rchar:&quot;)) == 0 ){
								ptr = &amp;cmdline[strlen(&quot;rchar:&quot;)];
								while ( *ptr &amp;&amp; (*ptr == &#039; &#039; || *ptr == &#039;\t&#039; ) ) ptr++;
								_io_read = atoll(ptr);
								continue;
							}
							if ( strncmp(cmdline,&quot;wchar:&quot;,strlen(&quot;wchar:&quot;)) == 0 ){
								ptr = &amp;cmdline[strlen(&quot;wchar:&quot;)];
								while ( *ptr &amp;&amp; (*ptr == &#039; &#039; || *ptr == &#039;\t&#039; ) ) ptr++;
								_io_write = atoll(ptr);
								continue;
							}
						}
						fclose(fp);
					}
#define BIG1024 (1024.0)
					diff = (double) (time(NULL) - servlist[idx].co[i].created);
					if ( diff &lt;= 0 ) diff = 1.0; // Avoid division by zero
					io_read = (double) _io_read;
					io_read_sec = io_read / diff;
					sprintf(io_read_text,&quot;%d&amp;nbsp;Bytes&quot;,(int)io_read);
					if ( io_read &gt; 1024.0 ){
						sprintf(io_read_text,&quot;%.02f&amp;nbsp;kB&quot;,io_read / BIG1024);
					}
					if ( io_read &gt; (BIG1024*BIG1024) ){
						sprintf(io_read_text,&quot;%.02f&amp;nbsp;MB&quot;,io_read / (BIG1024 * BIG1024));
					}
					if ( io_read &gt; (BIG1024*BIG1024*BIG1024) ){
						sprintf(io_read_text,&quot;%.02f&amp;nbsp;GB&quot;,io_read / (BIG1024 * BIG1024 * BIG1024));
					}
					if ( io_read &gt; (BIG1024*BIG1024*BIG1024*BIG1024) ){
						sprintf(io_read_text,&quot;%.02f&amp;nbsp;TB&quot;,io_read / (BIG1024 * BIG1024 * BIG1024 * BIG1024));
					}
					if ( io_read &gt; (BIG1024*BIG1024*BIG1024*BIG1024*BIG1024) ){
						sprintf(io_read_text,&quot;%.02f&amp;nbsp;PB&quot;,io_read / (BIG1024 * BIG1024 * BIG1024 * BIG1024 * BIG1024));
					}
					sprintf(io_read_sec_text,&quot;%d Bytes/s&quot;,(int)io_read_sec);
					if ( io_read_sec &gt; 1024.0 ){
						sprintf(io_read_sec_text,&quot;%.02f&amp;nbsp;kBytes/s&quot;,io_read_sec/1024.0);
					}
					if ( io_read_sec &gt; (1024.0*1024.0) ){
						sprintf(io_read_sec_text,&quot;%.02f&amp;nbsp;MBytes/s&quot;,io_read_sec/(1024.0 * 1024.0));
					}
					if ( io_read_sec &gt; (1024.0*1024.0*1024.0) ){
						sprintf(io_read_sec_text,&quot;%.02f&amp;nbsp;GBytes/s&quot;,io_read_sec/(1024.0 * 1024.0 * 1024.0));
					}
					if ( io_read_sec &gt; (1024.0*1024.0*1024.0*1024.0) ){
						sprintf(io_read_sec_text,&quot;%.02f&amp;nbsp;TBytes/s&quot;,io_read_sec/(1024.0 * 1024.0 * 1024.0 * 1024.0));
					}
					if ( io_read_sec &gt; (1024.0*1024.0*1024.0*1024.0*1024.0) ){
						sprintf(io_read_sec_text,&quot;%.02f&amp;nbsp;PBytes/s&quot;,io_read_sec/(1024.0 * 1024.0 * 1024.0 * 1024.0 * 1024.0));
					}
					io_write = (double) _io_write;
					io_write_sec = io_write / diff;
					sprintf(io_write_text,&quot;%d&amp;nbsp;Bytes&quot;,(int)io_write);
					if ( io_write &gt; 1024.0 ){
						sprintf(io_write_text,&quot;%.02f&amp;nbsp;kB&quot;,io_write / BIG1024);
					}
					if ( io_write &gt; (BIG1024*BIG1024) ){
						sprintf(io_write_text,&quot;%.02f&amp;nbsp;MB&quot;,io_write / (BIG1024 * BIG1024));
					}
					if ( io_write &gt; (BIG1024*BIG1024*BIG1024) ){
						sprintf(io_write_text,&quot;%.02f&amp;nbsp;GB&quot;,io_write / (BIG1024 * BIG1024 * BIG1024));
					}
					if ( io_write &gt; (BIG1024*BIG1024*BIG1024*BIG1024) ){
						sprintf(io_write_text,&quot;%.02f&amp;nbsp;TB&quot;,io_write / (BIG1024 * BIG1024 * BIG1024 * BIG1024));
					}
					if ( io_write &gt; (BIG1024*BIG1024*BIG1024*BIG1024*BIG1024) ){
						sprintf(io_write_text,&quot;%.02f&amp;nbsp;PB&quot;,io_write / (BIG1024 * BIG1024 * BIG1024 * BIG1024 * BIG1024));
					}
					sprintf(io_write_sec_text,&quot;%d&amp;nbsp;Bytes/s&quot;,(int)io_write_sec);
					if ( io_write_sec &gt; 1024.0 ){
						sprintf(io_write_sec_text,&quot;%.02f&amp;nbsp;kBytes/s&quot;,io_write_sec/1024.0);
					}
					if ( io_write_sec &gt; (1024.0*1024.0) ){
						sprintf(io_write_sec_text,&quot;%.0fg&amp;nbsp;MBytes/s&quot;,io_write_sec/(1024.0 * 1024.0));
					}
					if ( io_write_sec &gt; (1024.0*1024.0*1024.0) ){
						sprintf(io_write_sec_text,&quot;%.02f&amp;nbsp;GBytes/s&quot;,io_write_sec/(1024.0 * 1024.0 * 1024.0));
					}
					if ( io_write_sec &gt; (1024.0*1024.0*1024.0*1024.0) ){
						sprintf(io_write_sec_text,&quot;%.02f&amp;nbsp;TBytes/s&quot;,io_write_sec/(1024.0 * 1024.0 * 1024.0 * 1024.0));
					}
					if ( io_write_sec &gt; (1024.0*1024.0*1024.0*1024.0*1024.0) ){
						sprintf(io_write_sec_text,&quot;%.02f&amp;nbsp;PBytes/s&quot;,io_write_sec/(1024.0 * 1024.0 * 1024.0 * 1024.0 * 1024.0));
					}



					sprintf(procfile,&quot;/proc/%d/exe&quot;,servlist[idx].co[i].cpid);
					bzero(cmdline,1024);
					if ( readlink(procfile,cmdline,1024) &lt; 0 ){
						sprintf(cmdline,&quot;Executable not found&quot;);
					} 
					{
						char copy[1024];
						char *in;
						char *out;
						strcpy(copy,stack);
						in = copy;
						out = stack;
						while ( *in ){
							if ( *in == &#039; &#039; || *in == &#039;\t&#039; ){
								*out = &#039;&amp;&#039;;	
								out++;
								*out = &#039;n&#039;;	
								out++;
								*out = &#039;b&#039;;	
								out++;
								*out = &#039;s&#039;;	
								out++;
								*out = &#039;p&#039;;	
								out++;
								*out = &#039;;&#039;;	
								out++;
								in++; 
							} else {
								*out = *in;
								in++; out++;
							}
						}
						*out = &#039;\0&#039;;
						strcpy(copy,data);
						in = copy;
						out = data;
						while ( *in ){
							if ( *in == &#039; &#039; || *in == &#039;\t&#039; ){
								*out = &#039;&amp;&#039;;	
								out++;
								*out = &#039;n&#039;;	
								out++;
								*out = &#039;b&#039;;	
								out++;
								*out = &#039;s&#039;;	
								out++;
								*out = &#039;p&#039;;	
								out++;
								*out = &#039;;&#039;;	
								out++;
								in++; 
							} else {
								*out = *in;
								in++; out++;
							}
						}
						*out = &#039;\0&#039;;
						strcpy(copy,lib);
						in = copy;
						out = lib;
						while ( *in ){
							if ( *in == &#039; &#039; || *in == &#039;\t&#039; ){
								*out = &#039;&amp;&#039;;	
								out++;
								*out = &#039;n&#039;;	
								out++;
								*out = &#039;b&#039;;	
								out++;
								*out = &#039;s&#039;;	
								out++;
								*out = &#039;p&#039;;	
								out++;
								*out = &#039;;&#039;;	
								out++;
								in++; 
							} else {
								*out = *in;
								in++; out++;
							}
						}
						*out = &#039;\0&#039;;
						strcpy(copy,exe);
						in = copy;
						out = exe;
						while ( *in ){
							if ( *in == &#039; &#039; || *in == &#039;\t&#039; ){
								*out = &#039;&amp;&#039;;	
								out++;
								*out = &#039;n&#039;;	
								out++;
								*out = &#039;b&#039;;	
								out++;
								*out = &#039;s&#039;;	
								out++;
								*out = &#039;p&#039;;	
								out++;
								*out = &#039;;&#039;;	
								out++;
								in++; 
							} else {
								*out = *in;
								in++; out++;
							}
						}
						*out = &#039;\0&#039;;
					}
					
					tm = localtime(&amp;servlist[idx].co[i].created);
					sprintf(line,&quot;{\&quot;cwd\&quot;:\&quot;%s\&quot;,\&quot;slot\&quot;:\&quot;%d/%d\&quot;,\&quot;tcp_state\&quot;:\&quot;%s\&quot;,\&quot;tcp_timeout\&quot;:\&quot;%s\&quot;,\&quot;io_read\&quot;:\&quot;%s\&quot;,\&quot;io_read_sec\&quot;:\&quot;%s\&quot;,\&quot;io_write\&quot;:\&quot;%s\&quot;,\&quot;io_write_sec\&quot;:\&quot;%s\&quot;,\&quot;vm_stack\&quot;:\&quot;%s\&quot;,\&quot;vm_lib\&quot;:\&quot;%s\&quot;,\&quot;vm_exe\&quot;:\&quot;%s\&quot;,\&quot;vm_data\&quot;:\&quot;%s\&quot;,\&quot;cmdline\&quot;:\&quot;%s\&quot;,\&quot;index\&quot;:%d,\&quot;pid\&quot;:%d,\&quot;cpid\&quot;:%d,\&quot;source\&quot;:\&quot;%s\&quot;,\&quot;target\&quot;:\&quot;%s\&quot;,\&quot;source_port\&quot;:%d,\&quot;target_port\&quot;:%d,\&quot;created\&quot;:\&quot;%04d.%02d.%02d&amp;nbsp;%02d:%02d:%02d\&quot;},&quot;,
						cwd, i,idx, tcp_state,tcp_timeout,
						io_read_text,io_read_sec_text,
						io_write_text,io_write_sec_text,
						stack,lib,exe,data, cmdline, i,servlist[idx].co[i].pid,servlist[idx].co[i].cpid,servlist[idx].co[i].source,servlist[idx].co[i].target,servlist[idx].co[i].port,servlist[idx].co[i].t_port,tm-&gt;tm_year + 1900, tm-&gt;tm_mon + 1, tm-&gt;tm_mday,
						 tm-&gt;tm_hour, tm-&gt;tm_min, tm-&gt;tm_sec);	
					result = (char *)realloc(result, strlen(result) + strlen(line) + 1 );
					strcat(result,line);
				}	
			}
			sem_unlock(semid2);	
			if ( result[strlen(result)-1] == &#039;,&#039; ) result[strlen(result)-1] = &#039;\0&#039;;
			strcat(result,&quot;]&quot;);
			{
				char *in;
				char *out;
				int newsize;
				in = (char *)malloc(strlen(result) + 20);
				out = (char *)malloc(strlen(result) + 120);
				sprintf(in,&quot;OK[%s]\r\n&quot;,result);
				newsize = gzip_string(in,out);
				if ( newsize &gt; 0 ){
					fprintf(ss,&quot;Accept-Range: bytes\r\n&quot;);
					fprintf(ss,&quot;Content-Length: %d\r\n&quot;,newsize);	
					fprintf(ss,&quot;Content-Encoding: gzip\r\n\r\n&quot;,newsize);	
					fwrite(out,1,newsize,ss);
					fflush(ss);
				} else {
					logger(prefix,&quot;GZIP-FAILED: [%d] &lt;-- [%d]\n&quot;,newsize,strlen(in));
					fprintf(ss,&quot;\r\n%s&quot;,in);
				}
			}
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;		
		}
		if ( strcmp(command,&quot;KILLTCP&quot;) == 0 ){
			int pid;
			int slot,index;
			char *ptr;
			fprintf(ss,&quot;\r\n&quot;);
			logger(prefix,&quot;KILLTCP ARGUMNET: [%s]\n&quot;,argument);
			slot = atoi(argument);
			ptr = argument;
			while ( *ptr &amp;&amp; *ptr != &#039;/&#039; ) ptr++; 
			if ( *ptr == &#039;/&#039; ){
				logger(prefix,&quot;KILLTCP 2 ARGUMNET: %d, PTR: [%s]\n&quot;,argument,ptr);
				ptr++;
				index = atoi(ptr);
				if ( servlist[slot].co[index].pid != 0 ) m_kill(servlist[slot].co[index].pid,SIGTERM); 
				fprintf(ss,&quot;OK[Sent SIGTERM to %d]\r\n&quot;,pid);
			}
			
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}

		if ( strcmp(command,&quot;CONNSCOUNT&quot;) == 0 ){
			int idx;
			fprintf(ss,&quot;\r\n&quot;);
			idx = atoi(argument);
			if ( idx &gt;= entries ){
				fprintf(ss,&quot;ERR[Bad index]\r\n&quot;);
			} else {
				struct tm *tm;
				int semmel;
				tm = localtime(&amp;servlist[idx].reset);
				semmel = semget(INETD_KEY2 + idx,1,0);
				if ( semmel &lt; 0 ){
					logger(prefix,&quot;Cannot get SEM [0x%08lX]\n&quot;,INETD_KEY2 + idx);
				} else {
					sem_lock(semmel);
					fprintf(ss,&quot;OK[{\&quot;connections\&quot;:%d,\&quot;total_count\&quot;:%d,\&quot;reset\&quot;:\&quot;%04d.%02d.%02d %02d:%02d:%02d\&quot;,\&quot;max_conns\&quot;:%d,\&quot;pid\&quot;:%d}]\r\n&quot;,servlist[idx].connections,servlist[idx].total_count,
						tm-&gt;tm_year + 1900, tm-&gt;tm_mon + 1, tm-&gt;tm_mday,
						tm-&gt;tm_hour, tm-&gt;tm_min, tm-&gt;tm_sec, servlist[idx].max_conns,servlist[idx].pid);
					sem_unlock(semmel);
				}
			}
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}
		if ( strcmp(command,&quot;SIGNAL&quot;) == 0 ){
			int pid;
			int sig;
			char *ptr;
			fprintf(ss,&quot;\r\n&quot;);
			pid = atoi(argument);
			ptr = argument;
			while ( *ptr &amp;&amp; *ptr != &#039;/&#039; ) ptr++;
			if ( *ptr != &#039;/&#039; ){
				fprintf(ss,&quot;ERR[No Signal given!]\r\n&quot;);
				fflush(ss);
				shutdown(sock,SHUT_RDWR);
				fclose(ss);
				return;
			}
			ptr++;
			sig = atoi(ptr);
			logger(prefix,&quot;SIGNAL %d TO %d\n&quot;,sig,pid);
			if ( pid == getpid() || pid == getppid() || pid &lt; 100 ){
				fprintf(ss,&quot;ERR[No Signal to myself or parent or PID &lt; 100!]\r\n&quot;);
				fflush(ss);
				shutdown(sock,SHUT_RDWR);
				fclose(ss);
				return;
			}
			kill(pid,sig);
			fprintf(ss,&quot;OK[Signal sent!]\r\n&quot;);
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}
		if ( strcmp(command,&quot;SYSINFO&quot;) == 0 ){
			double load[3];
			char uptimer[1024];
			struct sysinfo sys;
			int idx;
			int semmel;
			char *json_list;
			char *tftp_list;
			char *dhcp_list;
			char *result;
			getloadavg(load,3);	
			sysinfo(&amp;sys);
			// Get count of connections 

			if ( gix_options-&gt;dhcp_enabled ){
				FILE *in;
				int lockfd;
				dhcp_list = strdup(&quot;\&quot;dhcp_enabled\&quot;:1,\&quot;dhcp_ipv4_leases\&quot;:[&quot;);
				lockfd = lock_file(DHCP_IP_LEASES_FILE_LOCK);
				in = fopen(DHCP_IP_LEASES_FILE,&quot;r&quot;);
				if ( in != NULL ){

					struct dhcp_ip_file_entry_t *entry;

					u_int8_t entry_buffer[sizeof(struct dhcp_ip_file_entry_t)+DHCP_MAX_OPTSIZE];

					entry = (struct dhcp_ip_file_entry_t *)entry_buffer;

					while ( fread(entry,sizeof(struct dhcp_ip_file_entry_t),1,in) == 1 ){
						char hostname[2256];
						int hostname_len;
						char class_id[2256];
						int class_id_len;
						char templine[2024];
						char ip_helper[128];
						struct tm tm;
						bzero(hostname,2256);
						bzero(class_id,2256);
						if ( entry-&gt;optlen ){
							int iii;
							fread(entry-&gt;opts,entry-&gt;optlen,1,in);
							iii = 0;
							while ( iii &lt; entry-&gt;optlen ){
								u_int8_t optind;
								u_int8_t optlen; 
								optind = entry-&gt;opts[iii++];
								optlen = entry-&gt;opts[iii++];
								if ( optind == 60 ){
									strcpy(class_id,make_json_print(&amp;entry-&gt;opts[iii],(int) optlen));
									class_id_len = (int) optlen;
								}	
								if ( optind == 12 ){
									strcpy(hostname,make_json_print(&amp;entry-&gt;opts[iii],(int) optlen));
									hostname_len = (int) optlen;
								}	
								iii += optlen; 
							}
							
						}
						bzero(ip_helper,128);
						sprintf(templine,&quot;{\&quot;hostname\&quot;:\&quot;%s\&quot;,\&quot;hostname_len\&quot;:%d,\&quot;class_id\&quot;:\&quot;%s\&quot;,\&quot;class_id_len\&quot;:%d,&quot;,
							hostname, hostname_len, class_id, class_id_len);
						sprintf(&amp;templine[strlen(templine)],&quot;\&quot;mac\&quot;:\&quot;%s\&quot;,&quot;,dump_mac_addr(entry-&gt;mac));
						inet_ntop(AF_INET,&amp;entry-&gt;ip,ip_helper,128);
						sprintf(&amp;templine[strlen(templine)],&quot;\&quot;ip\&quot;:\&quot;%s\&quot;,&quot;,ip_helper);
						localtime_r(&amp;entry-&gt;created,&amp;tm); 
						sprintf(ip_helper,&quot;%04d.%02d.%02d %02d:%02d:%02d&quot;,
							tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
							tm.tm_hour, tm.tm_min, tm.tm_sec);	
						sprintf(&amp;templine[strlen(templine)],&quot;\&quot;created\&quot;:\&quot;%s\&quot;,&quot;,ip_helper);
						localtime_r(&amp;entry-&gt;changed,&amp;tm); 
						sprintf(ip_helper,&quot;%04d.%02d.%02d %02d:%02d:%02d&quot;,
							tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
							tm.tm_hour, tm.tm_min, tm.tm_sec);	
						sprintf(&amp;templine[strlen(templine)],&quot;\&quot;changed\&quot;:\&quot;%s\&quot;,&quot;,ip_helper);
						localtime_r(&amp;entry-&gt;expiry,&amp;tm); 
						sprintf(ip_helper,&quot;%04d.%02d.%02d %02d:%02d:%02d&quot;,
							tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
							tm.tm_hour, tm.tm_min, tm.tm_sec);	
						sprintf(&amp;templine[strlen(templine)],&quot;\&quot;expiry\&quot;:\&quot;%s\&quot;,\&quot;optlen\&quot;:%d},&quot;,ip_helper,entry-&gt;optlen);
						dhcp_list = (char *)realloc(dhcp_list,strlen(templine)+2+strlen(dhcp_list));
						strcat(dhcp_list,templine);
					}
					fclose(in);
				}
				unlock_file(lockfd);
				dhcp_list = (char *)realloc(dhcp_list,strlen(dhcp_list) + 100);
				if ( dhcp_list[strlen(dhcp_list)-1] == &#039;,&#039; ) dhcp_list[strlen(dhcp_list)-1] = &#039;\0&#039;;
				strcat(dhcp_list,&quot;],\&quot;dhcp_ipv6_leases\&quot;:[&quot;);
				in = fopen(DHCP_IP6_LEASES_FILE,&quot;r&quot;);
				if ( in != NULL ){
					struct dhcp_ip6_file_entry_t entry;
					while ( fread(&amp;entry,sizeof(entry),1,in) == 1 ){
						char templine[1024];
					}
					fclose(in);
				}
				dhcp_list = (char *)realloc(dhcp_list,strlen(dhcp_list) + 100);
				if ( dhcp_list[strlen(dhcp_list)-1] == &#039;,&#039; ) dhcp_list[strlen(dhcp_list)-1] = &#039;\0&#039;;
				strcat(dhcp_list,&quot;]&quot;);
				
			} else {
				dhcp_list = strdup(&quot;\&quot;dhcp_enabled\&quot;:0,\&quot;dhcp_ipv4_leases\&quot;:[],\&quot;dhcp_ipv6_leases\&quot;:[]&quot;);
			}
			tftp_list = strdup(&quot;[&quot;);
			if ( gix_options-&gt;tftp_enabled ){
				char line[1024];
				int iid;
				// logger(prefix,&quot;SYSINFO starting parsing %d TFTP-Sessions\n&quot;,MAX_TFTP_SESSIONS);
				for ( iid = 0; iid &lt; MAX_TFTP_SESSIONS; iid++ ){
					if ( gix_options-&gt;tr[iid].active ){
						sprintf(line,&quot;{\&quot;started\&quot;:%ld,\&quot;lastaction\&quot;:%ld,\&quot;filename\&quot;:\&quot;%s\&quot;,\&quot;remote_ip\&quot;:\&quot;%s\&quot;,\&quot;offset\&quot;:%ld,\&quot;fullsize\&quot;:%ld,\&quot;blksize\&quot;:%d,\&quot;kind_transfer\&quot;:\&quot;%s\&quot;},&quot;,
							gix_options-&gt;tr[iid].started,
							gix_options-&gt;tr[iid].lastaction,
							gix_options-&gt;tr[iid].filename,
							gix_options-&gt;tr[iid].ipname,
							gix_options-&gt;tr[iid].offset,
							gix_options-&gt;tr[iid].fullsize,
							gix_options-&gt;tr[iid].packsize,
							gix_options-&gt;tr[iid].kind_request == TFTP_REQUEST_READ ? &quot;READ&quot; : &quot;WRITE&quot;);
						tftp_list = (char *)realloc((char *)tftp_list,strlen(tftp_list) + strlen(line) + 10);
						strcat(tftp_list,line);
				
					}
				}
			}
			tftp_list = (char *)realloc((char *)tftp_list,strlen(tftp_list) + 10);
			if ( tftp_list[strlen(tftp_list)-1] == &#039;,&#039; ) tftp_list[strlen(tftp_list)-1] = &#039;\0&#039;;
			strcat(tftp_list,&quot;]&quot;);
			// logger(prefix,&quot;SYSINFO TFTP processed [%d Bytes]\n&quot;,strlen(tftp_list));


			json_list = strdup(&quot;[&quot;);
			for ( idx = 0; (semmel = semget(INETD_KEY2 + idx,1,0)) &gt;= 0; idx++ ){
				char line[1024];
				struct tm *tm;
				tm = localtime(&amp;servlist[idx].reset);
				sem_lock(semmel);
				sprintf(line,&quot;{\&quot;connections\&quot;:%d,\&quot;total_count\&quot;:%d,\&quot;reset\&quot;:\&quot;%04d.%02d.%02d %02d:%02d:%02d\&quot;,\&quot;max_conns\&quot;:%d,\&quot;pid\&quot;:%d},&quot;,
					servlist[idx].connections,servlist[idx].total_count,
					tm-&gt;tm_year + 1900, tm-&gt;tm_mon + 1, tm-&gt;tm_mday,tm-&gt;tm_hour, tm-&gt;tm_min, tm-&gt;tm_sec, servlist[idx].max_conns,servlist[idx].pid);
				sem_unlock(semmel);
				json_list = (char *)realloc(json_list,strlen(json_list) + strlen(line) + 10);
				strcat(json_list,line);
			}	
			json_list = (char *)realloc(json_list,strlen(json_list) + 10);
			if ( json_list[strlen(json_list)-1] == &#039;,&#039; ) json_list[strlen(json_list)-1] = &#039;\0&#039;;
			sprintf(&amp;json_list[strlen(json_list)],&quot;]&quot;);
			// logger(prefix,&quot;SYSINFO INETD-LIST processed [%d Bytes]\n&quot;,strlen(json_list));

			result = (char *)malloc(strlen(json_list) +  2048 + strlen(tftp_list) + strlen(dhcp_list));
			
			sprintf(result,&quot;{\&quot;tftp_requests_read\&quot;:%d,\&quot;tftp_requests_write\&quot;:%d,\&quot;tftp_enabled\&quot;:\&quot;%d\&quot;,\&quot;tftp_readonly\&quot;:\&quot;%d\&quot;,\&quot;tftp_root\&quot;:\&quot;%s\&quot;,\&quot;tftp_list\&quot;:%s,\&quot;load1\&quot;:\&quot;%.02g\&quot;,\&quot;load5\&quot;:\&quot;%.02g\&quot;,\&quot;load15\&quot;:\&quot;%.02g\&quot;,\&quot;sys_procs\&quot;:%d,\&quot;uptime\&quot;:\&quot;%s\&quot;,\&quot;inetlist\&quot;:%s,%s}&quot;,
				gix_options-&gt;tftp_requests_read, 
				gix_options-&gt;tftp_requests_write, 
				gix_options-&gt;tftp_enabled, 
				gix_options-&gt;tftp_readonly, 
				gix_options-&gt;tftp_root, 
				tftp_list,
				load[0],load[1],load[2],sys.procs,gix_display_uptime(0,NULL,uptimer),json_list,dhcp_list);
			{
				char *in;
				char *out;
				int newsize;
				in = (char *)malloc(strlen(result) + 20);
				out = (char *)malloc(strlen(result) + 120);
				sprintf(in,&quot;OK[%s]\r\n&quot;,result);
				newsize = gzip_string(in,out);
				if ( newsize &gt; 0 ){
					fprintf(ss,&quot;Accept-Range: bytes\r\n&quot;);
					fprintf(ss,&quot;Content-Length: %d\r\n&quot;,newsize);	
					fprintf(ss,&quot;Content-Encoding: gzip\r\n\r\n&quot;,newsize);	
					fwrite(out,1,newsize,ss);
					fflush(ss);
				} else {
					logger(prefix,&quot;GZIP-FAILED: [%d] &lt;-- [%d]\n&quot;,newsize,strlen(in));
					fprintf(ss,&quot;\r\n%s&quot;,in);
				}
			}
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			free(result);
			free(tftp_list);
			free(json_list);
			return;
		}
		if ( strcmp(command,&quot;PROCDETAIL&quot;) == 0 ){
			int pid; 
			char *result;
                	struct sysinfo sys;
			struct timeval start;
			struct timeval end;
			long utime_ticks;
			long stime_ticks;
			long utime_ticks2;
			long stime_ticks2;
			double cpu_usage_usr;
			double cpu_usage_sys;
			char fname[1024];
			char exe[1024];
			char *helper;
			char full_exe[1024];
			char full_cwd[1024];
			char commandline[1024];
			int r_gid, r_uid;
			int e_gid, e_uid;
			int c_argc;
			char state;
			int ppid;
			long nice;
			long priority;
			long num_threads;
			long rss;
			int cpu_id;
			char *ptr;
			unsigned long vmsize;
			long long starttime;
			time_t p_start;
			FILE *fp;
			int slot, index;
			int fds;
			DIR *dir;
			struct dirent *diry;
			char dirname[1024];
			char *fd_array;
			fprintf(ss,&quot;\r\n&quot;);

			slot = -1;
			index = -1;	

			sysinfo(&amp;sys);
			pid = atoi(argument);


			sprintf(dirname,&quot;/proc/%d/fd&quot;,pid);

			dir = opendir(dirname);

			fds = 0;

			fd_array = strdup(&quot;[&quot;);

			if ( dir != NULL ){
				while ( (diry = readdir(dir)) != NULL ){
					char help2[1024];
					char lname[1024];
					char ltarget[1024];
					char addrinfo[256];
					char type[1024];
					unsigned long inode;
					struct socket_info *si;

					bzero(addrinfo,256);

					sprintf(addrinfo,&quot;\&quot;valid_addr\&quot;:false,&quot;);

					if ( !isdigit(diry-&gt;d_name[0]) ) continue;
					sprintf(lname,&quot;/proc/%d/fd/%s&quot;,pid,diry-&gt;d_name);
					bzero(ltarget,1024);
					if ( readlink(lname,ltarget,1024) &lt; 0 ) continue;
					sprintf(type,&quot;file&quot;);
					if ( strncmp(ltarget,&quot;socket:&quot;,strlen(&quot;socket:&quot;)) == 0 ){
						strcpy(type,&quot;socket&quot;);
						inode = atol(&amp;ltarget[strlen(&quot;socket:[&quot;)]);
						logger(prefix,&quot;PROCDETAIL (Requesting INODE: %ld)\n&quot;,inode);
						si = get_socket_info(inode,-1);
						if ( si != NULL ){
							sprintf(addrinfo,&quot;\&quot;valid_addr\&quot;:true,\&quot;local_addr\&quot;:\&quot;%s\&quot;,\&quot;protocol\&quot;:%d,\&quot;local_port\&quot;:%d,\&quot;remote_addr\&quot;:\&quot;%s\&quot;,\&quot;remote_port\&quot;:%d,\&quot;family\&quot;:%d,\&quot;state\&quot;:%d,\&quot;timer_kind\&quot;:%d,\&quot;timer_value\&quot;:%ld,\&quot;uid\&quot;:%d,&quot;,
								si-&gt;local_addr,si-&gt;protocol,si-&gt;local_port,si-&gt;remote_addr,si-&gt;remote_port,si-&gt;family,si-&gt;state,si-&gt;timer_kind,si-&gt;timer_value,si-&gt;uid);
						}
					}
					if ( strncmp(ltarget,&quot;pipe:&quot;,strlen(&quot;pipe:&quot;)) == 0 ) strcpy(type,&quot;pipe&quot;);
					if ( strncmp(ltarget,&quot;anon_inode:&quot;,strlen(&quot;anon_inode:&quot;)) == 0 ) strcpy(type,&quot;other&quot;);
					sprintf(help2,&quot;{%s\&quot;fd\&quot;:%d,\&quot;name\&quot;:\&quot;%s\&quot;,\&quot;type\&quot;:\&quot;%s\&quot;},&quot;,addrinfo,atoi(diry-&gt;d_name),ltarget,type);
					fd_array = (char *)realloc(fd_array,strlen(fd_array) + strlen(help2) + 10);
					strcat(fd_array,help2);
				
				}
				closedir(dir);
			}
			if ( fd_array[strlen(fd_array)-1] == &#039;,&#039; ) fd_array[strlen(fd_array)-1] = &#039;\0&#039;;	
			fd_array = (char *)realloc(fd_array,strlen(fd_array) + 10);
			strcat(fd_array,&quot;]&quot;);

			helper = (char *)malloc(1024 + strlen(fd_array) * 2);

			
			if ( pid &gt; 10 ) { 
				int k,l;
				for ( k = 0; k &lt; entries; k++ ){
					for ( l = 0; l &lt; MAX_CONNS; l++ ){
						if ( servlist[k].co[l].cpid == pid || servlist[k].co[l].pid == pid ){
							slot = k;
							index = l;
							break;
						}
					}
					if ( slot &gt;= 0 ) break;
				}
			}

			logger(prefix,&quot;PROCDETAIL[%d] --&gt; Start\n&quot;,pid);
			result = strdup(&quot;{&quot;);

			sprintf(fname,&quot;/proc/%d/exe&quot;,pid);
			bzero(full_exe,1024);
			if ( readlink(fname,full_exe,1024) &lt; 0 ){
				strcpy(full_exe,&quot;n.a.&quot;);	
			}
			sprintf(fname,&quot;/proc/%d/cwd&quot;,pid);
			bzero(full_cwd,1024);
			if ( readlink(fname,full_cwd,1024) &lt; 0 ){
				strcpy(full_cwd,&quot;n.a.&quot;);	
			}

			r_uid = 0;
			r_gid = 0;
			e_uid = 0;
			e_gid = 0;

			sprintf(fname,&quot;/proc/%d/status&quot;,pid);
			fp = fopen(fname,&quot;r&quot;);
			if ( fp == NULL ){
				fprintf(ss,&quot;ERR[Cannot open %s]\r\n&quot;,fname);
				fflush(ss);
				shutdown(sock,SHUT_RDWR);
				fclose(ss);
				return;
			}	
			while ( fgets(fname,1024,fp) != NULL ){
				if ( strncmp(fname,&quot;Uid:&quot;,4) == 0 ){
					char *ptr;
					ptr = &amp;fname[4];
					while ( *ptr &amp;&amp; !isdigit(*ptr) ) ptr++;
					r_uid = atoi(ptr);
					while ( *ptr &amp;&amp; isdigit(*ptr) ) ptr++;
					while ( *ptr &amp;&amp; !isdigit(*ptr) ) ptr++;
					e_uid = atoi(ptr);
					continue;
				}	
				if ( strncmp(fname,&quot;Gid:&quot;,4) == 0 ){
					char *ptr;
					ptr = &amp;fname[4];
					while ( *ptr &amp;&amp; !isdigit(*ptr) ) ptr++;
					r_gid = atoi(ptr);
					while ( *ptr &amp;&amp; isdigit(*ptr) ) ptr++;
					while ( *ptr &amp;&amp; !isdigit(*ptr) ) ptr++;
					e_gid = atoi(ptr);
					continue;
				}	
			}

			fclose(fp);
			


			sprintf(fname,&quot;/proc/%d/cmdline&quot;,pid);
			fp = fopen(fname,&quot;r&quot;);
			if ( fp == NULL ){
				fprintf(ss,&quot;ERR[Cannot open %s]\r\n&quot;,fname);
				fflush(ss);
				shutdown(sock,SHUT_RDWR);
				fclose(ss);
				return;
			}	
			{
				int c; 
				int lastchar;
				char *ptr;
				ptr = commandline;
				bzero(commandline,1024);
				lastchar = -1;
				c_argc = 0;
				while ( (c = fgetc(fp)) != -1 ){
					if ( c == 0  ){
						c_argc++;
						*ptr = &#039; &#039;; ptr++;
						continue;
					}
					if ( c == &#039;\n&#039;  ){
						*ptr = &#039; &#039;; ptr++;
						continue;
					}
					if ( c == &#039;\r&#039;  ){
						*ptr = &#039; &#039;; ptr++;
						continue;
					}
					if ( c == &#039;\t&#039;  ){
						*ptr = &#039; &#039;; ptr++;
						continue;
					}
					if ( c == &#039;&gt;&#039;  ){
						*ptr = &#039;&amp;&#039;; ptr++;
						*ptr = &#039;g&#039;; ptr++;
						*ptr = &#039;t&#039;; ptr++;
						*ptr = &#039;;&#039;; ptr++;
						continue;
					}
					if ( c == &#039;&lt;&#039;  ){
						*ptr = &#039;&amp;&#039;; ptr++;
						*ptr = &#039;l&#039;; ptr++;
						*ptr = &#039;t&#039;; ptr++;
						*ptr = &#039;;&#039;; ptr++;
						continue;
					}
					*ptr = c;
					ptr++;
					lastchar = c;
				}
			}
			fclose(fp);
			while ( strlen(commandline) &amp;&amp; commandline[strlen(commandline)-1] == &#039; &#039; ) commandline[strlen(commandline)-1] = &#039;\0&#039;;
			if ( commandline[strlen(commandline)-1] == &#039;\r&#039; || commandline[strlen(commandline)-1] == &#039;\n&#039; ) commandline[strlen(commandline)-1] = &#039;\0&#039;;
			if ( commandline[strlen(commandline)-1] == &#039;\r&#039; || commandline[strlen(commandline)-1] == &#039;\n&#039; ) commandline[strlen(commandline)-1] = &#039;\0&#039;;
			// logger(prefix,&quot;PROCDETAIL: COMMAND-LINE: [%s]\n&quot;,commandline);

			sprintf(fname,&quot;/proc/%d/stat&quot;,pid);
			fp = fopen(fname,&quot;r&quot;);
			if ( fp == NULL ){
				fprintf(ss,&quot;ERR[Cannot open %s]\r\n&quot;,fname);
				fflush(ss);
				shutdown(sock,SHUT_RDWR);
				fclose(ss);
				return;
			}	
			if ( fgets(fname,1024,fp) == NULL ){ 
				fclose(fp); 
				fprintf(ss,&quot;ERR[Cannot read %s]\r\n&quot;,fname);
				fflush(ss);
				shutdown(sock,SHUT_RDWR);
				fclose(ss);
				return;
			}
			fclose(fp);

#define EXIT_PROC_READ { fprintf(ss,&quot;ERR[%s:%d corrupted file /proc/%d/stat]\r\n&quot;,__FILE__,__LINE__,pid); fflush(ss); shutdown(sock,SHUT_RDWR); fclose(ss); return; }
			ptr = strtok(fname,&quot; \t&quot;); // PID
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // CMD
			if ( ptr == NULL ) EXIT_PROC_READ;	
			strcpy(exe,ptr);
			ptr = strtok(NULL,&quot; \t&quot;); // STATE
			if ( ptr == NULL ) EXIT_PROC_READ;	
			state = *ptr;
			ptr = strtok(NULL,&quot; \t&quot;); // PPID
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ppid = atoi(ptr);
			ptr = strtok(NULL,&quot; \t&quot;); // PGRP
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // SESSION
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // TTYNR
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // TPGID
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // FLAGS
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // MINFLT
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // CMINFLT
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // MAJFLT
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // CMAJFLT
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // UTIME
			if ( ptr == NULL ) EXIT_PROC_READ;	
			utime_ticks = atol(ptr);	
			ptr = strtok(NULL,&quot; \t&quot;); // STIME
			if ( ptr == NULL ) EXIT_PROC_READ;	
			stime_ticks = atol(ptr);	
			gettimeofday(&amp;start,NULL);
			ptr = strtok(NULL,&quot; \t&quot;); // CUTIME
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // CSTIME
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // PRIORITY
			if ( ptr == NULL ) EXIT_PROC_READ;	
			priority = atol(ptr);	
			ptr = strtok(NULL,&quot; \t&quot;); // NICE
			if ( ptr == NULL ) EXIT_PROC_READ;	
			nice = atol(ptr);	
			ptr = strtok(NULL,&quot; \t&quot;); // NUMTHREADS
			if ( ptr == NULL ) EXIT_PROC_READ;	
			num_threads = atol(ptr);	
			ptr = strtok(NULL,&quot; \t&quot;); // ITREALVALUE
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // STARTTIME
			if ( ptr == NULL ) EXIT_PROC_READ;	
			starttime = atoll(ptr);	
			ptr = strtok(NULL,&quot; \t&quot;); // VMSIZE
			if ( ptr == NULL ) EXIT_PROC_READ;	
			vmsize = atol(ptr);	
			ptr = strtok(NULL,&quot; \t&quot;); // RSS
			if ( ptr == NULL ) EXIT_PROC_READ;	
			rss = atol(ptr);	
			ptr = strtok(NULL,&quot; \t&quot;); // RSSLIM
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // STARTCODE
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // ENDCODE
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // STARTSTACK
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // KSTKESP
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // KSTKEIP
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // SIGNAL
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // BLOCKED
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // SIGIGNORE
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // SIGCATCH
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // WCHAN
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // NSWAP
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // CNSWAP
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // EXIT_SIGNAL
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // PROCESSOR
			if ( ptr == NULL ) EXIT_PROC_READ;	
			cpu_id = atoi(ptr);
			p_start = time(NULL) - (sys.uptime - (starttime / sysconf(_SC_CLK_TCK)));
			{ // Sleep now for 0.5 seconds...than check the ticks again
				struct timespec tv;
				struct timespec rem;
				tv.tv_sec = 0;
				tv.tv_nsec = 700000000;
				while ( nanosleep(&amp;tv,&amp;rem) &lt; 0 &amp;&amp; errno == EINTR &amp;&amp; rem.tv_sec != 0 &amp;&amp; rem.tv_nsec != 0 ){
					tv = rem;
				}
			}
			sprintf(fname,&quot;/proc/%d/stat&quot;,pid);
			fp = fopen(fname,&quot;r&quot;);
			if ( fp == NULL ){
				fprintf(ss,&quot;ERR[Cannot open %s]\r\n&quot;,fname);
				fflush(ss);
				shutdown(sock,SHUT_RDWR);
				fclose(ss);
				return;
			}
			if ( fgets(fname,1024,fp) == NULL ){ 
				fprintf(ss,&quot;ERR[Cannot read %s]\r\n&quot;,fname);
				fflush(ss);
				shutdown(sock,SHUT_RDWR);
				fclose(ss);
				fclose(fp);  
				return;
			}	
			fclose(fp);
			ptr = strtok(fname,&quot; \t&quot;); // PID
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // CMD
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // STATE
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // PPID
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // PGRP
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // SESSION
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // TTYNR
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // TPGID
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // FLAGS
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // MINFLT
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // CMINFLT
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // MAJFLT
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // CMAJFLT
			if ( ptr == NULL ) EXIT_PROC_READ;	
			ptr = strtok(NULL,&quot; \t&quot;); // UTIME
			if ( ptr == NULL ) EXIT_PROC_READ;	
			utime_ticks2 = atol(ptr);	
			ptr = strtok(NULL,&quot; \t&quot;); // STIME
			if ( ptr == NULL ) EXIT_PROC_READ;	
			stime_ticks2 = atol(ptr);	
			gettimeofday(&amp;end,NULL);
			{
				double old, new;
				double ticks; 
				old = (double)start.tv_sec + ((double)start.tv_usec)/1000000.0;
				new = (double)end.tv_sec + ((double)end.tv_usec)/1000000.0;
				ticks = ((double) sysconf(_SC_CLK_TCK)) * (new - old);
				if ( utime_ticks2 ){
					cpu_usage_usr = ((double)(utime_ticks2 -  utime_ticks)/ ticks) * 100.0;
					if ( cpu_usage_usr &gt; 100.0 ) cpu_usage_usr = 100.0;
				} else {
					cpu_usage_usr = 0.0;
				}
				// logger(prefix,&quot;************************* PROCDETAIL: %d [%s] USR:[%.02f %%] Ticks-elapsed: %.02f, Time elapsed: %.02f TICKS: %d\n&quot;,pid,exe,cpu_usage_usr,ticks,new-old,utime_ticks2 -  utime_ticks);
				if ( stime_ticks2 ){
					cpu_usage_sys = ((double)(stime_ticks2 -  stime_ticks)/ ticks) * 100.0;
					if ( cpu_usage_sys &gt; 100.0 ) cpu_usage_sys = 100.0;
				} else {
					cpu_usage_sys = 0.0;
				}
				// logger(prefix,&quot;************************* PROCDETAIL: %d [%s] SYS:[%.02f %%] Ticks-elapsed: %.02f, Time elapsed: %.02f TICKS: %d\n&quot;,pid,exe,cpu_usage_sys,ticks,new-old,stime_ticks2 -  stime_ticks);

				sprintf(helper,&quot;\&quot;cmd\&quot;:\&quot;%s\&quot;,\&quot;cpu_usage_sys\&quot;:\&quot;%.02f\&quot;,\&quot;cpu_usage_usr\&quot;:\&quot;%.02f\&quot;,&quot;,exe,cpu_usage_sys,cpu_usage_usr);		
				result = (char *)realloc(result,strlen(result) + strlen(helper) + 10);
				strcat(result,helper);

				sprintf(helper,&quot;\&quot;num_threads\&quot;:%d,&quot;,num_threads);
				result = (char *)realloc(result,strlen(result) + strlen(helper) + 10);
				strcat(result,helper);
				sprintf(helper,&quot;\&quot;cpu\&quot;:%d,&quot;,cpu_id);
				result = (char *)realloc(result,strlen(result) + strlen(helper) + 10);
				strcat(result,helper);

				sprintf(helper,&quot;\&quot;full_cwd\&quot;:\&quot;%s\&quot;,&quot;,full_cwd);
				result = (char *)realloc(result,strlen(result) + strlen(helper) + 10);
				strcat(result,helper);

				sprintf(helper,&quot;\&quot;name\&quot;:\&quot;%s\&quot;,&quot;,exe);
				result = (char *)realloc(result,strlen(result) + strlen(helper) + 10);
				strcat(result,helper);

				sprintf(helper,&quot;\&quot;commandline\&quot;:\&quot;%s\&quot;,&quot;,commandline);
				result = (char *)realloc(result,strlen(result) + strlen(helper) + 10);
				strcat(result,helper);

				sprintf(helper,&quot;\&quot;argc\&quot;:%d,&quot;,c_argc);
				result = (char *)realloc(result,strlen(result) + strlen(helper) + 10);
				strcat(result,helper);

				switch(state){
					case &#039;R&#039;:
						sprintf(helper,&quot;\&quot;full_state\&quot;:\&quot;R - Running\&quot;,&quot;);
						break;
					case &#039;S&#039;:
						sprintf(helper,&quot;\&quot;full_state\&quot;:\&quot;S - Sleeping\&quot;,&quot;);
						break;
					case &#039;D&#039;:
						sprintf(helper,&quot;\&quot;full_state\&quot;:\&quot;D - Waiting in disk-sleep\&quot;,&quot;);
						break;
					case &#039;Z&#039;:
						sprintf(helper,&quot;\&quot;full_state\&quot;:\&quot;Z - Zombie (defunct)\&quot;,&quot;);
						break;
					case &#039;T&#039;:
					case &#039;t&#039;:
						sprintf(helper,&quot;\&quot;full_state\&quot;:\&quot;T - Stopped\&quot;,&quot;);
						break;
					case &#039;W&#039;:
						sprintf(helper,&quot;\&quot;full_state\&quot;:\&quot;W - Paging/Waking\&quot;,&quot;);
						break;
					case &#039;X&#039;:
					case &#039;x&#039;:
						sprintf(helper,&quot;\&quot;full_state\&quot;:\&quot;X - Dead\&quot;,&quot;);
						break;
					case &#039;P&#039;:
						sprintf(helper,&quot;\&quot;full_state\&quot;:\&quot;P - Parked\&quot;,&quot;);
						break;
					case &#039;K&#039;:
						sprintf(helper,&quot;\&quot;full_state\&quot;:\&quot;K - Wakekill\&quot;,&quot;);
						break;
					default:
						sprintf(helper,&quot;\&quot;full_state\&quot;:\&quot;UNKNOWN(%c)\&quot;,&quot;,state);
						break;
				}	
				result = (char *)realloc(result,strlen(result) + strlen(helper) + 10);
				strcat(result,helper);
				{
					int hours;
					int minutes;
					int seconds;
					hours =   (stime_ticks2/sysconf(_SC_CLK_TCK)) / 3600;
					minutes = (stime_ticks2/sysconf(_SC_CLK_TCK) - hours * 3600)/60;
					seconds = (stime_ticks2/sysconf(_SC_CLK_TCK)) % 60;

					sprintf(helper,&quot;\&quot;sys_time\&quot;:\&quot;%02d:%02d:%02d&amp;nbsp;(%d ticks)\&quot;,&quot;,hours,minutes,seconds,stime_ticks2);
					result = (char *)realloc(result,strlen(result) + strlen(helper) + 10);
					strcat(result,helper);
				}
				{
					int hours;
					int minutes;
					int seconds;
					hours =   (utime_ticks2/sysconf(_SC_CLK_TCK)) / 3600;
					minutes = (utime_ticks2/sysconf(_SC_CLK_TCK) - hours * 3600)/60;
					seconds = (utime_ticks2/sysconf(_SC_CLK_TCK)) % 60;

					sprintf(helper,&quot;\&quot;usr_time\&quot;:\&quot;%02d:%02d:%02d&amp;nbsp;(%d ticks)\&quot;,&quot;,hours,minutes,seconds,utime_ticks2);
					result = (char *)realloc(result,strlen(result) + strlen(helper) + 10);
					strcat(result,helper);
				}

				sprintf(helper,&quot;\&quot;slot\&quot;:%d,&quot;,slot);
				result = (char *)realloc(result,strlen(result) + strlen(helper) + 10);
				strcat(result,helper);

				sprintf(helper,&quot;\&quot;index\&quot;:%d,&quot;,index);
				result = (char *)realloc(result,strlen(result) + strlen(helper) + 10);
				strcat(result,helper);

				sprintf(helper,&quot;\&quot;ppid\&quot;:%d,&quot;,ppid);
				result = (char *)realloc(result,strlen(result) + strlen(helper) + 10);
				strcat(result,helper);

				sprintf(helper,&quot;\&quot;fds\&quot;:%s,&quot;,fd_array);
				result = (char *)realloc(result,strlen(result) + strlen(helper) + 10);
				strcat(result,helper);

				{
					struct passwd *pwd;
					struct group  *grp;
					char username[1024];

					pwd = getpwuid(r_uid);
					if ( pwd == NULL ){
						sprintf(username,&quot;%d&quot;,r_uid);
					} else {
						strcpy(username,pwd-&gt;pw_name);
					}

					sprintf(helper,&quot;\&quot;r_uid\&quot;:\&quot;%d (%s)\&quot;,&quot;,r_uid,username);
					result = (char *)realloc(result,strlen(result) + strlen(helper) + 10);
					strcat(result,helper);

					grp = getgrgid(r_gid);
					if ( grp == NULL ){
						sprintf(username,&quot;%d&quot;,r_gid);
					} else {
						strcpy(username,grp-&gt;gr_name);
					}
	
					sprintf(helper,&quot;\&quot;r_gid\&quot;:\&quot;%d (%s)\&quot;,&quot;,r_gid,username);
					result = (char *)realloc(result,strlen(result) + strlen(helper) + 10);
					strcat(result,helper);

					pwd = getpwuid(e_uid);
					if ( pwd == NULL ){
						sprintf(username,&quot;%d&quot;,e_uid);
					} else {
						strcpy(username,pwd-&gt;pw_name);
					}
	
					sprintf(helper,&quot;\&quot;e_uid\&quot;:\&quot;%d (%s)\&quot;,&quot;,e_uid,username);
					result = (char *)realloc(result,strlen(result) + strlen(helper) + 10);
					strcat(result,helper);

					grp = getgrgid(e_gid);
					if ( grp == NULL ){
						sprintf(username,&quot;%d&quot;,e_gid);
					} else {
						strcpy(username,grp-&gt;gr_name);
					}
	
					sprintf(helper,&quot;\&quot;e_gid\&quot;:\&quot;%d (%s)\&quot;,&quot;,e_gid,username);
					result = (char *)realloc(result,strlen(result) + strlen(helper) + 10);
					strcat(result,helper);

				}

				sprintf(helper,&quot;\&quot;full_exe\&quot;:\&quot;%s\&quot;,&quot;,full_exe);
				result = (char *)realloc(result,strlen(result) + strlen(helper) + 10);
				strcat(result,helper);

				{
					struct tm *tm;
					tm = localtime(&amp;p_start);
					sprintf(helper,&quot;\&quot;p_start\&quot;:\&quot;%04d.%02d.%02d&amp;nbsp;%02d:%02d:%02d\&quot;,&quot;,
						tm-&gt;tm_year + 1900, tm-&gt;tm_mon + 1, tm-&gt;tm_mday,
						tm-&gt;tm_hour, tm-&gt;tm_min, tm-&gt;tm_sec);
					result = (char *)realloc(result,strlen(result) + strlen(helper) + 10);
					strcat(result,helper);
				}
#define FAT1024 (1024.0)
				{
					double n_vmsize;
					n_vmsize = (double) vmsize;
					sprintf(helper,&quot;\&quot;vm_size\&quot;:\&quot;%d&amp;nbsp;Bytes\&quot;,&quot;, (int) n_vmsize);				
					if ( n_vmsize &gt; FAT1024 ){ 
						sprintf(helper,&quot;\&quot;vm_size\&quot;:\&quot;%.02f&amp;nbsp;KBytes\&quot;,&quot;, n_vmsize/FAT1024);				
					}
					if ( n_vmsize &gt; (FAT1024*FAT1024) ){ 
						sprintf(helper,&quot;\&quot;vm_size\&quot;:\&quot;%.02f&amp;nbsp;MBytes\&quot;,&quot;, n_vmsize/(FAT1024*FAT1024));				
					}
					if ( n_vmsize &gt; (FAT1024*FAT1024*FAT1024) ){ 
						sprintf(helper,&quot;\&quot;vm_size\&quot;:\&quot;%.02f&amp;nbsp;GBytes\&quot;,&quot;, n_vmsize/(FAT1024*FAT1024*FAT1024));				
					}
					if ( n_vmsize &gt; (FAT1024*FAT1024*FAT1024*FAT1024) ){ 
						sprintf(helper,&quot;\&quot;vm_size\&quot;:\&quot;%.02f&amp;nbsp;TBytes\&quot;,&quot;, n_vmsize/(FAT1024*FAT1024*FAT1024*FAT1024));				
					}
					result = (char *)realloc(result,strlen(result) + strlen(helper) + 10);
					strcat(result,helper);
				}
				{	
					double n_rss;
					n_rss = ((double) rss) * ((double) sysconf(_SC_PAGESIZE));
					sprintf(helper,&quot;\&quot;rss\&quot;:\&quot;%d&amp;nbsp;Bytes\&quot;,&quot;, (int)n_rss);				
					if ( n_rss &gt; FAT1024 ){ 
						sprintf(helper,&quot;\&quot;rss\&quot;:\&quot;%.02f&amp;nbsp;KBytes\&quot;,&quot;, n_rss/FAT1024);				
					}
					if ( n_rss &gt; (FAT1024*FAT1024) ){ 
						sprintf(helper,&quot;\&quot;rss\&quot;:\&quot;%.02f&amp;nbsp;MBytes\&quot;,&quot;, n_rss/(FAT1024*FAT1024));				
					}
					if ( n_rss &gt; (FAT1024*FAT1024*FAT1024) ){ 
						sprintf(helper,&quot;\&quot;rss\&quot;:\&quot;%.02f&amp;nbsp;GBytes\&quot;,&quot;, n_rss/(FAT1024*FAT1024*FAT1024));				
					}
					if ( n_rss &gt; (FAT1024*FAT1024*FAT1024*FAT1024) ){ 
						sprintf(helper,&quot;\&quot;rss\&quot;:\&quot;%.02f&amp;nbsp;TBytes\&quot;,&quot;, n_rss/(FAT1024*FAT1024*FAT1024*FAT1024));				
					}
					result = (char *)realloc(result,strlen(result) + strlen(helper) + 10);
					strcat(result,helper);
				}


			}
			if ( result[strlen(result)-1] == &#039;,&#039; ) result[strlen(result)-1] = &#039;\0&#039;;
			result = (char *)realloc(result,strlen(result)+2);
			strcat(result,&quot;}&quot;);	
			fprintf(ss,&quot;OK[%s]\r\n&quot;,result);
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
			
		}
		if ( strcmp(command,&quot;PROCLIST&quot;) == 0 ){
			int ix;
			int lentries;
			struct ethinfo *eth;
			struct process_info *list;
			DIR *dir;
			struct dirent *diry;
			char *result;
			struct sysinfo sys;
			int cpu_count;
			double *usage_sum;
			int ethcount;
			char *ethjson;
			char *fsjson;
			char *dnsinfo;
			double loader[4];
			char dns_json[1024];
			getloadavg(loader,1);	
			cpu_count = 0;
			{
				FILE *fp;
				fp = fopen(&quot;/proc/stat&quot;,&quot;r&quot;);
				if ( fp != NULL ){
					char buf[1024];
					while ( fgets(buf,1024,fp) != NULL ){
						if ( strncmp(buf,&quot;cpu&quot;,3) == 0 ){
							if ( !isspace(buf[3]) ) cpu_count++;
						}
					}
					fclose(fp);
				} 
				if ( cpu_count &lt; 1 ){
					logger(prefix,&quot;PROCLIST: WARNING no CPUs found...assuming 1 CPU\n&quot;);
					cpu_count = 1;
				}
			}
			usage_sum = (double *)malloc(sizeof(double) * cpu_count);
			bzero(usage_sum,sizeof(double) * cpu_count);



			if ( strlen(gix_options-&gt;have_own_dns) &gt; 1 ){
				double dns_response_time;
				logger(prefix,&quot;PROCLIST: CHECK DNS [%s]\n&quot;,gix_options-&gt;have_own_dns);
				dns_response_time = process_dns(gix_options-&gt;have_own_dns);
				sprintf(dns_json,&quot;{\&quot;active\&quot;:true,\&quot;success\&quot;:%s,\&quot;time\&quot;:\&quot;%.02f ms\&quot;}&quot;,
					dns_response_time &gt;= 0.0 ? &quot;true&quot; : &quot;false&quot;, dns_response_time);
			} else {
				sprintf(dns_json,&quot;{\&quot;active\&quot;:false}&quot;);
			}
			

			{ 
				FILE *fp;
				char buf[1024];

				ethcount = 0;
				fp = fopen(&quot;/proc/net/dev&quot;,&quot;r&quot;);
				if ( fp == NULL ){
					fprintf(ss,&quot;\r\nERR[Cannot open /proc/net/dev]\r\n&quot;);
					fflush(ss);
					shutdown(sock,SHUT_RDWR);
					fclose(ss);
					return;
				}				
				eth = NULL;
				while ( fgets(buf,1024,fp) != NULL ){
					char ifname[256];
					char *ptr;
					char bytes_receive[64];
					char packets_receive[64];
					char errs_receive[64];
					char drop_receive[64];
					char bytes_transmit[64];
					char packets_transmit[64];
					char errs_transmit[64];
					char drop_transmit[64];
					char colls[64];
					if ( strstr(buf,&quot;:&quot;) == NULL ) continue;
					ptr = strtok(buf,&quot;:\t\r\n &quot;);
					if ( ptr == NULL ) continue;
					sprintf(ifname,&quot;%s&quot;,ptr);

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue;
					strcpy(bytes_receive,ptr);

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue;
					strcpy(packets_receive,ptr);

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue;
					strcpy(errs_receive,ptr);

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue;
					strcpy(drop_receive,ptr);

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue; // FIFO

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue; // FRAME

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue; // COMPRESSED

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue; // MULTICAST

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue;
					strcpy(bytes_transmit,ptr);

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue;
					strcpy(packets_transmit,ptr);

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue;
					strcpy(errs_transmit,ptr);

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue;
					strcpy(drop_transmit,ptr);

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue; // FIFO

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue;
					strcpy(colls,ptr);
					
					eth = (struct ethinfo *)realloc(eth,sizeof(struct ethinfo) * (ethcount+1));	
					bzero(&amp;eth[ethcount],sizeof(struct ethinfo));
					gettimeofday(&amp;(eth[ethcount].stamp1),NULL);	
					strcpy(eth[ethcount].ifname,ifname);
					strcpy(eth[ethcount].if_mac,get_interface_address(ifname,AF_PACKET));
					strcpy(eth[ethcount].if_ipv4,get_interface_address(ifname,AF_INET));
					strcpy(eth[ethcount].if_ipv6,get_interface_address(ifname,AF_INET6));
					eth[ethcount].bytes_receive_1 = atoll(bytes_receive);
					eth[ethcount].packets_receive_1 = atoll(packets_receive);
					eth[ethcount].error_receive_1 = atoll(errs_receive);
					eth[ethcount].drop_receive_1 = atoll(drop_receive);
					eth[ethcount].bytes_transmit_1 = atoll(bytes_transmit);
					eth[ethcount].packets_transmit_1 = atoll(packets_transmit);
					eth[ethcount].error_transmit_1 = atoll(errs_transmit);
					eth[ethcount].drop_transmit_1 = atoll(drop_transmit);
					eth[ethcount].colls_1 = atoll(colls);
					strcpy(eth[ethcount].bytes_receive_t,convert_bytes((double)eth[ethcount].bytes_receive_1,&quot;Bytes&quot;));
					strcpy(eth[ethcount].packets_receive_t,convert_bytes((double)eth[ethcount].packets_receive_1,&quot;Packets&quot;));
					strcpy(eth[ethcount].error_receive_t,convert_bytes((double)eth[ethcount].error_receive_1,&quot;Packets&quot;));
					strcpy(eth[ethcount].drop_receive_t,convert_bytes((double)eth[ethcount].drop_receive_1,&quot;Packets&quot;));
					strcpy(eth[ethcount].bytes_transmit_t,convert_bytes((double)eth[ethcount].bytes_transmit_1,&quot;Bytes&quot;));
					strcpy(eth[ethcount].packets_transmit_t,convert_bytes((double)eth[ethcount].packets_transmit_1,&quot;Packets&quot;));
					strcpy(eth[ethcount].error_transmit_t,convert_bytes((double)eth[ethcount].error_transmit_1,&quot;Packets&quot;));
					strcpy(eth[ethcount].drop_transmit_t,convert_bytes((double)eth[ethcount].drop_transmit_1,&quot;Packets&quot;));
					strcpy(eth[ethcount].colls_t,convert_bytes((double)eth[ethcount].colls_1,&quot;Packets&quot;));
					ethcount++;
					// logger(prefix,&quot;ETHINFO [%s] --&gt; Bytes: [%s]\n&quot;,eth[ethcount-1].ifname, eth[ethcount-1].bytes_receive_t);
				}		
				fclose(fp);	
			
			}


			sysinfo(&amp;sys);

			list = NULL;
			lentries = 0;
			dir = opendir(&quot;/proc&quot;);
			if ( dir == NULL ){
				fprintf(ss,&quot;\r\nERR[Cannot open /proc]\r\n&quot;);
				fflush(ss);
				shutdown(sock,SHUT_RDWR);
				fclose(ss);
				return;
			}
			while ( (diry = readdir(dir)) != NULL ){
				char fname[1024];
				char exe[1024];
				char state;
				unsigned long utime;
				unsigned long stime;
				unsigned long cutime;
				unsigned long cstime;
				long priority;
				long nice;
				long rss;
				long num_threads;
				long long starttime;
				unsigned long vmsize;
				int ppid;
				int cpu_id;
				char *ptr;
				int pid;
				FILE *fp;

				if ( !isdigit(diry-&gt;d_name[0]) ) continue;	
				pid = atoi(diry-&gt;d_name);
				sprintf(fname,&quot;/proc/%d/stat&quot;,pid);
				fp = fopen(fname,&quot;r&quot;);
				if ( fp == NULL ) continue;
				if ( fgets(fname,1024,fp) == NULL ){ fclose(fp); continue; }	
				fclose(fp);
				ptr = strtok(fname,&quot; \t&quot;); // PID
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // CMD
				if ( ptr == NULL ) continue;	
				strcpy(exe,ptr);
				ptr = strtok(NULL,&quot; \t&quot;); // STATE
				if ( ptr == NULL ) continue;	
				state = *ptr;
				ptr = strtok(NULL,&quot; \t&quot;); // PPID
				if ( ptr == NULL ) continue;	
				ppid = atoi(ptr);
				ptr = strtok(NULL,&quot; \t&quot;); // PGRP
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // SESSION
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // TTYNR
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // TPGID
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // FLAGS
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // MINFLT
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // CMINFLT
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // MAJFLT
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // CMAJFLT
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // UTIME
				if ( ptr == NULL ) continue;	
				utime = atol(ptr);	
				ptr = strtok(NULL,&quot; \t&quot;); // STIME
				if ( ptr == NULL ) continue;	
				stime = atol(ptr);	
				ptr = strtok(NULL,&quot; \t&quot;); // CUTIME
				if ( ptr == NULL ) continue;	
				cutime = atol(ptr);	
				ptr = strtok(NULL,&quot; \t&quot;); // CSTIME
				if ( ptr == NULL ) continue;	
				cstime = atol(ptr);	
				ptr = strtok(NULL,&quot; \t&quot;); // PRIORITY
				if ( ptr == NULL ) continue;	
				priority = atol(ptr);	
				ptr = strtok(NULL,&quot; \t&quot;); // NICE
				if ( ptr == NULL ) continue;	
				nice = atol(ptr);	
				ptr = strtok(NULL,&quot; \t&quot;); // NUMTHREADS
				if ( ptr == NULL ) continue;	
				num_threads = atol(ptr);	
				ptr = strtok(NULL,&quot; \t&quot;); // ITREALVALUE
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // STARTTIME
				if ( ptr == NULL ) continue;	
				starttime = atoll(ptr);	
				ptr = strtok(NULL,&quot; \t&quot;); // VMSIZE
				if ( ptr == NULL ) continue;	
				vmsize = atol(ptr);	
				ptr = strtok(NULL,&quot; \t&quot;); // RSS
				if ( ptr == NULL ) continue;	
				rss = atol(ptr);	
				ptr = strtok(NULL,&quot; \t&quot;); // RSSLIM
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // STARTCODE
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // ENDCODE
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // STARTSTACK
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // KSTKESP
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // KSTKEIP
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // SIGNAL
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // BLOCKED
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // SIGIGNORE
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // SIGCATCH
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // WCHAN
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // NSWAP
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // CNSWAP
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // EXIT_SIGNAL
				if ( ptr == NULL ) continue;	
				ptr = strtok(NULL,&quot; \t&quot;); // PROCESSOR
				if ( ptr == NULL ) continue;	
				cpu_id = atoi(ptr);

				// logger(prefix,&quot;PROCLIST (%d) CPU: [%d], RSS: [%ld], PPID: %d [%s] VMSIZE: %lu Bytes, NICE: %ld UTIME: %lu ticks STIME: %lu ticks (%d Ticks per second)\n&quot;,pid,cpu_id,rss,ppid,exe,vmsize,nice,utime,stime,sysconf(_SC_CLK_TCK));

				list = (struct process_info *)realloc(list,sizeof(struct process_info) * (lentries+1));
				list[lentries].pid  = pid;
				list[lentries].ppid = ppid;
				list[lentries].vmsize = vmsize;
				sprintf(list[lentries].vmtext,&quot;%lu&amp;nbsp;B&quot;,vmsize);
				if ( vmsize &gt; 1024 ) sprintf(list[lentries].vmtext,&quot;%lu&amp;nbsp;kB&quot;,vmsize / 1024);
				if ( vmsize &gt; (1024*1024) ) sprintf(list[lentries].vmtext,&quot;%lu&amp;nbsp;MB&quot;,vmsize / (1024 * 1024));
				strcpy(list[lentries].program,exe);
				list[lentries].nice = nice;
				list[lentries].num_threads = num_threads;
				list[lentries].cpu = cpu_id;
				list[lentries].rss = rss;
				list[lentries].priority = priority;
				list[lentries].ptime = (utime + stime) / sysconf(_SC_CLK_TCK);
				list[lentries].utime = utime;
				list[lentries].utime2 = -1;
				list[lentries].stime = stime;
				list[lentries].stime2 = -1;
				list[lentries].starttime = time(NULL) - (sys.uptime - (starttime / sysconf(_SC_CLK_TCK)));
				gettimeofday(&amp;(list[lentries].stamp),NULL);
				lentries++;
			}
			closedir(dir); 	
			{ // Sleep now for 0.5 seconds...than check the ticks again
				struct timespec tv;
				struct timespec rem;
				tv.tv_sec = 0;
				tv.tv_nsec = 800000000;
				while ( nanosleep(&amp;tv,&amp;rem) &lt; 0 &amp;&amp; errno == EINTR &amp;&amp; rem.tv_sec != 0 &amp;&amp; rem.tv_nsec != 0 ){
					tv = rem;
				}
				for ( ix = 0; ix &lt; lentries; ix++ ){
					char fname[1024];
					FILE *fp;
					unsigned long utime;
					unsigned long stime;
					
					sprintf(fname,&quot;/proc/%d/stat&quot;,list[ix].pid);
					fp = fopen(fname,&quot;r&quot;);
					if ( fp == NULL ) continue;
					if ( fgets(fname,1024,fp) == NULL ){ fclose(fp); continue; }	
					fclose(fp);
					ptr = strtok(fname,&quot; \t&quot;); // PID
					if ( ptr == NULL ) continue;	
					ptr = strtok(NULL,&quot; \t&quot;); // CMD
					if ( ptr == NULL ) continue;	
					ptr = strtok(NULL,&quot; \t&quot;); // STATE
					if ( ptr == NULL ) continue;	
					ptr = strtok(NULL,&quot; \t&quot;); // PPID
					if ( ptr == NULL ) continue;	
					ptr = strtok(NULL,&quot; \t&quot;); // PGRP
					if ( ptr == NULL ) continue;	
					ptr = strtok(NULL,&quot; \t&quot;); // SESSION
					if ( ptr == NULL ) continue;	
					ptr = strtok(NULL,&quot; \t&quot;); // TTYNR
					if ( ptr == NULL ) continue;	
					ptr = strtok(NULL,&quot; \t&quot;); // TPGID
					if ( ptr == NULL ) continue;	
					ptr = strtok(NULL,&quot; \t&quot;); // FLAGS
					if ( ptr == NULL ) continue;	
					ptr = strtok(NULL,&quot; \t&quot;); // MINFLT
					if ( ptr == NULL ) continue;	
					ptr = strtok(NULL,&quot; \t&quot;); // CMINFLT
					if ( ptr == NULL ) continue;	
					ptr = strtok(NULL,&quot; \t&quot;); // MAJFLT
					if ( ptr == NULL ) continue;	
					ptr = strtok(NULL,&quot; \t&quot;); // CMAJFLT
					if ( ptr == NULL ) continue;	
					ptr = strtok(NULL,&quot; \t&quot;); // UTIME
					if ( ptr == NULL ) continue;	
					utime = atol(ptr);	
					ptr = strtok(NULL,&quot; \t&quot;); // STIME
					if ( ptr == NULL ) continue;	
					stime = atol(ptr);	
					list[ix].utime2 = utime - list[ix].utime;
					list[ix].stime2 = stime - list[ix].stime;
					gettimeofday(&amp;(list[ix].stamp2),NULL);
					{
						double old, new;
						double ticks; 
						old = (double)list[ix].stamp.tv_sec + ((double)list[ix].stamp.tv_usec)/1000000.0;
						new = (double)list[ix].stamp2.tv_sec + ((double)list[ix].stamp2.tv_usec)/1000000.0;
						ticks = ((double) sysconf(_SC_CLK_TCK)) * (new - old);
						if ( list[ix].utime2 || list[ix].stime2 ){
							list[ix].cpu_usage = ((double)(list[ix].utime2 +  list[ix].stime2)/ ticks) * 100.0;
							if ( list[ix].cpu_usage &gt;= 100.0 ) list[ix].cpu_usage = 100.0; // Quick &amp; Dirty :-)
							//  logger(prefix,&quot;************************* PROCLIST: %d [%s] [%.02f %%] Ticks-elapsed: %.02f, Time elapsed: %.02f, UTIME2: %d, STIME2: %d\n&quot;,list[ix].pid,list[ix].program,list[ix].cpu_usage,ticks,new-old, list[ix].utime2, list[ix].stime2);
						} else {
							list[ix].cpu_usage = 0.0;
						}
						
					}
				}	
			}
			{ 
				FILE *fp;
				char buf[1024];
				ethcount = 0;
				fp = fopen(&quot;/proc/net/dev&quot;,&quot;r&quot;);
				if ( fp == NULL ){
					fprintf(ss,&quot;\r\nERR[Cannot open /proc/net/dev]\r\n&quot;);
					fflush(ss);
					shutdown(sock,SHUT_RDWR);
					fclose(ss);
					return;
				}				
				while ( fgets(buf,1024,fp) != NULL ){
					char ifname[256];
					char *ptr;
					char bytes_receive[64];
					char packets_receive[64];
					char errs_receive[64];
					char drop_receive[64];
					char bytes_transmit[64];
					char packets_transmit[64];
					char errs_transmit[64];
					char drop_transmit[64];
					char colls[64];
					if ( strstr(buf,&quot;:&quot;) == NULL ) continue;
					ptr = strtok(buf,&quot;:\t\r\n &quot;);
					if ( ptr == NULL ) continue;
					strcpy(ifname,ptr);

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue;
					strcpy(bytes_receive,ptr);

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue;
					strcpy(packets_receive,ptr);

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue;
					strcpy(errs_receive,ptr);

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue;
					strcpy(drop_receive,ptr);

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue; // FIFO

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue; // FRAME

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue; // COMPRESSED

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue; // MULTICAST

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue;
					strcpy(bytes_transmit,ptr);

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue;
					strcpy(packets_transmit,ptr);

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue;
					strcpy(errs_transmit,ptr);

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue;
					strcpy(drop_transmit,ptr);

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue; // FIFO

					ptr = strtok(NULL,&quot;\t\r\n &quot;);
					if ( ptr == NULL ) continue;
					strcpy(colls,ptr);
					
					gettimeofday(&amp;(eth[ethcount].stamp2),NULL);	
					eth[ethcount].bytes_receive_2 = atoll(bytes_receive);
					eth[ethcount].packets_receive_2 = atoll(packets_receive);
					eth[ethcount].error_receive_2 = atoll(errs_receive);
					eth[ethcount].drop_receive_2 = atoll(drop_receive);
					eth[ethcount].bytes_transmit_2 = atoll(bytes_transmit);
					eth[ethcount].packets_transmit_2 = atoll(packets_transmit);
					eth[ethcount].error_transmit_2 = atoll(errs_transmit);
					eth[ethcount].drop_transmit_2 = atoll(drop_transmit);
					eth[ethcount].colls_2 = atoll(colls);
					strcpy(eth[ethcount].bytes_receive_t,convert_bytes((double)eth[ethcount].bytes_receive_2,&quot;Bytes&quot;));
					strcpy(eth[ethcount].packets_receive_t,convert_bytes((double)eth[ethcount].packets_receive_2,&quot;Packets&quot;));
					strcpy(eth[ethcount].error_receive_t,convert_bytes((double)eth[ethcount].error_receive_2,&quot;Packets&quot;));
					strcpy(eth[ethcount].drop_receive_t,convert_bytes((double)eth[ethcount].drop_receive_2,&quot;Packets&quot;));
					strcpy(eth[ethcount].bytes_transmit_t,convert_bytes((double)eth[ethcount].bytes_transmit_2,&quot;Bytes&quot;));
					strcpy(eth[ethcount].packets_transmit_t,convert_bytes((double)eth[ethcount].packets_transmit_2,&quot;Packets&quot;));
					strcpy(eth[ethcount].error_transmit_t,convert_bytes((double)eth[ethcount].error_transmit_2,&quot;Packets&quot;));
					strcpy(eth[ethcount].drop_transmit_t,convert_bytes((double)eth[ethcount].drop_transmit_2,&quot;Packets&quot;));
					strcpy(eth[ethcount].colls_t,convert_bytes((double)eth[ethcount].colls_2,&quot;Packets&quot;));
					{
						double timediff;
						double datadiff;	
						double datasec;

						eth[ethcount].timestamp_calc = (((double) eth[ethcount].stamp1.tv_sec) + ((double) eth[ethcount].stamp1.tv_usec) / 1000000.0);
						timediff = (((double) eth[ethcount].stamp2.tv_sec) + ((double) eth[ethcount].stamp2.tv_usec) / 1000000.0) - (((double) eth[ethcount].stamp1.tv_sec) + ((double) eth[ethcount].stamp1.tv_usec) / 1000000.0);

						datadiff = ((double) eth[ethcount].bytes_receive_2) -  ((double) eth[ethcount].bytes_receive_1);
						datasec = datadiff / timediff;
						eth[ethcount].bytes_receive_sec = datasec;
						sprintf(eth[ethcount].bytes_receive_sec_t,&quot;%s/s&quot;,convert_bytes(datasec,&quot;Bytes&quot;));

						datadiff = ((double) eth[ethcount].packets_receive_2) -  ((double) eth[ethcount].packets_receive_1);
						datasec = datadiff / timediff;
						eth[ethcount].packets_receive_sec = datasec;
						sprintf(eth[ethcount].packets_receive_sec_t,&quot;%s/s&quot;,convert_bytes(datasec,&quot;Packets&quot;));
						
						datadiff = ((double) eth[ethcount].error_receive_2) -  ((double) eth[ethcount].error_receive_1);
						datasec = datadiff / timediff;
						eth[ethcount].error_receive_sec = datasec;
						sprintf(eth[ethcount].error_receive_sec_t,&quot;%s/s&quot;,convert_bytes(datasec,&quot;Packets&quot;));
						
						datadiff = ((double) eth[ethcount].drop_receive_2) -  ((double) eth[ethcount].drop_receive_1);
						datasec = datadiff / timediff;
						eth[ethcount].drop_receive_sec = datasec;
						sprintf(eth[ethcount].drop_receive_sec_t,&quot;%s/s&quot;,convert_bytes(datasec,&quot;Packets&quot;));

						datadiff = ((double) eth[ethcount].bytes_transmit_2) -  ((double) eth[ethcount].bytes_transmit_1);
						datasec = datadiff / timediff;
						eth[ethcount].bytes_transmit_sec = datasec;
						sprintf(eth[ethcount].bytes_transmit_sec_t,&quot;%s/s&quot;,convert_bytes(datasec,&quot;Bytes&quot;));

						datadiff = ((double) eth[ethcount].packets_transmit_2) -  ((double) eth[ethcount].packets_transmit_1);
						datasec = datadiff / timediff;
						eth[ethcount].packets_transmit_sec = datasec;
						sprintf(eth[ethcount].packets_transmit_sec_t,&quot;%s/s&quot;,convert_bytes(datasec,&quot;Packets&quot;));
						
						datadiff = ((double) eth[ethcount].error_transmit_2) -  ((double) eth[ethcount].error_transmit_1);
						datasec = datadiff / timediff;
						eth[ethcount].error_transmit_sec = datasec;
						sprintf(eth[ethcount].error_transmit_sec_t,&quot;%s/s&quot;,convert_bytes(datasec,&quot;Packets&quot;));
						
						datadiff = ((double) eth[ethcount].drop_transmit_2) -  ((double) eth[ethcount].drop_transmit_1);
						datasec = datadiff / timediff;
						eth[ethcount].drop_transmit_sec = datasec;
						sprintf(eth[ethcount].drop_transmit_sec_t,&quot;%s/s&quot;,convert_bytes(datasec,&quot;Packets&quot;));

						datadiff = ((double) eth[ethcount].colls_2) -  ((double) eth[ethcount].colls_1);
						datasec = datadiff / timediff;
						eth[ethcount].colls_sec = datasec;
						sprintf(eth[ethcount].colls_sec_t,&quot;%s/s&quot;,convert_bytes(datasec,&quot;Packets&quot;));



						// logger(prefix,&quot;ETHINFO(2) [%s] --&gt; B: [%llu] Timediff: %.02f D: %.02f Bytes [%s]\n&quot;,eth[ethcount].ifname, eth[ethcount].bytes_receive_1,timediff,datadiff,eth[ethcount].bytes_receive_sec_t);
					}
					ethcount++;
				}		
				fclose(fp);	
			}
			// logger(prefix,&quot;ETHINFO: Interfaces found: %d\n&quot;,ethcount);
			qsort(&amp;eth[0],ethcount,sizeof(struct ethinfo),comparer_eth);
			// logger(prefix,&quot;ETHINFO: Interfaces found: %d\n&quot;,ethcount);
			{
				int idx;
				ethjson = strdup(&quot;[&quot;);
				for ( idx = 0; idx &lt; ethcount; idx++ ){
					char line[1048];

					sprintf(line,&quot;{\&quot;ifname\&quot;:\&quot;%s\&quot;,\&quot;timestamp\&quot;:%.06f,&quot;,
						eth[idx].ifname, eth[idx].timestamp_calc);
					sprintf(&amp;line[strlen(line)],&quot;\&quot;mac_addr\&quot;:\&quot;%s\&quot;,\&quot;ipv4_addr\&quot;:\&quot;%s\&quot;,\&quot;ipv6_addr\&quot;:\&quot;%s\&quot;,&quot;,
						eth[idx].if_mac, eth[idx].if_ipv4,eth[idx].if_ipv6);
					sprintf(&amp;line[strlen(line)],&quot;\&quot;bytes_in_t\&quot;:\&quot;%s\&quot;,\&quot;bytes_out_t\&quot;:\&quot;%s\&quot;,&quot;,
						eth[idx].bytes_receive_t, eth[idx].bytes_transmit_t);
					sprintf(&amp;line[strlen(line)],&quot;\&quot;packets_in_t\&quot;:\&quot;%s\&quot;,\&quot;packets_out_t\&quot;:\&quot;%s\&quot;,&quot;,
						eth[idx].packets_receive_t, eth[idx].packets_transmit_t);
					sprintf(&amp;line[strlen(line)],&quot;\&quot;bytes_in_sec\&quot;:\&quot;%s\&quot;,\&quot;bytes_out_sec\&quot;:\&quot;%s\&quot;,&quot;,
						eth[idx].bytes_receive_sec_t, eth[idx].bytes_transmit_sec_t);
					sprintf(&amp;line[strlen(line)],&quot;\&quot;bytes_in\&quot;:%llu,\&quot;bytes_out\&quot;:%llu,&quot;,
						eth[idx].bytes_receive_1, eth[idx].bytes_transmit_1);
					sprintf(&amp;line[strlen(line)],&quot;\&quot;packets_in\&quot;:%llu,\&quot;packets_out\&quot;:%llu,&quot;,
						eth[idx].packets_receive_1, eth[idx].packets_transmit_1);
					sprintf(&amp;line[strlen(line)],&quot;\&quot;packets_out_sec\&quot;:\&quot;%s\&quot;,\&quot;packets_in_sec\&quot;:\&quot;%s\&quot;},&quot;,
						eth[idx].packets_transmit_sec_t, eth[idx].packets_receive_sec_t);


					// logger(prefix,&quot;ETHINFO[%d]: [%s] Timestamp: %.06f [%s], [%s] R: %llu T: %llu TRS: [%s] RRS: [%s] \n&quot;,idx,eth[idx].ifname, eth[idx].timestamp_calc,eth[idx].packets_transmit_sec_t, eth[idx].packets_receive_sec_t,  eth[idx].bytes_receive_1, eth[idx].bytes_transmit_1, eth[idx].bytes_receive_sec_t, eth[idx].bytes_transmit_sec_t);

					ethjson = (char *)realloc(ethjson,strlen(ethjson) + strlen(line) + 10);
					sprintf(&amp;ethjson[strlen(ethjson)],&quot;%s&quot;,line);
				}
				if ( ethjson[strlen(ethjson)-1] == &#039;,&#039; ) ethjson[strlen(ethjson)-1] = &#039;\0&#039;;
				ethjson = (char *)realloc(ethjson,strlen(ethjson) +  10);
				strcat(ethjson,&quot;]&quot;);
				
			}
			{ 
				// Get File-System information
				FILE *fp;
				char buf[1024];

				fsjson = strdup(&quot;[&quot;);

				fp = fopen(&quot;/proc/self/mountinfo&quot;,&quot;r&quot;);
				if ( fp != NULL ){
					while (fgets(buf,1024,fp)!= NULL ){
						char line[1024];
						char *ptr;
						char path[256];
						char dev[256];
						char dev_name[256];
						char type[256];
						struct statfs st;
						ptr = strtok(buf,&quot; \t\r\n&quot;);
						if ( ptr == NULL ) continue; // ID
						ptr = strtok(NULL,&quot; \t\r\n&quot;);
						if ( ptr == NULL ) continue; // Blabla
						ptr = strtok(NULL,&quot; \t\r\n&quot;);
						if ( ptr == NULL ) continue; // DEV
						strcpy(dev,ptr);
						ptr = strtok(NULL,&quot; \t\r\n&quot;);
						if ( ptr == NULL ) continue; // SLASH
						ptr = strtok(NULL,&quot; \t\r\n&quot;);
						if ( ptr == NULL ) continue; // PATH
						strcpy(path,ptr);
						ptr = strtok(NULL,&quot; \t\r\n&quot;);
						if ( ptr == NULL ) continue; // OPT
						ptr = strtok(NULL,&quot; \t\r\n&quot;);
						if ( ptr == NULL ) continue; // X
						ptr = strtok(NULL,&quot; \t\r\n&quot;);
						if ( ptr == NULL ) continue; // TYPE
						strcpy(type,ptr);
						if ( strncmp(type,&quot;ext&quot;,3) != 0  ) continue;
						if ( statfs(path,&amp;st) ) continue;
						logger(prefix,&quot;DSINFO [%s] --&gt; [%s] BLK-SIZE: %d BLOCKS: %llu\n&quot;,path,type,(int) FRAG_SIZE,(unsigned long long) st.f_blocks);	
						strcpy(dev_name, get_diskname(dev));
						sprintf(line,&quot;{\&quot;path\&quot;:\&quot;%s\&quot;,&quot;,path);
						sprintf(&amp;line[strlen(line)],&quot;\&quot;type\&quot;:\&quot;%s\&quot;,&quot;,type);
						sprintf(&amp;line[strlen(line)],&quot;\&quot;dev\&quot;:\&quot;%s\&quot;,&quot;,dev);
						sprintf(&amp;line[strlen(line)],&quot;\&quot;dev_name\&quot;:\&quot;%s\&quot;,&quot;,dev_name);
						sprintf(&amp;line[strlen(line)],&quot;\&quot;b_total\&quot;:%llu,&quot;,(unsigned long long) st.f_blocks * (unsigned long long) FRAG_SIZE);
						sprintf(&amp;line[strlen(line)],&quot;\&quot;b_total_t\&quot;:\&quot;%s\&quot;,&quot;,convert_bytes((double)((unsigned long long) st.f_blocks * (unsigned long long) FRAG_SIZE),&quot;Bytes&quot;));
						sprintf(&amp;line[strlen(line)],&quot;\&quot;b_free\&quot;:%llu,&quot;,(unsigned long long) st.f_bfree * (unsigned long long) FRAG_SIZE);
						sprintf(&amp;line[strlen(line)],&quot;\&quot;b_free_t\&quot;:\&quot;%s\&quot;,&quot;,convert_bytes((double)((unsigned long long) st.f_bavail * (unsigned long long) FRAG_SIZE),&quot;Bytes&quot;));
						sprintf(&amp;line[strlen(line)],&quot;\&quot;b_avail\&quot;:%llu,&quot;,(unsigned long long) st.f_bavail * (unsigned long long) FRAG_SIZE);
						sprintf(&amp;line[strlen(line)],&quot;\&quot;b_avail_t\&quot;:\&quot;%s\&quot;,&quot;,convert_bytes((double)((unsigned long long) st.f_bavail * (unsigned long long) FRAG_SIZE),&quot;Bytes&quot;));
						sprintf(&amp;line[strlen(line)],&quot;\&quot;i_total\&quot;:%llu,&quot;,(unsigned long long) st.f_files);
						sprintf(&amp;line[strlen(line)],&quot;\&quot;i_total_t\&quot;:\&quot;%s\&quot;,&quot;,convert_bytes((double)((unsigned long long) st.f_files),&quot;Inodes&quot;));
						sprintf(&amp;line[strlen(line)],&quot;\&quot;i_free\&quot;:%llu,&quot;,(unsigned long long) st.f_ffree );
						sprintf(&amp;line[strlen(line)],&quot;\&quot;i_free_t\&quot;:\&quot;%s\&quot;&quot;,convert_bytes((double)((unsigned long long) st.f_ffree),&quot;Inodes&quot;));
						sprintf(&amp;line[strlen(line)],&quot;},&quot;);
						fsjson = (char *)realloc(fsjson,strlen(fsjson) + strlen(line) + 10);
						sprintf(&amp;fsjson[strlen(fsjson)],&quot;%s&quot;,line);

					}
					fclose(fp);
				} else {
					logger(prefix,&quot;Getting Filesystems from /proc/mounts...\n&quot;);
					fp = fopen(&quot;/proc/mounts&quot;,&quot;r&quot;);
					if ( fp != NULL ){
						while (fgets(buf,1024,fp)!= NULL ){
							char line[1024];
							char *ptr;
							char path[256];
							char dev[256];
							char dev_name[256];
							char type[256];
							struct statfs st;
							ptr = strtok(buf,&quot; \t\r\n&quot;);
							if ( ptr == NULL ) continue; // DEV
							strcpy(dev,ptr);
							ptr = strtok(NULL,&quot; \t\r\n&quot;);
							if ( ptr == NULL ) continue; // PATH
							strcpy(path,ptr);
							ptr = strtok(NULL,&quot; \t\r\n&quot;);
							if ( ptr == NULL ) continue; // TYPE
							strcpy(type,ptr);
							if ( strncmp(type,&quot;ext&quot;,3) != 0  ) continue;
							if ( statfs(path,&amp;st) ) continue;
							logger(prefix,&quot;DSINFO [%s] --&gt; [%s] BLK-SIZE: %d BLOCKS: %llu\n&quot;,path,type,(int) FRAG_SIZE,(unsigned long long) st.f_blocks);	
							strcpy(dev_name, get_diskname(path));
							sprintf(line,&quot;{\&quot;path\&quot;:\&quot;%s\&quot;,&quot;,path);
							sprintf(&amp;line[strlen(line)],&quot;\&quot;type\&quot;:\&quot;%s\&quot;,&quot;,type);
							sprintf(&amp;line[strlen(line)],&quot;\&quot;dev\&quot;:\&quot;%s\&quot;,&quot;,dev);
							sprintf(&amp;line[strlen(line)],&quot;\&quot;dev_name\&quot;:\&quot;%s\&quot;,&quot;,dev_name);
							sprintf(&amp;line[strlen(line)],&quot;\&quot;b_total\&quot;:%llu,&quot;,(unsigned long long) st.f_blocks * (unsigned long long) FRAG_SIZE);
							sprintf(&amp;line[strlen(line)],&quot;\&quot;b_total_t\&quot;:\&quot;%s\&quot;,&quot;,convert_bytes((double)((unsigned long long) st.f_blocks * (unsigned long long) FRAG_SIZE),&quot;Bytes&quot;));
							sprintf(&amp;line[strlen(line)],&quot;\&quot;b_free\&quot;:%llu,&quot;,(unsigned long long) st.f_bfree * (unsigned long long) FRAG_SIZE);
							sprintf(&amp;line[strlen(line)],&quot;\&quot;b_free_t\&quot;:\&quot;%s\&quot;,&quot;,convert_bytes((double)((unsigned long long) st.f_bavail * (unsigned long long) FRAG_SIZE),&quot;Bytes&quot;));
							sprintf(&amp;line[strlen(line)],&quot;\&quot;b_avail\&quot;:%llu,&quot;,(unsigned long long) st.f_bavail * (unsigned long long) FRAG_SIZE);
							sprintf(&amp;line[strlen(line)],&quot;\&quot;b_avail_t\&quot;:\&quot;%s\&quot;,&quot;,convert_bytes((double)((unsigned long long) st.f_bavail * (unsigned long long) FRAG_SIZE),&quot;Bytes&quot;));
							sprintf(&amp;line[strlen(line)],&quot;\&quot;i_total\&quot;:%llu,&quot;,(unsigned long long) st.f_files);
							sprintf(&amp;line[strlen(line)],&quot;\&quot;i_total_t\&quot;:\&quot;%s\&quot;,&quot;,convert_bytes((double)((unsigned long long) st.f_files),&quot;Inodes&quot;));
							sprintf(&amp;line[strlen(line)],&quot;\&quot;i_free\&quot;:%llu,&quot;,(unsigned long long) st.f_ffree );
							sprintf(&amp;line[strlen(line)],&quot;\&quot;i_free_t\&quot;:\&quot;%s\&quot;&quot;,convert_bytes((double)((unsigned long long) st.f_ffree),&quot;Inodes&quot;));
							sprintf(&amp;line[strlen(line)],&quot;},&quot;);
							fsjson = (char *)realloc(fsjson,strlen(fsjson) + strlen(line) + 10);
							sprintf(&amp;fsjson[strlen(fsjson)],&quot;%s&quot;,line);
						}
						fclose(fp);
					}
				}

				if ( fsjson[strlen(fsjson)-1] == &#039;,&#039; ) fsjson[strlen(fsjson)-1] = &#039;\0&#039;;
				fsjson = (char *)realloc(fsjson,strlen(fsjson) + 10);
				sprintf(&amp;fsjson[strlen(fsjson)],&quot;]&quot;);
				
			}



			qsort(&amp;list[0],lentries,sizeof(struct process_info), comparer);
			// logger(prefix,&quot;************************PROCLIST:  Sorted %d processes\n&quot;,lentries);
			result = strdup(&quot;{\&quot;pl\&quot;:[&quot;);
			for ( ix = 0; ix &lt; lentries; ix++ ){
				char line[1024];
				char ptime[32];
				char stime[32];
				char rss[32];
				double rss_val;
				int slot, index;
				struct tm *tm;
				int hours;
				int minutes;
				int seconds;
				slot = -1;
				index = -1;
				if ( list[ix].pid &gt; 10 ) { 
					int k,l;
					for ( k = 0; k &lt; entries; k++ ){
						for ( l = 0; l &lt; MAX_CONNS; l++ ){
							if ( servlist[k].co[l].cpid == list[ix].pid ){
								slot = k;
								index = l;
								break;
							}
						}
						if ( slot &gt;= 0 ) break;
					}
				}
				hours = list[ix].ptime / 3600;
				minutes = (list[ix].ptime - hours * 3600)/60;
				seconds = list[ix].ptime % 60;
				tm = localtime(&amp;list[ix].starttime);
				sprintf(ptime,&quot;%02d:%02d:%02d&quot;,hours,minutes,seconds);
				sprintf(stime,&quot;%04d.%02d.%02d&amp;nbsp;%02d:%02d:%02d&quot;,
					tm-&gt;tm_year + 1900, tm-&gt;tm_mon + 1, tm-&gt;tm_mday,
					tm-&gt;tm_hour, tm-&gt;tm_min, tm-&gt;tm_sec);


				rss_val = (double) (list[ix].rss * sysconf(_SC_PAGESIZE));
				sprintf(rss,&quot;%d&amp;nbsp;Bytes&quot;,(int)rss_val);
				if ( rss_val &gt; 1024.0 ){
					sprintf(rss,&quot;%.02f&amp;nbsp;KB&quot;,rss_val / 1024.0);
				}
				if ( rss_val &gt; (1024.0*1024.0) ){
					sprintf(rss,&quot;%.02f&amp;nbsp;MB&quot;,rss_val / (1024.0 * 1024.0));
				}
					

				sprintf(line,&quot;{\&quot;rss\&quot;:\&quot;%s\&quot;,\&quot;num_threads\&quot;:%d,\&quot;cpu\&quot;:%d,\&quot;cpu_usage\&quot;:\&quot;%.02f\&quot;,\&quot;pid\&quot;:%d,\&quot;ppid\&quot;:%d,\&quot;vmsize\&quot;:\&quot;%s\&quot;,\&quot;prg\&quot;:\&quot;%s\&quot;,\&quot;stime\&quot;:\&quot;%s\&quot;,\&quot;ptime\&quot;:\&quot;%s\&quot;,\&quot;slot\&quot;:%d,\&quot;index\&quot;:%d,\&quot;_utime\&quot;:%ld,\&quot;_stime\&quot;:%ld,\&quot;nice\&quot;:%ld,\&quot;priority\&quot;:%ld},&quot;,
					rss, list[ix].num_threads, list[ix].cpu, list[ix].cpu_usage, list[ix].pid,list[ix].ppid,list[ix].vmtext,list[ix].program,stime,ptime,slot,index,list[ix].utime,list[ix].stime,list[ix].nice,list[ix].priority);
				// logger(prefix,&quot;[%05d]PROCLIST: [%s] STRLEN RESULT: %d\n&quot;,ix,line,strlen(result));
				if ( list[ix].cpu &gt; cpu_count ){
					usage_sum[0] += list[ix].cpu_usage;	
				} else {
					usage_sum[list[ix].cpu] += list[ix].cpu_usage;	
				}
				result = (char *)realloc(result,strlen(result)+strlen(line)+10);
				strcat(result,line);
			
			}
			if ( result[strlen(result)-1] == &#039;,&#039; ) result[strlen(result)-1] = &#039;\0&#039;;
			{
				char tempbuf[20240];
				int dan;
				sprintf(tempbuf,&quot;],\&quot;eth\&quot;:%s,\&quot;fs\&quot;:%s,\&quot;cpu_count\&quot;:%d,\&quot;load1\&quot;:%.02g,\&quot;ul\&quot;:[&quot;,ethjson,fsjson,cpu_count,loader[0]);
				result = (char *)realloc(result,strlen(result)+strlen(tempbuf) + 10);
				strcat(result,tempbuf);
				for ( dan = 0; dan &lt; cpu_count; dan++ ){
					if ( usage_sum[dan] &gt; 100.0 ) usage_sum[dan] = 100.0;
					sprintf(tempbuf,&quot;{\&quot;total\&quot;:\&quot;%.02f\&quot;},&quot;,usage_sum[dan]);
					result = (char *)realloc(result,strlen(result)+strlen(tempbuf) + 10);
					strcat(result,tempbuf);
				}
				
				if ( result[strlen(result)-1] == &#039;,&#039; ) result[strlen(result)-1] = &#039;\0&#039;;
				result = (char *)realloc(result,strlen(result)+ 1024);
				sprintf(&amp;result[strlen(result)],&quot;],\&quot;dnscheck\&quot;:%s}&quot;,dns_json);
			}
			{
				char *in;
				char *out;
				int newsize;
				in = (char *)malloc(strlen(result) + 20);
				out = (char *)malloc(strlen(result) + 120);
				sprintf(in,&quot;OK[%s]\r\n&quot;,result);
				newsize = gzip_string(in,out);
				if ( newsize &gt; 0 ){
					fprintf(ss,&quot;Accept-Range: bytes\r\n&quot;);
					fprintf(ss,&quot;Content-Length: %d\r\n&quot;,newsize);	
					fprintf(ss,&quot;Content-Encoding: gzip\r\n\r\n&quot;,newsize);	
					fwrite(out,1,newsize,ss);
					fflush(ss);
				} else {
					logger(prefix,&quot;GZIP-FAILED: [%d] &lt;-- [%d]\n&quot;,newsize,strlen(in));
					fprintf(ss,&quot;\r\n%s&quot;,in);
				}
			}
			free(result);
			free(list);
			free(usage_sum);
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
			
		}

		if ( strcmp(command,&quot;RESET&quot;) == 0 ){
			int idx;
			fprintf(ss,&quot;\r\n&quot;);
			logger(prefix,&quot;Resetting %d connections\n&quot;,entries);
			for ( idx = 0; idx &lt; entries; idx++ ){
				int semmel;
				semmel = semget(INETD_KEY2 + idx,1,0);
				if ( semmel &lt; 0 ){
					logger(prefix,&quot;Cannot get SEM [0x%08lX]\n&quot;,INETD_KEY2 + idx);
				} else {
					sem_lock(semmel);
					servlist[idx].reset = time(NULL);
					servlist[idx].total_count = 0;
					sem_unlock(semmel);
				}
			}
			fprintf(ss,&quot;OK[Reset done]\r\n&quot;);
			fflush(ss);
			shutdown(sock,SHUT_RDWR);
			fclose(ss);
			return;
		}


		fprintf(ss,&quot;\r\n&quot;);
		fprintf(ss,&quot;ERR[Bad function]\r\n&quot;);
		
		fflush(ss);
		shutdown(sock,SHUT_RDWR);
		fclose(ss);
		return;
	}
	html_done = 0;
	if ( type_req == TYPE_HTML &amp;&amp; strncmp(url,&quot;/supervisor&quot;,strlen(&quot;/supervisor&quot;)) == 0 ){
		html_done = 1;
		fprintf(ss,&quot;Content-Type: %s\r\n\r\n&quot;,HTML_MIME);
		fprintf(ss,&quot;&lt;HEAD&gt;&lt;meta CHARSET=\&quot;UTF-8\&quot;&gt;&lt;LINK REL=\&quot;stylesheet\&quot; TYPE=\&quot;text/css\&quot; HREF=\&quot;/style.css\&quot;&gt;&lt;/HEAD&gt;\n&quot;);
		fprintf(ss,&quot;&lt;BODY CLASS=&#039;mainbody&#039; onload=init_all()&gt;&quot;);
		fprintf(ss,&quot;&lt;DIV CLASS=&#039;headline&#039;&gt;&lt;TABLE BORDER=0 WIDTH=100%%&gt;&lt;TR&gt;&lt;TD ALIGN=LEFT WIDTH=33%%&gt;&lt;IMG CLASS=l_image onclick=go_main() SRC=/gix_logo.png&gt;&lt;/TD&gt;&lt;TD WIDTH=33%%&gt;&lt;CENTER&gt;&lt;SPAN CLASS=headliner&gt;%s (Supervisor) @ %s&lt;BR&gt;My Update-Server: [%s]&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD ALIGN=RIGHT WIDTH=33%%&gt;&lt;TABLE BORDER=0&gt;&lt;TR&gt;&lt;TD ALIGN=RIGHT&gt;PID:&lt;/TD&gt;&lt;TD ALIGN=LEFT&gt;&lt;B&gt;%d&lt;/B&gt;&lt;/TD&gt;&lt;/TR&gt;&lt;TR&gt;&lt;TD ALIGN=RIGHT&gt;You:&lt;/TD&gt;&lt;TD ALIGN=LEFT&gt;&lt;B&gt;%s&lt;/B&gt;&lt;/TD&gt;&lt;/TR&gt;&lt;TR&gt;&lt;TD ALIGN=RIGHT&gt;Me:&lt;/TD&gt;&lt;TD ALIGN=LEFT&gt;&lt;B&gt;%s&lt;/B&gt;&lt;/TD&gt;&lt;/TR&gt;&lt;/TABLE&gt;&lt;/TD&gt;&lt;/TR&gt;&lt;/TABLE&gt;&quot;,
			GIX_INETD_VERSION, my_hostname,GIX_INETD_UPDATESERVER,getppid(), CCON.source, CCON.target);
		fprintf(ss,&quot;&lt;/DIV&gt;&quot;);
		fprintf(ss,&quot;&lt;DIV ID=&#039;MAIN&#039; CLASS=mainscreen&gt;\n&quot;);
		fprintf(ss,&quot;&lt;CENTER&gt;&quot;);
		fprintf(ss,&quot;&lt;TABLE BORDER=0 CELLSPACING=1&gt;\n&quot;);
		fprintf(ss,&quot;&lt;TR&gt;&lt;TD VALIGN=TOP&gt;&quot;);
		fprintf(ss,&quot;&lt;DIV ID=HOSTLIST CLASS=simple_div&gt;&lt;/DIV&gt;&quot;);
		fprintf(ss,&quot;&lt;/TD&gt;&lt;/TR&gt;&lt;TR&gt;&lt;TD VALIGN=TOP&gt;&lt;CENTER&gt;&lt;BR&gt;&lt;P&gt;&quot;);
		fprintf(ss,&quot;&lt;TABLE BORDER=0 BGCOLOR=black CELLSPACING=1&gt;\n&quot;);
		fprintf(ss,&quot;&lt;TR BGCOLOR=yellow&gt;&lt;TD ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2&gt;Single-Check (IPv4, IPv6 or hostname):&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD ALIGN=LEFT&gt;&lt;INPUT TYPE=TEXT CLASS=input2s ID=TEST_HOSTNAME&gt;&lt;/TD&gt;&lt;TD ROWSPAN=1 VALIGN=BOTTOM&gt;&lt;INPUT TYPE=BUTTON VALUE=&#039;Test host...&#039; CLASS=standard_button onclick=test_host()&gt;&lt;/TD&gt;&lt;/TR&gt;\n&quot;);
		fprintf(ss,&quot;&lt;TR BGCOLOR=lightblue&gt;&lt;TD ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2&gt;Scan-IP Start (IPv4):&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD ALIGN=LEFT&gt;&lt;INPUT TYPE=TEXT CLASS=input2s ID=IPSCAN_START onchange=update_end_field()&gt;&lt;/TD&gt;&lt;TD ROWSPAN=2 VALIGN=BOTTOM&gt;&lt;INPUT TYPE=BUTTON VALUE=&#039;Start scan...&#039; CLASS=standard_button onclick=start_scan()&gt;&lt;/TD&gt;&lt;/TR&gt;\n&quot;);
		fprintf(ss,&quot;&lt;TR BGCOLOR=lightblue&gt;&lt;TD ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2&gt;Scan-IP End (IPv4):&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD ALIGN=LEFT&gt;&lt;INPUT TYPE=TEXT CLASS=input2s ID=IPSCAN_END&gt;&lt;/TD&gt;&lt;/TR&gt;\n&quot;);
		fprintf(ss,&quot;&lt;/TABLE&gt;\n&quot;);
		fprintf(ss,&quot;&lt;/TD&gt;&lt;/TR&gt;&quot;);
		fprintf(ss,&quot;&lt;/TABLE&gt;\n&quot;);
		fprintf(ss,&quot;&lt;/DIV&gt;&quot;);

		fprintf(ss,&quot;&lt;DIV CLASS=footer&gt;&lt;CENTER&gt;(C) Ing. Andy Paumann, globedom Bulgaria&lt;/DIV&gt;&quot;);

		fprintf(ss,&quot;&lt;SCRIPT LANGUAGE=JavaScript&gt;\n&quot;);
		
		fprintf(ss,&quot;hostentry = {\n&quot;);
		fprintf(ss,&quot; url: &#039;&#039;,\n&quot;);
		fprintf(ss,&quot; name: &#039;&#039;,\n&quot;);
		fprintf(ss,&quot; version: &#039;&#039;,\n&quot;);
		fprintf(ss,&quot; username: &#039;derDaniel&#039;,\n&quot;);
		fprintf(ss,&quot; password: &#039;&#039;,\n&quot;);
		fprintf(ss,&quot; remark: &#039;&#039;,\n&quot;);
		fprintf(ss,&quot; active: true\n&quot;);
		fprintf(ss,&quot;};\n&quot;);


		fprintf(ss,&quot;var hostlist = [];\n&quot;);
		fprintf(ss,&quot;var s_hlisttimer = null;\n&quot;);

		fprintf(ss,&quot;function sort_func(a,b){\n&quot;);
		fprintf(ss,&quot; return(a.remark.localeCompare(b.remark));\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
	
		fprintf(ss,&quot;function init_all(){\n&quot;);
		fprintf(ss,&quot; load_cookie();\n&quot;);
		fprintf(ss,&quot; if ( hostlist.length == 0 ){\n&quot;);
		fprintf(ss,&quot;  load_config();\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; hostlist.sort(sort_func);\n&quot;);
		fprintf(ss,&quot; s_hlisttimer = setInterval(update_responses,2000);\n&quot;);
		fprintf(ss,&quot; update_hostlist();\n&quot;);
		fprintf(ss,&quot; console.log(&#039;Init completed&#039;);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function update_hostlist(){\n&quot;);
		fprintf(ss,&quot; var divvy = document.getElementById(&#039;HOSTLIST&#039;);\n&quot;);
		fprintf(ss,&quot; var result = &#039;&lt;CENTER&gt;&lt;TABLE BORDER=0 CELLSPACING=1 BGCOLOR=black&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR BGCOLOR=white&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;&amp;nbsp;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;Response&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;Disks&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;Load&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;DNS&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;Remark&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;Hostname&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;URL&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;Version&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;Password&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;&amp;nbsp;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;&amp;nbsp;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;Response&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;Disks&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;Load&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;DNS&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;Remark&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;Hostname&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;URL&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;Version&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;Password&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;&amp;nbsp;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; var lines = Math.floor(hostlist.length / 2);\n&quot;);
		fprintf(ss,&quot; if ( hostlist.length %% 2 ) lines++;\n&quot;);
		fprintf(ss,&quot; console.log(&#039;Lines: [&#039; + lines + &#039;] Hosts: [&#039; + hostlist.length + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot; for ( var i = 0; i &lt; hostlist.length; i++ ){\n&quot;);
		fprintf(ss,&quot;  var color = &#039;lightblue&#039;;\n&quot;);
		fprintf(ss,&quot;  if ( i %% 2 ) color = &#039;yellow&#039;;\n&quot;);
		fprintf(ss,&quot;  if ( (i %% 2) == 0 ) result += &#039;&lt;TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  var idx = Math.floor(i/2) + (i%%2);\n&quot;);
		fprintf(ss,&quot;  if ( i %% 2 ) idx += (lines-1);\n&quot;);
		fprintf(ss,&quot;  console.log(&#039;Index: [&#039; + i + &#039;] IDX: [&#039; + idx + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  if ( idx &gt;= hostlist.length ){\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; COLSPAN=10&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   continue;\n&quot;);
		fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot;  if ( hostlist[idx].active ){\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039;&gt;&lt;INPUT TYPE=CHECKBOX ID=ACTIVE_&#039; + idx + &#039; CHECKED onchange=save_active(&#039; + idx + &#039;,false)&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD ALIGN=RIGHT BGCOLOR=&#039; + color + &#039;&gt;&lt;SPAN CLASS=thead2s ID=RESPONSE_TIME_&#039; + idx + &#039;&gt;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  } else {\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039;&gt;&lt;INPUT TYPE=CHECKBOX ID=ACTIVE_&#039; + idx + &#039;  onchange=save_active(&#039; + idx + &#039;,true)&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD ALIGN=RIGHT BGCOLOR=&#039; + color + &#039;&gt;&lt;SPAN CLASS=thead4s ID=RESPONSE_TIME_&#039; + idx + &#039;&gt;not monitored&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=CENTER ID=DISK_WARN_&#039; + idx + &#039; BGCOLOR=&#039; + color + &#039;&gt;&lt;/TD&gt;&#039;;\n&quot;); // DISK-WARN
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=CENTER ID=LOAD_WARN_&#039; + idx + &#039; BGCOLOR=&#039; + color + &#039;&gt;&lt;/TD&gt;&#039;;\n&quot;); // CPU-WARN
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=CENTER ID=DNS_WARN_&#039; + idx + &#039; BGCOLOR=&#039; + color + &#039;&gt;&lt;/TD&gt;&#039;;\n&quot;); // CPU-WARN
		fprintf(ss,&quot;  result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039;&gt;&lt;INPUT TYPE=TEXT CLASS=input2s VALUE=\&quot;&#039; + hostlist[idx].remark + &#039;\&quot; ID=REMARK_&#039; + idx + &#039; onchange=save_remark(&#039; + idx + &#039;)&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=LEFT BGCOLOR=&#039; + color + &#039;&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + hostlist[idx].name + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=LEFT BGCOLOR=&#039; + color + &#039;&gt;&lt;SPAN CLASS=thead2links onclick=goto_url(\&quot;&#039; + hostlist[idx].url + &#039;\&quot;)&gt;&#039; + hostlist[idx].url.substr(7) + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);

		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=RIGHT BGCOLOR=&#039; + color + &#039;&gt;&lt;SPAN CLASS=thead2s ID=VERSION_&#039; + idx + &#039;&gt;&#039; + get_version_number(hostlist[idx].version) + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039;&gt;&lt;INPUT TYPE=TEXT CLASS=input2s SIZE=6 VALUE=\&quot;&#039; + hostlist[idx].password + &#039;\&quot; ID=PASSWORD_&#039; + idx + &#039; onchange=save_pwd(&#039; + idx + &#039;)&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039;&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;INPUT TYPE=BUTTON CLASS=standard_buttons VALUE=\&quot;Delete\&quot; onclick=del_element(&#039; + idx + &#039;)&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&amp;nbsp;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;INPUT TYPE=BUTTON CLASS=standard_buttons VALUE=\&quot;Check\&quot; onclick=recheck(&#039; + idx + &#039;)&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&amp;nbsp;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;INPUT TYPE=BUTTON CLASS=standard_buttons VALUE=\&quot;Update\&quot; onclick=update_version_r(&#039; + idx + &#039;)&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  if ( (i %% 2) != 0 ) result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; if ( i %% 2 ) result += &#039;&lt;TD BGCOLOR=yellow COLSPAN=10&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;/TABLE&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;P&gt;&lt;CENTER&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;INPUT TYPE=BUTTON CLASS=standard_button VALUE=\&quot;Save hostlist as new default\&quot; onclick=save_config()&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&amp;nbsp;&lt;INPUT TYPE=BUTTON CLASS=standard_button VALUE=\&quot;Save global hostlist\&quot; onclick=save_config_x()&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&amp;nbsp;&lt;INPUT TYPE=BUTTON CLASS=standard_button VALUE=\&quot;Clear local cookie (will load defaults on next reload)\&quot; onclick=reset_cookie()&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&amp;nbsp;&lt;INPUT TYPE=BUTTON CLASS=standard_button VALUE=\&quot;Save hostlist to Cookie\&quot; onclick=save_cookie()&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&amp;nbsp;&lt;INPUT TYPE=BUTTON CLASS=standard_button VALUE=\&quot;Clear hostlist\&quot; onclick=del_hostlist()&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; divvy.innerHTML = result;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function update_responses(){\n&quot;);
		fprintf(ss,&quot; for ( var i = 0; i &lt; hostlist.length; i++ ){\n&quot;);
		fprintf(ss,&quot;  if ( hostlist[i].active == false ) continue;\n&quot;);
		fprintf(ss,&quot;  var req2 = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot;  req2.hostlist_idx = i;\n&quot;);
		fprintf(ss,&quot;  req2.gix_start_time = Date.now();\n&quot;);
		fprintf(ss,&quot;  req2.onreadystatechange = update_responses_callback;\n&quot;);
		// fprintf(ss,&quot;  console.log(&#039;TESTING: [&#039; + hostlist[i].url + &#039;/version]&#039;);\n&quot;);
		fprintf(ss,&quot;  req2.open(&#039;GET&#039;,hostlist[i].url + &#039;/version&#039;,true);\n&quot;);
		fprintf(ss,&quot;  req2.send();\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;function update_version_r(idx){\n&quot;);
		fprintf(ss,&quot; var ii = 0;\n&quot;);
		fprintf(ss,&quot; var a_current_version = &#039;%s&#039;;\n&quot;,GIX_INETD_VERSION);
		fprintf(ss,&quot; var a_installed_version = hostlist[idx].version;\n&quot;);
		fprintf(ss,&quot; for ( ii = 0; ii &lt; a_current_version.length; ii++ ){\n&quot;);
		fprintf(ss,&quot;  if ( a_current_version.charCodeAt(ii) &gt; 47 &amp;&amp; a_current_version.charCodeAt(ii) &lt; 58 ) break;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; var current_version_f = parseFloat(a_current_version.substr(ii));\n&quot;);
		fprintf(ss,&quot; if ( isNaN(current_version_f) ){ alert(&#039;Cannot determine current version&#039;); return;}\n&quot;);
		fprintf(ss,&quot; console.log(&#039;Currently local version: [&#039; + current_version_f + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot; for ( ii = 0; ii &lt; a_installed_version.length; ii++ ){\n&quot;);
		fprintf(ss,&quot;  if ( a_installed_version.charCodeAt(ii) &gt; 47 &amp;&amp; a_installed_version.charCodeAt(ii) &lt; 58 ) break;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; var installed_version_f = parseFloat(a_installed_version.substr(ii));\n&quot;);
		fprintf(ss,&quot; if ( isNaN(installed_version_f) ){ alert(&#039;Cannot determine current version&#039;); return;}\n&quot;);
		fprintf(ss,&quot; console.log(&#039;Currently installed version: [&#039; + installed_version_f + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot; if ( a_installed_version &gt;= a_current_version ){\n&quot;);
		fprintf(ss,&quot;  alert(&#039;There is already installed the actual/newer version (&#039; + a_installed_version + &#039;)&#039;);\n&quot;);
		fprintf(ss,&quot;  return;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; var request = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot; request.open(&#039;GET&#039;,hostlist[idx].url + &#039;/update_version/0&#039;,true);\n&quot;);
		fprintf(ss,&quot; request.setRequestHeader(&#039;Authorization&#039;,&#039;Basic &#039; + btoa(hostlist[idx].username + &#039;:&#039; + hostlist[idx].password));\n&quot;);
		fprintf(ss,&quot; request.send();\n&quot;);
		fprintf(ss,&quot; alert(&#039;Update request sent...&#039;);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function get_version_number(vers){\n&quot;);
		fprintf(ss,&quot; for ( var i = 0; i &lt; vers.length; i++ ){\n&quot;);
		fprintf(ss,&quot;  if ( vers.charCodeAt(i) &gt; 47 &amp;&amp; vers.charCodeAt(i) &lt; 58 ) break;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; return(vers.substr(i));\n&quot;);
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;function update_responses_callback(){\n&quot;);
		fprintf(ss,&quot; var req = this;\n&quot;);
		fprintf(ss,&quot; if ( req.readyState != 4 ) return;\n&quot;);
		fprintf(ss,&quot; if ( req.status == 200 &amp;&amp; req.responseText.charAt(0) == &#039;O&#039; ){\n&quot;);
		fprintf(ss,&quot;  var now = Date.now();\n&quot;);
		fprintf(ss,&quot;  var vers = JSON.parse(extract_bracket_val(req.responseText));\n&quot;);
		// fprintf(ss,&quot;  console.log(&#039;Received Version-String [&#039; + get_version_number(vers.version) + &#039;] for Index: [&#039; + req.hostlist_idx + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  document.getElementById(&#039;VERSION_&#039; + req.hostlist_idx).innerHTML = get_version_number(vers.version);\n&quot;);
		fprintf(ss,&quot;  hostlist[req.hostlist_idx].version = vers.version;\n&quot;);
		fprintf(ss,&quot;  var delta = now - req.gix_start_time;\n&quot;); 
		// fprintf(ss,&quot;  console.log(&#039;HOST [&#039; + hostlist[req.hostlist_idx].url + &#039;] Response-Time: [&#039; + delta + &#039; ms]&#039;);\n&quot;);
		fprintf(ss,&quot;  window.document.getElementById(&#039;RESPONSE_TIME_&#039; + req.hostlist_idx).setAttribute(&#039;class&#039;,&#039;thead2s&#039;);\n&quot;);
		fprintf(ss,&quot;  window.document.getElementById(&#039;RESPONSE_TIME_&#039; + req.hostlist_idx).innerHTML = delta + &#039;&amp;nbsp;ms&#039;;\n&quot;);
		fprintf(ss,&quot; } else {\n&quot;);
		fprintf(ss,&quot;  console.log(&#039;HOST [&#039; + hostlist[req.hostlist_idx].url + &#039;] Response-Time: [&#039; + delta + &#039; ms] TIMEOUT!&#039;);\n&quot;);
		fprintf(ss,&quot;  window.document.getElementById(&#039;RESPONSE_TIME_&#039; + req.hostlist_idx).setAttribute(&#039;class&#039;,&#039;thead1s&#039;);\n&quot;);
		fprintf(ss,&quot;  window.document.getElementById(&#039;RESPONSE_TIME_&#039; + req.hostlist_idx).innerHTML = &#039;&lt;B&gt;FAILED&lt;/B&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		// Get Disk &amp; CPU Informations
		fprintf(ss,&quot; var req2 = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot; req2.hostlist_idx = req.hostlist_idx;\n&quot;);
		fprintf(ss,&quot; req2.onreadystatechange = update_response_callback_callback;\n&quot;);
		fprintf(ss,&quot; req2.open(&#039;GET&#039;,hostlist[req2.hostlist_idx].url + &#039;/ajax/PROCLIST/0&#039;,true);\n&quot;);
		fprintf(ss,&quot; req2.setRequestHeader(&#039;Authorization&#039;,&#039;Basic &#039; + btoa(hostlist[req2.hostlist_idx].username + &#039;:&#039; + hostlist[req2.hostlist_idx].password));\n&quot;);
		fprintf(ss,&quot; req2.send();\n&quot;);
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;function update_response_callback_callback(){\n&quot;);
		fprintf(ss,&quot; req = this;\n&quot;);
		fprintf(ss,&quot; if ( req.readyState != 4 ) return;\n&quot;);
		// fprintf(ss,&quot; console.log(&#039;REQUEST-STATUS (&#039; + hostlist[req.hostlist_idx].url  + &#039;) --&gt; [&#039; + req.responseText + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot; if ( req.responseText.charAt(0) != &#039;O&#039; ) return;\n&quot;);
		fprintf(ss,&quot; var procinfo = JSON.parse(extract_bracket_val(req.responseText));\n&quot;);
		fprintf(ss,&quot; var normal_img = &#039;/led_green.gif&#039;;\n&quot;);
		fprintf(ss,&quot; for ( var i = 0; i &lt; procinfo.fs.length; i++ ){\n&quot;);
		fprintf(ss,&quot;  var usage_percent = Math.round((100.0 - (procinfo.fs[i].b_avail * 100) / procinfo.fs[i].b_total)*100)/100;\n&quot;);
		// fprintf(ss,&quot;  console.log(&#039;[&#039; + hostlist[req.hostlist_idx].url + &#039;](&#039; + hostlist[req.hostlist_idx].name + &#039;) FILESYSTEM: [&#039; + procinfo.fs[i].path + &#039;] AVAIL: [&#039; + procinfo.fs[i].b_avail + &#039;] TOTAL: [&#039; + procinfo.fs[i].b_total + &#039;] Factor: [&#039; + usage_percent + &#039;] Load: [&#039; + procinfo.load1 + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  if ( usage_percent &gt; 65 ) normal_img = &#039;/led_orange.gif&#039;;\n&quot;);
		fprintf(ss,&quot;  if ( usage_percent &gt; 90 ){ normal_img = &#039;/led_red.gif&#039;; break; }\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; document.getElementById(&#039;DISK_WARN_&#039; + req.hostlist_idx).innerHTML = &#039;&lt;IMG SRC=&#039; + normal_img + &#039; WIDTH=24&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; normal_img = &#039;/led_green.gif&#039;;\n&quot;);
		fprintf(ss,&quot; if ( procinfo.load1 &gt; 1.0 ) normal_img = &#039;/led_orange.gif&#039;;\n&quot;);
		fprintf(ss,&quot; if ( procinfo.load1 &gt; 3.0 ) normal_img = &#039;/led_red.gif&#039;;\n&quot;);
		fprintf(ss,&quot; document.getElementById(&#039;LOAD_WARN_&#039; + req.hostlist_idx).innerHTML = &#039;&lt;IMG SRC=&#039; + normal_img + &#039; WIDTH=24&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; document.getElementById(&#039;DNS_WARN_&#039; + req.hostlist_idx).innerHTML = &#039;&#039;;\n&quot;);
		fprintf(ss,&quot; if ( procinfo.dnscheck != undefined ){\n&quot;);
		fprintf(ss,&quot;  if ( procinfo.dnscheck.active ){\n&quot;);
		fprintf(ss,&quot;   var normal_img = &#039;/led_red.gif&#039;;\n&quot;);
		fprintf(ss,&quot;   if ( procinfo.dnscheck.success == true ) normal_img = &#039;/led_green.gif&#039;;\n&quot;);
		fprintf(ss,&quot;   document.getElementById(&#039;DNS_WARN_&#039; + req.hostlist_idx).innerHTML = &#039;&lt;IMG SRC=&#039; + normal_img + &#039; WIDTH=24&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;function setCookie(cname, cvalue, exmins) {\n&quot;);
		fprintf(ss,&quot;  var d = new Date();\n&quot;);
		fprintf(ss,&quot;  d.setTime(d.getTime() + (exmins*60*1000));\n&quot;);
		fprintf(ss,&quot;  var expires = &#039;expires=&#039;+ d.toUTCString();\n&quot;);
		fprintf(ss,&quot;  document.cookie = cname + &#039;=&#039; + cvalue + &#039;;&#039; + expires + &#039;;path=/&#039;;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;function delCookie(cname) {\n&quot;);
		fprintf(ss,&quot;  var d = new Date();\n&quot;);
		fprintf(ss,&quot;  d.setTime(d.getTime() - (500*24*60*60*1000) );\n&quot;);
		fprintf(ss,&quot;  var expires = &#039;expires=&#039;+ d.toUTCString();\n&quot;);
		fprintf(ss,&quot;  document.cookie = cname + &#039;=&#039; + null + &#039;;&#039; + expires + &#039;;path=/&#039;;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;\n&quot;);
		fprintf(ss,&quot;function getCookie(cname) {\n&quot;);
		fprintf(ss,&quot;  var name = cname + &#039;=&#039;;\n&quot;);
		fprintf(ss,&quot;  var decodedCookie = decodeURIComponent(document.cookie);\n&quot;);
		fprintf(ss,&quot;  var ca = decodedCookie.split(&#039;;&#039;);\n&quot;);
		fprintf(ss,&quot;  for(var i = 0; i &lt;ca.length; i++) {\n&quot;);
		fprintf(ss,&quot;    var c = ca[i];\n&quot;);
		fprintf(ss,&quot;    while (c.charAt(0) == &#039; &#039;) {\n&quot;);
		fprintf(ss,&quot;      c = c.substring(1);\n&quot;);
		fprintf(ss,&quot;    }\n&quot;);
		fprintf(ss,&quot;    if (c.indexOf(name) == 0) {\n&quot;);
		fprintf(ss,&quot;      return c.substring(name.length, c.length);\n&quot;);
		fprintf(ss,&quot;    }\n&quot;);
		fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot;  return &#039;&#039;;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;function recheck(idx){\n&quot;);
		fprintf(ss,&quot; var request = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot; request.hostlist_idx = idx;\n&quot;);
		fprintf(ss,&quot; request.onreadystatechange = function() { recheck_callback(request); };\n&quot;);
		fprintf(ss,&quot; request.open(&#039;GET&#039;,hostlist[idx].url + &#039;/version_s&#039;,true);\n&quot;);
		fprintf(ss,&quot; request.setRequestHeader(&#039;Authorization&#039;,&#039;Basic &#039; + btoa(hostlist[idx].username + &#039;:&#039; + hostlist[idx].password));\n&quot;);
		fprintf(ss,&quot; request.send();\n&quot;);
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;function recheck_callback(req){\n&quot;);
		fprintf(ss,&quot; console.log(&#039;ready-State: [&#039; + req.readyState + &#039;] Response-Code: [&#039; + req.status + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot; if ( req.readyState != 4 ) return;\n&quot;);
		fprintf(ss,&quot; if ( req.status == 200 &amp;&amp; req.responseText.charAt(0) == &#039;O&#039; ){\n&quot;);
		fprintf(ss,&quot;  console.log(&#039;Response: [&#039; + req.responseText + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  var vers = JSON.parse(extract_bracket_val(req.responseText));\n&quot;);
		fprintf(ss,&quot;  hostlist[req.hostlist_idx].version = vers.version;\n&quot;);
		fprintf(ss,&quot;  hostlist[req.hostlist_idx].name = vers.hostname;\n&quot;);
		fprintf(ss,&quot;  update_hostlist();\n&quot;);
		fprintf(ss,&quot;  alert(&#039;Check successfull, Name and Versioninfo updated&#039;);\n&quot;);
		fprintf(ss,&quot;  return;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; alert(&#039;Check failed: HTTP-Status: [&#039; + req.status + &#039;] Response-Text: [&#039; + req.responseText + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function del_hostlist(){\n&quot;);
		fprintf(ss,&quot; hostlist = [];\n&quot;);
		fprintf(ss,&quot; update_hostlist();\n&quot;);
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;function del_element(idx){\n&quot;);
		fprintf(ss,&quot; hostlist.splice(idx,1);\n&quot;);
		fprintf(ss,&quot; update_hostlist();\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function save_pwd(idx){\n&quot;);
		fprintf(ss,&quot;  hostlist[idx].password = document.getElementById(&#039;PASSWORD_&#039; + idx).value;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function save_active(idx,newval){\n&quot;);
		fprintf(ss,&quot;  hostlist[idx].active = newval;\n&quot;);
		fprintf(ss,&quot;  if ( newval == false ){\n&quot;);
		fprintf(ss,&quot;   window.document.getElementById(&#039;RESPONSE_TIME_&#039; + idx).innerHTML = &#039;not monitored&#039;;\n&quot;);
		fprintf(ss,&quot;   window.document.getElementById(&#039;RESPONSE_TIME_&#039; + idx).setAttribute(&#039;class&#039;,&#039;thead3s&#039;);\n&quot;);
		fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot; update_hostlist();\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function save_remark(idx){\n&quot;);
		fprintf(ss,&quot;  hostlist[idx].remark = document.getElementById(&#039;REMARK_&#039; + idx).value;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function reset_cookie(){\n&quot;);
		fprintf(ss,&quot; delCookie(&#039;gix_inetd_hostlist&#039;);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function save_cookie(){\n&quot;);
		fprintf(ss,&quot; for ( var i = 0; i &lt; hostlist.length; i++ ){\n&quot;);
		fprintf(ss,&quot;  hostlist[i].password = document.getElementById(&#039;PASSWORD_&#039; + i).value;\n&quot;);
		fprintf(ss,&quot;  hostlist[i].remark = document.getElementById(&#039;REMARK_&#039; + i).value;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; var json_string = JSON.stringify(hostlist);\n&quot;);
		fprintf(ss,&quot; console.log(&#039;JSON_STRING: [&#039; + json_string + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot; setCookie(&#039;gix_inetd_hostlist&#039;,json_string,3000000);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function save_config(){\n&quot;);
		fprintf(ss,&quot; if ( confirm(&#039;Are you sure, you want to overwrite system-configuration?&#039;) == false ) return;\n&quot;);
		fprintf(ss,&quot; var formData = new FormData();\n&quot;);
		fprintf(ss,&quot; formData.enctype = &#039;multipart/form-data&#039;;\n&quot;);
		fprintf(ss,&quot; formData.append(&#039;ACTION&#039;,&#039;SAVE_CONFIG&#039;);\n&quot;);
		fprintf(ss,&quot; formData.append(&#039;FILE&#039;,&#039;systems.cfg&#039;);\n&quot;);
		fprintf(ss,&quot; formData.append(&#039;DATA&#039;,JSON.stringify(hostlist));\n&quot;);
		fprintf(ss,&quot; var request = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot; request.onreadystatechange = save_config_callback;\n&quot;);
		fprintf(ss,&quot; request.open(&#039;POST&#039;,&#039;/ajax/AJAX&#039;,true);\n&quot;);
		fprintf(ss,&quot; // request.setRequestHeader(&#039;Authorization&#039;,&#039;Basic &#039; + btoa(hostlist[i].username + &#039;:&#039; + hostlist[i].password));\n&quot;);
		fprintf(ss,&quot; request.send(formData);\n&quot;);
		fprintf(ss,&quot; console.log(&#039;Sent SAVE-CONFIG Request to: myself&#039;);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function save_config_callback(){\n&quot;);
		fprintf(ss,&quot; var request = this;\n&quot;);
		fprintf(ss,&quot; if ( request.readyState != 4 ) return;\n&quot;);
		fprintf(ss,&quot; console.log(&#039;(%s:%d) REQUEST-STATUS: [&#039; + request.status + &#039;] RESULT: [&#039; + request.responseText + &#039;]&#039;);\n&quot;,__FILE__,__LINE__);
		fprintf(ss,&quot; if ( request.status != 200 ){ alert(&#039;Bad response-Code from Server (check password and version): [&#039; + request.status + &#039;]&#039;); return; }\n&quot;); 
		fprintf(ss,&quot; if ( request.responseText.charAt(0) == &#039;O&#039; ) { alert(&#039;Configuration successfully written &#039;); return; }\n&quot;);
		fprintf(ss,&quot; alert(&#039;Saving configuration failed [&#039; + request.responseText + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function save_config_x(){\n&quot;);
		fprintf(ss,&quot; if ( confirm(&#039;Are you sure, you want to overwrite system-configuration?&#039;) == false ) return;\n&quot;);
		fprintf(ss,&quot; for ( var i = 0; i &lt; hostlist.length; i++ ){\n&quot;);
		fprintf(ss,&quot;  var formData = new FormData();\n&quot;);
		fprintf(ss,&quot;  formData.enctype = &#039;multipart/form-data&#039;;\n&quot;);
		fprintf(ss,&quot;  formData.append(&#039;ACTION&#039;,&#039;SAVE_CONFIG&#039;);\n&quot;);
		fprintf(ss,&quot;  formData.append(&#039;FILE&#039;,&#039;systems.cfg&#039;);\n&quot;);
		fprintf(ss,&quot;  formData.append(&#039;DATA&#039;,JSON.stringify(hostlist));\n&quot;);
		fprintf(ss,&quot;  var request = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot;  request.host_entry = hostlist[i];\n&quot;);
		fprintf(ss,&quot;  request.onreadystatechange = save_config_x_callback;\n&quot;);
		fprintf(ss,&quot;  request.open(&#039;POST&#039;,hostlist[i].url + &#039;/ajax/AJAX&#039;,true);\n&quot;);
		fprintf(ss,&quot;  request.setRequestHeader(&#039;Authorization&#039;,&#039;Basic &#039; + btoa(hostlist[i].username + &#039;:&#039; + hostlist[i].password));\n&quot;);
		fprintf(ss,&quot;  request.send(formData);\n&quot;);
		fprintf(ss,&quot;  console.log(&#039;Sent SAVE-CONFIG Request to: [&#039; + hostlist[i].url + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function save_config_x_callback(){\n&quot;);
		fprintf(ss,&quot; var request = this;\n&quot;);
		fprintf(ss,&quot; if ( request.readyState != 4 ) return;\n&quot;);
		fprintf(ss,&quot; console.log(&#039;(%s:%d) REQUEST-STATUS: [&#039; + request.status + &#039;] RESULT: [&#039; + request.responseText + &#039;]&#039;);\n&quot;,__FILE__,__LINE__);
		fprintf(ss,&quot; if ( request.status != 200 ){ alert(&#039;Bad response-Code from Server (check password and version): [&#039; + request.status + &#039;]&#039;); return; }\n&quot;); 
		fprintf(ss,&quot; if ( request.responseText.charAt(0) == &#039;O&#039; ) { alert(&#039;Configuration successfully written at: [&#039; + request.host_entry.url + &#039;]&#039;); return; }\n&quot;);
		fprintf(ss,&quot; alert(&#039;Saving configuration failed at [&#039; + request.host_entry.url + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function load_config(){\n&quot;);
		fprintf(ss,&quot; var formData = new FormData();\n&quot;);
		fprintf(ss,&quot; formData.enctype = &#039;multipart/form-data&#039;;\n&quot;);
		fprintf(ss,&quot; formData.append(&#039;ACTION&#039;,&#039;LOAD_CONFIG&#039;);\n&quot;);
		fprintf(ss,&quot; formData.append(&#039;FILE&#039;,&#039;systems.cfg&#039;);\n&quot;);
		fprintf(ss,&quot; var request = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot; request.open(&#039;POST&#039;,&#039;/ajax/AJAX&#039;,false);\n&quot;);
		fprintf(ss,&quot; request.send(formData);\n&quot;);
		fprintf(ss,&quot; console.log(&#039;(%s:%d) REQUEST-STATUS: [&#039; + request.status + &#039;] RESULT: [&#039; + request.responseText + &#039;]&#039;);\n&quot;,__FILE__,__LINE__);
		fprintf(ss,&quot; if ( request.responseText.charAt(0) != &#039;O&#039; ){\n&quot;);
		fprintf(ss,&quot;  alert(&#039;Cannot load config [&#039; + extract_bracket_val(request.responseText) + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  return;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; hostlist = JSON.parse(extract_bracket_val(request.responseText));\n&quot;);
		fprintf(ss,&quot; alert(&#039;Configuration successfully loaded&#039;);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function load_cookie(){\n&quot;);
		fprintf(ss,&quot; var json_string = getCookie(&#039;gix_inetd_hostlist&#039;);\n&quot;);
		fprintf(ss,&quot; console.log(&#039;JSON_STRING ON LOAD: [&#039; + json_string + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot; if ( json_string.length &gt; 3 ){\n&quot;);
		fprintf(ss,&quot;  hostlist = JSON.parse(json_string);\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function goto_url(url){\n&quot;);
		fprintf(ss,&quot; window.open(url);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function go_main(){\n&quot;);
		fprintf(ss,&quot; location = &#039;/&#039;;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);	

		fprintf(ss,&quot;function test_host(){\n&quot;);
		fprintf(ss,&quot; var hostname = window.document.getElementById(&#039;TEST_HOSTNAME&#039;).value.trim();\n&quot;);
		fprintf(ss,&quot; if ( hostname.indexOf(&#039;:&#039;) != -1 ) hostname = &#039;[&#039; + hostname + &#039;]&#039;;\n&quot;);
		fprintf(ss,&quot; console.log(&#039;Testing HOST: {&#039; + hostname + &#039;}&#039;);\n&quot;);
		fprintf(ss,&quot; var request = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot; request.gix_inetd_addr = hostname;\n&quot;);
		fprintf(ss,&quot; request.gix_inetd_port = 9000;\n&quot;);
		fprintf(ss,&quot; request.onreadystatechange = scan_host_callback;\n&quot;);
		fprintf(ss,&quot; request.open(&#039;GET&#039;,&#039;http://&#039; + hostname + &#039;:&#039; + 9000 + &#039;/version&#039;,true);\n&quot;);
		fprintf(ss,&quot; request.send();\n&quot;);
		fprintf(ss,&quot; var request2 = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot; request2.gix_inetd_addr = hostname;\n&quot;);
		fprintf(ss,&quot; request2.gix_inetd_port = 9887;\n&quot;);
		fprintf(ss,&quot; request2.onreadystatechange = scan_host_callback;\n&quot;);
		fprintf(ss,&quot; request2.open(&#039;GET&#039;,&#039;http://&#039; + hostname + &#039;:&#039; + 9887 + &#039;/version&#039;,true);\n&quot;);
		fprintf(ss,&quot; request2.send();\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function scan_host_callback(q){\n&quot;);
		fprintf(ss,&quot; var req = this;\n&quot;);
		fprintf(ss,&quot; if ( req.readyState != 4 ) return;\n&quot;);
		fprintf(ss,&quot; if ( req.status != 200 ) return;\n&quot;);
		fprintf(ss,&quot; if ( req.responseText.charAt(0) == &#039;O&#039; ){\n&quot;);
		fprintf(ss,&quot;  var info = JSON.parse(extract_bracket_val(req.responseText));\n&quot;);
		fprintf(ss,&quot;  for ( var idx = 0; idx &lt; hostlist.length; idx ++ ){\n&quot;);
		fprintf(ss,&quot;   if ( hostlist[idx].url == &#039;http://&#039; + req.gix_inetd_addr + &#039;:&#039; + req.gix_inetd_port ) break;\n&quot;);
		fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot;  if ( hostlist.length != 0 &amp;&amp;  idx != hostlist.length ) return;\n&quot;);
		fprintf(ss,&quot;  console.log(&#039;Adding [&#039; + req.gix_inetd_addr + &#039;:&#039; + req.gix_inetd_port + &#039;] Response: [&#039; + req.responseText + &#039;] Current hostlist-length: [&#039; + hostlist.length + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  hostlist[hostlist.length] = Object.create(hostentry);\n&quot;);
		fprintf(ss,&quot;  hostlist[hostlist.length-1].url = &#039;http://&#039; + req.gix_inetd_addr + &#039;:&#039; + req.gix_inetd_port;\n&quot;);
		fprintf(ss,&quot;  hostlist[hostlist.length-1].name = info.hostname;\n&quot;);
		fprintf(ss,&quot;  hostlist[hostlist.length-1].version = info.version;\n&quot;);
		fprintf(ss,&quot;  hostlist[hostlist.length-1].username = &#039;derDaniel&#039;;\n&quot;);
		fprintf(ss,&quot;  hostlist[hostlist.length-1].password = &#039;&#039;;\n&quot;);
		fprintf(ss,&quot;  hostlist[hostlist.length-1].remark = &#039;&#039;;\n&quot;);
		fprintf(ss,&quot;  hostlist[hostlist.length-1].active = true;\n&quot;);
		fprintf(ss,&quot;  update_hostlist();\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function start_scan(){\n&quot;);
		fprintf(ss,&quot; var start_digits = window.document.getElementById(&#039;IPSCAN_START&#039;).value.trim().split(&#039;.&#039;);\n&quot;);
		fprintf(ss,&quot; var end_digits = window.document.getElementById(&#039;IPSCAN_END&#039;).value.trim().split(&#039;.&#039;);\n&quot;);
		fprintf(ss,&quot; window.document.getElementById(&#039;IPSCAN_START&#039;).setAttribute(&#039;class&#039;,&#039;input2s&#039;);\n&quot;);
		fprintf(ss,&quot; window.document.getElementById(&#039;IPSCAN_END&#039;).setAttribute(&#039;class&#039;,&#039;input2s&#039;);\n&quot;);
		fprintf(ss,&quot; if ( start_digits.length != 4 ){ alert(&#039;Please enter valid Start-Address&#039;); window.document.getElementById(&#039;IPSCAN_START&#039;).setAttribute(&#039;class&#039;,&#039;input2serror&#039;); return;}\n&quot;);
		fprintf(ss,&quot; if ( end_digits.length != 4 ){ alert(&#039;Please enter valid End-Address&#039;); window.document.getElementById(&#039;IPSCAN_END&#039;).setAttribute(&#039;class&#039;,&#039;input2serror&#039;); return;}\n&quot;);
		fprintf(ss,&quot; console.log(&#039;START_DIGITS consists of [&#039; + start_digits.length + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot; console.log(&#039;END_DIGITS consists of [&#039; + end_digits.length + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot; for ( i = 0; i &lt; start_digits.length; i++ ){\n&quot;);
		fprintf(ss,&quot;  start_digits[i] = parseInt(start_digits[i]);\n&quot;);
		fprintf(ss,&quot;  if ( isNaN(start_digits[i]) ){ alert(&#039;Please enter valid Start-Address Error at: [&#039; + i + &#039;]&#039;); window.document.getElementById(&#039;IPSCAN_START&#039;).setAttribute(&#039;class&#039;,&#039;input2serror&#039;); return;}\n&quot;);
		fprintf(ss,&quot;  if ( start_digits[i] &lt; 0 || start_digits[i] &gt; 255 ){ alert(&#039;Please enter valid Start-Address Range-Error at: [&#039; + i + &#039;]&#039;); window.document.getElementById(&#039;IPSCAN_START&#039;).setAttribute(&#039;class&#039;,&#039;input2serror&#039;); return;}\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; for ( i = 0; i &lt; end_digits.length; i++ ){\n&quot;);
		fprintf(ss,&quot;  end_digits[i] = parseInt(end_digits[i]);\n&quot;);
		fprintf(ss,&quot;  if ( isNaN(end_digits[i]) ){ alert(&#039;Please enter valid End-Address Error at: [&#039; + i + &#039;]&#039;); window.document.getElementById(&#039;IPSCAN_END&#039;).setAttribute(&#039;class&#039;,&#039;input2serror&#039;); return;}\n&quot;);
		fprintf(ss,&quot;  if ( end_digits[i] &lt; 0 || end_digits[i] &gt; 255 ){ alert(&#039;Please enter valid End-Address Range-Error at: [&#039; + i + &#039;]&#039;); window.document.getElementById(&#039;IPSCAN_END&#039;).setAttribute(&#039;class&#039;,&#039;input2serror&#039;); return;}\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; var start_long = start_digits[0] * 256 * 256 * 256 + start_digits[1] * 256 * 256 +  start_digits[2] * 256  + start_digits[3];\n&quot;);
		fprintf(ss,&quot; var end_long = end_digits[0] * 256 * 256 * 256 + end_digits[1] * 256 * 256 +  end_digits[2] * 256  + end_digits[3];\n&quot;);
		fprintf(ss,&quot; console.log(&#039;Will scan [&#039; + ((end_long - start_long) + 1) + &#039;] Addesses&#039;);\n&quot;);
		fprintf(ss,&quot; for ( var addr = start_long; addr &lt;= end_long; addr++ ){\n&quot;);
		fprintf(ss,&quot;  var addr_c = addr;\n&quot;);
		fprintf(ss,&quot;  var a0 = Math.floor(addr_c / (256*256*256));\n&quot;);
		fprintf(ss,&quot;  addr_c = addr_c - a0 * (256*256*256);\n&quot;);
		fprintf(ss,&quot;  var a1 = Math.floor(addr_c / (256*256));\n&quot;);
		fprintf(ss,&quot;  addr_c = addr_c - a1 * (256*256);\n&quot;);
		fprintf(ss,&quot;  var a2 = Math.floor(addr_c / (256));\n&quot;);
		fprintf(ss,&quot;  addr_c = addr_c - a2 * (256);\n&quot;);
		fprintf(ss,&quot;  var a3 = addr_c;\n&quot;);
		// fprintf(ss,&quot;  console.log(&#039;Scanning: [&#039; + a0 + &#039;.&#039; + a1 + &#039;.&#039; + a2 + &#039;.&#039; + a3 + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  scan_ip(a0 + &#039;.&#039; + a1 + &#039;.&#039; + a2 + &#039;.&#039; + a3,&#039;9000&#039; );\n&quot;);
		fprintf(ss,&quot;  scan_ip(a0 + &#039;.&#039; + a1 + &#039;.&#039; + a2 + &#039;.&#039; + a3,&#039;9887&#039; );\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function scan_ip(addr,port){\n&quot;);
		fprintf(ss,&quot; console.log(&#039;Start of scan at: [&#039; + addr + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot; var request = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot; request.gix_inetd_addr = addr;\n&quot;);
		fprintf(ss,&quot; request.gix_inetd_port = port;\n&quot;);
		fprintf(ss,&quot; request.onreadystatechange = scan_ip_callback;\n&quot;);
		fprintf(ss,&quot; request.open(&#039;GET&#039;,&#039;http://&#039; + addr + &#039;:&#039; + port + &#039;/version&#039;,true);\n&quot;);
		fprintf(ss,&quot; request.send();\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function scan_ip_callback(q){\n&quot;);
		fprintf(ss,&quot; var req = this;\n&quot;);
		fprintf(ss,&quot; if ( req.readyState != 4 ) return;\n&quot;);
		fprintf(ss,&quot; if ( req.status != 200 ) return;\n&quot;);
		fprintf(ss,&quot; if ( req.responseText.charAt(0) == &#039;O&#039; ){\n&quot;);
		fprintf(ss,&quot;  var info = JSON.parse(extract_bracket_val(req.responseText));\n&quot;);
		fprintf(ss,&quot;  for ( var idx = 0; idx &lt; hostlist.length; idx ++ ){\n&quot;);
		fprintf(ss,&quot;   if ( hostlist[idx].url == &#039;http://&#039; + req.gix_inetd_addr + &#039;:&#039; + req.gix_inetd_port ) break;\n&quot;);
		fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot;  if ( hostlist.length != 0 &amp;&amp;  idx != hostlist.length ) return;\n&quot;);
		fprintf(ss,&quot;  console.log(&#039;Adding [&#039; + req.gix_inetd_addr + &#039;:&#039; + req.gix_inetd_port + &#039;] Response: [&#039; + req.responseText + &#039;] Current hostlist-length: [&#039; + hostlist.length + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  hostlist[hostlist.length] = Object.create(hostentry);\n&quot;);
		fprintf(ss,&quot;  hostlist[hostlist.length-1].url = &#039;http://&#039; + req.gix_inetd_addr + &#039;:&#039; + req.gix_inetd_port;\n&quot;);
		fprintf(ss,&quot;  hostlist[hostlist.length-1].name = info.hostname;\n&quot;);
		fprintf(ss,&quot;  hostlist[hostlist.length-1].version = info.version;\n&quot;);
		fprintf(ss,&quot;  hostlist[hostlist.length-1].username = &#039;derDaniel&#039;;\n&quot;);
		fprintf(ss,&quot;  hostlist[hostlist.length-1].password = &#039;&#039;;\n&quot;);
		fprintf(ss,&quot;  hostlist[hostlist.length-1].remark = &#039;&#039;;\n&quot;);
		fprintf(ss,&quot;  hostlist[hostlist.length-1].active = true;\n&quot;);
		fprintf(ss,&quot;  update_hostlist();\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;function update_end_field(){\n&quot;);
		fprintf(ss,&quot; var id_start = window.document.getElementById(&#039;IPSCAN_START&#039;);\n&quot;);
		fprintf(ss,&quot; var id_end   = window.document.getElementById(&#039;IPSCAN_END&#039;);\n&quot;);
		fprintf(ss,&quot; if ( id_end.value.length &lt; 1 )  id_end.value = id_start.value;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function extract_bracket_val(msg){\n&quot;);
		fprintf(ss,&quot;  var returner = &#039;&#039;;\n&quot;);
		fprintf(ss,&quot;  var n1 = msg.indexOf(&#039;[&#039;);\n&quot;);
		fprintf(ss,&quot;  n1++;\n&quot;);
		fprintf(ss,&quot;  var n2 = msg.lastIndexOf(&#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  returner = msg.substring(n1,n2);\n&quot;);
		fprintf(ss,&quot;  return(returner);\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; function extract_bracket_val2(msg,index){\n&quot;);
		fprintf(ss,&quot;  var xx = extract_bracket_val(msg);\n&quot;);
		fprintf(ss,&quot;  var i = 0;\n&quot;);
		fprintf(ss,&quot;  var idx = 0;\n&quot;);
		fprintf(ss,&quot;  while ( 1 ){\n&quot;);
		fprintf(ss,&quot;   var returner = &#039;&#039;;\n&quot;);
		fprintf(ss,&quot;   for ( ; i &lt; xx.length; i++ ){\n&quot;);
		fprintf(ss,&quot;    var j = 0;\n&quot;);
		fprintf(ss,&quot;    if ( xx.charAt(i) == &#039;,&#039; ){ i++; break;}\n&quot;);
		fprintf(ss,&quot;    returner = returner + xx.charAt(i);  \n&quot;);
		fprintf(ss,&quot;   }\n&quot;);
		fprintf(ss,&quot;   if ( idx &gt;= index ) return(returner);\n&quot;);
		fprintf(ss,&quot;   idx++;\n&quot;);
		fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot;  return(&#039;&#039;);\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot;\n&quot;);
		fprintf(ss,&quot; function extract_bracket_val3(msg,index){\n&quot;);
		fprintf(ss,&quot;  var xx = msg;\n&quot;);
		fprintf(ss,&quot;  var i = 0;\n&quot;);
		fprintf(ss,&quot;  var idx = 0;\n&quot;);
		fprintf(ss,&quot;  while ( 1 ){\n&quot;);
		fprintf(ss,&quot;   var returner = &#039;&#039;;\n&quot;);
		fprintf(ss,&quot;   for ( ; i &lt; xx.length; i++ ){\n&quot;);
		fprintf(ss,&quot;    var j = 0;\n&quot;);
		fprintf(ss,&quot;    if ( xx.charAt(i) == &#039;;&#039; ){ i++; break;}\n&quot;);
		fprintf(ss,&quot;    returner = returner + xx.charAt(i);  \n&quot;);
		fprintf(ss,&quot;   }\n&quot;);
		fprintf(ss,&quot;   if ( idx &gt;= index ) return(returner);\n&quot;);
		fprintf(ss,&quot;   idx++;\n&quot;);
		fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot;  return(&#039;&#039;);\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot;&lt;/SCRIPT&gt;\n&quot;);
	}
	
	if ( type_req == TYPE_HTML &amp;&amp; html_done == 0 ){
		int i;
		fprintf(ss,&quot;Content-Type: %s\r\n\r\n&quot;,HTML_MIME);
		fprintf(ss,&quot;&lt;HEAD&gt;&lt;meta CHARSET=\&quot;UTF-8\&quot;&gt;&lt;LINK REL=\&quot;stylesheet\&quot; TYPE=\&quot;text/css\&quot; HREF=\&quot;/style.css\&quot;&gt;&lt;/HEAD&gt;\n&quot;);
		fprintf(ss,&quot;&lt;BODY CLASS=&#039;mainbody&#039; onload=init_all()&gt;&quot;);
		fprintf(ss,&quot;&lt;DIV CLASS=&#039;headline&#039;&gt;&lt;TABLE BORDER=0 WIDTH=100%%&gt;&lt;TR&gt;&lt;TD ALIGN=LEFT WIDTH=33%%&gt;&lt;IMG CLASS=l_image onclick=go_supervisor() SRC=/gix_logo.png&gt;&lt;/TD&gt;&quot;);
		fprintf(ss,&quot;&lt;TD WIDTH=33%% VALIGN=TOP&gt;&lt;CENTER&gt;&lt;SPAN CLASS=headliner&gt;%s @ %s&lt;/SPAN&gt;&lt;/TD&gt;&quot;, GIX_INETD_VERSION,my_hostname);
		fprintf(ss,&quot;&lt;TD VALIGN=TOP&gt;&lt;INPUT TYPE=BUTTON CLASS=standard_button onclick=toggle_giga_refresh()  VALUE=&#039;Enable Auto-Refresh&#039; ID=REFRESH_GIGA_BUTTON&gt;&lt;SPAN ID=GIGA_ROTATOR&gt;&lt;IMG SRC=/empty.gif HEIGHT=32&gt;&lt;/SPAN&gt;&lt;/TD&gt;&quot;);
		fprintf(ss,&quot;&lt;TD VALIGN=TOP&gt;&lt;INPUT TYPE=BUTTON CLASS=standard_button onclick=reset_counters() VALUE=\&quot;Reset counters\&quot;&gt;&lt;/TD&gt;&quot;); 
		fprintf(ss,&quot;&lt;TD ALIGN=RIGHT WIDTH=33%%&gt;&lt;TABLE BORDER=0&gt;&lt;TR&gt;&lt;TD ALIGN=RIGHT&gt;You:&lt;/TD&gt;&lt;TD ALIGN=LEFT&gt;&lt;B&gt;%s&lt;/B&gt;&lt;/TD&gt;&lt;/TR&gt;&lt;TR&gt;&lt;TD ALIGN=RIGHT&gt;Me:&lt;/TD&gt;&lt;TD ALIGN=LEFT&gt;&lt;B&gt;%s&lt;/B&gt;&lt;/TD&gt;&lt;/TR&gt;&lt;/TABLE&gt;&lt;/TD&gt;&lt;/TR&gt;&lt;/TABLE&gt;&quot;, CCON.source, CCON.target);
		fprintf(ss,&quot;&lt;/DIV&gt;&quot;);

		fprintf(ss,&quot;&lt;SCRIPT LANGUAGE=JavaScript&gt;\n&quot;);
		fprintf(ss,&quot;function go_supervisor(){\n&quot;);
		fprintf(ss,&quot; location = &#039;/supervisor&#039;;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		fprintf(ss,&quot;&lt;/SCRIPT&gt;\n&quot;);

		fprintf(ss,&quot;&lt;DIV CLASS=footer&gt;&lt;CENTER&gt;(C) Ing. Andy Paumann, globedom Bulgaria&lt;/DIV&gt;&quot;);

		fprintf(ss,&quot;&lt;DIV ID=&#039;MAIN&#039; CLASS=mainscreen&gt;\n&quot;);
		fprintf(ss,&quot;&lt;CENTER&gt;&quot;);
		fprintf(ss,&quot;&lt;TABLE BORDER=0&gt;&quot;);
		fprintf(ss,&quot;&lt;TR&gt;&lt;TD VALIGN=TOP&gt;&quot;);
		fprintf(ss,&quot;&lt;CENTER&gt;&quot;);
		fprintf(ss,&quot;&lt;TABLE CELLSPACING=1 BORDER=0 BGCOLOR=black&gt;\n&quot;);
		fprintf(ss,&quot;&lt;TR&gt;&lt;TD BGCOLOR=white ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;Uptime(1 min)&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s ID=LOAD1&gt;&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;(5 min)&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s ID=LOAD5&gt;&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;(15 min)&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s ID=LOAD15&gt;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&quot;);
		fprintf(ss,&quot;&lt;TR&gt;&lt;TD BGCOLOR=white COLSPAN=6&gt;&lt;CENTER&gt;&lt;DIV ID=FSINFO&gt;&lt;/DIV&gt;&lt;/TD&gt;&lt;/TR&gt;\n&quot;);
		fprintf(ss,&quot;&lt;TR&gt;&lt;TD BGCOLOR=white ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;Uptime&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD COLSPAN=5 BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s ID=UPTIME&gt;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&quot;);
		fprintf(ss,&quot;&lt;TR&gt;&lt;TD BGCOLOR=white ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;Processes&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD COLSPAN=5 BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s ID=SYS_PROCS&gt;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&quot;);
		fprintf(ss,&quot;&lt;TR&gt;&lt;TD BGCOLOR=white ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;CPU-count&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD COLSPAN=5 BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s ID=CPU_COUNT&gt;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&quot;);
		fprintf(ss,&quot;&lt;TR&gt;&lt;TD BGCOLOR=white ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;CPU-Usage (sys + usr)&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD COLSPAN=5 BGCOLOR=white ALIGN=LEFT&gt;&lt;DIV ID=CPU_INFO&gt;&lt;/DIV&gt;&lt;/TD&gt;&lt;/TR&gt;&quot;);
		fprintf(ss,&quot;&lt;TR&gt;&lt;TD COLSPAN=6 BGCOLOR=black&gt;&lt;DIV ID=PROCINFO&gt;&lt;/DIV&gt;&lt;/TD&gt;&lt;/TR&gt;&quot;);
		fprintf(ss,&quot;&lt;/TABLE&gt;&quot;);
		// fprintf(ss,&quot;&lt;P&gt;&lt;INPUT TYPE=BUTTON CLASS=standard_button onclick=reset_counters() VALUE=\&quot;Reset counters\&quot;&gt;&amp;nbsp;&lt;SPAN ID=GIGA_ROTATOR&gt;&lt;IMG SRC=/empty.gif HEIGHT=32&gt;&lt;/SPAN&gt;&amp;nbsp;&lt;INPUT TYPE=BUTTON CLASS=standard_button onclick=toggle_giga_refresh()  VALUE=&#039;Enable Auto-Refresh&#039; ID=REFRESH_GIGA_BUTTON&gt;&lt;/P&gt;\n&quot;);
		fprintf(ss,&quot;&lt;/CENTER&gt;&quot;);
		fprintf(ss,&quot;&lt;/TD&gt;&lt;TD VALIGN=TOP ALIGN=LEFT&gt;&lt;CENTER&gt;&quot;);
		fprintf(ss,&quot;&lt;P&gt;&quot;);
		fprintf(ss,&quot;&lt;TABLE BORDER=0 CELLSPACING=1 BGCOLOR=black&gt;\n&quot;);
		fprintf(ss,&quot;&lt;TR&gt;&lt;TD BGCOLOR=white ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead1s&gt;Have own DNS:&quot;);
		if ( strlen(gix_options-&gt;have_own_dns)  ){
			fprintf(ss,&quot; &lt;B&gt;%s&lt;/B&gt;&lt;/SPAN&gt;&lt;/TD&gt;&quot;,gix_options-&gt;have_own_dns);
		} else {
			fprintf(ss,&quot; &lt;B&gt;NO&lt;/B&gt;&lt;/SPAN&gt;&lt;/TD&gt;&quot;);
		}
		fprintf(ss,&quot;&lt;TD COLSPAN=3 BGCOLOR=white ID=DNSRESULT&gt;&amp;nbsp;&lt;/TD&gt;&lt;/TR&gt;&quot;);
		fprintf(ss,&quot;&lt;TR&gt;&lt;TD BGCOLOR=white ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead1s&gt;DHCP-enabled:&lt;/SPAN&gt;&quot;);
		if ( gix_options-&gt;dhcp_enabled ){
			fprintf(ss,&quot;&lt;INPUT TYPE=CHECKBOX CHECKED ID=DHCP_ENABLED&gt;&quot;);
		} else {
			fprintf(ss,&quot;&lt;INPUT TYPE=CHECKBOX ID=DHCP_ENABLED&gt;&quot;);
		}
		fprintf(ss,&quot;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead1s&gt;Active IP Leases:&lt;/SPAN&gt;&quot;);
		fprintf(ss,&quot;&lt;SPAN CLASS=thead2slink ID=DHCP_IP_LEASES onclick=show_dhcp_ip_leases(4)&gt;&lt;/SPAN&gt;&lt;/TD&gt;&quot;);
		fprintf(ss,&quot;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead1s&gt;Active IPv6 Leases:&lt;/SPAN&gt;&quot;);
		fprintf(ss,&quot;&lt;SPAN CLASS=thead2slink ID=DHCP_IP6_LEASES onclick=show_dhcp_ip_leases(6)&gt;&lt;/SPAN&gt;&lt;/TD&gt;&quot;);
		fprintf(ss,&quot;&lt;TD BGCOLOR=white ALIGN=CENTER&gt;&lt;INPUT TYPE=BUTTON VALUE=&#039;Save DHCP settings&#039; onclick=save_dhcp_settings() CLASS=standard_buttons&gt;&lt;/TD&gt;&lt;/TR&gt;&quot;);

		fprintf(ss,&quot;&lt;TR&gt;&lt;TD BGCOLOR=white ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead1s&gt;TFTP-enabled:&lt;/SPAN&gt;&quot;);
		if ( gix_options-&gt;tftp_enabled ){
			fprintf(ss,&quot;&lt;INPUT TYPE=CHECKBOX CHECKED ID=TFTP_ENABLED&gt;&quot;);
		} else {
			fprintf(ss,&quot;&lt;INPUT TYPE=CHECKBOX ID=TFTP_ENABLED&gt;&quot;);
		}
		fprintf(ss,&quot;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead1s&gt;TFTP-readonly:&lt;/SPAN&gt;&quot;);
		if ( gix_options-&gt;tftp_readonly ){
			fprintf(ss,&quot;&lt;INPUT TYPE=CHECKBOX CHECKED ID=TFTP_READONLY&gt;&quot;);
		} else {
			fprintf(ss,&quot;&lt;INPUT TYPE=CHECKBOX ID=TFTP_READONLY&gt;&quot;);
		}
		fprintf(ss,&quot;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead1s&gt;TFTP-root:&lt;/SPAN&gt;&lt;INPUT ID=TFTP_ROOT TYPE=TEXT VALUE=&#039;%s&#039; CLASS=input2s&gt;&lt;/TD&gt;&quot;,gix_options-&gt;tftp_root);
		fprintf(ss,&quot;&lt;TD BGCOLOR=white ALIGN=CENTER&gt;&lt;INPUT TYPE=BUTTON VALUE=&#039;Save TFTP settings&#039; onclick=save_tftp_settings() CLASS=standard_buttons&gt;&lt;/TD&gt;&lt;/TR&gt;&quot;);
		fprintf(ss,&quot;&lt;TR&gt;&lt;TD BGCOLOR=white ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead1s&gt;Read-Requests processed:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN ID=TFTP_REQUESTS_READ CLASS=thead2s&gt;&lt;/SPAN&gt;&lt;/TD&gt;&quot;);
		fprintf(ss,&quot;&lt;TD BGCOLOR=white ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead1s&gt;Write-Requests processed:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN ID=TFTP_REQUESTS_WRITE CLASS=thead2s&gt;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&quot;);
		fprintf(ss,&quot;&lt;TR&gt;&lt;TD COLSPAN=4 BGCOLOR=white&gt;&lt;DIV ID=TFTP_LIST&gt;&lt;/DIV&gt;&lt;/TD&gt;&lt;/TR&gt;&quot;);
		fprintf(ss,&quot;&lt;/TABLE&gt;\n&quot;);
		fprintf(ss,&quot;&lt;/P&gt;&quot;);
		fprintf(ss,&quot;&lt;TABLE BORDER=0 CELLSPACING=1 BGCOLOR=black&gt;\n&quot;);
		fprintf(ss,&quot;&lt;TR&gt;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;Slot&lt;/SPAN&gt;&lt;/CENTER&gt;&lt;/TD&gt;&quot;);
		fprintf(ss,&quot;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;IP-Version&lt;/SPAN&gt;&lt;/CENTER&gt;&lt;/TD&gt;&quot;);
		fprintf(ss,&quot;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;IP-Port&lt;/SPAN&gt;&lt;/CENTER&gt;&lt;/TD&gt;&quot;);
		fprintf(ss,&quot;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;Command&lt;/SPAN&gt;&lt;/CENTER&gt;&lt;/TD&gt;&quot;);
		fprintf(ss,&quot;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;Max-Connections&lt;/SPAN&gt;&lt;/CENTER&gt;&lt;/TD&gt;&quot;);
		fprintf(ss,&quot;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;Total-Timeout (Seconds)&lt;/SPAN&gt;&lt;/CENTER&gt;&lt;/TD&gt;&quot;);
		fprintf(ss,&quot;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;Idle-Timeout (Seconds)&lt;/SPAN&gt;&lt;/CENTER&gt;&lt;/TD&gt;&quot;);
		fprintf(ss,&quot;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;Active connections&lt;/SPAN&gt;&lt;/CENTER&gt;&lt;/TD&gt;&quot;);
		fprintf(ss,&quot;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;Total connections&lt;/SPAN&gt;&lt;/CENTER&gt;&lt;/TD&gt;&quot;);
		fprintf(ss,&quot;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;Last reset (counters)&lt;/SPAN&gt;&lt;/CENTER&gt;&lt;/TD&gt;&quot;);
		fprintf(ss,&quot;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;Process ID&lt;/SPAN&gt;&lt;/CENTER&gt;&lt;/TD&gt;&quot;);
		fprintf(ss,&quot;&lt;/TR&gt;&quot;);
		for ( i = 0; i &lt; entries; i++ ){
			char *color;
			if ( i % 2 ){
				color = &quot;yellow&quot;;
			} else {
				color = &quot;lightblue&quot;;
			}
			fprintf(ss,&quot;&lt;TR&gt;&quot;);
			fprintf(ss,&quot;&lt;TD BGCOLOR=%s&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead2s&gt;%d&lt;/SPAN&gt;&lt;/TD&gt;&quot;,color,i);
			fprintf(ss,&quot;&lt;TD BGCOLOR=%s&gt;&lt;CENTER&gt;&quot;,color);
			fprintf(ss,&quot;&lt;SPAN CLASS=thead2s&gt;%s&lt;/SPAN&gt;&quot;, servlist[i].family == AF_INET6 ? &quot;IPv6&quot; : &quot;IPv4&quot;);
			fprintf(ss,&quot;&lt;/CENTER&gt;&lt;/TD&gt;&quot;);
			fprintf(ss,&quot;&lt;TD BGCOLOR=%s ALIGN=right&gt;&quot;,color);
			fprintf(ss,&quot;&lt;SPAN CLASS=thead2s&gt;%d&lt;/SPAN&gt;&quot;, servlist[i].port);
			fprintf(ss,&quot;&lt;/TD&gt;&quot;);
			if ( strncmp(servlist[i].cmdline,&quot;ADMIN&quot;,5) == 0 ){
				fprintf(ss,&quot;&lt;TD BGCOLOR=%s ALIGN=center&gt;&quot;,color);
				fprintf(ss,&quot;&lt;SPAN CLASS=thead30s onclick=conns_list(%d,-1)&gt;ADMIN&lt;/SPAN&gt;&quot;,i);
				fprintf(ss,&quot;&lt;/TD&gt;&quot;);
			} else {
				fprintf(ss,&quot;&lt;TD BGCOLOR=%s ALIGN=right&gt;&quot;,color);
				fprintf(ss,&quot;&lt;SPAN CLASS=thead20s onclick=conns_list(%d,-1)&gt;%s&lt;/SPAN&gt;&quot;,i, servlist[i].cmdline);
				fprintf(ss,&quot;&lt;/TD&gt;&quot;);
			}
			fprintf(ss,&quot;&lt;TD BGCOLOR=%s ALIGN=RIGHT&gt;&quot;,color);
			fprintf(ss,&quot;&lt;SPAN CLASS=thead2s&gt;%d&lt;/SPAN&gt;&quot;, servlist[i].max_conns);
			fprintf(ss,&quot;&lt;/TD&gt;&quot;);
			if ( servlist[i].timeout == -1 ){
				fprintf(ss,&quot;&lt;TD BGCOLOR=%s ALIGN=center&gt;&quot;,color);
				fprintf(ss,&quot;&lt;SPAN CLASS=thead30s&gt;No timeout&lt;/SPAN&gt;&quot;);
				fprintf(ss,&quot;&lt;/TD&gt;&quot;);
			} else {
				fprintf(ss,&quot;&lt;TD BGCOLOR=%s ALIGN=right&gt;&quot;,color);
				fprintf(ss,&quot;&lt;SPAN CLASS=thead2s&gt;%d&lt;/SPAN&gt;&quot;, servlist[i].timeout);
				fprintf(ss,&quot;&lt;/TD&gt;&quot;);
			}
			if ( servlist[i].data_timeout == -1 ){
				fprintf(ss,&quot;&lt;TD BGCOLOR=%s ALIGN=center&gt;&quot;,color);
				fprintf(ss,&quot;&lt;SPAN CLASS=thead30s&gt;No timeout&lt;/SPAN&gt;&quot;);
				fprintf(ss,&quot;&lt;/TD&gt;&quot;);
			} else {
				fprintf(ss,&quot;&lt;TD BGCOLOR=%s ALIGN=right&gt;&quot;,color);
				fprintf(ss,&quot;&lt;SPAN CLASS=thead2s&gt;%d&lt;/SPAN&gt;&quot;, servlist[i].data_timeout);
				fprintf(ss,&quot;&lt;/TD&gt;&quot;);
			}
			fprintf(ss,&quot;&lt;TD BGCOLOR=%s ALIGN=RIGHT&gt;&quot;,color);
			fprintf(ss,&quot;&lt;SPAN CLASS=thead2s ID=CONNECTIONS_%d&gt;&lt;/SPAN&gt;&quot;, i);
			fprintf(ss,&quot;&lt;/TD&gt;&quot;);
			fprintf(ss,&quot;&lt;TD BGCOLOR=%s ALIGN=RIGHT&gt;&quot;,color);
			fprintf(ss,&quot;&lt;SPAN CLASS=thead2s ID=TOTAL_COUNT_%d&gt;&lt;/SPAN&gt;&quot;, i);
			fprintf(ss,&quot;&lt;/TD&gt;&quot;);
			fprintf(ss,&quot;&lt;TD BGCOLOR=%s ALIGN=RIGHT&gt;&quot;,color);
			fprintf(ss,&quot;&lt;SPAN CLASS=thead2s ID=RESET_%d&gt;&lt;/SPAN&gt;&quot;, i);
			fprintf(ss,&quot;&lt;/TD&gt;&quot;);
			fprintf(ss,&quot;&lt;TD BGCOLOR=%s ALIGN=RIGHT&gt;&quot;,color);
			fprintf(ss,&quot;&lt;SPAN CLASS=thead2links ID=PID_%d onclick=show_proc_info(&#039;PID_%d&#039;)&gt;&lt;/SPAN&gt;&quot;, i,i);
			fprintf(ss,&quot;&lt;/TD&gt;&quot;);
			fprintf(ss,&quot;&lt;/TR&gt;&quot;);
		}
		fprintf(ss,&quot;&lt;/TABLE&gt;\n&quot;);
		fprintf(ss,&quot;&lt;P&gt;&quot;);
		fprintf(ss,&quot;&lt;DIV ID=ETHLIST CLASS=ethlist&gt;init&lt;/DIV&gt;&quot;);
		fprintf(ss,&quot;&lt;/P&gt;&quot;);
		fprintf(ss,&quot;&lt;/TD&gt;&lt;/TR&gt;&lt;/TABLE&gt;&quot;);
		fprintf(ss,&quot;&lt;/DIV&gt;\n&quot;);

		fprintf(ss,&quot;&lt;SCRIPT LANGUAGE=JavaScript&gt;\n&quot;);

		fprintf(ss,&quot;var megatimer = null;\n&quot;);
		fprintf(ss,&quot;var gigatimer = null;\n&quot;);
		fprintf(ss,&quot;var megatimer_active = false;\n&quot;);
		fprintf(ss,&quot;var gigatimer_active = false;\n&quot;);
		fprintf(ss,&quot;var gigatimer_stored = false;\n&quot;);
		fprintf(ss,&quot;var leth = null;\n&quot;);




		fprintf(ss,&quot;function show_proc_info(diver){\n&quot;);
		fprintf(ss,&quot; diver_id = document.getElementById(diver);\n&quot;);
		fprintf(ss,&quot; console.log(&#039;DIVER_ID: [&#039; + diver_id.innerHTML + &#039;] Text: [&#039; + diver_id.innerText + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot; var pid = parseInt(diver_id.innerHTML);\n&quot;);
		fprintf(ss,&quot; if ( isNaN(pid) || pid == 0 ) pid = parseInt(diver_id.innerText);\n&quot;);
		fprintf(ss,&quot; process_detail(pid);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function extract_bracket_val(msg){\n&quot;);
		fprintf(ss,&quot;  var returner = &#039;&#039;;\n&quot;);
		fprintf(ss,&quot;  var n1 = msg.indexOf(&#039;[&#039;);\n&quot;);
		fprintf(ss,&quot;  n1++;\n&quot;);
		fprintf(ss,&quot;  var n2 = msg.lastIndexOf(&#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  returner = msg.substring(n1,n2);\n&quot;);
		fprintf(ss,&quot;  return(returner);\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; function extract_bracket_val2(msg,index){\n&quot;);
		fprintf(ss,&quot;  var xx = extract_bracket_val(msg);\n&quot;);
		fprintf(ss,&quot;  var i = 0;\n&quot;);
		fprintf(ss,&quot;  var idx = 0;\n&quot;);
		fprintf(ss,&quot;  while ( 1 ){\n&quot;);
		fprintf(ss,&quot;   var returner = &#039;&#039;;\n&quot;);
		fprintf(ss,&quot;   for ( ; i &lt; xx.length; i++ ){\n&quot;);
		fprintf(ss,&quot;    var j = 0;\n&quot;);
		fprintf(ss,&quot;    if ( xx.charAt(i) == &#039;,&#039; ){ i++; break;}\n&quot;);
		fprintf(ss,&quot;    returner = returner + xx.charAt(i);  \n&quot;);
		fprintf(ss,&quot;   }\n&quot;);
		fprintf(ss,&quot;   if ( idx &gt;= index ) return(returner);\n&quot;);
		fprintf(ss,&quot;   idx++;\n&quot;);
		fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot;  return(&#039;&#039;);\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot;\n&quot;);
		fprintf(ss,&quot; function extract_bracket_val3(msg,index){\n&quot;);
		fprintf(ss,&quot;  var xx = msg;\n&quot;);
		fprintf(ss,&quot;  var i = 0;\n&quot;);
		fprintf(ss,&quot;  var idx = 0;\n&quot;);
		fprintf(ss,&quot;  while ( 1 ){\n&quot;);
		fprintf(ss,&quot;   var returner = &#039;&#039;;\n&quot;);
		fprintf(ss,&quot;   for ( ; i &lt; xx.length; i++ ){\n&quot;);
		fprintf(ss,&quot;    var j = 0;\n&quot;);
		fprintf(ss,&quot;    if ( xx.charAt(i) == &#039;;&#039; ){ i++; break;}\n&quot;);
		fprintf(ss,&quot;    returner = returner + xx.charAt(i);  \n&quot;);
		fprintf(ss,&quot;   }\n&quot;);
		fprintf(ss,&quot;   if ( idx &gt;= index ) return(returner);\n&quot;);
		fprintf(ss,&quot;   idx++;\n&quot;);
		fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot;  return(&#039;&#039;);\n&quot;);
		fprintf(ss,&quot; }\n&quot;);



		fprintf(ss,&quot;function reset_counters(){\n&quot;);
		fprintf(ss,&quot; console.log(&#039;Requesting RESET of counters!&#039;);\n&quot;);
		fprintf(ss,&quot; var request = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot; request.onreadystatechange = function() { reset_counters_callback(request); };\n&quot;);
		fprintf(ss,&quot; request.open(&#039;GET&#039;,&#039;/ajax/RESET/0&#039;,true);\n&quot;);
		fprintf(ss,&quot; request.send();\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function reset_counters_callback(req){\n&quot;);
		fprintf(ss,&quot; if ( req.readyState != 4 ) return;\n&quot;);
		fprintf(ss,&quot; if ( req.status != 200 ) return;\n&quot;);
		fprintf(ss,&quot; console.log(&#039;Callback for RESET -&gt; Response: [&#039; + req.responseText + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot; if ( req.responseText.charAt(0) != &#039;O&#039; ){\n&quot;);
		fprintf(ss,&quot;  alert(&#039;Could not reset&#039;);\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; if ( gigatimer_active == false ) update_connections();\n&quot;);
		fprintf(ss,&quot;}\n&quot;);




		fprintf(ss,&quot;function update_conns_display(inl){\n&quot;);
		fprintf(ss,&quot; for ( idx = 0; idx &lt; inl.length; idx++ ){\n&quot;);
		fprintf(ss,&quot;  var id = document.getElementById(&#039;CONNECTIONS_&#039; + idx);\n&quot;);
		fprintf(ss,&quot;  if ( id != undefined &amp;&amp; id != null ) id.innerHTML = inl[idx].connections;\n&quot;);
		fprintf(ss,&quot;  var id = document.getElementById(&#039;RESET_&#039; + idx);\n&quot;);
		fprintf(ss,&quot;  if ( id != undefined &amp;&amp; id != null ) id.innerHTML = inl[idx].reset;\n&quot;);
		fprintf(ss,&quot;  var id = document.getElementById(&#039;TOTAL_COUNT_&#039; + idx);\n&quot;);
		fprintf(ss,&quot;  if ( id != undefined &amp;&amp; id != null ) id.innerHTML = inl[idx].total_count;\n&quot;);
		fprintf(ss,&quot;  var id = document.getElementById(&#039;PID_&#039; + idx);\n&quot;);
		fprintf(ss,&quot;  if ( id != undefined &amp;&amp; id != null ) id.innerHTML = inl[idx].pid;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;function update_connections(){\n&quot;);
		fprintf(ss,&quot; document.getElementById(&#039;GIGA_ROTATOR&#039;).innerHTML = &#039;&lt;IMG SRC=/new_rotator_big.gif HEIGHT=32&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  if ( gigatimer != null ) clearInterval(gigatimer);\n&quot;);
		fprintf(ss,&quot;  var request = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot;  request.onreadystatechange = function() { update_connections_callback(request); };\n&quot;);
		fprintf(ss,&quot;  request.open(&#039;GET&#039;,&#039;/ajax/PROCLIST/0&#039; ,true);\n&quot;);
		fprintf(ss,&quot;  request.send();\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
		


		fprintf(ss,&quot;function display_proclist(proclist){\n&quot;);
		fprintf(ss,&quot; var cpu_count_id = document.getElementById(&#039;CPU_COUNT&#039;);\n&quot;);
		fprintf(ss,&quot; cpu_count_id.innerHTML = proclist.cpu_count;\n&quot;);

		fprintf(ss,&quot; var cpu_info_id = document.getElementById(&#039;CPU_INFO&#039;);\n&quot;);
		fprintf(ss,&quot; var result = &#039;&lt;TABLE CELLSPACING=1 BORDER=0 BGCOLOR=blue&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; for ( var idx = 0; idx &lt; proclist.cpu_count; idx++ ){\n&quot;);
		fprintf(ss,&quot;  if ( idx &amp;&amp; !(idx %% 4 )) result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  if (  !(idx %% 4 ) ) result += &#039;&lt;TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  if ( proclist.ul[idx].total &gt; 80.0 ){\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;&lt;B&gt;CPU-&#039; + idx + &#039;&lt;/B&gt;&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead1s&gt;&lt;B&gt;&#039; + proclist.ul[idx].total + &#039;%%&lt;/B&gt;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  } else {\n&quot;);
		fprintf(ss,&quot;   if ( proclist.ul[idx].total &gt; 50.0 ){\n&quot;);
		fprintf(ss,&quot;    result += &#039;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;&lt;B&gt;CPU-&#039; + idx + &#039;&lt;/B&gt;&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2sw&gt;&lt;B&gt;&#039; + proclist.ul[idx].total + &#039;%%&lt;/B&gt;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   } else {\n&quot;);
		fprintf(ss,&quot;    result += &#039;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;&lt;B&gt;CPU-&#039; + idx + &#039;&lt;/B&gt;&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + proclist.ul[idx].total + &#039;%%&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   }\n&quot;);
		fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;/TR&gt;&lt;/TABLE&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; cpu_info_id.innerHTML = result;\n&quot;);
		fprintf(ss,&quot; var div_id = document.getElementById(&#039;PROCINFO&#039;);\n&quot;);
		fprintf(ss,&quot; div_id.setAttribute(&#039;class&#039;,&#039;procinfo&#039;);\n&quot;);
		fprintf(ss,&quot; var result = &#039;&lt;TABLE CELLSPACING=1 BGCOLOR=black&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;PID&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;PPID&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;CPU&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;Trs.&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;Command&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;V-Size&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;RSS&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;Started&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;Load&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;Time&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; for ( var i = 0; i &lt; proclist.pl.length; i++ ){\n&quot;);
		fprintf(ss,&quot;  var color = &#039;lightblue&#039;;\n&quot;);
		fprintf(ss,&quot;  if ( i %% 2 ) color = &#039;yellow&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=RIGHT BGCOLOR=&#039; + color + &#039;&gt;&lt;SPAN CLASS=thead3s onclick=process_detail1(&#039; + proclist.pl[i].pid + &#039;)&gt;&#039; + proclist.pl[i].pid + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=RIGHT BGCOLOR=&#039; + color + &#039;&gt;&lt;SPAN CLASS=thead3s onclick=process_detail1(&#039; + proclist.pl[i].ppid + &#039;)&gt;&#039; + proclist.pl[i].ppid + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=RIGHT BGCOLOR=&#039; + color + &#039;&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + proclist.pl[i].cpu + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=RIGHT BGCOLOR=&#039; + color + &#039;&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + proclist.pl[i].num_threads + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		// fprintf(ss,&quot;  console.log(&#039;PID: [&#039; + proclist.pl[i].pid + &#039;] Slot: [&#039; + proclist.pl[i].slot + &#039;] Index: [&#039; + proclist.pl[i].index + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  if ( proclist.pl[i].slot &gt; -1 &amp;&amp; proclist.pl[i].index &gt; -1 ){\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD ALIGN=RIGHT BGCOLOR=&#039; + color + &#039;&gt;&lt;SPAN CLASS=thead3s onclick=conns_list1(&#039; + proclist.pl[i].slot + &#039;,&#039; + proclist.pl[i].index + &#039;)&gt;&#039; + proclist.pl[i].prg + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  } else {\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD ALIGN=RIGHT BGCOLOR=&#039; + color + &#039;&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + proclist.pl[i].prg + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=RIGHT BGCOLOR=&#039; + color + &#039;&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + proclist.pl[i].vmsize + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=RIGHT BGCOLOR=&#039; + color + &#039;&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + proclist.pl[i].rss + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=RIGHT BGCOLOR=&#039; + color + &#039;&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + proclist.pl[i].stime + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=RIGHT BGCOLOR=&#039; + color + &#039;&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + proclist.pl[i].cpu_usage + &#039;%%&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=RIGHT BGCOLOR=&#039; + color + &#039;&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + proclist.pl[i].ptime + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;/TABLE&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; div_id.innerHTML = result;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;rawdata_obj = {\n&quot;);
		fprintf(ss,&quot; name: &#039;&#039;,\n&quot;);
		fprintf(ss,&quot; timestamp: 0,\n&quot;);
		fprintf(ss,&quot; bytes_in: 0,\n&quot;);
		fprintf(ss,&quot; bytes_out: 0\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;ilist_obj = {\n&quot;);
		fprintf(ss,&quot; rawdata: null,\n&quot;);
		fprintf(ss,&quot; array_in: null,\n&quot;);
		fprintf(ss,&quot; array_out: null,\n&quot;);
		fprintf(ss,&quot; canvas_in: null,\n&quot;);
		fprintf(ss,&quot; canvas_out: null,\n&quot;);
		fprintf(ss,&quot; ifname: &#039;&#039;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;eth_obj = {\n&quot;);
		fprintf(ss,&quot; ilist: []\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;var colorarray = [ &#039;red&#039;, &#039;blue&#039;,&#039;green&#039; ];\n&quot;);

		fprintf(ss,&quot;GIXGraph = {\n&quot;);
		fprintf(ss,&quot; id: null,\n&quot;);
		fprintf(ss,&quot; color: &#039;blue&#039;,\n&quot;);
		fprintf(ss,&quot; bgcolor: &#039;black&#039;,\n&quot;);
		fprintf(ss,&quot; tcolor: &#039;green&#039;,\n&quot;);
		fprintf(ss,&quot; x_caption: &#039;&#039;,\n&quot;);
		fprintf(ss,&quot; y_caption: &#039;&#039;,\n&quot;);
		fprintf(ss,&quot; x_start_label: &#039;&#039;,\n&quot;);
		fprintf(ss,&quot; x_end_label: &#039;&#039;,\n&quot;);
		fprintf(ss,&quot; y_caption: &#039;&#039;,\n&quot;);
		fprintf(ss,&quot; headline: &#039;Head&#039;,\n&quot;);
		fprintf(ss,&quot; samples: &#039;&#039;,\n&quot;);
		fprintf(ss,&quot; canvas_width: 0,\n&quot;);
		fprintf(ss,&quot; canvas_height: 0,\n&quot;);
		fprintf(ss,&quot; canvas_offset_x: 1,\n&quot;);
		fprintf(ss,&quot; canvas_offset_y: 1,\n&quot;);
		fprintf(ss,&quot; script_size: 10,\n&quot;);
		fprintf(ss,&quot; ctx: null,\n&quot;);
		fprintf(ss,&quot; init: function(_id, _color,_bgcolor,_tcolor,_headline,_x_caption,_y_caption){\n&quot;); // _samples is an array of values with X and Y values 
		fprintf(ss,&quot;  if ( _id == undefined ) return(false);\n&quot;);
		fprintf(ss,&quot;  this.id = window.document.getElementById(_id);\n&quot;);
		fprintf(ss,&quot;  if ( this.id == undefined || this.id == null ) return false;\n&quot;);
		fprintf(ss,&quot;  this.canvas_width = parseInt(this.id.getBoundingClientRect().width) - this.canvas_offset_x * 2;\n&quot;);
		fprintf(ss,&quot;  this.canvas_height = parseInt(this.id.getBoundingClientRect().height) - this.canvas_offset_y * 2;\n&quot;);
		fprintf(ss,&quot;  console.log(&#039;CANVAS-SIZE: [&#039; + this.canvas_width + &#039; x &#039; + this.canvas_height + &#039;] BORDER: [&#039; + this.id.style.border + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  if ( _color != undefined ) this.color = _color;\n&quot;);
		fprintf(ss,&quot;  if ( _bgcolor != undefined ) this.bgcolor = _bgcolor;\n&quot;);
		fprintf(ss,&quot;  if ( _tcolor != undefined ) this.tcolor = _tcolor;\n&quot;);
		fprintf(ss,&quot;  if ( _headline != undefined ) this.headline = _headline;\n&quot;);
		fprintf(ss,&quot;  if ( _x_caption != undefined ) this.x_caption = _x_caption;\n&quot;);
		fprintf(ss,&quot;  if ( _y_caption != undefined ) this.y_caption = _y_caption;\n&quot;);
		fprintf(ss,&quot;  if ( (this.ctx = this.id.getContext(\&quot;2d\&quot;)) == undefined || this.ctx == null ) return false;\n&quot;);
		fprintf(ss,&quot;  return true;\n&quot;);
		fprintf(ss,&quot; },\n&quot;);
		fprintf(ss,&quot; draw_graph: function(_samples,_x_start_label,_x_end_label){\n&quot;);
		fprintf(ss,&quot;  this.ctx.clearRect(0,0,this.id.width, this.id.height);\n&quot;);
		fprintf(ss,&quot;  if ( _x_start_label != undefined ) this.x_start_label = _x_start_label;\n&quot;);
		fprintf(ss,&quot;  if ( _x_end_label != undefined ) this.x_end_label = _x_end_label;\n&quot;);
		fprintf(ss,&quot;  this.samples = _samples;\n&quot;);
		fprintf(ss,&quot;  if ( this.samples.length &lt; 1 ) return;\n&quot;);
		fprintf(ss,&quot;  var draw_width = this.canvas_width - 2 * this.canvas_offset_x;\n&quot;);
		fprintf(ss,&quot;  var draw_height = this.canvas_height - (2 * this.canvas_offset_y + this.script_size + 2);\n&quot;);
		fprintf(ss,&quot;  var max = this.samples[0];\n&quot;);
		fprintf(ss,&quot;  var min = this.samples[0];\n&quot;);
		fprintf(ss,&quot;  var sum = 0.0;\n&quot;);
		fprintf(ss,&quot;  for ( idx = 0; idx &lt; this.samples.length; idx++ ){\n&quot;);
		fprintf(ss,&quot;   if ( this.samples[idx] &gt; max ) max = this.samples[idx];\n&quot;);
		fprintf(ss,&quot;   if ( this.samples[idx] &lt; min ) min = this.samples[idx];\n&quot;);
		fprintf(ss,&quot;   sum += this.samples[idx];\n&quot;);
		fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot;  var min_word = this.roundup(min) + &#039; &#039; + this.y_caption;\n&quot;);
		fprintf(ss,&quot;  if ( min &gt; 1024 ) min_word = this.roundup(min/1024) + &#039; k&#039; +  this.y_caption;\n&quot;);
		fprintf(ss,&quot;  if ( min &gt; (1024*1024) ) min_word = this.roundup(min/(1024*1024)) + &#039; M&#039; +  this.y_caption;\n&quot;);
		fprintf(ss,&quot;  if ( min &gt; (1024*1024*1024) ) min_word = this.roundup(min/(1024*1024*1024)) + &#039; G&#039; +  this.y_caption;\n&quot;);
		fprintf(ss,&quot;  if ( min &gt; (1024*1024*1024*1024) ) min_word = this.roundup(min/(1024*1024*1024*1024)) + &#039; T&#039; +  this.y_caption;\n&quot;);
		fprintf(ss,&quot;  var max_word = this.roundup(max) + &#039; &#039; + this.y_caption;\n&quot;);
		fprintf(ss,&quot;  if ( max &gt; 1024 ) max_word = this.roundup(max/1024) + &#039; k&#039; +  this.y_caption;\n&quot;);
		fprintf(ss,&quot;  if ( max &gt; (1024*1024) ) max_word = this.roundup(max/(1024*1024)) + &#039; M&#039; +  this.y_caption;\n&quot;);
		fprintf(ss,&quot;  if ( max &gt; (1024*1024*1024) ) max_word = this.roundup(max/(1024*1024*1024)) + &#039; G&#039; +  this.y_caption;\n&quot;);
		fprintf(ss,&quot;  if ( max &gt; (1024*1024*1024*1024) ) max_word = this.roundup(max/(1024*1024*1024*1024)) + &#039; T&#039;  + this.y_caption;\n&quot;);
		fprintf(ss,&quot;  var y_factor = draw_height / (max - min);\n&quot;);
		fprintf(ss,&quot;  var x_factor = draw_width / this.samples.length;\n&quot;);
		fprintf(ss,&quot;  console.log(&#039;Min-Value: [&#039; + min + &#039;] Max: [&#039; + max + &#039;] Sum: [&#039; + sum + &#039;] Y-Factor: [&#039; + y_factor + &#039;] X-Factor: [&#039; + x_factor + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  for ( var idx = 0; idx &lt; this.samples.length; idx++ ){\n&quot;);
		fprintf(ss,&quot;   var sample_value = this.samples[idx] - min;\n&quot;);
		fprintf(ss,&quot;   var draw_height = sample_value * y_factor;\n&quot;);
		fprintf(ss,&quot;   var x_start = idx * x_factor + this.canvas_offset_x;\n&quot;);
		fprintf(ss,&quot;   var x_end = x_factor;\n&quot;);
		fprintf(ss,&quot;   var y_start = this.canvas_height - (this.canvas_offset_y +  this.canvas_offset_y + this.script_size + 2);\n&quot;);
		fprintf(ss,&quot;   var y_end   =  draw_height  * (-1) ;\n&quot;);
		fprintf(ss,&quot;   if ( y_end &gt;= 0 ) y_end = -1;\n&quot;);
		fprintf(ss,&quot;   var color = colorarray[idx %% colorarray.length];\n&quot;);
		// fprintf(ss,&quot;   console.log(&#039;VALUE[&#039; + idx  + &#039;]: [&#039; + sample_value + &#039;] X_START: [&#039; + x_start + &#039;] X_END: [&#039; + x_end + &#039;] Draw_HEIGHT: [&#039;  + draw_height + &#039;] Y_START: [&#039; + y_start + &#039;] Y_END: [&#039; + y_end + &#039;] COLOR: [&#039; + color + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;   this.ctx.fillStyle = this.color;\n&quot;);
		fprintf(ss,&quot;   this.ctx.fillRect(x_start,y_start,x_end,y_end);\n&quot;);
		fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot;  this.ctx.font = this.script_size + &#039;px monospace&#039;;\n&quot;);
		fprintf(ss,&quot;  this.ctx.strokeStyle =  this.tcolor;\n&quot;);
		fprintf(ss,&quot;  this.ctx.strokeText(max_word,this.canvas_offset_x ,this.script_size + 2);\n&quot;);
		fprintf(ss,&quot;  this.ctx.strokeText(min_word,this.canvas_offset_x ,this.canvas_height - (this.canvas_offset_y +  this.canvas_offset_y + this.script_size + 6));\n&quot;);
		fprintf(ss,&quot;  this.ctx.strokeText(this.headline,this.canvas_width / 2 ,this.script_size + 2);\n&quot;);
		fprintf(ss,&quot;  this.ctx.strokeText(this.x_start_label,this.canvas_offset_x,this.canvas_height - this.canvas_offset_y -1);\n&quot;); 
		fprintf(ss,&quot;  this.ctx.strokeText(this.x_end_label,this.canvas_width - ( this.canvas_offset_x + (this.script_size - 3) * this.x_end_label.length),this.canvas_height - this.canvas_offset_y - 1);\n&quot;); 
		fprintf(ss,&quot; },\n&quot;);
		fprintf(ss,&quot; roundup: function(x){\n&quot;);
		fprintf(ss,&quot;  return(Math.round(x*100)/100);\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;var testarray = [ 10,2048,1230,1350,14,-40,12,1234,900,1299 ];\n&quot;);	
		

		fprintf(ss,&quot;function display_int_info(ethlist){\n&quot;);
		fprintf(ss,&quot; console.log(&#039;ETHLIST-LEN: [&#039;  + ethlist.length + &#039;] ETH-Length: [&#039; + leth.ilist.length + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot; for ( var j = 0; j &lt; ethlist.length; j++ ){\n&quot;);
		fprintf(ss,&quot;  console.log(&#039;ETHLIST-Index: [&#039; + j + &#039;] Name: [&#039;  + ethlist[j].ifname + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  for ( var i = 0; i &lt; leth.ilist.length; i++ ){\n&quot;);
		fprintf(ss,&quot;   if ( leth.ilist[i].ifname == ethlist[j].ifname ){\n&quot;);
		fprintf(ss,&quot;    var rawdata_len = leth.ilist[i].rawdata.length;\n&quot;);
		fprintf(ss,&quot;    console.log(&#039;[&#039; + j + &#039;] Updating [&#039; + i + &#039;] NAME: [&#039; + leth.ilist[i].ifname + &#039;] Size currently: [&#039; + rawdata_len + &#039;] Name: [&#039; + leth.ilist[i].rawdata[0].name + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;    leth.ilist[i].rawdata[rawdata_len] = Object.create(rawdata_obj);\n&quot;);
		fprintf(ss,&quot;    leth.ilist[i].rawdata[rawdata_len].timestamp = ethlist[j].timestamp;\n&quot;);
		fprintf(ss,&quot;    leth.ilist[i].rawdata[rawdata_len].bytes_in = ethlist[j].bytes_in;\n&quot;);
		fprintf(ss,&quot;    leth.ilist[i].rawdata[rawdata_len].bytes_out = ethlist[j].bytes_out;\n&quot;);
		fprintf(ss,&quot;    var canvas_array_length = leth.ilist[i].array_in.length;\n&quot;);
		fprintf(ss,&quot;    leth.ilist[i].array_in[canvas_array_length] = (leth.ilist[i].rawdata[rawdata_len].bytes_in - leth.ilist[i].rawdata[rawdata_len-1].bytes_in) / (leth.ilist[i].rawdata[rawdata_len].timestamp - leth.ilist[i].rawdata[rawdata_len-1].timestamp);\n&quot;);
		fprintf(ss,&quot;    leth.ilist[i].array_out[canvas_array_length] = (leth.ilist[i].rawdata[rawdata_len].bytes_out - leth.ilist[i].rawdata[rawdata_len-1].bytes_out) / (leth.ilist[i].rawdata[rawdata_len].timestamp - leth.ilist[i].rawdata[rawdata_len-1].timestamp);\n&quot;);
		fprintf(ss,&quot;    var date = new Date(parseInt(leth.ilist[i].rawdata[0].timestamp * 1000));\n&quot;);
		fprintf(ss,&quot;    var hours = &#039;0&#039; + date.getHours();\n&quot;);
		fprintf(ss,&quot;    var mins = &#039;0&#039; + date.getMinutes();\n&quot;);
		fprintf(ss,&quot;    var secs = &#039;0&#039; + date.getSeconds();\n&quot;);
		fprintf(ss,&quot;    var start_date = hours.substr(-2) + &#039;:&#039; + mins.substr(-2) + &#039;:&#039; + secs.substr(-2);\n&quot;);
		fprintf(ss,&quot;    var date = new Date(parseInt(leth.ilist[i].rawdata[rawdata_len].timestamp * 1000));\n&quot;);
		fprintf(ss,&quot;    hours = &#039;0&#039; + date.getHours();\n&quot;);
		fprintf(ss,&quot;    mins = &#039;0&#039; + date.getMinutes();\n&quot;);
		fprintf(ss,&quot;    secs = &#039;0&#039; + date.getSeconds();\n&quot;);
		fprintf(ss,&quot;    var end_date = hours.substr(-2) + &#039;:&#039; + mins.substr(-2) + &#039;:&#039; + secs.substr(-2);\n&quot;);
		fprintf(ss,&quot;    leth.ilist[i].canvas_in.draw_graph(leth.ilist[i].array_in,start_date,end_date);\n&quot;);
		fprintf(ss,&quot;    leth.ilist[i].canvas_out.draw_graph(leth.ilist[i].array_out,start_date,end_date);\n&quot;);
		fprintf(ss,&quot;    console.log(&#039;Updated [&#039; + i + &#039;] NAME: [&#039; + leth.ilist[i].ifname + &#039;] Size currently: [&#039; + leth.ilist[i].rawdata.length + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;    break;\n&quot;);
		fprintf(ss,&quot;   }\n&quot;);
		fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot;  console.log(&#039;[&#039; + j + &#039;] ILIST-INDEX: [&#039; + i + &#039;/&#039; + leth.ilist.length + &#039;] ETHLIST-INDEX: [&#039; + j + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  if ( i == leth.ilist.length ){\n&quot;);
		fprintf(ss,&quot;   var ilist_length = leth.ilist.length;\n&quot;);
		fprintf(ss,&quot;   console.log(&#039;Creating object [&#039; + ilist_length + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;   leth.ilist[ilist_length] = Object.create(ilist_obj);\n&quot;);
		fprintf(ss,&quot;   leth.ilist[ilist_length].ifname = ethlist[j].ifname;\n&quot;);
		fprintf(ss,&quot;   leth.ilist[ilist_length].array_in  = [];\n&quot;);
		fprintf(ss,&quot;   leth.ilist[ilist_length].array_out = [];\n&quot;);
		fprintf(ss,&quot;   leth.ilist[ilist_length].rawdata   = [];\n&quot;);
		fprintf(ss,&quot;   leth.ilist[ilist_length].rawdata[0] = Object.create(rawdata_obj);\n&quot;);
		fprintf(ss,&quot;   leth.ilist[ilist_length].rawdata[0].name = ethlist[j].ifname;\n&quot;);
		fprintf(ss,&quot;   leth.ilist[ilist_length].rawdata[0].timestamp = ethlist[j].timestamp;\n&quot;);
		fprintf(ss,&quot;   leth.ilist[ilist_length].rawdata[0].bytes_in = ethlist[j].bytes_in;\n&quot;);
		fprintf(ss,&quot;   leth.ilist[ilist_length].rawdata[0].bytes_out = ethlist[j].bytes_out;\n&quot;);
		fprintf(ss,&quot;   leth.ilist[ilist_length].canvas_in = Object.create(GIXGraph);\n&quot;);
		fprintf(ss,&quot;   leth.ilist[ilist_length].canvas_out = Object.create(GIXGraph);\n&quot;);
		fprintf(ss,&quot;   console.log(&#039;Created object [&#039; + ilist_length + &#039;] Name: [&#039; + leth.ilist[ilist_length].ifname + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; for ( var i = 0; i &lt; leth.ilist.length; i++ ){\n&quot;);
		fprintf(ss,&quot;   console.log(&#039;Final object [&#039; + i + &#039;] Name: [&#039; + leth.ilist[i].ifname + &#039;] Raw-Data[0] [&#039; + leth.ilist[i].rawdata[0].name + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; var divvy = document.getElementById(&#039;ETHLIST&#039;);\n&quot;);
		fprintf(ss,&quot; console.log(&#039;Processing ETH-Display for &#039; + ethlist.length + &#039; Interfaces&#039;);\n&quot;);
		fprintf(ss,&quot; if ( divvy.innerHTML == &#039;init&#039; ){\n&quot;);
		fprintf(ss,&quot;  console.log(&#039;Initializing ETH-Display&#039;);\n&quot;);
		fprintf(ss,&quot;  var result = &#039;&lt;TABLE CELLSPACING=1 BORDER=0 BGCOLOR=black&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TR&gt;&lt;TD BGCOLOR=white COLSPAN=4&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;&lt;B&gt;Network-Interfaces&lt;/B&gt;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TR&gt;&lt;TD BGCOLOR=white COLSPAN=2&gt;&lt;SPAN CLASS=thead2&gt;Total Samples:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD COLSPAN=2 BGCOLOR=white&gt;&lt;SPAN CLASS=thead2 ID=TOTAL_SAMPLES&gt;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  for ( var x = 0; x &lt; ethlist.length; x++ ){\n&quot;);
		fprintf(ss,&quot;   var color = &#039;yellow&#039;;\n&quot;);
		fprintf(ss,&quot;   if ( x %% 2 ) color = &#039;lightblue&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ROWSPAN=11 VALIGN=TOP&gt;&lt;SPAN CLASS=thead2&gt;&lt;B&gt;&#039; + ethlist[x].ifname + &#039;&lt;/B&gt;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead1s&gt;Bytes in:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD ALIGN=RIGHT BGCOLOR=&#039; + color + &#039;&gt;&lt;SPAN CLASS=thead2s ID=BYTES_SEC_IN_&#039; + x + &#039;&gt;&#039; + ethlist[x].bytes_in_sec + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ROWSPAN=11&gt;&lt;CANVAS WIDTH=500 HEIGHT=100 ID=C_RECEIVE_&#039; + x + &#039; CLASS=gcanvas1&gt;&lt;/CANVAS&gt;&lt;BR&gt;&lt;CANVAS  WIDTH=500 HEIGHT=100 CLASS=gcanvas1 ID=C_TRANSMIT_&#039; + x + &#039;&gt;&lt;/CANVAS&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead1s&gt;Bytes out:&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s ID=BYTES_SEC_OUT_&#039; + x + &#039;&gt;&#039; + ethlist[x].bytes_out_sec + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead1s&gt;Total Bytes in:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s ID=BYTES_IN_T_&#039; + x + &#039;&gt;&#039; + ethlist[x].bytes_in_t + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead1s&gt;Total Bytes out:&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s ID=BYTES_OUT_T_&#039; + x + &#039;&gt;&#039; + ethlist[x].bytes_out_t + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead1s&gt;Packets in:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD ALIGN=RIGHT BGCOLOR=&#039; + color + &#039;&gt;&lt;SPAN CLASS=thead2s ID=PACKETS_SEC_IN_&#039; + x + &#039;&gt;&#039; + ethlist[x].packets_in_sec + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD ALIGN=RIGHT BGCOLOR=&#039; + color + &#039;&gt;&lt;SPAN CLASS=thead1s&gt;Packets out:&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD ALIGN=RIGHT BGCOLOR=&#039; + color + &#039;&gt;&lt;SPAN CLASS=thead2s ID=PACKETS_SEC_OUT_&#039; + x + &#039;&gt;&#039; + ethlist[x].packets_out_sec + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead1s&gt;Total Packets in:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s ID=PACKETS_IN_T_&#039; + x + &#039;&gt;&#039; + ethlist[x].packets_in_t + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead1s&gt;Total Packets out:&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s ID=PACKETS_OUT_T_&#039; + x + &#039;&gt;&#039; + ethlist[x].packets_out_t + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead1s&gt;MAC-Address&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + ethlist[x].mac_addr + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead1s&gt;IPv4&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + ethlist[x].ipv4_addr + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead1s&gt;IPv6&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD ALIGN=RIGHT BGCOLOR=&#039; + color + &#039;&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + ethlist[x].ipv6_addr + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;/TABLE&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  divvy.innerHTML = result;\n&quot;);
		fprintf(ss,&quot;  var id = document.getElementById(&#039;TOTAL_SAMPLES&#039;);\n&quot;);
		fprintf(ss,&quot;  console.log(&#039;Total Samples: [&#039; + leth.ilist[0].rawdata.length + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  if ( id != undefined ) id.innerHTML = leth.ilist[0].rawdata.length;\n&quot;);
		fprintf(ss,&quot;  for ( var idx = 0; idx &lt; leth.ilist.length; idx++ ){\n&quot;);
		fprintf(ss,&quot;   leth.ilist[idx].canvas_in.init(&#039;C_RECEIVE_&#039; + idx, &#039;green&#039;,&#039;red&#039;,&#039;black&#039;,&#039;Bytes in&#039;,&#039;&#039;,&#039;Bytes/s&#039;);\n&quot;);
		fprintf(ss,&quot;   leth.ilist[idx].canvas_out.init(&#039;C_TRANSMIT_&#039; + idx, &#039;green&#039;,&#039;red&#039;,&#039;black&#039;,&#039;Bytes out&#039;,&#039;&#039;,&#039;Bytes/s&#039;);\n&quot;);
		fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot; } else {\n&quot;); // Just update
		fprintf(ss,&quot;  console.log(&#039;Total Samples: [&#039; + leth.ilist[0].rawdata.length + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  var id = document.getElementById(&#039;TOTAL_SAMPLES&#039;);\n&quot;);
		fprintf(ss,&quot;  if ( id != undefined ) id.innerHTML = leth.ilist[0].rawdata.length;\n&quot;);
		fprintf(ss,&quot;  for ( var x = 0; x &lt; ethlist.length; x++ ){\n&quot;);
		fprintf(ss,&quot;   var id = document.getElementById(&#039;BYTES_SEC_IN_&#039; + x);\n&quot;);
		fprintf(ss,&quot;   if ( id != undefined ) id.innerHTML = ethlist[x].bytes_in_sec;\n&quot;);
		fprintf(ss,&quot;   var id = document.getElementById(&#039;BYTES_SEC_OUT_&#039; + x);\n&quot;);
		fprintf(ss,&quot;   if ( id != undefined ) id.innerHTML = ethlist[x].bytes_out_sec;\n&quot;);
		fprintf(ss,&quot;   var id = document.getElementById(&#039;PACKETS_SEC_IN_&#039; + x);\n&quot;);
		fprintf(ss,&quot;   if ( id != undefined ) id.innerHTML = ethlist[x].packets_in_sec;\n&quot;);
		fprintf(ss,&quot;   var id = document.getElementById(&#039;PACKETS_SEC_OUT_&#039; + x);\n&quot;);
		fprintf(ss,&quot;   if ( id != undefined ) id.innerHTML = ethlist[x].packets_out_sec;\n&quot;);
		fprintf(ss,&quot;   var id = document.getElementById(&#039;BYTES_IN_T_&#039; + x);\n&quot;);
		fprintf(ss,&quot;   if ( id != undefined ) id.innerHTML = ethlist[x].bytes_in_t;\n&quot;);
		fprintf(ss,&quot;   var id = document.getElementById(&#039;BYTES_OUT_T_&#039; + x);\n&quot;);
		fprintf(ss,&quot;   if ( id != undefined ) id.innerHTML = ethlist[x].bytes_out_t;\n&quot;);
		fprintf(ss,&quot;   var id = document.getElementById(&#039;PACKETS_IN_T_&#039; + x);\n&quot;);
		fprintf(ss,&quot;   if ( id != undefined ) id.innerHTML = ethlist[x].packets_in_t;\n&quot;);
		fprintf(ss,&quot;   var id = document.getElementById(&#039;PACKETS_OUT_T_&#039; + x);\n&quot;);
		fprintf(ss,&quot;   if ( id != undefined ) id.innerHTML = ethlist[x].packets_out_t;\n&quot;);
		fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;function display_fs_info(fsinfo){\n&quot;);
		fprintf(ss,&quot; console.log(&#039;Displaying info for [&#039; + fsinfo.length + &#039;] Filesystems&#039;);\n&quot;);
		fprintf(ss,&quot; var id = document.getElementById(&#039;FSINFO&#039;);\n&quot;);
		fprintf(ss,&quot; var result = &#039;&lt;TABLE CELLSPACING=1 BORDER=0 BGCOLOR=black&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;Device&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;Path&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;Total Size&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;Avail Size&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;Used Size(%%)&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;Total Inodes&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;Free Inodes&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;Used Inodes(%%)&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; for ( var i = 0; i &lt; fsinfo.length; i++ ){\n&quot;);
		fprintf(ss,&quot;  var color = &#039;lightblue&#039;;\n&quot;);
		fprintf(ss,&quot;  if ( i %% 2 ) color = &#039;yellow&#039;;\n&quot;);
		fprintf(ss,&quot;  var b_percent_size = Math.round((100.0 - (fsinfo[i].b_avail * 100) / fsinfo[i].b_total)*100)/100;\n&quot;);
		fprintf(ss,&quot;  var i_percent_size = Math.round((100.0 - (fsinfo[i].i_free * 100) / fsinfo[i].i_total)*100)/100;\n&quot;);
		fprintf(ss,&quot;  console.log(&#039;PATH: [&#039; + fsinfo[i].path	 + &#039;] Percent Blocks: [&#039; + b_percent_size + &#039;] Percent Inodes: [&#039; + i_percent_size + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  var bgcolor = color;\n&quot;);
		fprintf(ss,&quot;  var bolder = &#039;&#039;;\n&quot;);
		fprintf(ss,&quot;  var endbolder = &#039;&#039;;\n&quot;);
		fprintf(ss,&quot;  if ( b_percent_size &gt; 65 || i_percent_size &gt; 60 ){ bolder = &#039;&lt;B&gt;&#039;; endbolder = &#039;&lt;/B&gt;&#039;; bgcolor = &#039;orange&#039;; }\n&quot;);
		fprintf(ss,&quot;  if ( b_percent_size &gt; 90 || i_percent_size &gt; 95 ){ bolder = &#039;&lt;B&gt;&#039;; endbolder = &#039;&lt;/B&gt;&#039;; bgcolor = &#039;red&#039;; }\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=LEFT BGCOLOR=&#039; + bgcolor + &#039;&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + bolder + &#039;/dev/&#039; + fsinfo[i].dev_name + endbolder + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=LEFT BGCOLOR=&#039; + bgcolor + &#039;&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + bolder + fsinfo[i].path + endbolder + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=LEFT BGCOLOR=&#039; + bgcolor + &#039;&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + bolder + fsinfo[i].b_total_t + endbolder + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=LEFT BGCOLOR=&#039; + bgcolor + &#039;&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + bolder + fsinfo[i].b_avail_t + endbolder + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=LEFT BGCOLOR=&#039; + bgcolor + &#039;&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + bolder + b_percent_size + &#039;%%&#039; + endbolder + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=LEFT BGCOLOR=&#039; + bgcolor + &#039;&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + bolder + fsinfo[i].i_free_t + endbolder + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=LEFT BGCOLOR=&#039; + bgcolor + &#039;&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + bolder + fsinfo[i].i_free_t + endbolder + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=LEFT BGCOLOR=&#039; + bgcolor + &#039;&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + bolder + i_percent_size + &#039;%%&#039; + endbolder + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;/TABLE&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; id.innerHTML = result;\n&quot;);	
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;function update_connections_callback(req){\n&quot;);
		fprintf(ss,&quot; if ( req.readyState != 4 ) return;\n&quot;);
		fprintf(ss,&quot; if ( req.status != 200 ) return;\n&quot;);
		fprintf(ss,&quot; if ( req.responseText.charAt(0) == &#039;O&#039; ){\n&quot;);
		fprintf(ss,&quot;  console.log(&#039;JSON-REPLY: &#039; + req.responseText);\n&quot;);
		fprintf(ss,&quot;  var proclist = JSON.parse(extract_bracket_val(req.responseText));\n&quot;);
		fprintf(ss,&quot;  display_proclist(proclist);\n&quot;); 
		fprintf(ss,&quot;  display_int_info(proclist.eth);\n&quot;);
		fprintf(ss,&quot;  display_fs_info(proclist.fs);\n&quot;);
		fprintf(ss,&quot;  console.log(&#039;DNSCHECK.ACTIVE: [&#039; + proclist.dnscheck.active + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  if ( proclist.dnscheck.active == true ){\n&quot;);
		fprintf(ss,&quot;   var result = &#039;&#039;;\n&quot;);
		fprintf(ss,&quot;   if ( proclist.dnscheck.success == true ){\n&quot;);
		fprintf(ss,&quot;    result += &#039;&lt;SPAN CLASS=thead2s&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   } else {\n&quot;);
		fprintf(ss,&quot;    result += &#039;&lt;SPAN CLASS=thead1s&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   }\n&quot;);
		fprintf(ss,&quot;   result += &#039;Response-time: &#039; + proclist.dnscheck.time + &#039;&lt;/SPAN&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;   var iddd = document.getElementById(&#039;DNSRESULT&#039;);\n&quot;);
		fprintf(ss,&quot;   if ( iddd != undefined &amp;&amp; iddd != null ) iddd.innerHTML = result;\n&quot;);
		fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		// fprintf(ss,&quot;  for ( var i = 0; i &lt; %d; i++ ){\n&quot;,entries);
		// fprintf(ss,&quot;   get_conns(i);\n&quot;);
		// fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot;  var request = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot;  request.onreadystatechange = function() { update_connections_callback_callback(request); };\n&quot;);
		fprintf(ss,&quot;  request.open(&#039;GET&#039;,&#039;/ajax/SYSINFO/0&#039; ,true);\n&quot;);
		fprintf(ss,&quot;  request.send();\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function update_connections_callback_callback(req){\n&quot;);
		fprintf(ss,&quot; if ( req.readyState != 4 ) return;\n&quot;);
		fprintf(ss,&quot; if ( req.status != 200 ) return;\n&quot;);
		fprintf(ss,&quot; console.log(&#039;Callback for SYSINFO -&gt;  Response: [&#039; + req.responseText + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot; if ( req.responseText.charAt(0) == &#039;O&#039; ){\n&quot;);
		fprintf(ss,&quot;  var jresp = JSON.parse(extract_bracket_val(req.responseText));\n&quot;);
		fprintf(ss,&quot;  var id = document.getElementById(&#039;LOAD1&#039;);\n&quot;);
		fprintf(ss,&quot;  if ( id != undefined &amp;&amp; id != null ) id.innerHTML = jresp.load1;\n&quot;);
		fprintf(ss,&quot;  var id = document.getElementById(&#039;LOAD5&#039;);\n&quot;);
		fprintf(ss,&quot;  if ( id != undefined &amp;&amp; id != null ) id.innerHTML = jresp.load5;\n&quot;);
		fprintf(ss,&quot;  var id = document.getElementById(&#039;LOAD15&#039;);\n&quot;);
		fprintf(ss,&quot;  if ( id != undefined &amp;&amp; id != null ) id.innerHTML = jresp.load15;\n&quot;);
		fprintf(ss,&quot;  var id = document.getElementById(&#039;UPTIME&#039;);\n&quot;);
		fprintf(ss,&quot;  if ( id != undefined &amp;&amp; id != null ) id.innerHTML = jresp.uptime;\n&quot;);
		fprintf(ss,&quot;  var id = document.getElementById(&#039;SYS_PROCS&#039;);\n&quot;);
		fprintf(ss,&quot;  if ( id != undefined &amp;&amp; id != null ) id.innerHTML = jresp.sys_procs;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; if ( jresp.dhcp_enabled &gt; 0 ){\n&quot;);
		fprintf(ss,&quot;  document.getElementById(&#039;DHCP_ENABLED&#039;).checked = true;\n&quot;);
		fprintf(ss,&quot; } else {\n&quot;);
		fprintf(ss,&quot;  document.getElementById(&#039;DHCP_ENABLED&#039;).checked = false;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; document.getElementById(&#039;DHCP_IP_LEASES&#039;).innerHTML = &#039;[&#039; + jresp.dhcp_ipv4_leases.length + &#039;]&#039;;\n&quot;);
		fprintf(ss,&quot; document.getElementById(&#039;DHCP_IP6_LEASES&#039;).innerHTML = &#039;[&#039; + jresp.dhcp_ipv6_leases.length + &#039;]&#039;;\n&quot;);
		fprintf(ss,&quot; update_tftp_display(jresp);\n&quot;);
		fprintf(ss,&quot; update_conns_display(jresp.inetlist);\n&quot;);
		fprintf(ss,&quot; document.getElementById(&#039;GIGA_ROTATOR&#039;).innerHTML = &#039;&lt;IMG SRC=/empty.gif HEIGHT=32&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; if ( gigatimer_active ) gigatimer = setInterval(update_connections,2000);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		

		fprintf(ss,&quot;function update_tftp_display(js){\n&quot;);
		fprintf(ss,&quot; document.getElementById(&#039;TFTP_REQUESTS_READ&#039;).innerHTML = js.tftp_requests_read;\n&quot;);
		fprintf(ss,&quot; document.getElementById(&#039;TFTP_REQUESTS_WRITE&#039;).innerHTML = js.tftp_requests_write;\n&quot;);
		fprintf(ss,&quot; document.getElementById(&#039;TFTP_ROOT&#039;).value = js.tftp_root;\n&quot;);
		fprintf(ss,&quot; if ( js.tftp_enabled &gt; 0 ){\n&quot;);
		fprintf(ss,&quot;  document.getElementById(&#039;TFTP_ENABLED&#039;).checked = true;\n&quot;);
		fprintf(ss,&quot; } else {\n&quot;);
		fprintf(ss,&quot;  document.getElementById(&#039;TFTP_ENABLED&#039;).checked = false;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; if ( js.tftp_readonly &gt; 0 ){\n&quot;);
		fprintf(ss,&quot;  document.getElementById(&#039;TFTP_READONLY&#039;).checked = true;\n&quot;);
		fprintf(ss,&quot; } else {\n&quot;);
		fprintf(ss,&quot;  document.getElementById(&#039;TFTP_READONLY&#039;).checked = false;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; var divvy = document.getElementById(&#039;TFTP_LIST&#039;);\n&quot;);
		fprintf(ss,&quot; if ( js.tftp_list.length &lt; 1 ){\n&quot;);
		fprintf(ss,&quot;  divvy.innerHTML = &#039;&#039;;\n&quot;);
		fprintf(ss,&quot;  return;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; var result = &#039;&lt;TABLE BGCOLOR=black CELLSPACING=1&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;Type&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;Remote-IP&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;File&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;Size&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;Transferred&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;Started&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1s&gt;Block-Size&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; for ( var idx = 0; idx &lt; js.tftp_list.length; idx++ ){\n&quot;);
		fprintf(ss,&quot;  var color = &#039;yellow&#039;;\n&quot;);
		fprintf(ss,&quot;  if ( idx %% 2 ) color = &#039;lightblue&#039;;\n&quot;);
		fprintf(ss,&quot;  var percent = &#039;-&#039;;\n&quot;);
		fprintf(ss,&quot;  var date_start = new Date(js.tftp_list[idx].started * 1000);\n&quot;);
		fprintf(ss,&quot;  var hours = &#039;0&#039; + date_start.getHours();\n&quot;);
		fprintf(ss,&quot;  var mins  = &#039;0&#039; + date_start.getMinutes();\n&quot;);
		fprintf(ss,&quot;  var secs  = &#039;0&#039; + date_start.getSeconds();\n&quot;);
		fprintf(ss,&quot;  var date_string = hours.substr(-2) + &#039;:&#039; + mins.substr(-2) + &#039;:&#039; + secs.substr(-2);\n&quot;);
		fprintf(ss,&quot;  if ( js.tftp_list[idx].fullsize ){ percent = Math.round((10000 * js.tftp_list[idx].offset)/js.tftp_list[idx].fullsize)/100 + &#039;%%&#039;; }\n&quot;); 
		fprintf(ss,&quot;  result += &#039;&lt;TR BGCOLOR=&#039; + color + &#039;&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=CENTER&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + js.tftp_list[idx].kind_transfer + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + js.tftp_list[idx].remote_ip + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + js.tftp_list[idx].filename + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + js.tftp_list[idx].fullsize + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + js.tftp_list[idx].offset + &#039;(&#039; + percent + &#039;)&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + date_string + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + js.tftp_list[idx].blksize + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);	
		fprintf(ss,&quot; result += &#039;&lt;/TABLE&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; divvy.innerHTML = result;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);	

		fprintf(ss,&quot;function save_dhcp_settings(){\n&quot;);
		fprintf(ss,&quot;  var newval = 1;\n&quot;);
		fprintf(ss,&quot;  if ( document.getElementById(&#039;DHCP_ENABLED&#039;).checked == false ) newval = 0;\n&quot;);
		fprintf(ss,&quot;  console.log(&#039;DHCP-ENABLED: [&#039; + newval + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  var request = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot;  request.open(&#039;GET&#039;,&#039;/ajax/SET_DHCP_ENABLE/&#039; + newval ,false);\n&quot;);
		fprintf(ss,&quot;  request.send();\n&quot;);
		fprintf(ss,&quot;  console.log(&#039;Request-Status: [&#039; + request.status + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function save_tftp_settings(){\n&quot;);
		fprintf(ss,&quot;  var newval = 1;\n&quot;);
		fprintf(ss,&quot;  if ( document.getElementById(&#039;TFTP_ENABLED&#039;).checked == false ) newval = 0;\n&quot;);
		fprintf(ss,&quot;  var request = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot;  request.open(&#039;GET&#039;,&#039;/ajax/SET_TFTP_ENABLE/&#039; + newval ,false);\n&quot;);
		fprintf(ss,&quot;  request.send();\n&quot;);
		fprintf(ss,&quot;  console.log(&#039;Request-Status: [&#039; + request.status + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  newval = 1;\n&quot;);
		fprintf(ss,&quot;  if ( document.getElementById(&#039;TFTP_READONLY&#039;).checked == false ) newval = 0;\n&quot;);
		fprintf(ss,&quot;  var request = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot;  request.open(&#039;GET&#039;,&#039;/ajax/SET_TFTP_READONLY/&#039; + newval ,false);\n&quot;);
		fprintf(ss,&quot;  request.send();\n&quot;);
		fprintf(ss,&quot;  console.log(&#039;Request-Status: [&#039; + request.status + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  var request = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot;  request.open(&#039;GET&#039;,&#039;/ajax/SET_TFTP_ROOT/&#039; + document.getElementById(&#039;TFTP_ROOT&#039;).value  ,false);\n&quot;);
		fprintf(ss,&quot;  request.send();\n&quot;);
		fprintf(ss,&quot;  console.log(&#039;Request-Status: [&#039; + request.status + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);



		fprintf(ss,&quot;function toggle_giga_refresh(){\n&quot;);
		fprintf(ss,&quot; if ( gigatimer_active ){\n&quot;);
		fprintf(ss,&quot;  document.getElementById(&#039;REFRESH_GIGA_BUTTON&#039;).value = &#039;Enable Auto-Refresh&#039;;\n&quot;);
		fprintf(ss,&quot;  gigatimer_active = false;\n&quot;);
		fprintf(ss,&quot;  if ( gigatimer != null ){ clearInterval(gigatimer); }\n&quot;);
		fprintf(ss,&quot; } else {\n&quot;);
		fprintf(ss,&quot;  document.getElementById(&#039;REFRESH_GIGA_BUTTON&#039;).value = &#039;Stop Auto-Refresh&#039;;\n&quot;);
		fprintf(ss,&quot;  gigatimer_active = true;\n&quot;);
		fprintf(ss,&quot;  update_connections();\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot;}\n&quot;);



		fprintf(ss,&quot;function show_info_rotator(){\n&quot;);
		// fprintf(ss,&quot; var refresh_button = document.getElementById(&#039;REFRESH_BUTTON&#039;);\n&quot;);
		fprintf(ss,&quot; var rotator_id = document.getElementById(&#039;ROTATOR&#039;);\n&quot;);
		// fprintf(ss,&quot; refresh_button.style.visibility = &#039;hidden&#039;;\n&quot;);
		fprintf(ss,&quot; rotator_id.innerHTML = &#039;&lt;IMG SRC=/new_rotator_big.gif HEIGHT=32&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function hide_info_rotator(){\n&quot;);
		// fprintf(ss,&quot; var refresh_button = document.getElementById(&#039;REFRESH_BUTTON&#039;);\n&quot;);
		fprintf(ss,&quot; var rotator_id = document.getElementById(&#039;ROTATOR&#039;);\n&quot;);
		// fprintf(ss,&quot; refresh_button.style.visibility = &#039;visible&#039;;\n&quot;);
		fprintf(ss,&quot; rotator_id.innerHTML = &#039;&lt;IMG SRC=/empty.gif HEIGHT=32&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;function process_detail1(pid){\n&quot;);
		fprintf(ss,&quot; if ( gigatimer_active ) { toggle_giga_refresh(); }\n&quot;);
		fprintf(ss,&quot; if ( megatimer != null ) clearInterval(megatimer);\n&quot;);
		fprintf(ss,&quot; megatimer_active = false;\n&quot;);
		fprintf(ss,&quot; process_detail(pid);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;function show_dhcp_ip_leases(which){\n&quot;);
		fprintf(ss,&quot; if ( gigatimer_active ) { toggle_giga_refresh(); }\n&quot;);
		fprintf(ss,&quot; if ( megatimer != null ) clearInterval(megatimer);\n&quot;);
		fprintf(ss,&quot; megatimer_active = false;\n&quot;);
		fprintf(ss,&quot; dhcp_detail(which);\n&quot;);	
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;function dhcp_detail(which){\n&quot;);
		fprintf(ss,&quot; close_info_window();\n&quot;);
		fprintf(ss,&quot; var main = document.getElementById(&#039;MAIN&#039;);\n&quot;);
		fprintf(ss,&quot; var newdiv = document.createElement(&#039;DIV&#039;);\n&quot;);
		fprintf(ss,&quot; newdiv.setAttribute(&#039;class&#039;,&#039;info_div&#039;);\n&quot;);
		fprintf(ss,&quot; newdiv.id = &#039;NEWDIV&#039;;\n&quot;);
		fprintf(ss,&quot; var closer_span = document.createElement(&#039;SPAN&#039;);\n&quot;);
		fprintf(ss,&quot; closer_span.setAttribute(&#039;class&#039;,&#039;filemanagerclose2&#039;);\n&quot;);
		fprintf(ss,&quot; closer_span.style.styleFloat = &#039;right&#039;;\n&quot;);
		fprintf(ss,&quot; closer_span.style.cssFloat = &#039;right&#039;;\n&quot;);
		fprintf(ss,&quot; closer_span.innerHTML = &#039;&amp;times&#039;;\n&quot;);
		fprintf(ss,&quot; closer_span.id = &#039;CLOSER&#039;;\n&quot;);
		fprintf(ss,&quot; var refresh_button = document.createElement(&#039;BUTTON&#039;);\n&quot;);
		fprintf(ss,&quot; refresh_button.id = &#039;REFRESH_BUTTON&#039;;\n&quot;);
		fprintf(ss,&quot; refresh_button.setAttribute(&#039;class&#039;,&#039;standard_button&#039;);\n&quot;);
		fprintf(ss,&quot; refresh_button.innerHTML = &#039;Enable Auto-Refresh&#039;;\n&quot;);
		fprintf(ss,&quot; newdiv.appendChild(closer_span);\n&quot;);
		fprintf(ss,&quot; var rotator_id = document.createElement(&#039;SPAN&#039;);\n&quot;);
		fprintf(ss,&quot; rotator_id.id = &#039;ROTATOR&#039;;\n&quot;);
		fprintf(ss,&quot; rotator_id.setAttribute(&#039;class&#039;,&#039;rotator_div&#039;);\n&quot;);
		fprintf(ss,&quot; rotator_id.innerHTML = &#039;&lt;IMG SRC=/empty.gif HEIGHT=32&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; newdiv.appendChild(rotator_id);\n&quot;);
		fprintf(ss,&quot; newdiv.appendChild(refresh_button);\n&quot;);
		fprintf(ss,&quot; var tdiv = document.createElement(&#039;DIV&#039;);\n&quot;);
		fprintf(ss,&quot; closer_span.addEventListener(&#039;click&#039;,function() { close_info_window(); });\n&quot;);
		fprintf(ss,&quot; refresh_button.addEventListener(&#039;click&#039;,function() { dhcp_detail_refresh_toggle(which,tdiv); });\n&quot;);
		fprintf(ss,&quot; tdiv.setAttribute(&#039;class&#039;,&#039;table_list2&#039;);\n&quot;);
		fprintf(ss,&quot; tdiv.id = &#039;TDIV&#039;;\n&quot;);
		fprintf(ss,&quot; tdiv.style.backgroundColor = &#039;black&#039;;\n&quot;);
		fprintf(ss,&quot; newdiv.appendChild(tdiv);\n&quot;);
		fprintf(ss,&quot; main.appendChild(newdiv);\n&quot;);
		fprintf(ss,&quot; var request = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot; show_info_rotator();\n&quot;);
		fprintf(ss,&quot; request.onreadystatechange = function() { dhcp_detail_callback(request,which,tdiv); };\n&quot;);
		fprintf(ss,&quot; request.open(&#039;GET&#039;,&#039;/ajax/SYSINFO/0&#039;, true);\n&quot;);
		fprintf(ss,&quot; request.send();\n&quot;);
		fprintf(ss,&quot; if ( megatimer_active ) megatimer = setInterval(function() { dhcp_detail_refresh(which,tdiv); },2000);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);
	
		fprintf(ss,&quot;function dhcp_detail_refresh_toggle(which,tdiv){\n&quot;);
		fprintf(ss,&quot; var id = document.getElementById(&#039;REFRESH_BUTTON&#039;);\n&quot;);
		fprintf(ss,&quot; if ( megatimer_active ){\n&quot;);
		fprintf(ss,&quot;  if ( megatimer != null ) { clearInterval(megatimer); megatimer = null; };\n&quot;);
		fprintf(ss,&quot;  id.innerHTML = &#039;Enable Auto-Refresh&#039;;\n&quot;);
		fprintf(ss,&quot;  megatimer_active = false;\n&quot;);
		fprintf(ss,&quot; } else {\n&quot;);
		fprintf(ss,&quot;  if ( megatimer != null ) { clearInterval(megatimer); megatimer = null; };\n&quot;);
		fprintf(ss,&quot;  megatimer = setInterval(function() { dhcp_detail_refresh(which,tdiv); },2000);\n&quot;);
		fprintf(ss,&quot;  id.innerHTML = &#039;Stop Auto-Refresh&#039;;\n&quot;);
		fprintf(ss,&quot;  dhcp_detail_refresh(which,tdiv);\n&quot;);
		fprintf(ss,&quot;  megatimer_active = true;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function dhcp_detail_refresh(which,tdiv){\n&quot;);
		fprintf(ss,&quot; if ( megatimer != null ) clearInterval(megatimer);\n&quot;);
		fprintf(ss,&quot; show_info_rotator();\n&quot;);
		fprintf(ss,&quot; var request = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot; request.onreadystatechange = function() { dhcp_detail_callback(request,which,tdiv); };\n&quot;);
		fprintf(ss,&quot; request.open(&#039;GET&#039;,&#039;/ajax/SYSINFO/0&#039;, true);\n&quot;);
		fprintf(ss,&quot; request.send();\n&quot;);
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;function dhcp_detail_callback(req,which,tdiv){\n&quot;);
		fprintf(ss,&quot; if ( req.readyState != 4 ) return;\n&quot;);
		fprintf(ss,&quot; if ( req.status != 200 ) return;\n&quot;);
		fprintf(ss,&quot; console.log(&#039;Callback for DHCP_DETAIL(&#039; + which + &#039;) -&gt;  Response: [&#039; + req.responseText + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot; hide_info_rotator();\n&quot;);
		fprintf(ss,&quot; var result = &#039;&lt;CENTER&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;P&gt;&lt;SPAN CLASS=theadbig&gt;Information for DHCP-Leases: &lt;B&gt;IPv&#039; + which + &#039;&lt;/B&gt;&lt;/SPAN&gt;&lt;/P&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; if ( req.responseText.charAt(0) != &#039;O&#039; ){\n&quot;);
		fprintf(ss,&quot;  tdiv.innerHTML = result;\n&quot;);
		fprintf(ss,&quot;  alert(&#039;Could not get process details [&#039; + extract_bracket_val(req.responseText) + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  close_info_window();\n&quot;);
		fprintf(ss,&quot;  return;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; var ds = JSON.parse(extract_bracket_val(req.responseText));\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;P&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TABLE CELLSPACING=1 BORDER=0 BGCOLOR=black&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR BGCOLOR=white&gt;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;MAC-Address&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;Class-ID(60)&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;Hostname(12)&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;IP-Address&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;Created&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;Last-Refresh&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;Expiry&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead1s&gt;&amp;nbsp;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; if ( which == 4 ) var addrlist = ds.dhcp_ipv4_leases;\n&quot;);
		fprintf(ss,&quot; if ( which == 6 ) var addrlist = ds.dhcp_ipv6_leases;\n&quot;);
		fprintf(ss,&quot; for ( var ii = 0; ii &lt; addrlist.length; ii++ ){\n&quot;);
		fprintf(ss,&quot;  var color = &#039;lightblue&#039;;\n&quot;);
		fprintf(ss,&quot;  if ( ii % 2 ) color = &#039;yellow&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TR BGCOLOR=&#039; + color + &#039;&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + addrlist[ii].mac + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + addrlist[ii].class_id + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + addrlist[ii].hostname + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + addrlist[ii].ip + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + addrlist[ii].created + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  if ( addrlist[ii].changed.charAt(0) == &#039;1&#039; ){\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead2s&gt;not yet&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  } else {\n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + addrlist[ii].changed + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + addrlist[ii].expiry + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD&gt;&lt;SPAN CLASS=thead2s&gt;&lt;INPUT TYPE=BUTTON CLASS=standard_buttons VALUE=\&quot;Release\&quot; onclick=dhcp_release(&#039; + which + &#039;,\&quot;&#039; + addrlist[ii].mac + &#039;\&quot;,\&quot;&#039; + addrlist[ii].ip + &#039;\&quot;)&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;/TABLE&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;/P&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; tdiv.innerHTML = result;\n&quot;);
		fprintf(ss,&quot; if ( megatimer_active ) megatimer = setInterval(function() { dhcp_detail_refresh(which,tdiv); },2000);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function dhcp_release(which, mac, ip){\n&quot;);
		fprintf(ss,&quot;  console.log(&#039;DHCP-Releasing: [IPv&#039; + which + &#039;] MAC: [&#039; + mac + &#039;] IP: [&#039; + ip + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		


		fprintf(ss,&quot;function process_detail(pid){\n&quot;);
		fprintf(ss,&quot; close_info_window();\n&quot;);
		fprintf(ss,&quot; var main = document.getElementById(&#039;MAIN&#039;);\n&quot;);
		fprintf(ss,&quot; var newdiv = document.createElement(&#039;DIV&#039;);\n&quot;);
		fprintf(ss,&quot; newdiv.setAttribute(&#039;class&#039;,&#039;info_div&#039;);\n&quot;);
		fprintf(ss,&quot; newdiv.id = &#039;NEWDIV&#039;;\n&quot;);
		fprintf(ss,&quot; var closer_span = document.createElement(&#039;SPAN&#039;);\n&quot;);
		fprintf(ss,&quot; closer_span.setAttribute(&#039;class&#039;,&#039;filemanagerclose2&#039;);\n&quot;);
		fprintf(ss,&quot; closer_span.style.styleFloat = &#039;right&#039;;\n&quot;);
		fprintf(ss,&quot; closer_span.style.cssFloat = &#039;right&#039;;\n&quot;);
		fprintf(ss,&quot; closer_span.innerHTML = &#039;&amp;times&#039;;\n&quot;);
		fprintf(ss,&quot; closer_span.id = &#039;CLOSER&#039;;\n&quot;);
		fprintf(ss,&quot; var refresh_button = document.createElement(&#039;BUTTON&#039;);\n&quot;);
		fprintf(ss,&quot; refresh_button.id = &#039;REFRESH_BUTTON&#039;;\n&quot;);
		fprintf(ss,&quot; refresh_button.setAttribute(&#039;class&#039;,&#039;standard_button&#039;);\n&quot;);
		fprintf(ss,&quot; refresh_button.innerHTML = &#039;Enable Auto-Refresh&#039;;\n&quot;);
		fprintf(ss,&quot; newdiv.appendChild(closer_span);\n&quot;);
		fprintf(ss,&quot; var rotator_id = document.createElement(&#039;SPAN&#039;);\n&quot;);
		fprintf(ss,&quot; rotator_id.id = &#039;ROTATOR&#039;;\n&quot;);
		fprintf(ss,&quot; rotator_id.setAttribute(&#039;class&#039;,&#039;rotator_div&#039;);\n&quot;);
		fprintf(ss,&quot; rotator_id.innerHTML = &#039;&lt;IMG SRC=/empty.gif HEIGHT=32&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; newdiv.appendChild(rotator_id);\n&quot;);
		fprintf(ss,&quot; newdiv.appendChild(refresh_button);\n&quot;);
		fprintf(ss,&quot; var tdiv = document.createElement(&#039;DIV&#039;);\n&quot;);
		fprintf(ss,&quot; closer_span.addEventListener(&#039;click&#039;,function() { close_info_window(); });\n&quot;);
		fprintf(ss,&quot; refresh_button.addEventListener(&#039;click&#039;,function() { process_detail_refresh_toggle(pid,tdiv); });\n&quot;);
		fprintf(ss,&quot; tdiv.setAttribute(&#039;class&#039;,&#039;table_list2&#039;);\n&quot;);
		fprintf(ss,&quot; tdiv.id = &#039;TDIV&#039;;\n&quot;);
		fprintf(ss,&quot; tdiv.style.backgroundColor = &#039;black&#039;;\n&quot;);
		fprintf(ss,&quot; newdiv.appendChild(tdiv);\n&quot;);
		fprintf(ss,&quot; main.appendChild(newdiv);\n&quot;);
		fprintf(ss,&quot; var request = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot; show_info_rotator();\n&quot;);
		fprintf(ss,&quot; request.onreadystatechange = function() { process_detail_callback(request,pid,tdiv); };\n&quot;);
		fprintf(ss,&quot; request.open(&#039;GET&#039;,&#039;/ajax/PROCDETAIL/&#039; + pid, true);\n&quot;);
		fprintf(ss,&quot; request.send();\n&quot;);
		fprintf(ss,&quot; if ( megatimer_active ) megatimer = setInterval(function() { process_detail_refresh(pid,tdiv); },2000);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function process_detail_refresh_toggle(pid,tdiv){\n&quot;);
		fprintf(ss,&quot; var id = document.getElementById(&#039;REFRESH_BUTTON&#039;);\n&quot;);
		fprintf(ss,&quot; if ( megatimer_active ){\n&quot;);
		fprintf(ss,&quot;  if ( megatimer != null ) { clearInterval(megatimer); megatimer = null; };\n&quot;);
		fprintf(ss,&quot;  id.innerHTML = &#039;Enable Auto-Refresh&#039;;\n&quot;);
		fprintf(ss,&quot;  megatimer_active = false;\n&quot;);
		fprintf(ss,&quot; } else {\n&quot;);
		fprintf(ss,&quot;  if ( megatimer != null ) { clearInterval(megatimer); megatimer = null; };\n&quot;);
		fprintf(ss,&quot;  megatimer = setInterval(function() { process_detail_refresh(pid,tdiv); },2000);\n&quot;);
		fprintf(ss,&quot;  id.innerHTML = &#039;Stop Auto-Refresh&#039;;\n&quot;);
		fprintf(ss,&quot;  process_detail_refresh(pid,tdiv);\n&quot;);
		fprintf(ss,&quot;  megatimer_active = true;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;function process_detail_refresh(pid,tdiv){\n&quot;);
		fprintf(ss,&quot; if ( megatimer != null ) clearInterval(megatimer);\n&quot;);
		fprintf(ss,&quot; show_info_rotator();\n&quot;);
		fprintf(ss,&quot; var request = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot; request.onreadystatechange = function() { process_detail_callback(request,pid,tdiv); };\n&quot;);
		fprintf(ss,&quot; request.open(&#039;GET&#039;,&#039;/ajax/PROCDETAIL/&#039; + pid, true);\n&quot;);
		fprintf(ss,&quot; request.send();\n&quot;);
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;function process_detail_callback(req,pid,tdiv){\n&quot;);
		fprintf(ss,&quot; if ( req.readyState != 4 ) return;\n&quot;);
		fprintf(ss,&quot; if ( req.status != 200 ) return;\n&quot;);
		fprintf(ss,&quot; console.log(&#039;Callback for PROCESS_DETAIL(&#039; + pid + &#039;) -&gt;  Response: [&#039; + req.responseText + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot; hide_info_rotator();\n&quot;);
		fprintf(ss,&quot; var result = &#039;&lt;CENTER&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;P&gt;&lt;SPAN CLASS=theadbig&gt;Information for Process: &lt;B&gt;&#039; + pid + &#039;&lt;/B&gt;&lt;/SPAN&gt;&lt;/P&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;P&gt;&lt;INPUT TYPE=BUTTON CLASS=standard_buttons VALUE=\&quot;Send HUP Signal\&quot; onclick=send_signal(&#039; + pid + &#039;,1)&gt;&amp;nbsp;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;INPUT TYPE=BUTTON CLASS=standard_buttons VALUE=\&quot;Send KILL Signal\&quot; onclick=send_signal(&#039; + pid + &#039;,9)&gt;&lt;/P&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; if ( req.responseText.charAt(0) != &#039;O&#039; ){\n&quot;);
		fprintf(ss,&quot;  tdiv.innerHTML = result;\n&quot;);
		fprintf(ss,&quot;  alert(&#039;Could not get process details [&#039; + extract_bracket_val(req.responseText) + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot;  close_info_window();\n&quot;);
		fprintf(ss,&quot;  return;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; var pd = JSON.parse(extract_bracket_val(req.responseText));\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;P&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TABLE CELLSPACING=1 BORDER=0 BGCOLOR=black&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&lt;TD VALIGN=TOP&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TABLE CELLSPACING=1 BORDER=0 BGCOLOR=blue&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; if ( pd.ppid == 0 ){\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TR&gt;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;Parent-PID:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s&gt;No parent&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; } else {\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TR&gt;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;Parent-PID:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2slink onclick=process_detail1(&#039; + pd.ppid + &#039;)&gt;&#039; + pd.ppid + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;Process-state:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + pd.full_state + &#039;&lt;/B&gt;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;Real-UID:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + pd.r_uid + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;Real-GID:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + pd.r_gid + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;Effective-UID:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + pd.e_uid + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;Effective-GID:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + pd.e_gid + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;Name:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + pd.name + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;Executeable-path:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + pd.full_exe + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;Working-directory:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + pd.full_cwd + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;Commandline:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + pd.commandline + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;CPU-Usage (sys):&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + pd.cpu_usage_sys + &#039;%%&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;CPU-Time (sys):&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + pd.sys_time + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;CPU-Usage (usr):&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + pd.cpu_usage_usr + &#039;%%&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;CPU-Time (usr):&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + pd.usr_time + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; if ( pd.slot &gt; -1 &amp;&amp; pd.index &gt; -1 ){\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TR&gt;&lt;TD ALIGN=CENTER BGCOLOR=white COLSPAN=2&gt;&lt;INPUT TYPE=BUTTON CLASS=standard_button VALUE=\&quot;Show GINETD-Connection\&quot; onclick=conns_list1(&#039; + pd.slot + &#039;,&#039; + pd.index + &#039;)&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;Process-started:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + pd.p_start + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;Virtual memory:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + pd.vm_size + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;Real memory:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + pd.rss + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;Threads:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + pd.num_threads + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;CPU:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + pd.cpu + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&lt;TD ALIGN=RIGHT BGCOLOR=white&gt;&lt;SPAN CLASS=thead2s&gt;Count of fds:&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + pd.fds.length + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;/TABLE&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD VALIGN=TOP&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;DIV CLASS=fd_div&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TABLE CELLSPACING=1 BGCOLOR=blue&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TR&gt;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1&gt;FD&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1&gt;Type&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white&gt;&lt;SPAN CLASS=thead1&gt;Name&lt;/SPAN&gt;&lt;/TD&gt;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; for ( var ix = 0; ix &lt; pd.fds.length; ix++ ){\n&quot;);
		fprintf(ss,&quot;  var color = &#039;yellow&#039;;\n&quot;);
		fprintf(ss,&quot;  if ( ix %% 2 ) color = &#039;lightblue&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + pd.fds[ix].fd + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + pd.fds[ix].type + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  if ( pd.fds[ix].valid_addr == true ){\n&quot;);
		fprintf(ss,&quot;   var status = &#039;unknown&amp;nbsp;&#039; + pd.fds[ix].state;\n&quot;);
		fprintf(ss,&quot;   if ( pd.fds[ix].state == 1 ) status = &#039;ESTABLISHED&#039;;\n&quot;);
		fprintf(ss,&quot;   if ( pd.fds[ix].state == 2 ) status = &#039;SYN_SENT&#039;;\n&quot;);
		fprintf(ss,&quot;   if ( pd.fds[ix].state == 3 ) status = &#039;SYN_RECV&#039;;\n&quot;);
		fprintf(ss,&quot;   if ( pd.fds[ix].state == 4 ) status = &#039;FIN_WAIT1&#039;;\n&quot;);
		fprintf(ss,&quot;   if ( pd.fds[ix].state == 5 ) status = &#039;FIN_WAIT2&#039;;\n&quot;);
		fprintf(ss,&quot;   if ( pd.fds[ix].state == 6 ) status = &#039;TIME_WAIT(&#039; + pd.fds[ix].timer_value + &#039;)&#039;;\n&quot;);
		fprintf(ss,&quot;   if ( pd.fds[ix].state == 7 ) status = &#039;CLOSE&#039;;\n&quot;);
		fprintf(ss,&quot;   if ( pd.fds[ix].state == 8 ) status = &#039;CLOSE_WAIT(&#039; + pd.fds[ix].timer_value + &#039;)&#039;;\n&quot;);
		fprintf(ss,&quot;   if ( pd.fds[ix].state == 9 ) status = &#039;LAST_ACK&#039;;\n&quot;);
		fprintf(ss,&quot;   if ( pd.fds[ix].state == 10 ) status = &#039;LISTEN&#039;;\n&quot;);
		fprintf(ss,&quot;   if ( pd.fds[ix].state == 11 ) status = &#039;CLOSING&#039;;\n&quot;);
		fprintf(ss,&quot;   var family = &#039;unknown&amp;nbsp;&#039; + pd.fds[ix].family;\n&quot;);
		fprintf(ss,&quot;   if ( pd.fds[ix].family == %d ) family = &#039;IPv6&#039;;\n&quot;,AF_INET6);
		fprintf(ss,&quot;   if ( pd.fds[ix].family == %d ) family = &#039;IPv4&#039;;\n&quot;,AF_INET);
		fprintf(ss,&quot;   if ( pd.fds[ix].family == %d ) family = &#039;unix&#039;;\n&quot;,AF_UNIX);
		fprintf(ss,&quot;   var protocol = &#039;unknown&amp;nbsp;&#039; + pd.fds[ix].protocol;\n&quot;);
		fprintf(ss,&quot;   if ( pd.fds[ix].protocol == %d ) protocol = &#039;TCP&#039;;\n&quot;,SOCK_STREAM);
		fprintf(ss,&quot;   if ( pd.fds[ix].protocol == %d ) protocol = &#039;UDP&#039;;\n&quot;,SOCK_DGRAM);
		fprintf(ss,&quot;   result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s&gt;[&#039; + family + &#039;][&#039; + protocol + &#039;] [&#039; + pd.fds[ix].local_addr + &#039;]:&#039; + pd.fds[ix].local_port + &#039; - [&#039; + pd.fds[ix].remote_addr + &#039;]:&#039; + pd.fds[ix].remote_port + &#039; (&#039; + status + &#039;)&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  } else { \n&quot;);
		fprintf(ss,&quot;   result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=LEFT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + pd.fds[ix].name + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  }\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;/TABLE&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;/DIV&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;/TABLE&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;/P&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; tdiv.innerHTML = result;\n&quot;);
		fprintf(ss,&quot; if ( megatimer_active ) megatimer = setInterval(function() { process_detail_refresh(pid,tdiv); },2000);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;function conns_list1(idx,item){\n&quot;);
		fprintf(ss,&quot; if ( gigatimer_active ) { toggle_giga_refresh(); }\n&quot;);
		fprintf(ss,&quot; if ( megatimer != null ) clearInterval(megatimer);\n&quot;);
		fprintf(ss,&quot; megatimer_active = false;\n&quot;);
		fprintf(ss,&quot; conns_list(idx,item);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;function send_signal(pid, sig){\n&quot;);
		fprintf(ss,&quot; console.log(&#039;Sending Signal [&#039; + sig + &#039;] to process-ID: [&#039; + pid + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot; var request = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot; request.onreadystatechange = send_signal_callback;\n&quot;);
		fprintf(ss,&quot; request.open(&#039;GET&#039;,&#039;/ajax/SIGNAL/&#039; + pid + &#039;/&#039; + sig , true);\n&quot;);
		fprintf(ss,&quot; request.send();\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function send_signal_callback(){\n&quot;);
		fprintf(ss,&quot; if ( this.readyState != 4 ) return;\n&quot;);
		fprintf(ss,&quot; console.log(&#039;Status: [&#039; + this.status + &#039;] Response: [&#039; + this.responseText + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot; if ( this.responseText.charAt(0) == &#039;O&#039; ) {\n&quot;);
		fprintf(ss,&quot;  alert(&#039;Sent signal to process&#039;);\n&quot;);
		fprintf(ss,&quot; } else {\n&quot;);
		fprintf(ss,&quot;  alert(&#039;Sending signal to process failed!&#039;);\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot;}\n&quot;);



		fprintf(ss,&quot;function  conns_list(idx,item){\n&quot;);
		fprintf(ss,&quot; close_info_window();\n&quot;);
		fprintf(ss,&quot; var main = document.getElementById(&#039;MAIN&#039;);\n&quot;);
		fprintf(ss,&quot; var newdiv = document.createElement(&#039;DIV&#039;);\n&quot;);
		fprintf(ss,&quot; newdiv.setAttribute(&#039;class&#039;,&#039;info_div&#039;);\n&quot;);
		fprintf(ss,&quot; newdiv.id = &#039;NEWDIV&#039;;\n&quot;);
		fprintf(ss,&quot; var closer_span = document.createElement(&#039;SPAN&#039;);\n&quot;);
		fprintf(ss,&quot; closer_span.setAttribute(&#039;class&#039;,&#039;filemanagerclose2&#039;);\n&quot;);
		fprintf(ss,&quot; closer_span.style.styleFloat = &#039;right&#039;;\n&quot;);
		fprintf(ss,&quot; closer_span.style.cssFloat = &#039;right&#039;;\n&quot;);
		fprintf(ss,&quot; closer_span.innerHTML = &#039;&amp;times&#039;;\n&quot;);
		fprintf(ss,&quot; closer_span.id = &#039;CLOSER&#039;;\n&quot;);
		fprintf(ss,&quot; var refresh_button = document.createElement(&#039;BUTTON&#039;);\n&quot;);
		fprintf(ss,&quot; refresh_button.id = &#039;REFRESH_BUTTON&#039;;\n&quot;);
		fprintf(ss,&quot; refresh_button.setAttribute(&#039;class&#039;,&#039;standard_button&#039;);\n&quot;);
		fprintf(ss,&quot; refresh_button.innerHTML = &#039;Enable Auto-Refresh&#039;;\n&quot;);
		fprintf(ss,&quot; newdiv.appendChild(closer_span);\n&quot;);
		fprintf(ss,&quot; var rotator_id = document.createElement(&#039;SPAN&#039;);\n&quot;);
		fprintf(ss,&quot; rotator_id.id = &#039;ROTATOR&#039;;\n&quot;);
		fprintf(ss,&quot; rotator_id.setAttribute(&#039;class&#039;,&#039;rotator_div&#039;);\n&quot;);
		fprintf(ss,&quot; newdiv.appendChild(rotator_id);\n&quot;);
		fprintf(ss,&quot; newdiv.appendChild(refresh_button);\n&quot;);
		fprintf(ss,&quot; var tdiv = document.createElement(&#039;DIV&#039;);\n&quot;);
		fprintf(ss,&quot; closer_span.addEventListener(&#039;click&#039;,function() { close_info_window(); });\n&quot;);
		fprintf(ss,&quot; refresh_button.addEventListener(&#039;click&#039;,function() { reload_conns_list_toggle(idx,item); });\n&quot;);
		fprintf(ss,&quot; tdiv.setAttribute(&#039;class&#039;,&#039;table_list&#039;);\n&quot;);
		fprintf(ss,&quot; tdiv.id = &#039;TDIV&#039;;\n&quot;);
		fprintf(ss,&quot; newdiv.appendChild(tdiv);\n&quot;);
		fprintf(ss,&quot; main.appendChild(newdiv);\n&quot;);
		fprintf(ss,&quot; var request = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot; show_info_rotator();\n&quot;);
		fprintf(ss,&quot; request.onreadystatechange = function() { conns_list_callback(request,idx,item); };\n&quot;);
		fprintf(ss,&quot; request.open(&#039;GET&#039;,&#039;/ajax/CONNSLIST/&#039; + idx, true);\n&quot;);
		fprintf(ss,&quot; request.send();\n&quot;);
		fprintf(ss,&quot; if ( megatimer_active ) megatimer = setInterval(function() { reload_conns_list(idx,item); },1000);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function reload_conns_list_toggle(idx,item){\n&quot;);
		fprintf(ss,&quot; var id = document.getElementById(&#039;REFRESH_BUTTON&#039;);\n&quot;);
		fprintf(ss,&quot; if ( megatimer_active ){\n&quot;);
		fprintf(ss,&quot;  if ( megatimer != null ) { clearInterval(megatimer); megatimer = null; };\n&quot;);
		fprintf(ss,&quot;  id.innerHTML = &#039;Enable Auto-Refresh&#039;;\n&quot;);
		fprintf(ss,&quot;  megatimer_active = false;\n&quot;);
		fprintf(ss,&quot; } else {\n&quot;);
		fprintf(ss,&quot;  if ( megatimer != null ) { clearInterval(megatimer); megatimer = null; };\n&quot;);
		fprintf(ss,&quot;  megatimer = setInterval(function() { reload_conns_list(idx,item); },1000);\n&quot;);
		fprintf(ss,&quot;  id.innerHTML = &#039;Stop Auto-Refresh&#039;;\n&quot;);
		fprintf(ss,&quot;  reload_conns_list(idx,item);\n&quot;);
		fprintf(ss,&quot;  megatimer_active = true;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;function reload_conns_list(idx,item){\n&quot;);
		fprintf(ss,&quot; if ( megatimer != null ) clearInterval(megatimer);\n&quot;);
		fprintf(ss,&quot; show_info_rotator();\n&quot;);
		fprintf(ss,&quot; var request = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot; request.onreadystatechange = function() { conns_list_callback(request,idx,item); };\n&quot;);
		fprintf(ss,&quot; request.open(&#039;GET&#039;,&#039;/ajax/CONNSLIST/&#039; + idx, true);\n&quot;);
		fprintf(ss,&quot; request.send();\n&quot;);
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;function conns_list_callback(req,idx,item){\n&quot;);
		fprintf(ss,&quot; if ( req.readyState != 4 ) return;\n&quot;);
		fprintf(ss,&quot; if ( req.status != 200 ) return;\n&quot;);
		fprintf(ss,&quot; console.log(&#039;Callback for CONNSLIST -&gt;  Response: [&#039; + req.responseText + &#039;]&#039;);\n&quot;);
		fprintf(ss,&quot; hide_info_rotator();\n&quot;);
		fprintf(ss,&quot; if ( req.responseText.charAt(0) != &#039;O&#039; ){\n&quot;);
		fprintf(ss,&quot;  alert(&#039;Could not get list of connections&#039;);\n&quot;);
		fprintf(ss,&quot;  return;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; var connection = JSON.parse(extract_bracket_val(req.responseText));\n&quot;);
		fprintf(ss,&quot; console.log(&#039;Found [&#039; + connection.length + &#039;] records&#039;);\n&quot;);
		fprintf(ss,&quot; var cid = document.getElementById(&#039;TDIV&#039;);\n&quot;);
		fprintf(ss,&quot; var result = &#039;&lt;TABLE CELLSPACING=1 BORDER=0 BGCOLOR=black&gt;&lt;TR&gt;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;Index&lt;/SPAN&gt;&lt;/TD&gt;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;Source&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;Target&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;PID&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;Prog&amp;nbsp;PID&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;Created&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;CWD&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;Data&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;Stack&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;Exe&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;Libs&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;IO-Read&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;IO-Write&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;TCP&amp;nbsp;State&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;TCP&amp;nbsp;Timeout&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;TD BGCOLOR=white&gt;&lt;CENTER&gt;&lt;SPAN CLASS=thead1&gt;&amp;nbsp;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; for ( var i = 0; i &lt; connection.length; i++ ){\n&quot;);
		fprintf(ss,&quot;  var color = &#039;lightblue&#039;;\n&quot;);
		fprintf(ss,&quot;  if ( i % 2 ) color = &#039;yellow&#039;;\n&quot;);
		fprintf(ss,&quot;  if ( i == item ) color = &#039;orange&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; +  connection[i].slot +  &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039;&gt;&lt;SPAN CLASS=thead2s&gt;&lt;B&gt;&#039; + connection[i].source + &#039;&lt;/B&gt;:&#039; + connection[i].source_port + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039;&gt;&lt;SPAN CLASS=thead2s&gt;&lt;B&gt;&#039; + connection[i].target + &#039;&lt;/B&gt;:&#039; + connection[i].target_port + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2links onclick=process_detail1(&#039; + connection[i].pid + &#039;)&gt;&#039; + connection[i].pid + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2links onclick=process_detail1(&#039; + connection[i].cpid + &#039;)&gt;&#039; + connection[i].cpid + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + connection[i].created + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + connection[i].cwd + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + connection[i].vm_data + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + connection[i].vm_stack + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + connection[i].vm_exe + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + connection[i].vm_lib + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + connection[i].io_read + &#039;(&#039; + connection[i].io_read_sec + &#039;)&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + connection[i].io_write + &#039;(&#039; + connection[i].io_write_sec + &#039;)&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + connection[i].tcp_state + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=RIGHT&gt;&lt;SPAN CLASS=thead2s&gt;&#039; + connection[i].tcp_timeout + &#039;&lt;/SPAN&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;TD BGCOLOR=&#039; + color + &#039; ALIGN=CENTER&gt;&lt;INPUT TYPE=BUTTON CLASS=standard_button onclick=kill_connection(&#039; + connection[i].cpid + &#039;,&#039; + idx + &#039;,&#039; + i + &#039;) VALUE=\&quot;Disconnect\&quot;&gt;&lt;/TD&gt;&#039;;\n&quot;);
		fprintf(ss,&quot;  result += &#039;&lt;/TR&gt;&#039;;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot; cid.innerHTML = result;\n&quot;);
		fprintf(ss,&quot; if ( megatimer )  megatimer = setInterval(function() { reload_conns_list(idx,item); },1000);\n&quot;);
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;function kill_connection(pid, main_idx, co_index){\n&quot;);
		fprintf(ss,&quot; var request = new XMLHttpRequest();\n&quot;);
		fprintf(ss,&quot; request.onreadystatechange = function() { kill_connection_callback(request,pid,main_idx,co_index); };\n&quot;);
		fprintf(ss,&quot; request.open(&#039;GET&#039;,&#039;/ajax/KILLTCP/&#039; + main_idx + &#039;/&#039; + co_index, true);\n&quot;);
		fprintf(ss,&quot; request.send();\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function kill_connection_callback(req,pid,main_idx,co_idx){\n&quot;); 
		fprintf(ss,&quot; if ( req.readyState != 4 ) return;\n&quot;);
		fprintf(ss,&quot; if ( req.status != 200 ) return;\n&quot;);
		fprintf(ss,&quot; if ( req.responseText.charAt(0) != &#039;O&#039; ){\n&quot;);
		fprintf(ss,&quot;  alert(&#039;Could kill connection&#039;);\n&quot;);
		fprintf(ss,&quot;  return;\n&quot;);
		fprintf(ss,&quot; } else {\n&quot;);
		fprintf(ss,&quot;  alert(&#039;Connection received kill&#039;);\n&quot;);
		fprintf(ss,&quot;  return;\n&quot;);
		fprintf(ss,&quot; }\n&quot;);
		fprintf(ss,&quot;}\n&quot;);


		fprintf(ss,&quot;function close_info_window(){\n&quot;);
		fprintf(ss,&quot;var newdiv =  document.getElementById(&#039;NEWDIV&#039;);\n&quot;);
		fprintf(ss,&quot;var rotator = document.getElementById(&#039;ROTATOR&#039;);\n&quot;);
		fprintf(ss,&quot;var closer =  document.getElementById(&#039;CLOSER&#039;);\n&quot;);
		fprintf(ss,&quot;var main =    document.getElementById(&#039;MAIN&#039;);\n&quot;);
		fprintf(ss,&quot;var tdiv =    document.getElementById(&#039;TDIV&#039;);\n&quot;);
		fprintf(ss,&quot; if ( megatimer != undefined &amp;&amp; megatimer != null ){ clearInterval(megatimer); megatimer = null; } \n&quot;);
		fprintf(ss,&quot; if ( newdiv != undefined &amp;&amp; rotator != undefined ) newdiv.removeChild(rotator);\n&quot;);
		fprintf(ss,&quot; if ( newdiv != undefined &amp;&amp; closer != undefined )  newdiv.removeChild(closer);\n&quot;);
		fprintf(ss,&quot; if ( newdiv != undefined &amp;&amp; tdiv != undefined )    newdiv.removeChild(tdiv);\n&quot;);
		fprintf(ss,&quot; if ( main != undefined &amp;&amp; newdiv != undefined )    main.removeChild(newdiv);\n&quot;);
		fprintf(ss,&quot; megatimer_active = false;\n&quot;);
		fprintf(ss,&quot; if ( megatimer ) { clearInterval(megatimer); megatimer = null; }\n&quot;);
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;function init_all(){\n&quot;);
		fprintf(ss,&quot; console.log(&#039;Initializing everything&#039;);\n&quot;);
		fprintf(ss,&quot; megatimer = null;\n&quot;);
		fprintf(ss,&quot; gigatimer = null;\n&quot;);
		fprintf(ss,&quot; megatimer_active = false;\n&quot;);
		fprintf(ss,&quot; gigatimer_active = false;\n&quot;);
		fprintf(ss,&quot; gigatimer_stored = false;\n&quot;);
		fprintf(ss,&quot; leth = Object.create(eth_obj);\n&quot;);
		fprintf(ss,&quot; update_connections();\n&quot;); // Initial call
		fprintf(ss,&quot;}\n&quot;);

		fprintf(ss,&quot;&lt;/SCRIPT&gt;\n&quot;);
	}




	if ( type_req == TYPE_HTML ){
		fprintf(ss,&quot;&lt;/BODY&gt;\n&quot;);
		fflush(ss);
		shutdown(sock,SHUT_RDWR);
		fclose(ss);
		return;
	}
		
	shutdown(sock,SHUT_RDWR);
	fclose(ss);
	return;
}


void process_client(int index){
	char nprefix[256];
	long safe_fd;
	struct pollfd polly[2];
	unsigned char buffer[MAX_BUFFER];
	int pid;
	connection_index = index;
	sprintf(nprefix,&quot;%s IDX:%d [%s:%d] [%s]&quot;,prefix,index,CCON.source,CCON.port,CSERVER.cmdline);
	strcpy(prefix,nprefix);
	// logger(prefix,&quot;STARTING\n&quot;);

	
	{
		struct sigaction act;
		bzero(&amp;act,sizeof(act));
		act.sa_sigaction = &amp;slave_reaper;
		act.sa_flags = SA_SIGINFO | SA_RESTART;
		sigaction(SIGCHLD,&amp;act,NULL);
		// signal(SIGCHLD,server_reaper);
	}
	// logger(prefix,&quot;About to start: [%s]\n&quot;,CSERVER.cmdline);
	if ( (pid = fork()) == 0 ){
		char **pp;
		char *cmd;
		char *prg;
		char *ptr;
		int args;
		pp = NULL;

		if ( strncmp(CSERVER.cmdline,&quot;ADMIN&quot;,5) == 0 ){
			char pwd[128];
			ptr = &amp;(CSERVER.cmdline)[5];
			while ( *ptr &amp;&amp; ( *ptr == &#039; &#039; || *ptr == &#039;\t&#039; )) ptr++;
			strcpy(pwd,ptr);
			ptr = &amp;pwd[strlen(pwd)-1];
			while ( ptr &gt; pwd &amp;&amp; ( *ptr == &#039; &#039; || *ptr == &#039;\t&#039; || *ptr == &#039;\r&#039; || *ptr == &#039;\n&#039; )) ptr--;
			strcat(prefix,&quot;{ADMIN}&quot;);
			call_webserver(CCON.sock,pwd);
			exit(0);
		}


		cmd = strdup(CSERVER.cmdline);
		args = 0;
		while ( (ptr = strtok(cmd,&quot; \t\r\n&quot;)) != NULL ){
			cmd = NULL;
			if ( args == 0 ){
				prg = strdup(ptr);	
			}
			pp = (char **)realloc(pp,sizeof(char *) * (args+1));
			pp[args++] = strdup(ptr);
			pp[args] = NULL;
		}
		logger(prefix,&quot;Will execute [%s] with %d args PID: %d\n&quot;,prg,args,getpid());
		dup2(CCON.sock, fileno(stdin));
		dup2(CCON.sock, fileno(stdout));
		execvp(prg,pp);
		logger(prefix,&quot;Cannot execute: [%s]\n&quot;,prg);
		exit(9);
		
	} 
	CCON.cpid = pid;



	/*	
	// Make everything non-blocking
	safe_fd = fcntl(CCON.sock,F_GETFL);
	safe_fd |= O_NONBLOCK;
	if ( fcntl(CCON.sock,F_SETFL,safe_fd) &lt; 0){
		logger(prefix,&quot;Cannot set socket non-blocking!\n&quot;);
		kill(CCON.cpid,9);
		exit(0);
	}
	*/

	while(1){
		int received;
		int fat_timeout;
		struct timespec tmo_p;
		sigset_t mask;

		polly[0].fd     = CCON.sock;
#ifdef POLLRDHUP
		polly[0].events =  POLLHUP | POLLERR | POLLRDHUP;
#else
		polly[0].events =  POLLHUP | POLLERR;
#endif
		if ( CSERVER.data_timeout &gt; 0 ) polly[0].events |=  POLLIN;

		if ( CSERVER.timeout &lt; 0  ){
			fat_timeout = CSERVER.data_timeout;
		} else {
			if ( CSERVER.data_timeout &lt; 0 ){
				fat_timeout = CSERVER.timeout;
			} else {
				if ( CSERVER.data_timeout &lt; CSERVER.timeout ){
					fat_timeout = CSERVER.data_timeout;
				} else {
					fat_timeout = CSERVER.timeout;
				}
			}
		}
		// logger(prefix,&quot;POLLING...\n&quot;);	
		if ( fat_timeout &lt;= 0 ){
			tmo_p.tv_sec = 31536000;
		} else {
			tmo_p.tv_sec = fat_timeout;
		}
		tmo_p.tv_nsec = 0;
		sigemptyset(&amp;mask);
		// sigaddset(&amp;mask,SIGTERM);
		// sigaddset(&amp;mask,SIGHUP);
		// sigaddset(&amp;mask,SIGCHLD);
		sigaddset(&amp;mask,SIGPIPE);
		sigaddset(&amp;mask,SIGINT);
		sigaddset(&amp;mask,SIGUSR1);
		sigaddset(&amp;mask,SIGUSR2);
		/* if ( (received =  ppoll(polly,1,&amp;tmo_p,&amp;mask)) &lt; 1 ) */
#ifdef IPV6_V6ONLY
		if ( (received =  ppoll(polly,1,&amp;tmo_p,NULL)) &lt; 1 ){
#else
		if ( (received =  poll(polly,1,tmo_p.tv_sec * 1000)) &lt; 1 ){
#endif
		
			if ( CSERVER.timeout &gt; 0 &amp;&amp; (CSERVER.timeout + CCON.created) &lt;= time(NULL) ){
				logger(prefix,&quot;Connection ran into timeout (%d Seconds)\n&quot;, CSERVER.timeout);
				if ( CCON.cpid ) kill(CCON.cpid,9);
				exit(0);
			} else { // A data-timeout
				if ( CSERVER.data_timeout &gt; 0 ){
					if ( (CCON.lastin + CSERVER.data_timeout) &lt;= time(NULL) ){
						logger(prefix,&quot;Connection canceled because of data-timeout (%d Seconds) [Total-Session-time: %d]\n&quot;, CSERVER.data_timeout,time(NULL) - CCON.created);
						close(CCON.sock);
						if ( CCON.cpid ) m_kill(CCON.cpid,9);
						exit(0);
					}
				}
			}
		}
#ifdef POLLRDHUP		
		/*
		logger(prefix,&quot;POLL[SOCKET]: [%s,%s,%s,%s,%s]\n&quot;,
			polly[0].revents &amp; POLLNVAL ? &quot;NVAL&quot; : &quot;&quot;,
			polly[0].revents &amp; POLLIN ? &quot;IN&quot; : &quot;&quot;,
			polly[0].revents &amp; POLLHUP ? &quot;HUP&quot; : &quot;&quot;,
			polly[0].revents &amp; POLLRDHUP ? &quot;RDHUP&quot; : &quot;&quot;,
			polly[0].revents &amp; POLLERR ? &quot;ERR&quot; : &quot;&quot;);
		*/
		if ( (polly[0].revents &amp; POLLHUP) || (polly[0].revents &amp; POLLRDHUP) ){
				logger(prefix,&quot;SOCKET finished connection (%d Seconds active) Socket-ID: %d\n&quot;, time(NULL) - CCON.created,CCON.sock);
				close(CCON.sock);
				if ( CCON.cpid ) m_kill(CCON.cpid,9);
				exit(0);
		}
#else
		/*
		logger(prefix,&quot;POLL[SOCKET]: [%s,%s,%s,%s]\n&quot;,
			polly[0].revents &amp; POLLNVAL ? &quot;NVAL&quot; : &quot;&quot;,
			polly[0].revents &amp; POLLIN ? &quot;IN&quot; : &quot;&quot;,
			polly[0].revents &amp; POLLHUP ? &quot;HUP&quot; : &quot;&quot;,
			polly[0].revents &amp; POLLERR ? &quot;ERR&quot; : &quot;&quot;);
		*/
		if ( (polly[0].revents &amp; POLLHUP)  ){
				logger(prefix,&quot;SOCKET finished connection (%d Seconds active) Socket-ID: %d\n&quot;, time(NULL) - CCON.created,CCON.sock);
				close(CCON.sock);
				if ( CCON.cpid ) m_kill(CCON.cpid,9);
				exit(0);
		}
#endif
		if ( (polly[0].revents &amp; POLLIN) ){
			CCON.lastin = time(NULL);
		}
		if ( CSERVER.data_timeout &gt; 0 ){
			if ( (CCON.lastin + CSERVER.data_timeout) &lt;= time(NULL) ){
				logger(prefix,&quot;Connection canceled because of data-timeout (%d Seconds) [Total-Session-time: %d]\n&quot;, CSERVER.data_timeout,time(NULL) - CCON.created);
				close(CCON.sock);
				if ( CCON.cpid ) m_kill(CCON.cpid,9);
				exit(0);
			}
		}
	}	
	close(CCON.sock);
	exit(0);	
}



void start_server(int index){
	int sock;
	int on;
	struct sockaddr *saddr;
	int saddr_len;
	struct sockaddr_in sock4;
	struct sockaddr_in6 sock6;

	global_index = index;
	servlist = (struct server *)shmat(shm_id,NULL,0);
	if ( servlist == NULL ){
		logger(&quot;MAIN&quot;,&quot;FATAL(%s:%d) Cannot attach shared-memory\n&quot;,__FILE__,__LINE__);
		exit(3);
	}
	sprintf(prefix,&quot;[%d] S-PORT %d [%s]&quot;,index,servlist[index].port,servlist[index].family == AF_INET6 ? &quot;IPv6&quot; : &quot;IPv4&quot;);
	logger(prefix,&quot;Initializing...\n&quot;);
	sock = socket(CSERVER.family,SOCK_STREAM,0);
	if ( sock &lt; 0 ){
		logger	(prefix,&quot;FATAL(%s:%d) Cannot create socket\n&quot;,__FILE__,__LINE__);
		exit(3);
	}
	on = 1;
	if ( setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&amp;on,sizeof(on)) &lt; 0 ){
		logger	(prefix,&quot;FATAL(%s:%d) Cannot SO_REUSEADDR socket\n&quot;,__FILE__,__LINE__);
		exit(3);
	}
	if ( CSERVER.family == AF_INET ){
		sock4.sin_family = AF_INET;
		sock4.sin_addr.s_addr = INADDR_ANY;
		sock4.sin_port = htons(CSERVER.port);
		saddr = (struct sockaddr *)&amp;sock4;
		saddr_len = sizeof(sock4);
	} else {
#ifdef IPV6_V6ONLY
		if ( setsockopt(sock,IPPROTO_IPV6, IPV6_V6ONLY,&amp;on,sizeof(on)) &lt; 0 ){
			logger	(prefix,&quot;FATAL(%s:%d) Cannot IPV6_V6ONLY socket\n&quot;,__FILE__,__LINE__);
			exit(3);
		}
#endif
		sock6.sin6_family = AF_INET6;
		sock6.sin6_port   = htons(CSERVER.port);
		sock6.sin6_addr   = in6addr_any;
		saddr = (struct sockaddr *)&amp;sock6;
		saddr_len = sizeof(sock6);
	}	
	if ( bind(sock,saddr,saddr_len) &lt; 0 ){
		logger	(prefix,&quot;FATAL(%s:%d) Cannot bind socket\n&quot;,__FILE__,__LINE__);
		exit(3);
	}
	listen(sock,MAX_BACKLOG);
	semid2 = semget(INETD_KEY2 + global_index,1,0);
	if ( semid2 &gt;= 0 ) semctl(semid2,IPC_RMID,0);
	semid2 = semget(INETD_KEY2 + global_index,1,0600|IPC_CREAT);
	semctl(semid2,0,SETVAL,1);
	semid = semget(INETD_KEY + global_index,1,0);
	if ( semid &gt;= 0 ) semctl(semid,IPC_RMID,0);
	semid = semget(INETD_KEY + global_index,1,0600|IPC_CREAT);
	semctl(semid,0,SETVAL,1);
	sem_set(semid,CSERVER.max_conns-1);	
	msg_id = msgget(INETD_KEY + global_index,0);
	if ( msg_id &gt;= 0 ) msgctl(msg_id,IPC_RMID,0);
	msg_id = msgget(INETD_KEY + global_index,IPC_CREAT | 0600);
	signal(SIGCHLD,SIG_IGN);
	if ( fork() == 0 ){
		server_reaper_process();
		exit(0);
	}
	{
		struct sigaction act;
		bzero(&amp;act,sizeof(act));
		act.sa_sigaction = &amp;server_reaper;
		act.sa_flags = SA_SIGINFO | SA_RESTART;
		sigaction(SIGCHLD,&amp;act,NULL);
		// signal(SIGCHLD,server_reaper);
	}
	while ( 1 ){
		sem_lock(semid);
		if ( CSERVER.connections &gt; CSERVER.max_conns ){
			logger(prefix,&quot;Cannot  handle connection semaphore (Goint to accept %d/%d)\n&quot;,CSERVER.connections+1, CSERVER.max_conns);
			continue;
		}
		{
			int newsock;
			struct sockaddr from_addr;
			int from_addr_len;	
			if ( CSERVER.family == AF_INET )
				from_addr_len = sizeof(sock4);
			else	
				from_addr_len = sizeof(sock6);
			newsock = accept(sock,&amp;from_addr,&amp;from_addr_len);
			if ( newsock &gt; 0 ){
				char ip_name[256];
				char ips_name[256];
				int  ip_port;
				int  ips_port;
				int pid;
				int i;
				if ( CSERVER.family == AF_INET ){
					struct sockaddr_in *s;	
					s = (struct sockaddr_in *)&amp;from_addr;
					ip_port = ntohs(s-&gt;sin_port);
					sprintf(ip_name,&quot;%s&quot;,inet_ntoa(s-&gt;sin_addr));
				} else {
					struct sockaddr_in6 *s;	
					s = (struct sockaddr_in6 *)&amp;from_addr;
					ip_port = ntohs(s-&gt;sin6_port);
					inet_ntop(AF_INET6,&amp;(s-&gt;sin6_addr),ip_name,256);	
				}
				logger(prefix,&quot;New connection from: [%s:%d]\n&quot;,ip_name,ip_port);
				// Find slot :-)
				sem_lock(semid2);	
				for ( i = 0; i &lt; MAX_CONNS; i++ ){
					if ( CSERVER.co[i].port == 0 ) break;
				}
				if ( i == MAX_CONNS ){ // We have to kick out the connection
					sem_unlock(semid2);	
					logger(prefix,&quot;System-Limit reached (more than %d connections) --&gt; closing connection\n&quot;,MAX_CONNS);
					close(newsock);
					continue;
				}
				CSERVER.co[i].sock      = newsock;
				CSERVER.co[i].port      = ip_port;
				CSERVER.co[i].created   = time(NULL);
				CSERVER.connections++;
				CSERVER.total_count++;
				if ( CSERVER.family == AF_INET ) {
					struct sockaddr_in _s;	
					struct sockaddr_in *s;	
					int s_len;
					s_len = sizeof(_s);
					getsockname(newsock,(struct sockaddr *)&amp;_s,&amp;s_len);
					s = (struct sockaddr_in *)&amp;_s;
					ips_port = ntohs(s-&gt;sin_port);
					sprintf(ips_name,&quot;%s&quot;,inet_ntoa(s-&gt;sin_addr));
				}
				if ( CSERVER.family == AF_INET6 ) {
					struct sockaddr_in6 _s;	
					struct sockaddr_in6 *s;	
					int s_len;
					s_len = sizeof(_s);
					getsockname(newsock,(struct sockaddr *)&amp;_s,&amp;s_len);
					s = (struct sockaddr_in6 *)&amp;_s;
					ips_port = ntohs(s-&gt;sin6_port);
					inet_ntop(AF_INET6,&amp;(s-&gt;sin6_addr),ips_name,256);	
				}
				strcpy(CSERVER.co[i].target,ips_name);
				CSERVER.co[i].t_port      = ips_port;
				strcpy(CSERVER.co[i].source,ip_name);
				sem_unlock(semid2);	
				pid = fork();
				if ( pid == 0 ){
					process_client(i);
					exit(0);
				} else {
					close(newsock);
					CSERVER.co[i].pid = pid;
				}
			} else {
				logger(prefix,&quot;ACCEPT FAILED! (%s)\n&quot;,strerror(errno));
			}
			garbage_collect();
		}
		
	}

	exit(0);
}

void terminator(){
	int i,j;
	logger(prefix,&quot;*** TERMINATOR Terminating all childs...\n&quot;);
	for ( i  = 0; i &lt; entries; i++ ){
		for ( j = 0; j &lt; MAX_CONNS; j++ ){
			if ( servlist[i].co[j].port != 0 &amp;&amp; servlist[i].co[j].cpid != 0 ){ 
				m_kill(servlist[i].co[j].cpid,SIGTERM); 
				m_kill(servlist[i].co[j].cpid,SIGHUP); 
				m_kill(servlist[i].co[j].cpid,SIGKILL); 
				logger(prefix,&quot;*** TERMINATOR Killed connection: [%s]:%d &lt;--&gt; [%s]:%d PID: %d\n&quot;,servlist[i].co[j].source,servlist[i].co[j].port, servlist[i].co[j].target, servlist[i].co[j].t_port, servlist[i].co[j].cpid);
				if ( servlist[i].co[j].pid != 0 ){
					m_kill(servlist[i].co[j].pid,SIGTERM); 
				}
			}
		}	
	}
	exit(0);
}


void main(int argc, char **argv){
        FILE *fp;
        char buf[1024];
	int idx;
	int i;
	int semmel;
	int tftp_pid;
	int dhcp_pid;
	int config_lines;

	GIX_INETD_UPDATESERVER = DEFAULT_GIX_INETD_UPDATESERVER;



	ether_bcast[0] = 0xFF;
	ether_bcast[1] = 0xFF;
	ether_bcast[2] = 0xFF;
	ether_bcast[3] = 0xFF;
	ether_bcast[4] = 0xFF;
	ether_bcast[5] = 0xFF;
	
	if ( gethostname(my_hostname,1024) &lt; 0 )strcpy(my_hostname,&quot;unknown&quot;);



	mkdir(&quot;/big/GIX_INETD/logs&quot;,00777);
	mkdir(&quot;/big/GIX_INETD/conf&quot;,00777);
	mkdir(&quot;/big/GIX_INETD/run&quot;,00777);

	// Cleanup a little bit :-)
	for ( i = 0; i &lt; 8192; i++ ){
		semmel = semget(INETD_KEY + i,1,0);
		if ( semmel &gt;= 0 ) semctl(semmel,IPC_RMID,0);
		semmel = semget(INETD_KEY2 + i,1,0);
		if ( semmel &gt;= 0 ) semctl(semmel,IPC_RMID,0);
		semmel = msgget(INETD_KEY + i,0);
		if ( semmel &gt;= 0 ) msgctl(semmel,IPC_RMID,0);
	}
	semmel = shmget(INETD_KEY,0,0);
	if ( semmel &gt;= 0 ) shmctl(semmel,IPC_RMID,0);

	semmel = shmget(INETD_OPTIONS,0,0);
	if ( semmel &gt;= 0 ) shmctl(semmel,IPC_RMID,0);


	strcpy(prefix,&quot;MAIN&quot;);

	logger(prefix,&quot;Server starting at: [%s]...delaying for 4 seconds\n&quot;,my_hostname);
	sleep(4); // Wait a little bit...to avoid respawn
	logger(prefix,&quot;Starting up now\n&quot;);

	if_count = get_interfaces(&amp;if_config);
	for ( i = 0; i &lt; if_count; i++ ){
		logger(prefix,&quot;[%d] [%s] --&gt; [%s]\n&quot;,i,if_config[i].ethname,if_config[i].addr);
	}
	
	
	shmid_options = shmget(INETD_OPTIONS,sizeof(struct gix_inetd_options),0600|IPC_CREAT);
	if ( shmid_options &lt; 0 ){
		logger(prefix,&quot;FATAL(%s:%d) Cannot allocate shared-memory\n&quot;,__FILE__,__LINE__);
		exit(0);
	}
	gix_options = (struct gix_inetd_options *)shmat(shmid_options,NULL,0);
	if ( gix_options == NULL ){
		logger(prefix,&quot;FATAL(%s:%d) Cannot attach shared-memory\n&quot;,__FILE__,__LINE__);
		exit(0);
	}


        fp = fopen(CONFIG_FILE,&quot;r&quot;);
        if ( fp == NULL ){
                logger(prefix,&quot;%s: Cannot open &#039;%s&#039;\n&quot;,argv[0],CONFIG_FILE);
                exit(2);
        }
        entries = 0;
        while ( fgets(buf,1024,fp) != NULL ){
		if ( buf[0] == &#039;[&#039; ) continue;
		if ( strlen(buf) &lt; 4 || buf[0] == &#039;#&#039; || buf[0] == &#039;;&#039; ) continue;
                entries++;
        }
        rewind(fp);
	shm_id = shmget(INETD_KEY,0,0);
	if ( shm_id &gt;= 0 ){
		shmctl(shm_id,IPC_RMID,0);
	}
	shm_id = shmget(INETD_KEY,sizeof(struct server) * (entries *2),0600|IPC_CREAT);
	if ( shm_id &lt; 0 ){
		logger(prefix,&quot;FATAL(%s:%d) Cannot allocate shared-memory\n&quot;,__FILE__,__LINE__);
		exit(0);
	}
	servlist = (struct server *)shmat(shm_id,NULL,0);
	if ( servlist == NULL ){
		logger(prefix,&quot;FATAL(%s:%d) Cannot attach shared-memory\n&quot;,__FILE__,__LINE__);
		exit(0);
	}
	bzero((void *)servlist,sizeof(struct server) * entries * 2);
	bzero((void *)gix_options,sizeof(struct gix_inetd_options));
	idx = 0;
	config_lines = 0;
	while ( fgets(buf,1024,fp) != NULL ){
		int port;
		int max_conns;
		int timeout;
		int data_timeout;
		char *ptr;
		char cmdline[1024];
		config_lines++;



		if ( strncasecmp(buf,&quot;[HAVEOWNDNS=&quot;,strlen(&quot;[HAVEOWNDNS=&quot;)) == 0 ){
			char *ptr;
			ptr = &amp;buf[strlen(&quot;[HAVEOWNDNS=&quot;)];
			strcpy(gix_options-&gt;have_own_dns,ptr);
			ptr = gix_options-&gt;have_own_dns;
			while ( *ptr &amp;&amp; *ptr != &#039;]&#039; ) ptr++;
			*ptr = &#039;\0&#039;;
			continue;			
		} 


		if ( strncmp(buf,&quot;[UPDATE_SERVER=&quot;,strlen(&quot;[UPDATE_SERVER=&quot;)) == 0 ){
			char *ptr;
			ptr = &amp;buf[strlen(&quot;[UPDATE_SERVER=&quot;)];
			GIX_INETD_UPDATESERVER = strdup(ptr);
			ptr = GIX_INETD_UPDATESERVER;
			while ( *ptr &amp;&amp; *ptr != &#039;]&#039; ) ptr++;
			*ptr = &#039;\0&#039;;
			continue;			
		}

		if ( strncmp(buf,&quot;[DHCP=yes]&quot;,strlen(&quot;[DHCP=yes]&quot;)) == 0 ){
			gix_options-&gt;dhcp_enabled = 1;
			logger(prefix,&quot;DHCP--&gt;ENABLED\n&quot;);
			continue;
		}
		if ( strncmp(buf,&quot;[DHCP_IP6_PORT_OUT=&quot;,strlen(&quot;[DHCP_IP6_PORT_OUT=&quot;)) == 0 ){
			char interface[256];
			int idx, i_index;
			int port;
			ptr = &amp;buf[strlen(&quot;[DHCP_IP6_PORT_OUT=&quot;)];
			strcpy(interface,ptr);
			ptr = interface;
			while ( *ptr &amp;&amp; *ptr != &#039;:&#039; ) ptr++;
			if ( *ptr != &#039;:&#039; ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d)\n&quot;,config_lines);
				continue;
			}
			*ptr = &#039;\0&#039;;
			ptr++;
			while ( *ptr &amp;&amp; isspace(*ptr) ) ptr++;
			port = atoi(ptr);
			if ( port &lt; 1 || port &gt; 32767){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) Bad Port\n&quot;,config_lines);
				continue;
			}
			for ( i_index = 0; i_index &lt; if_count; i_index++ ){
				if ( strcmp(interface,if_config[i_index].ethname) == 0 ) break;
			}
			if ( i_index == if_count ){
				logger(prefix,&quot;FATAL: Interface [%s] does not exist!\n&quot;,interface);
				continue;
			}
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_interfaces &amp;&amp; idx &lt; MAX_DHCP_INTERFACES; idx++ ){
				if ( gix_options-&gt;dhcp_interface[idx].index == i_index ) break;
			}
			if ( idx &gt;= MAX_DHCP_INTERFACES ){
				logger(prefix,&quot;WARNING: Error in config-file (Line: %d) --&gt; Too many interfaces defined (Max: %d)n&quot;,config_lines,MAX_DHCP_INTERFACES);
				continue;
			}
			if ( idx == gix_options-&gt;dhcp_interfaces ){
				gix_options-&gt;dhcp_interface[idx].index = i_index;
				init_defaults_dhcp(&amp;gix_options-&gt;dhcp_interface[idx]);
				gix_options-&gt;dhcp_interfaces++;
			} 
			gix_options-&gt;dhcp_interface[idx].ip6_port_out = (unsigned short) port;
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;IP6_PORT_OUT Interface: [%s](%d), PORT: [%d] Interface-Index: [%d/%d]\n&quot;,if_config[i_index].ethname,i_index,port,idx,gix_options-&gt;dhcp_interfaces);
#endif
			continue;
		
		}
		if ( strncmp(buf,&quot;[DHCP_IP6_PORT_IN=&quot;,strlen(&quot;[DHCP_IP6_PORT_IN=&quot;)) == 0 ){
			char interface[256];
			int idx, i_index;
			int port;
			ptr = &amp;buf[strlen(&quot;[DHCP_IP6_PORT_IN=&quot;)];
			strcpy(interface,ptr);
			ptr = interface;
			while ( *ptr &amp;&amp; *ptr != &#039;:&#039; ) ptr++;
			if ( *ptr != &#039;:&#039; ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d)\n&quot;,config_lines);
				continue;
			}
			*ptr = &#039;\0&#039;;
			ptr++;
			while ( *ptr &amp;&amp; isspace(*ptr) ) ptr++;
			port = atoi(ptr);
			if ( port &lt; 1 || port &gt; 32767){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) Bad Port\n&quot;,config_lines);
				continue;
			}
			for ( i_index = 0; i_index &lt; if_count; i_index++ ){
				if ( strcmp(interface,if_config[i_index].ethname) == 0 ) break;
			}
			if ( i_index == if_count ){
				logger(prefix,&quot;FATAL: Interface [%s] does not exist!\n&quot;,interface);
				continue;
			}
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_interfaces &amp;&amp; idx &lt; MAX_DHCP_INTERFACES; idx++ ){
				if ( gix_options-&gt;dhcp_interface[idx].index == i_index ) break;
			}
			if ( idx &gt;= MAX_DHCP_INTERFACES ){
				logger(prefix,&quot;WARNING: Error in config-file (Line: %d) --&gt; Too many interfaces defined (Max: %d)n&quot;,config_lines,MAX_DHCP_INTERFACES);
				continue;
			}
			if ( idx == gix_options-&gt;dhcp_interfaces ){
				gix_options-&gt;dhcp_interface[idx].index = i_index;
				init_defaults_dhcp(&amp;gix_options-&gt;dhcp_interface[idx]);
				gix_options-&gt;dhcp_interfaces++;
			} 
			gix_options-&gt;dhcp_interface[idx].ip6_port_in = (unsigned short) port;
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;IP6_PORT_IN Interface: [%s](%d), PORT: [%d] Interface-Index: [%d/%d]\n&quot;,if_config[i_index].ethname,i_index,port,idx,gix_options-&gt;dhcp_interfaces);
#endif
			continue;
		
		}
		if ( strncmp(buf,&quot;[DHCP_IP_PORT_OUT=&quot;,strlen(&quot;[DHCP_IP_PORT_OUT=&quot;)) == 0 ){
			char interface[256];
			int idx, i_index;
			int port;
			ptr = &amp;buf[strlen(&quot;[DHCP_IP_PORT_OUT=&quot;)];
			strcpy(interface,ptr);
			ptr = interface;
			while ( *ptr &amp;&amp; *ptr != &#039;:&#039; ) ptr++;
			if ( *ptr != &#039;:&#039; ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d)\n&quot;,config_lines);
				continue;
			}
			*ptr = &#039;\0&#039;;
			ptr++;
			while ( *ptr &amp;&amp; isspace(*ptr) ) ptr++;
			port = atoi(ptr);
			if ( port &lt; 1 || port &gt; 32767){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) Bad Port\n&quot;,config_lines);
				continue;
			}
			for ( i_index = 0; i_index &lt; if_count; i_index++ ){
				if ( strcmp(interface,if_config[i_index].ethname) == 0 ) break;
			}
			if ( i_index == if_count ){
				logger(prefix,&quot;FATAL: Interface [%s] does not exist!\n&quot;,interface);
				continue;
			}
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_interfaces &amp;&amp; idx &lt; MAX_DHCP_INTERFACES; idx++ ){
				if ( gix_options-&gt;dhcp_interface[idx].index == i_index ) break;
			}
			if ( idx &gt;= MAX_DHCP_INTERFACES ){
				logger(prefix,&quot;WARNING: Error in config-file (Line: %d) --&gt; Too many interfaces defined (Max: %d)n&quot;,config_lines,MAX_DHCP_INTERFACES);
				continue;
			}
			if ( idx == gix_options-&gt;dhcp_interfaces ){
				gix_options-&gt;dhcp_interface[idx].index = i_index;
				init_defaults_dhcp(&amp;gix_options-&gt;dhcp_interface[idx]);
				gix_options-&gt;dhcp_interfaces++;
			} 
			gix_options-&gt;dhcp_interface[idx].ip_port_out = (unsigned short) port;
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;IP_PORT_OUT Interface: [%s](%d), PORT: [%d] Interface-Index: [%d/%d]\n&quot;,if_config[i_index].ethname,i_index,port,idx,gix_options-&gt;dhcp_interfaces);
#endif
			continue;
		
		}
		if ( strncmp(buf,&quot;[DHCP_IP_DHCP_OPTS=&quot;,strlen(&quot;[DHCP_IP_DHCP_OPTS=&quot;)) == 0 ){
			int idx, i_index;
			char interface[256];
			int t_optlen;
			u_int8_t t_optlist[256];
			char temp_optlist[2048];
			ptr = &amp;buf[strlen(&quot;[DHCP_IP_PORT_IN=&quot;)];
			strcpy(interface,ptr);
			ptr = interface;
			while ( *ptr &amp;&amp; *ptr != &#039;:&#039; ) ptr++;
			if ( *ptr != &#039;:&#039; ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d)\n&quot;,config_lines);
				continue;
			}
			for ( i_index = 0; i_index &lt; if_count; i_index++ ){
				if ( strcmp(interface,if_config[i_index].ethname) == 0 ) break;
			}
			if ( i_index == if_count ){
				logger(prefix,&quot;FATAL: Interface [%s] does not exist!\n&quot;,interface);
				continue;
			}
			while ( *ptr &amp;&amp; (isspace(*ptr) || *ptr == &#039;:&#039;) ) ptr++;
			t_optlen = 0;
			strcpy(temp_optlist,&quot;&quot;);
			while ( *ptr &amp;&amp; *ptr != &#039;]&#039; ){
				t_optlist[t_optlen++] = (u_int8_t)atoi(ptr);
				sprintf(&amp;temp_optlist[strlen(temp_optlist)],&quot;%d,&quot;,(int)t_optlist[t_optlen-1]);
				while (*ptr &amp;&amp; *ptr != &#039;,&#039; &amp;&amp; *ptr != &#039;]&#039; ) ptr++;
				if ( *ptr != &#039;,&#039; ) break;
				ptr++; // Next option :-)
			}

			if ( t_optlen == 0 ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d)...please specify at least 1 option!\n&quot;,config_lines);
				continue;
			}
			
			
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_interfaces &amp;&amp; idx &lt; MAX_DHCP_INTERFACES; idx++ ){
				if ( gix_options-&gt;dhcp_interface[idx].index == i_index ) break;
			}
			if ( idx &gt;= MAX_DHCP_INTERFACES ){
				logger(prefix,&quot;WARNING: Error in config-file (Line: %d) --&gt; Too many interfaces defined (Max: %d)n&quot;,config_lines,MAX_DHCP_INTERFACES);
				continue;
			}
			if ( idx == gix_options-&gt;dhcp_interfaces ){
				gix_options-&gt;dhcp_interface[idx].index = i_index;
				init_defaults_dhcp(&amp;gix_options-&gt;dhcp_interface[idx]);
				gix_options-&gt;dhcp_interfaces++;
			} 
			memcpy(gix_options-&gt;dhcp_interface[idx].ip_default_optlist,t_optlist,t_optlen);
			gix_options-&gt;dhcp_interface[idx].ip_default_optlist_len = t_optlen;
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;DHCP_OPTIONS Interface: [%s](%d),OPTLIST: [%s] (%d Options) Interface-Index: [%d/%d]\n&quot;,if_config[i_index].ethname,i_index,temp_optlist,t_optlen,idx,gix_options-&gt;dhcp_interfaces);
#endif
			continue;
		}
		if ( strncmp(buf,&quot;[DHCP_IP_PORT_IN=&quot;,strlen(&quot;[DHCP_IP_PORT_IN=&quot;)) == 0 ){
			char interface[256];
			int idx, i_index;
			int port;
			ptr = &amp;buf[strlen(&quot;[DHCP_IP_PORT_IN=&quot;)];
			strcpy(interface,ptr);
			ptr = interface;
			while ( *ptr &amp;&amp; *ptr != &#039;:&#039; ) ptr++;
			if ( *ptr != &#039;:&#039; ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d)\n&quot;,config_lines);
				continue;
			}
			*ptr = &#039;\0&#039;;
			ptr++;
			while ( *ptr &amp;&amp; isspace(*ptr) ) ptr++;
			port = atoi(ptr);
			if ( port &lt; 1 || port &gt; 32767){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) Bad Port\n&quot;,config_lines);
				continue;
			}
			for ( i_index = 0; i_index &lt; if_count; i_index++ ){
				if ( strcmp(interface,if_config[i_index].ethname) == 0 ) break;
			}
			if ( i_index == if_count ){
				logger(prefix,&quot;FATAL: Interface [%s] does not exist!\n&quot;,interface);
				continue;
			}
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_interfaces &amp;&amp; idx &lt; MAX_DHCP_INTERFACES; idx++ ){
				if ( gix_options-&gt;dhcp_interface[idx].index == i_index ) break;
			}
			if ( idx &gt;= MAX_DHCP_INTERFACES ){
				logger(prefix,&quot;WARNING: Error in config-file (Line: %d) --&gt; Too many interfaces defined (Max: %d)n&quot;,config_lines,MAX_DHCP_INTERFACES);
				continue;
			}
			if ( idx == gix_options-&gt;dhcp_interfaces ){
				gix_options-&gt;dhcp_interface[idx].index = i_index;
				init_defaults_dhcp(&amp;gix_options-&gt;dhcp_interface[idx]);
				gix_options-&gt;dhcp_interfaces++;
			} 
			gix_options-&gt;dhcp_interface[idx].ip_port_in = (unsigned short) port;
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;IP_PORT_IN Interface: [%s](%d), PORT: [%d] Interface-Index: [%d/%d]\n&quot;,if_config[i_index].ethname,i_index,port,idx,gix_options-&gt;dhcp_interfaces);
#endif
			continue;
		
		}
		if ( strncmp(buf,&quot;[DHCP_IP_NETMASK=&quot;,strlen(&quot;[DHCP_IP_NETMASK=&quot;)) == 0 ){
			char interface[256];
			struct sockaddr_in *retval;
			int idx, i_index;
			char domain[256];
			ptr = &amp;buf[strlen(&quot;[DHCP_IP_NETMASK=&quot;)];
			strcpy(interface,ptr);
			ptr = interface;
			while ( *ptr &amp;&amp; *ptr != &#039;:&#039; ) ptr++;
			if ( *ptr != &#039;:&#039; ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d)\n&quot;,config_lines);
				continue;
			}
			*ptr = &#039;\0&#039;;
			ptr++;
			while ( *ptr &amp;&amp; isspace(*ptr) ) ptr++;
			strcpy(domain,ptr);
			ptr = &amp;domain[strlen(domain)-1];
			while ( ptr &gt; domain &amp;&amp;  ( *ptr == &#039;\r&#039; || *ptr == &#039;\n&#039; || isspace(*ptr) || *ptr == &#039;]&#039; )) ptr--;
			ptr++;
			*ptr = &#039;\0&#039;;
			if ( strlen(domain) &lt; 3 ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) Bad NETMASK\n&quot;,config_lines);
				continue;
			}
			if ( (retval = 	check_valid_ipv4(domain,DHCP_DEFAULT_PORT_IN,SOCK_DGRAM)) == NULL ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) Bad NETMASK\n&quot;,config_lines);
				continue;
			}
			for ( i_index = 0; i_index &lt; if_count; i_index++ ){
				if ( strcmp(interface,if_config[i_index].ethname) == 0 ) break;
			}
			if ( i_index == if_count ){
				logger(prefix,&quot;FATAL: Interface [%s] does not exist!\n&quot;,interface);
				continue;
			}
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_interfaces &amp;&amp; idx &lt; MAX_DHCP_INTERFACES; idx++ ){
				if ( gix_options-&gt;dhcp_interface[idx].index == i_index ) break;
			}
			if ( idx &gt;= MAX_DHCP_INTERFACES ){
				logger(prefix,&quot;WARNING: Error in config-file (Line: %d) --&gt; Too many interfaces defined (Max: %d)n&quot;,config_lines,MAX_DHCP_INTERFACES);
				continue;
			}
			if ( idx == gix_options-&gt;dhcp_interfaces ){
				gix_options-&gt;dhcp_interface[idx].index = i_index;
				init_defaults_dhcp(&amp;gix_options-&gt;dhcp_interface[idx]);
				gix_options-&gt;dhcp_interfaces++;
			} 
			memcpy(&amp;gix_options-&gt;dhcp_interface[idx].ip_netmask,retval,sizeof(struct sockaddr_in));
			inet_ntop(AF_INET,&amp;(gix_options-&gt;dhcp_interface[idx].ip_netmask.sin_addr),domain,256);
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;IP_NETMASK Interface: [%s](%d), NETMASK: [%s] Interface-Index: [%d/%d]\n&quot;,if_config[i_index].ethname,i_index,domain,idx,gix_options-&gt;dhcp_interfaces);
#endif
			continue;
		
		}
		if ( strncmp(buf,&quot;[DHCP_IP_BROADCAST=&quot;,strlen(&quot;[DHCP_IP_BROADCAST=&quot;)) == 0 ){
			char interface[256];
			struct sockaddr_in *retval;
			int idx, i_index;
			char domain[256];
			ptr = &amp;buf[strlen(&quot;[DHCP_IP_BROADCAST=&quot;)];
			strcpy(interface,ptr);
			ptr = interface;
			while ( *ptr &amp;&amp; *ptr != &#039;:&#039; ) ptr++;
			if ( *ptr != &#039;:&#039; ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d)\n&quot;,config_lines);
				continue;
			}
			*ptr = &#039;\0&#039;;
			ptr++;
			while ( *ptr &amp;&amp; isspace(*ptr) ) ptr++;
			strcpy(domain,ptr);
			ptr = &amp;domain[strlen(domain)-1];
			while ( ptr &gt; domain &amp;&amp;  ( *ptr == &#039;\r&#039; || *ptr == &#039;\n&#039; || isspace(*ptr) || *ptr == &#039;]&#039; )) ptr--;
			ptr++;
			*ptr = &#039;\0&#039;;
			if ( strlen(domain) &lt; 3 ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) Bad NETMASK\n&quot;,config_lines);
				continue;
			}
			if ( (retval = 	check_valid_ipv4(domain,DHCP_DEFAULT_PORT_IN,SOCK_DGRAM)) == NULL ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) Bad NETMASK\n&quot;,config_lines);
				continue;
			}
			for ( i_index = 0; i_index &lt; if_count; i_index++ ){
				if ( strcmp(interface,if_config[i_index].ethname) == 0 ) break;
			}
			if ( i_index == if_count ){
				logger(prefix,&quot;FATAL: Interface [%s] does not exist!\n&quot;,interface);
				continue;
			}
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_interfaces &amp;&amp; idx &lt; MAX_DHCP_INTERFACES; idx++ ){
				if ( gix_options-&gt;dhcp_interface[idx].index == i_index ) break;
			}
			if ( idx &gt;= MAX_DHCP_INTERFACES ){
				logger(prefix,&quot;WARNING: Error in config-file (Line: %d) --&gt; Too many interfaces defined (Max: %d)n&quot;,config_lines,MAX_DHCP_INTERFACES);
				continue;
			}
			if ( idx == gix_options-&gt;dhcp_interfaces ){
				gix_options-&gt;dhcp_interface[idx].index = i_index;
				init_defaults_dhcp(&amp;gix_options-&gt;dhcp_interface[idx]);
				gix_options-&gt;dhcp_interfaces++;
			} 
			memcpy(&amp;gix_options-&gt;dhcp_interface[idx].ip_broadcast,retval,sizeof(struct sockaddr_in));
			inet_ntop(AF_INET,&amp;(gix_options-&gt;dhcp_interface[idx].ip_broadcast.sin_addr),domain,256);
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;IP_BROADCAST Interface: [%s](%d), BROADCAST: [%s] Interface-Index: [%d/%d]\n&quot;,if_config[i_index].ethname,i_index,domain,idx,gix_options-&gt;dhcp_interfaces);
#endif
			continue;
		
		}
		if ( strncmp(buf,&quot;[DHCP_IP6_PREFIXLEN=&quot;,strlen(&quot;[DHCP_IP6_PREFIXLEN=&quot;)) == 0 ){
			char interface[256];
			int idx, i_index;
			char domain[256];
			int prefix_len;
			ptr = &amp;buf[strlen(&quot;[DHCP_IP6_PREFIXLEN=&quot;)];
			strcpy(interface,ptr);
			ptr = interface;
			while ( *ptr &amp;&amp; *ptr != &#039;:&#039; ) ptr++;
			if ( *ptr != &#039;:&#039; ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d)\n&quot;,config_lines);
				continue;
			}
			*ptr = &#039;\0&#039;;
			ptr++;
			while ( *ptr &amp;&amp; isspace(*ptr) ) ptr++;
			prefix_len = atoi(ptr);
			if ( prefix_len &lt; 0 || prefix_len &gt; 128 ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) Bad PREFIX-LEN\n&quot;,config_lines);
				continue;
			}
			for ( i_index = 0; i_index &lt; if_count; i_index++ ){
				if ( strcmp(interface,if_config[i_index].ethname) == 0 ) break;
			}
			if ( i_index == if_count ){
				logger(prefix,&quot;FATAL: Interface [%s] does not exist!\n&quot;,interface);
				continue;
			}
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_interfaces &amp;&amp; idx &lt; MAX_DHCP_INTERFACES; idx++ ){
				if ( gix_options-&gt;dhcp_interface[idx].index == i_index ) break;
			}
			if ( idx &gt;= MAX_DHCP_INTERFACES ){
				logger(prefix,&quot;WARNING: Error in config-file (Line: %d) --&gt; Too many interfaces defined (Max: %d)n&quot;,config_lines,MAX_DHCP_INTERFACES);
				continue;
			}
			if ( idx == gix_options-&gt;dhcp_interfaces ){
				gix_options-&gt;dhcp_interface[idx].index = i_index;
				init_defaults_dhcp(&amp;gix_options-&gt;dhcp_interface[idx]);
				gix_options-&gt;dhcp_interfaces++;
			} 
			gix_options-&gt;dhcp_interface[idx].ip6_prefixlen = prefix_len;
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;IP6 PREFIXLEN Interface: [%s](%d), Prefix-LEN: [%d] Interface-Index: [%d/%d]\n&quot;,if_config[i_index].ethname,i_index,prefix_len,idx,gix_options-&gt;dhcp_interfaces);
#endif
			continue;
		
		}
		if ( strncmp(buf,&quot;[DHCP_IP6_DOMAIN=&quot;,strlen(&quot;[DHCP_IP6_DOMAIN=&quot;)) == 0 ){
			char interface[256];
			int idx, i_index;
			char domain[256];
			ptr = &amp;buf[strlen(&quot;[DHCP_IP6_DOMAIN=&quot;)];
			strcpy(interface,ptr);
			ptr = interface;
			while ( *ptr &amp;&amp; *ptr != &#039;:&#039; ) ptr++;
			if ( *ptr != &#039;:&#039; ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d)\n&quot;,config_lines);
				continue;
			}
			*ptr = &#039;\0&#039;;
			ptr++;
			while ( *ptr &amp;&amp; isspace(*ptr) ) ptr++;
			strcpy(domain,ptr);
			ptr = &amp;domain[strlen(domain)-1];
			while ( ptr &gt; domain &amp;&amp;  ( *ptr == &#039;\r&#039; || *ptr == &#039;\n&#039; || isspace(*ptr) || *ptr == &#039;]&#039; )) ptr--;
			ptr++;
			*ptr = &#039;\0&#039;;
			if ( strlen(domain) &lt; 3 ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) Bad domain\n&quot;,config_lines);
				continue;
			}
			for ( i_index = 0; i_index &lt; if_count; i_index++ ){
				if ( strcmp(interface,if_config[i_index].ethname) == 0 ) break;
			}
			if ( i_index == if_count ){
				logger(prefix,&quot;FATAL: Interface [%s] does not exist!\n&quot;,interface);
				continue;
			}
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_interfaces &amp;&amp; idx &lt; MAX_DHCP_INTERFACES; idx++ ){
				if ( gix_options-&gt;dhcp_interface[idx].index == i_index ) break;
			}
			if ( idx &gt;= MAX_DHCP_INTERFACES ){
				logger(prefix,&quot;WARNING: Error in config-file (Line: %d) --&gt; Too many interfaces defined (Max: %d)n&quot;,config_lines,MAX_DHCP_INTERFACES);
				continue;
			}
			if ( idx == gix_options-&gt;dhcp_interfaces ){
				gix_options-&gt;dhcp_interface[idx].index = i_index;
				init_defaults_dhcp(&amp;gix_options-&gt;dhcp_interface[idx]);
				gix_options-&gt;dhcp_interfaces++;
			} 
			strcpy(gix_options-&gt;dhcp_interface[idx].ip6_domain,domain);
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;DOMAIN6 Interface: [%s](%d), Domain: [%s] Interface-Index: [%d/%d]\n&quot;,if_config[i_index].ethname,i_index,domain,idx,gix_options-&gt;dhcp_interfaces);
#endif
			continue;
		
		}
		if ( strncmp(buf,&quot;[DHCP_IP6_TFTPSERVER=&quot;,strlen(&quot;[DHCP_IP6_TFTPSERVER=&quot;)) == 0 ){
			char interface[256];
			int idx, i_index;
			char domain[256];
			ptr = &amp;buf[strlen(&quot;[DHCP_IP6_TFTPSERVER=&quot;)];
			strcpy(interface,ptr);
			ptr = interface;
			while ( *ptr &amp;&amp; *ptr != &#039;:&#039; ) ptr++;
			if ( *ptr != &#039;:&#039; ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d)\n&quot;,config_lines);
				continue;
			}
			*ptr = &#039;\0&#039;;
			ptr++;
			while ( *ptr &amp;&amp; isspace(*ptr) ) ptr++;
			strcpy(domain,ptr);
			ptr = &amp;domain[strlen(domain)-1];
			while ( ptr &gt; domain &amp;&amp;  ( *ptr == &#039;\r&#039; || *ptr == &#039;\n&#039; || isspace(*ptr) || *ptr == &#039;]&#039; )) ptr--;
			ptr++;
			*ptr = &#039;\0&#039;;
			if ( strlen(domain) &lt; 3 ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) Bad tftp_server\n&quot;,config_lines);
				continue;
			}
			for ( i_index = 0; i_index &lt; if_count; i_index++ ){
				if ( strcmp(interface,if_config[i_index].ethname) == 0 ) break;
			}
			if ( i_index == if_count ){
				logger(prefix,&quot;FATAL: Interface [%s] does not exist!\n&quot;,interface);
				continue;
			}
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_interfaces &amp;&amp; idx &lt; MAX_DHCP_INTERFACES; idx++ ){
				if ( gix_options-&gt;dhcp_interface[idx].index == i_index ) break;
			}
			if ( idx &gt;= MAX_DHCP_INTERFACES ){
				logger(prefix,&quot;WARNING: Error in config-file (Line: %d) --&gt; Too many interfaces defined (Max: %d)n&quot;,config_lines,MAX_DHCP_INTERFACES);
				continue;
			}
			if ( idx == gix_options-&gt;dhcp_interfaces ){
				gix_options-&gt;dhcp_interface[idx].index = i_index;
				init_defaults_dhcp(&amp;gix_options-&gt;dhcp_interface[idx]);
				gix_options-&gt;dhcp_interfaces++;
			} 
			strcpy(gix_options-&gt;dhcp_interface[idx].ip6_tftp_server,domain);
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;IP6-TFTPSERVER Interface: [%s](%d), tftp-server: [%s] Interface-Index: [%d/%d]\n&quot;,if_config[i_index].ethname,i_index,domain,idx,gix_options-&gt;dhcp_interfaces);
#endif
			continue;
		}
		if ( strncmp(buf,&quot;[DHCP_IP_TFTPSERVER=&quot;,strlen(&quot;[DHCP_IP_TFTPSERVER=&quot;)) == 0 ){
			char interface[256];
			int idx, i_index;
			char domain[256];
			ptr = &amp;buf[strlen(&quot;[DHCP_IP_TFTPSERVER=&quot;)];
			strcpy(interface,ptr);
			ptr = interface;
			while ( *ptr &amp;&amp; *ptr != &#039;:&#039; ) ptr++;
			if ( *ptr != &#039;:&#039; ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d)\n&quot;,config_lines);
				continue;
			}
			*ptr = &#039;\0&#039;;
			ptr++;
			while ( *ptr &amp;&amp; isspace(*ptr) ) ptr++;
			strcpy(domain,ptr);
			ptr = &amp;domain[strlen(domain)-1];
			while ( ptr &gt; domain &amp;&amp;  ( *ptr == &#039;\r&#039; || *ptr == &#039;\n&#039; || isspace(*ptr) || *ptr == &#039;]&#039; )) ptr--;
			ptr++;
			*ptr = &#039;\0&#039;;
			if ( strlen(domain) &lt; 3 ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) Bad tftp_server\n&quot;,config_lines);
				continue;
			}
			for ( i_index = 0; i_index &lt; if_count; i_index++ ){
				if ( strcmp(interface,if_config[i_index].ethname) == 0 ) break;
			}
			if ( i_index == if_count ){
				logger(prefix,&quot;FATAL: Interface [%s] does not exist!\n&quot;,interface);
				continue;
			}
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_interfaces &amp;&amp; idx &lt; MAX_DHCP_INTERFACES; idx++ ){
				if ( gix_options-&gt;dhcp_interface[idx].index == i_index ) break;
			}
			if ( idx &gt;= MAX_DHCP_INTERFACES ){
				logger(prefix,&quot;WARNING: Error in config-file (Line: %d) --&gt; Too many interfaces defined (Max: %d)n&quot;,config_lines,MAX_DHCP_INTERFACES);
				continue;
			}
			if ( idx == gix_options-&gt;dhcp_interfaces ){
				gix_options-&gt;dhcp_interface[idx].index = i_index;
				init_defaults_dhcp(&amp;gix_options-&gt;dhcp_interface[idx]);
				gix_options-&gt;dhcp_interfaces++;
			} 
			strcpy(gix_options-&gt;dhcp_interface[idx].ip_tftp_server,domain);
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;IP-TFTPSERVER Interface: [%s](%d), tftp-server: [%s] Interface-Index: [%d/%d]\n&quot;,if_config[i_index].ethname,i_index,domain,idx,gix_options-&gt;dhcp_interfaces);
#endif
			continue;
		}
		if ( strncmp(buf,&quot;[DHCP_IP_DOMAIN=&quot;,strlen(&quot;[DHCP_IP_DOMAIN=&quot;)) == 0 ){
			char interface[256];
			int idx, i_index;
			char domain[256];
			ptr = &amp;buf[strlen(&quot;[DHCP_IP_DOMAIN=&quot;)];
			strcpy(interface,ptr);
			ptr = interface;
			while ( *ptr &amp;&amp; *ptr != &#039;:&#039; ) ptr++;
			if ( *ptr != &#039;:&#039; ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d)\n&quot;,config_lines);
				continue;
			}
			*ptr = &#039;\0&#039;;
			ptr++;
			while ( *ptr &amp;&amp; isspace(*ptr) ) ptr++;
			strcpy(domain,ptr);
			ptr = &amp;domain[strlen(domain)-1];
			while ( ptr &gt; domain &amp;&amp;  ( *ptr == &#039;\r&#039; || *ptr == &#039;\n&#039; || isspace(*ptr) || *ptr == &#039;]&#039; )) ptr--;
			ptr++;
			*ptr = &#039;\0&#039;;
			if ( strlen(domain) &lt; 3 ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) Bad domain\n&quot;,config_lines);
				continue;
			}
			for ( i_index = 0; i_index &lt; if_count; i_index++ ){
				if ( strcmp(interface,if_config[i_index].ethname) == 0 ) break;
			}
			if ( i_index == if_count ){
				logger(prefix,&quot;FATAL: Interface [%s] does not exist!\n&quot;,interface);
				continue;
			}
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_interfaces &amp;&amp; idx &lt; MAX_DHCP_INTERFACES; idx++ ){
				if ( gix_options-&gt;dhcp_interface[idx].index == i_index ) break;
			}
			if ( idx &gt;= MAX_DHCP_INTERFACES ){
				logger(prefix,&quot;WARNING: Error in config-file (Line: %d) --&gt; Too many interfaces defined (Max: %d)n&quot;,config_lines,MAX_DHCP_INTERFACES);
				continue;
			}
			if ( idx == gix_options-&gt;dhcp_interfaces ){
				gix_options-&gt;dhcp_interface[idx].index = i_index;
				init_defaults_dhcp(&amp;gix_options-&gt;dhcp_interface[idx]);
				gix_options-&gt;dhcp_interfaces++;
			} 
			strcpy(gix_options-&gt;dhcp_interface[idx].ip_domain,domain);
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;DOMAIN Interface: [%s](%d), Domain: [%s] Interface-Index: [%d/%d]\n&quot;,if_config[i_index].ethname,i_index,domain,idx,gix_options-&gt;dhcp_interfaces);
#endif
			continue;
		
		}
		if ( strncmp(buf,&quot;[DHCP_LEASE_TIME=&quot;,strlen(&quot;[DHCP_LEASE_TIME=&quot;)) == 0 ){
			char interface[256];
			int idx, i_index;
			time_t leasetime;
			ptr = &amp;buf[strlen(&quot;[DHCP_IP6_ROUTER=&quot;)];
			strcpy(interface,ptr);
			ptr = interface;
			while ( *ptr &amp;&amp; *ptr != &#039;:&#039; ) ptr++;
			if ( *ptr != &#039;:&#039; ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d)\n&quot;,config_lines);
				continue;
			}
			*ptr = &#039;\0&#039;;
			ptr++;
			leasetime = atoi(ptr);
			if ( leasetime == 0 ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) Bad lease time...ignoring\n&quot;,config_lines);
				continue;
			}
			for ( i_index = 0; i_index &lt; if_count; i_index++ ){
				if ( strcmp(interface,if_config[i_index].ethname) == 0 ) break;
			}
			if ( i_index == if_count ){
				logger(prefix,&quot;FATAL: Interface [%s] does not exist!\n&quot;,interface);
				continue;
			}
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_interfaces &amp;&amp; idx &lt; MAX_DHCP_INTERFACES; idx++ ){
				if ( gix_options-&gt;dhcp_interface[idx].index == i_index ) break;
			}
			if ( idx &gt;= MAX_DHCP_INTERFACES ){
				logger(prefix,&quot;WARNING: Error in config-file (Line: %d) --&gt; Too many interfaces defined (Max: %d)n&quot;,config_lines,MAX_DHCP_INTERFACES);
				continue;
			}
			if ( idx == gix_options-&gt;dhcp_interfaces ){
				gix_options-&gt;dhcp_interface[idx].index = i_index;
				init_defaults_dhcp(&amp;gix_options-&gt;dhcp_interface[idx]);
				gix_options-&gt;dhcp_interfaces++;
			} 
			gix_options-&gt;dhcp_interface[idx].leasetime = leasetime;
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;Lease-Time Interface: [%s](%d), Lease-Time: [%ld] Interface-Index: [%d/%d]\n&quot;,if_config[i_index].ethname,i_index,leasetime,idx,gix_options-&gt;dhcp_interfaces);
#endif
			continue;
		
		}
		if ( strncmp(buf,&quot;[DHCP_IP6_ROUTER=&quot;,strlen(&quot;[DHCP_IP6_ROUTER=&quot;)) == 0 ){
			char interface[256];
			int i_index;
			struct sockaddr_in6 *retaddr;
			char ip[64];
			int idx;
			ptr = &amp;buf[strlen(&quot;[DHCP_IP6_ROUTER=&quot;)];
			strcpy(interface,ptr);
			ptr = interface;
			while ( *ptr &amp;&amp; *ptr != &#039;:&#039; ) ptr++;
			if ( *ptr != &#039;:&#039; ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d)\n&quot;,config_lines);
				continue;
			}
			*ptr = &#039;\0&#039;;
			ptr++;
			strcpy(ip,ptr);
			ptr = ip;
			while ( *ptr &amp;&amp; (*ptr == &#039;:&#039; || ( *ptr &gt;= &#039;0&#039; &amp;&amp; *ptr &lt;= &#039;9&#039; ) || ( *ptr &gt;= &#039;a&#039; &amp;&amp; *ptr &lt;= &#039;f&#039; ) || ( *ptr &gt;= &#039;A&#039; &amp;&amp; *ptr &lt;= &#039;F&#039; ) ) )ptr++;
			*ptr = &#039;\0&#039;;
			if ( (retaddr = check_valid_ipv6(ip,DHCP_DEFAULT_PORT_IN,SOCK_DGRAM)) == NULL ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) --&gt; Invalid IPv6 address\n&quot;,config_lines);
				continue;
			}
			for ( i_index = 0; i_index &lt; if_count; i_index++ ){
				if ( strcmp(interface,if_config[i_index].ethname) == 0 ) break;
			}
			if ( i_index == if_count ){
				logger(prefix,&quot;FATAL: Interface [%s] does not exist!\n&quot;,interface);
				continue;
			}
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_interfaces &amp;&amp; idx &lt; MAX_DHCP_INTERFACES; idx++ ){
				if ( gix_options-&gt;dhcp_interface[idx].index == i_index ) break;
			}
			if ( idx &gt;= MAX_DHCP_INTERFACES ){
				logger(prefix,&quot;WARNING: Error in config-file (Line: %d) --&gt; Too many interfaces defined (Max: %d)n&quot;,config_lines,MAX_DHCP_INTERFACES);
				continue;
			}
			if ( idx == gix_options-&gt;dhcp_interfaces ){
				gix_options-&gt;dhcp_interface[idx].index = i_index;
				init_defaults_dhcp(&amp;gix_options-&gt;dhcp_interface[idx]);
				gix_options-&gt;dhcp_interfaces++;
			} 
			memcpy(&amp;(gix_options-&gt;dhcp_interface[idx].ip6_router),retaddr,sizeof(struct sockaddr_in6));
			inet_ntop(AF_INET6,&amp;(gix_options-&gt;dhcp_interface[idx].ip6_router.sin6_addr),ip,64);
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;Router6 Interface: [%s](%d), IP: [%s] Interface-Index: [%d/%d]\n&quot;,if_config[i_index].ethname,i_index,ip,idx,gix_options-&gt;dhcp_interfaces);
#endif
			continue;
		
		}
		if ( strncmp(buf,&quot;[DHCP_IP6_ME=&quot;,strlen(&quot;[DHCP_IP6_ME=&quot;)) == 0 ){
			char interface[256];
			int i_index;
			struct sockaddr_in6 *retaddr;
			char ip[64];
			int idx;
			ptr = &amp;buf[strlen(&quot;[DHCP_IP6_ME=&quot;)];
			strcpy(interface,ptr);
			ptr = interface;
			while ( *ptr &amp;&amp; *ptr != &#039;:&#039; ) ptr++;
			if ( *ptr != &#039;:&#039; ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d)\n&quot;,config_lines);
				continue;
			}
			*ptr = &#039;\0&#039;;
			ptr++;
			strcpy(ip,ptr);
			ptr = ip;
			while ( *ptr &amp;&amp; (*ptr == &#039;:&#039; || ( *ptr &gt;= &#039;0&#039; &amp;&amp; *ptr &lt;= &#039;9&#039; ) || ( *ptr &gt;= &#039;a&#039; &amp;&amp; *ptr &lt;= &#039;f&#039; ) || ( *ptr &gt;= &#039;A&#039; &amp;&amp; *ptr &lt;= &#039;F&#039; ) ) )ptr++;
			*ptr = &#039;\0&#039;;
			if ( (retaddr = check_valid_ipv6(ip,DHCP_DEFAULT_PORT_IN,SOCK_DGRAM)) == NULL ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) --&gt; Invalid IPv6 address\n&quot;,config_lines);
				continue;
			}
			for ( i_index = 0; i_index &lt; if_count; i_index++ ){
				if ( strcmp(interface,if_config[i_index].ethname) == 0 ) break;
			}
			if ( i_index == if_count ){
				logger(prefix,&quot;FATAL: Interface [%s] does not exist!\n&quot;,interface);
				continue;
			}
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_interfaces &amp;&amp; idx &lt; MAX_DHCP_INTERFACES; idx++ ){
				if ( gix_options-&gt;dhcp_interface[idx].index == i_index ) break;
			}
			if ( idx &gt;= MAX_DHCP_INTERFACES ){
				logger(prefix,&quot;WARNING: Error in config-file (Line: %d) --&gt; Too many interfaces defined (Max: %d)n&quot;,config_lines,MAX_DHCP_INTERFACES);
				continue;
			}
			if ( idx == gix_options-&gt;dhcp_interfaces ){
				gix_options-&gt;dhcp_interface[idx].index = i_index;
				init_defaults_dhcp(&amp;gix_options-&gt;dhcp_interface[idx]);
				gix_options-&gt;dhcp_interfaces++;
			} 
			memcpy(&amp;(gix_options-&gt;dhcp_interface[idx].ip6_me),retaddr,sizeof(struct sockaddr_in6));
			inet_ntop(AF_INET6,&amp;(gix_options-&gt;dhcp_interface[idx].ip6_me.sin6_addr),ip,64);
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;ME6 Interface: [%s](%d), IP: [%s] Interface-Index: [%d/%d]\n&quot;,if_config[i_index].ethname,i_index,ip,idx,gix_options-&gt;dhcp_interfaces);
#endif
			continue;
		
		}
		if ( strncmp(buf,&quot;[DHCP_IP_DNS=&quot;,strlen(&quot;[DHCP_IP_DNS=&quot;)) == 0 ){
			int i_index;
			char interface[256];
			struct sockaddr_in *retaddr;
			struct sockaddr_in a_ip[MAX_DHCP_DNS_SERVERS];
			char ip[MAX_DHCP_DNS_SERVERS][64];
			char ip_help[64];
			char nslist[1024];
			int idx;
			int dns_idx;

			ptr = &amp;buf[strlen(&quot;[DHCP_IP_DNS=&quot;)];
			strcpy(interface,ptr);
			ptr = interface;
			while ( *ptr &amp;&amp; *ptr != &#039;:&#039; ) ptr++;
			if ( *ptr != &#039;:&#039; ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d)\n&quot;,config_lines);
				continue;
			}
			*ptr = &#039;\0&#039;;
			ptr++;
			for ( i_index = 0; i_index &lt; if_count; i_index++ ){
				if ( strcmp(interface,if_config[i_index].ethname) == 0 ) break;
			}
			if ( i_index == if_count ){
				logger(prefix,&quot;FATAL: Interface [%s] does not exist!\n&quot;,interface);
				continue;
			}
			for (dns_idx = 0; dns_idx &lt; MAX_DHCP_DNS_SERVERS; dns_idx++ ){
				strcpy(ip[dns_idx],ptr);
				ptr = ip[dns_idx];
				while ( *ptr &amp;&amp; (*ptr == &#039;.&#039; || ( *ptr &gt;= &#039;0&#039; &amp;&amp; *ptr &lt;= &#039;9&#039; )) )ptr++;
				*ptr = &#039;\0&#039;;
				if ( (retaddr = check_valid_ipv4(ip[dns_idx],DHCP_DEFAULT_PORT_IN,SOCK_DGRAM)) == NULL ) break;
				memcpy(&amp;(a_ip[dns_idx]),retaddr,sizeof(struct sockaddr_in));
				ptr++;
				while ( *ptr &amp;&amp; isspace(*ptr) ) ptr++;
			}
			if ( dns_idx == 0 ){
				logger(prefix,&quot;WARNING: You must specify at least 1 nameserver for this interface\n&quot;);
				continue;
			}
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_interfaces &amp;&amp; idx &lt; MAX_DHCP_INTERFACES; idx++ ){
				if ( gix_options-&gt;dhcp_interface[idx].index == i_index ) break;
			}
			if ( idx &gt;= MAX_DHCP_INTERFACES ){
				logger(prefix,&quot;WARNING: Error in config-file (Line: %d) --&gt; Too many interfaces defined (Max: %d)n&quot;,config_lines,MAX_DHCP_INTERFACES);
				continue;
			}
			if ( idx == gix_options-&gt;dhcp_interfaces ){
				gix_options-&gt;dhcp_interface[idx].index = i_index;
				init_defaults_dhcp(&amp;gix_options-&gt;dhcp_interface[idx]);
				gix_options-&gt;dhcp_interfaces++;
			} 
			gix_options-&gt;dhcp_interface[idx].ip_nameservers = dns_idx;
			strcpy(nslist,&quot;&quot;);
			for ( dns_idx = 0; dns_idx &lt; gix_options-&gt;dhcp_interface[idx].ip_nameservers; dns_idx++ ){
				memcpy(&amp;(gix_options-&gt;dhcp_interface[idx].ip_nameserver[dns_idx]),&amp;a_ip[dns_idx],sizeof(struct sockaddr_in));
				inet_ntop(AF_INET,&amp;(gix_options-&gt;dhcp_interface[idx].ip_nameserver[dns_idx].sin_addr),ip_help,64);
				strcat(nslist,ip_help);
				strcat(nslist,&quot;,&quot;);
			}
			if ( strlen(nslist) &amp;&amp; nslist[strlen(nslist)-1] == &#039;,&#039; ) nslist[strlen(nslist)-1] = &#039;\0&#039;;
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;DNS Interface: [%s](%d), Count: %d [%s] Interface-Index: [%d/%d]\n&quot;,if_config[i_index].ethname,i_index,dns_idx,nslist,idx,gix_options-&gt;dhcp_interfaces);
#endif
			continue;
		
		}
		if ( strncmp(buf,&quot;[DHCP_IP6_DNS=&quot;,strlen(&quot;[DHCP_IP6_DNS=&quot;)) == 0 ){
			int i_index;
			char interface[256];
			struct sockaddr_in6 *retaddr;
			struct sockaddr_in6 a_ip[MAX_DHCP_DNS_SERVERS];
			char ip[MAX_DHCP_DNS_SERVERS][64];
			char ip_help[64];
			char nslist[1024];
			int idx;
			int dns_idx;

			ptr = &amp;buf[strlen(&quot;[DHCP_IP6_DNS=&quot;)];
			strcpy(interface,ptr);
			ptr = interface;
			while ( *ptr &amp;&amp; *ptr != &#039;:&#039; ) ptr++;
			if ( *ptr != &#039;:&#039; ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d)\n&quot;,config_lines);
				continue;
			}
			*ptr = &#039;\0&#039;;
			ptr++;
			for ( i_index = 0; i_index &lt; if_count; i_index++ ){
				if ( strcmp(interface,if_config[i_index].ethname) == 0 ) break;
			}
			if ( i_index == if_count ){
				logger(prefix,&quot;FATAL: Interface [%s] does not exist!\n&quot;,interface);
				continue;
			}
			for (dns_idx = 0; dns_idx &lt; MAX_DHCP_DNS_SERVERS; dns_idx++ ){
				strcpy(ip[dns_idx],ptr);
				ptr = ip[dns_idx];
				while ( *ptr &amp;&amp; (*ptr == &#039;:&#039; || ( *ptr &gt;= &#039;0&#039; &amp;&amp; *ptr &lt;= &#039;9&#039; ) || ( *ptr &gt;= &#039;a&#039; &amp;&amp; *ptr &lt;= &#039;f&#039; ) || ( *ptr &gt;= &#039;A&#039; &amp;&amp; *ptr &lt;= &#039;F&#039; ) ) )ptr++;
				*ptr = &#039;\0&#039;;
				if ( (retaddr = check_valid_ipv6(ip[dns_idx],DHCP_DEFAULT_PORT_IN,SOCK_DGRAM)) == NULL ) break;
				memcpy(&amp;(a_ip[dns_idx]),retaddr,sizeof(struct sockaddr_in6));
				ptr++;
				while ( *ptr &amp;&amp; isspace(*ptr) ) ptr++;
			}
			if ( dns_idx == 0 ){
				logger(prefix,&quot;WARNING: You must specify at least 1 nameserver for this interface\n&quot;);
				continue;
			}
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_interfaces &amp;&amp; idx &lt; MAX_DHCP_INTERFACES; idx++ ){
				if ( gix_options-&gt;dhcp_interface[idx].index == i_index ) break;
			}
			if ( idx &gt;= MAX_DHCP_INTERFACES ){
				logger(prefix,&quot;WARNING: Error in config-file (Line: %d) --&gt; Too many interfaces defined (Max: %d)n&quot;,config_lines,MAX_DHCP_INTERFACES);
				continue;
			}
			if ( idx == gix_options-&gt;dhcp_interfaces ){
				gix_options-&gt;dhcp_interface[idx].index = i_index;
				init_defaults_dhcp(&amp;gix_options-&gt;dhcp_interface[idx]);
				gix_options-&gt;dhcp_interfaces++;
			} 
			gix_options-&gt;dhcp_interface[idx].ip6_nameservers = dns_idx;
			strcpy(nslist,&quot;&quot;);
			for ( dns_idx = 0; dns_idx &lt; gix_options-&gt;dhcp_interface[idx].ip6_nameservers; dns_idx++ ){
				memcpy(&amp;(gix_options-&gt;dhcp_interface[idx].ip6_nameserver[dns_idx]),&amp;a_ip[dns_idx],sizeof(struct sockaddr_in6));
				inet_ntop(AF_INET6,&amp;(gix_options-&gt;dhcp_interface[idx].ip6_nameserver[dns_idx].sin6_addr),ip_help,64);
				strcat(nslist,ip_help);
				strcat(nslist,&quot;,&quot;);
			}
			if ( strlen(nslist) &amp;&amp; nslist[strlen(nslist)-1] == &#039;,&#039; ) nslist[strlen(nslist)-1] = &#039;\0&#039;;
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;DNS6 Interface: [%s](%d), Count: %d [%s] Interface-Index: [%d/%d]\n&quot;,if_config[i_index].ethname,i_index,dns_idx,nslist,idx,gix_options-&gt;dhcp_interfaces);
#endif
			continue;
		
		}
		if ( strncmp(buf,&quot;[DHCP_IP6_MAC=&quot;,strlen(&quot;[DHCP_IP6_MAC=&quot;)) == 0 ){
			char mac_addr[64];
			char ip_addr[128];
			struct ether_addr eth_raw; 
			int idx;
			struct sockaddr_in6 *ret_addr;
			char boot_image[512];
			ptr = &amp;buf[strlen(&quot;[DHCP_IP6_MAC=&quot;)];
			strcpy(mac_addr,ptr);
			ptr = mac_addr;
			while ( *ptr &amp;&amp; ( *ptr == &#039;:&#039; || ( *ptr &gt;= &#039;0&#039; &amp;&amp; *ptr &lt;= &#039;9&#039; ) || ( *ptr &gt;= &#039;a&#039; &amp;&amp; *ptr &lt;= &#039;f&#039; ) || ( *ptr &gt;= &#039;A&#039; &amp;&amp; *ptr &lt;= &#039;F&#039; ) ) ){ *ptr = toupper(*ptr); ptr++; }
			*ptr = &#039;\0&#039;;
			ptr++;

			if ( sscanf(mac_addr,&quot;%02X:%02X:%02X:%02X:%02X:%02X&quot;, &amp;(eth_raw.ether_addr_octet[0]), &amp;(eth_raw.ether_addr_octet[1]), &amp;(eth_raw.ether_addr_octet[2]), &amp;(eth_raw.ether_addr_octet[3]), &amp;(eth_raw.ether_addr_octet[4]), &amp;(eth_raw.ether_addr_octet[5])) != 6 ){
				logger(prefix,&quot;WARNING: Syntax error in line %d (invalid MAC address)\n&quot;,config_lines);
				continue;
			}
			
			while ( *ptr &amp;&amp; isspace(*ptr) ) ptr++;
			strcpy(ip_addr,ptr);
			ptr = ip_addr;
			while ( *ptr &amp;&amp; (*ptr == &#039;:&#039; || ( *ptr &gt;= &#039;0&#039; &amp;&amp; *ptr &lt;= &#039;9&#039; ) || ( *ptr &gt;= &#039;a&#039; &amp;&amp; *ptr &lt;= &#039;f&#039; ) || ( *ptr &gt;= &#039;A&#039; &amp;&amp; *ptr &lt;= &#039;F&#039; ) ) )ptr++;
			*ptr = &#039;\0&#039;;
			ptr++;
			if ( (ret_addr = check_valid_ipv6(ip_addr,DHCP_DEFAULT_PORT_OUT,SOCK_DGRAM)) == NULL ){
				logger(prefix,&quot;WARNING: Syntax error in line %d (invalid IPv6 address)\n&quot;,config_lines);
				continue;
			}
			while ( *ptr &amp;&amp; isspace(*ptr) ) ptr++;
			strcpy(boot_image,ptr);
			ptr = boot_image;
			while ( *ptr &amp;&amp; ( !isspace(*ptr) &amp;&amp; *ptr != &#039;]&#039; &amp;&amp; *ptr != &#039;\r&#039; &amp;&amp; *ptr != &#039;\n&#039; ) )ptr++;
			*ptr = &#039;\0&#039;;
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_hosts; idx++ ){
				if ( memcmp(&amp;gix_options-&gt;dhcp_host[idx].mac,&amp;eth_raw,sizeof(struct ether_addr)) == 0 ) break;
			}
			if ( idx &gt;= MAX_DHCP_HOSTS ){
				logger(prefix,&quot;FATAL: Too many DHCP-Hosts defined (Max: %d)\n&quot;,MAX_DHCP_HOSTS);
				continue;
			}			
			if ( idx == gix_options-&gt;dhcp_hosts ){
				memcpy(&amp;(gix_options-&gt;dhcp_host[idx].mac),&amp;eth_raw,sizeof(struct ether_addr));
				gix_options-&gt;dhcp_hosts++;
			}
			memcpy(&amp;gix_options-&gt;dhcp_host[idx].ip6_addr,ret_addr,sizeof(struct sockaddr_in6));
			if ( strlen(boot_image) ) strcpy(gix_options-&gt;dhcp_host[idx].bootfile,boot_image); // Do not overwrite, if already specified 
			inet_ntop(AF_INET6,&amp;(gix_options-&gt;dhcp_host[idx].ip6_addr.sin6_addr),ip_addr,128);
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;IP6_MAC: [%02X:%02X:%02X:%02X:%02X:%02X] IP: [%s] BOOT-FILE: [%s](%d Bytes) [%d/%d]\n&quot;,
				gix_options-&gt;dhcp_host[idx].mac.ether_addr_octet[0], gix_options-&gt;dhcp_host[idx].mac.ether_addr_octet[1], gix_options-&gt;dhcp_host[idx].mac.ether_addr_octet[2],
				gix_options-&gt;dhcp_host[idx].mac.ether_addr_octet[3], gix_options-&gt;dhcp_host[idx].mac.ether_addr_octet[4], gix_options-&gt;dhcp_host[idx].mac.ether_addr_octet[5],
				ip_addr,gix_options-&gt;dhcp_host[idx].bootfile,strlen(gix_options-&gt;dhcp_host[idx].bootfile),idx,gix_options-&gt;dhcp_hosts);
#endif
			continue;	
		}
		if ( strncmp(buf,&quot;[DHCP_DENY_MAC=&quot;,strlen(&quot;[DHCP_DENY_MAC=&quot;)) == 0 ){
			int idx;
			char mac_addr[64];
			struct ether_addr eth_raw; 
			ptr = &amp;buf[strlen(&quot;[DHCP_DENY_MAC=&quot;)];
			strcpy(mac_addr,ptr);
			ptr = mac_addr;
			while ( *ptr &amp;&amp; ( *ptr == &#039;:&#039; || ( *ptr &gt;= &#039;0&#039; &amp;&amp; *ptr &lt;= &#039;9&#039; ) || ( *ptr &gt;= &#039;a&#039; &amp;&amp; *ptr &lt;= &#039;f&#039; ) || ( *ptr &gt;= &#039;A&#039; &amp;&amp; *ptr &lt;= &#039;F&#039; ) ) ){ *ptr = toupper(*ptr); ptr++; }
			*ptr = &#039;\0&#039;;
			ptr++;

			if ( sscanf(mac_addr,&quot;%02X:%02X:%02X:%02X:%02X:%02X&quot;, &amp;(eth_raw.ether_addr_octet[0]), &amp;(eth_raw.ether_addr_octet[1]), &amp;(eth_raw.ether_addr_octet[2]), &amp;(eth_raw.ether_addr_octet[3]), &amp;(eth_raw.ether_addr_octet[4]), &amp;(eth_raw.ether_addr_octet[5])) != 6 ){
				logger(prefix,&quot;WARNING: Syntax error in line %d (invalid MAC address)\n&quot;,config_lines);
				continue;
			}
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_denials; idx++ ){
				if ( memcmp(&amp;gix_options-&gt;dhcp_deny[idx].mac,&amp;eth_raw,sizeof(struct ether_addr)) == 0 ) break;
			}
			if ( idx &gt;= MAX_DHCP_DENY_MACS ){
				logger(prefix,&quot;FATAL: Too many DENY_DHCP-MACS defined (Max: %d)\n&quot;,MAX_DHCP_DENY_MACS);
				continue;
			}			
			if ( idx == gix_options-&gt;dhcp_denials ){
				memcpy(&amp;(gix_options-&gt;dhcp_deny[idx].mac),&amp;eth_raw,sizeof(struct ether_addr));
				gix_options-&gt;dhcp_denials++;
			}
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;DENY_MAC: [%02X:%02X:%02X:%02X:%02X:%02X]\n&quot;,
				gix_options-&gt;dhcp_deny[idx].mac.ether_addr_octet[0], gix_options-&gt;dhcp_deny[idx].mac.ether_addr_octet[1], gix_options-&gt;dhcp_deny[idx].mac.ether_addr_octet[2],
				gix_options-&gt;dhcp_deny[idx].mac.ether_addr_octet[3], gix_options-&gt;dhcp_deny[idx].mac.ether_addr_octet[4], gix_options-&gt;dhcp_deny[idx].mac.ether_addr_octet[5]);
#endif
			continue;	
		}
		
		if ( strncmp(buf,&quot;[DHCP_IP_MAC=&quot;,strlen(&quot;[DHCP_IP_MAC=&quot;)) == 0 ){
			char mac_addr[64];
			char ip_addr[128];
			struct ether_addr eth_raw; 
			int idx;
			struct sockaddr_in *ret_addr;
			char boot_image[512];
			ptr = &amp;buf[strlen(&quot;[DHCP_IP_MAC=&quot;)];
			strcpy(mac_addr,ptr);
			ptr = mac_addr;
			while ( *ptr &amp;&amp; ( *ptr == &#039;:&#039; || ( *ptr &gt;= &#039;0&#039; &amp;&amp; *ptr &lt;= &#039;9&#039; ) || ( *ptr &gt;= &#039;a&#039; &amp;&amp; *ptr &lt;= &#039;f&#039; ) || ( *ptr &gt;= &#039;A&#039; &amp;&amp; *ptr &lt;= &#039;F&#039; ) ) ){ *ptr = toupper(*ptr); ptr++; }
			*ptr = &#039;\0&#039;;
			ptr++;

			if ( sscanf(mac_addr,&quot;%02X:%02X:%02X:%02X:%02X:%02X&quot;, &amp;(eth_raw.ether_addr_octet[0]), &amp;(eth_raw.ether_addr_octet[1]), &amp;(eth_raw.ether_addr_octet[2]), &amp;(eth_raw.ether_addr_octet[3]), &amp;(eth_raw.ether_addr_octet[4]), &amp;(eth_raw.ether_addr_octet[5])) != 6 ){
				logger(prefix,&quot;WARNING: Syntax error in line %d (invalid MAC address)\n&quot;,config_lines);
				continue;
			}
			
			while ( *ptr &amp;&amp; isspace(*ptr) ) ptr++;
			strcpy(ip_addr,ptr);
			ptr = ip_addr;
			while ( *ptr &amp;&amp; ( *ptr == &#039;.&#039; || ( *ptr &gt;= &#039;0&#039; &amp;&amp; *ptr &lt;= &#039;9&#039; ) )  ) ptr++;
			*ptr = &#039;\0&#039;;
			ptr++;
			if ( (ret_addr = check_valid_ipv4(ip_addr,DHCP_DEFAULT_PORT_OUT,SOCK_DGRAM)) == NULL ){
				logger(prefix,&quot;WARNING: Syntax error in line %d (invalid IPv4 address)\n&quot;,config_lines);
				continue;
			}
			while ( *ptr &amp;&amp; isspace(*ptr) ) ptr++;
			strcpy(boot_image,ptr);
			ptr = boot_image;
			while ( *ptr &amp;&amp; ( !isspace(*ptr) &amp;&amp; *ptr != &#039;]&#039; &amp;&amp; *ptr != &#039;\r&#039; &amp;&amp; *ptr != &#039;\n&#039; ) )ptr++;
			*ptr = &#039;\0&#039;;
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_hosts; idx++ ){
				if ( memcmp(&amp;gix_options-&gt;dhcp_host[idx].mac,&amp;eth_raw,sizeof(struct ether_addr)) == 0 ) break;
			}
			if ( idx &gt;= MAX_DHCP_HOSTS ){
				logger(prefix,&quot;FATAL: Too many DHCP-Hosts defined (Max: %d)\n&quot;,MAX_DHCP_HOSTS);
				continue;
			}			
			if ( idx == gix_options-&gt;dhcp_hosts ){
				memcpy(&amp;(gix_options-&gt;dhcp_host[idx].mac),&amp;eth_raw,sizeof(struct ether_addr));
				gix_options-&gt;dhcp_hosts++;
			}
			memcpy(&amp;gix_options-&gt;dhcp_host[idx].ip_addr,ret_addr,sizeof(struct sockaddr_in));
			if ( strlen(boot_image) ) strcpy(gix_options-&gt;dhcp_host[idx].bootfile,boot_image); // Do not overwrite, if already specified 
			inet_ntop(AF_INET,&amp;(gix_options-&gt;dhcp_host[idx].ip_addr.sin_addr),ip_addr,128);
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;IP_MAC: [%02X:%02X:%02X:%02X:%02X:%02X] IP: [%s] BOOT-FILE: [%s](%d Bytes) [%d/%d]\n&quot;,
				gix_options-&gt;dhcp_host[idx].mac.ether_addr_octet[0], gix_options-&gt;dhcp_host[idx].mac.ether_addr_octet[1], gix_options-&gt;dhcp_host[idx].mac.ether_addr_octet[2],
				gix_options-&gt;dhcp_host[idx].mac.ether_addr_octet[3], gix_options-&gt;dhcp_host[idx].mac.ether_addr_octet[4], gix_options-&gt;dhcp_host[idx].mac.ether_addr_octet[5],
				ip_addr,gix_options-&gt;dhcp_host[idx].bootfile,strlen(gix_options-&gt;dhcp_host[idx].bootfile),idx,gix_options-&gt;dhcp_hosts);
#endif
			continue;	
		}
		if ( strncmp(buf,&quot;[DHCP_BOOTIMAGE=&quot;,strlen(&quot;[DHCP_BOOTIMAGE=&quot;)) == 0 ){
			char image_name[1024];
			char class_id[1024];
			ptr = &amp;buf[strlen(&quot;[DHCP_BOOTIMAGE=&quot;)];
			strcpy(image_name,ptr);
			ptr = image_name;
			while ( *ptr &amp;&amp; !isspace(*ptr) &amp;&amp; *ptr != &#039;]&#039; )ptr++;
			*ptr = &#039;\0&#039;;
			ptr++;		
			while ( *ptr &amp;&amp; isspace(*ptr) )ptr++;
			strcpy(class_id,ptr);
			ptr = &amp;class_id[strlen(class_id)-1];
			while ( ptr &gt; class_id &amp;&amp; ( *ptr == &#039;\r&#039; ||  *ptr == &#039;\n&#039; || *ptr == &#039;]&#039; ) )ptr--;
			ptr++;
			*ptr = &#039;\0&#039;;
			if ( gix_options-&gt;dhcp_bootfiles &gt;= MAX_DHCP_BOOTFILES ){
				logger(prefix,&quot;WARNING: A maximum of %d DHCP-Bootfiles is allowed!\n&quot;,MAX_DHCP_BOOTFILES);
				continue;
			}
			strcpy(gix_options-&gt;dhcp_bootfile[gix_options-&gt;dhcp_bootfiles].bootimage,image_name);
			strcpy(gix_options-&gt;dhcp_bootfile[gix_options-&gt;dhcp_bootfiles].class_id,class_id);
			if ( strlen(class_id) == 0 ){
				gix_options-&gt;dhcp_bootfile[gix_options-&gt;dhcp_bootfiles].def = 1;
			} else {
				gix_options-&gt;dhcp_bootfile[gix_options-&gt;dhcp_bootfiles].def = 0;
			}
			gix_options-&gt;dhcp_bootfiles++;
			
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;BOOTIMAGE [%s](%d Bytes) CLASS-ID: [%s](%d Bytes) Index: %d Default: [%s]\n&quot;,image_name,strlen(image_name),class_id,strlen(class_id),gix_options-&gt;dhcp_bootfiles-1, gix_options-&gt;dhcp_bootfile[gix_options-&gt;dhcp_bootfiles-1].def == 1 ? &quot;YES&quot; : &quot;NO&quot;);
#endif
			
			continue;
		}
		if ( strncmp(buf,&quot;[DHCP_IP6_RANGE=&quot;,strlen(&quot;[DHCP_IP6_RANGE=&quot;)) == 0 ){
			int i_index;
			char interface[256];
			struct sockaddr_in6 *retaddr;
			struct sockaddr_in6 a_ip1;
			struct sockaddr_in6 a_ip2;
			char opt_bootfile[1024];
			char ip1[1640];
			char ip2[1640];
			int idx;
			ptr = &amp;buf[strlen(&quot;[DHCP_IP6_RANGE=&quot;)];
			strcpy(interface,ptr);
			ptr = interface;
			while ( *ptr &amp;&amp; *ptr != &#039;:&#039; ) ptr++;
			if ( *ptr != &#039;:&#039; ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d)\n&quot;,config_lines);
				continue;
			}
			*ptr = &#039;\0&#039;;
			ptr++;
			strcpy(ip1,ptr);
			ptr = ip1;
			while ( *ptr &amp;&amp; (*ptr == &#039;:&#039; || ( *ptr &gt;= &#039;0&#039; &amp;&amp; *ptr &lt;= &#039;9&#039; ) || ( *ptr &gt;= &#039;a&#039; &amp;&amp; *ptr &lt;= &#039;f&#039; ) || ( *ptr &gt;= &#039;A&#039; &amp;&amp; *ptr &lt;= &#039;F&#039; ) ) )ptr++;
			*ptr = &#039;\0&#039;;
			ptr++;
			if ( (retaddr = check_valid_ipv6(ip1,DHCP_DEFAULT_PORT_IN,SOCK_DGRAM)) == NULL ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) --&gt; Invalid IPv6 address\n&quot;,config_lines);
				continue;
			}
			memcpy(&amp;a_ip1,retaddr,sizeof(struct sockaddr_in6));
			while ( *ptr &amp;&amp; isspace(*ptr) ) ptr++;
			if ( !*ptr ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) --&gt; Invalid IPv6 address\n&quot;,config_lines);
				continue;
			}
			strcpy(ip2,ptr);
			ptr = ip2;
			while ( *ptr &amp;&amp; (*ptr == &#039;:&#039; || ( *ptr &gt;= &#039;0&#039; &amp;&amp; *ptr &lt;= &#039;9&#039; ) || ( *ptr &gt;= &#039;a&#039; &amp;&amp; *ptr &lt;= &#039;f&#039; ) || ( *ptr &gt;= &#039;A&#039; &amp;&amp; *ptr &lt;= &#039;F&#039; ) ) )ptr++;
			*ptr = &#039;\0&#039;;
			if ( (retaddr = check_valid_ipv6(ip2,DHCP_DEFAULT_PORT_IN,SOCK_DGRAM)) == NULL ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) --&gt; Invalid IPv6 address\n&quot;,config_lines);
				continue;
			}
			memcpy(&amp;a_ip2,retaddr,sizeof(struct sockaddr_in6));
			while ( *ptr &amp;&amp; isspace(*ptr) ) ptr++;
			if ( *ptr ){
				logger(prefix,&quot;INFO: Found optional default-bootfile for range...\n&quot;);
				strcpy(opt_bootfile,ptr);		
				ptr = opt_bootfile;
				while ( *ptr &amp;&amp; (!isspace(*ptr) &amp;&amp; *ptr != &#039;]&#039;) )ptr++;
				*ptr = &#039;\0&#039;;	
			} else {
				strcpy(opt_bootfile,&quot;&quot;);
			}
			logger(prefix,&quot;INFO: Optional bootfile for Range: [%s]\n&quot;,opt_bootfile);

			for ( i_index = 0; i_index &lt; if_count; i_index++ ){
				if ( strcmp(interface,if_config[i_index].ethname) == 0 ) break;
			}
			if ( i_index == if_count ){
				logger(prefix,&quot;FATAL: Interface [%s] does not exist!\n&quot;,interface);
				continue;
			}
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_interfaces &amp;&amp; idx &lt; MAX_DHCP_INTERFACES; idx++ ){
				if ( gix_options-&gt;dhcp_interface[idx].index == i_index ) break;
			}
			if ( idx &gt;= MAX_DHCP_INTERFACES ){
				logger(prefix,&quot;WARNING: Error in config-file (Line: %d) --&gt; Too many interfaces defined (Max: %d)n&quot;,config_lines,MAX_DHCP_INTERFACES);
				continue;
			}
			if ( idx == gix_options-&gt;dhcp_interfaces ){
				gix_options-&gt;dhcp_interface[idx].index = i_index;
				init_defaults_dhcp(&amp;gix_options-&gt;dhcp_interface[idx]);
				gix_options-&gt;dhcp_interfaces++;
			} 
			memcpy(&amp;(gix_options-&gt;dhcp_interface[idx].ip6_range_start),&amp;a_ip1,sizeof(struct sockaddr_in6));
			memcpy(&amp;(gix_options-&gt;dhcp_interface[idx].ip6_range_end),&amp;a_ip2,sizeof(struct sockaddr_in6));
			inet_ntop(AF_INET6,&amp;(gix_options-&gt;dhcp_interface[idx].ip6_range_start.sin6_addr),ip1,64);
			inet_ntop(AF_INET6,&amp;(gix_options-&gt;dhcp_interface[idx].ip6_range_end.sin6_addr),ip2,64);
			strcpy(gix_options-&gt;dhcp_interface[idx].ip6_default_bootimage,opt_bootfile);
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;RANGE6 Interface: [%s](%d), IP: [%s - %s] Interface-Index: [%d/%d] [IMAGE: [%s]]\n&quot;,if_config[i_index].ethname,i_index,ip1,ip2,idx,gix_options-&gt;dhcp_interfaces,gix_options-&gt;dhcp_interface[idx].ip6_default_bootimage);
#endif
			continue;
		
		}
		if ( strncmp(buf,&quot;[DHCP_IP_RANGE=&quot;,strlen(&quot;[DHCP_IP_RANGE=&quot;)) == 0 ){
			int i_index;
			char interface[256];
			struct sockaddr_in *retaddr;
			struct sockaddr_in a_ip1;
			struct sockaddr_in a_ip2;
			char opt_bootfile[1024];
			char ip1[1640];
			char ip2[1640];
			int idx;
			ptr = &amp;buf[strlen(&quot;[DHCP_IP_RANGE=&quot;)];
			strcpy(interface,ptr);
			ptr = interface;
			while ( *ptr &amp;&amp; *ptr != &#039;:&#039; ) ptr++;
			if ( *ptr != &#039;:&#039; ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d)\n&quot;,config_lines);
				continue;
			}
			*ptr = &#039;\0&#039;;
			ptr++;
			strcpy(ip1,ptr);
			ptr = ip1;
			while ( *ptr &amp;&amp; (*ptr == &#039;.&#039; || ( *ptr &gt;= &#039;0&#039; &amp;&amp; *ptr &lt;= &#039;9&#039; )) )ptr++;
			*ptr = &#039;\0&#039;;
			ptr++;
			if ( (retaddr = check_valid_ipv4(ip1,DHCP_DEFAULT_PORT_IN,SOCK_DGRAM)) == NULL ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) --&gt; Invalid IPv4 address\n&quot;,config_lines);
				continue;
			}
			memcpy(&amp;a_ip1,retaddr,sizeof(struct sockaddr_in));
			while ( *ptr &amp;&amp; isspace(*ptr) ) ptr++;
			if ( !*ptr ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) --&gt; Invalid IPv4 address\n&quot;,config_lines);
				continue;
			}
			strcpy(ip2,ptr);
			ptr = ip2;
			while ( *ptr &amp;&amp; (*ptr == &#039;.&#039; || ( *ptr &gt;= &#039;0&#039; &amp;&amp; *ptr &lt;= &#039;9&#039; )) )ptr++;
			*ptr = &#039;\0&#039;;
			ptr++;
			if ( (retaddr = check_valid_ipv4(ip2,DHCP_DEFAULT_PORT_IN,SOCK_DGRAM)) == NULL ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) --&gt; Invalid IPv4 address\n&quot;,config_lines);
				continue;
			}
			memcpy(&amp;a_ip2,retaddr,sizeof(struct sockaddr_in));
			while ( *ptr &amp;&amp; isspace(*ptr) ) ptr++;
			if ( *ptr ){
				logger(prefix,&quot;INFO: Found optional default-bootfile for range...\n&quot;);
				strcpy(opt_bootfile,ptr);		
				ptr = opt_bootfile;
				while ( *ptr &amp;&amp; (!isspace(*ptr) &amp;&amp; *ptr != &#039;]&#039;) )ptr++;
				*ptr = &#039;\0&#039;;	
			} else {
				strcpy(opt_bootfile,&quot;&quot;);
			}
			logger(prefix,&quot;INFO: Optional bootfile for Range: [%s]\n&quot;,opt_bootfile);
				

			

			for ( i_index = 0; i_index &lt; if_count; i_index++ ){
				if ( strcmp(interface,if_config[i_index].ethname) == 0 ) break;
			}
			if ( i_index == if_count ){
				logger(prefix,&quot;FATAL: Interface [%s] does not exist!\n&quot;,interface);
				continue;
			}
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_interfaces &amp;&amp; idx &lt; MAX_DHCP_INTERFACES; idx++ ){
				if ( gix_options-&gt;dhcp_interface[idx].index == i_index ) break;
			}
			if ( idx &gt;= MAX_DHCP_INTERFACES ){
				logger(prefix,&quot;WARNING: Error in config-file (Line: %d) --&gt; Too many interfaces defined (Max: %d)n&quot;,config_lines,MAX_DHCP_INTERFACES);
				continue;
			}
			if ( idx == gix_options-&gt;dhcp_interfaces ){
				gix_options-&gt;dhcp_interface[idx].index = i_index;
				init_defaults_dhcp(&amp;gix_options-&gt;dhcp_interface[idx]);
				gix_options-&gt;dhcp_interfaces++;
			} 
			memcpy(&amp;(gix_options-&gt;dhcp_interface[idx].ip_range_start),&amp;a_ip1,sizeof(struct sockaddr_in));
			memcpy(&amp;(gix_options-&gt;dhcp_interface[idx].ip_range_end),&amp;a_ip2,sizeof(struct sockaddr_in));
			inet_ntop(AF_INET,&amp;(gix_options-&gt;dhcp_interface[idx].ip_range_start.sin_addr),ip1,64);
			inet_ntop(AF_INET,&amp;(gix_options-&gt;dhcp_interface[idx].ip_range_end.sin_addr),ip2,64);
			strcpy(gix_options-&gt;dhcp_interface[idx].ip_default_bootimage,opt_bootfile);
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;RANGE Interface: [%s](%d), IP: [%s - %s] Interface-Index: [%d/%d] BOOTFILE: [%s]\n&quot;,if_config[i_index].ethname,i_index,ip1,ip2,idx,gix_options-&gt;dhcp_interfaces,gix_options-&gt;dhcp_interface[idx].ip_default_bootimage);
#endif
			continue;
		
		}
		if ( strncmp(buf,&quot;[DHCP_IP_ME=&quot;,strlen(&quot;[DHCP_IP_ME=&quot;)) == 0 ){
			int i_index;
			char interface[256];
			struct sockaddr_in *retaddr;
			char ip[64];
			int idx;
			ptr = &amp;buf[strlen(&quot;[DHCP_IP_ME=&quot;)];
			strcpy(interface,ptr);
			ptr = interface;
			while ( *ptr &amp;&amp; *ptr != &#039;:&#039; ) ptr++;
			if ( *ptr != &#039;:&#039; ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d)\n&quot;,config_lines);
				continue;
			}
			*ptr = &#039;\0&#039;;
			ptr++;
			strcpy(ip,ptr);
			ptr = ip;
			while ( *ptr &amp;&amp; (*ptr == &#039;.&#039; || ( *ptr &gt;= &#039;0&#039; &amp;&amp; *ptr &lt;= &#039;9&#039; )) )ptr++;
			*ptr = &#039;\0&#039;;
			if ( (retaddr = check_valid_ipv4(ip,DHCP_DEFAULT_PORT_IN,SOCK_DGRAM)) == NULL ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) --&gt; Invalid IPv4 address\n&quot;,config_lines);
				continue;
			}
			for ( i_index = 0; i_index &lt; if_count; i_index++ ){
				if ( strcmp(interface,if_config[i_index].ethname) == 0 ) break;
			}
			if ( i_index == if_count ){
				logger(prefix,&quot;FATAL: Interface [%s] does not exist!\n&quot;,interface);
				continue;
			}
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_interfaces &amp;&amp; idx &lt; MAX_DHCP_INTERFACES; idx++ ){
				if ( gix_options-&gt;dhcp_interface[idx].index == i_index ) break;
			}
			if ( idx &gt;= MAX_DHCP_INTERFACES ){
				logger(prefix,&quot;WARNING: Error in config-file (Line: %d) --&gt; Too many interfaces defined (Max: %d)n&quot;,config_lines,MAX_DHCP_INTERFACES);
				continue;
			}
			if ( idx == gix_options-&gt;dhcp_interfaces ){
				gix_options-&gt;dhcp_interface[idx].index = i_index;
				init_defaults_dhcp(&amp;gix_options-&gt;dhcp_interface[idx]);
				gix_options-&gt;dhcp_interfaces++;
			} 
			memcpy(&amp;(gix_options-&gt;dhcp_interface[idx].ip_me),retaddr,sizeof(struct sockaddr_in));
			inet_ntop(AF_INET,&amp;(gix_options-&gt;dhcp_interface[idx].ip_me.sin_addr),ip,64);
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;ME Interface: [%s](%d), IP: [%s] Interface-Index: [%d/%d]\n&quot;,if_config[i_index].ethname,i_index,ip,idx,gix_options-&gt;dhcp_interfaces);
#endif
			continue;
		
		}
		if ( strncmp(buf,&quot;[DHCP_IP_ROUTER=&quot;,strlen(&quot;[DHCP_IP_ROUTER=&quot;)) == 0 ){
			int i_index;
			char interface[256];
			struct sockaddr_in *retaddr;
			char ip[64];
			int idx;
			ptr = &amp;buf[strlen(&quot;[DHCP_IP_ROUTER=&quot;)];
			strcpy(interface,ptr);
			ptr = interface;
			while ( *ptr &amp;&amp; *ptr != &#039;:&#039; ) ptr++;
			if ( *ptr != &#039;:&#039; ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d)\n&quot;,config_lines);
				continue;
			}
			*ptr = &#039;\0&#039;;
			ptr++;
			strcpy(ip,ptr);
			ptr = ip;
			while ( *ptr &amp;&amp; (*ptr == &#039;.&#039; || ( *ptr &gt;= &#039;0&#039; &amp;&amp; *ptr &lt;= &#039;9&#039; )) )ptr++;
			*ptr = &#039;\0&#039;;
			if ( (retaddr = check_valid_ipv4(ip,DHCP_DEFAULT_PORT_IN,SOCK_DGRAM)) == NULL ){
				logger(prefix,&quot;WARNING: Syntax Error in config-file (Line: %d) --&gt; Invalid IPv4 address\n&quot;,config_lines);
				continue;
			}
			for ( i_index = 0; i_index &lt; if_count; i_index++ ){
				if ( strcmp(interface,if_config[i_index].ethname) == 0 ) break;
			}
			if ( i_index == if_count ){
				logger(prefix,&quot;FATAL: Interface [%s] does not exist!\n&quot;,interface);
				continue;
			}
			for ( idx = 0; idx &lt; gix_options-&gt;dhcp_interfaces &amp;&amp; idx &lt; MAX_DHCP_INTERFACES; idx++ ){
				if ( gix_options-&gt;dhcp_interface[idx].index == i_index ) break;
			}
			if ( idx &gt;= MAX_DHCP_INTERFACES ){
				logger(prefix,&quot;WARNING: Error in config-file (Line: %d) --&gt; Too many interfaces defined (Max: %d)n&quot;,config_lines,MAX_DHCP_INTERFACES);
				continue;
			}
			if ( idx == gix_options-&gt;dhcp_interfaces ){
				gix_options-&gt;dhcp_interface[idx].index = i_index;
				init_defaults_dhcp(&amp;gix_options-&gt;dhcp_interface[idx]);
				gix_options-&gt;dhcp_interfaces++;
			} 
			memcpy(&amp;(gix_options-&gt;dhcp_interface[idx].ip_router),retaddr,sizeof(struct sockaddr_in));
			inet_ntop(AF_INET,&amp;(gix_options-&gt;dhcp_interface[idx].ip_router.sin_addr),ip,64);
#ifdef DEBUG_DHCP
			logger(prefix,&quot;DHCP-&gt;Router Interface: [%s](%d), IP: [%s] Interface-Index: [%d/%d]\n&quot;,if_config[i_index].ethname,i_index,ip,idx,gix_options-&gt;dhcp_interfaces);
#endif
			continue;
		
		}

		if ( strncmp(buf,&quot;[TFTP=yes]&quot;,strlen(&quot;[TFTP=yes]&quot;)) == 0 ){
			gix_options-&gt;tftp_enabled = 1;
			gix_options-&gt;tftp_port = 69;
			if ( strlen(gix_options-&gt;tftp_root) == 0 ){
				strcpy(gix_options-&gt;tftp_root,&quot;/TFTP&quot;);
			}
			logger(prefix,&quot;TFTP--&gt;ENABLED\n&quot;);
			continue;
		}
		if ( strncmp(buf,&quot;[TFTP_DIR=&quot;,strlen(&quot;[TFTP_DIR=&quot;)) == 0 ){
			char *ptr;
			strcpy(gix_options-&gt;tftp_root,&amp;buf[strlen(&quot;[TFTP_DIR=&quot;)]);
			ptr = gix_options-&gt;tftp_root;
			while ( *ptr ){
				if ( *ptr == &#039;]&#039; ){ *ptr = &#039;\0&#039;; break; }
				ptr++;
			}	
		}
		if ( strncmp(buf,&quot;[TFTP_READONLY=yes]&quot;,strlen(&quot;[TFTP_READONLY=yes]&quot;)) == 0 ){
			gix_options-&gt;tftp_readonly = 1;
			continue;
		}
		if ( strncmp(buf,&quot;[TFTP_READONLY=no]&quot;,strlen(&quot;[TFTP_READONLY=no]&quot;)) == 0 ){
			gix_options-&gt;tftp_readonly = 0;
			continue;
		}

		if ( strlen(buf) &lt; 4 || buf[0] == &#039;#&#039; || buf[0] == &#039;;&#039; ) continue;
		port = atoi(buf);
		ptr = buf;
		while ( *ptr &amp;&amp; *ptr != &#039; &#039; &amp;&amp; *ptr != &#039;\t&#039; ) ptr++;
		if ( *ptr == &#039;\0&#039; ) continue;

		while ( *ptr &amp;&amp; ( *ptr == &#039; &#039; ||  *ptr == &#039;\t&#039; ) ) ptr++;
		if ( *ptr == &#039;\0&#039; ) continue;
		max_conns = atoi(ptr);

		while ( *ptr &amp;&amp; *ptr != &#039; &#039; &amp;&amp; *ptr != &#039;\t&#039; ) ptr++;
		if ( *ptr == &#039;\0&#039; ) continue;

		while ( *ptr &amp;&amp; ( *ptr == &#039; &#039; ||  *ptr == &#039;\t&#039; ) ) ptr++;
		if ( *ptr == &#039;\0&#039; ) continue;

		timeout = atoi(ptr);
		while ( *ptr &amp;&amp; *ptr != &#039; &#039; &amp;&amp; *ptr != &#039;\t&#039; ) ptr++;
		if ( *ptr == &#039;\0&#039; ) continue;

		while ( *ptr &amp;&amp; ( *ptr == &#039; &#039; ||  *ptr == &#039;\t&#039; ) ) ptr++;
		if ( *ptr == &#039;\0&#039; ) continue;

		data_timeout = atoi(ptr);
		while ( *ptr &amp;&amp; *ptr != &#039; &#039; &amp;&amp; *ptr != &#039;\t&#039; ) ptr++;
		if ( *ptr == &#039;\0&#039; ) continue;
		while ( *ptr &amp;&amp; ( *ptr == &#039; &#039; ||  *ptr == &#039;\t&#039; ) ) ptr++;
		if ( *ptr == &#039;\0&#039; ) continue;
		strcpy(cmdline,ptr);

		if ( strlen(cmdline) &lt; 2 ) continue;
		if ( cmdline[strlen(cmdline)-1] == &#039;\r&#039; || cmdline[strlen(cmdline)-1] == &#039;\n&#039; ) cmdline[strlen(cmdline)-1] = &#039;\0&#039;;
		if ( cmdline[strlen(cmdline)-1] == &#039;\r&#039; || cmdline[strlen(cmdline)-1] == &#039;\n&#039; ) cmdline[strlen(cmdline)-1] = &#039;\0&#039;;
		if ( max_conns &lt;= 0 ) max_conns = MAX_CONNS;
		logger(&quot;MAIN&quot;,&quot;[%d] Port: %d, Max-Connections: %d, Timeout: %d, Data-Timeout: %d, Command: [%s]\n&quot;,idx,port,max_conns,timeout,data_timeout,cmdline);
		servlist[idx].port = port;
		servlist[idx].max_conns = max_conns;			
		servlist[idx].timeout = timeout;			
		servlist[idx].data_timeout = data_timeout;			
		servlist[idx].family = AF_INET;
		servlist[idx].reset = time(NULL);
		strcpy(servlist[idx].cmdline,cmdline);
		idx++;
		servlist[idx].port = port;
		servlist[idx].max_conns = max_conns;			
		servlist[idx].timeout = timeout;			
		servlist[idx].data_timeout = data_timeout;			
		servlist[idx].family = AF_INET6;
		servlist[idx].reset = time(NULL);
		strcpy(servlist[idx].cmdline,cmdline);
		idx++;
	}
        fclose(fp);
	entries = idx;
        logger(prefix,&quot;Starting servers with %d entries\n&quot;,entries);
	logger(prefix,&quot;TFTP-Enabled: %d, TFTP-Root-PATH: [%s], TFTP-READONLY: %d\n&quot;,gix_options-&gt;tftp_enabled, gix_options-&gt;tftp_root, gix_options-&gt;tftp_readonly);
	signal(SIGCHLD,SIG_IGN);
	for ( i = 0; i &lt; idx; i++ ){
		int pid;
		if ( (pid = fork()) == 0 ){
			start_server(i);
			exit(0);
		} else {
			servlist[i].pid = pid;
		}
	}
	signal(SIGTERM,terminator);
	tftp_pid = 0;
	dhcp_pid = 0;
	while(1){ 
		int status;
		sleep(1);
		if ( gix_options-&gt;dhcp_enabled == 1 &amp;&amp; gix_options-&gt;dhcp_pid == 0 ){
			if ( (dhcp_pid = fork()) == 0 ){
				start_dhcp();
				exit(0);
			} 
			gix_options-&gt;dhcp_pid = dhcp_pid;
			logger(prefix,&quot;DHCP-SERVER Started (PID: %d)\n&quot;,dhcp_pid);
		}
		if ( dhcp_pid &amp;&amp; waitpid(dhcp_pid,&amp;status,WNOHANG) == dhcp_pid ){
			if ( gix_options-&gt;dhcp_enabled == 1 ) logger(prefix,&quot;DHCP-SERVER[W] died unexpected...will be restarted soon\n&quot;);
			if ( gix_options-&gt;dhcp_enabled == 0 ) logger(prefix,&quot;DHCP-SERVER[W] turned off\n&quot;);
			gix_options-&gt;dhcp_pid = 0;
			dhcp_pid = 0;
			
		}
		if ( dhcp_pid &amp;&amp; kill(dhcp_pid,0) ){
			if ( gix_options-&gt;dhcp_enabled == 1 ) logger(prefix,&quot;DHCP-SERVER died unexpected...will be restarted soon\n&quot;);
			if ( gix_options-&gt;dhcp_enabled == 0 ) logger(prefix,&quot;DHCP-SERVER turned off\n&quot;);
			gix_options-&gt;dhcp_pid = 0;
			dhcp_pid = 0;
		}

		if ( gix_options-&gt;tftp_enabled == 1 &amp;&amp; gix_options-&gt;tftp_pid == 0 ){
			if ( (tftp_pid = fork()) == 0 ){
				start_tftp();
				exit(0);
			} 
			gix_options-&gt;tftp_pid = tftp_pid;
			logger(prefix,&quot;TFTP-SERVER Started (PID: %d)\n&quot;,tftp_pid);
		}
		if ( tftp_pid &amp;&amp; waitpid(tftp_pid,&amp;status,WNOHANG) == tftp_pid ){
			if ( gix_options-&gt;tftp_enabled == 1 ) logger(prefix,&quot;TFTP-SERVER[W] died unexpected...will be restarted soon\n&quot;);
			if ( gix_options-&gt;tftp_enabled == 0 ) logger(prefix,&quot;TFTP-SERVER[W] turned off\n&quot;);
			gix_options-&gt;tftp_pid = 0;
			tftp_pid = 0;
			
		}
		if ( tftp_pid &amp;&amp; kill(tftp_pid,0) ){
			if ( gix_options-&gt;tftp_enabled == 1 ) logger(prefix,&quot;TFTP-SERVER died unexpected...will be restarted soon\n&quot;);
			if ( gix_options-&gt;tftp_enabled == 0 ) logger(prefix,&quot;TFTP-SERVER turned off\n&quot;);
			gix_options-&gt;tftp_pid = 0;
			tftp_pid = 0;
		}
	}
}


void process_tftp_packet(int socket, unsigned char *data, int len, char *ipname, int port, struct sockaddr *addrinfo, int addr_len);
void process_data_packet(int slot, int sock, struct sockaddr *addr, int addr_len);


void start_tftp(){
	int s4, s6;
	int on;
	struct sockaddr *saddr6;
	struct sockaddr *saddr4;
	int saddr6_len;
	int saddr4_len;
	struct sockaddr_in sock4;
	struct sockaddr_in6 sock6;
	struct pollfd polly[MAX_TFTP_SESSIONS+3];
	int fdcnt;

	sprintf(prefix,&quot;TFTPSERVER&quot;);
	logger(prefix,&quot;TFTP-Server starting!\n&quot;);	
	gix_options = (struct gix_inetd_options *)shmat(shmid_options,NULL,0);
	if ( gix_options == NULL ){
		logger(prefix,&quot;FATAL(%s:%d) Cannot attach shared-memory\n&quot;,__FILE__,__LINE__);
		exit(0);
	}
	bzero((void *)gix_options-&gt;tr,sizeof(struct tftp_request) * MAX_TFTP_SESSIONS);

	s4 = socket(AF_INET,SOCK_DGRAM,0);
	if ( s4 &lt; 0 ){
		logger(prefix,&quot;FATAL(%s:%d) Cannot create socket!\n&quot;,__FILE__,__LINE__);
		exit(0);
	}	
	s6 = socket(AF_INET6,SOCK_DGRAM,0);
	if ( s6 &lt; 0 ){
		logger(prefix,&quot;FATAL(%s:%d) Cannot create socket!\n&quot;,__FILE__,__LINE__);
		exit(0);
	}	

	on = 1;
	if ( setsockopt(s6,SOL_SOCKET,SO_REUSEADDR,&amp;on,sizeof(on)) &lt; 0 ){
		logger	(prefix,&quot;FATAL(%s:%d) Cannot SO_REUSEADDR socket\n&quot;,__FILE__,__LINE__);
		exit(3);
	}
	if ( setsockopt(s4,SOL_SOCKET,SO_REUSEADDR,&amp;on,sizeof(on)) &lt; 0 ){
		logger	(prefix,&quot;FATAL(%s:%d) Cannot SO_REUSEADDR socket\n&quot;,__FILE__,__LINE__);
		exit(3);
	}

	sock4.sin_family = AF_INET;
	sock4.sin_addr.s_addr = INADDR_ANY;
	sock4.sin_port = htons(gix_options-&gt;tftp_port);
	saddr4 = (struct sockaddr *)&amp;sock4;
	saddr4_len = sizeof(sock4);
#ifdef IPV6_V6ONLY
	if ( setsockopt(s6,IPPROTO_IPV6, IPV6_V6ONLY,&amp;on,sizeof(on)) &lt; 0 ){
		logger	(prefix,&quot;FATAL(%s:%d) Cannot IPV6_V6ONLY socket\n&quot;,__FILE__,__LINE__);
		exit(3);
	}
#endif
	sock6.sin6_family = AF_INET6;
	sock6.sin6_port   = htons(gix_options-&gt;tftp_port);
	sock6.sin6_addr   = in6addr_any;
	saddr6 = (struct sockaddr *)&amp;sock6;
	saddr6_len = sizeof(sock6);


	
	if ( bind(s4,saddr4,saddr4_len) &lt; 0 ){
		logger	(prefix,&quot;FATAL(%s:%d) Cannot bind socket (IPv4)\n&quot;,__FILE__,__LINE__);
		exit(3);
	}
	if ( bind(s6,saddr6,saddr6_len) &lt; 0 ){
		logger	(prefix,&quot;FATAL(%s:%d) Cannot bind socket (IPv6)\n&quot;,__FILE__,__LINE__);
		exit(3);
	}

	
	while ( 1 ){
		int x,y;
		int retval;
		int packlen;
		unsigned char recvbuf[1024];
		polly[0].fd = s4;
		polly[1].fd = s6;
		polly[0].events = POLLIN;
		polly[1].events = POLLIN;
		fdcnt = 2;

		// Are we still enabled?

		if ( gix_options-&gt;tftp_enabled ){
			// Still enabled...
		} else {
			logger(prefix,&quot;TFTP-disabled...exiting\n&quot;);
			close(s4);
			close(s6); // Main sockets closed
			for ( x = 0; x &lt; MAX_TFTP_SESSIONS; x++ ){
				if ( gix_options-&gt;tr[x].active ){
					logger(prefix,&quot;TFTP-Session in Slot %d cancelling...\n&quot;,x);
					if ( gix_options-&gt;tr[x].sock &gt; 0 ) close(gix_options-&gt;tr[x].sock);
					if ( gix_options-&gt;tr[x].fd &gt; 0 ) close(gix_options-&gt;tr[x].fd);
				}
				bzero((void *)&amp;gix_options-&gt;tr[x],sizeof(struct tftp_request));
			}	
			exit(0);
		}	

		// Check for timeouts :-)

		for ( x = 0; x &lt; MAX_TFTP_SESSIONS; x++ ){
			if ( gix_options-&gt;tr[x].active &amp;&amp; time(NULL) &gt; (gix_options-&gt;tr[x].lastaction + TFTP_TIMEOUT) ){
				logger(prefix,&quot;TFTP-Session in Slot %d timed out! Cancelling...\n&quot;,x);
				if ( gix_options-&gt;tr[x].sock &gt; 0 ) close(gix_options-&gt;tr[x].sock);
				if ( gix_options-&gt;tr[x].fd &gt; 0 ) close(gix_options-&gt;tr[x].fd);
				bzero((void *)&amp;gix_options-&gt;tr[x],sizeof(struct tftp_request));
			}
		}

		for ( x = 0; x &lt; MAX_TFTP_SESSIONS; x++ ){
			if ( gix_options-&gt;tr[x].active &amp;&amp; gix_options-&gt;tr[x].sock &gt; 0 ){
				polly[fdcnt].fd = gix_options-&gt;tr[x].sock;
				polly[fdcnt++].events = POLLIN;
			}
		}
		retval = poll(polly,fdcnt,1000);
		if ( retval &gt; 0 ){
			if ( polly[0].revents &amp; POLLIN ){
				struct sockaddr_in socky4;
				int slen4;
				char ipname[1024];
				int port;
				bzero(ipname,1024);
				bzero(recvbuf,1024);
				slen4 = sizeof(socky4);
				packlen = recvfrom(s4,recvbuf,1023,0,&amp;socky4,&amp;slen4);
				inet_ntop(AF_INET,&amp;(socky4.sin_addr),ipname,1024);
				port = (int) ntohs(socky4.sin_port);
				logger(prefix,&quot;READ FOR IPv4 (%d Bytes) from: [%s]:%d\n&quot;,packlen,ipname,port);
				process_tftp_packet(s4,recvbuf,packlen,ipname,port,(struct sockaddr *)&amp;socky4,slen4);
				sprintf(prefix,&quot;TFTPSERVER&quot;);
			}	
			if ( polly[1].revents &amp; POLLIN ){
				struct sockaddr_in6 socky6;
				int slen6;
				char ipname[1024];
				int port;
				bzero(ipname,1024);
				bzero(recvbuf,1024);
				slen6 = sizeof(socky6);
				packlen = recvfrom(s6,recvbuf,1023,0,&amp;socky6,&amp;slen6);
				inet_ntop(AF_INET6,&amp;(socky6.sin6_addr),ipname,1024);
				port = (int) ntohs(socky6.sin6_port);
				logger(prefix,&quot;READ FOR IPv6 (%d Bytes) from: [%s]:%d\n&quot;,packlen,ipname,port);
				process_tftp_packet(s6,recvbuf,packlen,ipname,port,(struct sockaddr *)&amp;socky6,slen6);
				sprintf(prefix,&quot;TFTPSERVER&quot;);
			}	
			for ( x = 2; x &lt; fdcnt; x++ ){
				if ( polly[x].revents &amp; POLLIN ){
					for ( y = 0; y &lt; MAX_TFTP_SESSIONS; y++ ){
						if ( gix_options-&gt;tr[y].sock == polly[x].fd ){
							if ( gix_options-&gt;tr[y].addr_family == AF_INET ){
								struct sockaddr_in socky4;
								int slen4;
								char ipname[1024];
								int port;
								bzero(ipname,1024);
								bzero(recvbuf,1024);
								slen4 = sizeof(socky4);
								packlen = recvfrom(polly[x].fd,recvbuf,1023,0,&amp;socky4,&amp;slen4);
								inet_ntop(AF_INET,&amp;(socky4.sin_addr),ipname,1024);
								port = (int) ntohs(socky4.sin_port);
								logger(prefix,&quot;READ FOR SLOT[%d]-IPv4 (%d Bytes) from: [%s]:%d\n&quot;,y,packlen,ipname,port);
								process_tftp_packet(polly[x].fd,recvbuf,packlen,ipname,port,(struct sockaddr *)&amp;socky4,slen4);
								sprintf(prefix,&quot;TFTPSERVER&quot;);
							}
							if (  gix_options-&gt;tr[y].addr_family == AF_INET6 ){
								struct sockaddr_in6 socky6;
								int slen6;
								char ipname[1024];
								int port;
								bzero(ipname,1024);
								bzero(recvbuf,1024);
								slen6 = sizeof(socky6);
								packlen = recvfrom(polly[x].fd,recvbuf,1023,0,&amp;socky6,&amp;slen6);
								inet_ntop(AF_INET6,&amp;(socky6.sin6_addr),ipname,1024);
								port = (int) ntohs(socky6.sin6_port);
								logger(prefix,&quot;READ FOR SLOT[%d]-IPv6 (%d Bytes) from: [%s]:%d\n&quot;,y,packlen,ipname,port);
								process_tftp_packet(polly[x].fd,recvbuf,packlen,ipname,port,(struct sockaddr *)&amp;socky6,slen6);
								sprintf(prefix,&quot;TFTPSERVER&quot;);
							}
						}
					}
				}			
			}
		}
	}	
	

	logger(prefix,&quot;TFTP-Server ending!\n&quot;);	
	exit(0);
}

#define TFTP_SLOT gix_options-&gt;tr[slot]

void process_tftp_packet(int sock, unsigned char *data, int len, char *ipname,int port, struct sockaddr *addrinfo, int addr_len){
	unsigned int opcode;
	unsigned char reply[1024];
	char fullname[1024];
	int ret;
	int packsize;
	sprintf(prefix,&quot;TFTPSERVER([%s]:%d)&quot;,ipname,port);
	opcode = ((unsigned int)data[1]) + ((unsigned int)data[0]) * 256; 
	logger(prefix,&quot;OPCODE: %d\n&quot;,opcode);


	if ( opcode == 4 ){
		int slot;
		int pindex;
		pindex = data[2] * 256 + data[3];
		logger(prefix,&quot;ACK for Packet-ID: %d\n&quot;,pindex);
		for ( slot = 0; slot &lt; MAX_TFTP_SESSIONS; slot++ ){
			if ( strcmp(TFTP_SLOT.ipname,ipname) == 0 &amp;&amp; TFTP_SLOT.port == port ) break;
		}
		if ( slot == MAX_TFTP_SESSIONS ){
			logger(prefix,&quot;Slot not found --&gt; Ignoring\n&quot;);
			return;
		}
		logger(prefix,&quot;Processing packet from slot %d\n&quot;,slot);
		process_data_packet(slot,sock,addrinfo,addr_len);
		return;	
	}
	if ( opcode == 5 ){
		int slot;
		int error;
		char errtext[1024];
		bzero(errtext,1024);
		error = data[2] * 256 + data[3];
		strncpy(errtext,&amp;data[4],len-4);
		for ( slot = 0; slot &lt; MAX_TFTP_SESSIONS; slot++ ){
			if ( strcmp(TFTP_SLOT.ipname,ipname) == 0 &amp;&amp; TFTP_SLOT.port == port ) break;
		}
		logger(prefix,&quot;Received error (Code: %d) Text: [%s] for slot: %d\n&quot;,error,errtext,slot);
		return;
	}

	if ( opcode == 1 ){
		int i;
		int fd;
		int tsize_requested;
		int blksize_requested;
		int blksize_requested_value;	
		int timeout_requested;
		int options;
		int new_socket;
		char optscmd[1024];
		struct stat st;
		char filename[1024];
		char filemode[1024];
		bzero(filename,1024);
		bzero(filemode,1024);
		strcpy(filename,&amp;data[2]);
		gix_options-&gt;tftp_requests_read++; // Every try is counted ;-)
		if ( strlen(filename)+3 &lt; len ){
			strcpy(filemode,&amp;data[3+strlen(filename)]);
		}
		tsize_requested = 0;
		blksize_requested = 0;
		timeout_requested = 0;
		if ( (strlen(filename) + strlen(filemode) + 4) &lt; len ){
			int lastoffset;
			options = 1;
			lastoffset = strlen(filename) + strlen(filemode) + 4;
			while ( lastoffset &lt; len ){
				memcpy(optscmd,&amp;data[lastoffset],len - lastoffset);
				logger(prefix,&quot;Option: [%s] Offset: %d\n&quot;,optscmd,lastoffset);
				if ( strcmp(optscmd,&quot;tsize&quot;) == 0 ){
					tsize_requested = 1;
				}
				if ( strcmp(optscmd,&quot;blksize&quot;) == 0 ){
					char blksize[64];
					blksize_requested = 1;
					lastoffset += strlen(optscmd)+1;
					strcpy(blksize,&amp;data[lastoffset]);
					blksize_requested_value = atoi(blksize);
					logger(prefix,&quot;Requested BLKSIZE: %d Bytes\n&quot;,blksize_requested_value);
				}
				if ( strcmp(optscmd,&quot;timeout&quot;) == 0 ){
					timeout_requested = 1;
				}
				lastoffset += strlen(optscmd)+1;
			}
		} else {
			options = 0;
			strcpy(optscmd,&quot;&quot;);
		}
		logger(prefix,&quot;Requested File: [%s] Mode: [%s] Options: %d (%d vs %d)\n&quot;,filename,filemode,options,len, strlen(filename) + strlen(filemode) + 4);
		// Ok...lets check the file
		if ( strstr(filename,&quot;..&quot;) != NULL ){
			// Do not be tricky :-)
			reply[0] = 0;
			reply[1] = 5;
			reply[2] = 0;
			reply[3] = 1; // File not found :-)
			sprintf(&amp;reply[4],&quot;Invalid File&quot;);
			packsize = 4 + strlen(&amp;reply[4]) + 1;	
			ret = sendto(sock,reply,packsize,0,addrinfo,addr_len);
			logger(prefix,&quot;Invalid filename: [%s] --&gt; Send returned: %d\n&quot;,filename,ret);
			return;
		}
		if ( filename[0] == &#039;/&#039; )
			sprintf(fullname,&quot;%s%s&quot;,gix_options-&gt;tftp_root,filename);
		else
			sprintf(fullname,&quot;%s/%s&quot;,gix_options-&gt;tftp_root,filename);
		if ( stat(fullname,&amp;st) ){
			reply[0] = 0;
			reply[1] = 5;
			reply[2] = 0;
			reply[3] = 1; // File not found :-)
			sprintf(&amp;reply[4],&quot;File not found&quot;);
			packsize = 4 + strlen(&amp;reply[4]) + 1;	
			ret = sendto(sock,reply,packsize,0,addrinfo,addr_len);
			logger(prefix,&quot;File not found: [%s] --&gt; Send returned: %d\n&quot;,filename,ret);
			return;
		}
		logger(prefix,&quot;Requesting file: [%s], %d Bytes\n&quot;,fullname,st.st_size);
		fd = open(fullname,O_RDONLY);
		if ( fd &lt; 0 ){
			reply[0] = 0;
			reply[1] = 5;
			reply[2] = 0;
			reply[3] = 1; // File not found :-)
			sprintf(&amp;reply[4],&quot;FILE NOT FOUND&quot;);
			packsize = 4 + strlen(&amp;reply[4]) + 1;	
			ret = sendto(sock,reply,packsize,0,addrinfo,addr_len);
			logger(prefix,&quot;File not found: [%s] --&gt; Send returned: %d\n&quot;,filename,ret);
			return;
		}
		new_socket = socket(addrinfo-&gt;sa_family,SOCK_DGRAM,0);
		if ( new_socket &lt; 0 ){
			close(fd);
			reply[0] = 0;
			reply[1] = 5;
			reply[2] = 0;
			reply[3] = 0; // No more sockets available
			sprintf(&amp;reply[4],&quot;Server busy...Try again later&quot;);
			packsize = 4 + strlen(&amp;reply[4]) + 1;	
			ret = sendto(sock,reply,packsize,0,addrinfo,addr_len);
			logger(prefix,&quot;No more sockets! [%s] --&gt; Send returned: %d\n&quot;,filename,ret);
			return;
		}
		for ( i = 0; i &lt; MAX_TFTP_SESSIONS; i++ ){
			if ( gix_options-&gt;tr[i].active == 0 ){
				gix_options-&gt;tr[i].active = 1;
				gix_options-&gt;tr[i].lastaction = time(NULL);
				gix_options-&gt;tr[i].started = gix_options-&gt;tr[i].lastaction;
				strcpy(gix_options-&gt;tr[i].ipname,ipname);
				strcpy(gix_options-&gt;tr[i].filename,filename);
				gix_options-&gt;tr[i].port = port;
				gix_options-&gt;tr[i].kind_request = TFTP_REQUEST_READ;
				gix_options-&gt;tr[i].fullsize = st.st_size;
				gix_options-&gt;tr[i].fd = fd;
				gix_options-&gt;tr[i].offset = (size_t) 0;
				gix_options-&gt;tr[i].cur_packet = (size_t) 0;
				gix_options-&gt;tr[i].addr_family = addrinfo-&gt;sa_family;
				gix_options-&gt;tr[i].options = options;
				gix_options-&gt;tr[i].sock = new_socket;
				if ( blksize_requested ){
					if ( blksize_requested_value &gt; TFTP_MAX_PACKSIZE ){
						gix_options-&gt;tr[i].packsize = TFTP_MAX_PACKSIZE;
					} else {
						gix_options-&gt;tr[i].packsize = blksize_requested_value;
					}
				} else {
					gix_options-&gt;tr[i].packsize = TFTP_DEFAULT_PACKSIZE;
				}
				logger(prefix,&quot;Will use a packsize of %d Bytes\n&quot;,gix_options-&gt;tr[i].packsize);
				break;
			}
		}	
		if ( i == MAX_TFTP_SESSIONS ){
			close(fd);
			reply[0] = 0;
			reply[1] = 5;
			reply[2] = 0;
			reply[3] = 0; // File not found :-)
			sprintf(&amp;reply[4],&quot;Server busy...try again later&quot;);
			packsize = 4 + strlen(&amp;reply[4]) + 1;	
			ret = sendto(sock,reply,packsize,0,addrinfo,addr_len);
			logger(prefix,&quot;MAX_TFTP_SESSIONS reached! [%s] --&gt; Send returned: %d\n&quot;,filename,ret);
			return;
		}
		if ( options ){
			int current_offset;
			current_offset = 0;
			reply[current_offset++] = 0;
			reply[current_offset++] = 6;
			if ( tsize_requested ){
				sprintf(&amp;reply[current_offset],&quot;tsize&quot;);
				current_offset += strlen(&amp;reply[current_offset])+1;	
				sprintf(&amp;reply[current_offset],&quot;%ld&quot;,st.st_size);
				current_offset += strlen(&amp;reply[current_offset])+1;	
			}
			if ( blksize_requested ){
				sprintf(&amp;reply[current_offset],&quot;blksize&quot;);
				current_offset += strlen(&amp;reply[current_offset])+1;	
				sprintf(&amp;reply[current_offset],&quot;%d&quot;,gix_options-&gt;tr[i].packsize);
				current_offset += strlen(&amp;reply[current_offset])+1;	
			}
			if ( timeout_requested ){
				sprintf(&amp;reply[current_offset],&quot;timeout&quot;);
				current_offset += strlen(&amp;reply[current_offset])+1;	
				sprintf(&amp;reply[current_offset],&quot;200&quot;);
				current_offset += strlen(&amp;reply[current_offset])+1;	
			}
			ret = sendto(gix_options-&gt;tr[i].sock,reply,current_offset,0,addrinfo,addr_len);
			logger(prefix,&quot;SENDING OPTIONS TO Client (%d Bytes) --&gt; %d\n&quot;,current_offset,ret);
		}
		logger(prefix,&quot;File [%s] will be processed from Slot %d (Addr-Family: %d, SOCKET-FD: %d)\n&quot;,fullname,i,addrinfo-&gt;sa_family,gix_options-&gt;tr[i].sock);
		process_data_packet(i,sock,addrinfo,addr_len);
		return;
	}
}


void process_data_packet(int slot, int sock, struct sockaddr *addrinfo, int addr_len){
	unsigned char send_data[TFTP_MAX_PACKSIZE+10];
	int packsize;
	int red;
	int ret;
	red = read(TFTP_SLOT.fd,&amp;send_data[4],TFTP_SLOT.packsize);
	if ( red &lt; 0 ){
		close(TFTP_SLOT.fd);	
		bzero(&amp;TFTP_SLOT,sizeof(struct tftp_request));
		send_data[0] = 0;
		send_data[1] = 5;
		send_data[2] = 0;
		send_data[3] = 0; // File not found :-)
		sprintf(&amp;send_data[4],&quot;File-Read-Error&quot;);
		packsize = 4 + strlen(&amp;send_data[4]) + 1;	
		ret = sendto(sock,send_data,packsize,0,addrinfo,addr_len);
		logger(prefix,&quot;File read error: [%s] --&gt; Send returned: %d\n&quot;,TFTP_SLOT.filename,ret);
		return;
	}
	logger(prefix,&quot;[%d] Read from file %s [Current Offset: %&quot; PRId64 &quot;/%&quot; PRId64 &quot;, Packet-Nr: %d] Read: %d\n&quot;,slot,TFTP_SLOT.filename,(int64_t)TFTP_SLOT.offset,(int64_t)TFTP_SLOT.fullsize,TFTP_SLOT.cur_packet,red);
	TFTP_SLOT.lastaction = time(NULL);
	TFTP_SLOT.offset += (size_t)red;
	TFTP_SLOT.cur_packet++;
	send_data[0] = 0;
	send_data[1] = 3;
	send_data[2] = TFTP_SLOT.cur_packet / 256;
	send_data[3] = TFTP_SLOT.cur_packet &amp; 0xFF;
	packsize = 4 + red;
	ret = sendto(TFTP_SLOT.sock,send_data,packsize,0,addrinfo,addr_len);
	logger(prefix,&quot;File read OK: [%d] --&gt; Send returned: %d/%d [%02X][%02X]\n&quot;,slot,ret,packsize,send_data[2],send_data[3]);
	if ( red == 0 ){ 
		close(TFTP_SLOT.fd); 
		close(TFTP_SLOT.sock); 
		bzero(&amp;TFTP_SLOT,sizeof(struct tftp_request));
		logger(prefix,&quot;File finished! Freeing slot %d\n&quot;,slot);
	}
	return;
}

#define DHCP_INTERFACE            gix_options-&gt;dhcp_interface[idx]
#define DHCP_INTERFACE_IF_CONFIG  if_config[DHCP_INTERFACE.index]

void process_dhcp_packet(int idx);

void start_dhcp(){
	int idx;

	sprintf(prefix,&quot;DHCPSERVER&quot;);
	logger(prefix,&quot;DHCP-Server starting (%d fixed Host-Entries, %d Interfaces, %d Bootimages, %d denials)\n&quot;,
			gix_options-&gt;dhcp_hosts, gix_options-&gt;dhcp_interfaces, gix_options-&gt;dhcp_bootfiles,gix_options-&gt;dhcp_denials);
	for ( idx = 0; idx &lt; gix_options-&gt;dhcp_interfaces; idx++ ){
		if ( (DHCP_INTERFACE.send_socket = socket(AF_PACKET,SOCK_RAW,IPPROTO_RAW)) &lt; 0 ){
			logger(prefix,&quot;FATAL: Cannot open send_socket for interface: [%s](%s)\n&quot;,DHCP_INTERFACE_IF_CONFIG.ethname,strerror(errno));
			return;
		}
		{
			struct ifreq if_idx;
			char ifName[IFNAMSIZ];
			strcpy(ifName,DHCP_INTERFACE_IF_CONFIG.ethname);
			bzero(&amp;if_idx,sizeof(struct ifreq));
			strncpy(if_idx.ifr_name,ifName,IFNAMSIZ-1);
			if ( ioctl(DHCP_INTERFACE.send_socket,SIOCGIFINDEX,&amp;if_idx) &lt; 0 ){
				logger(prefix,&quot;FATAL: Cannot get interface_index from [%s]\n&quot;,ifName);
				close(DHCP_INTERFACE.send_socket);
				return;
			}
			logger(prefix,&quot;INDEX for Interface: %d (%s)\n&quot;,if_idx.ifr_ifindex,ifName);
			DHCP_INTERFACE.saddr_l.sll_ifindex = if_idx.ifr_ifindex;
			DHCP_INTERFACE.saddr_l.sll_halen = ETH_ALEN;
			
		}	
		if ( (DHCP_INTERFACE.socket = socket(AF_PACKET,SOCK_RAW,htons(ETH_P_ALL))) &lt; 0 ){
			close(DHCP_INTERFACE.send_socket);
			logger(prefix,&quot;FATAL: Cannot open socket for interface: [%s](%s)\n&quot;,DHCP_INTERFACE_IF_CONFIG.ethname,strerror(errno));
			return;
		}
		if ( strlen(DHCP_INTERFACE_IF_CONFIG.ethname) &gt; IFNAMSIZ ){
			close(DHCP_INTERFACE.socket);
			close(DHCP_INTERFACE.send_socket);
			logger(prefix,&quot;FATAL: Cannot set socket-binding for interface: [%s] (Name to long)\n&quot;,DHCP_INTERFACE_IF_CONFIG.ethname);
			return;
		}
		if ( setsockopt(DHCP_INTERFACE.socket,SOL_SOCKET, SO_BINDTODEVICE, DHCP_INTERFACE_IF_CONFIG.ethname, strlen(DHCP_INTERFACE_IF_CONFIG.ethname)) &lt; 0 ){
			close(DHCP_INTERFACE.socket);
			close(DHCP_INTERFACE.send_socket);
			logger(prefix,&quot;FATAL: Cannot set socket-binding for interface: [%s] (SO_BINDTODEVICE: %s)\n&quot;,DHCP_INTERFACE_IF_CONFIG.ethname,strerror(errno));
			return;
		}
		logger(prefix,&quot;Interface: [%s]...assigned socket: %d (receive), %d (sending), MAC-Addr: [%s] Port: %d IF-INDEX: %d\n&quot;,
			DHCP_INTERFACE_IF_CONFIG.ethname, DHCP_INTERFACE.socket,DHCP_INTERFACE.send_socket, dump_mac_addr(DHCP_INTERFACE.mac), DHCP_INTERFACE.ip_port_in,DHCP_INTERFACE.saddr_l.sll_ifindex);
	}
	// Main-Loop...poll and wait for packets :-)
	while (1){
		struct pollfd polly[MAX_DHCP_INTERFACES];
		int pollfds;
		int retval;

		if ( gix_options-&gt;dhcp_enabled == 0 ) goto EXIT_DHCP; // Is it still wanted, that we work?
		
		pollfds = gix_options-&gt;dhcp_interfaces;
		
		for ( idx = 0; idx &lt; pollfds; idx++ ){
			polly[idx].fd = DHCP_INTERFACE.socket;
#ifdef POLLRDHUP
			polly[idx].events = POLLIN | POLLERR | POLLHUP | POLLRDHUP;
#else
			polly[idx].events = POLLIN | POLLERR | POLLHUP;
#endif
			polly[idx].revents = 0;
		}
		retval = poll(polly,pollfds,1000);
		if ( retval &lt; 0 ){
			logger(prefix,&quot;POLL failed...exiting [%s]\n&quot;,strerror(errno));
			goto EXIT_DHCP;
		}
		if ( retval &gt; 0 ){
			for ( idx = 0; idx &lt; pollfds; idx++ ){
				if ( polly[idx].revents &amp; POLLIN ){
					process_dhcp_packet(idx);
					continue;
				}
#ifdef POLLRDHUP
				if ( (polly[idx].revents &amp; POLLHUP) ||  (polly[idx].revents &amp; POLLRDHUP) || (polly[idx].revents &amp; POLLERR ) ){
#else
				if ( (polly[idx].revents &amp; POLLHUP) || (polly[idx].revents &amp; POLLERR ) ){
#endif
					logger(prefix,&quot;Socket for interface [%s] corrupted...closing DHCP-Server (will be restarted automatically)\n&quot;,DHCP_INTERFACE_IF_CONFIG.ethname);
					goto EXIT_DHCP;
				}
			}
		}
	
	}

	// Never reached (normally) :-)
EXIT_DHCP:
	for ( idx = 0; idx &lt; gix_options-&gt;dhcp_interfaces; idx++ ){
		if ( DHCP_INTERFACE.socket ) close(DHCP_INTERFACE.socket);
		if ( DHCP_INTERFACE.send_socket ) close(DHCP_INTERFACE.send_socket);
	}
	logger(prefix,&quot;Ending\n&quot;);
	exit(0);
}

int dhcp_check_ipv4_pool_address(int idx, u_int32_t check_address, u_int8_t *mac);

void process_dhcp_packet(int idx){
	u_int8_t packet[8192]; // Even big enough for jumbo-frames :-)
	struct ethhdr *ethhdr;
	int p_size;
	char ether_source[64];
	char ether_target[64];


	p_size = recv(DHCP_INTERFACE.socket,packet,8192,0);
	ethhdr = (struct ethhdr *)packet;
	if ( memcmp(ethhdr-&gt;h_source,DHCP_INTERFACE.mac,6) == 0 ){ // Ignore own packets 
		return;
	}
	if ( memcmp(ethhdr-&gt;h_dest,DHCP_INTERFACE.mac,6) != 0 &amp;&amp; memcmp(ethhdr-&gt;h_dest,ether_bcast,6) != 0 ){ // Only packets for my interface :-)
		return;
	}
	// We are only interested in IP and IPv6 Packets  

		

	strcpy(ether_source,dump_mac_addr(ethhdr-&gt;h_source));
	strcpy(ether_target,dump_mac_addr(ethhdr-&gt;h_dest));
	if ( ntohs(ethhdr-&gt;h_proto) == ETH_P_IPV6 ){
		// logger(prefix,&quot;IPv6[%s] (%d Bytes data) [%s] Proto: [0x%04X]\n&quot;,DHCP_INTERFACE_IF_CONFIG.ethname,p_size,dump_mac_addr(ethhdr-&gt;h_source),ntohs(ethhdr-&gt;h_proto));
		// Is the MAC allowed at all?
		{
			int i;
			for ( i = 0; i &lt; gix_options-&gt;dhcp_denials; i++ ){
				if ( memcmp(gix_options-&gt;dhcp_deny[i].mac.ether_addr_octet,ethhdr-&gt;h_source,6) == 0 ){
					logger(prefix,&quot;IGNORING unallowed Packet from: [%s]/DHCP\n&quot;,dump_mac_addr(gix_options-&gt;dhcp_deny[i].mac.ether_addr_octet));
					return;
				}
			}
		}
		return;
	}
	if ( ntohs(ethhdr-&gt;h_proto) == ETH_P_IP ){ // A IPv4  Packet
		int opt_len; // If 0...only a BOOTP-Request
		struct dhcp_features features;
		struct bootp_packet *bootp;
		u_int8_t magic_cookie[4];	
		struct ip *iphdr;
		struct gix_udphdr *udphdr;
		int ip_hlen;
		int udp_datalen;
		int p_len;
		int d_len;
		unsigned short s_port;
		unsigned short d_port;
		iphdr = (struct ip *)&amp;packet[sizeof(struct ethhdr)];
		ip_hlen = (int)(((unsigned int)(iphdr-&gt;ip_hl)) &lt;&lt; 2);
		// We are only interested in UDP
		if ( iphdr-&gt;ip_p != IPPROTO_UDP ) return;  // Check if UDP-Request
		bzero(&amp;features,sizeof(struct dhcp_features));
		memcpy(features.source_mac,ethhdr-&gt;h_source,6);

		struct sockaddr_in ip_source;
		struct sockaddr_in ip_target; 	
#ifdef DEBUG_DHCP
		char source_ip[128];
		char target_ip[128];
#endif
		ip_source.sin_family = AF_INET;
		ip_target.sin_family = AF_INET;
		memcpy(&amp;ip_source.sin_addr,&amp;(iphdr-&gt;ip_src),4);
		memcpy(features.source_ip,&amp;(iphdr-&gt;ip_src),4);
		memcpy(&amp;ip_target.sin_addr,&amp;(iphdr-&gt;ip_dst),4);
#ifdef DEBUG_DHCP
		inet_ntop(AF_INET,&amp;ip_source.sin_addr,source_ip,128);
		inet_ntop(AF_INET,&amp;ip_target.sin_addr,target_ip,128);
#endif
		udphdr = (struct gix_udphdr *)&amp;packet[sizeof(struct ethhdr)+ip_hlen];
		s_port = ntohs(udphdr-&gt;source);	
		d_port = ntohs(udphdr-&gt;dest);	

		if ( d_port != DHCP_INTERFACE.ip_port_in ) return; // We only want DHCP packets :-)
		// Is the MAC allowed at all?
		{
			int i;
			for ( i = 0; i &lt; gix_options-&gt;dhcp_denials; i++ ){
				if ( memcmp(gix_options-&gt;dhcp_deny[i].mac.ether_addr_octet,ethhdr-&gt;h_source,6) == 0 ){
					logger(prefix,&quot;IGNORING unallowed Packet from: [%s]/DHCP\n&quot;,dump_mac_addr(gix_options-&gt;dhcp_deny[i].mac.ether_addr_octet));
					return;
				}
			}
		}
		udp_datalen = ntohs(udphdr-&gt;len);
		p_len = udp_datalen + sizeof(struct ethhdr) + ip_hlen;
		if ( p_len != p_size ){
			logger(prefix,&quot;WARNING: ignoring corrupted packet:[%s] (%d Bytes) ETH[%s]-&gt;[%s] (%s:%d) -&gt; (%s:%d) IP-HLEN: %d Bytes Calc-Len: %d\n&quot;,DHCP_INTERFACE_IF_CONFIG.ethname,p_size,ether_source,ether_target,source_ip,(int) s_port,target_ip,(int) d_port,ip_hlen,p_len);
			return;
		}
		d_len = p_len - (sizeof(struct ethhdr) + ip_hlen +  sizeof(struct gix_udphdr));		
#ifdef DEBUG_DHCP
		logger(prefix,&quot;***NEW REQUEST***\n&quot;);
		logger(prefix,&quot;IP[%s] (%d Bytes) ETH[%s]-&gt;[%s] (%s:%d) -&gt; (%s:%d) IP-HLEN: %d Bytes DHCP-Len: %d\n&quot;,DHCP_INTERFACE_IF_CONFIG.ethname,p_size,ether_source,ether_target,source_ip,(int) s_port,target_ip,(int) d_port,ip_hlen,d_len);
		logger(prefix,&quot;TOS: %d, ID: %d, IP_OFF: 0x%04X, TTL: %d, Protocol: %d\n&quot;,
			(int) iphdr-&gt;ip_tos, (int) iphdr-&gt;ip_id, (int) iphdr-&gt;ip_off, (int) iphdr-&gt;ip_ttl, (int) iphdr-&gt;ip_p);
#endif
		bootp = (struct bootp_packet *)&amp;packet[sizeof(struct ethhdr) + ip_hlen + sizeof(struct gix_udphdr)];
#ifdef DEBUG_DHCP
		logger(prefix,&quot;HTYPE: %d, HLEN: %d, HOPS: %d, XID: 0x%08lX Secs: %d FLAGS: 0x%04X\n&quot;,
				(int) bootp-&gt;htype, (int) bootp-&gt;hlen, (int) bootp-&gt;hops, bootp-&gt;xid, (int) bootp-&gt;secs, (int) bootp-&gt;flags);
		logger(prefix,&quot;CIADDR: [0x%08lX] YIADDR: [0x%08lX]\n&quot;, bootp-&gt;ciaddr, bootp-&gt;yiaddr);
#endif
		opt_len = d_len - sizeof(struct bootp_packet);
		if ( bootp-&gt;flags &amp; 0x80 ) features.wants_broadcast = 1;
		if ( memcmp(&amp;(ip_target.sin_addr.s_addr),&amp;(DHCP_INTERFACE.ip_me.sin_addr.s_addr),4) == 0 ) features.is_dedicated = 1;	
		logger(prefix,&quot;(%d Bytes) BOOTP-OP: %d  HTYPE: %d HLEN: %d HOPS: %d XID: 0x%08X FLAGS: 0x%02X SNAME: [%.64s] Total: %d Bytes, Options: %d Bytes DHCP: [%s] Broadcast-Reply: [%s] Dedicated: [%s]\n&quot;,
			sizeof(struct bootp_packet),bootp-&gt;op, bootp-&gt;htype, bootp-&gt;hlen, bootp-&gt;hops, bootp-&gt;xid, bootp-&gt;flags, bootp-&gt;sname, d_len, opt_len, opt_len &gt; 0 ? &quot;YES&quot; : &quot;NO&quot;, features.wants_broadcast ? &quot;YES&quot; : &quot;NO&quot;, features.is_dedicated ? &quot;YES&quot; : &quot;NO&quot;);

		if ( bootp-&gt;op != 1 ){ // We only accept requests...no replies :-)
			return;
		}
#define DHCP_OPTIONS_OFFSET (sizeof(struct ethhdr) + ip_hlen + sizeof(struct gix_udphdr)+sizeof(struct bootp_packet))
		if ( opt_len &gt; 0 ){ // A DHCP-Request :-)
			int offset;
			int msg_type;
			struct sockaddr_in option50ip;	
			bzero(&amp;option50ip,sizeof(struct sockaddr_in));
			features.wants_dhcp = 1;	
			memcpy(magic_cookie,&amp;packet[DHCP_OPTIONS_OFFSET],4);
#ifdef DEBUG_DHCP
			logger(prefix,&quot;MAGIC-COOKIE: %02X%02X%02X%02X\n&quot;, magic_cookie[0], magic_cookie[1], magic_cookie[2], magic_cookie[3]);
#endif
			if ( memcmp(magic_cookie,dhcp_magic_cookie,4) != 0 ){
				logger(prefix,&quot;WARNING: Illegal DHCP request (wrong magic cookie value [%02X%02X%02X%02X])\n&quot;, magic_cookie[0], magic_cookie[1], magic_cookie[2], magic_cookie[3]);
				return;
			}
			// Now let us parse the options :-)
			offset = DHCP_OPTIONS_OFFSET + 4; // Jump over magic-cookie
			while ( offset &lt; p_size ){
				u_int8_t option;
				u_int8_t optlen;
				option = packet[offset++];
				if ( option == 0 ) continue; // Padding
				if ( option == 255 ) break;  // Options done
				optlen = packet[offset++];
				logger(prefix,&quot;[%04d/%04d]Option: %d [%s], Len: %d, Value: [%s]\n&quot;,offset,p_size,option,get_type_name(option),optlen,make_print(&amp;packet[offset],optlen));
				if ( option == 53 ){ 
					msg_type = (int)packet[offset];
					logger(prefix,&quot;REQUEST-TYPE: [%s]\n&quot;,dhcp_message_type(msg_type));
					offset += optlen;
					continue;
				}
				if ( option == 50 ){ // Normallu this must be sent in a REQUEST
					option50ip.sin_family = AF_INET;		
					memcpy(&amp;(option50ip.sin_addr.s_addr),&amp;packet[offset],4);
#ifdef DEBUG_DHCP
					{
						char ip_helpa[64];
						inet_ntop(AF_INET,&amp;(option50ip.sin_addr),ip_helpa,64);
						logger(prefix,&quot;*** Client Requests IP: [%s]\n&quot;,ip_helpa);
					}
#endif
					offset += optlen;
					continue;
				}
				if ( option == 60 ){ // Client Class-ID
					features.class_id = (u_int8_t *)malloc(optlen);
					features.class_id_len = optlen;
					memcpy(features.class_id,&amp;packet[offset],optlen);
					logger(prefix,&quot;Client-Class: [%s] (%d Bytes)\n&quot;,make_print(&amp;packet[offset],optlen),optlen);
					offset += optlen;
					continue;
				}
				if ( option == 12 ){ // Client hostname
					features.hostname = (u_int8_t *)malloc(optlen);
					features.hostname_len = optlen;
					memcpy(features.hostname,&amp;packet[offset],optlen);
					logger(prefix,&quot;Client-Hostname: [%s] (%d Bytes)\n&quot;,make_print(&amp;packet[offset],optlen),optlen);
					offset += optlen;
					continue;
				}
				if ( option == 55 ){
					int i;
					logger(prefix,&quot;CLIENT WANTS: %d Options\n&quot;,optlen);
					for ( i = 0; i &lt; optlen; i++ ){
						memcpy(features.o_wants_optlist,&amp;packet[offset],optlen);
						features.o_wants_optlist_len = optlen; 
						logger(prefix,&quot;OPTION[%d]: [%d] [%s]\n&quot;,i,(int)packet[offset+i],get_type_name((int)packet[offset+i]));
						/*
						if ( (int)packet[offset+i] == 1 ) features.o_wants_subnetmask = 1;
						if ( (int)packet[offset+i] == 3 ) features.o_wants_router = 1;
						if ( (int)packet[offset+i] == 5 ) features.o_wants_nameserver = 1;
						if ( (int)packet[offset+i] == 6 ) features.o_wants_domain_nameserver = 1;
						if ( (int)packet[offset+i] == 12 ) features.o_wants_hostname = 1;
						if ( (int)packet[offset+i] == 13 ) features.o_wants_bootfile_size = 1;
						if ( (int)packet[offset+i] == 15 ) features.o_wants_domain_name = 1;
						if ( (int)packet[offset+i] == 28 ) features.o_wants_broadcastaddress = 1;
						if ( (int)packet[offset+i] == 50 ) features.o_wants_address = 1;
						if ( (int)packet[offset+i] == 51 ) features.o_wants_leasetime = 1;
						if ( (int)packet[offset+i] == 54 ) features.o_wants_dhcp_server_id = 1;
						if ( (int)packet[offset+i] == 58 ) features.o_wants_renewal_time = 1;
						if ( (int)packet[offset+i] == 67 ) features.o_wants_bootfile = 1;
						if ( (int)packet[offset+i] == 66 ) features.o_wants_tftpserver = 1; // Servername
						*/
					}
					offset += optlen;
					continue;
				}
				
				offset += optlen;
			}	
#ifdef DEBUG_DHCP
			logger(prefix,&quot;Options parsed: Offset: %d\n&quot;,offset);
#endif


			if ( msg_type == DHCP_T_RELEASE ){ // A DHCPRELEASE-Request :-)
				struct dhcp_ip_file_entry_t *found;
				logger(prefix,&quot;Processing DHCPRELEASE FOR: [%s]\n&quot;,dump_mac_addr(features.source_mac));		
				found = dhcp_ip_get_entry(features.source_mac);
				if ( found == NULL ){
					logger(prefix,&quot;WARNING: Received RELEASE FROM unknown address [%s]\n&quot;,dump_mac_addr(features.source_mac));
					free_features(&amp;features);
					return;
				}
				dhcp_ip_remove_entry_by_mac(features.source_mac);
				logger(prefix,&quot;Successfully processed DHCPRELEASE FOR: [%s]\n&quot;,dump_mac_addr(features.source_mac));		
				free_features(&amp;features);
				return; 
			}
			if ( msg_type == DHCP_T_DECLINE ){ // A DHCP-Decline :-)
				logger(prefix,&quot;Processing a DHCPDECLINE FOR: [%s]\n&quot;,dump_mac_addr(features.source_mac));		
				dhcp_ip_invalid_entry(features.source_mac,30); // Will be locked for 30 seconds...so the next assignement uses different address
				send_udp_response_ip(idx,DHCP_T_NACK,&amp;features,bootp,NULL,NULL);
				free_features(&amp;features);
				return;		
			}
			if ( msg_type == 1 ){ // A DHCPDISCOVER-Request :-)
				int i;
				struct sockaddr_in found_ip;	
				char print_ip[64];
				char bootfile[1024];
				bzero(bootfile,1024);
				logger(prefix,&quot;Processing DHCPDISCOVERY FOR: [%s]\n&quot;,dump_mac_addr(features.source_mac));		
				for ( i = 0; i &lt; gix_options-&gt;dhcp_hosts; i++ ){
					if ( memcmp(gix_options-&gt;dhcp_host[i].mac.ether_addr_octet,features.source_mac,6) == 0 ){
						int retval;

						struct dhcp_ip_file_entry_t *f_entry;	
						u_int8_t f_entry_buffer[sizeof(struct dhcp_ip_file_entry_t) + DHCP_MAX_OPTSIZE];
						f_entry = (struct dhcp_ip_file_entry_t *) f_entry_buffer;
						bzero(f_entry,sizeof(struct dhcp_ip_file_entry_t) + DHCP_MAX_OPTSIZE);

						inet_ntop(AF_INET,&amp;(gix_options-&gt;dhcp_host[i].ip_addr.sin_addr),print_ip,64);
						logger(prefix,&quot;Found matching entry for [%s] --&gt; [%s]\n&quot;,dump_mac_addr(features.source_mac),print_ip);
						dhcp_ip_remove_entry_by_mac(features.source_mac); // Remove old entry...maybe someone changed the configuration
						f_entry-&gt;created = time(NULL);
						f_entry-&gt;expiry  = time(NULL) + 10; // Keep only for 10 seconds...
						memcpy(f_entry-&gt;ip,&amp;(gix_options-&gt;dhcp_host[i].ip_addr.sin_addr),4);
						memcpy(f_entry-&gt;mac,features.source_mac,6);
						memcpy(&amp;found_ip,&amp;(gix_options-&gt;dhcp_host[i].ip_addr),sizeof(struct sockaddr_in));
						if ( strlen(gix_options-&gt;dhcp_host[i].bootfile) ) strcpy(bootfile,gix_options-&gt;dhcp_host[i].bootfile);
						{
							int optoffset;

							optoffset = 0;
							if ( features.class_id_len &gt; 0 ){
								f_entry-&gt;opts[optoffset++] = 60; // DHCP-Option 60 for CLASS-ID
								f_entry-&gt;opts[optoffset++] = features.class_id_len;
								memcpy(&amp;f_entry-&gt;opts[optoffset],features.class_id, features.class_id_len);
								optoffset += features.class_id_len;
							}
							if ( features.hostname_len &gt; 0 ){
								f_entry-&gt;opts[optoffset++] = 12; // DHCP-Option 12 for HOSTNAME
								f_entry-&gt;opts[optoffset++] = features.hostname_len;
								memcpy(&amp;f_entry-&gt;opts[optoffset],features.hostname, features.hostname_len);
								optoffset += features.hostname_len;
							}
							f_entry-&gt;optlen  = (u_int16_t) optoffset; 
							
						}
						if ( ( retval = dhcp_ip_add_entry(f_entry)) != 0 ){
							logger(prefix,&quot;Failed to write lease to file! (%d)\n&quot;,retval);
							// Send  deny to Client
							free_features(&amp;features);
							return;
						}
						break;
					}
				}
				if ( i != gix_options-&gt;dhcp_hosts ){
					inet_ntop(AF_INET,&amp;(found_ip.sin_addr),print_ip,64);
					logger(prefix,&quot;Successfully found fixed IP-Address [%s], optional boot-file: [%s]\n&quot;,print_ip,bootfile);
				} else {
					u_int32_t start_address;
					u_int32_t end_address;
					u_int32_t check_address;
					int i;
					check_address = 0x00;	
					start_address = 0x00;
					end_address   = 0x00;
					strcpy(bootfile,DHCP_INTERFACE.ip_default_bootimage); // We are in a pool, so we use the default boot-image
					if ( dhcp_check_ipv4_valid_lease(idx, features.source_mac, &amp;check_address) == 0 ){ // Success
						char helpa[128]; 
						u_int32_t helpa2;
						helpa2 = htonl(check_address);
						inet_ntop(AF_INET,&amp;helpa2,helpa,128);
						start_address = 0x00;
						end_address   = 0x00;
						logger(prefix,&quot;Will assign the same address again for [%s] --&gt; IP: [%s]\n&quot;,dump_mac_addr(features.source_mac),helpa);
					} else {
						// Assign address from pool
						// Fist look, if an old entry already exists in lease-file, which is not expired...so a turned off workstation will get same address every day
						start_address = ntohl(DHCP_INTERFACE.ip_range_start.sin_addr.s_addr);
						end_address   = ntohl(DHCP_INTERFACE.ip_range_end.sin_addr.s_addr);
						logger(prefix,&quot;Assign address from pool... [0x%08lX - 0x%08lX]\n&quot;,start_address, end_address);
						for ( check_address = start_address; check_address &lt;= end_address; check_address++ ){
							if ( dhcp_check_ipv4_pool_address(idx, check_address, NULL) == 0 ) break;
						}
					}
					if ( start_address != 0 &amp;&amp; (check_address &gt; end_address) ){
						logger(prefix,&quot;No more addresses available (please increase pool or assign fixed host-entry)\n&quot;);
						// Send  deny to Client
						free_features(&amp;features);
						return;
					} else {
						u_int32_t check_addr;
						int retval;

						struct dhcp_ip_file_entry_t *f_entry;	
						u_int8_t f_entry_buffer[sizeof(struct dhcp_ip_file_entry_t) + DHCP_MAX_OPTSIZE];
						f_entry = (struct dhcp_ip_file_entry_t *) f_entry_buffer;
						bzero(f_entry,sizeof(struct dhcp_ip_file_entry_t) + DHCP_MAX_OPTSIZE);
						check_addr = htonl(check_address);
						memcpy(&amp;(found_ip.sin_addr.s_addr),&amp;check_addr,4);
						logger(prefix,&quot;Found Pool-address: [0x%08lX]\n&quot;,check_address);
						inet_ntop(AF_INET,&amp;(found_ip.sin_addr),print_ip,64);
						dhcp_ip_remove_entry_by_ip((u_int8_t *)&amp;check_addr);
						dhcp_ip_remove_entry_by_mac(features.source_mac);
						logger(prefix,&quot;Successfully found pool IP-Address [%s], optional boot-file: [%s]\n&quot;,print_ip,bootfile);
						f_entry-&gt;created = time(NULL);	
						f_entry-&gt;expiry  = time(NULL) + DHCP_INTERFACE.leasetime;
						memcpy(f_entry-&gt;mac,features.source_mac,6);
						memcpy(f_entry-&gt;ip,&amp;check_addr,4);
						{
							int optoffset;
							optoffset = 0;
							if ( features.class_id_len &gt; 0 ){
								f_entry-&gt;opts[optoffset++] = 60; // DHCP-Option 60 for CLASS-ID
								f_entry-&gt;opts[optoffset++] = features.class_id_len;
								memcpy(&amp;f_entry-&gt;opts[optoffset],features.class_id, features.class_id_len);
								optoffset += features.class_id_len;
							}
							if ( features.hostname_len &gt; 0 ){
								f_entry-&gt;opts[optoffset++] = 12; // DHCP-Option 12 for HOSTNAME
								f_entry-&gt;opts[optoffset++] = features.hostname_len;
								memcpy(&amp;f_entry-&gt;opts[optoffset],features.hostname, features.hostname_len);
								optoffset += features.class_id_len;
							}
							f_entry-&gt;optlen  = (u_int16_t) optoffset; 
							
						}
						if (  ( retval = dhcp_ip_add_entry(f_entry)) != 0 ){
							logger(prefix,&quot;Failed to write lease to file! (%d)\n&quot;,retval);
							// Send  deny to Client
							free_features(&amp;features);
							return;
						}
					}
				}
				/* Send success to Client
				 * We are creating an offer-packet here 
				 */
				send_udp_response_ip(idx,DHCP_T_OFFER,&amp;features,bootp,&amp;found_ip,bootfile);
				free_features(&amp;features);
				return;	
			} // Discovery done
			if ( msg_type == 3 ){ // A DHCPD-Request :-)
				int i;
				struct sockaddr_in found_ip;	
				char print_ip[64];
				char bootfile[1024];
				bzero(bootfile,1024);
				inet_ntop(AF_INET,&amp;option50ip.sin_addr,print_ip,64);
				logger(prefix,&quot;Processing DHCPREQUEST FOR: [%s] Requested-IP: [%s]\n&quot;,dump_mac_addr(features.source_mac),print_ip);		
				for ( i = 0; i &lt; gix_options-&gt;dhcp_hosts; i++ ){
					if ( memcmp(gix_options-&gt;dhcp_host[i].mac.ether_addr_octet,features.source_mac,6) == 0 ){
						int retval;
						struct dhcp_ip_file_entry_t f_entry;	
						bzero(&amp;f_entry,sizeof(f_entry));
						inet_ntop(AF_INET,&amp;(gix_options-&gt;dhcp_host[i].ip_addr.sin_addr),print_ip,64);
						logger(prefix,&quot;Found matching entry for [%s] --&gt; [%s]\n&quot;,dump_mac_addr(features.source_mac),print_ip);
						dhcp_ip_refresh_entry(features.source_mac, DHCP_INTERFACE.leasetime);
						/*
						dhcp_ip_remove_entry_by_mac(features.source_mac); // Remove old entry...maybe someone changed the configuration
						f_entry.optlen  = 0; // No options
						f_entry.created = time(NULL);
						f_entry.expiry  = time(NULL) + DHCP_INTERFACE.leasetime;
						memcpy(f_entry.ip,&amp;(gix_options-&gt;dhcp_host[i].ip_addr.sin_addr),4);
						memcpy(f_entry.mac,features.source_mac,6);
						*/
						memcpy(&amp;found_ip,&amp;(gix_options-&gt;dhcp_host[i].ip_addr),sizeof(struct sockaddr_in));
						if ( strlen(gix_options-&gt;dhcp_host[i].bootfile) ) strcpy(bootfile,gix_options-&gt;dhcp_host[i].bootfile);
						/*
						if ( ( retval = dhcp_ip_add_entry(&amp;f_entry)) != 0 ){
							logger(prefix,&quot;Failed to write lease to file! (%d)\n&quot;,retval);
							// Send  deny to Client
							return;
						}
						*/
						break;
					}
				}
				if ( i != gix_options-&gt;dhcp_hosts ){
					inet_ntop(AF_INET,&amp;(found_ip.sin_addr),print_ip,64);
					logger(prefix,&quot;Successfully found fixed IP-Address [%s], optional boot-file: [%s]\n&quot;,print_ip,bootfile);
				} else {
					u_int32_t start_address;
					u_int32_t end_address;
					u_int32_t check_address;
					int retval_checker;
					int i;
					// Assign address from pool
					// Fist look, if an old entry already exists in lease-file, which is not expired...so a turned off workstation will get same address every day
					strcpy(bootfile,DHCP_INTERFACE.ip_default_bootimage); // We are in a pool, so we use the default boot-image
					if ( option50ip.sin_family != AF_INET ){
						char helpa[64]; 
						u_int32_t helpa2;
						inet_ntop(AF_INET,features.source_ip,helpa,64);
							
						// No option 50 sent!!! denying
						logger(prefix,&quot;Client did not send a 50 option (Using Source-Address)[%s]\n&quot;,helpa);
						memcpy(&amp;helpa2,features.source_ip,4);
						check_address = ntohl(helpa2);
					} else {
						check_address = ntohl(option50ip.sin_addr.s_addr);
					}
					logger(prefix,&quot;Check address in active leases... [0x%08lX]\n&quot;,check_address);
					retval_checker = dhcp_check_ipv4_pool_address(idx, check_address, features.source_mac);	
					if ( retval_checker   ){
						char helpa[64];
						u_int32_t helpa2;
						helpa2 = htonl(start_address);
						inet_ntop(AF_INET,&amp;helpa2,helpa,64);
						logger(prefix,&quot;INVALID IP-Address requested...does not match our database for this IP: [%s] MAC: [%s]...we cannot fullfill this request!\n&quot;,helpa,dump_mac_addr(features.source_mac));
						// We send a NACK
						goto REQUEST_NACK;	
					} else {
						struct dhcp_ip_file_entry_t f_entry;	
						u_int32_t check_addr;
						int retval;
						check_addr = htonl(check_address);
						memcpy(&amp;(found_ip.sin_addr.s_addr),&amp;check_addr,4);
						logger(prefix,&quot;Found valid-address: [0x%08lX]\n&quot;,check_address);
						inet_ntop(AF_INET,&amp;(found_ip.sin_addr),print_ip,64);
						/*
						dhcp_ip_remove_entry_by_ip((u_int8_t *)&amp;check_addr);
						dhcp_ip_remove_entry_by_mac(features.source_mac);
						*/
						dhcp_ip_refresh_entry(features.source_mac, DHCP_INTERFACE.leasetime);
						logger(prefix,&quot;Successfully found pre-assigned pool IP-Address [%s] for this mac, optional boot-file: [%s]\n&quot;,print_ip,bootfile);
						/*
						bzero(&amp;f_entry,sizeof(f_entry));
						f_entry.optlen  = 0; // No options
						f_entry.created = time(NULL);	
						f_entry.expiry  = time(NULL) + DHCP_INTERFACE.leasetime;
						memcpy(f_entry.mac,features.source_mac,6);
						memcpy(f_entry.ip,&amp;check_addr,4);
						if (  ( retval = dhcp_ip_add_entry(&amp;f_entry)) != 0 ){
							logger(prefix,&quot;Failed to write lease to file! (%d)\n&quot;,retval);
							// Send  deny to Client
							return;
						}
						*/
					}
				}
				/* Send success to Client
				 * We are creating an ack-packet here 
				 */
REQUEST_ACK:
				if ( strlen(bootfile) &lt; 1 ) strcpy(bootfile,DHCP_INTERFACE.ip_default_bootimage); // We are in a pool, so we use the default boot-image
				send_udp_response_ip(idx,DHCP_T_ACK,&amp;features,bootp,&amp;found_ip,bootfile);
				free_features(&amp;features);
				return;
REQUEST_NACK:
				send_udp_response_ip(idx,DHCP_T_NACK,&amp;features,bootp,NULL,NULL);
				free_features(&amp;features);
				return;	
			} // Request done
				
		}

		return;
	}

}


// Ret-Addr is in Host-Byte Order!!!
/* Returns 0 on success and writes in retaddr the IP-Address of the leases-file  for this MAC (If not already expired!!!) */

int dhcp_check_ipv4_valid_lease(int idx, u_int8_t *mac, u_int32_t *_retaddr){ 
	u_int8_t *entry_buf[sizeof(struct dhcp_ip_file_entry_t) + DHCP_MAX_OPTSIZE];
	struct dhcp_ip_file_entry_t *entry;
	FILE *fp;
	int lockfd;
	lockfd = lock_file(DHCP_IP_LEASES_FILE_LOCK);
	fp = fopen(DHCP_IP_LEASES_FILE,&quot;r&quot;);
	if ( fp == NULL ){  unlock_file(lockfd); return(1); } // Leases file does not exist...so address is definitly not in leases file
	bzero(entry_buf,sizeof(struct dhcp_ip_file_entry_t) + DHCP_MAX_OPTSIZE);
	entry = (struct dhcp_ip_file_entry_t *)entry_buf;
	while ( fread(entry,sizeof(struct dhcp_ip_file_entry_t),1,fp) == 1 ){
		char ip_helper2[124];

		if ( entry-&gt;optlen ){
			fread(entry-&gt;opts,entry-&gt;optlen,1,fp);
		}
#ifdef DEBUG_DHCP
		inet_ntop(AF_INET,&amp;entry-&gt;ip,ip_helper2,124);
		logger(prefix,&quot;LEASES-FILE Searching for MAC-Address: [%s] [%s]\n&quot;,dump_mac_addr(mac),ip_helper2);
#endif
		if ( mac != NULL &amp;&amp; memcmp(entry-&gt;mac,mac,6) == 0 &amp;&amp; (entry-&gt;expiry + DHCP_INTERFACE.leasetime) &gt; time(NULL) ){
			u_int32_t retaddr;
			logger(prefix,&quot;Requesting station used [%s] (Entry for this MAC is still valid)\n&quot;,dump_mac_addr(entry-&gt;mac));
			memcpy(&amp;retaddr,entry-&gt;ip,4);
			*_retaddr = ntohl(retaddr);
			fclose(fp);
			unlock_file(lockfd);
			return(0);
		}
	}	
	fclose(fp);	
	unlock_file(lockfd);
	return(1);  // MAC not found in leasses-file with valid-ip-address
	
}

int check_if_ipv4_valid_pool(int idx, u_int32_t check_addr){ // Host-Byte Order
	u_int8_t a,b,c,d;
	u_int8_t as,bs,cs,ds;
	u_int8_t ae,be,ce,de;
	u_int32_t start_addr;
	u_int32_t end_addr;
	u_int32_t chk_addr;

	a = (u_int8_t)((check_addr &gt;&gt; 24) &amp; 0xFF);
	b = (u_int8_t)((check_addr &gt;&gt; 16) &amp; 0xFF);
	c = (u_int8_t)((check_addr &gt;&gt; 8) &amp; 0xFF);
	d = (u_int8_t)((check_addr) &amp; 0xFF);
	start_addr = ntohl(DHCP_INTERFACE.ip_range_start.sin_addr.s_addr);
	end_addr   = ntohl(DHCP_INTERFACE.ip_range_end.sin_addr.s_addr);
	as = (u_int8_t)((start_addr &gt;&gt; 24) &amp; 0xFF);
	bs = (u_int8_t)((start_addr &gt;&gt; 16) &amp; 0xFF);
	cs = (u_int8_t)((start_addr &gt;&gt; 8) &amp; 0xFF);
	ds = (u_int8_t)((start_addr) &amp; 0xFF);
	ae = (u_int8_t)((end_addr &gt;&gt; 24) &amp; 0xFF);
	be = (u_int8_t)((end_addr &gt;&gt; 16) &amp; 0xFF);
	ce = (u_int8_t)((end_addr &gt;&gt; 8) &amp; 0xFF);
	de = (u_int8_t)((end_addr) &amp; 0xFF);

	for ( chk_addr = start_addr; chk_addr &lt; end_addr; chk_addr++ ){
		if ( memcmp(&amp;check_addr,&amp;chk_addr,4) == 0 ){
			logger(prefix,&quot;[CHECKING IPV4_POOL] Check if %d.%d.%d.%d is in POOL (%d.%d.%d.%d - %d.%d.%d.%d) --&gt; SUCCESS!\n&quot;,
				a,b,c,d, as,bs,cs,ds, ae,be,ce,de);
			return(0); // A valid Pool-Address
		}
	}
	logger(prefix,&quot;[CHECKING IPV4_POOL] Check if %d.%d.%d.%d is in POOL (%d.%d.%d.%d - %d.%d.%d.%d) --&gt; FAILURE!\n&quot;,
		a,b,c,d, as,bs,cs,ds, ae,be,ce,de);
	return(1); // Requested address not in Pool-Range
}

/* If MAC != NULL...than it may be contained in the leases-file */
/* Check_Address is in Host-Byte Order!!! */

int dhcp_check_ipv4_pool_address(int idx, u_int32_t _check_address, u_int8_t *mac){
	u_int8_t *entry_buf[sizeof(struct dhcp_ip_file_entry_t) + DHCP_MAX_OPTSIZE];
	struct dhcp_ip_file_entry_t *entry;
	u_int32_t check_address;
	int cnt;
	FILE *fp;
	int lockfd;
#ifdef DEBUG_DHCP
	char ip_helper[124];
	char ip_helper2[124];
#endif
	check_address = htonl(_check_address);
#ifdef DEBUG_DHCP
	inet_ntop(AF_INET,&amp;check_address,ip_helper,124);
	logger(prefix,&quot;Checking availability of [%s]\n&quot;,ip_helper);
#endif
	for ( cnt = 0; cnt &lt; gix_options-&gt;dhcp_hosts; cnt++ ){
/*
#ifdef DEBUG_DHCP
		inet_ntop(AF_INET,&amp;(gix_options-&gt;dhcp_host[cnt].ip_addr.sin_addr),ip_helper2,124);
		logger(prefix,&quot;HOSTS[%d] Comparing [%s] with [%s]\n&quot;,cnt,ip_helper,ip_helper2);
#endif
*/
		if ( memcmp(&amp;check_address,&amp;(gix_options-&gt;dhcp_host[cnt].ip_addr.sin_addr),4) == 0 ){
#ifdef DEBUG_DHCP
			logger(prefix,&quot;Address [%s] already assigned to fixed host: [%s]\n&quot;,ip_helper, dump_mac_addr(gix_options-&gt;dhcp_host[cnt].mac.ether_addr_octet));
#endif
			return(1); // Already in fixed-Pool
		}
	}
	lockfd = lock_file(DHCP_IP_LEASES_FILE_LOCK);
	fp = fopen(DHCP_IP_LEASES_FILE,&quot;r&quot;);
	if ( fp == NULL ){  unlock_file(lockfd); 
		return(check_if_ipv4_valid_pool(idx,_check_address)); 
	} // Leases file does not exist...so address is free
	bzero(entry_buf,sizeof(struct dhcp_ip_file_entry_t) + DHCP_MAX_OPTSIZE);
	entry = (struct dhcp_ip_file_entry_t *)entry_buf;
	while ( fread(entry,sizeof(struct dhcp_ip_file_entry_t),1,fp) == 1 ){
		if ( entry-&gt;optlen ){
			fread(entry-&gt;opts,entry-&gt;optlen,1,fp);
		}
#ifdef DEBUG_DHCP
		inet_ntop(AF_INET,&amp;entry-&gt;ip,ip_helper2,124);
		logger(prefix,&quot;LEASES-FILE Comparing [%s] with [%s] %d\n&quot;,ip_helper,ip_helper2,memcmp(entry-&gt;ip,&amp;check_address,4));
#endif
		if ( mac != NULL &amp;&amp; memcmp(entry-&gt;mac,mac,6) == 0 &amp;&amp; memcmp(entry-&gt;ip,&amp;check_address,4) == 0 ){
			logger(prefix,&quot;Address [%s] assigned to requesting station [%s]...that&#039;s OK\n&quot;,ip_helper, dump_mac_addr(entry-&gt;mac)); 
			fclose(fp);
			unlock_file(lockfd);
			return(0);
		}
		if ( (entry-&gt;expiry + DHCP_INTERFACE.leasetime) &lt; time(NULL) &amp;&amp; memcmp(entry-&gt;ip,&amp;check_address,4) == 0 &amp;&amp; mac == NULL ){ // In case of discovery...we reassign the address
#ifdef DEBUG_DHCP
			logger(prefix,&quot;Address [%s] has been locked to MAC-host: [%s]\n&quot;,ip_helper, dump_mac_addr(entry-&gt;mac));
#endif
			fclose(fp);
			unlock_file(lockfd);
			return(0);
		}	
		if ( memcmp(entry-&gt;ip,&amp;check_address,4) == 0 &amp;&amp; ( mac == NULL || memcmp(entry-&gt;mac,mac,6) != 0 )){
#ifdef DEBUG_DHCP
			logger(prefix,&quot;Address [%s] already assigned to leased host: [%s]\n&quot;,ip_helper, dump_mac_addr(entry-&gt;mac));
#endif
			fclose(fp);
			unlock_file(lockfd);
			return(1);
		}		
	}	
	fclose(fp);	
	unlock_file(lockfd);
	return(check_if_ipv4_valid_pool(idx,_check_address)); // all checks passed...we may use the address :-) (IF VALID!!!)
}

/* 
 * UDP is connectionless...so no return code here! 
 */

void _send_udp_response_ip(char *file, int line, int idx,u_int8_t  dhcp_type, struct dhcp_features *features,struct bootp_packet *bootp, struct sockaddr_in *found_ip, char *bootfile){
		int send_reply;
		struct ethhdr *eth;
		struct ip *ip;
		struct gix_udphdr *udp;
		struct bootp_packet *bp;
		int dhcp_p_offset;
		u_int8_t reply_packet[8192];
		char helpa[64];
		inet_ntop(AF_INET,features-&gt;source_ip,helpa,64);
#ifdef DEBUG_DHCP
		logger(prefix,&quot;(%s:%d) Requesting sending of [%s] packet send-socket: %d to [%s] BOOTFILE: [%s]\n&quot;,file,line,dhcp_message_type(dhcp_type),DHCP_INTERFACE.send_socket,helpa,bootfile);
#endif

		eth = (struct ethhdr *)&amp;reply_packet[0];
		ip = (struct ip *)&amp;reply_packet[sizeof(struct ethhdr)];
		udp = (struct gix_udphdr *)&amp;reply_packet[sizeof(struct ethhdr) + sizeof(struct ip)];
		bp = (struct bootp_packet *)&amp;reply_packet[sizeof(struct ethhdr) + sizeof(struct ip) + sizeof(struct gix_udphdr)];
		bzero(reply_packet,8192);	

		/* Ethernet-Header */
		eth-&gt;h_proto = htons(ETH_P_IP);
		memcpy(eth-&gt;h_source,DHCP_INTERFACE.mac,6);
		if ( features-&gt;wants_broadcast ){
			memcpy(eth-&gt;h_dest,ethernet_broadcast,6);
		} else {
			memcpy(eth-&gt;h_dest,features-&gt;source_mac,6);
		}
		/* IP-Header */
		ip-&gt;ip_v   = 4;
		ip-&gt;ip_hl  = 5; // Minimum length	
		ip-&gt;ip_tos = 0x10;
		ip-&gt;ip_len = 0; // Must be filled later
		ip-&gt;ip_id  = 0;
		ip-&gt;ip_off = 0;
		ip-&gt;ip_p   = IPPROTO_UDP;
		ip-&gt;ip_ttl = 128; // Enough...we travel only in LAN...but leave enough for DNS-Request
		ip-&gt;ip_sum = 0; // Must be filled at the very end
		memcpy(&amp;(ip-&gt;ip_src.s_addr),&amp;(DHCP_INTERFACE.ip_me.sin_addr.s_addr),4);
		if ( features-&gt;wants_broadcast ){
			memcpy(&amp;(ip-&gt;ip_dst.s_addr),ip_broadcast,4);
		} else {
			memcpy(&amp;(ip-&gt;ip_dst.s_addr),features-&gt;source_ip,4);
		}
		/* UDP-Header */ 
		udp-&gt;source = htons(DHCP_INTERFACE.ip_port_in);
		udp-&gt;dest   = htons(DHCP_INTERFACE.ip_port_out);
		udp-&gt;len    = (u_int16_t) 0; // Must be filled later
		udp-&gt;check  = (u_int16_t) 0; // If Zero&#039;s than it is not used...that&#039;s OK :-)
		/* BOOTP-Header */		
		bp-&gt;op = 2; // Boot-Reply 
		bp-&gt;htype = bootp-&gt;htype; // We came from the same network...so hardware should not change
		bp-&gt;flags = bootp-&gt;flags; // Reply the same flags we received.
		bp-&gt;hlen  = 6; // Ethernet Address
		bp-&gt;hops  = 0; // Direct LAN-Request
		bp-&gt;xid   = bootp-&gt;xid;
		bp-&gt;secs  = 0; // Not really needed
		bp-&gt;ciaddr  = 0x00;
		memcpy(&amp;bp-&gt;yiaddr,&amp;found_ip-&gt;sin_addr.s_addr,4);
		// memcpy(&amp;bp-&gt;siaddr,&amp;DHCP_INTERFACE.ip_me.sin_addr.s_addr,4);
		bp-&gt;giaddr  = 0x00;
		memcpy(bp-&gt;chaddr,bootp-&gt;chaddr,16);
		// memcpy(bp-&gt;sname,bootp-&gt;sname,64);
		memcpy(bp-&gt;file,bootfile,strlen(bootfile));
		/* DHCP follows */	
		dhcp_p_offset = sizeof(struct ethhdr) + sizeof(struct ip) + sizeof(struct gix_udphdr) + sizeof(struct bootp_packet);	
		if ( features-&gt;wants_dhcp ){
			memcpy(&amp;reply_packet[dhcp_p_offset],dhcp_magic_cookie,4);
			dhcp_p_offset += 4;
			reply_packet[dhcp_p_offset++] = 53;
			reply_packet[dhcp_p_offset++] = 1;
			reply_packet[dhcp_p_offset++] = dhcp_type;

			if ( ( check_option_set(features,54)  || dhcp_type == DHCP_T_OFFER || dhcp_type == DHCP_T_ACK) ){
				reply_packet[dhcp_p_offset++] = 54;  
				reply_packet[dhcp_p_offset++] = 4;
				memcpy(&amp;reply_packet[dhcp_p_offset],&amp;DHCP_INTERFACE.ip_me.sin_addr.s_addr,4);
				dhcp_p_offset += 4;
			}
			if (dhcp_type != DHCP_T_NACK &amp;&amp; (  (dhcp_type == DHCP_T_OFFER || dhcp_type == DHCP_T_ACK) || check_option_set(features,51)  )){
				u_int32_t timer;
				reply_packet[dhcp_p_offset++] = 51;  
				reply_packet[dhcp_p_offset++] = 4;
				timer = (u_int32_t) htonl(DHCP_INTERFACE.leasetime);	
				memcpy(&amp;reply_packet[dhcp_p_offset],&amp;timer,4);
				dhcp_p_offset += 4;
			}

			if ( dhcp_type != DHCP_T_NACK &amp;&amp; ((dhcp_type == DHCP_T_OFFER || dhcp_type == DHCP_T_ACK)  || check_option_set(features,1) ) ){
				reply_packet[dhcp_p_offset++] = 1;  
				reply_packet[dhcp_p_offset++] = 4;
				memcpy(&amp;reply_packet[dhcp_p_offset],&amp;DHCP_INTERFACE.ip_netmask.sin_addr.s_addr,4);
				dhcp_p_offset += 4;
			}
			if (dhcp_type != DHCP_T_NACK &amp;&amp;(  (dhcp_type == DHCP_T_OFFER || dhcp_type == DHCP_T_ACK) || check_option_set(features,3)  )){
				reply_packet[dhcp_p_offset++] = 3;  
				reply_packet[dhcp_p_offset++] = 4;
				memcpy(&amp;reply_packet[dhcp_p_offset],&amp;DHCP_INTERFACE.ip_router.sin_addr.s_addr,4);
				dhcp_p_offset += 4;
			}
			/*
			if (dhcp_type != DHCP_T_NACK &amp;&amp;  check_option_set(features,23)  ){
				reply_packet[dhcp_p_offset++] = 23;  
				reply_packet[dhcp_p_offset++] = 1;
				reply_packet[dhcp_p_offset++] = 64; // TTL
			}
			if ( dhcp_type != DHCP_T_NACK &amp;&amp; ( check_option_set(features,50) || dhcp_type == DHCP_T_OFFER || dhcp_type == DHCP_T_ACK)  ){
				reply_packet[dhcp_p_offset++] = 50;  
				reply_packet[dhcp_p_offset++] = 4;
				memcpy(&amp;reply_packet[dhcp_p_offset],&amp;found_ip-&gt;sin_addr.s_addr,4);
				dhcp_p_offset += 4;
			}
			*/
			if (  dhcp_type != DHCP_T_NACK &amp;&amp; ((dhcp_type == DHCP_T_OFFER || dhcp_type == DHCP_T_ACK) &amp;&amp; check_option_set(features,6)) &amp;&amp; DHCP_INTERFACE.ip_nameservers ){
				int ii;
				reply_packet[dhcp_p_offset++] = 6;  
				reply_packet[dhcp_p_offset++] = DHCP_INTERFACE.ip_nameservers * 4;

				for ( ii = 0; ii &lt; DHCP_INTERFACE.ip_nameservers; ii++ ){
					memcpy(&amp;reply_packet[dhcp_p_offset],&amp;(DHCP_INTERFACE.ip_nameserver[ii].sin_addr.s_addr),4);
					dhcp_p_offset += 4;
				}
			
			}
			if (  dhcp_type != DHCP_T_NACK &amp;&amp; ((dhcp_type == DHCP_T_OFFER || dhcp_type == DHCP_T_ACK) &amp;&amp; check_option_set(features,15)) &amp;&amp;  strlen(DHCP_INTERFACE.ip_domain) ){
				reply_packet[dhcp_p_offset++] = 15;  
				reply_packet[dhcp_p_offset++] = (u_int8_t) strlen(DHCP_INTERFACE.ip_domain);
				memcpy(&amp;reply_packet[dhcp_p_offset],DHCP_INTERFACE.ip_domain,strlen(DHCP_INTERFACE.ip_domain));
				dhcp_p_offset += strlen(DHCP_INTERFACE.ip_domain);
			}
// This features where turned off for testing...
			/*
			if ( check_option_set(features,66)  &amp;&amp; strlen(DHCP_INTERFACE.ip_tftp_server) ){
				reply_packet[dhcp_p_offset++] = 66;  
				reply_packet[dhcp_p_offset++] = strlen(DHCP_INTERFACE.ip_tftp_server);
				memcpy(&amp;reply_packet[dhcp_p_offset],DHCP_INTERFACE.ip_tftp_server,strlen(DHCP_INTERFACE.ip_tftp_server));
				dhcp_p_offset += strlen(DHCP_INTERFACE.ip_tftp_server);
			}
			if ( dhcp_type != DHCP_T_NACK &amp;&amp; check_option_set(features,67) &amp;&amp; strlen(bootfile) ){
				reply_packet[dhcp_p_offset++] = 67;  
				reply_packet[dhcp_p_offset++] = (u_int8_t) strlen(bootfile);
				memcpy(&amp;reply_packet[dhcp_p_offset],bootfile,strlen(bootfile));
				dhcp_p_offset += strlen(bootfile);
			}
			if ( dhcp_type != DHCP_T_NACK &amp;&amp; (check_option_set(features,13) || check_option_set(features,67)) &amp;&amp; strlen(bootfile) ){
				char full_filename[1024];
				struct stat st;
				sprintf(full_filename,&quot;%s/%s&quot;,gix_options-&gt;tftp_root,bootfile);
				if ( stat(full_filename,&amp;st) == 0 ){
					size_t blks;
					blks = st.st_size/512;
#ifdef DEBUG_DHCP
					logger(prefix,&quot;BOOT_FILE_REQUEST --&gt; Size: %d Bytes (Chunks: %d)\n&quot;,(int)st.st_size,blks);
#endif
					reply_packet[dhcp_p_offset++] = 13;  
					reply_packet[dhcp_p_offset++] = 2; // Size 
					reply_packet[dhcp_p_offset++] = (u_int8_t) (blks % 256); 
					reply_packet[dhcp_p_offset++] = (u_int8_t) (blks / 256) +  (blks % 256) ? 1 : 0;
				} else {	
					logger(prefix,&quot;FAILED TO STAT: [%s] (%s)\n&quot;,full_filename,strerror(errno));
				}
			}
			*/
			if ( dhcp_type != DHCP_T_NACK &amp;&amp; check_option_set(features,28)  ){
				reply_packet[dhcp_p_offset++] = 28;  
				reply_packet[dhcp_p_offset++] = 4;
				memcpy(&amp;reply_packet[dhcp_p_offset],&amp;DHCP_INTERFACE.ip_broadcast.sin_addr.s_addr,4);
				dhcp_p_offset += 4;
			}
			reply_packet[dhcp_p_offset++] = 255; // End of options
			if ( dhcp_p_offset % 2 ) reply_packet[dhcp_p_offset++] = 0;
			while ( (dhcp_p_offset - (sizeof(struct ethhdr) + sizeof(struct ip) + sizeof(struct gix_udphdr))) &lt; 300 ){	
				reply_packet[dhcp_p_offset++] = 0; // Padding
			}
						
		}
		/* dhcp_p_offset contains the packet-size */
		ip-&gt;ip_len = (unsigned short) htons(dhcp_p_offset - sizeof(struct ethhdr) );
		udp-&gt;len = (unsigned short) htons( dhcp_p_offset - (sizeof(struct ethhdr) + sizeof(struct ip)) );
		/* Calculate UDP-Checksum (Must be done before IP-Checksum, but after other credentials in IP Header to create a correct pseudo-header */
		udp-&gt;check = udp_checksum(&amp;reply_packet[sizeof(struct ethhdr)+ sizeof(struct ip)], (int) ntohs(udp-&gt;len),(struct ip *)&amp;reply_packet[sizeof(struct ethhdr)]);
		/* Calculate IP-Checksum ... the last step */
		ip-&gt;ip_sum = ip_checksum(&amp;reply_packet[sizeof(struct ethhdr)],  sizeof(struct ip));
		memcpy(DHCP_INTERFACE.saddr_l.sll_addr,eth-&gt;h_dest,6);
		send_reply = sendto(DHCP_INTERFACE.send_socket,reply_packet,dhcp_p_offset,0,(struct sockaddr *)&amp;(DHCP_INTERFACE.saddr_l),sizeof(struct sockaddr_ll));
#ifdef DEBUG_DHCP
		logger(prefix,&quot;Send of [%s] packet (%d/%d) Socket: %d (Datalen: [%d Bytes])\n&quot;,dhcp_message_type(dhcp_type),send_reply,dhcp_p_offset,DHCP_INTERFACE.send_socket);
#endif
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FGIX_INETD%2Fsrc'>🔙 Back</a></p>