�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: gixsetup.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;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;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;uuid/uuid.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;net/ethernet.h&gt;
#include &lt;sys/sysmacros.h&gt;
#include &quot;gix.h&quot;


void do_efi();

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

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);
}


u_int16_t udp_checksum(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);

        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));
}





unsigned char ipbcast[4]; 	
unsigned char dhcpmagic[4]; 	
/*
    A_NORMAL        Normal display (no highlight)
    A_STANDOUT      Best highlighting mode of the terminal.
    A_UNDERLINE     Underlining
    A_REVERSE       Reverse video
    A_BLINK         Blinking
    A_DIM           Half bright
    A_BOLD          Extra bright or bold
    A_PROTECT       Protected mode
    A_INVIS         Invisible or blank mode
    A_ALTCHARSET    Alternate character set
    A_CHARTEXT      Bit-mask to extract a character
    COLOR_PAIR(n)   Color-pair number n
*/

void end_runner();
#define end_scroller() end_runner()
int create_scroller(char *caption);

typedef struct _win_border_struct {
	chtype 	ls, rs, ts, bs, 
	 	tl, tr, bl, br;
}WIN_BORDER;

typedef struct _WIN_struct {

	int start_x, start_y;
	int height, width;
	WIN_BORDER border;
	WINDOW *win;
}WIN;



void draw_frame();

int rows, cols;
int o_rows, o_cols;
char caption[1024];
int current_option = 0;

struct _option {
	char *caption;
	void (*handler)();
};

int options;

struct _select {
	char *name;
	int internal_id;
	int useable;
	void (*handler)(); // Not used yet 
};

struct _select2 {
	char *name;
	int internal_id;
	char selected;
	int useable;
	void (*handler)(); // Not used yet 
};

struct _disk {
	char devname[64];
	u_int64_t size;
	u_int64_t sectors;
	char israid;
	int partitions;
	char serial[256];
	char model[256];
	char badsectors[256];
	char uptime[256];
	fdisk_sector_t cylinders;
	fdisk_sector_t heads;
	fdisk_sector_t first_lba;
	fdisk_sector_t last_lba;
	fdisk_sector_t geom_secs;
	size_t labels;
	unsigned long sector_size;
	int nents;
	struct fdisk_context *ctx;
	struct fdisk_table *tb;
	struct fdisk_label *label;
};

struct _disk *disk = NULL;
int disks = 0;
int current_disk = 0;

void disk_setup();
void exit_setup();
void reboot_system();
void display_options();

void raid_setup();
void raid_stop();
void network_setup();
void efi_setup();
void files_setup();
void zero_all_disks();
void linux_setup();

struct _option option[] = {
	{ &quot;Configure disks&quot;,disk_setup },
	{ &quot;Configure RAID&quot;,raid_setup },
	{ &quot;Configure network (for installing)&quot;,network_setup },
	{ &quot;Install EFI files &amp; GIX-Linux files&quot;,files_setup },
	{ &quot;Configure GIX-Linux&quot;,linux_setup },
	{ &quot;Configure UEFI-BIOS Boot-Order&quot;,efi_setup },
	{ &quot;Reboot system&quot;,reboot_system },
	{ &quot;Exec a shell&quot;,exit_setup },
	{ &quot;Stop RAID-Systems&quot;,raid_stop },
	{ &quot;Zero all disks&quot;,zero_all_disks },
	{ NULL,NULL }
};

WIN _sub1;
WIN _sub2;
WIN _walarm;
WIN _runner;
WIN _screen;
WIN *sub1;
WIN *sub2;
WIN *walarm;
WIN *runner;

WIN *screen;
WINDOW *root;

int last_status;
void reaper(int signal){
	while ( wait(&amp;last_status) &lt; 0 );
}





int disk_sorter(const void *_a, const void *_b){
	struct _disk *a;
	struct _disk *b;
	a = (struct _disk *)_a;
	b = (struct _disk *)_b;
	return(strcmp(a-&gt;devname,b-&gt;devname));

}

int current_select = 0;
int show_selector(char *caption, WIN *win, int y_offset, struct _select *sel, int sels){
	int i;
	int possible_rows;
	int possible_cols;
	char fmt_string[129];
	int start_idx,last_idx;

	possible_rows = (win-&gt;height-3) - y_offset;
	possible_cols = win-&gt;width-2;

	sprintf(fmt_string,&quot;%%.%ds&quot;,possible_cols);

	start_idx = 0;
	last_idx  = possible_rows;

	if ( current_select &gt; last_idx ){
		last_idx = current_select;
		start_idx = last_idx - possible_rows;
		if ( start_idx &lt; 0 ) start_idx = 0;
	}
	for ( i = start_idx; i  &lt;= last_idx &amp;&amp; i &lt; sels; i++ ){
		// move((i-start_idx) + win-&gt;start_y + 1 + y_offset, win-&gt;start_x + 1);
		wmove(win-&gt;win, (i-start_idx) +  1 + y_offset,  1);
		if ( current_select == i ){
			wattron(win-&gt;win,A_REVERSE);
			wprintw(win-&gt;win,fmt_string,sel[i].name);
			// printw(&quot;DISK %d&quot;,i);
			wattroff(win-&gt;win,A_REVERSE);

		} else {
			wattroff(win-&gt;win,A_REVERSE);
			wprintw(win-&gt;win,fmt_string,sel[i].name);
		}
	}
	wrefresh(win-&gt;win);


}
int show_selector2(char *caption, WIN *win, int y_offset, struct _select2 *sel, int sels){
	int i;
	int possible_rows;
	int possible_cols;
	char fmt_string[129];
	int start_idx,last_idx;

	possible_rows = (win-&gt;height-3) - y_offset;
	possible_cols = win-&gt;width-2;

	sprintf(fmt_string,&quot;%%.%ds&quot;,possible_cols);

	start_idx = 0;
	last_idx  = possible_rows;

	if ( current_select &gt; last_idx ){
		last_idx = current_select;
		start_idx = last_idx - possible_rows;
		if ( start_idx &lt; 0 ) start_idx = 0;
	}
	for ( i = start_idx; i  &lt;= last_idx &amp;&amp; i &lt; sels; i++ ){
		if ( current_select == i ){
			wattron(win-&gt;win, A_REVERSE);
			wmove(win-&gt;win,(i-start_idx) +  1 + y_offset,  1);
			if ( sel[i].selected ){
				wprintw(win-&gt;win,&quot;[X]  &quot;);
			} else {
				wprintw(win-&gt;win,&quot;[ ]  &quot;);
			}
			wmove(win-&gt;win,(i-start_idx) +  1 + y_offset,  5);
			wprintw(win-&gt;win,fmt_string,sel[i].name);
			// printw(&quot;DISK %d&quot;,i);
			wattroff(win-&gt;win, A_REVERSE);

		} else {
			wattroff(win-&gt;win, A_REVERSE);
			wmove(win-&gt;win,(i-start_idx) + 1 + y_offset,  1);
			if ( sel[i].selected ){
				wprintw(win-&gt;win,&quot;[X]  &quot;);
			} else {
				wprintw(win-&gt;win,&quot;[ ]  &quot;);
			}
			wmove(win-&gt;win,(i-start_idx)  + 1 + y_offset,  5);
			wprintw(win-&gt;win,fmt_string,sel[i].name);
		}
	}
	wrefresh(win-&gt;win);


}
int run_selector2(char *caption, WIN *win, int y_offset, struct _select2 *sel, int sels, int(*handler)(int ch) ){
	// current_select = 0;
	show_selector2(caption, win,y_offset, sel, sels);
	refresh();
	while ( 1 ){
		int ch;
		ch = getch();
		if (handler){ 
			int retval;
			retval = handler(ch);
			if ( retval == HANDLER_RETURN_ESCAPE ) return(-2);
			if ( retval == HANDLER_RETURN_CURRENT_SELECT ) return(current_select);
		}
		switch(ch){
			case KEY_UP: 
				current_select--; 
				if ( current_select &lt; 0 ){
					current_select = 0;
				} else {
					show_selector2(caption, win,y_offset, sel, sels);
					refresh();
				}
				break;
			case KEY_DOWN: 
				current_select++; 
				if ( current_select &gt;= sels ){
					current_select = sels-1;
				} else {
					show_selector2(caption, win, y_offset,sel, sels);
					refresh();
				}
				break;
			case 0x0020:
				if ( sel[current_select].selected ) 
					sel[current_select].selected = 0;
				else
					sel[current_select].selected = 1;
				show_selector2(caption, win, y_offset,sel, sels);
				break;
			case KEY_ENTER: 
			case 0x000A:
				return(current_select);
				break;
			case 0x001B:
				return(-1);
				break;
		}	
	}
}

int run_selector(char *caption, WIN *win, int y_offset, struct _select *sel, int sels, int(*handler)(int ch) ){
	// current_select = 0;
	show_selector(caption, win,y_offset, sel, sels);
	refresh();
	while ( 1 ){
		int ch;
		ch = getch();
		if (handler){ 
			int retval;
			retval = handler(ch);
			if ( retval == HANDLER_RETURN_ESCAPE ) return(-2);
			if ( retval == HANDLER_RETURN_CURRENT_SELECT ) return(current_select);
		}
		switch(ch){
			case KEY_UP: 
				current_select--; 
				if ( current_select &lt; 0 ){
					current_select = 0;
				} else {
					show_selector(caption, win,y_offset, sel, sels);
					refresh();
				}
				break;
			case KEY_DOWN: 
				current_select++; 
				if ( current_select &gt;= sels ){
					current_select = sels-1;
				} else {
					show_selector(caption, win, y_offset,sel, sels);
					refresh();
				}
				break;
			case KEY_ENTER: 
			case 0x000A:
				return(current_select);
				break;
			case 0x001B:
				return(-1);
				break;
		}	
	}
}


#define alarm_window(a,b,c,d) _alarm_window(__FILE__,__LINE__,(a),(b),(c),(d))

int _alarm_window(char *__file__, int __line__,char *caption,  int level, char *input, int input_len){ // input_len ANSWER_OK, ANSWER_CANCEL, if input == NULL!!!
	char **content;
	int x,y,w,h,i,j;
	int longest;
	int lines;
	char *ptr1;
	char *ptr2;
	int cursel;

#define ERROR_ALARM  &quot;&lt;EXIT&gt;&quot;
#define INFO_ALARM   &quot;&lt;CONTINUE&gt;&quot;
#define OK_ALARM     &quot;&lt;OK&gt;&quot;
#define CANCEL_ALARM &quot;&lt;CANCEL&gt;&quot;

	debug_logger(&quot;ALARM_WINDOW(%s:%d) REQUESTED: [%.32s], LEVEL: %d\n&quot;,__file__,__line__,caption,level);

	if ( level == ALARM_INPUT &amp;&amp; input ){
		int ch;
		int curpos;
		int input_offset;
		int real_len;
		lines = 3;
		input_offset = strlen(caption) + 1;
		longest = 4 + strlen(caption) + input_len;
		walarm-&gt;height = lines;
		walarm-&gt;width  = longest;
		walarm-&gt;start_x = screen-&gt;start_x + ((screen-&gt;width  - longest)/2);
		walarm-&gt;start_y = screen-&gt;start_y + ((screen-&gt;height - lines) / 2);
		walarm-&gt;win = newwin(walarm-&gt;height,walarm-&gt;width, walarm-&gt;start_y, walarm-&gt;start_x);
		wattron(walarm-&gt;win,COLOR_PAIR(ALARM_COLOR_INPUT));
		x = 0;
		y = 0;
		w = walarm-&gt;width;
		h = walarm-&gt;height;
		for(j = y; j &lt;= y + h; ++j)
			for(i = x; i &lt;= x + w; ++i)
				mvwaddch(walarm-&gt;win,j, i, &#039; &#039;);
		box(walarm-&gt;win,0,0);
		mvwprintw(walarm-&gt;win,1,1,&quot;%s&quot;,caption);
		curs_set(2);
		wattron(walarm-&gt;win,A_UNDERLINE);
		for ( i = 0; i &lt; input_len; i++ ){
			mvwaddch(walarm-&gt;win,1,input_offset+i, &#039; &#039;);			
		}	
		real_len = strlen(input);
		mvwprintw(walarm-&gt;win,1,input_offset,&quot;%s&quot;,input);
		for ( i = real_len; i &lt; input_len; i++ ) input[i] = &#039; &#039;;
		input[i] = 0x00;
		curpos = real_len;
		mvwaddch(walarm-&gt;win,1,input_offset+curpos,&#039; &#039;); 
		wmove(walarm-&gt;win,1,input_offset+curpos);
		wrefresh(walarm-&gt;win);
		while ( (ch = getch()) != KEY_ENTER &amp;&amp; ch != 0x000A &amp;&amp; ch != 0x001B){

			if ( (curpos &lt; input_len) &amp;&amp; 
			     ((ch &gt;= &#039;A&#039; &amp;&amp; ch &lt;= &#039;Z&#039;)||
			     (ch &gt;= &#039;a&#039; &amp;&amp; ch &lt;= &#039;z&#039;)||
			     (ch &gt;= &#039;0&#039; &amp;&amp; ch &lt;= &#039;9&#039;)||
			     (ch == &#039;-&#039;)|| 
			     (ch == &#039;+&#039;)|| 
			     (ch == &#039;_&#039;)|| 
			     (ch == &#039;=&#039;)|| 
			     (ch == &#039;:&#039;)|| 
			     (ch == &#039;,&#039;)|| 
			     (ch == &#039;&lt;&#039;)|| 
			     (ch == &#039;&gt;&#039;)|| 
			     (ch == &#039;(&#039;)|| 
			     (ch == &#039;)&#039;)|| 
			     (ch == &#039;[&#039;)|| 
			     (ch == &#039;]&#039;)|| 
			     (ch == &#039;{&#039;)|| 
			     (ch == &#039;}&#039;)|| 
			     (ch == &#039;;&#039;)|| 
			     (ch == &#039; &#039;)|| 
			     (ch == &#039;/&#039;)|| 
			     (ch == &#039;.&#039;))
			   )
			 {

				input[curpos] = (char)ch; 
				mvwaddch(walarm-&gt;win,1,input_offset+curpos,ch); 
				curpos++;
				wmove(walarm-&gt;win,1,input_offset+curpos);
				wrefresh(walarm-&gt;win); 
				continue;
			}
			if ( ch == KEY_BACKSPACE || ch == 0x0008 ){
				curpos--;
				if ( curpos &lt; 0 ){ curpos = 0; continue; }
				input[curpos] = &#039; &#039;;
				mvwaddch(walarm-&gt;win,1,input_offset+curpos,&#039; &#039;); 
				wmove(walarm-&gt;win,1,input_offset+curpos);
				wrefresh(walarm-&gt;win);
				continue;
			}
			if ( ch == KEY_LEFT ){
				curpos--;
				if ( curpos &lt; 0 ){ curpos = 0; continue; }
				// mvwaddch(walarm-&gt;win,1,input_offset+curpos,input[curpos]);
				wmove(walarm-&gt;win,1,input_offset+curpos);
				wrefresh(walarm-&gt;win);
				continue;
			}
			if ( ch == KEY_RIGHT ){
				curpos++;
				if ( curpos &gt;= input_len ){ curpos = input_len - 1; continue; }
				// mvwaddch(walarm-&gt;win,1,input_offset+curpos,input[curpos]);
				wmove(walarm-&gt;win,1,input_offset+curpos);
				wrefresh(walarm-&gt;win);
				continue;
			}
		}
		curs_set(0);
		wattroff(walarm-&gt;win,A_UNDERLINE);
		werase(walarm-&gt;win);
		delwin(walarm-&gt;win);
		walarm-&gt;win = NULL;
		touchwin(root);
		refresh();
		if ( sub1-&gt;win ) touchwin(sub1-&gt;win);
		if ( sub1-&gt;win ) wrefresh(sub1-&gt;win);
		if ( sub2-&gt;win ) touchwin(sub2-&gt;win);
		if ( sub2-&gt;win ) wrefresh(sub2-&gt;win);
		if ( runner-&gt;win ) touchwin(runner-&gt;win);
		if ( runner-&gt;win ) wrefresh(runner-&gt;win);
		if ( ch == 0x001B ) 
			return(-1);
		else
			return(0);
	}


	cursel = input_len;

	lines = 0;
	longest = 0;
	ptr1 = caption;
	ptr2 = ptr1;
	content = NULL;
	while ( 1 ){
		if ( *ptr2 == &#039;\n&#039; || *ptr2 == &#039;\0&#039; ){
			if ( longest &lt; (ptr2 - ptr1) ) longest = ptr2 - ptr1;
			content = (char **)realloc(content,sizeof(char *) * (lines+1));
			content[lines] = (char *)malloc((ptr2-ptr1) + 2);
			bzero(content[lines],(ptr2-ptr1)+2);
			memcpy(content[lines],ptr1,(ptr2-ptr1));
			lines++;
			ptr1 = ptr2;
			ptr1++;
		}
		if ( *ptr2 == &#039;\0&#039; ) break;
		ptr2++;
	}	
	if ( longest == 0 ) longest = strlen(caption);

	walarm-&gt;height  = lines + 5;
	walarm-&gt;width   = longest + 4;
	walarm-&gt;start_x = screen-&gt;start_x + ((screen-&gt;width - longest)/2);
	walarm-&gt;start_y = screen-&gt;start_y + ((screen-&gt;height - lines)/2);



	x = 0;
	y = 0;
	w = walarm-&gt;width;
	h = walarm-&gt;height;


	walarm-&gt;win = newwin(walarm-&gt;height,walarm-&gt;width, walarm-&gt;start_y, walarm-&gt;start_x);
	if ( level == ALARM_FATAL ){
		wattron(walarm-&gt;win,COLOR_PAIR(ALARM_COLOR_FATAL));
	} else if ( level == ALARM_ERROR) {
		wattron(walarm-&gt;win,COLOR_PAIR(ALARM_COLOR_ERROR));
	} else if ( level == ALARM_WARNING) {
		wattron(walarm-&gt;win,COLOR_PAIR(ALARM_COLOR_WARNING));
	} else if ( level == ALARM_OKCANCEL) {
		wattron(walarm-&gt;win,COLOR_PAIR(ALARM_COLOR_OKCANCEL));
	} else {
		wattron(walarm-&gt;win,COLOR_PAIR(ALARM_COLOR_INFO));
	}
	for(j = y; j &lt;= y + h; ++j)
		for(i = x; i &lt;= x + w; ++i)
			mvwaddch(walarm-&gt;win,j, i, &#039; &#039;);
	box(walarm-&gt;win,0,0);
	for ( i = 0; i &lt; lines; i++ ){
		mvwprintw(walarm-&gt;win,2+i,  2,  &quot;%s&quot;,content[i]);
		free(content[i]);
	}
	free(content);
	if ( level == ALARM_OKCANCEL ){
		int ch; 
		int ok_offset;
		int cancel_offset;
		char ok_alarm[1024];
		char cancel_alarm[1024];


		strcpy(ok_alarm,OK_ALARM);
		strcpy(cancel_alarm,CANCEL_ALARM);

		if ( input ){
			char *ptr;
			strcpy(ok_alarm,input);
			ptr = ok_alarm;
			while ( *ptr &amp;&amp; *ptr != &#039;|&#039; ) ptr++;
			if ( *ptr == &#039;|&#039; ){
				*ptr = 0x00;
				ptr++;
				strcpy(cancel_alarm,ptr);
			}


		}


		ok_offset = walarm-&gt;width/2 - (strlen(ok_alarm)+1);
		cancel_offset = walarm-&gt;width/2 + 1;
		ch = 0;
		while(ch != KEY_ENTER &amp;&amp; ch != 0x000A ){	
			if ( ch == 0x001B ){
				werase(walarm-&gt;win);
				delwin(walarm-&gt;win);
				walarm-&gt;win = NULL;
				touchwin(root);
				refresh();
				if ( sub1-&gt;win ) touchwin(sub1-&gt;win);
				if ( sub1-&gt;win ) wrefresh(sub1-&gt;win);
				if ( sub2-&gt;win ) touchwin(sub2-&gt;win);
				if ( sub2-&gt;win ) wrefresh(sub2-&gt;win);
				if ( runner-&gt;win ) touchwin(runner-&gt;win);
				if ( runner-&gt;win ) wrefresh(runner-&gt;win);
				return(-1);
			}
			if ( cursel == ANSWER_OK ){
				wattron(walarm-&gt;win,A_REVERSE);
				mvwprintw(walarm-&gt;win,walarm-&gt;height  - 2, ok_offset,  &quot;%s&quot;,ok_alarm);
				wattroff(walarm-&gt;win,A_REVERSE);
				mvwprintw(walarm-&gt;win,walarm-&gt;height  - 2, cancel_offset,  &quot;%s&quot;,cancel_alarm);
			} else {
				wattroff(walarm-&gt;win,A_REVERSE);
				mvwprintw(walarm-&gt;win,walarm-&gt;height  - 2, ok_offset,  &quot;%s&quot;,ok_alarm);
				wattron(walarm-&gt;win,A_REVERSE);
				mvwprintw(walarm-&gt;win,walarm-&gt;height  - 2, cancel_offset,  &quot;%s&quot;,cancel_alarm);
			}
			wrefresh(walarm-&gt;win);
			ch = getch();
			if ( ch == KEY_BTAB || ch == KEY_LEFT || ch == KEY_RIGHT || ch == 0x0009 ){
				if ( cursel == ANSWER_OK ) 
					cursel = ANSWER_CANCEL;
				else
					cursel = ANSWER_OK;
			}
		}
		werase(walarm-&gt;win);
		delwin(walarm-&gt;win);
		walarm-&gt;win = NULL;
		touchwin(root);
		refresh();
		if ( sub1-&gt;win ) touchwin(sub1-&gt;win);
		if ( sub1-&gt;win ) wrefresh(sub1-&gt;win);
		if ( sub2-&gt;win ) touchwin(sub2-&gt;win);
		if ( sub2-&gt;win ) wrefresh(sub2-&gt;win);
		if ( runner-&gt;win ) touchwin(runner-&gt;win);
		if ( runner-&gt;win ) wrefresh(runner-&gt;win);
		return(cursel);
	} else { 
		wattron(walarm-&gt;win,A_REVERSE);
		if ( level == ALARM_FATAL ){
			mvwprintw(walarm-&gt;win,walarm-&gt;height  - 2, walarm-&gt;width/2 - strlen(ERROR_ALARM)/2,  &quot;%s&quot;,ERROR_ALARM);
		} else {
			mvwprintw(walarm-&gt;win,walarm-&gt;height  - 2, walarm-&gt;width/2 - strlen(INFO_ALARM)/2,  &quot;%s&quot;,INFO_ALARM);
		}
		wrefresh(walarm-&gt;win);
	}



	{ 
		int ch;
		while ( (ch = getch()) != KEY_ENTER &amp;&amp; ch != 0x000A );
	}
	werase(walarm-&gt;win);
	delwin(walarm-&gt;win);
	if ( level == ALARM_FATAL ){
		erase();
		refresh();
		endwin();
		exit(2);
	}
	walarm-&gt;win = NULL;
	touchwin(root);
	refresh();
	if ( sub1-&gt;win) touchwin(sub1-&gt;win);
	if ( sub1-&gt;win) wrefresh(sub1-&gt;win);
	if ( sub2-&gt;win) touchwin(sub2-&gt;win);
	if ( sub2-&gt;win) wrefresh(sub2-&gt;win);
	if ( runner-&gt;win ) touchwin(runner-&gt;win);
	if ( runner-&gt;win ) wrefresh(runner-&gt;win);
	return(0);
}

int current_runner_last_line;
int current_runner_last_col;
int current_runner_current_x;
int current_runner_current_y;

void create_runner(int x,int y,int width,int height,char *caption){
	int w,h,i,j;

	runner-&gt;height  = height;
	runner-&gt;width   = width;
	runner-&gt;start_x = x;
	runner-&gt;start_y = y;



	x = 0;
	y = 0;
	w = runner-&gt;width;
	h = runner-&gt;height;


	if ( runner-&gt;win == NULL ){ runner-&gt;win = newwin(runner-&gt;height,runner-&gt;width,runner-&gt;start_y,runner-&gt;start_x); }
	wattron(runner-&gt;win,COLOR_PAIR(RUNNER_COLOR));


	for(j = y; j &lt;= y + h; ++j)
		for(i = x; i &lt;= x + w; ++i)
			mvwaddch(runner-&gt;win,j, i, &#039; &#039;);

	box(runner-&gt;win,0,0);
	wattron(runner-&gt;win,A_BOLD);
	mvwprintw(runner-&gt;win,y, x + ((runner-&gt;width  - strlen(caption)) / 2),&quot;%s&quot;,caption);
	wrefresh(runner-&gt;win);
	refresh();
}

void end_runner(){
		if ( runner-&gt;win ){
			werase(runner-&gt;win);
			delwin(runner-&gt;win);
		}
		runner-&gt;win = NULL;
		touchwin(root);
		refresh();
		if ( sub1-&gt;win ) touchwin(sub1-&gt;win);
		if ( sub1-&gt;win ) wrefresh(sub1-&gt;win);
		if ( sub2-&gt;win ) touchwin(sub2-&gt;win);
		if ( sub2-&gt;win ) wrefresh(sub2-&gt;win);
}

void add_scroller(char *text){
	char c;
	int last_line;
	int last_col;
	int current_x; 
	int current_y;
	last_line = current_runner_last_line;
	last_col = current_runner_last_col;
	current_x = current_runner_current_x;
	current_y = current_runner_current_y;
	while ( c = *(text++) ){
		if ( c == &#039;\r&#039; ){ current_x = 1; continue; }
		if ( c == &#039;\n&#039; ){ 
			current_y++; 
			if ( current_y &gt; last_line ){ 
				int j;
				current_y--;
				for ( ;  current_x &lt;= last_col; current_x++ ){
					mvwaddch(runner-&gt;win,current_y, current_x,&#039; &#039;);
				}
				wrefresh(runner-&gt;win);
				scroll(runner-&gt;win);
				box(runner-&gt;win,0,0);
				wrefresh(runner-&gt;win);
			}
			current_x = 1;
			continue;
		}
		if ( c == &#039;\t&#039; ) c = &#039; &#039;;
		if ( isprint(c)){ 
			current_x++;
			if ( current_x &gt; last_col ){
				current_y++; 
				if ( current_y &gt; last_line ){ 
					scroll(runner-&gt;win);
					box(runner-&gt;win,0,0);
					wrefresh(runner-&gt;win);
					current_y--;
				}
				current_x = 1;
			}
			mvwaddch(runner-&gt;win,current_y, current_x,c);
			wrefresh(runner-&gt;win);
		}
	}
	current_runner_current_x = current_x;
	current_runner_current_y = current_y;

}


#define scroll_logger(fmt, ...) _scroll_logger(__FILE__,__LINE__,fmt, ##__VA_ARGS__)

void _scroll_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];
        gettimeofday(&amp;tv,NULL);
        tm = localtime_r(&amp;tv.tv_sec,&amp;_tm);
        sprintf(datestamp,&quot;[%04d-%02d-%02d %02d:%02d:%02d.%06d] &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);

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

	add_scroller(datestamp);
	add_scroller(p);

	debug_logger(&quot;SCROLL_LOGGER REQUESTED (%s:%d): [%.100s]\n&quot;,__file__,__line__,p);

}

void c_logger(const char *fmt, ...){
        char p[102400];
        va_list ap;

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

	add_scroller(p);

	touchwin(runner-&gt;win);
	wrefresh(runner-&gt;win);

}



int create_scroller(char *caption){
	if ( sub2-&gt;win ){
		create_runner(sub2-&gt;start_x + 1,sub2-&gt;start_y + 1, sub2-&gt;width - 2, sub2-&gt;height - 2, caption);
        } else if ( sub1-&gt;win ) {
		create_runner(sub1-&gt;start_x + 1,sub1-&gt;start_y + 1, sub1-&gt;width - 2, sub1-&gt;height - 2, caption);
        } else {
		create_runner(screen-&gt;start_x + 1,screen-&gt;start_y + 1, screen-&gt;width - 2, screen-&gt;height - 2, caption);
	}
	scrollok(runner-&gt;win,true);
	current_runner_last_line = runner-&gt;height - 2; 
	current_runner_last_col  = runner-&gt;width - 2; 
	current_runner_current_x = 1;
	current_runner_current_y = 1;
}





int run_program(char *exe, char **arg,char *caption, char *final_prompt){
	int pid;
	int fd_in;
	int fd_out;
	char tempfile[1024];
	sprintf(tempfile,&quot;/tmp/exec_log_%d&quot;,getpid());
	unlink(tempfile);
	int last_line;
	int last_col;
	int current_x; 
	int current_y;
	signal(SIGCHLD,reaper);

	if ( sub2-&gt;win ){
		create_runner(sub2-&gt;start_x + 1,sub2-&gt;start_y + 1, sub2-&gt;width - 2, sub2-&gt;height - 2, caption);
        } else if ( sub1-&gt;win ) {
		create_runner(sub1-&gt;start_x + 1,sub1-&gt;start_y + 1, sub1-&gt;width - 2, sub1-&gt;height - 2, caption);
        } else {
		create_runner(screen-&gt;start_x + 1,screen-&gt;start_y + 1, screen-&gt;width - 2, screen-&gt;height - 2, caption);
	}
	scrollok(runner-&gt;win,true);

	last_line = runner-&gt;height - 2; 
	last_col  = runner-&gt;width - 2; 
	current_x = 1;
	current_y = 1;

	if ((fd_in = open(&quot;/dev/zero&quot;,O_RDONLY)) &lt; 0 ) return(-1);
	if ((fd_out = open(tempfile,O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IRGRP | S_IWGRP | S_IWUSR)) &lt; 0 ){
			close(fd_in);
			return(-1);
	}
	if ( (pid = fork()) == 0 ){
		int sid;
		sid = setsid();
		dup2(fd_in,0);
		dup2(fd_out,1);
		dup2(fd_out,2);
		if ( fd_in &gt; 2 )  close(fd_in);
		if ( fd_out &gt; 2 ) close(fd_out);
		if ( execv(exe,arg) &lt; 0 ){
			exit(2);
		}
	} else {
		int log;
		char c;
		sleep(1);
		log = open(tempfile,O_RDONLY | O_NONBLOCK);
		while ( 1 ){
			while ( read(log,&amp;c,1) == 1 ){
			//	putchar(c);
			//
				if ( c == &#039;\r&#039; ){ current_x = 1; continue; }
				if ( c == &#039;\n&#039; ){ 
					current_y++; 
					if ( current_y &gt; last_line ){ 
						int j;
						current_y--;
						for ( ;  current_x &lt;= last_col; current_x++ ){
							mvwaddch(runner-&gt;win,current_y, current_x,&#039; &#039;);
						}
						wrefresh(runner-&gt;win);
						scroll(runner-&gt;win);
						box(runner-&gt;win,0,0);
						wrefresh(runner-&gt;win);
					}
					current_x = 1;
					continue;
				}
				if ( c == &#039;\t&#039; ) c = &#039; &#039;;
				if ( isprint(c)){ 
					current_x++;
					if ( current_x &gt; last_col ){
						current_y++; 
						if ( current_y &gt; last_line ){ 
							scroll(runner-&gt;win);
							box(runner-&gt;win,0,0);
							wrefresh(runner-&gt;win);
							current_y--;
						}
						current_x = 1;
					}
					mvwaddch(runner-&gt;win,current_y, current_x,c);
					wrefresh(runner-&gt;win);
				}
			}
			if ( kill(pid,0) != 0 ) break;
			usleep(1000000);
		}
		close(log);
		unlink(tempfile);
		touchwin(runner-&gt;win);
		wrefresh(runner-&gt;win);
		if ( final_prompt ) alarm_window(final_prompt,ALARM_INFO,NULL,0);
		end_runner();
		return(last_status);
	}
	
}

void create_sub2(int x,int y,int width,int height,char *caption){
	int w,h,i,j;

	sub2-&gt;height  = height;
	sub2-&gt;width   = width;
	sub2-&gt;start_x = x;
	sub2-&gt;start_y = y;

	sub2-&gt;border.ls = &#039;|&#039;;
	sub2-&gt;border.rs = &#039;|&#039;;
	sub2-&gt;border.ts = &#039;-&#039;;
	sub2-&gt;border.bs = &#039;-&#039;;
	sub2-&gt;border.tl = &#039;+&#039;;
	sub2-&gt;border.tr = &#039;+&#039;;
	sub2-&gt;border.bl = &#039;+&#039;;
	sub2-&gt;border.br = &#039;+&#039;;


	x = 0;
	y = 0;
	w = sub2-&gt;width;
	h = sub2-&gt;height;


	if ( sub2-&gt;win == NULL ){ sub2-&gt;win = newwin(sub2-&gt;height,sub2-&gt;width,sub2-&gt;start_y,sub2-&gt;start_x); }
	wattron(sub2-&gt;win,COLOR_PAIR(BASE2_COLOR_NORMAL));


	for(j = y; j &lt;= y + h; ++j)
		for(i = x; i &lt;= x + w; ++i)
			mvwaddch(sub2-&gt;win,j, i, &#039; &#039;);

	box(sub2-&gt;win,0,0);
	wattron(sub2-&gt;win,A_BOLD);
	mvwprintw(sub2-&gt;win,y, x + (sub1-&gt;width / 2 - strlen(caption) / 2),&quot;%s&quot;,caption);
	wrefresh(sub2-&gt;win);
	refresh();
}

void create_sub1(){
	int x, y, w, h;
	int i,j;

	sub1-&gt;height  = rows - SUBWIN_Y_OFFSET * 2;
	sub1-&gt;width   = cols - SUBWIN_X_OFFSET * 2;
	sub1-&gt;start_x = SUBWIN_X_OFFSET;
	sub1-&gt;start_y = SUBWIN_Y_OFFSET;

	if ( sub1-&gt;win == NULL ){ sub1-&gt;win = newwin(sub1-&gt;height,sub1-&gt;width,sub1-&gt;start_y,sub1-&gt;start_x); }



	x = 0;
	y = 0;
	w = sub1-&gt;width;
	h = sub1-&gt;height;

	for(j = y; j &lt;= y + h; ++j)
		for(i = x; i &lt;= x + w; ++i)
			mvwaddch(sub1-&gt;win,j, i, &#039; &#039;);


	box(sub1-&gt;win,0,0);
	wattron(sub1-&gt;win,A_BOLD);
	mvwprintw(sub1-&gt;win,y, x + (sub1-&gt;width / 2 - strlen(option[current_option].caption) / 2),&quot;%s&quot;,option[current_option].caption);
	wattroff(sub1-&gt;win,A_BOLD);
	wrefresh(sub1-&gt;win);
	refresh();





}

void find_disks(int mode){
	DIR *dir;
	char fname[1024];
	struct dirent *diry;
	u_int64_t size;
	u_int64_t sectors;
	u_int64_t uptime;
	u_int64_t badsectors;
	char israid;
	int partitions;
	char buf[1024];
	FILE *fp;
	struct stat st;
	disks = 0;
	dir = opendir(&quot;/sys/class/block&quot;);
	if ( dir ){
		while ( (diry = readdir(dir)) != NULL ){
			SkDisk *d;
			if ( strcmp(diry-&gt;d_name,&quot;.&quot;) == 0 ) continue;
			if ( strcmp(diry-&gt;d_name,&quot;..&quot;) == 0 ) continue;

			israid = 0;
			sprintf(fname,&quot;/sys/class/block/%s/md&quot;,diry-&gt;d_name);
			if ( stat(fname,&amp;st) == 0 &amp;&amp; mode == MODE_ROOT_DISKS ){ israid = 1; continue; }
			if ( stat(fname,&amp;st) == 0 &amp;&amp; mode == MODE_FS_DISKS ){ israid = 1;  }

			sprintf(fname,&quot;/sys/class/block/%s/partition&quot;,diry-&gt;d_name);
			if ( stat(fname,&amp;st) == 0 &amp;&amp; mode == MODE_ROOT_DISKS ) continue;
			if ( stat(fname,&amp;st) != 0 &amp;&amp; israid == 0 &amp;&amp; mode == MODE_FS_DISKS ) continue;

			sprintf(fname,&quot;/sys/class/block/%s/size&quot;,diry-&gt;d_name);
			fp = fopen(fname,&quot;r&quot;);
			if ( fp == NULL ) continue;
			if ( fgets(buf,1024,fp) == NULL ) { fclose(fp); continue; }
			fclose(fp);
			if ( sscanf(buf,&quot;%ju&quot;,&amp;size) != 1 || size &lt;= 0  ) continue;
			sectors = size;
			size *= (u_int64_t) BSIZE;
			// printf(&quot;/dev/%s -&gt; [%s] RAID: %d\r\n&quot;,diry-&gt;d_name,showsize(size),israid);
			disk = (struct _disk *)realloc(disk,sizeof(struct _disk) * (disks+1));
			sprintf(disk[disks].devname,&quot;/dev/%s&quot;,diry-&gt;d_name);
			sprintf(disk[disks].serial,&quot;N.A.&quot;);
			sprintf(disk[disks].model,&quot;N.A.&quot;);
			sprintf(disk[disks].uptime,&quot;N.A.&quot;);
			sprintf(disk[disks].badsectors,&quot;N.A.&quot;);
			if ( sk_disk_open(disk[disks].devname,&amp;d) == 0 ){
				if ( sk_disk_smart_read_data(d) == 0 ){
					SkBool available;
					u_int64_t uptime;
					u_int64_t badsectors;
					const SkIdentifyParsedData *data;
					if ( sk_disk_smart_get_power_on(d,&amp;uptime) == 0 ){
						sprintf(disk[disks].uptime,&quot;%ju h&quot;,uptime/ ( 1000 * 3600));
					}
					if ( sk_disk_smart_get_bad(d,&amp;badsectors) == 0 ){
						sprintf(disk[disks].badsectors,&quot;%ju&quot;,badsectors);
					}
					if ( sk_disk_identify_is_available(d,&amp;available) == 0 &amp;&amp; available ){
						if ( sk_disk_identify_parse(d,&amp;data) == 0 ){
							sprintf(disk[disks].serial,&quot;%s&quot;,data-&gt;serial);
							sprintf(disk[disks].model,&quot;%s&quot;,data-&gt;model);
						}
					}
				}
				sk_disk_free(d);
			}
			disk[disks].israid = israid;
			disk[disks].size = size;
			disk[disks].sectors = sectors;
			disks++;
		}			
	}
	closedir(dir);
	qsort(disk,disks,sizeof(struct _disk),disk_sorter);

}

int cur_part_action = 0;
int disk_index;
int part_index;

void show_part_options();

int leftright(int ch){
	switch(ch){
		case KEY_ENTER:
		case 0x000A:
			return(0);
			break;
		case KEY_RIGHT:
		case 0x0009:
			cur_part_action++;
			if ( cur_part_action &gt; 3 ) cur_part_action = 0;
			show_part_options();
			break;
		case KEY_LEFT:
		case KEY_BTAB:
			cur_part_action--;
			if ( cur_part_action &lt; 0 ) cur_part_action = 3;
			show_part_options();
			break;

	}	
	return(HANDLER_RETURN_STAY);

}

#define NEW_PARTITION 0
#define DEL_PARTITION 1
#define NEW_LAYOUT    2
#define NEW_LAYOUT2   3
#define NEW_PARTITION_TEXT &quot;&lt;New Partition&gt;&quot;
#define DEL_PARTITION_TEXT &quot;&lt;Del Partition&gt;&quot;
#define NEW_LAYOUT_TEXT    &quot;&lt;Std. layout(EFI, Remain: Linux)&gt;&quot;
#define NEW_LAYOUT2_TEXT   &quot;&lt;Std. RAID layout(EFI, Remain: Linux)&gt;&quot;
#define PART_Y_START 1
#define PART_X_START 1

void show_part_options(){
	int x_offset;
	int y_offset;
	x_offset = 0;
	y_offset = 0;
	wattroff(sub2-&gt;win,A_REVERSE);
	if ( cur_part_action == NEW_PARTITION ) wattron(sub2-&gt;win,A_REVERSE);
	mvwprintw(sub2-&gt;win,PART_Y_START + y_offset, PART_X_START + x_offset, NEW_PARTITION_TEXT);
	x_offset += strlen(NEW_PARTITION_TEXT) + 1;

	wattroff(sub2-&gt;win,A_REVERSE);
	if ( cur_part_action == DEL_PARTITION) wattron(sub2-&gt;win,A_REVERSE);
	mvwprintw(sub2-&gt;win,PART_Y_START + y_offset, PART_X_START + x_offset, DEL_PARTITION_TEXT);
	x_offset += strlen(DEL_PARTITION_TEXT) + 1;
	x_offset = 0;
	y_offset++;

	wattroff(sub2-&gt;win,A_REVERSE);
	if ( cur_part_action == NEW_LAYOUT ) wattron(sub2-&gt;win,A_REVERSE);
	mvwprintw(sub2-&gt;win,PART_Y_START + y_offset, PART_X_START + x_offset, NEW_LAYOUT_TEXT);
	x_offset += strlen(NEW_LAYOUT_TEXT) + 1;

	wattroff(sub2-&gt;win,A_REVERSE);
	if ( cur_part_action == NEW_LAYOUT2 ) wattron(sub2-&gt;win,A_REVERSE);
	mvwprintw(sub2-&gt;win,PART_Y_START + y_offset, PART_X_START + x_offset, NEW_LAYOUT2_TEXT );
	x_offset += strlen(NEW_LAYOUT2_TEXT ) + 1;

	wrefresh(sub2-&gt;win);

	return;
}



int wanted_raidlevel; 
#define LEVEL0  &quot;[RAID-0] Stripe&quot;
#define LEVEL1  &quot;[RAID-1] Mirror&quot;
#define LEVEL10 &quot;[RAID-10] Mirror+Stripe&quot;

void show_raidlevel(){
	int x_offset;
	if ( wanted_raidlevel == 1 ){
		x_offset = 1;
		wattroff(sub2-&gt;win, A_REVERSE);
		mvwprintw(sub2-&gt;win,3,x_offset,LEVEL0);
		x_offset += strlen(LEVEL0) + 1;
		wattron(sub2-&gt;win, A_REVERSE);
		mvwprintw(sub2-&gt;win,3,x_offset,LEVEL1);
		wattroff(sub2-&gt;win, A_REVERSE);
		x_offset += strlen(LEVEL1) + 1;
		wattroff(sub2-&gt;win, A_REVERSE);
		mvwprintw(sub2-&gt;win,3,x_offset,LEVEL10);
		wattroff(sub2-&gt;win, A_REVERSE);
	} else if ( wanted_raidlevel == 0 ){
		x_offset = 1;
		wattron(sub2-&gt;win, A_REVERSE);
		mvwprintw(sub2-&gt;win,3,x_offset,LEVEL0);
		x_offset += strlen(LEVEL0) + 1;
		wattroff(sub2-&gt;win, A_REVERSE);
		mvwprintw(sub2-&gt;win,3,x_offset,LEVEL1);
		wattroff(sub2-&gt;win, A_REVERSE);
		x_offset += strlen(LEVEL1) + 1;
		wattroff(sub2-&gt;win, A_REVERSE);
		mvwprintw(sub2-&gt;win,3,x_offset,LEVEL10);
		wattroff(sub2-&gt;win, A_REVERSE);
	} else {
		x_offset = 1;
		wattroff(sub2-&gt;win, A_REVERSE);
		mvwprintw(sub2-&gt;win,3,x_offset,LEVEL0);
		x_offset += strlen(LEVEL0) + 1;
		wattroff(sub2-&gt;win, A_REVERSE);
		mvwprintw(sub2-&gt;win,3,x_offset,LEVEL1);
		wattroff(sub2-&gt;win, A_REVERSE);
		x_offset += strlen(LEVEL1) + 1;
		wattron(sub2-&gt;win, A_REVERSE);
		mvwprintw(sub2-&gt;win,3,x_offset,LEVEL10);
		wattroff(sub2-&gt;win, A_REVERSE);
	}
	wrefresh(sub2-&gt;win);
}


int toggle_raidlevel(int key){
	if ( key == KEY_LEFT ){
		wanted_raidlevel--;
		if ( wanted_raidlevel &lt; 0 ) wanted_raidlevel = 0;
		show_raidlevel();
	}
	if ( key == KEY_RIGHT ){
		wanted_raidlevel++;
		if ( wanted_raidlevel &gt; 2 ) wanted_raidlevel = 2;
		show_raidlevel();
	}
	return(HANDLER_RETURN_STAY);
}


void create_raid(){
	char cmd[1024];
	struct _select2 *sel;
	int disks_found;
	int i;
	char buf[1024];
	int array_index;
	char caption[1024];
	wanted_raidlevel = 1;
RERUN_RAID_LIST:
	update_raidlist();
	array_index = 0;
	{
		DIR *dir;
		struct dirent *diry;
		dir = opendir(&quot;/dev/&quot;);
		if ( dir ){
			while ( (diry = readdir(dir)) != NULL ){
				if ( strncmp(diry-&gt;d_name,&quot;md&quot;,2) != 0 ) continue;
				if ( strlen(diry-&gt;d_name) &lt; 3 ) continue;
				if ( atoi(&amp;diry-&gt;d_name[2]) &gt;= array_index ) array_index = atoi(&amp;diry-&gt;d_name[2]) + 1;
			}
			closedir(dir);
		}

	}
	touchwin(root);
	refresh();
	attron(COLOR_PAIR(BASE2_COLOR_NORMAL));
	create_sub1();
	wrefresh(sub1-&gt;win);

	if ( disk ) { free(disk); disk = NULL; }
	disks = 0;
	find_disks(MODE_FS_DISKS);

	if ( disks == 0 ){
		// Warn, no disks found!
		return;
	}
	sprintf(caption,&quot;Select partitions/arrays for RAID /dev/md%d&quot;,array_index);
	create_sub2(sub1-&gt;start_x + 2, sub1-&gt;start_y + 2, sub1-&gt;width - 4, sub1-&gt;height - 4, caption);
	sel = (struct _select2 *)malloc(sizeof(struct _select2) * disks);
	bzero(sel,sizeof(struct _select) * disks);
	for ( i = 0; i &lt; disks; i++ ){
		struct _raid *rd;
		char helper[1024];
		char helper2[124];
		if ( (rd = checkraidmember(disk[i].devname)) ){
			strcpy(helper2,showsize(rd-&gt;size));
			sprintf(helper,&quot;%s (%s) [%s, Level: %d, Size: %s]&quot;,
					disk[i].devname, showsize(disk[i].size),
					rd-&gt;devname,rd-&gt;level,helper2);
			sel[i].useable = 0;
		} else {
			sel[i].useable = 1;
			sprintf(helper,&quot;%s (%s)&quot;,
					disk[i].devname, showsize(disk[i].size));
		}
		sel[i].name     = strdup(helper);
		sel[i].selected = 0;
	}
	mvwprintw(sub2-&gt;win,1,1,&quot;&lt;SPACE&gt;:Toggle sel. &lt;UP/DOWN&gt;:Part. &lt;LEFT/RIGHT&gt;: RAID-LEVEL &lt;ESC&gt;:Go back &lt;CR&gt;:Create&quot;);
	show_raidlevel();
	wrefresh(sub2-&gt;win);
SELECTOR_RERUN: 
	current_select = 0;
	disk_index = run_selector2(NULL,sub2,4,sel,disks,toggle_raidlevel);
	if ( disk_index &lt; 0 ){
		attroff(COLOR_PAIR(BASE2_COLOR_NORMAL));
		erase();
		display_options();
		refresh();
		return;
	}
	disks_found = 0;
	sprintf(buf,&quot;Are you sure want to create RAID-Level %d (/dev/md%d) on\n&quot;,wanted_raidlevel == 2 ? 10 : wanted_raidlevel,array_index);
	for ( i = 0; i &lt; disks; i++ ){
		if ( sel[i].selected &amp;&amp; sel[i].useable == 0 ){
			char helper[1024];
			sprintf(helper,&quot;Disk %s\n Not useable (Already RAID-member)!&quot;,sel[i].name);
			alarm_window(helper,ALARM_ERROR,NULL,0);
			sel[i].selected = 0;
			goto SELECTOR_RERUN;
		}
		if ( sel[i].selected ){
			disks_found++;
			sprintf(&amp;buf[strlen(buf)],&quot;[%s]&quot;,disk[i].devname);
		}
	}
	sprintf(&amp;buf[strlen(buf)],&quot;?&quot;);

	if ( disks_found &lt; 2 &amp;&amp; wanted_raidlevel &lt; 2){
		alarm_window(&quot;You must select at least 2 partitions to build a Level 1 or Level 0 array&quot;,ALARM_ERROR,NULL,0);
		for ( i = 0; i &lt; disks; i++ ){
			free(sel[i].name);
		}
		free(sel);
		goto RERUN_RAID_LIST;
	}
	if ( disks_found &lt; 4 &amp;&amp; wanted_raidlevel == 2){
		alarm_window(&quot;You must select at least 4 partitions to build a Level 10 array&quot;,ALARM_ERROR,NULL,0);
		for ( i = 0; i &lt; disks; i++ ){
			free(sel[i].name);
		}
		free(sel);
		goto RERUN_RAID_LIST;
	}
	if ( alarm_window(buf,ALARM_OKCANCEL,NULL,ANSWER_OK) == ANSWER_CANCEL ){
		for ( i = 0; i &lt; disks; i++ ){
			free(sel[i].name);
		}
		free(sel);
	       goto RERUN_RAID_LIST;
	}
	sprintf(buf,&quot;&quot;);
	disks_found = 0;
	for ( i = 0; i &lt; disks; i++ ){
		if ( sel[i].selected ){
			disks_found++;
			sprintf(&amp;buf[strlen(buf)],&quot; %s&quot;,disk[i].devname);
		}
	}
	if ( wanted_raidlevel == 0 ){
		sprintf(cmd,RAID_0_CMD, array_index, disks_found,buf);
	} else if ( wanted_raidlevel == 1 ) {
		sprintf(cmd,RAID_1_CMD, array_index, disks_found,buf);
	} else {
		sprintf(cmd,RAID_10_CMD, array_index, disks_found,buf);
	}
	{
		int i;
		char *hlp;
		char *hlp2;
		char **arg;
		int args;
		char *ptr;
		int result;
		
		for ( i = 0; i &lt; disks; i++ ){
			if ( sel[i].selected ){
				int jj;
				arg = NULL;
				args = 0;
				arg = (char **)realloc(arg,sizeof(char *) * (args+1));	
				arg[args++] = RAID_CMD;
				arg = (char **)realloc(arg,sizeof(char *) * (args+1));	
				arg[args++] = strdup(&quot;--zero-superblock&quot;);
				arg = (char **)realloc(arg,sizeof(char *) * (args+1));	
				arg[args++] = strdup(disk[i].devname);
				arg = (char **)realloc(arg,sizeof(char *) * (args+1));	
				arg[args++] = NULL;
				sprintf(buf,&quot;Zeroing superblock of %s&quot;,disk[i].devname);
				result = run_program(arg[0],arg,buf,NULL);
				/*
				for ( jj = 0; jj &lt; (args-1); jj++ ) free(arg[jj]);
				free(arg);
				sprintf(buf,&quot;ZERO OF [%s] Result: %d&quot;,disk[i].devname,result);
				alarm_window(buf,ALARM_INFO,NULL,0);
				*/
			}
		}
		for ( i = 0; i &lt; disks; i++ ){
			if ( sel[i].selected ){
				char block[512];
				int fd;
				int j;
				bzero(block,512);
				fd = open(disk[i].devname,O_WRONLY);
				if ( fd &lt; 0 ){
					sprintf(buf,&quot;Cannot open &#039;%s&#039; for writing&quot;,disk[i].devname);
					alarm_window(buf,ALARM_ERROR,NULL,0);
				} else {
					for ( j = 0; j &lt; 100; j++ ){
						result = write(fd,block,512);
					}
					close(fd);
					/*
					sprintf(buf,&quot;Superblock zeroed at &#039;%s&#039; (%d)&quot;,disk[i].devname,result);
					alarm_window(buf,ALARM_INFO,NULL,0);
					*/
				}
			}
		}

		arg = NULL;
		args = 0;
		hlp = strdup(cmd);
		hlp2 = hlp;
		while ( (ptr = strtok(hlp,&quot; \t&quot;)) != NULL ){
			hlp = NULL;
			arg = (char **)realloc(arg,sizeof(char *) * (args+1));	
			arg[args++] = strdup(ptr);
		}
		arg = (char **)realloc(arg,sizeof(char *) * (args+1));	
		arg[args++] = NULL;

		result = run_program(arg[0],arg,&quot;Creating RAID&quot;,&quot;RAID completed&quot;);
		for ( i = 0; i &lt; args; i++ ){
			if ( arg[i] ) free(arg[i]);
		}
		free(arg);
		free(hlp2);
		{

			char **arg;
			int args;
			char caption[1024];
			char fsname[1024];
			char result[1024];
			sprintf(fsname,&quot;/dev/md%d&quot;,array_index);
			arg  = NULL; 
			args = 0;
			arg = (char **)realloc(arg,sizeof(char *) * (args+1));
			arg[args++] = strdup(EXT4_COMMAND);
			arg = (char **)realloc(arg,sizeof(char *) * (args+1));
			arg[args++] = strdup(&quot;-v&quot;);
			arg = (char **)realloc(arg,sizeof(char *) * (args+1));
			arg[args++] = strdup(fsname);
			arg = (char **)realloc(arg,sizeof(char *) * (args+1));
			arg[args++] = NULL;
			sprintf(fsname,&quot;Creating EXT4 at /dev/md%d&quot;,array_index);
			sprintf(result,&quot;EXT4 at /dev/md%d created&quot;,array_index);
			run_program(arg[0],arg,fsname,result);
			for ( i = 0; i &lt; args-1; i++ ) free(arg[i]);
			free(arg);
		}
	}
	for ( i = 0; i &lt; disks; i++ ){
		free(sel[i].name);
	}
	free(sel);
	goto RERUN_RAID_LIST;

	
}

void disk_setup(){
	int i;
	int parts;
	int shown;
	struct _select *sel;
	char new_caption[1024];
	char buf[1024];
	struct fdisk_partition *pa;
	struct fdisk_iter *itr;
	size_t partno_list[256];



DISK_GO_AGAIN:
	attron(COLOR_PAIR(BASE2_COLOR_NORMAL));
	create_sub1();
	if ( disk ) { free(disk); disk = NULL; }
	disks = 0;
	find_disks(MODE_ROOT_DISKS);

	if ( disks == 0 ){
		// Warn, no disks found!
		return;
	}

	create_sub2(sub1-&gt;start_x + 2, sub1-&gt;start_y + 2, sub1-&gt;width - 4, sub1-&gt;height - 4, &quot;Select disk&quot;);
	sel = (struct _select *)malloc(sizeof(struct _select) * disks);
	bzero(sel,sizeof(struct _select) * disks);
	for ( i = 0; i &lt; disks; i++ ){
		char helper[1024];
		sprintf(helper,&quot;%s (%s) Serial:[%s], Bad-Sect: [%s], Model:[%s], Uptime:[%s]&quot;,
				disk[i].devname, showsize(disk[i].size), disk[i].serial, disk[i].badsectors, disk[i].model,disk[i].uptime);
		sel[i].name = strdup(helper);
	}
	current_select = 0;
	disk_index = run_selector(NULL,sub2,0,sel,disks,NULL);
	for ( i = 0; i &lt; disks; i++ ){
		free(sel[i].name);
	}
	free(sel);
	if ( disk_index &lt; 0 ){
		attroff(COLOR_PAIR(BASE2_COLOR_NORMAL));
		erase();
		display_options();
		refresh();
		return;
	}
	shown = 0;
DISK_RELOAD_ME_AGAIN:
        sprintf(new_caption,&quot;Setting up [%s]&quot;,disk[disk_index].devname);
        create_sub2(sub1-&gt;start_x + 2, sub1-&gt;start_y + 2, sub1-&gt;width - 4, sub1-&gt;height - 4,new_caption);				      

	disk[disk_index].ctx = fdisk_new_context();
	if ( disk[disk_index].ctx == NULL ){
		alarm_window(&quot;Cannot get Disk-Handle&quot;,ALARM_FATAL,NULL,0);
	}
	if ( fdisk_assign_device(disk[disk_index].ctx,disk[disk_index].devname,0) ){ 
		alarm_window(&quot;Cannot assign Disk-Handle&quot;,ALARM_FATAL,NULL,0);
	}

	disk[disk_index].cylinders     = fdisk_get_geom_cylinders(disk[disk_index].ctx);
	disk[disk_index].heads         = fdisk_get_geom_heads(disk[disk_index].ctx);
	disk[disk_index].geom_secs     = fdisk_get_geom_sectors(disk[disk_index].ctx);
	disk[disk_index].first_lba     = fdisk_get_first_lba(disk[disk_index].ctx);
	disk[disk_index].last_lba      = fdisk_get_last_lba(disk[disk_index].ctx);
	disk[disk_index].sector_size   = fdisk_get_sector_size(disk[disk_index].ctx);
	disk[disk_index].label         = fdisk_get_label(disk[disk_index].ctx,NULL);
	disk[disk_index].labels        = fdisk_get_nlabels(disk[disk_index].ctx);






	disk[disk_index].tb = NULL;
	if ( fdisk_get_partitions(disk[disk_index].ctx,&amp;disk[disk_index].tb) != 0 ){
		if ( alarm_window(&quot;Cannot read Partition-Table\n    Create a new one?&quot;,ALARM_OKCANCEL,NULL,0) != ANSWER_OK){
			fdisk_deassign_device(disk[disk_index].ctx,0);
			fdisk_unref_context(disk[disk_index].ctx);
			goto DISK_GO_AGAIN;
		}
		disk[disk_index].tb = fdisk_new_table();
		if ( fdisk_reset_table(disk[disk_index].tb) != 0 ){
			alarm_window(&quot;Cannot reset Partition-Table&quot;,ALARM_FATAL,NULL,0);
		}
		if ( fdisk_create_disklabel(disk[disk_index].ctx,&quot;GPT&quot;) != 0 &amp;&amp; fdisk_create_disklabel(disk[disk_index].ctx,&quot;DOS&quot;) != 0 ){
			alarm_window(&quot;Cannot assigen Disk-Label (neither GPT or DOS)&quot;,ALARM_FATAL,NULL,0);
		}
		if ( fdisk_apply_table(disk[disk_index].ctx,disk[disk_index].tb) ){
			alarm_window(&quot;Cannot apply table (neither GPT or DOS)&quot;,ALARM_FATAL,NULL,0);
		}
		if ( fdisk_write_disklabel(disk[disk_index].ctx) != 0 ){
			alarm_window(&quot;Cannot write Disk-Label&quot;,ALARM_FATAL,NULL,0);
		}
		fdisk_deassign_device(disk[disk_index].ctx,0);
		fdisk_unref_context(disk[disk_index].ctx);
		goto DISK_RELOAD_ME_AGAIN;
	}
	disk[disk_index].nents = fdisk_table_get_nents(disk[disk_index].tb);

	sprintf(buf,&quot;Disk-info\nLABEL: [%s], Model: [%s]\nCylinders: %jd,Sectors: %jd\nSector-Size: %ld,Heads: %jd\nFirst LBA: %jd, Last-LBA: %jd\nPartitions: %d&quot;,
			fdisk_label_get_name(disk[disk_index].label),
			disk[disk_index].model,
			disk[disk_index].cylinders,
			disk[disk_index].geom_secs,
			disk[disk_index].sector_size,
			disk[disk_index].heads,
			disk[disk_index].first_lba,
			disk[disk_index].last_lba,
			disk[disk_index].nents);
	/*
	{
		struct fdisk_label *lb;
		lb = NULL;
		while ( fdisk_next_label(disk[disk_index].ctx,&amp;lb) == 0 ){
			strcat(buf,&quot;[&quot;);
			strcat(buf,fdisk_label_get_name(lb));
			strcat(buf,&quot;]&quot;);
		}
	}
	*/
	if ( shown == 0 ){
		alarm_window(buf,ALARM_INFO,NULL,0);
	}
	shown = 1;
	pa = NULL;
	parts = 0;
	if ( disk[disk_index].nents ){
		sel = (struct _select *)malloc(sizeof(struct _select) * disk[disk_index].nents);
		bzero(sel,sizeof(struct _select) * disk[disk_index].nents);
	}
	itr = fdisk_new_iter(FDISK_ITER_FORWARD);
	while ( fdisk_table_next_partition(disk[disk_index].tb,itr,&amp;pa) == 0 ){
		const char *name;
		const char *uuid;
		uint64_t start, size;
		fdisk_sector_t end;
		size_t partno;
		const struct fdisk_parttype *typ;
		const char *typname;

		name   = fdisk_partition_get_name(pa);
		uuid   = fdisk_partition_get_uuid(pa);
		end    = fdisk_partition_get_end(pa);
		start  = fdisk_partition_get_start(pa);
		size   = fdisk_partition_get_size(pa);
		partno = fdisk_partition_get_partno(pa);
		partno_list[parts] = partno;
		typname = NULL;
		typ    = fdisk_partition_get_type(pa);
		if ( typ ){
			typname = fdisk_parttype_get_name(typ);
		}

		/*
		sprintf(buf,&quot;Part: %d\nName: [%s]\nUUID: [%s]\nStart: %jd\nSize: %jd\nEnd: %jd\nPartno: %d\nType: [%s]&quot;,parts,
				name ? name : &quot;NULL&quot;,
				uuid ? uuid : &quot;NULL&quot;,
				start,size,end,partno,
				typname ? typname : &quot;NULL&quot; );
		alarm_window(buf,ALARM_INFO,NULL,0);
		*/
		sprintf(buf,&quot;%02d [%s] [%jd - %jd] (%jd Blocks)&quot;,partno,typname ? typname : &quot;unknown&quot;,start,end,size);
		sel[parts].name = strdup(buf);
		parts++;
	}
	fdisk_free_iter(itr);

	cur_part_action = 0;
	if ( parts == 0 ){ cur_part_action = NEW_LAYOUT; }

	show_part_options();

	current_select = 0;
	part_index = run_selector(NULL,sub2,3,sel,parts,leftright);

	for ( i = 0; i &lt; parts; i++ ){
		free(sel[i].name);
	}
	if ( parts) free(sel);
	
	if ( part_index == -1 ){
		fdisk_unref_table(disk[disk_index].tb);
		fdisk_deassign_device(disk[disk_index].ctx,0);
		fdisk_unref_context(disk[disk_index].ctx);
		goto DISK_GO_AGAIN; 
	}
	if ( cur_part_action == DEL_PARTITION ){
		size_t partno;
		char new_label[1024];


		partno = partno_list[part_index];
		sprintf(new_label,&quot;Delete partion %d?&quot;,partno);
		if ( alarm_window(new_label,ALARM_OKCANCEL,NULL,ANSWER_OK) == ANSWER_CANCEL ){
			fdisk_deassign_device(disk[disk_index].ctx,0);
			fdisk_unref_context(disk[disk_index].ctx);
			goto DISK_RELOAD_ME_AGAIN;
		}
		if ( fdisk_delete_partition(disk[disk_index].ctx,partno) != 0 ){
			sprintf(new_label,&quot;Deleting partion %d failed!&quot;,partno);
			alarm_window(new_label,ALARM_ERROR,NULL,0);
			fdisk_deassign_device(disk[disk_index].ctx,0);
			fdisk_unref_context(disk[disk_index].ctx);
			goto DISK_RELOAD_ME_AGAIN;
		}
		if ( fdisk_write_disklabel(disk[disk_index].ctx) ){
			alarm_window(&quot;Writing partition table failed!&quot;,ALARM_ERROR,NULL,0);
			fdisk_deassign_device(disk[disk_index].ctx,0);
			fdisk_unref_context(disk[disk_index].ctx);
			goto DISK_RELOAD_ME_AGAIN;
		}
		fdisk_deassign_device(disk[disk_index].ctx,0);
		fdisk_unref_context(disk[disk_index].ctx);
		sprintf(new_label,&quot;Partion %d successfully deleted!&quot;,partno);
		alarm_window(new_label,ALARM_INFO,NULL,0);
		goto DISK_RELOAD_ME_AGAIN;

	}
	if ( cur_part_action == NEW_LAYOUT || cur_part_action == NEW_LAYOUT2  ){

			struct fdisk_partition *part;
			int index_efi;
			int index_linux_raid;
			int index_linux;
			int codes;
			int i;
			uintmax_t first_lba;
			uintmax_t part_size;
			struct fdisk_parttype **code;
			struct fdisk_table *tb;
			char new_label[1024];
			const char *disk_label; // The Partition table-type

			disk[disk_index].tb = fdisk_new_table();
			if ( fdisk_reset_table(disk[disk_index].tb) != 0 ){
				alarm_window(&quot;Cannot reset Partition-Table&quot;,ALARM_FATAL,NULL,0);
			}
			if ( fdisk_create_disklabel(disk[disk_index].ctx,&quot;GPT&quot;) != 0 &amp;&amp; fdisk_create_disklabel(disk[disk_index].ctx,&quot;DOS&quot;) != 0 ){
				alarm_window(&quot;Cannot assigen Disk-Label (neither GPT or DOS)&quot;,ALARM_FATAL,NULL,0);
			}
			if ( fdisk_apply_table(disk[disk_index].ctx,disk[disk_index].tb) ){
				alarm_window(&quot;Cannot apply table (neither GPT or DOS)&quot;,ALARM_FATAL,NULL,0);
			}
			if ( fdisk_write_disklabel(disk[disk_index].ctx) != 0 ){
				alarm_window(&quot;Cannot write Disk-Label&quot;,ALARM_FATAL,NULL,0);
			}

			disk[disk_index].label         = fdisk_get_label(disk[disk_index].ctx,NULL);
			disk_label = fdisk_label_get_name(disk[disk_index].label);		    
			sprintf(new_label,&quot;Are you sure you want to clear all data\nand create a bootable layout on %s [%s]?&quot;,disk[disk_index].devname,disk_label);
			if ( alarm_window(new_label,ALARM_OKCANCEL,NULL,ANSWER_OK) == ANSWER_CANCEL ){
				fdisk_deassign_device(disk[disk_index].ctx,0);
				fdisk_unref_context(disk[disk_index].ctx);
				goto DISK_RELOAD_ME_AGAIN;
			}
			codes = fdisk_label_get_nparttypes(disk[disk_index].label);
			code = (struct fdisk_parttype **)malloc(sizeof(struct fdisk_parttype *) * codes);
			index_efi = -1;
			index_linux = -1;
			index_linux_raid = -1;
			for ( i = 0; i &lt; codes; i++ ){
				const char *name;
				code[i] = fdisk_label_get_parttype(disk[disk_index].label,(size_t)i);
				name = fdisk_parttype_get_name(code[i]);
				if ( index_efi == -1 &amp;&amp; strncasecmp(name,&quot;EFI&quot;,3) == 0 ) index_efi = i;
				if ( index_linux_raid == -1 &amp;&amp; strncasecmp(name,&quot;Linux RAID&quot;,10) == 0 ) index_linux_raid = i;
				if ( index_linux_raid == -1 &amp;&amp; strncasecmp(name,&quot;Linux-RAID&quot;,10) == 0 ) index_linux_raid = i;
				if ( index_linux_raid == -1 &amp;&amp; strncasecmp(name,&quot;Linux_RAID&quot;,10) == 0 ) index_linux_raid = i;
				if ( index_linux      == -1 &amp;&amp; strncasecmp(name,&quot;Linux FILE&quot;,10) == 0 ) index_linux = i;
			}
			if ( index_linux_raid == -1 || index_efi == -1 || index_linux == -1 ){
				fdisk_deassign_device(disk[disk_index].ctx,0);
				fdisk_unref_context(disk[disk_index].ctx);
				alarm_window(&quot;Cannot get Credentials&quot;,ALARM_FATAL,NULL,0);
			}	
			disk[disk_index].tb = fdisk_new_table();
			if ( fdisk_reset_table(disk[disk_index].tb) != 0 ){
				alarm_window(&quot;Cannot reset Partition-Table&quot;,ALARM_FATAL,NULL,0);
			}
			if ( fdisk_create_disklabel(disk[disk_index].ctx,&quot;GPT&quot;) != 0 &amp;&amp; fdisk_create_disklabel(disk[disk_index].ctx,&quot;DOS&quot;) != 0 ){
				alarm_window(&quot;Cannot assigen Disk-Label (neither GPT or DOS)&quot;,ALARM_FATAL,NULL,0);
			}
			if ( fdisk_apply_table(disk[disk_index].ctx,disk[disk_index].tb) ){
				alarm_window(&quot;Cannot apply table (neither GPT or DOS)&quot;,ALARM_FATAL,NULL,0);
			}
			if ( fdisk_write_disklabel(disk[disk_index].ctx) != 0 ){
				alarm_window(&quot;Cannot write Disk-Label&quot;,ALARM_FATAL,NULL,0);
			}
			part = fdisk_new_partition();
			fdisk_partition_partno_follow_default(part,1);
			fdisk_partition_set_start(part,disk[disk_index].first_lba);
			fdisk_partition_set_size(part,204800);
			fdisk_partition_set_name(part,&quot;GIX-Linux-EFI&quot;);
			fdisk_partition_set_type(part,code[index_efi]);
			fdisk_partition_size_explicit(part,1);
			if ( fdisk_add_partition(disk[disk_index].ctx,part,NULL) ){
				alarm_window(&quot;Adding EFI partition failed!&quot;,ALARM_ERROR,NULL,0);
				fdisk_deassign_device(disk[disk_index].ctx,0);
				fdisk_unref_context(disk[disk_index].ctx);
				goto DISK_RELOAD_ME_AGAIN;
			}
			if ( fdisk_write_disklabel(disk[disk_index].ctx) ){
				alarm_window(&quot;Writing partition table failed!&quot;,ALARM_ERROR,NULL,0);
				fdisk_deassign_device(disk[disk_index].ctx,0);
				fdisk_unref_context(disk[disk_index].ctx);
				goto DISK_RELOAD_ME_AGAIN;
			}
			tb = NULL;
			if ( fdisk_get_partitions(disk[disk_index].ctx,&amp;tb) ){
				alarm_window(&quot;Re-loading partition table failed!&quot;,ALARM_ERROR,NULL,0);
				fdisk_deassign_device(disk[disk_index].ctx,0);
				fdisk_unref_context(disk[disk_index].ctx);
				goto DISK_RELOAD_ME_AGAIN;
			}

			part = fdisk_table_get_partition(tb,0); // Get EFI-Partition
			if ( part == NULL ){
				alarm_window(&quot;Re-reading partition table failed!&quot;,ALARM_ERROR,NULL,0);
				fdisk_deassign_device(disk[disk_index].ctx,0);
				fdisk_unref_context(disk[disk_index].ctx);
				goto DISK_RELOAD_ME_AGAIN;
			}
			first_lba = fdisk_partition_get_size(part) + disk[disk_index].first_lba;
			part_size = disk[disk_index].last_lba - first_lba;

			part = fdisk_new_partition();
			fdisk_partition_partno_follow_default(part,1);
			fdisk_partition_set_start(part,first_lba);
			fdisk_partition_set_size(part,part_size);
			fdisk_partition_set_name(part,&quot;GIX-Linux&quot;);
			if ( cur_part_action == NEW_LAYOUT2 ){
				fdisk_partition_set_type(part,code[index_linux_raid]);
			} else { 
				fdisk_partition_set_type(part,code[index_linux]);
			}
			fdisk_partition_size_explicit(part,1);
			if ( fdisk_add_partition(disk[disk_index].ctx,part,NULL) ){
				alarm_window(&quot;Adding Linux RAID partition failed!&quot;,ALARM_ERROR,NULL,0);
				fdisk_deassign_device(disk[disk_index].ctx,0);
				fdisk_unref_context(disk[disk_index].ctx);
				goto DISK_RELOAD_ME_AGAIN;
			}
			if ( fdisk_write_disklabel(disk[disk_index].ctx) ){
				alarm_window(&quot;Writing partition table failed!&quot;,ALARM_ERROR,NULL,0);
				fdisk_deassign_device(disk[disk_index].ctx,0);
				fdisk_unref_context(disk[disk_index].ctx);
				goto DISK_RELOAD_ME_AGAIN;
			}




			fdisk_deassign_device(disk[disk_index].ctx,0);
			fdisk_unref_context(disk[disk_index].ctx);
			sprintf(new_label,&quot;Basic  layout successfully created, creating EFI-Filesystem now...&quot;);
			alarm_window(new_label,ALARM_INFO,NULL,0);
			{
				char **arg;
				int args;
				char caption[1024];
				char efiname[1024];
				char result[1024];
				int i;
				sprintf(efiname,&quot;%s1&quot;,disk[disk_index].devname);
				arg  = NULL; 
				args = 0;
				arg = (char **)realloc(arg,sizeof(char *) * (args+1));
				arg[args++] = strdup(VFAT_COMMAND);
				arg = (char **)realloc(arg,sizeof(char *) * (args+1));
				arg[args++] = strdup(&quot;-v&quot;);
				arg = (char **)realloc(arg,sizeof(char *) * (args+1));
				arg[args++] = strdup(efiname);
				arg = (char **)realloc(arg,sizeof(char *) * (args+1));
				arg[args++] = NULL;
				sprintf(efiname,&quot;Creating VFAT at %s1&quot;,disk[disk_index].devname);
				sprintf(result,&quot;VFAT at %s1 created&quot;,disk[disk_index].devname);
				run_program(arg[0],arg,efiname,result);
				for ( i = 0; i &lt; args-1; i++ ) free(arg[i]);
				free(arg);
				if ( cur_part_action == NEW_LAYOUT ){
					char **arg;
					int args;
					char caption[1024];
					char efiname[1024];
					char result[1024];
					sprintf(efiname,&quot;%s2&quot;,disk[disk_index].devname);
					arg  = NULL; 
					args = 0;
					arg = (char **)realloc(arg,sizeof(char *) * (args+1));
					arg[args++] = strdup(EXT4_COMMAND);
					arg = (char **)realloc(arg,sizeof(char *) * (args+1));
					arg[args++] = strdup(&quot;-v&quot;);
					arg = (char **)realloc(arg,sizeof(char *) * (args+1));
					arg[args++] = strdup(efiname);
					arg = (char **)realloc(arg,sizeof(char *) * (args+1));
					arg[args++] = NULL;
					sprintf(efiname,&quot;Creating EXT4 at %s2&quot;,disk[disk_index].devname);
					sprintf(result,&quot;EXT4 at %s2 created&quot;,disk[disk_index].devname);
					run_program(arg[0],arg,efiname,result);
					for ( i = 0; i &lt; args-1; i++ ) free(arg[i]);
					free(arg);
				}
			}
			goto DISK_RELOAD_ME_AGAIN;
		}
		if ( cur_part_action == NEW_PARTITION ){
			int longest;
			int new_type;
			struct fdisk_parttype **code;
			int codes = 0;
			uintmax_t first_lba;
			uintmax_t last_lba;
			char buf[1024];
			char new_label[1024];
			const char *disk_label; // The Partition table-type
						
						
						
			disk_label = fdisk_label_get_name(disk[disk_index].label);		    
			codes = fdisk_label_get_nparttypes(disk[disk_index].label);
			code = (struct fdisk_parttype **)malloc(sizeof(struct fdisk_parttype *) * codes);
			sprintf(new_caption,&quot;Create new partition on [%s] (Mode:(%s))&quot;,disk[disk_index].devname,disk_label);
			create_sub2(sub1-&gt;start_x + 2, sub1-&gt;start_y + 2, sub1-&gt;width - 4, sub1-&gt;height - 4,new_caption);				      
			sel = (struct _select *)malloc(sizeof(struct _select ) * codes);
			bzero(sel,sizeof(struct _select ) * codes);
			longest = 0;
			for ( i = 0; i &lt; codes; i++ ){
				code[i] = fdisk_label_get_parttype(disk[disk_index].label,(size_t)i);
				if ( strlen(fdisk_parttype_get_name(code[i])) &gt; longest ) longest = strlen(fdisk_parttype_get_name(code[i]));
			}
			for ( i = 0; i &lt; codes; i++ ){
				if ( strcmp(disk_label,&quot;gpt&quot;) == 0 ){
					sprintf(buf,&quot;%s&quot;,
					fdisk_parttype_get_name(code[i]));
				} else {
					sprintf(buf,&quot;[%04X] %s&quot;,
					fdisk_parttype_get_code(code[i]),fdisk_parttype_get_name(code[i]));
				}
				{ 
					int j; 
					for ( j = strlen(fdisk_parttype_get_name(code[i])); j &lt; longest; j++ ) strcat(buf,&quot; &quot;);
				}
				sel[i].name = strdup(buf);
			}
			current_select = 0;
			new_type = run_selector(NULL,sub2,2,sel,codes,NULL);
			if ( new_type &lt; 0 ) goto DISK_RELOAD_ME_AGAIN;


			for ( i = 0; i &lt; codes; i++ ){
				free(sel[i].name);
			}
			free(sel);
	INPUT_LBA_FIRST:
			// We have a part-type now...continue to start lba...
			sprintf(new_label,&quot;Starting LBA(min: %ju, max: %ju):&quot;,disk[disk_index].first_lba,disk[disk_index].last_lba);
			sprintf(buf,&quot;%ju&quot;,disk[disk_index].first_lba);
			if ( alarm_window(new_label, ALARM_INPUT, buf, 16) ){
				fdisk_deassign_device(disk[disk_index].ctx,0);
				fdisk_unref_context(disk[disk_index].ctx);
				goto DISK_RELOAD_ME_AGAIN;
			}
			sscanf(buf,&quot;%ju&quot;,&amp;first_lba);
			if ( first_lba &lt; disk[disk_index].first_lba || first_lba &gt; disk[disk_index].last_lba ){
				sprintf(caption,&quot;Invalid first sector!\nMust be between %jd and %jd&quot;,disk[disk_index].first_lba,disk[disk_index].last_lba);
				alarm_window(caption,ALARM_ERROR,NULL,0);
				goto INPUT_LBA_FIRST;
			}	
			/*
			sprintf(new_label,&quot;Using First-LBA: %jd&quot;,first_lba);
			alarm_window(new_label,ALARM_INFO,NULL,0);	
			*/
	INPUT_LBA_LAST:
			sprintf(new_label,&quot;Ending LBA(min: %ju, max: %ju), &#039;+SizeKMB&#039; or &#039;max&#039;:&quot;,first_lba,disk[disk_index].last_lba);
			sprintf(buf,&quot;%ju&quot;,disk[disk_index].last_lba);
			if ( alarm_window(new_label, ALARM_INPUT, buf, 16) ){
				fdisk_deassign_device(disk[disk_index].ctx,0);
				fdisk_unref_context(disk[disk_index].ctx);
				goto DISK_RELOAD_ME_AGAIN;
			}
			if ( strncasecmp(buf,&quot;max&quot;,3) == 0 ){
				last_lba = disk[disk_index].last_lba;
			} else {
				if ( buf[0] == &#039;+&#039; ){
					u_int64_t the_size;
					char *ptr;
					sscanf(&amp;buf[1],&quot;%ju&quot;,&amp;the_size); 
					ptr = &amp;buf[1];
					while ( *ptr &amp;&amp; isdigit(*ptr) ) ptr++;
					if ( *ptr == &#039;G&#039; ) the_size *= (u_int64_t)1000 * (u_int64_t)1000 * (u_int64_t)1000;
					if ( *ptr == &#039;M&#039; ) the_size *= (u_int64_t)1000 * (u_int64_t)1000;
					if ( *ptr == &#039;K&#039; ) the_size *= (u_int64_t)1000;
					the_size /= (u_int64_t)disk[disk_index].sector_size;
					if ( the_size % (u_int64_t)disk[disk_index].sector_size ) the_size++;
					last_lba = first_lba + the_size;
					if ( (last_lba) &gt; disk[disk_index].last_lba ){
						sprintf(caption,&quot;Invalid last sector!\nMust be lower than %jd (calculated: %jd)&quot;,disk[disk_index].last_lba,last_lba);
						alarm_window(caption,ALARM_ERROR,NULL,0);
						goto INPUT_LBA_LAST;
					}
				} else {
					sscanf(buf,&quot;%ju&quot;,&amp;last_lba);
				}
				if ( last_lba &lt; first_lba || last_lba &gt; disk[disk_index].last_lba ){
					sprintf(caption,&quot;Invalid last sector!\nMust be between %jd and %jd&quot;,disk[disk_index].first_lba,disk[disk_index].last_lba);
					alarm_window(caption,ALARM_ERROR,NULL,0);
					goto INPUT_LBA_LAST;
				}	
			}
			sprintf(new_label,&quot;Creating new partition on %s\nFirst-Sector: %ju\nLast-Sector: %ju\nType: [%s]&quot;,
					disk[disk_index].devname,
					first_lba, last_lba,
					fdisk_parttype_get_name(code[new_type]));
				
			if ( alarm_window(new_label,ALARM_OKCANCEL,NULL,ANSWER_OK) == ANSWER_OK ){
				size_t partno;
				// Create partition here :-)
				struct fdisk_partition *part;
				part = fdisk_new_partition();
				// fdisk_partition_set_bootable(part,false);
				fdisk_partition_partno_follow_default(part,1);
				fdisk_partition_set_start(part,first_lba);
				fdisk_partition_set_size(part,last_lba - first_lba);
				fdisk_partition_set_name(part,&quot;GIX-Linux&quot;);
				fdisk_partition_size_explicit(part,1);
				fdisk_partition_set_type(part,code[new_type]);
				if ( fdisk_add_partition(disk[disk_index].ctx,part,&amp;partno) ){
					alarm_window(&quot;Adding partition failed!&quot;,ALARM_ERROR,NULL,0);
					fdisk_deassign_device(disk[disk_index].ctx,0);
					fdisk_unref_context(disk[disk_index].ctx);
					goto DISK_RELOAD_ME_AGAIN;
				}
				if ( fdisk_write_disklabel(disk[disk_index].ctx) ){
					alarm_window(&quot;Writing partition table failed!&quot;,ALARM_ERROR,NULL,0);
					fdisk_deassign_device(disk[disk_index].ctx,0);
					fdisk_unref_context(disk[disk_index].ctx);
					goto DISK_RELOAD_ME_AGAIN;
				}
				sprintf(new_label,&quot;Partition Nr. %d successfully created&quot;,partno);
				alarm_window(new_label,ALARM_INFO,NULL,0);
			}
			fdisk_deassign_device(disk[disk_index].ctx,0);
			fdisk_unref_context(disk[disk_index].ctx);
			goto DISK_RELOAD_ME_AGAIN;
			
		}

			


		fdisk_unref_table(disk[disk_index].tb);
		fdisk_deassign_device(disk[disk_index].ctx,0);
		fdisk_unref_context(disk[disk_index].ctx);


		





		attroff(COLOR_PAIR(BASE2_COLOR_NORMAL));
		erase();
		display_options();
		refresh();
		return;
}

struct _iface {
	char iface_name[64];
	unsigned char mac[128]; 
	int mac_len;
	unsigned char ipv4[4];
	int type; // According to if_arp.h
	int selected;
	int send_socket;
	int recv_socket;
	u_int32_t xid;
	int ifr_index;
	struct sockaddr_ll saddr_l;
};

struct _iface *iface = NULL;
int ifaces = 0;

char *display_mac2(unsigned char  *ift){
	static char retval[1024];
	int i;
	retval[0] = 0x00;
	for ( i = 0; i &lt; 6; i++ ){
		if ( i == 0 ){
			sprintf(&amp;retval[strlen(retval)],&quot;%02X&quot;,ift[i]);
		} else {
			sprintf(&amp;retval[strlen(retval)],&quot;:%02X&quot;,ift[i]);
		}
	}
	return(retval);
}

char *display_mac(struct _iface *ift){
	static char retval[1024];
	int i;
	retval[0] = 0x00;
	for ( i = 0; i &lt; ift-&gt;mac_len; i++ ){
		if ( i == 0 ){
			sprintf(&amp;retval[strlen(retval)],&quot;%02X&quot;,ift-&gt;mac[i]);
		} else {
			sprintf(&amp;retval[strlen(retval)],&quot;:%02X&quot;,ift-&gt;mac[i]);
		}
	}
	return(retval);
}

char *dump_if_flags(struct ifreq *ifr){
	static char response[128];
        response[0] = 0x00;
        if ( ifr-&gt;ifr_flags &amp; IFF_UP ) strcat(response,&quot;UP,&quot;);
        if ( ifr-&gt;ifr_flags &amp; IFF_RUNNING ) strcat(response,&quot;RUNNING,&quot;);
        if ( ifr-&gt;ifr_flags &amp; IFF_BROADCAST ) strcat(response,&quot;BROADCAST,&quot;);
        if ( ifr-&gt;ifr_flags &amp; IFF_DEBUG ) strcat(response,&quot;DEBUG,&quot;);
        if ( ifr-&gt;ifr_flags &amp; IFF_LOOPBACK ) strcat(response,&quot;LOOPBACK,&quot;);
        if ( ifr-&gt;ifr_flags &amp; IFF_POINTOPOINT ) strcat(response,&quot;POINTOPOINT,&quot;);
        if ( ifr-&gt;ifr_flags &amp; IFF_NOTRAILERS ) strcat(response,&quot;NOTRAILERS,&quot;);
        if ( ifr-&gt;ifr_flags &amp; IFF_NOARP ) strcat(response,&quot;NOARP,&quot;);
        if ( ifr-&gt;ifr_flags &amp; IFF_PROMISC ) strcat(response,&quot;PROMISC,&quot;);
        if ( ifr-&gt;ifr_flags &amp; IFF_ALLMULTI ) strcat(response,&quot;ALLMULTI,&quot;);
        if ( ifr-&gt;ifr_flags &amp; IFF_MASTER ) strcat(response,&quot;MASTER,&quot;);
        if ( ifr-&gt;ifr_flags &amp; IFF_SLAVE ) strcat(response,&quot;SLAVE,&quot;);
        if ( ifr-&gt;ifr_flags &amp; IFF_MULTICAST ) strcat(response,&quot;MULTICAST,&quot;);
        if ( ifr-&gt;ifr_flags &amp; IFF_PORTSEL ) strcat(response,&quot;PORTSEL,&quot;);
        if ( ifr-&gt;ifr_flags &amp; IFF_AUTOMEDIA ) strcat(response,&quot;AUTOMEDIA,&quot;);
        if ( ifr-&gt;ifr_flags &amp; IFF_DYNAMIC ) strcat(response,&quot;DYNAMIC,&quot;);

        if ( strlen(response) &amp;&amp; response[strlen(response)-1] == &#039;,&#039; ) response[strlen(response)-1] = 0x00;
        return(response);
}

struct _dhcpoffer {
	int interface;
	unsigned char client_ip[4];
	unsigned char router[4];
	unsigned char dhcp[4];
	unsigned char nameserver[4];
	unsigned char subnet[4];
	unsigned char broadcast[4];
	
};

struct _dhcpoffer *dhcpoffer;
int dhcpoffers;


void process_iface_packet(unsigned char *packet, int packet_len, int iface_idx){
		struct ethhdr *eth;
		struct ip *ip;
		struct gix_udphdr *udp;
		struct bootp_packet *bp;
		int dhcp_offset;
		unsigned char yiaddr[4];
		unsigned char router[4];
		unsigned char nameserver[4];
		unsigned char broadcast[4];
		unsigned char dhcp[4];
		unsigned char subnet[4];
		int i;

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

		dhcp_offset = sizeof(struct ethhdr) + sizeof(struct ip) + sizeof(struct gix_udphdr) + sizeof(struct bootp_packet);

		if ( eth-&gt;h_proto != htons(ETH_P_IP) ) return;

		if ( ip-&gt;ip_p != IPPROTO_UDP ) return;

		if ( ntohs(udp-&gt;dest) != 68 ) return;

		if ( memcmp(&amp;packet[dhcp_offset],dhcpmagic,4) != 0 ) return;

		dhcp_offset += 4;

	
		bzero(router,4);	
		bzero(nameserver,4);	
		bzero(broadcast,4);	
		bzero(dhcp,4);	
		bzero(subnet,4);	
		subnet[0] = 255;
		subnet[1] = 255;
		subnet[2] = 255;
		subnet[3] = 0;
		yiaddr[0] = (bp-&gt;yiaddr &gt;&gt; 0)  &amp; 0xFF; 
		yiaddr[1] = (bp-&gt;yiaddr &gt;&gt; 8)  &amp; 0xFF; 
		yiaddr[2] = (bp-&gt;yiaddr &gt;&gt; 16)  &amp; 0xFF; 
		yiaddr[3] = (bp-&gt;yiaddr &gt;&gt; 24)  &amp; 0xFF; 

		for ( i = 0; i &lt; dhcpoffers; i++ ){
			if ( dhcpoffer[i].interface == iface_idx &amp;&amp; memcmp(yiaddr,dhcpoffer[i].client_ip,4) == 0 ) break;
		}
		if ( i == dhcpoffers ){
			unsigned char option;
			unsigned char option_len;
			while ( dhcp_offset &lt; packet_len ){
				option = packet[dhcp_offset++];
				if ( option == 0xff ) break; // End of options
				option_len = packet[dhcp_offset++];
				scroll_logger(&quot;OPTION: %d, LEN: %d\n&quot;,option,option_len);
				if ( option == 3 ){
					memcpy(router,&amp;packet[dhcp_offset],4);
				}
				if ( option  == 1 ){
					memcpy(subnet,&amp;packet[dhcp_offset],4);
				}
				if ( option  == 6 ){
					memcpy(nameserver,&amp;packet[dhcp_offset],4);
				}
				if ( option  == 54 ){
					memcpy(dhcp,&amp;packet[dhcp_offset],4);
				}
				if ( option  == 28 ){
					memcpy(broadcast,&amp;packet[dhcp_offset],4);
				}
				if ( option == 53 )
					if ( packet[dhcp_offset] != 2 ) goto DHCP_NOT_VALID;
				dhcp_offset += option_len;
			}

			dhcpoffer = (struct _dhcpoffer *)realloc(dhcpoffer,sizeof(struct _dhcpoffer) * (dhcpoffers+1));
			bzero(&amp;dhcpoffer[dhcpoffers],sizeof(struct _dhcpoffer));
			memcpy(dhcpoffer[dhcpoffers].client_ip,yiaddr,4);
			memcpy(dhcpoffer[dhcpoffers].router,router,4);
			memcpy(dhcpoffer[dhcpoffers].dhcp,dhcp,4);
			memcpy(dhcpoffer[dhcpoffers].nameserver,nameserver,4);
			memcpy(dhcpoffer[dhcpoffers].broadcast,broadcast,4);
			memcpy(dhcpoffer[dhcpoffers].subnet,subnet,4);
			dhcpoffer[dhcpoffers].interface = iface_idx;

			

			scroll_logger(&quot;Received UDP Packet on Interface %s FROM:  [%s] (%d Bytes) %d.%d.%d.%d --&gt; %d.%d.%d.%d,\n               YIADDR: %d.%d.%d.%d, GW: %d.%d.%d.%d, BCAST: %d.%d.%d.%d, NS: %d.%d.%d.%d\n&quot;,iface[iface_idx].iface_name, display_mac2(eth-&gt;h_source),packet_len,
				( ip-&gt;ip_src.s_addr &gt;&gt; 0)  &amp; 0xFF, 
				( ip-&gt;ip_src.s_addr &gt;&gt; 8)  &amp; 0xFF, 
				( ip-&gt;ip_src.s_addr &gt;&gt; 16) &amp; 0xFF, 
				( ip-&gt;ip_src.s_addr &gt;&gt; 24) &amp; 0xFF,
				( ip-&gt;ip_dst.s_addr &gt;&gt; 0)  &amp; 0xFF, 
				( ip-&gt;ip_dst.s_addr &gt;&gt; 8)  &amp; 0xFF, 
				( ip-&gt;ip_dst.s_addr &gt;&gt; 16) &amp; 0xFF, 
				( ip-&gt;ip_dst.s_addr &gt;&gt; 24) &amp; 0xFF,
				( bp-&gt;yiaddr &gt;&gt; 0)  &amp; 0xFF, 
				( bp-&gt;yiaddr &gt;&gt; 8)  &amp; 0xFF, 
				( bp-&gt;yiaddr &gt;&gt; 16) &amp; 0xFF, 
				( bp-&gt;yiaddr &gt;&gt; 24) &amp; 0xFF,
				router[0],router[1],router[2], router[3],
				broadcast[0],broadcast[1],broadcast[2], broadcast[3],
				nameserver[0],nameserver[1],nameserver[2], nameserver[3]
				);
			dhcpoffers++;	
		}
DHCP_NOT_VALID:
		return;
}


struct _ipconfig {
	int iface;
	unsigned char ip[4];
	unsigned char netmask[4];
	unsigned char gw[4];
	unsigned char dhcp[4];
	unsigned char dns[4];
	unsigned char ftp_server[1024];
	unsigned char ftp_user[1024];
	unsigned char ftp_pwd[1024];
	char prefix[1024]; // A prefix used for...multi-purpose
	char ftp_ip[1024]; // The IP-Address of ftp_server, usefull, if more are used
};

struct _ipconfig ipconfig;


int setup_interface(struct _ipconfig *ipc){
	struct sockaddr_in sai;
	struct ifreq ifr;
	char buf[1024];
	int sock,i; 

	for ( i = 0; i &lt; ifaces; i++ ){
		sock = socket(AF_INET,SOCK_DGRAM,IPPROTO_IP);
		if ( sock &lt; 0 ){
			sprintf(buf,&quot;Setting up interface %s failed (Code: %d)&quot;,iface[i].iface_name,__LINE__);
			alarm_window(buf,ALARM_ERROR,NULL,0); 
			return(-1);
		}
		sai.sin_family = AF_INET;
		sai.sin_port   = 0;
		memset(&amp;sai.sin_addr.s_addr,0,4);
		bzero(&amp;ifr,sizeof(struct ifreq));
		strcpy(ifr.ifr_name,iface[i].iface_name);
		memcpy(&amp;(ifr.ifr_addr),&amp;sai,sizeof(struct sockaddr_in));
		if ( ioctl(sock,SIOCSIFADDR,&amp;ifr) != 0 ){
			sprintf(buf,&quot;Setting up interface %s failed (Code: %d)&quot;,iface[i].iface_name,__LINE__);
			alarm_window(buf,ALARM_ERROR,NULL,0); 
			close(sock);
			return(-1);
		}
		close(sock);
	}



	sock = socket(AF_INET,SOCK_DGRAM,IPPROTO_IP);
	if ( sock &lt; 0 ){
		sprintf(buf,&quot;Setting up interface %s failed (Code: %d)&quot;,iface[ipc-&gt;iface].iface_name,__LINE__);
		alarm_window(buf,ALARM_ERROR,NULL,0); 
		return(-1);
	}
	sai.sin_family = AF_INET;
	sai.sin_port   = 0;
	memcpy(&amp;sai.sin_addr.s_addr,ipc-&gt;ip,4);
	bzero(&amp;ifr,sizeof(struct ifreq));
	strcpy(ifr.ifr_name,iface[ipc-&gt;iface].iface_name);
	memcpy(&amp;(ifr.ifr_addr),&amp;sai,sizeof(struct sockaddr_in));
	if ( ioctl(sock,SIOCSIFADDR,&amp;ifr) != 0 ){
		sprintf(buf,&quot;Setting up interface %s failed (Code: %d)&quot;,iface[ipc-&gt;iface].iface_name,__LINE__);
		alarm_window(buf,ALARM_ERROR,NULL,0); 
		close(sock);
		return(-1);
	}
	sai.sin_family = AF_INET;
	sai.sin_port   = 0;
	memcpy(&amp;sai.sin_addr.s_addr,ipc-&gt;netmask,4);
	bzero(&amp;ifr,sizeof(struct ifreq));
	strcpy(ifr.ifr_name,iface[ipc-&gt;iface].iface_name);
	memcpy(&amp;(ifr.ifr_addr),&amp;sai,sizeof(struct sockaddr_in));
	if ( ioctl(sock,SIOCSIFNETMASK,&amp;ifr) != 0 ){
		sprintf(buf,&quot;Setting up interface %s failed (Code: %d)&quot;,iface[ipc-&gt;iface].iface_name,__LINE__);
		alarm_window(buf,ALARM_ERROR,NULL,0); 
		close(sock);
		return(-1);
	}
	bzero(buf,16);
	if ( memcmp(ipc-&gt;gw,buf,4) != 0 ){
		char print_ip[1024];
		struct rtentry rt2;
		struct sockaddr_in *addr;
		bzero(&amp;rt2,sizeof(struct rtentry));
		sprintf(print_ip,&quot;%d.%d.%d.%d&quot;,
				ipc-&gt;gw[0], ipc-&gt;gw[1],
				ipc-&gt;gw[2], ipc-&gt;gw[3]);
		addr = (struct sockaddr_in *)&amp;rt2.rt_gateway;
		addr-&gt;sin_family = AF_INET;
		addr-&gt;sin_port   = 0;
		addr-&gt;sin_addr.s_addr = inet_addr(print_ip);
		addr = (struct sockaddr_in *)&amp;rt2.rt_genmask;
		addr-&gt;sin_family = AF_INET;
		addr-&gt;sin_port   = 0;
		addr-&gt;sin_addr.s_addr = (in_addr_t)0;
		addr = (struct sockaddr_in *)&amp;rt2.rt_dst;
		addr-&gt;sin_family = AF_INET;
		addr-&gt;sin_port   = 0;
		addr-&gt;sin_addr.s_addr = (in_addr_t)0;
		rt2.rt_flags = RTF_GATEWAY;
		rt2.rt_metric = 0;
		rt2.rt_dev = iface[ipc-&gt;iface].iface_name; 
		if ( ioctl(sock,SIOCADDRT,&amp;rt2) != 0 ){
			sprintf(print_ip,&quot;Failed to set default route (%s)&quot;,strerror(errno));
			alarm_window(print_ip,ALARM_ERROR,NULL,0);
		}
	}
	if ( memcmp(ipc-&gt;dns,buf,4) != 0 ){
		FILE *fp;
		unlink(&quot;/etc/resolv.conf&quot;);
		fp = fopen(&quot;/etc/resolv.conf&quot;,&quot;w&quot;);
		if ( fp ){
			fprintf(fp,&quot;nameserver %d.%d.%d.%d\n&quot;,ipc-&gt;dns[0],ipc-&gt;dns[1],ipc-&gt;dns[2],ipc-&gt;dns[3]);
			fclose(fp);
		}
	}
	close(sock);
	return(0);
}


void detect_interfaces(){
	int iface_index;
	int idx;
	DIR *dir;
	struct dirent *diry;
	int i;
	int j;
	struct _select *sel;


	if ( iface ){
		for ( i = 0; i &lt; ifaces; i++ ){
			if ( iface[i].recv_socket ) close(iface[i].recv_socket);
			if ( iface[i].send_socket ) close(iface[i].send_socket);
		}
		free(iface);
		iface = NULL;
	}
	ifaces = 0;

	create_scroller(&quot;Detecting network&quot;);

	srandom(time(NULL));

	dir = opendir(&quot;/sys/class/net&quot;);
	if ( dir == NULL ){
		alarm_window(&quot;No network environement found!&quot;,ALARM_ERROR,NULL,0);
		return;
	}
	while ( (diry = readdir(dir)) != NULL ){
		char buf[1024];
		int sock;
		struct ifreq ifr;
		char fname[1024];
		unsigned char mac[124];
		int if_index;
		int mac_len;
		int type;
		int send_socket;
		FILE *fp; 

		if ( strcmp(diry-&gt;d_name,&quot;.&quot;) == 0 ) continue;
		if ( strcmp(diry-&gt;d_name,&quot;..&quot;) == 0 ) continue;
		sprintf(fname,&quot;/sys/class/net/%s/type&quot;,diry-&gt;d_name);
		fp = fopen(fname,&quot;r&quot;);
		if ( fp == NULL ) continue;
		if ( fgets(buf,1024,fp) == NULL ){
			fclose(fp);
			continue;
		}
		fclose(fp);
		type = atoi(buf);
		if ( type != ARPHRD_ETHER ) continue;
		sprintf(fname,&quot;/sys/class/net/%s/address&quot;,diry-&gt;d_name);
		fp = fopen(fname,&quot;r&quot;);
		if ( fp == NULL ) continue;
		if ( fgets(buf,1024,fp) == NULL ){
			fclose(fp);
			continue;
		}
		fclose(fp);

		switch(type){
			case ARPHRD_ETHER:
				mac_len = 6;
				break;
			default:
				mac_len = 0;
				break;
		}
		if ( mac_len == 6 ){
			sscanf(buf,&quot;%02X:%02X:%02X:%02X:%02X:%02X&quot;,
				&amp;mac[0], &amp;mac[1], &amp;mac[2],
				&amp;mac[3], &amp;mac[4], &amp;mac[5]);
		}

		sock = socket(AF_INET,SOCK_DGRAM,IPPROTO_IP);
		if ( sock &lt; 0 ) continue;
		bzero(&amp;ifr,sizeof(struct ifreq));
		strcpy(ifr.ifr_name,diry-&gt;d_name);
		if ( ioctl(sock,SIOCGIFINDEX,&amp;ifr) != 0 ){
			close(sock);
			continue;
		}
		if_index = ifr.ifr_ifindex;	
		if ( ioctl(sock,SIOCGIFFLAGS,&amp;ifr) != 0 ){
			close(sock);
			continue;
		}
		

		if ( ( ifr.ifr_flags &amp; IFF_UP ) &amp;&amp;  ( ifr.ifr_flags &amp; IFF_RUNNING ) ){
			// Well...nothing to do...
		} else {
			ifr.ifr_flags |= IFF_UP || IFF_RUNNING;
			if ( ioctl(sock,SIOCSIFFLAGS,&amp;ifr) != 0 ){
				sprintf(buf,&quot;INTERFACE: [%s] [%s--&gt; FLAGS: [%s]\n\nCannot set flags!\n&quot;,diry-&gt;d_name,dump_if_flags(&amp;ifr));
				alarm_window(buf,ALARM_ERROR,NULL,0);
				close(sock);
				continue;
			}
			scroll_logger(&quot;Turning on interface %s&quot;,diry-&gt;d_name);
			sleep(1);
			c_logger(&quot;.&quot;);
			sleep(1);
			c_logger(&quot;.&quot;);
			sleep(1);
			c_logger(&quot;.&quot;);
			sleep(1);
			c_logger(&quot;.\n&quot;);

		}
		close(sock); 
		send_socket = socket(AF_PACKET,SOCK_RAW,IPPROTO_RAW);
		if ( send_socket &lt; 0 ){
			sprintf(buf,&quot;INTERFACE: [%s]\n\nCannot open send-socket!\n&quot;,diry-&gt;d_name);
			alarm_window(buf,ALARM_ERROR,NULL,0);
			close(sock);
			continue;
		}
		sock = socket(AF_PACKET,SOCK_RAW,htons(ETH_P_ALL));
		if ( sock &lt; 0 ){
			sprintf(buf,&quot;INTERFACE: [%s]\n\nCannot open recv-socket!\n&quot;,diry-&gt;d_name);
			alarm_window(buf,ALARM_ERROR,NULL,0);
			close(send_socket);
			continue;
		}
		if ( setsockopt(sock,SOL_SOCKET,SO_BINDTODEVICE,diry-&gt;d_name,strlen(diry-&gt;d_name)) &lt; 0 ){
			sprintf(buf,&quot;INTERFACE: [%s]\n\nCannot bind recv-socket!\n&quot;,diry-&gt;d_name);
			scroll_logger(buf);
			alarm_window(buf,ALARM_ERROR,NULL,0);
			close(send_socket);
			close(sock);
			continue;
		}
		iface = (struct _iface *)realloc(iface,sizeof(struct _iface) * (ifaces+1));
		bzero(&amp;iface[ifaces],sizeof(struct _iface));
		strcpy(iface[ifaces].iface_name,diry-&gt;d_name);
		iface[ifaces].mac_len = mac_len;
		if ( mac_len ){
			memcpy(iface[ifaces].mac,mac,mac_len);
		}
		iface[ifaces].type = type;
		iface[ifaces].send_socket = send_socket;
		iface[ifaces].recv_socket = sock;
		iface[ifaces].xid = random(); 
		iface[ifaces].ifr_index = if_index;
		iface[ifaces].saddr_l.sll_ifindex = if_index;
		iface[ifaces].saddr_l.sll_halen = ETH_ALEN;

		sprintf(buf,&quot;INTERFACE: (%d) [%s] [%s] --&gt; FLAGS: [%s]\n&quot;,if_index,iface[ifaces].iface_name,display_mac(&amp;iface[ifaces]),dump_if_flags(&amp;ifr));
		// alarm_window(buf,ALARM_INFO,NULL,0);
		scroll_logger(buf);
		ifaces++;
	}
	closedir(dir);
	scroll_logger(&quot;Detecting DHCP..\n&quot;);
	for ( idx = 0; idx &lt; ifaces; idx++ ){
		char buf[512];
		int result;
		struct ethhdr *eth;
		struct ip *ip;
		struct gix_udphdr *udp;
		struct bootp_packet *bp;
		unsigned char packet[8192];
		int dhcp_offset;

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

		eth-&gt;h_proto = htons(ETH_P_IP);
		memcpy(eth-&gt;h_source,iface[idx].mac,6);
		memset(eth-&gt;h_dest,0xFF,6);

		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_dst.s_addr,ipbcast,4);
		udp-&gt;source = htons(68);
		udp-&gt;dest   = htons(67);
		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 :-)


		bp-&gt;op    = 1; // DHCP-Discover
		bp-&gt;htype = 1; 
		bp-&gt;hlen  = 6;
		bp-&gt;hops  = 0;
		bp-&gt;flags = 0;
		bp-&gt;xid   = iface[idx].xid; 
		memcpy(bp-&gt;chaddr,eth-&gt;h_source,6);

		dhcp_offset = sizeof(struct ethhdr) + sizeof(struct ip) + sizeof(struct gix_udphdr) + sizeof(struct bootp_packet);

		memcpy(&amp;packet[dhcp_offset],dhcpmagic,4); dhcp_offset += 4;

		packet[dhcp_offset++] = 0x35; // First option
		packet[dhcp_offset++] = 0x01; // Length
		packet[dhcp_offset++] = 0x01; // Message Type...01-Discover, 02-Offer, ...
		packet[dhcp_offset++] = 0x37; // List of wanted options
		packet[dhcp_offset++] = 0x09; // Count of wanted options
		packet[dhcp_offset++] = 1; 
		packet[dhcp_offset++] = 3; 
		packet[dhcp_offset++] = 5; 
		packet[dhcp_offset++] = 6; 
		packet[dhcp_offset++] = 13; 
		packet[dhcp_offset++] = 28; 
		packet[dhcp_offset++] = 54; 
		packet[dhcp_offset++] = 66; 
		packet[dhcp_offset++] = 67; 
		packet[dhcp_offset++] = 255;  // End of options

		ip-&gt;ip_len = (unsigned short) htons(dhcp_offset - sizeof(struct ethhdr) );
		udp-&gt;len = (unsigned short) htons( dhcp_offset - (sizeof(struct ethhdr) + sizeof(struct ip)) );				
		udp-&gt;check = udp_checksum(&amp;packet[sizeof(struct ethhdr)+ sizeof(struct ip)], (int) ntohs(udp-&gt;len),(struct ip *)&amp;packet[sizeof(struct ethhdr)]);
		ip-&gt;ip_sum = ip_checksum(&amp;packet[sizeof(struct ethhdr)],  sizeof(struct ip));
		memcpy(iface[idx].saddr_l.sll_addr,eth-&gt;h_dest,6);
	
		result = sendto(iface[idx].send_socket,packet,dhcp_offset,0,(struct sockaddr *)&amp;iface[idx].saddr_l,sizeof(struct sockaddr_ll));
		
		sprintf(buf,&quot;Sending packet (%d Bytes) FROM [%s] --&gt; %d\n&quot;, dhcp_offset, iface[idx].iface_name,result);
		scroll_logger(buf);	
	}

	if ( ifaces ) {
		int i;
		time_t start;
		struct pollfd *polly;
		polly = (struct pollfd *)malloc(sizeof(struct pollfd) * ifaces);
		
		start = time(NULL);
		while ( (start + DHCP_TIMEOUT) &gt; time(NULL)){
			for ( i = 0; i &lt; ifaces; i++ ){
				polly[i].fd     = iface[i].recv_socket;
				polly[i].events = POLLIN;
			}
			if ( poll(polly,ifaces,1000) &gt; 0 ){
				for ( i = 0; i &lt; ifaces; i++ ){
					if ( polly[i].revents &amp; POLLIN ){
						unsigned char packin[8192];
						int size;   
						size = recv(polly[i].fd,packin,8192,0);
						process_iface_packet(packin,size,i);
						
					}
				}
			}
		}
	}

	end_scroller();
	attron(COLOR_PAIR(BASE2_COLOR_NORMAL));
	create_sub2(sub1-&gt;start_x + 2, sub1-&gt;start_y + 2, sub1-&gt;width - 4, sub1-&gt;height - 4, &quot;Select network interface&quot;);
	sel = (struct _select *)malloc(sizeof(struct _select) * (ifaces + dhcpoffers));
	bzero(sel,sizeof(struct _select) * disks);
	for ( i = 0; i &lt; ifaces; i++ ){
		char helper[1024];
		sprintf(helper,&quot;%s [%s] manual configuration&quot;,iface[i].iface_name,display_mac(&amp;iface[i]));
		sel[i].name = strdup(helper);
	}
	for ( j = 0; j &lt;  dhcpoffers; j++ ){
		char helper[1024];
		sprintf(helper,&quot;%s [%s] IP: %d.%d.%d.%d, DHCP: %d.%d.%d.%d GW: %d.%d.%d.%d, NS: %d.%d.%d.%d, MASK: %d.%d.%d.%d&quot;,
				iface[dhcpoffer[j].interface].iface_name,
				display_mac(&amp;iface[dhcpoffer[j].interface]),
				dhcpoffer[j].client_ip[0], dhcpoffer[j].client_ip[1], dhcpoffer[j].client_ip[2], dhcpoffer[j].client_ip[3],
				dhcpoffer[j].dhcp[0], dhcpoffer[j].dhcp[1], dhcpoffer[j].dhcp[2], dhcpoffer[j].dhcp[3],
				dhcpoffer[j].router[0], dhcpoffer[j].router[1], dhcpoffer[j].router[2], dhcpoffer[j].router[3],
				dhcpoffer[j].nameserver[0], dhcpoffer[j].nameserver[1], dhcpoffer[j].nameserver[2], dhcpoffer[j].nameserver[3],
				dhcpoffer[j].subnet[0], dhcpoffer[j].subnet[1], dhcpoffer[j].subnet[2], dhcpoffer[j].subnet[3]);
		sel[j+i].name = strdup(helper);
	}
	current_select = 0;
	iface_index = run_selector(NULL,sub2,0,sel,ifaces+dhcpoffers,NULL);
	for ( i = 0; i &lt; ifaces + dhcpoffers ; i++ ){
		free(sel[i].name);
	}
	free(sel);
	if ( iface_index &lt; 0 ){
		attroff(COLOR_PAIR(BASE2_COLOR_NORMAL));
		erase();
		display_options();
		refresh();
		return;
	}
	if ( iface_index &gt;= ifaces ){
		bzero(&amp;ipconfig,sizeof(struct _ipconfig));
		strcpy(ipconfig.ftp_server,FTP_SERVER);
		strcpy(ipconfig.ftp_user,FTP_USER);
		strcpy(ipconfig.ftp_pwd,FTP_PWD);
		ipconfig.iface = dhcpoffer[iface_index - ifaces].interface;
		memcpy(ipconfig.ip,dhcpoffer[iface_index - ifaces].client_ip,4);
		memcpy(ipconfig.gw,dhcpoffer[iface_index - ifaces].router,4);
		memcpy(ipconfig.dhcp,dhcpoffer[iface_index - ifaces].dhcp,4);
		memcpy(ipconfig.dns,dhcpoffer[iface_index - ifaces].nameserver,4);
		memcpy(ipconfig.netmask,dhcpoffer[iface_index - ifaces].subnet,4);
		setup_interface(&amp;ipconfig);
	} else {
		in_addr_t ip;
		unsigned char temp_ip[1024];
		in_addr_t netmask;
		unsigned char temp_netmask[1024];
		in_addr_t dns;
		unsigned char temp_dns[1024];
		in_addr_t gw;
		unsigned char temp_gw[1024];
SETUP_ENTER_IP:
		sprintf(temp_ip,&quot;192.168.0.87&quot;);
		if ( alarm_window(&quot;Enter IPv4 Address: &quot;,ALARM_INPUT,temp_ip,16) &lt; 0 ){
			return;
		}
		if ( inet_addr(temp_ip) == INADDR_NONE ){
			alarm_window(&quot;Invalid IP-Address!&quot;,ALARM_ERROR,NULL,0);
			goto SETUP_ENTER_IP;
		} else {
			ip = inet_addr(temp_ip);
			temp_ip[0] = (ip &gt;&gt; 0)  &amp; 0xFF;
			temp_ip[1] = (ip &gt;&gt; 8)  &amp; 0xFF;
			temp_ip[2] = (ip &gt;&gt; 16)  &amp; 0xFF;
			temp_ip[3] = (ip &gt;&gt; 24)  &amp; 0xFF;
		}
SETUP_ENTER_NETMASK:
		sprintf(temp_netmask,&quot;255.255.255.128&quot;);
		if ( alarm_window(&quot;Enter IPv4 Netmask: &quot;,ALARM_INPUT,temp_netmask,16) &lt; 0 ){
			return;
		}
		if ( inet_addr(temp_netmask) == INADDR_NONE ){
			alarm_window(&quot;Invalid IP-NETMASK!&quot;,ALARM_ERROR,NULL,0);
			goto SETUP_ENTER_NETMASK;
		} else {
			netmask = inet_addr(temp_netmask);
			temp_netmask[0] = (netmask &gt;&gt; 0)  &amp; 0xFF;
			temp_netmask[1] = (netmask &gt;&gt; 8)  &amp; 0xFF;
			temp_netmask[2] = (netmask &gt;&gt; 16)  &amp; 0xFF;
			temp_netmask[3] = (netmask &gt;&gt; 24)  &amp; 0xFF;
		}
SETUP_ENTER_GW:
		sprintf(temp_gw,&quot;192.168.0.1&quot;);
		if ( alarm_window(&quot;Enter IPv4 Gateway: &quot;,ALARM_INPUT,temp_gw,16) &lt; 0 ){
			return;
		}
		if ( inet_addr(temp_gw) == INADDR_NONE ){
			alarm_window(&quot;Invalid IP-Gateway!&quot;,ALARM_ERROR,NULL,0);
			goto SETUP_ENTER_GW;
		} else {
			gw = inet_addr(temp_gw);
			temp_gw[0] = (gw &gt;&gt; 0)  &amp; 0xFF;
			temp_gw[1] = (gw &gt;&gt; 8)  &amp; 0xFF;
			temp_gw[2] = (gw &gt;&gt; 16)  &amp; 0xFF;
			temp_gw[3] = (gw &gt;&gt; 24)  &amp; 0xFF;
		}
SETUP_ENTER_DNS:
		sprintf(temp_dns,&quot;192.168.0.1&quot;);
		if ( alarm_window(&quot;Enter IPv4 DNS-Server: &quot;,ALARM_INPUT,temp_dns,16) &lt; 0 ){
			return;
		}
		if ( inet_addr(temp_dns) == INADDR_NONE ){
			alarm_window(&quot;Invalid IP-DNS-Server!&quot;,ALARM_ERROR,NULL,0);
			goto SETUP_ENTER_DNS;
		} else {
			dns = inet_addr(temp_dns);
			temp_dns[0] = (dns &gt;&gt; 0)  &amp; 0xFF;
			temp_dns[1] = (dns &gt;&gt; 8)  &amp; 0xFF;
			temp_dns[2] = (dns &gt;&gt; 16)  &amp; 0xFF;
			temp_dns[3] = (dns &gt;&gt; 24)  &amp; 0xFF;
		}

		bzero(&amp;ipconfig,sizeof(struct _ipconfig));
		strcpy(ipconfig.ftp_server,FTP_SERVER);
		strcpy(ipconfig.ftp_user,FTP_USER);
		strcpy(ipconfig.ftp_pwd,FTP_PWD);
		ipconfig.iface = iface_index;
		memcpy(ipconfig.ip,temp_ip,4);
		memcpy(ipconfig.gw,temp_gw,4);
		memcpy(ipconfig.dns,temp_dns,4);
		memcpy(ipconfig.netmask,temp_netmask,4);
		if ( alarm_window(&quot;Restart this interface (OK) or simply leave it running (CANCEL)&quot;,ALARM_OKCANCEL,NULL,ANSWER_CANCEL) == ANSWER_OK ){
			setup_interface(&amp;ipconfig);
		}
	}
	alarm_window(&quot;Interface SETUP completed successfully!&quot;,ALARM_INFO,NULL,0);
}

void do_network(){
	detect_interfaces();	
}




void exit_setup(){
	char **args;
	args = (char **)malloc(2 * sizeof(char *));
	args[0] = strdup(&quot;[SHELL]&quot;);
	args[1] = NULL;
	endwin();
	if ( execv(&quot;/bin/sh&quot;,args) &lt; 0 ){
		fprintf(stderr,&quot;EXECV failed (%s)\n&quot;,strerror(errno));
		exit(0);
	}
	exit(0);
}

void reboot_system(){
	char **arg;
	int args;

	if ( alarm_window(&quot;Are you sure, you want to reboot?&quot;,ALARM_OKCANCEL,NULL,ANSWER_OK) == ANSWER_OK ){
		int fd;
		fd = open(SYS_TRIGGER_CTL,O_WRONLY);
		if ( fd ){
			char buf[2];
			buf[0] = &#039;1&#039;;
			buf[1] = &#039;\n&#039;;
			write(fd,buf,2);
			close(fd);
		}
		fd = open(SYS_TRIGGER,O_WRONLY);
		if ( fd ){
			char buf[2];
			buf[0] = &#039;b&#039;;
			buf[1] = &#039;\n&#039;;
			write(fd,buf,2);
			close(fd);
		}
	}
	attroff(COLOR_PAIR(BASE2_COLOR_NORMAL));
	erase();
	display_options();
	refresh();
}



void run_main_action(){
	 option[current_option].handler();
}


void display_options(){
	int i;
	int longest_option = 0;

	draw_frame();
	for ( options = 0; option[options].caption != 0; options++ ){
		if ( strlen(option[options].caption) &gt; longest_option ) longest_option = strlen(option[options].caption);
	}
	for ( i = 0; i &lt; options; i++ ){
		move(i * 2 + OPTION_Y_OFFSET, OPTION_X_OFFSET);
		if ( current_option == i ){
			attron(A_REVERSE);
			printw(&quot;%s&quot;,option[i].caption);
			attroff(A_REVERSE);

		} else {
			attroff(A_REVERSE);
			printw(&quot;%s&quot;,option[i].caption);
		}
		refresh();
	}

}


void draw_frame(){
	int x;
	int y;

	getmaxyx(stdscr,rows,cols);
	screen-&gt;width = cols;
	screen-&gt;height = rows;
	if ( o_rows != rows || o_cols != cols ){
		clear();
		o_rows = rows;
		o_cols = cols;
	}
	box(root,0,0);
	// border( &#039;|&#039;, &#039;|&#039;, &#039;-&#039;, &#039;-&#039;, &#039;+&#039;, &#039;+&#039;, &#039;+&#039;, &#039;+&#039;);	
	y = 0;
	x = cols / 2 - strlen(caption)/2;
	move(0,x);
	attron(A_BOLD);
	printw(&quot;%s&quot;,caption);
	attroff(A_BOLD);
}

void raid_setup(){
		create_sub1();
		attroff(COLOR_PAIR(BASE2_COLOR_NORMAL));
		erase();
		update_raidlist();
		create_raid();
		attroff(COLOR_PAIR(BASE2_COLOR_NORMAL));
		erase();
		display_options();
		refresh();
}

void stop_raids(){
		int i;	
		for ( i = 0; i &lt; 256; i++ ){
			struct stat st;
			char fname[1024];
			char caption[1024];
			char result[1024];
			sprintf(fname,&quot;/dev/md%d&quot;,i);
			if ( stat(fname,&amp;st) == 0 ){
				char **arg;
				int args;
				int jj;
				arg  = NULL;
				args = 0;
				arg = (char **)realloc(arg,sizeof(char *) * (args+1));
				arg[args++] = strdup(RAID_CMD);
				arg = (char **)realloc(arg,sizeof(char *) * (args+1));
				arg[args++] = strdup(&quot;--stop&quot;);
				arg = (char **)realloc(arg,sizeof(char *) * (args+1));
				arg[args++] = strdup(fname);
				arg = (char **)realloc(arg,sizeof(char *) * (args+1));
				arg[args++] = NULL;
				sprintf(caption,&quot;Stopping %s&quot;,fname);
				sprintf(result,&quot;Stopped %s&quot;,fname);
				run_program(arg[0],arg,caption,result);
				for ( jj = 0; jj &lt; (args-1); jj++ ) free(arg[jj]);
				free(arg);
			}
		}
}

void raid_stop(){
		int i;	
		create_sub1();


		create_sub2(sub1-&gt;start_x + 2, sub1-&gt;start_y + 2, sub1-&gt;width - 4, sub1-&gt;height - 4, &quot;Stopping RAIDs&quot;);
		stop_raids();
		attroff(COLOR_PAIR(BASE2_COLOR_NORMAL));
		erase();
		display_options();
		refresh();
}

void zero_all_disks(){
		int i;	
		DIR *dir;
		struct dirent *diry;
		create_sub1();
		char zero_block[BSIZE];

		bzero(zero_block,BSIZE);


		create_sub2(sub1-&gt;start_x + 2, sub1-&gt;start_y + 2, sub1-&gt;width - 4, sub1-&gt;height - 4, &quot;Zeroing all disks&quot;);
		stop_raids();
		dir = opendir(&quot;/dev&quot;);
		if ( dir ){
			while ( (diry = readdir(dir)) != NULL ){
				char fname[1024];
				int fd;
				struct stat st;
				if ( strncmp(diry-&gt;d_name,&quot;sd&quot;,2) != 0 ) continue;
				if ( strlen(diry-&gt;d_name) &lt; 4 ) continue;
				sprintf(fname,&quot;/dev/%s&quot;,diry-&gt;d_name);
				if ( stat(fname,&amp;st) == 0 ){
					char **arg;
					int args;
					int jj;
					int result_tot;
					char result[256];
					arg  = NULL;
					args = 0;
					arg = (char **)realloc(arg,sizeof(char *) * (args+1));
					arg[args++] = strdup(RAID_CMD);
					arg = (char **)realloc(arg,sizeof(char *) * (args+1));
					arg[args++] = strdup(&quot;--zero-superblock&quot;);
					arg = (char **)realloc(arg,sizeof(char *) * (args+1));
					arg[args++] = strdup(fname);
					arg = (char **)realloc(arg,sizeof(char *) * (args+1));
					arg[args++] = NULL;
					sprintf(caption,&quot;Zeroing superblock for %s&quot;,fname);
					sprintf(result,&quot;Zeroed superblock for %s&quot;,fname);
					run_program(arg[0],arg,caption,result);
					create_scroller(&quot;Wiping device-header&quot;);
					for ( jj = 0; jj &lt; (args-1); jj++ ) free(arg[jj]);
					free(arg);
					fd = open(fname,O_WRONLY);
					if ( fd ){
						scroll_logger(&quot;Wiping %s...\n&quot;,fname);
						result_tot = 0;
						for ( i = 0; i &lt; 5000; i++ ){
							int result;
							result = write(fd,zero_block,BSIZE);
							result_tot += result;
							if (( i % 100 ) == 0 ) scroll_logger(&quot;Wiping Block: %d --&gt; (Written %d Bytes)\n&quot;,i,result_tot);
						}
						close(fd);
					}
					sleep(1);
					end_scroller();
				}

			}
			closedir(dir);
		}
		dir = opendir(&quot;/dev&quot;);
		if ( dir ){
			while ( (diry = readdir(dir)) != NULL ){
				int jj;
				char fname[1024];
				int fd;
				int result_tot;
				struct stat st;
				if ( strncmp(diry-&gt;d_name,&quot;sd&quot;,2) != 0 ) continue;
				if ( strlen(diry-&gt;d_name) &gt; 3 ) continue;
				sprintf(fname,&quot;/dev/%s&quot;,diry-&gt;d_name);
				if ( stat(fname,&amp;st) == 0 ){
					char **arg;
					int args;
					int jj;
					int result_tot;
					char result[256];
					arg  = NULL;
					args = 0;
					arg = (char **)realloc(arg,sizeof(char *) * (args+1));
					arg[args++] = strdup(RAID_CMD);
					arg = (char **)realloc(arg,sizeof(char *) * (args+1));
					arg[args++] = strdup(&quot;--zero-superblock&quot;);
					arg = (char **)realloc(arg,sizeof(char *) * (args+1));
					arg[args++] = strdup(fname);
					arg = (char **)realloc(arg,sizeof(char *) * (args+1));
					arg[args++] = NULL;
					sprintf(caption,&quot;Zeroing superblock for %s&quot;,fname);
					sprintf(result,&quot;Zeroed superblock for %s&quot;,fname);
					run_program(arg[0],arg,caption,result);
					create_scroller(&quot;Wiping device-header&quot;);
					fd = open(fname,O_WRONLY);
					if ( fd ){
						scroll_logger(&quot;Wiping %s...\n&quot;,fname);
						result_tot = 0;
						for ( i = 0; i &lt; 5000; i++ ){
							int result;
							result = write(fd,zero_block,BSIZE);
							result_tot += result;
							if (( i % 100 ) == 0 ) scroll_logger(&quot;Wiping Block: %d --&gt; (Written %d Bytes)\n&quot;,i,result_tot);
						}
						close(fd);
					}
					sleep(1);
					end_scroller();
				}

			}
			closedir(dir);
		}
		alarm_window(&quot;All Devices zeroed and partition tables destroyed, please reboot now!&quot;,ALARM_INFO,NULL,0);
		attroff(COLOR_PAIR(BASE2_COLOR_NORMAL));
		erase();
		display_options();
		refresh();
		
}



struct _interface *iff = NULL;
int iffs = 0;

char *root_prefix = NULL;

int interface_sort(const void *_a, const void *_b){
	struct _interface *a;
	struct _interface *b;

	a = (struct _interface *)_a;
	b = (struct _interface *)_b;
	return(strcmp(a-&gt;name,b-&gt;name));
}


void setup_interfaces(){
		char sysconfig[1024];
		DIR *dir;
		struct dirent *diry;
		int i;
		char dummy[128];


		sprintf(sysconfig,&quot;%s/etc/sysconfig&quot;,root_prefix ? root_prefix : &quot;&quot; );

		if ( iff ) free(iff);
		iff = NULL;
		iffs = 0;

		dir = opendir(&quot;/sys/class/net&quot;);
		if ( dir ){
			while ( (diry = readdir(dir)) != NULL ){
				struct _interface *tif;
				char buf[1024];
				struct stat st;
				FILE *fp;
				char fname[1024];
				char target[1024];


				if ( strcmp(diry-&gt;d_name,&quot;.&quot;) == 0 ) continue;
				if ( strcmp(diry-&gt;d_name,&quot;..&quot;) == 0 ) continue;
				sprintf(fname,&quot;/sys/class/net/%s&quot;,diry-&gt;d_name);
				if ( stat(fname,&amp;st) != 0 ) continue;
				if ( readlink(fname,target,1024) == -1 ) continue;
				if ( strstr(target,&quot;/virtual/&quot;) ) continue;
				// printf(&quot;Interface: [%s] --&gt; [%s]\n&quot;, fname,target);			
				if ( (tif = getinterface(sysconfig, diry-&gt;d_name)) == NULL ) continue;
				iff = (struct _interface *)realloc(iff,(iffs+1) * sizeof(struct _interface));
				memcpy(&amp;iff[iffs],tif,sizeof(struct _interface));
				iffs++;	

			}
			closedir(dir);
		}
		qsort(iff,iffs,sizeof(struct _interface),interface_sort);
		/*
		for ( i = 0; i &lt; iffs; i++ ){
			printf(&quot;INTERFACE: %d\n&quot;,i);
			printf(&quot;IF-NAME:     [%s]\n&quot;,iff[i].name);
			printf(&quot;IP4-VALUE:   [%s]\n&quot;,display_ipv4(iff[i].ip4,4,dummy));
			printf(&quot;GW4-VALUE:   [%s]\n&quot;,display_ipv4(iff[i].gw_ip4,4,dummy));
			printf(&quot;BR4-VALUE:   [%s]\n&quot;,display_ipv4(iff[i].broadcast_ip4,4,dummy));
			printf(&quot;PREFIX4-LEN: [%d]\n&quot;,iff[i].prefixlen_ip4);
			printf(&quot;IP6-VALUE:   [%s]\n&quot;,display_ipv6(iff[i].ip6,16,dummy));
			printf(&quot;PREFIX6-LEN: [%d]\n&quot;,iff[i].prefixlen_ip6);
			printf(&quot;SERVICE:     [%s]\n&quot;,iff[i].service);
			printf(&quot;ONBOOT:      [%d]\n&quot;,iff[i].active);
		}
		printf(&quot;Found %d interfaces\n&quot;,iffs);
		*/
}


void network_setup(){
		dhcpoffers = 0;
		if ( dhcpoffer ) free(dhcpoffer);
		dhcpoffer = NULL;
		create_sub1();

		do_network();

		attroff(COLOR_PAIR(BASE2_COLOR_NORMAL));
		erase();
		display_options();
		refresh();
}
void efi_setup(){
		create_sub1();
		attroff(COLOR_PAIR(BASE2_COLOR_NORMAL));
		do_efi();
		erase();
		display_options();
		refresh();
}
void linux_setup(){
		in_addr_t xx;
		unsigned char gateway_ipv4[4];
		unsigned char gateway_ipv6[16];
		int i;
		FILE *fp;
		char fname[1024];
		char help[1024];
		char buf[1024];
		char sysconfig[1024];
		struct stat st;
		create_sub1();
		attroff(COLOR_PAIR(BASE2_COLOR_NORMAL));
		if ( stat(&quot;/mnt/etc/rc.d&quot;,&amp;st) == 0 ){
			root_prefix=&quot;/mnt/&quot;;
		} else {
			root_prefix=&quot;/&quot;;
		}
		sprintf(sysconfig,&quot;%s/etc/sysconfig&quot;,root_prefix ? root_prefix : &quot;&quot; );
		sprintf(help,&quot;SETUP System (ROOT-PREFIX: [%s]&quot;,root_prefix);
		create_sub2(sub1-&gt;start_x + 2, sub1-&gt;start_y + 2, sub1-&gt;width - 6, sub1-&gt;height - 4, help);
		sprintf(fname,&quot;%s/etc/hostname&quot;,root_prefix);
		strcpy(buf,&quot;gixlinux2&quot;);
		fp = fopen(fname,&quot;r&quot;);
		if ( fp ){
			fgets(buf,1024,fp);
			fclose(fp);
		} 
		while ( strlen(buf) &amp;&amp; ( buf[strlen(buf)-1] == &#039; &#039; || buf[strlen(buf)-1] == &#039;\n&#039; || buf[strlen(buf)-1] == &#039;\r&#039; )) buf[strlen(buf)-1] = 0x00;
ENTER_HOSTNAME: 
		if ( alarm_window(&quot;Set Hostname: &quot;,ALARM_INPUT,buf,32) &lt; 0 ) goto END_LINUX;
		while ( strlen(buf) &amp;&amp; ( buf[strlen(buf)-1] == &#039; &#039; || buf[strlen(buf)-1] == &#039;\n&#039; || buf[strlen(buf)-1] == &#039;\r&#039; )) buf[strlen(buf)-1] = 0x00;
		if ( strlen(buf) &gt; 3 ){
			unlink(fname);
			fp = fopen(fname,&quot;w&quot;);
			if ( fp ){
				fprintf(fp,&quot;%s\n&quot;,buf);
				fclose(fp);
			} 
		} else {
			alarm_window(&quot;Hostname must be at least 3 characters!&quot;,ALARM_ERROR,NULL,0);
			goto ENTER_HOSTNAME;
		}

		setup_interfaces();
		memset(gateway_ipv4,0,4);
		memset(gateway_ipv6,0,16);
		for ( i = 0; i &lt; iffs; i++ ){
			int ret;
			unsigned char dummyip[64];
			if ( !is_zero(iff[i].gw_ip4,4) ){ 
				memcpy(gateway_ipv4,iff[i].gw_ip4,4);
				debug_logger(&quot;[%s] GW_IP: [%s] IS_ZERO-&gt;FALSE!\n&quot;,iff[i].name,display_ipv4(iff[i].gw_ip4,4,dummyip));
			} else {
				debug_logger(&quot;[%s] GW_IP: [%s] IS_ZERO-&gt;TRUE!\n&quot;,iff[i].name,display_ipv4(iff[i].gw_ip4,4,dummyip));
			}
			if ( !is_zero(iff[i].gw_ip6,16) ) memcpy(gateway_ipv6,iff[i].gw_ip6,16);
			sprintf(help,&quot;Setting up interface [%s]&quot;,iff[i].name);
			create_sub2(sub1-&gt;start_x + 2, sub1-&gt;start_y + 2, sub1-&gt;width - 6, sub1-&gt;height - 4, help);
			sprintf(help,&quot;Use interface [%s]?&quot;,iff[i].name);
			ret = alarm_window(help,ALARM_OKCANCEL,&quot;&lt;YES&gt;|&lt;NO&gt;&quot;,iff[i].active ? ANSWER_OK : ANSWER_CANCEL);
			if ( ret == ANSWER_CANCEL ){
				iff[i].active = 0;
			} else if ( ret  == ANSWER_OK ){
IP_AGAIN:
				iff[i].active = 1;
				sprintf(help,&quot;IPv4 for [%s]: &quot;,iff[i].name);
				display_ipv4(iff[i].ip4,4,buf);
				if ( is_zero(iff[i].ip4,4) )strcpy(buf,&quot;&quot;);
				if ( alarm_window(help,ALARM_INPUT,buf,32) &lt; 0 ) goto END_LINUX;
				while ( strlen(buf) &amp;&amp;  isspace(buf[strlen(buf)-1]) ) buf[strlen(buf)-1] = 0x00;
				if ( strlen(buf) &lt; 1 ){
					bzero(iff[i].ip4,4);
					goto IP_AGAIN3;
				}
				if ( inet_addr(buf)  == INADDR_NONE ){
					alarm_window(&quot;Please enter a valid IPv4 address!&quot;,ALARM_ERROR,NULL,0);
					goto IP_AGAIN;
				}
				xx = inet_addr(buf);
				iff[i].ip4[3] = ((xx) &gt;&gt; 24) &amp; 0xFF;
                                iff[i].ip4[2] = ((xx) &gt;&gt; 16) &amp; 0xFF;
                                iff[i].ip4[1] = ((xx) &gt;&gt; 8) &amp; 0xFF;
                                iff[i].ip4[0] = ((xx) &gt;&gt; 0) &amp; 0xFF;
IP_AGAIN2:
				sprintf(help,&quot;IPv4 Prefixlen for [%s] (0...32): &quot;,iff[i].name);
				sprintf(buf,&quot;%d&quot;,iff[i].prefixlen_ip4);
				if ( alarm_window(help,ALARM_INPUT,buf,2) &lt; 0 ) goto END_LINUX;
				while ( strlen(buf) &amp;&amp;  isspace(buf[strlen(buf)-1]) ) buf[strlen(buf)-1] = 0x00;
				if ( sscanf(buf,&quot;%d&quot;,&amp;ret) != 1 ||  ret &gt; 32 || ret &lt; 0 ){
					alarm_window(&quot;Please enter a valid IPv4 prefix (0...32)!&quot;,ALARM_ERROR,NULL,0);
					goto IP_AGAIN2;
				}
				debug_logger(&quot;INTERFACE [%s] PREFIX-LEN: %d\n&quot;,iff[i].name,ret);
				iff[i].prefixlen_ip4 = ret;

IP_AGAIN3:
				sprintf(help,&quot;IPv6 for [%s](blank for no addr.): &quot;,iff[i].name);
				display_ipv6(iff[i].ip6,16,buf);
				if ( is_zero(iff[i].ip6,16)) strcpy(buf,&quot;&quot;);
				if ( alarm_window(help,ALARM_INPUT,buf,50) &lt; 0 ) goto END_LINUX;
				while ( strlen(buf) &amp;&amp;  isspace(buf[strlen(buf)-1]) ) buf[strlen(buf)-1] = 0x00;
				if ( strlen(buf) == 0 ){
					memset(iff[i].ip6,0,16);
				} else {
					char dummy[129];
					if ( inet_pton(AF_INET6,buf,dummyip) != 1 ){
						alarm_window(&quot;Please enter a valid IPv6 address!&quot;,ALARM_ERROR,NULL,0);
						goto IP_AGAIN3;
					}	
					memcpy(iff[i].ip6,dummyip,16);
					debug_logger(&quot;INTERFACE [%s] IPV6: [%s]\n&quot;,iff[i].name,display_ipv6(iff[i].ip6,16,dummy));
IP_AGAIN4:
					sprintf(help,&quot;IPv6 Prefixlen for [%s] (0...128): &quot;,iff[i].name);
					sprintf(buf,&quot;%d&quot;,iff[i].prefixlen_ip6);
					if ( alarm_window(help,ALARM_INPUT,buf,3) &lt; 0 ) goto END_LINUX;
					while ( strlen(buf) &amp;&amp;  isspace(buf[strlen(buf)-1]) ) buf[strlen(buf)-1] = 0x00;
					if ( sscanf(buf,&quot;%d&quot;,&amp;ret) != 1 ||  ret &gt; 128 || ret &lt; 0 ){
						alarm_window(&quot;Please enter a valid IPv6 prefixlen (0...128)!&quot;,ALARM_ERROR,NULL,0);
						goto IP_AGAIN4;
					}
					debug_logger(&quot;INTERFACE [%s] PREFIX6-LEN: %d\n&quot;,iff[i].name,ret);
					iff[i].prefixlen_ip6 = ret;
				}

			} else {
				goto END_LINUX;
			}
		}
IP_AGAIN5:
		display_ipv4(gateway_ipv4,4,buf);
		if ( is_zero(gateway_ipv4,4)) strcpy(buf,&quot;&quot;);
		if ( alarm_window(&quot;IPv4 Gateway (blank for no gateway): &quot;,ALARM_INPUT,buf,32) &lt; 0 ) goto END_LINUX;
		while ( strlen(buf) &amp;&amp;  isspace(buf[strlen(buf)-1]) ) buf[strlen(buf)-1] = 0x00;
		if ( strlen(buf) == 0 ){
			int j;
			for ( j = 0; j &lt; iffs; j++ ){
				memset(iff[j].gw_ip4,0,4);	
				gix_gen_broadcast_ipv4(iff[j].ip4, iff[j].prefixlen_ip4,iff[j].broadcast_ip4);
			}
			goto IP_AGAIN6;

		}
		if ( inet_addr(buf)  == INADDR_NONE ){
			alarm_window(&quot;Please enter a valid IPv4 address!&quot;,ALARM_ERROR,NULL,0);
			goto IP_AGAIN5;
		}
		xx = inet_addr(buf);
		gateway_ipv4[3] = ((xx) &gt;&gt; 24) &amp; 0xFF;
		gateway_ipv4[2] = ((xx) &gt;&gt; 16) &amp; 0xFF;
		gateway_ipv4[1] = ((xx) &gt;&gt; 8) &amp; 0xFF;
		gateway_ipv4[0] = ((xx) &gt;&gt; 0) &amp; 0xFF;

		// Now check if gateway is valid...
		for ( i = 0; i &lt; iffs; i++ ){
			char dummy1[256];
			char dummy2[256];
			char dummy3[256];
			char dummy4[256];
			char dummy5[256];
			char dummy6[256];
			unsigned char netmask[4];
			unsigned char result1[4];
			unsigned char result2[4];
			unsigned char result3[4];
			if ( iff[i].active == 0 ) continue;
			gix_genmask_ipv4(iff[i].prefixlen_ip4,netmask);
			gix_apply_netmask_ipv4(netmask,iff[i].ip4,result1);
			gix_apply_netmask_ipv4(netmask,gateway_ipv4,result2);
			gix_gen_broadcast_ipv4(iff[i].ip4, iff[i].prefixlen_ip4, result3);
			debug_logger(&quot;[%s] NETMASK: [%s] IPV4: [%s] --&gt; [%s] GW: [%s] --&gt; [%s] (BCAST: [%s])\n&quot;,
					iff[i].name,
					display_ipv4(netmask,4,dummy1), 
					display_ipv4(iff[i].ip4,4,dummy2),
					display_ipv4(result1,4,dummy3),
					display_ipv4(gateway_ipv4,4,dummy4), 
					display_ipv4(result2,4,dummy5),
					display_ipv4(result3,4,dummy6));
			if ( memcmp(result1,result2,4) == 0 ){ 
				int j;
				for ( j = 0; j &lt; iffs; j++ ){
					memset(iff[j].gw_ip4,0,4);	
					gix_gen_broadcast_ipv4(iff[j].ip4, iff[j].prefixlen_ip4,iff[j].broadcast_ip4);
				}
				memcpy(iff[i].gw_ip4,gateway_ipv4,4);
				break;
			}
		}
		if ( i == iffs ){
			alarm_window(&quot;Please enter a valid IPv4 gate-way address!\nThe given address is not matching any interface!&quot;,ALARM_ERROR,NULL,0);
			goto IP_AGAIN5;
		}
IP_AGAIN6:
		display_ipv6(gateway_ipv6,16,buf);
		if ( is_zero(gateway_ipv6,16)) strcpy(buf,&quot;&quot;);
		if ( alarm_window(&quot;IPv6 Gateway (blank for no gateway): &quot;,ALARM_INPUT,buf,50) &lt; 0 ) goto END_LINUX;
		while ( strlen(buf) &amp;&amp;  isspace(buf[strlen(buf)-1]) ) buf[strlen(buf)-1] = 0x00;
		if ( strlen(buf) == 0 ){
			int j;
			for ( j = 0; j &lt; iffs; j++ ){
				memset(iff[j].gw_ip6,0,16);	
			}
			goto DO_DNS;

		}
		if ( inet_pton(AF_INET6,buf,gateway_ipv6)  != 1 ){
			alarm_window(&quot;Please enter a valid IPv6 address!&quot;,ALARM_ERROR,NULL,0);
			goto IP_AGAIN6;
		}

		// Now check if gateway is valid...
		for ( i = 0; i &lt; iffs; i++ ){
			char dummy1[256];
			char dummy2[256];
			char dummy3[256];
			char dummy4[256];
			char dummy5[256];
			unsigned char netmask[16];
			unsigned char result1[16];
			unsigned char result2[16];
			if ( iff[i].active == 0 ) continue;
			gix_genmask_ipv6(iff[i].prefixlen_ip4,netmask);
			gix_apply_netmask_ipv6(netmask,iff[i].ip4,result1);
			gix_apply_netmask_ipv6(netmask,gateway_ipv4,result2);
			debug_logger(&quot;[%s] NETMASK: [%s] IPV6: [%s] --&gt; [%s] GW: [%s] --&gt; [%s]\n&quot;,
					iff[i].name,
					display_ipv6(netmask,16,dummy1), 
					display_ipv6(iff[i].ip6,16,dummy2),
					display_ipv6(result1,16,dummy3),
					display_ipv6(gateway_ipv6,16,dummy4), 
					display_ipv6(result2,16,dummy5));
			if ( memcmp(result1,result2,16) == 0 ){ 
				int j;
				for ( j = 0; j &lt; iffs; j++ ){
					memset(iff[j].gw_ip6,0,16);	
				}
				memcpy(iff[i].gw_ip6,gateway_ipv6,16);
				break;
			}
		}
		if ( i == iffs ){
			alarm_window(&quot;Please enter a valid IPv6 gate-way address!\nThe given address is not matching any interface!&quot;,ALARM_ERROR,NULL,0);
			goto IP_AGAIN6;
		}
DO_DNS:
		{
			char resolver_file[1024];
			char dns_server[1024];
			unsigned char ip[16];
			char the_ip[256];
			FILE *fp;

			sprintf(resolver_file,&quot;%s/etc/resolv.conf&quot;,root_prefix);
DNS_AGAIN: 
			bzero(dns_server,64);
			if ( alarm_window(&quot;DNS-Server-IP(IPv4 or IPv6): &quot;,ALARM_INPUT,dns_server,32) &lt; 0 ){
				goto END_LINUX;
			}
			while ( strlen(dns_server) &amp;&amp;  isspace(dns_server[strlen(dns_server)-1]) ) dns_server[strlen(dns_server)-1] = 0x00;
			if ( inet_pton(AF_INET,dns_server,ip) != 1 &amp;&amp; inet_pton(AF_INET6,dns_server,ip) != 1 ){
				alarm_window(&quot;Please enter a valid IPv4 or IPv6 address!&quot;,ALARM_ERROR,NULL,0);
				goto DNS_AGAIN;
			}
			unlink(resolver_file);
			if ( inet_pton(AF_INET,dns_server,ip) == 1 ){
				inet_ntop(AF_INET,ip,the_ip,255);
			} else {
				inet_pton(AF_INET6,dns_server,ip);
				inet_ntop(AF_INET6,ip,the_ip,255);
			}
			fp = fopen(resolver_file,&quot;w&quot;);
			if ( fp ){
				fprintf(fp,&quot;nameserver %s\n&quot;,the_ip);
				fclose(fp);
			}


		}
WRITE_IP_CONFIG:	
		// Everything done...write the config(s) now
		for ( i = 0; i &lt; iffs; i++ ){
			write_interface(sysconfig,&amp;iff[i]);
		}
		sync();
		umount(&quot;/mnt&quot;);	
		

END_LINUX:
		erase();
		display_options();
		refresh();
}

#define sock_readline(a,b,c) _sock_readline(__FILE__,__LINE__,(a),(b),(c))
#define sock_writeline(a,b,c) _sock_writeline(__FILE__,__LINE__,(a),(b),(c))
#define FTP_LINE_BUFFER 4096


int _sock_readline(char *file, int line, int sock,char *buf, char verbose){
	char c;
	int received = 0;
	*buf = 0x00;
	while ( recv(sock,&amp;c,1,0) == 1 ){
		if ( c == &#039;\r&#039; ) continue;
		if ( c == &#039;\n&#039; ) break;
		buf[received++] = c;
		buf[received] = 0x00;
		if ( received == (FTP_LINE_BUFFER-1) ) break;
		
	}
	if ( verbose ) scroll_logger(&quot;SOCK_IO(%s:%d) (%d)&lt;&lt; %s\n&quot;,file,line,received,buf);
	return(received);
}

int _sock_writeline(char *file, int line, int sock, char *buf,char verbose){
	int retval;
	retval = send(sock,buf,strlen(buf),0);
	if ( verbose ) scroll_logger(&quot;SOCK_IO(%s:%d) (%d/%d)&gt;&gt; %s&quot;,file,line,retval,strlen(buf),buf);
	return(retval);
}


int ftp_login(struct _ipconfig *ipc, char verbose){
	struct addrinfo hints;
	struct addrinfo *result;
	struct addrinfo *rp;
	char buf[FTP_LINE_BUFFER];
	int s;
	int sock;
	int code;

	bzero(&amp;hints,sizeof(struct addrinfo));
	hints.ai_family   = AF_INET;
	hints.ai_socktype = SOCK_STREAM;

	if ( (s = getaddrinfo(ipc-&gt;ftp_server,&quot;21&quot;,&amp;hints,&amp;result)) != 0 ){
		if ( verbose ) debug_logger(&quot;Invalid [%s] --&gt; [%s]\n&quot;,ipc-&gt;ftp_server,gai_strerror(s));
		return(-1);
	}
	sock = -1;
	for ( rp = result; rp != NULL; rp = rp-&gt;ai_next ){
		int save_fd;
		int old_fd;
		struct pollfd fd;
		sock = socket(rp-&gt;ai_family,rp-&gt;ai_socktype,rp-&gt;ai_protocol);
		if ( sock &lt; 0 ){
			if ( verbose ) debug_logger(&quot;Invalid [%s] --&gt; Cannot create socket [%s]\n&quot;,ipc-&gt;ftp_server,strerror(errno));
			return(-1);
		}
		old_fd = fcntl(sock,F_GETFL);
		save_fd = O_NONBLOCK | old_fd;
		fcntl(sock,F_SETFL,save_fd);

		scroll_logger(&quot;Trying [%s]...\n&quot;,inet_ntoa( ((struct sockaddr_in *)rp-&gt;ai_addr)-&gt;sin_addr));
		strcpy(ipc-&gt;ftp_ip,inet_ntoa( ((struct sockaddr_in *)rp-&gt;ai_addr)-&gt;sin_addr));
		if ( connect(sock,rp-&gt;ai_addr,rp-&gt;ai_addrlen) &lt; 0 &amp;&amp; errno != EINPROGRESS){
			if ( verbose ) c_logger(&quot;\n&quot;);
			if ( verbose ) debug_logger(&quot;Invalid [%s] --&gt; Cannot connect socket [%s]\n&quot;,ipc-&gt;ftp_server,strerror(errno));
			close(sock);
			sock = -1;
			continue;	
		}
		fd.events  = POLLIN | POLLHUP | POLLERR | POLLOUT;
		fd.revents = 0;
		fd.fd = sock;
		if ( poll(&amp;fd,1,FTP_CONNECT_TIMEOUT) &lt;= 0 ){
			if ( verbose ) c_logger(&quot;\n&quot;);
			if ( verbose ) debug_logger(&quot;Invalid [%s] --&gt; Cannot connect socket(poll) [timed out]\n&quot;,ipc-&gt;ftp_server);
			close(sock);
			sock = -1;
			continue;	
		}
		if ( (fd.revents &amp; POLLIN) || (fd.revents &amp; POLLOUT) ){
			fcntl(sock,F_SETFL,old_fd);
			if ( verbose ) debug_logger(&quot;OK\n&quot;);
			while ( sock_readline(sock,buf,verbose) &gt; 0 &amp;&amp; buf[3] == &#039;-&#039; ); 
			code = atoi(buf);
			if ( code != 220 ){
				if ( verbose ) scroll_logger(&quot;Invalid [%s] --&gt; Bad prompt! Code: %d\n&quot;,ipc-&gt;ftp_server,code);
				close(sock);
				sock = -1;
				continue;	
			}
			sprintf(buf,&quot;USER %s\r\n&quot;,ipc-&gt;ftp_user);
			if ( sock_writeline(sock,buf,verbose) != strlen(buf) ){
				if ( verbose ) debug_logger(&quot;Invalid [%s] --&gt; Write failed!\n&quot;,ipc-&gt;ftp_server);
				close(sock);
				sock = -1;
				continue;	
			}
			while ( sock_readline(sock,buf,verbose) &gt; 0 &amp;&amp; buf[3] == &#039;-&#039; ); 
			code = atoi(buf);
			if ( code &lt; 300 || code &gt; 399 ){
				if ( verbose ) debug_logger(&quot;Invalid [%s] --&gt; Bad prompt! Code: %d\n&quot;,ipc-&gt;ftp_server,code);
				close(sock);
				sock = -1;
				continue;	
			}
			sprintf(buf,&quot;PASS %s\r\n&quot;,ipc-&gt;ftp_pwd);
			if ( sock_writeline(sock,buf,verbose) != strlen(buf) ){
				if ( verbose ) debug_logger(&quot;Invalid [%s] --&gt; Write failed!\n&quot;,ipc-&gt;ftp_server);
				close(sock);
				sock = -1;
				continue;	
			}
			while ( sock_readline(sock,buf,verbose) &gt; 0 &amp;&amp; buf[3] == &#039;-&#039; ); 
			code = atoi(buf);
			if ( code &lt; 200 || code &gt; 299 ){
				if ( verbose ) debug_logger(&quot;Invalid [%s] --&gt; Bad prompt! Code: %d\n&quot;,ipc-&gt;ftp_server,code);
				close(sock);
				sock = -1;
				continue;	
			}
			sprintf(buf,&quot;TYPE I\r\n&quot;);
			if ( sock_writeline(sock,buf,verbose) != strlen(buf) ){
				if ( verbose ) debug_logger(&quot;Invalid [%s] --&gt; Write failed!\n&quot;,ipc-&gt;ftp_server);
				close(sock);
				sock = -1;
				continue;	
			}
			while ( sock_readline(sock,buf,verbose) &gt; 0 &amp;&amp; buf[3] == &#039;-&#039; ); 
			code = atoi(buf);
			if ( code &lt; 200 || code &gt; 299 ){
				if ( verbose ) debug_logger(&quot;Invalid [%s] --&gt; Bad prompt! Code: %d\n&quot;,ipc-&gt;ftp_server,code);
				close(sock);
				sock = -1;
				continue;	
			}
			if ( verbose ) debug_logger(&quot;Login success!\n&quot;);
			return(sock);
		}
	}
	debug_logger(&quot;Tried all possibilities...giving up\n&quot;);
	return(-1);
}


void ftp_logout(int sock, char verbose){
	char buf[FTP_LINE_BUFFER];
	sprintf(buf,&quot;QUIT\n&quot;);
	if ( sock_writeline(sock,buf,verbose) != strlen(buf) ){
		if ( verbose ) debug_logger(&quot;Write failed!\n&quot;);
		close(sock);
		return;
	}
	while ( sock_readline(sock,buf,verbose) &gt; 0 &amp;&amp; buf[3] == &#039;-&#039; ); 
	close(sock);
	return;
}


struct _ftp_file {
	char *name;
	char *localname;
	int is_tar;
	int is_compressed; // Only allowed, if &#039;is_tar&#039; == 1 !!!
	u_int64_t size;	
};




struct _ftp_file efi_file[] = { 
		{ &quot;/gixl2/efi/bzImage&quot;, &quot;/mnt/bzImage&quot;,0,0, 0 },
		{ &quot;/gixl2/efi/initrd.img&quot;,&quot;/mnt/initrd.img&quot;,0,0,0 },
		{ NULL,NULL,0,0,0 } };

struct _ftp_file gixl_file[] = { 
		{ &quot;/gixl2/gixl2_install.tar.xz&quot;,&quot;/mnt/&quot;,1,1,0 },
		{ NULL,NULL,0,0,0 } };

unsigned char fat_magic[] = { 0xEB, 0x3C, 0x90 };



void create_path(char *_path){
	char path[4096];
	char current_dir[4096];
	char current_dir2[4096];
	char *here;
	char *hlp;
	char *dir;
	strcpy(path,_path);
	getcwd(current_dir,4095);	
	// debug_logger(&quot;We are here: [%s] --&gt; Creating: [%s]\n&quot;,current_dir,path);
	here = path;
	hlp  = here;
	chdir(&quot;/&quot;);
	while ( (dir = strtok_r(here,&quot;/&quot;,&amp;hlp)) != NULL ){
		here = NULL;
		if ( strlen(dir) ){
			mkdir(dir,0755);
			chdir(dir);
			getcwd(current_dir2,4095);	
			// debug_logger(&quot;Created: [%s], Current_PATH: [%s]\n&quot;,dir,current_dir2);
		}

	}
	chdir(current_dir);


}

#define data (*_data)
#define read_tar_bytes(a,b,c) _read_tar_bytes(__FILE__,__LINE__,(a),(b),(c))

int64_t _read_tar_bytes(char *__file__,int __line__,int fd,u_int64_t file_size,char **_data){
	u_int64_t blocks;
	u_int64_t to_read;

	blocks = file_size / ((u_int64_t)512);
	if ( file_size % ((u_int64_t)512) ) blocks++;
	data = malloc(blocks * ((u_int64_t)512));
	to_read = blocks * ((u_int64_t)512);
	// debug_logger(&quot;[%s:%d] Reading %ju Bytes to memory\n&quot;,__file__,__line__,to_read);
	while (  to_read &gt; 0 ){
		int64_t recvd;
		recvd = read(fd,&amp;data[blocks * ((u_int64_t)512) - to_read],to_read);
		to_read -= recvd;
	}
	return(blocks * ((int64_t)512));
}

#undef data

#define read_tar_file(a,b,c) _read_tar_file(__FILE__,__LINE__,(a),(b),(c))
int64_t _read_tar_file(char *__file__,int __line__,int fd,u_int64_t file_size,char *fname){
	unsigned char buf[TBUFSIZE];
	u_int64_t blocks;
	u_int64_t to_read;
	u_int64_t tot_read;
	u_int64_t tot_written;
	int fp;
	if ( fname ){
		unlink(fname);
		fp = open(fname,O_WRONLY | O_CREAT,0644);
		if ( fp &lt; 0 ){
			debug_logger(&quot;[%s:%d] Cannot open &#039;%s&#039; for writing! (%s)\n&quot;,__file__,__line__,fname,strerror(errno));
			return(-1);
		}
	}
	debug_logger(&quot;[%s:%d] Opened [%s] for %ju Bytes\n&quot;,__file__,__line__,fname,file_size);
	blocks = file_size / ((u_int64_t)512);
	if ( file_size % ((u_int64_t)512) ) blocks++;
	to_read = blocks * ((u_int64_t)512);

	// debug_logger(&quot;Reading %ju Bytes to file [%s], TOTAL: %ju\n&quot;,file_size,fname,to_read);
	tot_read = 0;
	tot_written = 0;
	while (  to_read &gt; 0 ){
		int block_write;
		int block_read;
		int64_t recvd;
		int64_t recvd2;
		if ( to_read &gt; TBUFSIZE )
			block_read = TBUFSIZE;
		else
			block_read = to_read;
		recvd = read(fd,buf,block_read);
		to_read -= recvd;
		tot_read += recvd;
		recvd2 = recvd;
		if ( tot_read &gt; file_size ) recvd2 = (file_size - tot_written);
		block_write = 0;
		if ( recvd2 ) { 
			if ( fname ){
				block_write = write(fp,buf,recvd2); 
				if ( block_write != recvd2 ) 
					scroll_logger(&quot;Short write!!!\n&quot;); 
			} else {
				block_write = recvd2;
			}
		}
		tot_written += block_write;
		// debug_logger(&quot;WRITTEN %d Bytes to file (%ju/%ju)\n&quot;,recvd,tot_written,file_size);
	}
	if ( fname ) close(fp);
	// debug_logger(&quot;Read %ju Bytes to file [%s], TOTAL: %ju (%ju Blocks)\n&quot;,file_size,fname,tot_read,blocks);
	return(blocks * ((int64_t)512));
}


int ftp_fetch(int sock,struct _ftp_file *fil, int verbose){
	char cmd[512];
	unsigned char tbuf[TBUFSIZE];
	char reply[1024];
	int code;
	int sockd;
	char *ptr;
	char *ptr2;
	char *hlp;
	char path_copy[1024];
	unsigned int port_low;
	unsigned int port_high;
	unsigned int ip_a;
	unsigned int ip_b;
	unsigned int ip_c;
	unsigned int ip_d;
	struct sockaddr_in data;
	unsigned short port;
	char ip_address[64];
	int file_out;

	sprintf(cmd,&quot;PASV\r\n&quot;);
	if ( sock_writeline(sock,cmd,0) != strlen(cmd) ) return(-1);
	while ( sock_readline(sock,reply,0) &gt; 0 &amp;&amp; reply[3] == &#039;-&#039; ); 
	code = atoi(reply);
	if ( code &lt; 200 || code &gt; 299 ){
		return(-2);
	}
	ptr = reply;
	while ( *ptr &amp;&amp; *ptr != &#039;(&#039; ) ptr++;
	if ( *ptr == 0x00 ){
		return(-3);
	}
	ptr++;
	hlp = ptr;
	ptr2 = strtok_r(ptr,&quot;(),&quot;,&amp;hlp);
	if ( ptr2 == NULL ){
		return(-4);
	}
	ip_a = atoi(ptr2);
	ptr2 = strtok_r(NULL,&quot;(),&quot;,&amp;hlp);
	if ( ptr2 == NULL ){
		return(-5);
	}
	ip_b = atoi(ptr2);
	ptr2 = strtok_r(NULL,&quot;(),&quot;,&amp;hlp);
	if ( ptr2 == NULL ){
		return(-6);
	}
	ip_c = atoi(ptr2);
	ptr2 = strtok_r(NULL,&quot;(),&quot;,&amp;hlp);
	if ( ptr2 == NULL ){
		return(-7);
	}
	ip_d = atoi(ptr2);
	ptr2 = strtok_r(NULL,&quot;(),&quot;,&amp;hlp);
	if ( ptr2 == NULL ){
		return(-8);
	}
	port_high = atoi(ptr2);
	ptr2 = strtok_r(NULL,&quot;(),&quot;,&amp;hlp);
	if ( ptr2 == NULL ){
		return(-9);
	}
	port_low = atoi(ptr2);
	if ( fil-&gt;is_tar ){
		create_path(fil-&gt;localname);		
	} else {
		char path_to_create[2048];
		char *ptr;

		strcpy(path_to_create,fil-&gt;localname);
		ptr = &amp;path_to_create[strlen(path_to_create)-1];
		while ( ptr &gt; path_to_create &amp;&amp; *ptr != &#039;/&#039; ) ptr--;
		*ptr = 0x00;
		create_path(path_to_create);		
		unlink(fil-&gt;localname);
		file_out = open(fil-&gt;localname,O_WRONLY );
		if ( file_out &lt; 0 )file_out = open(fil-&gt;localname,O_CREAT | O_WRONLY, 0755);
		if ( file_out &lt; 0 ){
			debug_logger(&quot;Failed to open &#039;%s&#039; for writing (%s)\n&quot;,fil-&gt;localname,strerror(errno));
			return(-10);
		}
	}


	port = ((unsigned short) port_low)  + 256 * ((unsigned short)port_high);
	sprintf(ip_address,&quot;%d.%d.%d.%d&quot;,ip_a, ip_b, ip_c, ip_d);
	data.sin_family = AF_INET;
	data.sin_port = htons(port);
	data.sin_addr.s_addr = inet_addr(ip_address);
	sockd = socket(AF_INET,SOCK_STREAM,0);
	if ( sockd &lt; 0 ){
		close(file_out);
		return(-20);		
	}
	if ( connect(sockd,(struct sockaddr *)&amp;data,sizeof(struct sockaddr_in)) &lt; 0 ){
		close(sockd);
		close(file_out);
		return(-21);		
	}
	sprintf(cmd,&quot;RETR %s\r\n&quot;,fil-&gt;name);
	if ( sock_writeline(sock,cmd,0) != strlen(cmd) ) return(-1);
	while ( sock_readline(sock,reply,0) &gt; 0 &amp;&amp; reply[3] == &#039;-&#039; ); 
	code = atoi(reply);
	if ( code &lt; 100 || code &gt; 199 ){
		close(sockd);
		close(file_out);
		return(-22);
	}
	scroll_logger(&quot;Installing [%s] to [%s] (%ju Bytes) %s:%u\n&quot;,fil-&gt;name,fil-&gt;localname,fil-&gt;size,ip_address,(unsigned int)port);
	if ( fil-&gt;is_tar == 0 ){
		u_int64_t received;
		u_int64_t total;
		total = 0;
		while ( (received = recv(sockd,tbuf,TBUFSIZE,0)) &gt; 0 ){
			total += received;
			if ( write(file_out,tbuf,received) != received ){
				close(sockd);
				close(file_out);
				return(-23);
			}
			c_logger(&quot;Received %.02f%%       \r&quot;, (((double)total) / ((double)fil-&gt;size)) * 100.0);
		}
		close(file_out);
		scroll_logger(&quot;Installation completed\n&quot;);
	} else {
		int pipefd[2];
		signal(SIGCHLD,SIG_DFL);
		if ( pipe(pipefd) &lt; 0 ){
			close(sockd);
			return(-30);
		}
		if ( fork() == 0 ){
			char k_filename[8192];	
			struct tar_header *hd;
			unsigned char buf[512];
			unsigned char zero[512];
			int real_red;
			int still_alive;
			close(pipefd[1]); // Close write end, this process just de-tars...
			strcpy(k_filename,&quot;&quot;);
			while ( 1 ){
				struct utimbuf utim;
				int ownerid;
				int groupid;
				int devmajor;
				int devminor;
				time_t modtime;
				int filemode;
				u_int64_t file_size;
				unsigned char file_name[8192];
				unsigned char local_file_name[8192];
				char info[8192];
				real_red = 0;
				// debug_logger(&quot;Requesting another 512 Bytes from socket\n&quot;);
      	 			while ( real_red != 512 ){
					int red;
					red = read(pipefd[0],&amp;buf[real_red],512 - real_red);
					if ( red &lt; 0 ){
						scroll_logger(&quot;PIPE-Broken! (%s)\n&quot;,strerror(errno));
						exit(0);
					}
					if ( red == 0 ){
						debug_logger(&quot;File finished\n&quot;);
						exit(0);
					}
					real_red += red;
				}			
				// debug_logger(&quot;Received another 512 Bytes from socket\n&quot;);
				bzero(zero,512);
				if ( memcmp(buf,zero,sizeof(struct tar_header)) == 0 ){
						continue;
				}
				memset(zero,&#039;0&#039;,512);
				if ( memcmp(buf,zero,sizeof(struct tar_header)) == 0 ){
						continue;
				}
				hd = (struct tar_header *)buf;
				if ( strncasecmp(hd-&gt;magic,&quot;ustar&quot;,5) != 0 ) continue; // Skip NON USTAR-HEADER
				if ( hd-&gt;filesize[0] &amp; 0x80 ){
					char hex_field[32];
					int x;
					bzero(hex_field,32);
					for ( x = 0; x &lt; 11; x++ ){
						sprintf(&amp;hex_field[strlen(hex_field)],&quot;%02X&quot;,hd-&gt;filesize[1+x]);
					}
					file_size = 0;
					x = sscanf(hex_field,&quot;%llx&quot;,&amp;file_size);
					/*
					sprintf(info,&quot;GNU-BASE256: HEX-Field: [%s] --&gt; HEX_FIELD: %ju (%d)\n&quot;,hex_field,file_size,x);
					alarm_window(info,ALARM_INFO,NULL,0);
					*/
					if ( x != 1 ) continue;
				} else {
					if ( sscanf(hd-&gt;filesize,&quot;%o&quot;,&amp;file_size) != 1 ) continue;
				}
				/*
				sprintf(info,&quot;GNU-BASE256: File-Name: [%s] --&gt; SIZE: %ju Bytes\n&quot;,hd-&gt;filename,file_size);
				alarm_window(info,ALARM_INFO,NULL,0);
				*/
				if ( hd-&gt;typeflag[0] == &#039;L&#039; ){
					char *data;
					read_tar_bytes(pipefd[0],file_size,&amp;data);
					data[file_size]  = 0x00;
					strcpy(file_name,data);
					real_red = 0;
					free(data);
					while ( real_red != 512 ){
						int red;
						red = read(pipefd[0],&amp;buf[real_red],512 - real_red);
						if ( red &lt; 0 ){
							scroll_logger(&quot;PIPE-Broken! (%s)\n&quot;,strerror(errno));
							exit(0);
						}
						real_red += red;
					}			
					hd = (struct tar_header *)buf; // Get the real-file info after Logic-Link part
					if ( hd-&gt;filesize[0] &amp; 0x80 ){
						char hex_field[32];
						int x;
						bzero(hex_field,32);
						for ( x = 0; x &lt; 11; x++ ){
							sprintf(&amp;hex_field[strlen(hex_field)],&quot;%02X&quot;,hd-&gt;filesize[1+x]);
						}
						file_size = 0;
						x = sscanf(hex_field,&quot;%llx&quot;,&amp;file_size);
						/*
						sprintf(info,&quot;GNU-BASE256: HEX-Field: [%s] --&gt; HEX_FIELD: %ju (%d)\n&quot;,hex_field,file_size,x);
						alarm_window(info,ALARM_INFO,NULL,0);
						*/
						if ( x != 1 ) continue;
					} else {
						if ( sscanf(hd-&gt;filesize,&quot;%o&quot;,&amp;file_size) != 1 ) continue;
					}
				} else {
					strcpy(file_name,hd-&gt;filename);
				}
				sscanf(hd-&gt;ownerid,&quot;%o&quot;,&amp;ownerid);
				sscanf(hd-&gt;groupid,&quot;%o&quot;,&amp;groupid);
				sscanf(hd-&gt;modtime,&quot;%o&quot;,&amp;modtime);
				sscanf(hd-&gt;filemode,&quot;%o&quot;,&amp;filemode);
				sscanf(hd-&gt;devmajor,&quot;%o&quot;,&amp;devmajor);
				sscanf(hd-&gt;devminor,&quot;%o&quot;,&amp;devminor);
				sprintf(local_file_name,&quot;%s/%s&quot;,fil-&gt;localname,file_name);
				bzero(&amp;utim,sizeof(struct utimbuf));
				utim.actime  = modtime;
				utim.modtime = modtime;
				/*
				debug_logger(info,&quot; NEW PART IN TAR\n&quot;);
				debug_logger(&quot;File-Name:         [%s]\n&quot;,file_name);
				debug_logger(&quot;Local-File-Name:   [%s]\n&quot;,local_file_name);
				debug_logger(&quot;File-Size:         [%ju]\n&quot;,file_size);
				debug_logger(&quot;Owner-ID:          [%d]\n&quot;,ownerid);
				debug_logger(&quot;Group-ID:          [%d]\n&quot;,groupid);
				debug_logger(&quot;MOD-Time:          [%d]\n&quot;,modtime);
				debug_logger(&quot;File-Mode:         [%.8s] (%d)\n&quot;,hd-&gt;filemode,filemode);
				debug_logger(&quot;MAGIC:             [%.6s]\n&quot;,hd-&gt;magic);
				debug_logger(&quot;TYPEFLAG:          [%.1s]\n&quot;,hd-&gt;typeflag);
				debug_logger(&quot;LINKFILE:          [%.100s]\n&quot;,hd-&gt;linkname);
				*/
				if ( hd-&gt;typeflag[0] == &#039;5&#039; ){
					mkdir(local_file_name,filemode);
					chown(local_file_name,ownerid,groupid);
					utime(local_file_name,&amp;utim);
				} else if ( hd-&gt;typeflag[0] == &#039;0&#039; || hd-&gt;typeflag[0] == 0x00 ){
					read_tar_file(pipefd[0],file_size,local_file_name);
					chown(local_file_name,ownerid,groupid);
					chmod(local_file_name,filemode);
					utime(local_file_name,&amp;utim);
				} else if ( hd-&gt;typeflag[0] == &#039;6&#039; || hd-&gt;typeflag[0] == 6) { // A FIFO
					mkfifo(local_file_name,filemode);	
					chown(local_file_name,ownerid,groupid);
					utime(local_file_name,&amp;utim);
				} else if ( hd-&gt;typeflag[0] == &#039;3&#039; || hd-&gt;typeflag[0] == 3) {
					mknod(local_file_name,filemode | S_IFCHR,makedev(devmajor,devminor));
					chown(local_file_name,ownerid,groupid);
					utime(local_file_name,&amp;utim);
				} else if ( hd-&gt;typeflag[0] == &#039;4&#039; || hd-&gt;typeflag[0] == 4) {
					mknod(local_file_name,filemode | S_IFBLK,makedev(devmajor,devminor));
					chown(local_file_name,ownerid,groupid);
					utime(local_file_name,&amp;utim);
				} else if ( hd-&gt;typeflag[0] == &#039;2&#039; || hd-&gt;typeflag[0] == 2 ) {
					char link_target[8192];
					if ( strlen(k_filename) )
						strcpy(link_target,k_filename);
					else
						strcpy(link_target,hd-&gt;linkname);
					symlink(link_target,local_file_name);
					debug_logger(&quot;SYM-LINKING: [%s] --&gt; [%s]\n&quot;,local_file_name,link_target);
					strcpy(k_filename,&quot;&quot;);
					// chown(local_file_name,ownerid,groupid);
					// utime(local_file_name,&amp;utim);
				} else if ( hd-&gt;typeflag[0] == &#039;1&#039; || hd-&gt;typeflag[0] == 1 ) {
					char link_target[8192];
					if ( strlen(k_filename) )
						sprintf(link_target,&quot;%s/%s&quot;,fil-&gt;localname,k_filename);
					else
						sprintf(link_target,&quot;%s/%s&quot;,fil-&gt;localname,hd-&gt;linkname);
					link(link_target,local_file_name);
					debug_logger(&quot;LINKING: [%s] --&gt; [%s]\n&quot;,local_file_name,link_target);
					strcpy(k_filename,&quot;&quot;);
					// chown(local_file_name,ownerid,groupid);
					// utime(local_file_name,&amp;utim);
				} else if ( hd-&gt;typeflag[0] == &#039;K&#039; ) {
					char *data;
					read_tar_bytes(pipefd[0],file_size,&amp;data);
					data[file_size] = 0x00;
					strcpy(k_filename,data);
					free(data);
					debug_logger(&quot;************ K-Link received [%s]\n&quot;,k_filename);
				} else {
					debug_logger(&quot;###### UNKNOWN PART IN TAR\n&quot;);
					debug_logger(&quot;######File-Name:         [%s]\n&quot;,file_name);
					debug_logger(&quot;######Local-File-Name:   [%s]\n&quot;,local_file_name);
					debug_logger(&quot;######File-Size:         [%ju]\n&quot;,file_size);
					debug_logger(&quot;######Owner-ID:          [%d]\n&quot;,ownerid);
					debug_logger(&quot;######Group-ID:          [%d]\n&quot;,groupid);
					debug_logger(&quot;######MOD-Time:          [%d]\n&quot;,modtime);
					debug_logger(&quot;######File-Mode:         [%.8s] (%d)\n&quot;,hd-&gt;filemode,filemode);
					debug_logger(&quot;######MAGIC:             [%.6s]\n&quot;,hd-&gt;magic);
					debug_logger(&quot;######TYPEFLAG:          [%.1s]\n&quot;,hd-&gt;typeflag);
					debug_logger(&quot;######LINKFILE:          [%.100s]\n&quot;,hd-&gt;linkname);
					debug_logger(&quot;######Current K-Link:    [%s]\n&quot;,k_filename);
					if ( file_size ) read_tar_file(pipefd[0],file_size,NULL);
					if ( hd-&gt;typeflag[0] == &#039;2&#039; ) strcpy(k_filename,&quot;&quot;);
				}
			}	
			debug_logger(&quot;File totally received\n&quot;);
			close(pipefd[0]);
			exit(0);	
		} else {
			close(pipefd[0]);
			if ( fil-&gt;is_compressed ){ // Process LZMA here, before piping to TAR
				u_int64_t received;
				u_int64_t total_in;
				u_int64_t total_out;
				u_int64_t real_sent;
				u_int64_t cur_sent;
				char ratio[128];
				unsigned char tbuf_in[XZ_CHUNK_SIZE];
				unsigned char tbuf_out[XZ_CHUNK_SIZE];
				char buf[128];
				int lzma_ret;
				lzma_stream strm = LZMA_STREAM_INIT;

				total_in = 0;
				total_out = 0;





				if ( lzma_auto_decoder(&amp;strm,UINT64_MAX,0) != LZMA_OK ){
					sprintf(buf,&quot;Starting LZMA failed (internal error - maybe too less memory)?&quot;);
					alarm_window(buf,ALARM_ERROR,NULL,0);
					close(pipefd[1]);
					close(sockd);
					wait(NULL); 
					return(-100);
				}
				while ( (received = recv(sockd,tbuf_in,XZ_CHUNK_SIZE,0)) &gt; 0 ){
					strm.next_in = tbuf_in;
					strm.avail_in = received;
					strm.avail_out = XZ_CHUNK_SIZE;
					strm.next_out = tbuf_out;
					total_in += received;
					do {
						if ( (lzma_ret = lzma_code(&amp;strm, LZMA_RUN)) != LZMA_OK &amp;&amp; lzma_ret != LZMA_STREAM_END ){
							sprintf(buf,&quot;Decoding LZMA failed (internal error - maybe too less memory)?&quot;);
							alarm_window(buf,ALARM_ERROR,NULL,0);
							close(pipefd[1]);
							close(sockd);
							wait(NULL); 
							return(-101);
						}
						received = XZ_CHUNK_SIZE - strm.avail_out;
						real_sent = 0;
						while ( real_sent &lt; received ){
							cur_sent = write(pipefd[1],&amp;tbuf_out[real_sent],received - real_sent);
							real_sent += cur_sent;
						}
						total_out += received;
						strm.avail_out = XZ_CHUNK_SIZE;
						strm.next_out = tbuf_out;
					} while ( strm.avail_in &gt; 0 );
					if ( total_out ){
						double tot_in;
						double tot_out;
						tot_in = (double) total_in;
						tot_out = (double) total_out;
						sprintf(ratio,&quot;Compression: %.02f%%&quot;, 100 * ((tot_out - tot_in)/tot_out));
					} else {
						sprintf(ratio,&quot;&quot;);
					}
					c_logger(&quot;Received %.02f%%       %s                       \r&quot;, (((double)total_in) / ((double)fil-&gt;size)) * 100.0,ratio);
					if ( lzma_ret == LZMA_STREAM_END ) break;
				}
				lzma_end(&amp;strm);
				if ( total_out ){
					double tot_in;
					double tot_out;
					tot_in = (double) total_in;
					tot_out = (double) total_out;
					sprintf(ratio,&quot;,compression: %.02f%%&quot;, 100 * ((tot_out - tot_in)/tot_out));
				} else {
					sprintf(ratio,&quot;         &quot;);
				}
				scroll_logger(&quot;Installed%s                                              \n&quot;, ratio);
				close(pipefd[1]);
				wait(NULL); // Wait for child to exit...
			} else {
				u_int64_t received;
				u_int64_t total;
				u_int64_t real_sent;
				u_int64_t cur_sent;
				total = 0;
				while ( (received = recv(sockd,tbuf,TBUFSIZE,0)) &gt; 0 ){
					real_sent = 0;
					while ( real_sent &lt; received ){
						cur_sent = write(pipefd[1],&amp;tbuf[real_sent],received - real_sent);
						real_sent += cur_sent;
					}
					total += received;
					c_logger(&quot;Received %.02f%%       \r&quot;, (((double)total) / ((double)fil-&gt;size)) * 100.0);
				}
				close(pipefd[1]);
				wait(NULL); // Wait for child to exit...
			}
			scroll_logger(&quot;File [%s] completely processed\n&quot;,fil-&gt;name);
		}
	}
	close(sockd);
	while ( sock_readline(sock,reply,0) &gt; 0 &amp;&amp; reply[3] == &#039;-&#039; ); 
	
	return(0);
}

struct _ext4list {
	char devname[256];
	struct  ext4_super_block superblock;
	char mountdir[256]; // Just for installation
	u_int64_t size;
};

struct  _ext4list *instpart = NULL;
int instparts = 0;
	

void files_setup(){
		int error_found;
		char zero[512];
		char cmd[512];
		char reply[1024];
		unsigned char buf[1024];
		int code;
		char *ptr;
		int retval;
		int sock;
		int i;
		
		create_sub1();
		attroff(COLOR_PAIR(BASE2_COLOR_NORMAL));
		bzero(zero,4);
		create_scroller(&quot;Setting up system&quot;);
		if ( memcmp(ipconfig.ip,zero,4) == 0 ){
			alarm_window(&quot;Please set up network first!&quot;,ALARM_ERROR,NULL,0);
			erase();
			display_options();
			refresh();
			return;
		}
LOGIN_FTP:
		strcpy(zero,ipconfig.ftp_server);
		if ( alarm_window(&quot;FTP-Server to use (IP or name): &quot;,ALARM_INPUT,zero, 32) &lt; 0 ){
			erase();
			display_options();
			refresh();
			return;
		}
		if ( strlen(zero) ){
			ptr = &amp;zero[strlen(zero)-1];
			while ( ptr &gt; zero &amp;&amp; *ptr == &#039; &#039; ) { *ptr = 0x00; ptr--; }
		}
		strcpy(ipconfig.ftp_server,zero);
		strcpy(zero,ipconfig.ftp_user);
		if ( alarm_window(&quot;FTP-User to use: &quot;,ALARM_INPUT,zero, 32) &lt; 0 ){
			erase();
			display_options();
			refresh();
			return;
		}
		if ( strlen(zero) ){
			ptr = &amp;zero[strlen(zero)-1];
			while ( ptr &gt; zero &amp;&amp; *ptr == &#039; &#039; ) { *ptr = 0x00; ptr--; }
		}
		strcpy(ipconfig.ftp_user,zero);
		strcpy(zero,ipconfig.ftp_pwd);
		if ( alarm_window(&quot;FTP-Password to use: &quot;,ALARM_INPUT,zero, 32) &lt; 0 ){
			erase();
			display_options();
			refresh();
			return;
		}
		if ( strlen(zero) ){
			ptr = &amp;zero[strlen(zero)-1];
			while ( ptr &gt; zero &amp;&amp; *ptr == &#039; &#039; ) { *ptr = 0x00; ptr--; }
		}
		strcpy(ipconfig.ftp_user,zero);

		scroll_logger(&quot;Checking credentials\n&quot;);
		if ( (sock = ftp_login(&amp;ipconfig,FTP_DEBUG)) &lt; 0 ){
			if ( alarm_window(&quot;Connection to FTP-Server failed! Retry?&quot;,ALARM_OKCANCEL,NULL,ANSWER_OK) == ANSWER_OK ) goto LOGIN_FTP;
			erase();
			display_options();
			refresh();
			return;
		} 
		for ( i = 0; efi_file[i].name != NULL; i++ ){
			int dummy;
			sprintf(cmd,&quot;SIZE %s\r\n&quot;,efi_file[i].name);
			if ( sock_writeline(sock,cmd,FTP_DEBUG) != strlen(cmd) ){
				close(sock);
				sprintf(cmd,&quot;FTP-Server does not contain mandatory [%s]\nRetry?&quot;,efi_file[i].name);
				if ( alarm_window(cmd,ALARM_OKCANCEL,NULL,ANSWER_OK) == ANSWER_OK ) goto LOGIN_FTP;
				erase();
				display_options();
				refresh();
				return;
			}
			while ( sock_readline(sock,reply,FTP_DEBUG) &gt; 0 &amp;&amp; reply[3] == &#039;-&#039; ); 
			code = atoi(reply);
			if ( code &lt; 200 || code &gt;= 300 ){
				close(sock);
				sprintf(cmd,&quot;FTP-Server does not contain mandatory [%s]\nRetry?&quot;,efi_file[i].name);
				if ( alarm_window(cmd,ALARM_OKCANCEL,NULL,ANSWER_OK) == ANSWER_OK ) goto LOGIN_FTP;
				erase();
				display_options();
				refresh();
				return;
			}
			if ( sscanf(reply,&quot;%d %ju&quot;,&amp;dummy, &amp;efi_file[i].size) != 2 ){
				close(sock);
				sprintf(cmd,&quot;FTP-Server does not contain mandatory [%s]\nRetry?&quot;,efi_file[i].name);
				if ( alarm_window(cmd,ALARM_OKCANCEL,NULL,ANSWER_OK) == ANSWER_OK ) goto LOGIN_FTP;
				erase();
				display_options();
				refresh();
				return;
			}
			scroll_logger(&quot;[%s] --&gt; %ju Bytes\n&quot;,efi_file[i].name,efi_file[i].size);
		}
		for ( i = 0; gixl_file[i].name != NULL; i++ ){
			int dummy;
			sprintf(cmd,&quot;SIZE %s\r\n&quot;,gixl_file[i].name);
			if ( sock_writeline(sock,cmd,FTP_DEBUG) != strlen(cmd) ){
				close(sock);
				sprintf(cmd,&quot;FTP-Server does not contain mandatory [%s]\nRetry?&quot;,gixl_file[i].name);
				if ( alarm_window(cmd,ALARM_OKCANCEL,NULL,ANSWER_OK) == ANSWER_OK ) goto LOGIN_FTP;
				erase();
				display_options();
				refresh();
				return;
			}
			while ( sock_readline(sock,reply,FTP_DEBUG) &gt; 0 &amp;&amp; reply[3] == &#039;-&#039; ); 
			code = atoi(reply);
			if ( code &lt; 200 || code &gt;= 300 ){
				close(sock);
				sprintf(cmd,&quot;FTP-Server does not contain mandatory [%s]\nRetry?&quot;,gixl_file[i].name);
				if ( alarm_window(cmd,ALARM_OKCANCEL,NULL,ANSWER_OK) == ANSWER_OK ) goto LOGIN_FTP;
				erase();
				display_options();
				refresh();
				return;
			}
			if ( sscanf(reply,&quot;%d %ju&quot;,&amp;dummy, &amp;gixl_file[i].size) != 2 ){
				close(sock);
				sprintf(cmd,&quot;FTP-Server does not contain mandatory [%s]\nRetry?&quot;,gixl_file[i].name);
				if ( alarm_window(cmd,ALARM_OKCANCEL,NULL,ANSWER_OK) == ANSWER_OK ) goto LOGIN_FTP;
				erase();
				display_options();
				refresh();
				return;
			}
			scroll_logger(&quot;[%s] --&gt; %ju Bytes\n&quot;,gixl_file[i].name,gixl_file[i].size);
		}

		mkdir(&quot;/mnt&quot;,0755);
		error_found = 0;

		// First we install the EFI stuff...
		{
			DIR *dir;
			struct dirent *diry;
			dir = opendir(&quot;/dev&quot;);
			if ( dir ){
				char partname[1024];
				while ( (diry = readdir(dir)) != NULL ){
					strcpy(partname,&quot;&quot;);
					if ( strncmp(diry-&gt;d_name,&quot;sd&quot;,2) == 0 &amp;&amp; strlen(diry-&gt;d_name) == 4 ){
						sprintf(partname,&quot;/dev/%s&quot;,diry-&gt;d_name);
					}
					if ( strncmp(diry-&gt;d_name,&quot;md&quot;,2) == 0 &amp;&amp; strlen(diry-&gt;d_name) == 3 ){
						sprintf(partname,&quot;/dev/%s&quot;,diry-&gt;d_name);
					}
					if ( strlen(partname) ){
						int fd;
						debug_logger(&quot;Checking partition  [%s]\n&quot;,partname);
						fd = open(partname,O_RDONLY);
						if ( fd &lt; 0 ) continue;
						if ( lseek(fd,0,SEEK_SET) &lt; 0 ){
							close(fd);
							continue;
						}
						if ( read(fd,(unsigned char *)buf,512) != 512 ){
							close(fd);
							continue;
						}
						close(fd);
						debug_logger(&quot;Checking partition for VFAT: [%s] [0x%02X] [0x%02X] [0x%02X]\n&quot;,partname,buf[0],buf[1],buf[2]);
						if ( memcmp(buf,fat_magic,3) == 0 ){
							scroll_logger(&quot;[%s] --&gt; Microsoft FAT\n&quot;,partname);
							if ( mount(partname,&quot;/mnt&quot;,&quot;vfat&quot;,0,NULL)  &lt; 0 ){
								sprintf(buf,&quot;Failed to mount [%s] as FAT (%s) --&gt; Skip[OK] or abort[CANCEL]?\n&quot;,partname,strerror(errno));
								if ( alarm_window(buf,ALARM_OKCANCEL,NULL,ANSWER_OK) == ANSWER_CANCEL ){
									close(sock);
									end_scroller();
									erase();
									display_options();
									refresh();
									return;
								}
							} else {
								for ( i = 0; efi_file[i].name != NULL; i++ ){
									int retval;
									if ( (retval = ftp_fetch(sock,&amp;efi_file[i],FTP_DEBUG)) &lt; 0 ){
										sprintf(buf,&quot;Failed to fetch [%s] as (%s)[%s] --&gt; (%d)\nSkip[OK] or abort[CANCEL]?\n&quot;,
												efi_file[i].name,partname,efi_file[i].localname,retval);
										if ( alarm_window(buf,ALARM_OKCANCEL,NULL,ANSWER_OK) == ANSWER_CANCEL ){
											umount(&quot;/mnt&quot;);
											close(sock);
											end_scroller();
											erase();
											display_options();
											refresh();
											return;
										}
									}
								}
								sync();
								umount(&quot;/mnt&quot;);
								continue;
							}
						}

					}
				}
				closedir(dir);
			}

		}
		ftp_logout(sock,FTP_DEBUG);
		scroll_logger(&quot;----------------------------------------------------------\n&quot;);
		scroll_logger(&quot;Searching for EXT4 Partitions\n&quot;);
		scroll_logger(&quot;----------------------------------------------------------\n&quot;);
		{
			DIR *dir;
			struct dirent *diry;
			u_int64_t the_size;

			if ( instpart ){ free(instpart); instpart = NULL;}
			instparts = 0;	


			dir = opendir(&quot;/dev&quot;);
			if ( dir ){
				char partname[1024];
				while ( (diry = readdir(dir)) != NULL ){
					strcpy(partname,&quot;&quot;);
					if ( strncmp(diry-&gt;d_name,&quot;sd&quot;,2) == 0 &amp;&amp; strlen(diry-&gt;d_name) == 4 ){
						sprintf(partname,&quot;/dev/%s&quot;,diry-&gt;d_name);
					}
					if ( strncmp(diry-&gt;d_name,&quot;md&quot;,2) == 0 &amp;&amp; strlen(diry-&gt;d_name) == 3 ){
						sprintf(partname,&quot;/dev/%s&quot;,diry-&gt;d_name);
					}
					if ( strlen(partname) ){
						unsigned buf[1024];
						int fd;
						struct ext4_super_block *super;
						debug_logger(&quot;Checking partition  [%s]\n&quot;,partname);
						fd = open(partname,O_RDONLY);
						if ( fd &lt; 0 ) continue;
						if ( lseek(fd,1024,SEEK_SET) &lt; 0 ){
							close(fd);
							continue;
						}
						if ( read(fd,(unsigned char *)buf,1024) != 1024 ){
							close(fd);
							continue;
						}
						the_size = lseek(fd,0,SEEK_END);
						close(fd);
						super = (struct ext4_super_block *)buf;	
						if ( checkraidmember(partname) ) continue; // Cannot be used for installation
						if ( super-&gt;s_magic == EXT4_MAGIC ){
							instpart = (struct _ext4list *)realloc(instpart,sizeof(struct _ext4list) * (instparts+1));
							bzero(&amp;instpart[instparts],sizeof(struct _ext4list));
							memcpy(&amp;instpart[instparts].superblock,super,sizeof(struct ext4_super_block));
							strcpy(instpart[instparts].devname,partname);
							instpart[instparts].size = the_size;
							scroll_logger(&quot;[%d]Partition [%s] SIZE: (%s)\n&quot;,
								instparts, partname,showsize(the_size));
							instparts++;
						}
					}
				}
				closedir(dir);
			}

		}
		if ( instparts ) {
			char helper[1024];
			int i,j;
			struct _select *sel;
			int instpart_index;
			create_sub2(sub1-&gt;start_x + 2, sub1-&gt;start_y + 2, sub1-&gt;width - 6, sub1-&gt;height - 4, &quot;Select Root-Disk&quot;);
			sel = (struct _select *)malloc(sizeof(struct _select) * (instparts+1));
			mvwprintw(sub2-&gt;win,2,2, &quot;Select now a root-disk for installing the operating system.&quot;);
			mvwprintw(sub2-&gt;win,4,2, &quot;       Press &lt;ESC&gt; to abort the installation.&quot;);

			bzero(sel,sizeof(struct _select) * (instparts+1));

			for ( i = 0; i &lt; instparts; i++ ){
				struct _raid *rd;
				if ( (rd = getraid(instpart[i].devname)) ){
					int i;
					sprintf(helper,&quot;%s (%s) [RAID%d: &quot;,instpart[i].devname,showsize(instpart[i].size),rd-&gt;level);
					for ( j = 0; j &lt; rd-&gt;parts; j++ ){
						if ( j ) strcat(helper,&quot;, &quot;);
						strcat(helper,rd-&gt;part[j].devname);
					}	
					strcat(helper,&quot;]&quot;);

				} else {
					sprintf(helper,&quot;%s (%s)&quot;,instpart[i].devname,showsize(instpart[i].size));
				}

				sel[i].name = strdup(helper);
			}
			current_select = 0;
			instpart_index = run_selector(NULL,sub2,4,sel,instparts,NULL);
			if ( instpart_index &lt; 0 ){ error_found = 1; goto NO_ROOT_FOUND; }
			for ( i = 0; i &lt; instparts; i++ ){
				free(sel[i].name);
			}
			free(sel);
			sprintf(helper,&quot;Create a new ext4 file-system on [%s] before proceeding?&quot;,instpart[instpart_index].devname);
			if ( alarm_window(helper,ALARM_OKCANCEL,NULL,ANSWER_OK)  == ANSWER_OK ){
				{

					char **arg;
					int args;
					char caption[1024];
					char result[1024];
					arg  = NULL;
					args = 0;
					arg = (char **)realloc(arg,sizeof(char *) * (args+1));
					arg[args++] = strdup(EXT4_COMMAND);
					arg = (char **)realloc(arg,sizeof(char *) * (args+1));
					arg[args++] = strdup(&quot;-v&quot;);
					arg = (char **)realloc(arg,sizeof(char *) * (args+1));
					arg[args++] = strdup(instpart[instpart_index].devname);
					arg = (char **)realloc(arg,sizeof(char *) * (args+1));
					arg[args++] = NULL;
					sprintf(caption,&quot;Creating EXT4 at %s&quot;,instpart[instpart_index].devname);
					sprintf(result,&quot;EXT4 at %s created&quot;,instpart[instpart_index].devname);
					run_program(arg[0],arg,caption,result);
					for ( i = 0; i &lt; args-1; i++ ) free(arg[i]);
					free(arg);
				}

			}
			// Mount filesystem now...
			create_scroller(&quot;Mounting and installing Root-Filesysem&quot;);
			if ( mount(instpart[instpart_index].devname,&quot;/mnt&quot;,&quot;ext4&quot;,0,NULL)  &lt; 0 ){
				error_found = 1;
				sprintf(buf,&quot;Failed to mount [%s] as EXT4 (%s) --&gt; Skip[OK] or abort[CANCEL]?\n&quot;,instpart[instpart_index].devname,strerror(errno));
				if ( alarm_window(buf,ALARM_OKCANCEL,NULL,ANSWER_OK) == ANSWER_CANCEL ){
					close(sock);
					end_scroller();
					erase();
					display_options();
					refresh();
					return;
				}
			} else {
				mkdir(&quot;/mnt/dev&quot;,0755);
				mkdir(&quot;/mnt/proc&quot;,0755);
				mkdir(&quot;/mnt/sys&quot;,0755);
				mkdir(&quot;/mnt/run&quot;,0755);
				mkdir(&quot;/mnt/tmp&quot;,0777);
				mkdir(&quot;/mnt/etc&quot;,0755);
				mkdir(&quot;/mnt/fast&quot;,0755);
				mkdir(&quot;/mnt/large&quot;,0755);
				if ( (sock = ftp_login(&amp;ipconfig,FTP_DEBUG)) &lt; 0 ){
					alarm_window(&quot;Reconnection to FTP-Server failed!\n     (Aborting installation)&quot;,ALARM_ERROR,NULL,0);
				} else {
					for ( i = 0; gixl_file[i].name != NULL; i++ ){
						int retval;
						if ( (retval = ftp_fetch(sock,&amp;gixl_file[i],FTP_DEBUG)) &lt; 0 ){
							sprintf(buf,&quot;Failed to fetch [%s] as (%s)[%s]\n (aborting installation)&quot;,
									gixl_file[i].name,instpart[instpart_index].devname,gixl_file[i].localname,retval);
							alarm_window(buf,ALARM_ERROR,NULL,0);
							if ( alarm_window(buf,ALARM_OKCANCEL,NULL,ANSWER_OK) == ANSWER_CANCEL ){
								umount(&quot;/mnt&quot;);
								close(sock);
								end_scroller();
								erase();
								display_options();
								refresh();
								return;
							}
						}
					}
					chmod(&quot;/mnt/tmp/&quot;,01777); // Include sticky-bit
					sync();
					// umount(&quot;/mnt&quot;); // As we continue setup, leave it mounted
					ftp_logout(sock,FTP_DEBUG);
				}
			}
		} else {
NO_ROOT_FOUND:
			alarm_window(&quot;No Partition applicable as root-device found!\nInstallation aborted!&quot;,ALARM_ERROR,NULL,0);
		}
		scroll_logger(&quot;----------------------------------------------------------\n&quot;);






		
		if ( error_found == 0 ) alarm_window(&quot;System-Setup finished, your system is ready to be configured!&quot;,ALARM_INFO,NULL,0);
		end_scroller();
		erase();
		display_options();
		refresh();
}


struct _efivar *evi = NULL;
int evis = 0;

struct _select *evi_sel;
int evi_sels;
// current_select contains the currently selected element


struct _efidisk *efidisk = NULL;
int efidisks = 0;



struct _select *efipsel = NULL;
int efipsels = 0;

int efipsorter(const void *_a, const void *_b){
	struct _efidisk *a;
	struct _efidisk *b;

	a = (struct _efidisk *)_a;
	b = (struct _efidisk *)_b;

	return(strcmp(a-&gt;device,b-&gt;device));
}

int add_efi_entry(u_int16_t *bootorder, int bootorders, int bootsel){
	char helper[1024];
	int i;
	int sel_disk;
	char fname[1024];
	char bootimage[1024];
	char bootargs[1024];
	char bootlabel[1024];
	int old_current_select;
	DIR *dir;
	struct dirent *diry;

	efidisk = NULL;
	efidisks = 0;


	dir = opendir(&quot;/dev&quot;);
	if ( dir == NULL ) return(1);

	while ( diry = readdir(dir) ){
		int i,fd;
		char partname[1024];
		char disk[1024];
		char hexdump2[1024];
		unsigned char buf[1024];
		const char *ptr;
		if ( (strncmp(diry-&gt;d_name,&quot;sd&quot;,2) != 0) || (strlen(diry-&gt;d_name) != 4) ) continue;
		sprintf(partname,&quot;/dev/%s&quot;,diry-&gt;d_name);
		fd = open(partname,O_RDONLY);
		if ( fd &lt; 0 ) continue;
		if ( lseek(fd,0,SEEK_SET) &lt; 0 ){
			close(fd);
			continue;
		}
		if ( read(fd,(unsigned char *)buf,512) != 512 ){
			close(fd);
			continue;
		}
		close(fd);
		if ( memcmp(buf,fat_magic,3) != 0 ) continue;
		strcpy(disk,partname);
		disk[strlen(disk)-1] = 0x00;
		efidisk = (struct _efidisk *)realloc(efidisk,sizeof(struct _efidisk) * (efidisks+1));
		bzero(&amp;efidisk[efidisks],sizeof(struct _efidisk));
		strcpy(efidisk[efidisks].device,disk);
		efidisk[efidisks].partno = atoi(&amp;diry-&gt;d_name[3]);
		efidisk[efidisks].ctx = fdisk_new_context();
		if ( fdisk_assign_device(efidisk[efidisks].ctx,efidisk[efidisks].device,1) != 0  ) continue;
		debug_logger(&quot;Partition [%d] is a valid canidate for DISK: [%s] %d\n&quot;,efidisk[efidisks].partno,efidisk[efidisks].device);
		for ( i = 0; i &lt; 128; i++ ){
			int inuse;
			inuse = fdisk_is_partition_used(efidisk[efidisks].ctx,i);
			if ( inuse == 0 ) continue;
			if ( fdisk_get_partition(efidisk[efidisks].ctx, i, &amp;efidisk[efidisks].pa) ) continue;
			if ( fdisk_partition_get_partno(efidisk[efidisks].pa) == ( efidisk[efidisks].partno - 1) )break;
		}
		efidisk[efidisks].label = fdisk_get_label(efidisk[efidisks].ctx,NULL);
		efidisk[efidisks].pt    = fdisk_label_get_parttype(efidisk[efidisks].label,i);
		efidisk[efidisks].start = fdisk_partition_get_start(efidisk[efidisks].pa);
		efidisk[efidisks].size  = fdisk_partition_get_size(efidisk[efidisks].pa);
		ptr  = fdisk_label_get_name(efidisk[efidisks].label);
		strcpy(efidisk[efidisks].label_name,ptr);
		ptr  = fdisk_partition_get_uuid(efidisk[efidisks].pa);
		strcpy(efidisk[efidisks].uuid,ptr);
		efidisk[efidisks].label_type = fdisk_label_get_type(efidisk[efidisks].label);
		debug_logger(&quot;PARTITION[%d] --&gt; SIZE:  %ju\n&quot;,i,(efidisk[efidisks].size));
		debug_logger(&quot;PARTITION[%d] --&gt; START: %ju\n&quot;,i,(efidisk[efidisks].start));
		uuid_to_serial(efidisk[efidisks].uuid,efidisk[efidisks].serial);
		debug_logger(&quot;PARTITION[%d] --&gt; UUID:  [%s] --&gt; SERIAL: [%s]\n&quot;,i,(efidisk[efidisks].uuid), gix_hexdump(efidisk[efidisks].serial,16,hexdump2));
		debug_logger(&quot;PARTITION[%d] --&gt; LABEL: [%s]\n&quot;,i,(efidisk[efidisks].label_name));
		debug_logger(&quot;PARTITION[%d] --&gt; TYPE:  [%d]\n&quot;,i,(efidisk[efidisks].label_type));
		// fdisk_deassign_device(efidisk[efidisks].ctx);		


		efidisks++;
	}
	closedir(dir);
	qsort(efidisk,efidisks,sizeof(struct _efidisk),efipsorter);
	create_sub2(sub1-&gt;start_x + 2, sub1-&gt;start_y + 2, sub1-&gt;width - 6, sub1-&gt;height - 4, &quot;Select Partition to add&quot;);
	efipsels = efidisks;
	efipsel = (struct _select *)malloc(sizeof(struct _select) * (efidisks));
	bzero(efipsel,sizeof(struct _select) * (efidisks));
	mvwprintw(sub2-&gt;win,1,1,&quot;Select a disk and press &lt;ENTER&gt; or &lt;ESC&gt; to abort&quot;);
	for ( i = 0; i &lt; efipsels; i++ ){
		sprintf(helper,&quot;%s Partno: %d Size: %ju GUID: [%s]&quot;,efidisk[i].device, efidisk[i].partno, efidisk[i].size,efidisk[i].uuid);
		efipsel[i].name = strdup(helper);
	}
	old_current_select = current_select;
	current_select = 0;
	if ( (sel_disk = run_selector(NULL,sub2,4,efipsel,efipsels,NULL)) &lt; 0 ) return(1);
	current_select = old_current_select;
BOOT_LABEL_ENTER:
	strcpy(bootlabel,&quot;GIXLinux2&quot;);
	sprintf(helper,&quot;Boot-Label for %s%d: &quot;,efidisk[sel_disk].device,efidisk[sel_disk].partno);
	if ( alarm_window(helper,ALARM_INPUT,bootlabel,16) &lt; 0 ) return(1);
	while ( strlen(bootlabel) &amp;&amp; isspace(bootlabel[strlen(bootlabel)-1]) ) bootlabel[strlen(bootlabel)-1] = 0x00;
	if ( strlen(bootlabel) &lt; 3 ){
		alarm_window(&quot;Please enter a valid boot-label (at least 3 chars)!&quot;,ALARM_ERROR,NULL,0);
		goto BOOT_IMAGE_ENTER;
	}
BOOT_IMAGE_ENTER:
	strcpy(bootimage,&quot;bzImage&quot;);
	sprintf(helper,&quot;Boot-Image for %s%d: &quot;,efidisk[sel_disk].device,efidisk[sel_disk].partno);
	if ( alarm_window(helper,ALARM_INPUT,bootimage,16) &lt; 0 ) return(1);
	while ( strlen(bootimage) &amp;&amp; isspace(bootimage[strlen(bootimage)-1]) ) bootimage[strlen(bootimage)-1] = 0x00;
	if ( strlen(bootimage) &lt; 1 ){
		alarm_window(&quot;Please enter a valid boot-file!&quot;,ALARM_ERROR,NULL,0);
		goto BOOT_IMAGE_ENTER;
	}
BOOT_ARGS_ENTER:
	sprintf(bootargs,&quot;initrd=initrd.img root=%s2 console=ttyS0,115200 console=tty0&quot;,efidisk[sel_disk].device);
	sprintf(helper,&quot;Boot-Args: &quot;);
	if ( alarm_window(helper,ALARM_INPUT,bootargs,70) &lt; 0 ) return(1);
	while ( strlen(bootargs) &amp;&amp; isspace(bootargs[strlen(bootargs)-1]) ) bootargs[strlen(bootargs)-1] = 0x00;

	return( create_efi_boot_entry(&amp;efidisk[sel_disk],bootlabel,bootimage,bootargs,bootorder, bootorders, bootsel) );

}

int efi_action(int key){
	char helper[1024];
	int i,j;
        if ( key == &#039;d&#039; || key == &#039;D&#039; ){
		sprintf(helper,&quot;Are you sure, you want to delete this entry?&quot;);
		if ( alarm_window(helper,ALARM_OKCANCEL,&quot;&lt;YES&gt;|&lt;NO&gt;&quot;,ANSWER_CANCEL) == ANSWER_CANCEL ) return(HANDLER_RETURN_STAY);
                for ( i = 0; i &lt; evi-&gt;bootorders; i++ ){
			if ( evi[evi_sel[current_select].internal_id].entrynr == evi-&gt;bootorder[i] ){
				char fname[1024];
				sprintf(fname,&quot;%s/%s&quot;,EFI_PATH,evi[evi_sel[current_select].internal_id].name);
				unlink(fname);
				debug_logger(&quot;Deleted File: [%s]\n&quot;,fname);
				for ( j = i; j &lt; (evi-&gt;bootorders-1); j++ )
					evi-&gt;bootorder[j] = evi-&gt;bootorder[j+1];
				break;
			}
		}
		evi-&gt;bootorders--;
		efi_write_boot_order(evi-&gt;bootorder, evi-&gt;bootorders);
		if ( current_select ) current_select--;
		return(HANDLER_RETURN_CURRENT_SELECT);
        }
	if ( key == &#039;n&#039; || key == &#039;N&#039; ){
		int retval;
		debug_logger(&quot;Trying to create new entry\n&quot;);
		retval = add_efi_entry(evi-&gt;bootorder,evi-&gt;bootorders, current_select);
		// current_select = 0;
		if ( retval == 0 ){
			alarm_window(&quot;New entry created successfully!&quot;,ALARM_INFO,NULL,0);
		} else if ( retval == 1 ){
			alarm_window(&quot;Aborted creating new entry!&quot;,ALARM_WARNING,NULL,0);
		} else {
			alarm_window(&quot;Error creating new entry!&quot;,ALARM_ERROR,NULL,0);
		}
		return(HANDLER_RETURN_CURRENT_SELECT);
	}
        if ( key == &#039;-&#039; ){
		if ( current_select &gt;= evi_sels ) return(HANDLER_RETURN_STAY); // Already at top
                for ( i = 0; i &lt; (evi-&gt;bootorders-1); i++ ){
			if ( evi[evi_sel[current_select].internal_id].entrynr == evi-&gt;bootorder[i] ){
				if ( i ){
					u_int16_t swap_value;
					swap_value = evi-&gt;bootorder[i+1];
					evi-&gt;bootorder[i+1] = evi-&gt;bootorder[i];
					evi-&gt;bootorder[i] = swap_value;
				}
				break;
			}
		}
		if ( current_select &lt; (evi_sels-1)){
			current_select++;
		}
		efi_write_boot_order(evi-&gt;bootorder, evi-&gt;bootorders);
		return(HANDLER_RETURN_CURRENT_SELECT);
	}
        if ( key == &#039;+&#039; ){
		if ( current_select == 0 ) return(HANDLER_RETURN_STAY); // Already at top
                for ( i = 0; i &lt; evi-&gt;bootorders; i++ ){
			if ( evi[evi_sel[current_select].internal_id].entrynr == evi-&gt;bootorder[i] ){
				if ( i ){
					u_int16_t swap_value;
					swap_value = evi-&gt;bootorder[i-1];
					evi-&gt;bootorder[i-1] = evi-&gt;bootorder[i];
					evi-&gt;bootorder[i] = swap_value;
				}
				break;
			}
		}
		current_select--;
		efi_write_boot_order(evi-&gt;bootorder, evi-&gt;bootorders);
		return(HANDLER_RETURN_CURRENT_SELECT);
	}
        if ( key == KEY_RIGHT ){
        }
        return(HANDLER_RETURN_STAY);
}



void do_efi(){
	int i;
	int entry_index;
	current_select = 0;
DO_EFI:
	evis = load_efi_vars(&amp;evi);
	for ( i = 0; i &lt; evis; i++ ){
		dump_efi(&amp;evi[i]);
	}

	create_sub2(sub1-&gt;start_x + 2, sub1-&gt;start_y + 2, sub1-&gt;width - 6, sub1-&gt;height - 4, &quot;Manage EFI-Bootlist&quot;);
	evi_sels = 0;
	evi_sel  = NULL;
	for ( i = 0; i &lt; evis; i++ ){
		if ( evi[i].entrynr == 0xFFFF ) continue;
		char helper[1024];
		evi_sel = (struct _select *)realloc(evi_sel,(evi_sels+1) * sizeof(struct _select));
		bzero(&amp;evi_sel[evi_sels],sizeof(struct _select));
		sprintf(helper,&quot;[%04X] (%c) [%ls] {%s}&quot;,evi[i].entrynr, evi[i].active ? &#039;*&#039; : &#039; &#039;, evi[i].description,&amp;(evi[i].name)[9]);
		evi_sel[evi_sels].name = strdup(helper);
		evi_sel[evi_sels].internal_id = i;
		evi_sels++;
	}
	mvwprintw(sub2-&gt;win,1,1,&quot;&lt;D&gt; Delete &lt;N&gt;Insert new&quot;);
	mvwprintw(sub2-&gt;win,2,1,&quot;&lt;+&gt; Move entry up &lt;-&gt; Move entry down&quot;);
	if ( (entry_index = run_selector(NULL,sub2,5,evi_sel,evi_sels,efi_action)) &lt; 0 ) return;
	goto DO_EFI;
}




int main(int argc, char **argv){
	WINDOW *sub;
	int ch;
	int result;
	int args;
	char **arg;

/*
	struct _raid *rd;

	rd = getraid(&quot;/dev/sdc1&quot;);
	printf(&quot;RAID-CHECKING [/dev/sdc1] --&gt; [%s]\n&quot;, rd == NULL ? &quot;NULL&quot; : rd-&gt;devname);
	rd = getraid(&quot;/dev/sdb1&quot;);
	printf(&quot;RAID-CHECKING [/dev/sdb1] --&gt; [%s]\n&quot;, rd == NULL ? &quot;NULL&quot; : rd-&gt;devname);
	rd = getraid(&quot;/dev/sdb2&quot;);
	printf(&quot;RAID-CHECKING [/dev/sdb2] --&gt; [%s]\n&quot;, rd == NULL ? &quot;NULL&quot; : rd-&gt;devname);
	rd = getraid(&quot;/dev/sda2&quot;);
	printf(&quot;RAID-CHECKING [/dev/sda2] --&gt; [%s]\n&quot;, rd == NULL ? &quot;NULL&quot; : rd-&gt;devname);

	exit(0);


	setup_interfaces();
	exit(0);

	{
		struct _efivar *evi;
		int evis;
		int i;
		debug_logger(&quot;LOAD_EFI_VARS RETURND: %d\n&quot;,(evis = load_efi_vars(&amp;evi)));
		for ( i = 0; i &lt; evis; i++ ){
			dump_efi(&amp;evi[i]);
		}
		exit(0);
	}

*/

	memset(ipbcast,255,4);
	dhcpmagic[0] = 0x63;
	dhcpmagic[1] = 0x82;
	dhcpmagic[2] = 0x53;
	dhcpmagic[3] = 0x63;


	sprintf(caption,&quot;%s Setup&quot;,GIX_VERSION);



/*
	arg = NULL;
	args = 0;
	arg = (char **)realloc(arg,sizeof(char *) * (args+1));
	arg[args++] = strdup(&quot;[GIXSETUP]&quot;);

	arg = (char **)realloc(arg,sizeof(char *) * (args+1));
	arg[args++] = strdup(&quot;-asl&quot;);

	arg = (char **)realloc(arg,sizeof(char *) * (args+1));
	arg[args++] = strdup(&quot;/big&quot;);

	arg = (char **)realloc(arg,sizeof(char *) * (args+1));
	arg[args++] = NULL;

	result = run_program(&quot;/usr/bin/ls&quot;,arg);

	printf(&quot;\n\nRESULT: %d\n&quot;,result);

	exit(0);
*/

	sub1  = &amp;_sub1;
	sub2  = &amp;_sub2;
	walarm = &amp;_walarm;
	screen = &amp;_screen;
	runner = &amp;_runner;

	bzero(sub1,sizeof(WIN));
	bzero(sub2,sizeof(WIN));
	bzero(walarm,sizeof(WIN));
	bzero(runner,sizeof(WIN));

	o_rows = 0;
	o_cols = 0;

	root = initscr();
	screen-&gt;win = root;
	screen-&gt;start_x = 0;
	screen-&gt;start_y = 0;
	box(root,0,0);
	start_color();
	init_pair(BASE2_COLOR_NORMAL,COLOR_BLACK, COLOR_CYAN);
	init_pair(BASE2_COLOR_ERROR,COLOR_RED, COLOR_CYAN);
	init_pair(BASE_COLOR_ERROR,COLOR_RED, COLOR_BLACK);
	init_pair(ALARM_COLOR_FATAL,COLOR_BLACK, COLOR_RED);     // ERROR
	init_pair(ALARM_COLOR_INFO,COLOR_BLACK, COLOR_GREEN);   // INFO
	init_pair(ALARM_COLOR_WARNING,COLOR_BLACK, COLOR_YELLOW);  // WARNING
	init_pair(ALARM_COLOR_OKCANCEL,COLOR_BLACK, COLOR_MAGENTA); // OK/CANCEL
	raw();
	keypad(stdscr,TRUE);
	noecho();
	/*
	while ( 1 ){
		ch = getch();
		printf(&quot;CH = %d\r\n&quot;,ch);
	}
	*/
	curs_set(0);
	display_options();
	refresh();
	while ( (ch = getch()) ){
		if ( ch == KEY_UP ){
			current_option--;
			if ( current_option &lt; 0  ) current_option = options - 1;
			display_options();
			continue;
		}
		if ( ch == KEY_DOWN ){
			current_option++;
			if ( current_option &gt;= options ) current_option = 0;
			display_options();
			continue;
		}
		if ( ch == KEY_ENTER || ch == 0x000A){
			run_main_action();
			continue;
		}
		if ( ch == 0x001B ) break;
	}
	erase();
	refresh();
	endwin();

	return(0);
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FGIX_SETUP%2Fsrc'>🔙 Back</a></p>