[people/pmueller/ipfire-2.x.git] / src / install+setup / libsmooth / netstuff.c

/* SmoothWall libsmooth.
 *
 * This program is distributed under the terms of the GNU General Public
 * Licence.  See the file COPYING for details.
 *
 * (c) Lawrence Manning, 2001
 * Contains network library functions.
 * 
 */

#include "libsmooth.h"
#include <signal.h>

extern FILE *flog;
extern char *mylog;

extern char **ctr;

extern struct nic nics[];
extern struct knic knics[];

char *ucolourcard[] = { "GREEN", "RED", "ORANGE", "BLUE", NULL };
char *lcolourcard[] = { "green", "red", "orange", "blue", NULL };

int scanned_nics_read_done = 0;

newtComponent networkform;
newtComponent addressentry;
newtComponent netmaskentry;
newtComponent statictyperadio;
newtComponent dhcptyperadio;
newtComponent pppoetyperadio;
newtComponent pptptyperadio;
newtComponent dhcphostnameentry;

/* acceptable character filter for IP and netmaks entry boxes */
static int ip_input_filter(newtComponent entry, void * data, int ch, int cursor)
{
	if ((ch >= '0' && ch <= '9') || ch == '.' || ch == '\r' || ch >= NEWT_KEY_EXTRA_BASE)
		return ch;
	return 0;
}

/* This is a groovie dialog for showing network info.  Takes a keyvalue list,
 * a colour and a dhcp flag.  Shows the current settings, and rewrites them
 * if necessary.  DHCP flag sets wether to show the dhcp checkbox. */
int changeaddress(struct keyvalue *kv, char *colour, int typeflag,
	char *defaultdhcphostname)
{
	char *addressresult;
	char *netmaskresult;
	char *dhcphostnameresult;
	struct newtExitStruct es;
	newtComponent header;
	newtComponent addresslabel;
	newtComponent netmasklabel;
	newtComponent dhcphostnamelabel;
	newtComponent ok, cancel;	
	char message[1000];
	char temp[STRING_SIZE];
	char addressfield[STRING_SIZE];
	char netmaskfield[STRING_SIZE];
	char typefield[STRING_SIZE];
	char dhcphostnamefield[STRING_SIZE];
	int error;
	int result = 0;
	char type[STRING_SIZE];
	int startstatictype = 0;
	int startdhcptype = 0;
	int startpppoetype = 0;
	int startpptptype = 0;
		
	/* Build some key strings. */
	sprintf(addressfield, "%s_ADDRESS", colour);
	sprintf(netmaskfield, "%s_NETMASK", colour);
	sprintf(typefield, "%s_TYPE", colour);
	sprintf(dhcphostnamefield, "%s_DHCP_HOSTNAME", colour);
		
	sprintf(message, ctr[TR_INTERFACE], colour);
	newtCenteredWindow(44, (typeflag ? 18 : 12), message);
	
	networkform = newtForm(NULL, NULL, 0);

	sprintf(message, ctr[TR_ENTER_THE_IP_ADDRESS_INFORMATION], colour);
	header = newtTextboxReflowed(1, 1, message, 42, 0, 0, 0);
	newtFormAddComponent(networkform, header);

	/* See if we need a dhcp checkbox.  If we do, then we shift the contents
	 * of the window down two rows to make room. */
	if (typeflag)
	{
		strcpy(temp, "STATIC"); findkey(kv, typefield, temp);
		if (strcmp(temp, "STATIC") == 0) startstatictype = 1;
		if (strcmp(temp, "DHCP") == 0) startdhcptype = 1;
		if (strcmp(temp, "PPPOE") == 0) startpppoetype = 1;
		if (strcmp(temp, "PPTP") == 0) startpptptype = 1;
		statictyperadio = newtRadiobutton(2, 4, ctr[TR_STATIC], startstatictype, NULL);
		dhcptyperadio = newtRadiobutton(2, 5, "DHCP", startdhcptype, statictyperadio);
		pppoetyperadio = newtRadiobutton(2, 6, "PPPOE", startpppoetype, dhcptyperadio);
		pptptyperadio = newtRadiobutton(2, 7, "PPTP", startpptptype, pppoetyperadio);
		newtFormAddComponents(networkform, statictyperadio, dhcptyperadio, 
			pppoetyperadio, pptptyperadio, NULL);
		newtComponentAddCallback(statictyperadio, networkdialogcallbacktype, NULL);
		newtComponentAddCallback(dhcptyperadio, networkdialogcallbacktype, NULL);
		newtComponentAddCallback(pppoetyperadio, networkdialogcallbacktype, NULL);
		newtComponentAddCallback(pptptyperadio, networkdialogcallbacktype, NULL);
		dhcphostnamelabel = newtTextbox(2, 9, 18, 1, 0);
		newtTextboxSetText(dhcphostnamelabel, ctr[TR_DHCP_HOSTNAME]);
		strcpy(temp, defaultdhcphostname);
		findkey(kv, dhcphostnamefield, temp);
		dhcphostnameentry = newtEntry(20, 9, temp, 20, &dhcphostnameresult, 0);
		newtFormAddComponent(networkform, dhcphostnamelabel);		
		newtFormAddComponent(networkform, dhcphostnameentry);	
		if (startdhcptype == 0)
			newtEntrySetFlags(dhcphostnameentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
	}
	/* Address */
	addresslabel = newtTextbox(2, (typeflag ? 11 : 4) + 0, 18, 1, 0);
	newtTextboxSetText(addresslabel, ctr[TR_IP_ADDRESS_PROMPT]);
	strcpy(temp, "");
	findkey(kv, addressfield, temp);
	addressentry = newtEntry(20, (typeflag ? 11 : 4) + 0, temp, 20, &addressresult, 0);
	newtEntrySetFilter(addressentry, ip_input_filter, NULL);
	if (typeflag == 1 && startstatictype == 0 && startpptptype == 0 )
		newtEntrySetFlags(addressentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
	newtFormAddComponent(networkform, addresslabel);
	newtFormAddComponent(networkform, addressentry);
	
	/* Netmask */
	netmasklabel = newtTextbox(2, (typeflag ? 11 : 4) + 1, 18, 1, 0);
	newtTextboxSetText(netmasklabel, ctr[TR_NETMASK_PROMPT]);
	strcpy(temp, "255.255.255.0"); findkey(kv, netmaskfield, temp);
	netmaskentry = newtEntry(20, (typeflag ? 11 : 4) + 1, temp, 20, &netmaskresult, 0);
	newtEntrySetFilter(netmaskentry, ip_input_filter, NULL);
	if (typeflag == 1 && startstatictype == 0 && startpptptype == 0 ) 
		newtEntrySetFlags(netmaskentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);

	newtFormAddComponent(networkform, netmasklabel);
	newtFormAddComponent(networkform, netmaskentry);

	/* Buttons. */
	ok = newtButton(8, (typeflag ? 14 : 7), ctr[TR_OK]);
	cancel = newtButton(26, (typeflag ? 14 : 7), ctr[TR_CANCEL]);

	newtFormAddComponents(networkform, ok, cancel, NULL);

	newtRefresh();
	newtDrawForm(networkform);

	do
	{
		error = 0;
		newtFormRun(networkform, &es);
	
		if (es.u.co == ok)
		{
			/* OK was pressed; verify the contents of each entry. */
			strcpy(message, ctr[TR_INVALID_FIELDS]);
			
			strcpy(type, "STATIC");
			if (typeflag)
				gettype(type);
			if (strcmp(type, "STATIC") == 0 || strcmp(type, "PPTP") == 0 )
			{		
				if (inet_addr(addressresult) == INADDR_NONE)
				{
					strcat(message, ctr[TR_IP_ADDRESS_CR]);
					error = 1;
				}
				if (inet_addr(netmaskresult) == INADDR_NONE)
				{
					strcat(message, ctr[TR_NETWORK_MASK_CR]);
					error = 1;
				}
			}
			if (strcmp(type, "DHCP") == 0)
			{
				if (!strlen(dhcphostnameresult))
				{
					strcat(message, ctr[TR_DHCP_HOSTNAME_CR]);
					error = 1;
				}
			}
			if (error)
				errorbox(message);
			else
			{
				/* No errors!  Set new values, depending on dhcp flag etc. */
				if (typeflag)
				{
					replacekeyvalue(kv, dhcphostnamefield, dhcphostnameresult);
					if (strcmp(type, "STATIC") != 0 && strcmp(type, "PPTP") != 0)
					{
						replacekeyvalue(kv, addressfield, "0.0.0.0");
						replacekeyvalue(kv, netmaskfield, "0.0.0.0");
					}
					else
					{
						replacekeyvalue(kv, addressfield, addressresult);
						replacekeyvalue(kv, netmaskfield, netmaskresult);
					}
					replacekeyvalue(kv, typefield, type);					
				}
				else
				{
					replacekeyvalue(kv, addressfield, addressresult);
					replacekeyvalue(kv, netmaskfield, netmaskresult);
				}
				
				setnetaddress(kv, colour);
				result = 1;
			}
		}			
	}
	while (error);

	newtFormDestroy(networkform);
	newtPopWindow();
		
	return result;
}

/* for pppoe: return string thats type STATIC, DHCP or PPPOE */
int gettype(char *type)
{
	newtComponent selected = newtRadioGetCurrent(statictyperadio);
	
	if (selected == statictyperadio)
		strcpy(type, "STATIC");
	else if (selected == dhcptyperadio)
		strcpy(type, "DHCP");
	else if (selected == pppoetyperadio)
		strcpy(type, "PPPOE");
	else if (selected == pptptyperadio)
		strcpy(type, "PPTP");
	else
		strcpy(type, "ERROR");
	
	return 0;
}

/* 0.9.9: calculates broadcast too. */
int setnetaddress(struct keyvalue *kv, char *colour)
{
	char addressfield[STRING_SIZE];
	char netaddressfield[STRING_SIZE];		
	char netmaskfield[STRING_SIZE];
	char broadcastfield[STRING_SIZE];
	char address[STRING_SIZE];
	char netmask[STRING_SIZE];
	unsigned long int intaddress;
	unsigned long int intnetaddress;
	unsigned long int intnetmask;
	unsigned long int intbroadcast;
	struct in_addr temp;
	char *netaddress;
	char *broadcast;
		
	/* Build some key strings. */
	sprintf(addressfield, "%s_ADDRESS", colour);
	sprintf(netaddressfield, "%s_NETADDRESS", colour);
	sprintf(netmaskfield, "%s_NETMASK", colour);
	sprintf(broadcastfield, "%s_BROADCAST", colour);

	strcpy(address, ""); findkey(kv, addressfield, address);	
	strcpy(netmask, ""); findkey(kv, netmaskfield, netmask);		

	/* Calculate netaddress. Messy.. */
	intaddress = inet_addr(address);
	intnetmask = inet_addr(netmask);
	
	intnetaddress = intaddress & intnetmask;
	temp.s_addr = intnetaddress;	
	netaddress = inet_ntoa(temp);
	
	replacekeyvalue(kv, netaddressfield, netaddress);
	
	intbroadcast = intnetaddress | ~intnetmask;
	temp.s_addr = intbroadcast;
	broadcast = inet_ntoa(temp);	
	
	replacekeyvalue(kv, broadcastfield, broadcast);
	
	return 1;
}	

/* Called when dhcp flag is toggled.  Toggle disabled state of other 3
 * controls. */
void networkdialogcallbacktype(newtComponent cm, void *data)
{
	char type[STRING_SIZE];
	
	gettype(type);

	if (strcmp(type, "STATIC") != 0  && strcmp(type, "PPTP") != 0 )
	{
		newtEntrySetFlags(addressentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
		newtEntrySetFlags(netmaskentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
	}
	else
	{
		newtEntrySetFlags(addressentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_RESET);
		newtEntrySetFlags(netmaskentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_RESET);
	}
	if (strcmp(type, "DHCP") == 0)
		newtEntrySetFlags(dhcphostnameentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_RESET);
	else
		newtEntrySetFlags(dhcphostnameentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);		
		
	newtRefresh();
	newtDrawForm(networkform);	
}

int interfacecheck(struct keyvalue *kv, char *colour)
{
	char temp[STRING_SIZE];
	char colourfields[NETCHANGE_TOTAL][STRING_SIZE];
	int c;

	sprintf(colourfields[ADDRESS], "%s_ADDRESS", colour);
	sprintf(colourfields[NETADDRESS], "%s_NETADDRESS", colour);
	sprintf(colourfields[NETMASK], "%s_NETMASK", colour);

	for (c = 0; c < 3; c++)
	{
		strcpy(temp, ""); findkey(kv, colourfields[c], temp);
		if (!(strlen(temp))) return 0;
	}
	return 1;
}

/* Funky routine for loading all drivers (cept those are already loaded.). */
int probecards(char *driver, char *driveroptions)
{
	return 0;
}

/* ### alter strupper ###
char *strupper(char *s)
{
 int n;
 for (n=0;s[n];n++) s[n]=toupper(s[n]);
 return s;
}
*/

/* neuer StringUpper, wird zur Zeit nicht benutzt da UTF-8 nicht geht.
void strupper(unsigned char *string)
{
	unsigned char *str;
	for (str = string; *str != '\0'; str++)
		if (!(*str & 0x80) && islower(*str)) 
			*str = toupper(*str);
}
*/

int write_configs_netudev(char *description, char *macaddr, int colour)
{	
	#define UDEV_NET_CONF "/etc/udev/rules.d/30-persistent-network.rules"
	FILE *fp;
	char commandstring[STRING_SIZE];
	struct keyvalue *kv = initkeyvalues();
	char temp1[STRING_SIZE], temp2[STRING_SIZE], temp3[STRING_SIZE];
	char ucolour[STRING_SIZE];

//	sprintf(ucolour, colour);	
//	strupper(ucolour);

	sprintf(ucolour, ucolourcard[colour]);
	strcpy(knics[colour].description, description);
	strcpy(knics[colour].macaddr, macaddr);
	
	if (!(readkeyvalues(kv, CONFIG_ROOT "/ethernet/settings")))
	{
		freekeyvalues(kv);
		errorbox(ctr[TR_UNABLE_TO_OPEN_SETTINGS_FILE]);
		return 0;
	}

	sprintf(temp1, "%s_DEV", ucolour);
	sprintf(temp2, "%s_MACADDR", ucolour);
	sprintf(temp3, "%s0", lcolourcard[colour]);
	replacekeyvalue(kv, temp1, temp3);
	replacekeyvalue(kv, temp2, macaddr);
	sprintf(temp1, "%s_DESCRIPTION", ucolour);
	replacekeyvalue(kv, temp1, description);

	writekeyvalues(kv, CONFIG_ROOT "/ethernet/settings");
	freekeyvalues(kv);
	
	// Make sure that there is no conflict
	snprintf(commandstring, STRING_SIZE, "/usr/bin/touch "UDEV_NET_CONF" >/dev/null 2>&1");
	system(commandstring);
	
//	snprintf(commandstring, STRING_SIZE, "/bin/cat "UDEV_NET_CONF" | /bin/grep -v \"%s\" > "UDEV_NET_CONF" 2>/dev/null", macaddr);
//	system(commandstring);

	snprintf(commandstring, STRING_SIZE, "/bin/cat "UDEV_NET_CONF" | /bin/grep -v \"%s0\" > "UDEV_NET_CONF" 2>/dev/null", lcolourcard[colour]);
	system(commandstring);

	if( (fp = fopen(UDEV_NET_CONF, "a")) == NULL )
	{
		fprintf(stderr,"Couldn't open" UDEV_NET_CONF);
		return 1;
	}
	fprintf(fp,"ACTION==\"add\", SUBSYSTEM==\"net\", SYSFS{address}==\"%s\", NAME=\"%s0\" # %s\n", macaddr, lcolourcard[colour], description);
	fclose(fp);	
	
	return 0;
}

int scan_network_cards(void)
{
	FILE *fp;
	char description[STRING_SIZE], macaddr[STRING_SIZE], temp_line[STRING_SIZE];
	int count = 0;
	
	if (!(scanned_nics_read_done))
	{
		fprintf(flog,"Enter scan_network_cards\n"); // #### Debug ####
		mysystem("/bin/probenic.sh");
		// Read our scanned nics
		if( (fp = fopen(SCANNED_NICS, "r")) == NULL )
		{
			fprintf(stderr,"Couldn't open "SCANNED_NICS);
			return 1;
		}
		while (fgets(temp_line, STRING_SIZE, fp) != NULL)
		{
			strcpy(description, strtok(temp_line,";"));
			strcpy(macaddr,     strtok(NULL,";"));
			if ( strlen(macaddr) ) {
				strcpy(nics[count].description , description );
				strcpy(nics[count].macaddr , macaddr );
				count++;
			}
		}
		fclose(fp);
		scanned_nics_read_done = count;
	} else fprintf(flog,"Scan Networkcards does read.\n");
	return scanned_nics_read_done;
}


int nicmenu(int colour)
{
	int rc, choise = 0, count = 0, kcount = 0, mcount = 0, i, j, nic_in_use;
	int found_NIC_as_Card[4];
	char message[STRING_SIZE];

	char cMenuInhalt[STRING_SIZE];
	char MenuInhalt[20][180];
	char *pMenuInhalt[20];
	
//	strcpy( message , pnics[count].macaddr);
//	while (strcmp(message, "")) {
//		count++;
//		strcpy( message , pnics[count].macaddr);
//	}

	while (strcmp(nics[count].macaddr, "")) count++;			// 2 find how many nics in system
	for ( i=0 ; i<4;i++) if (strcmp(knics[i].macaddr, "")) kcount++;	// loop to find all knowing nics
	fprintf(flog, "Enter NicMenu\n");					// #### Debug ####
	fprintf(flog, "count nics %i\ncount knics %i\n", count, kcount);	// #### Debug ####

	// If new nics are found...
	if (count > kcount) {
		for (i=0 ; i < count ; i++)
		{
			nic_in_use = 0;
			for (j=0 ; j <= kcount ; j++) {
				if (strcmp(nics[ i ].macaddr, knics[ j ].macaddr) == 0 ) {
					nic_in_use = 1;
					fprintf(flog,"NIC \"%s\" is in use.\n", nics[ i ].macaddr); // #### Debug ####
					break;
				}
			}
			if (!(nic_in_use)) {
				fprintf(flog,"NIC \"%s\" is free.\n", nics[ i ].macaddr); // #### Debug ####
				if ( strlen(nics[i].description) < 55 ) 
					sprintf(MenuInhalt[mcount], "%.*s",  strlen(nics[i].description)-2, nics[i].description+1);
				else {
					sprintf(cMenuInhalt, "%.50s", nics[i].description + 1);
					strncpy(MenuInhalt[mcount], cMenuInhalt,(strrchr(cMenuInhalt,' ') - cMenuInhalt));
					strcat (MenuInhalt[mcount], "...");
				}

				while ( strlen(MenuInhalt[mcount]) < 50) strcat(MenuInhalt[mcount], " "); // Fill with space.

				strcat(MenuInhalt[mcount], " (");
				strcat(MenuInhalt[mcount], nics[i].macaddr);
				strcat(MenuInhalt[mcount], ")");
				pMenuInhalt[mcount] = MenuInhalt[mcount];
				found_NIC_as_Card[mcount]=i;
				mcount++;
			}
		}

		pMenuInhalt[mcount] = NULL;

//		sprintf(message, "Es wurde(n) %d freie Netzwerkkarte(n) in Ihrem System gefunden.\nBitte waehlen Sie im naechsten Dialog eine davon aus.\n", count);
//		newtWinMessage("NetcardMenu", ctr[TR_OK], message);

		sprintf(message, "(TR) Bitte wählen Sie eine der untenstehenden Netzwerkkarten fuer die Schnittstelle \"%s\" aus.\n", ucolourcard[colour]);
		rc = newtWinMenu("(TR) NetcardMenu2", message, 50, 5, 5, 6, pMenuInhalt, &choise, ctr[TR_OK], ctr[TR_SELECT], ctr[TR_CANCEL], NULL);
				
		if ( rc == 0 || rc == 1) {
			write_configs_netudev(nics[choise].description, nics[found_NIC_as_Card[choise]].macaddr, colour);
		} else if (rc == 2) {
//			manualdriver("pcnet32","");
	      	}
		return 0;
	} else {
		// We have to add here that you can manually add a device
		errorbox("(TR) Es wurden leider keine freien Netzwerkkarten fuer die Schnittstelle in ihrem System gefunden.");
		return 1;
	}
}

int clear_card_entry(int card)
{
	struct keyvalue *kv = initkeyvalues();
	char temp[STRING_SIZE];

	if (!(readkeyvalues(kv, CONFIG_ROOT "/ethernet/settings")))
	{
		freekeyvalues(kv);
		errorbox(ctr[TR_UNABLE_TO_OPEN_SETTINGS_FILE]);
		return 0;
	}

	strcpy(knics[card].description, ctr[TR_UNSET]);
	strcpy(knics[card].macaddr, "");
	strcpy(knics[card].colour, "");
	sprintf(temp, "%s_DEV", ucolourcard[card]);
	replacekeyvalue(kv, temp, "");
	sprintf(temp, "%s_MACADDR", ucolourcard[card]);
	replacekeyvalue(kv, temp, "");
	sprintf(temp, "%s_DESCRIPTION", ucolourcard[card]);
	replacekeyvalue(kv, temp, "");

	writekeyvalues(kv, CONFIG_ROOT "/ethernet/settings");
	freekeyvalues(kv);

	fprintf(flog,"Card \"%s\" cleared\n",ucolourcard[card]); // #### Debug ####
	return 0;
}

int ask_clear_card_entry(int card)
{
	char message[STRING_SIZE];
	int rc;

	sprintf(message, "(TR) Soll die Zuordnung der Netzwerkkarte \"%s\" entfernt werden ?\n", ucolourcard[card]);
	rc = newtWinChoice(ctr[TR_WARNING], ctr[TR_OK], ctr[TR_CANCEL], message);				

	if ( rc = 0 || rc == 1) {
		clear_card_entry(card);
//		sprintf(temp1, "%s_DEV", ucolour);
//		sprintf(temp2, "%s_MACADDR", ucolour);
//		replacekeyvalue(kv, temp1, "");
//		replacekeyvalue(kv, temp2, "");
//		sprintf(temp1, "%s_DESCRIPTION", ucolour);
//		replacekeyvalue(kv, temp1, "");

//		writekeyvalues(kv, CONFIG_ROOT "/ethernet/settings");
	} else return 1;

	return 0;
}

/* Manual entry for gurus. */
int manualdriver(char *driver, char *driveroptions)
{
	char *values[] = { NULL, NULL };	/* pointers for the values. */
	struct newtWinEntry entries[] =
		{ { "", &values[0], 0,}, { NULL, NULL, 0 } };
	int rc;
	char commandstring[STRING_SIZE];
	char *driverend;

	strcpy(driver, "");
	strcpy(driveroptions, "");
	
	rc = newtWinEntries(ctr[TR_SELECT_NETWORK_DRIVER], 
		ctr[TR_MODULE_PARAMETERS], 50, 5, 5, 40, entries, 
		ctr[TR_OK], ctr[TR_CANCEL], NULL);	
	if (rc == 0 || rc == 1)
	{
		if (strlen(values[0]))
		{
			sprintf(commandstring, "/sbin/modprobe %s", values[0]);
			if (runcommandwithstatus(commandstring, ctr[TR_LOADING_MODULE]) == 0)
			{
				if ((driverend = strchr(values[0], ' ')))
				{
					*driverend = '\0';
					strcpy(driver, values[0]);
					strcpy(driveroptions, driverend + 1);
				}				
				else
				{
					strcpy(driver, values[0]);
					strcpy(driveroptions, "");
				}
			}
			else
				errorbox(ctr[TR_UNABLE_TO_LOAD_DRIVER_MODULE]);
		}
		else
			errorbox(ctr[TR_MODULE_NAME_CANNOT_BE_BLANK]);
	}
	free(values[0]);

	return 1;
}
Commit	Line	Data
9607771a MT	1	/* SmoothWall libsmooth.
	2	*
	3	* This program is distributed under the terms of the GNU General Public
	4	* Licence. See the file COPYING for details.
	5	*
	6	* (c) Lawrence Manning, 2001
	7	* Contains network library functions.
	8	*
9607771a MT	9	*/
	10
	11	#include "libsmooth.h"
	12	#include <signal.h>
	13
	14	extern FILE *flog;
	15	extern char *mylog;
	16
	17	extern char **ctr;
	18
5057b611 HS	19	extern struct nic nics[];
	20	extern struct knic knics[];
	21
9b040aa0 HS	22	char *ucolourcard[] = { "GREEN", "RED", "ORANGE", "BLUE", NULL };
	23	char *lcolourcard[] = { "green", "red", "orange", "blue", NULL };
	24
5057b611 HS	25	int scanned_nics_read_done = 0;
5057b611 HS	26
9607771a MT	27	newtComponent networkform;
	28	newtComponent addressentry;
	29	newtComponent netmaskentry;
	30	newtComponent statictyperadio;
	31	newtComponent dhcptyperadio;
	32	newtComponent pppoetyperadio;
	33	newtComponent pptptyperadio;
	34	newtComponent dhcphostnameentry;
	35
	36	/* acceptable character filter for IP and netmaks entry boxes */
	37	static int ip_input_filter(newtComponent entry, void * data, int ch, int cursor)
	38	{
	39	if ((ch >= '0' && ch <= '9') \|\| ch == '.' \|\| ch == '\r' \|\| ch >= NEWT_KEY_EXTRA_BASE)
	40	return ch;
	41	return 0;
	42	}
	43
	44	/* This is a groovie dialog for showing network info. Takes a keyvalue list,
	45	* a colour and a dhcp flag. Shows the current settings, and rewrites them
	46	* if necessary. DHCP flag sets wether to show the dhcp checkbox. */
	47	int changeaddress(struct keyvalue kv, char colour, int typeflag,
	48	char *defaultdhcphostname)
	49	{
	50	char *addressresult;
	51	char *netmaskresult;
	52	char *dhcphostnameresult;
	53	struct newtExitStruct es;
	54	newtComponent header;
	55	newtComponent addresslabel;
	56	newtComponent netmasklabel;
	57	newtComponent dhcphostnamelabel;
	58	newtComponent ok, cancel;
	59	char message[1000];
	60	char temp[STRING_SIZE];
	61	char addressfield[STRING_SIZE];
	62	char netmaskfield[STRING_SIZE];
	63	char typefield[STRING_SIZE];
	64	char dhcphostnamefield[STRING_SIZE];
	65	int error;
	66	int result = 0;
	67	char type[STRING_SIZE];
	68	int startstatictype = 0;
	69	int startdhcptype = 0;
	70	int startpppoetype = 0;
	71	int startpptptype = 0;
	72
	73	/* Build some key strings. */
	74	sprintf(addressfield, "%s_ADDRESS", colour);
	75	sprintf(netmaskfield, "%s_NETMASK", colour);
	76	sprintf(typefield, "%s_TYPE", colour);
	77	sprintf(dhcphostnamefield, "%s_DHCP_HOSTNAME", colour);
	78
	79	sprintf(message, ctr[TR_INTERFACE], colour);
	80	newtCenteredWindow(44, (typeflag ? 18 : 12), message);
	81
	82	networkform = newtForm(NULL, NULL, 0);
	83
	84	sprintf(message, ctr[TR_ENTER_THE_IP_ADDRESS_INFORMATION], colour);
	85	header = newtTextboxReflowed(1, 1, message, 42, 0, 0, 0);
	86	newtFormAddComponent(networkform, header);
	87
	88	/* See if we need a dhcp checkbox. If we do, then we shift the contents
	89	* of the window down two rows to make room. */
	90	if (typeflag)
91	{
92	strcpy(temp, "STATIC"); findkey(kv, typefield, temp);
93	if (strcmp(temp, "STATIC") == 0) startstatictype = 1;
94	if (strcmp(temp, "DHCP") == 0) startdhcptype = 1;
95	if (strcmp(temp, "PPPOE") == 0) startpppoetype = 1;
96	if (strcmp(temp, "PPTP") == 0) startpptptype = 1;
97	statictyperadio = newtRadiobutton(2, 4, ctr[TR_STATIC], startstatictype, NULL);
98	dhcptyperadio = newtRadiobutton(2, 5, "DHCP", startdhcptype, statictyperadio);
99	pppoetyperadio = newtRadiobutton(2, 6, "PPPOE", startpppoetype, dhcptyperadio);
100	pptptyperadio = newtRadiobutton(2, 7, "PPTP", startpptptype, pppoetyperadio);
101	newtFormAddComponents(networkform, statictyperadio, dhcptyperadio,
102	pppoetyperadio, pptptyperadio, NULL);
103	newtComponentAddCallback(statictyperadio, networkdialogcallbacktype, NULL);
104	newtComponentAddCallback(dhcptyperadio, networkdialogcallbacktype, NULL);
105	newtComponentAddCallback(pppoetyperadio, networkdialogcallbacktype, NULL);
106	newtComponentAddCallback(pptptyperadio, networkdialogcallbacktype, NULL);
107	dhcphostnamelabel = newtTextbox(2, 9, 18, 1, 0);
108	newtTextboxSetText(dhcphostnamelabel, ctr[TR_DHCP_HOSTNAME]);
109	strcpy(temp, defaultdhcphostname);
110	findkey(kv, dhcphostnamefield, temp);
111	dhcphostnameentry = newtEntry(20, 9, temp, 20, &dhcphostnameresult, 0);
112	newtFormAddComponent(networkform, dhcphostnamelabel);
113	newtFormAddComponent(networkform, dhcphostnameentry);
114	if (startdhcptype == 0)
115	newtEntrySetFlags(dhcphostnameentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
116	}
117	/* Address */
118	addresslabel = newtTextbox(2, (typeflag ? 11 : 4) + 0, 18, 1, 0);
119	newtTextboxSetText(addresslabel, ctr[TR_IP_ADDRESS_PROMPT]);
120	strcpy(temp, "");
121	findkey(kv, addressfield, temp);
122	addressentry = newtEntry(20, (typeflag ? 11 : 4) + 0, temp, 20, &addressresult, 0);
123	newtEntrySetFilter(addressentry, ip_input_filter, NULL);
124	if (typeflag == 1 && startstatictype == 0 && startpptptype == 0 )
125	newtEntrySetFlags(addressentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
126	newtFormAddComponent(networkform, addresslabel);
127	newtFormAddComponent(networkform, addressentry);
128
129	/* Netmask */
130	netmasklabel = newtTextbox(2, (typeflag ? 11 : 4) + 1, 18, 1, 0);
131	newtTextboxSetText(netmasklabel, ctr[TR_NETMASK_PROMPT]);
132	strcpy(temp, "255.255.255.0"); findkey(kv, netmaskfield, temp);
133	netmaskentry = newtEntry(20, (typeflag ? 11 : 4) + 1, temp, 20, &netmaskresult, 0);
134	newtEntrySetFilter(netmaskentry, ip_input_filter, NULL);
135	if (typeflag == 1 && startstatictype == 0 && startpptptype == 0 )
136	newtEntrySetFlags(netmaskentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
137
138	newtFormAddComponent(networkform, netmasklabel);
139	newtFormAddComponent(networkform, netmaskentry);
140
141	/* Buttons. */
142	ok = newtButton(8, (typeflag ? 14 : 7), ctr[TR_OK]);
143	cancel = newtButton(26, (typeflag ? 14 : 7), ctr[TR_CANCEL]);
144
145	newtFormAddComponents(networkform, ok, cancel, NULL);
146
147	newtRefresh();
148	newtDrawForm(networkform);
149
150	do
151	{
152	error = 0;
153	newtFormRun(networkform, &es);
154
155	if (es.u.co == ok)
156	{
157	/* OK was pressed; verify the contents of each entry. */
158	strcpy(message, ctr[TR_INVALID_FIELDS]);
159
160	strcpy(type, "STATIC");
161	if (typeflag)
162	gettype(type);
163	if (strcmp(type, "STATIC") == 0 \|\| strcmp(type, "PPTP") == 0 )
164	{
165	if (inet_addr(addressresult) == INADDR_NONE)
166	{
167	strcat(message, ctr[TR_IP_ADDRESS_CR]);
168	error = 1;
169	}
170	if (inet_addr(netmaskresult) == INADDR_NONE)
171	{
172	strcat(message, ctr[TR_NETWORK_MASK_CR]);
173	error = 1;
174	}
175	}
176	if (strcmp(type, "DHCP") == 0)
177	{
178	if (!strlen(dhcphostnameresult))
179	{
180	strcat(message, ctr[TR_DHCP_HOSTNAME_CR]);
181	error = 1;
182	}
183	}
184	if (error)
185	errorbox(message);
186	else
187	{
188	/* No errors! Set new values, depending on dhcp flag etc. */
189	if (typeflag)
190	{
191	replacekeyvalue(kv, dhcphostnamefield, dhcphostnameresult);
192	if (strcmp(type, "STATIC") != 0 && strcmp(type, "PPTP") != 0)
193	{
194	replacekeyvalue(kv, addressfield, "0.0.0.0");
195	replacekeyvalue(kv, netmaskfield, "0.0.0.0");
196	}
197	else
198	{
199	replacekeyvalue(kv, addressfield, addressresult);
200	replacekeyvalue(kv, netmaskfield, netmaskresult);
201	}
202	replacekeyvalue(kv, typefield, type);
203	}
204	else
205	{
206	replacekeyvalue(kv, addressfield, addressresult);
207	replacekeyvalue(kv, netmaskfield, netmaskresult);
208	}
209
210	setnetaddress(kv, colour);
211	result = 1;
212	}
213	}
214	}
215	while (error);
216
217	newtFormDestroy(networkform);
218	newtPopWindow();
219
220	return result;
221	}
222
223	/* for pppoe: return string thats type STATIC, DHCP or PPPOE */
224	int gettype(char *type)
225	{
226	newtComponent selected = newtRadioGetCurrent(statictyperadio);
227
228	if (selected == statictyperadio)
229	strcpy(type, "STATIC");
230	else if (selected == dhcptyperadio)
231	strcpy(type, "DHCP");
232	else if (selected == pppoetyperadio)
233	strcpy(type, "PPPOE");
234	else if (selected == pptptyperadio)
235	strcpy(type, "PPTP");
236	else
237	strcpy(type, "ERROR");
238
239	return 0;
240	}
241
242	/* 0.9.9: calculates broadcast too. */
243	int setnetaddress(struct keyvalue kv, char colour)
244	{
245	char addressfield[STRING_SIZE];
246	char netaddressfield[STRING_SIZE];
247	char netmaskfield[STRING_SIZE];
248	char broadcastfield[STRING_SIZE];
249	char address[STRING_SIZE];
250	char netmask[STRING_SIZE];
251	unsigned long int intaddress;
252	unsigned long int intnetaddress;
253	unsigned long int intnetmask;
254	unsigned long int intbroadcast;
255	struct in_addr temp;
256	char *netaddress;
257	char *broadcast;
258
259	/* Build some key strings. */
260	sprintf(addressfield, "%s_ADDRESS", colour);
261	sprintf(netaddressfield, "%s_NETADDRESS", colour);
262	sprintf(netmaskfield, "%s_NETMASK", colour);
263	sprintf(broadcastfield, "%s_BROADCAST", colour);
264
265	strcpy(address, ""); findkey(kv, addressfield, address);
266	strcpy(netmask, ""); findkey(kv, netmaskfield, netmask);
267
268	/* Calculate netaddress. Messy.. */
269	intaddress = inet_addr(address);
270	intnetmask = inet_addr(netmask);
271
272	intnetaddress = intaddress & intnetmask;
273	temp.s_addr = intnetaddress;
274	netaddress = inet_ntoa(temp);
275
276	replacekeyvalue(kv, netaddressfield, netaddress);
277
278	intbroadcast = intnetaddress \| ~intnetmask;
279	temp.s_addr = intbroadcast;
280	broadcast = inet_ntoa(temp);
281
282	replacekeyvalue(kv, broadcastfield, broadcast);
283
284	return 1;
285	}
286
287	/* Called when dhcp flag is toggled. Toggle disabled state of other 3
288	* controls. */
289	void networkdialogcallbacktype(newtComponent cm, void *data)
290	{
291	char type[STRING_SIZE];
292
293	gettype(type);
294
295	if (strcmp(type, "STATIC") != 0 && strcmp(type, "PPTP") != 0 )
296	{
297	newtEntrySetFlags(addressentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
298	newtEntrySetFlags(netmaskentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
299	}
300	else
301	{
302	newtEntrySetFlags(addressentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_RESET);
303	newtEntrySetFlags(netmaskentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_RESET);
304	}
305	if (strcmp(type, "DHCP") == 0)
306	newtEntrySetFlags(dhcphostnameentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_RESET);
307	else
308	newtEntrySetFlags(dhcphostnameentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
309
310	newtRefresh();
311	newtDrawForm(networkform);
312	}
313
314	int interfacecheck(struct keyvalue kv, char colour)
315	{
316	char temp[STRING_SIZE];
317	char colourfields[NETCHANGE_TOTAL][STRING_SIZE];
318	int c;
319
320	sprintf(colourfields[ADDRESS], "%s_ADDRESS", colour);
321	sprintf(colourfields[NETADDRESS], "%s_NETADDRESS", colour);
322	sprintf(colourfields[NETMASK], "%s_NETMASK", colour);
323
324	for (c = 0; c < 3; c++)
325	{
326	strcpy(temp, ""); findkey(kv, colourfields[c], temp);
327	if (!(strlen(temp))) return 0;
328	}
329	return 1;
330	}
9607771a MT	331
	332	/* Funky routine for loading all drivers (cept those are already loaded.). */
	333	int probecards(char driver, char driveroptions)
	334	{
75ae2191 MT	335	return 0;
75ae2191 MT	336	}
b4e381a8	337
5057b611	338	/* ### alter strupper ###
75ae2191 MT	339	char strupper(char s)
	340	{
	341	int n;
	342	for (n=0;s[n];n++) s[n]=toupper(s[n]);
	343	return s;
	344	}
5057b611	345	*/
b4e381a8	346
5057b611 HS	347	/* neuer StringUpper, wird zur Zeit nicht benutzt da UTF-8 nicht geht.
	348	void strupper(unsigned char *string)
	349	{
	350	unsigned char *str;
	351	for (str = string; *str != '\0'; str++)
	352	if (!(str & 0x80) && islower(str))
	353	str = toupper(str);
	354	}
	355	*/
9607771a	356
9b040aa0	357	int write_configs_netudev(char description, char macaddr, int colour)
75ae2191 MT	358	{
75ae2191 MT	359	#define UDEV_NET_CONF "/etc/udev/rules.d/30-persistent-network.rules"
75ae2191 MT	360	FILE *fp;
	361	char commandstring[STRING_SIZE];
	362	struct keyvalue *kv = initkeyvalues();
	363	char temp1[STRING_SIZE], temp2[STRING_SIZE], temp3[STRING_SIZE];
	364	char ucolour[STRING_SIZE];
5057b611 HS	365
	366	// sprintf(ucolour, colour);
	367	// strupper(ucolour);
	368
9b040aa0 HS	369	sprintf(ucolour, ucolourcard[colour]);
	370	strcpy(knics[colour].description, description);
	371	strcpy(knics[colour].macaddr, macaddr);
	372
75ae2191	373	if (!(readkeyvalues(kv, CONFIG_ROOT "/ethernet/settings")))
b4e381a8	374	{
75ae2191 MT	375	freekeyvalues(kv);
	376	errorbox(ctr[TR_UNABLE_TO_OPEN_SETTINGS_FILE]);
	377	return 0;
b4e381a8	378	}
9607771a	379
75ae2191 MT	380	sprintf(temp1, "%s_DEV", ucolour);
75ae2191 MT	381	sprintf(temp2, "%s_MACADDR", ucolour);
9b040aa0	382	sprintf(temp3, "%s0", lcolourcard[colour]);
75ae2191 MT	383	replacekeyvalue(kv, temp1, temp3);
75ae2191 MT	384	replacekeyvalue(kv, temp2, macaddr);
5057b611 HS	385	sprintf(temp1, "%s_DESCRIPTION", ucolour);
5057b611 HS	386	replacekeyvalue(kv, temp1, description);
75ae2191 MT	387
	388	writekeyvalues(kv, CONFIG_ROOT "/ethernet/settings");
	389	freekeyvalues(kv);
9607771a	390
75ae2191 MT	391	// Make sure that there is no conflict
75ae2191 MT	392	snprintf(commandstring, STRING_SIZE, "/usr/bin/touch "UDEV_NET_CONF" >/dev/null 2>&1");
5057b611 HS	393	system(commandstring);
5057b611 HS	394
9b040aa0 HS	395	// snprintf(commandstring, STRING_SIZE, "/bin/cat "UDEV_NET_CONF" \| /bin/grep -v \"%s\" > "UDEV_NET_CONF" 2>/dev/null", macaddr);
9b040aa0 HS	396	// system(commandstring);
5057b611	397
9b040aa0	398	snprintf(commandstring, STRING_SIZE, "/bin/cat "UDEV_NET_CONF" \| /bin/grep -v \"%s0\" > "UDEV_NET_CONF" 2>/dev/null", lcolourcard[colour]);
75ae2191 MT	399	system(commandstring);
	400
	401	if( (fp = fopen(UDEV_NET_CONF, "a")) == NULL )
9607771a	402	{
75ae2191 MT	403	fprintf(stderr,"Couldn't open" UDEV_NET_CONF);
75ae2191 MT	404	return 1;
9607771a	405	}
9b040aa0	406	fprintf(fp,"ACTION==\"add\", SUBSYSTEM==\"net\", SYSFS{address}==\"%s\", NAME=\"%s0\" # %s\n", macaddr, lcolourcard[colour], description);
75ae2191	407	fclose(fp);
9607771a	408
75ae2191 MT	409	return 0;
	410	}
	411
5057b611	412	int scan_network_cards(void)
75ae2191	413	{
5057b611 HS	414	FILE *fp;
	415	char description[STRING_SIZE], macaddr[STRING_SIZE], temp_line[STRING_SIZE];
	416	int count = 0;
	417
	418	if (!(scanned_nics_read_done))
	419	{
	420	fprintf(flog,"Enter scan_network_cards\n"); // #### Debug ####
	421	mysystem("/bin/probenic.sh");
	422	// Read our scanned nics
	423	if( (fp = fopen(SCANNED_NICS, "r")) == NULL )
	424	{
	425	fprintf(stderr,"Couldn't open "SCANNED_NICS);
	426	return 1;
	427	}
	428	while (fgets(temp_line, STRING_SIZE, fp) != NULL)
	429	{
	430	strcpy(description, strtok(temp_line,";"));
	431	strcpy(macaddr, strtok(NULL,";"));
	432	if ( strlen(macaddr) ) {
	433	strcpy(nics[count].description , description );
	434	strcpy(nics[count].macaddr , macaddr );
	435	count++;
75ae2191	436	}
5057b611 HS	437	}
5057b611 HS	438	fclose(fp);
9b040aa0 HS	439	scanned_nics_read_done = count;
	440	} else fprintf(flog,"Scan Networkcards does read.\n");
	441	return scanned_nics_read_done;
5057b611	442	}
75ae2191	443
5057b611 HS	444
5057b611 HS	445
9b040aa0	446	int nicmenu(int colour)
5057b611 HS	447	{
	448	int rc, choise = 0, count = 0, kcount = 0, mcount = 0, i, j, nic_in_use;
	449	int found_NIC_as_Card[4];
	450	char message[STRING_SIZE];
	451
	452	char cMenuInhalt[STRING_SIZE];
	453	char MenuInhalt[20][180];
	454	char *pMenuInhalt[20];
	455
	456	// strcpy( message , pnics[count].macaddr);
	457	// while (strcmp(message, "")) {
	458	// count++;
	459	// strcpy( message , pnics[count].macaddr);
	460	// }
	461
	462	while (strcmp(nics[count].macaddr, "")) count++; // 2 find how many nics in system
	463	for ( i=0 ; i<4;i++) if (strcmp(knics[i].macaddr, "")) kcount++; // loop to find all knowing nics
	464	fprintf(flog, "Enter NicMenu\n"); // #### Debug ####
	465	fprintf(flog, "count nics %i\ncount knics %i\n", count, kcount); // #### Debug ####
	466
	467	// If new nics are found...
	468	if (count > kcount) {
	469	for (i=0 ; i < count ; i++)
	470	{
	471	nic_in_use = 0;
	472	for (j=0 ; j <= kcount ; j++) {
	473	if (strcmp(nics[ i ].macaddr, knics[ j ].macaddr) == 0 ) {
	474	nic_in_use = 1;
	475	fprintf(flog,"NIC \"%s\" is in use.\n", nics[ i ].macaddr); // #### Debug ####
	476	break;
9607771a	477	}
9607771a	478	}
5057b611 HS	479	if (!(nic_in_use)) {
	480	fprintf(flog,"NIC \"%s\" is free.\n", nics[ i ].macaddr); // #### Debug ####
	481	if ( strlen(nics[i].description) < 55 )
	482	sprintf(MenuInhalt[mcount], "%.*s", strlen(nics[i].description)-2, nics[i].description+1);
	483	else {
	484	sprintf(cMenuInhalt, "%.50s", nics[i].description + 1);
	485	strncpy(MenuInhalt[mcount], cMenuInhalt,(strrchr(cMenuInhalt,' ') - cMenuInhalt));
	486	strcat (MenuInhalt[mcount], "...");
75ae2191	487	}
9607771a	488
5057b611 HS	489	while ( strlen(MenuInhalt[mcount]) < 50) strcat(MenuInhalt[mcount], " "); // Fill with space.
	490
	491	strcat(MenuInhalt[mcount], " (");
	492	strcat(MenuInhalt[mcount], nics[i].macaddr);
	493	strcat(MenuInhalt[mcount], ")");
	494	pMenuInhalt[mcount] = MenuInhalt[mcount];
	495	found_NIC_as_Card[mcount]=i;
	496	mcount++;
	497	}
75ae2191	498	}
5057b611 HS	499
	500	pMenuInhalt[mcount] = NULL;
	501
	502	// sprintf(message, "Es wurde(n) %d freie Netzwerkkarte(n) in Ihrem System gefunden.\nBitte waehlen Sie im naechsten Dialog eine davon aus.\n", count);
	503	// newtWinMessage("NetcardMenu", ctr[TR_OK], message);
	504
9b040aa0	505	sprintf(message, "(TR) Bitte wählen Sie eine der untenstehenden Netzwerkkarten fuer die Schnittstelle \"%s\" aus.\n", ucolourcard[colour]);
5057b611 HS	506	rc = newtWinMenu("(TR) NetcardMenu2", message, 50, 5, 5, 6, pMenuInhalt, &choise, ctr[TR_OK], ctr[TR_SELECT], ctr[TR_CANCEL], NULL);
	507
	508	if ( rc == 0 \|\| rc == 1) {
	509	write_configs_netudev(nics[choise].description, nics[found_NIC_as_Card[choise]].macaddr, colour);
	510	} else if (rc == 2) {
	511	// manualdriver("pcnet32","");
	512	}
	513	return 0;
	514	} else {
	515	// We have to add here that you can manually add a device
	516	errorbox("(TR) Es wurden leider keine freien Netzwerkkarten fuer die Schnittstelle in ihrem System gefunden.");
	517	return 1;
	518	}
	519	}
	520
9b040aa0	521	int clear_card_entry(int card)
5057b611 HS	522	{
5057b611 HS	523	struct keyvalue *kv = initkeyvalues();
9b040aa0	524	char temp[STRING_SIZE];
5057b611	525
5057b611 HS	526	if (!(readkeyvalues(kv, CONFIG_ROOT "/ethernet/settings")))
	527	{
	528	freekeyvalues(kv);
	529	errorbox(ctr[TR_UNABLE_TO_OPEN_SETTINGS_FILE]);
	530	return 0;
	531	}
	532
9b040aa0 HS	533	strcpy(knics[card].description, ctr[TR_UNSET]);
	534	strcpy(knics[card].macaddr, "");
	535	strcpy(knics[card].colour, "");
	536	sprintf(temp, "%s_DEV", ucolourcard[card]);
	537	replacekeyvalue(kv, temp, "");
	538	sprintf(temp, "%s_MACADDR", ucolourcard[card]);
	539	replacekeyvalue(kv, temp, "");
	540	sprintf(temp, "%s_DESCRIPTION", ucolourcard[card]);
	541	replacekeyvalue(kv, temp, "");
	542
	543	writekeyvalues(kv, CONFIG_ROOT "/ethernet/settings");
	544	freekeyvalues(kv);
	545
	546	fprintf(flog,"Card \"%s\" cleared\n",ucolourcard[card]); // #### Debug ####
	547	return 0;
	548	}
	549
	550	int ask_clear_card_entry(int card)
	551	{
	552	char message[STRING_SIZE];
	553	int rc;
5057b611	554
9b040aa0	555	sprintf(message, "(TR) Soll die Zuordnung der Netzwerkkarte \"%s\" entfernt werden ?\n", ucolourcard[card]);
5057b611 HS	556	rc = newtWinChoice(ctr[TR_WARNING], ctr[TR_OK], ctr[TR_CANCEL], message);
	557
	558	if ( rc = 0 \|\| rc == 1) {
9b040aa0 HS	559	clear_card_entry(card);
	560	// sprintf(temp1, "%s_DEV", ucolour);
	561	// sprintf(temp2, "%s_MACADDR", ucolour);
	562	// replacekeyvalue(kv, temp1, "");
	563	// replacekeyvalue(kv, temp2, "");
	564	// sprintf(temp1, "%s_DESCRIPTION", ucolour);
	565	// replacekeyvalue(kv, temp1, "");
	566
	567	// writekeyvalues(kv, CONFIG_ROOT "/ethernet/settings");
5057b611 HS	568	} else return 1;
5057b611 HS	569
5057b611	570	return 0;
9607771a MT	571	}
	572
	573	/* Manual entry for gurus. */
	574	int manualdriver(char driver, char driveroptions)
	575	{
	576	char values[] = { NULL, NULL }; / pointers for the values. */
	577	struct newtWinEntry entries[] =
	578	{ { "", &values[0], 0,}, { NULL, NULL, 0 } };
	579	int rc;
	580	char commandstring[STRING_SIZE];
	581	char *driverend;
	582
	583	strcpy(driver, "");
	584	strcpy(driveroptions, "");
	585
	586	rc = newtWinEntries(ctr[TR_SELECT_NETWORK_DRIVER],
	587	ctr[TR_MODULE_PARAMETERS], 50, 5, 5, 40, entries,
	588	ctr[TR_OK], ctr[TR_CANCEL], NULL);
	589	if (rc == 0 \|\| rc == 1)
	590	{
	591	if (strlen(values[0]))
	592	{
	593	sprintf(commandstring, "/sbin/modprobe %s", values[0]);
	594	if (runcommandwithstatus(commandstring, ctr[TR_LOADING_MODULE]) == 0)
	595	{
	596	if ((driverend = strchr(values[0], ' ')))
	597	{
	598	*driverend = '\0';
	599	strcpy(driver, values[0]);
	600	strcpy(driveroptions, driverend + 1);
	601	}
	602	else
	603	{
	604	strcpy(driver, values[0]);
	605	strcpy(driveroptions, "");
	606	}
	607	}
	608	else
	609	errorbox(ctr[TR_UNABLE_TO_LOAD_DRIVER_MODULE]);
	610	}
	611	else
	612	errorbox(ctr[TR_MODULE_NAME_CANNOT_BE_BLANK]);
	613	}
	614	free(values[0]);
	615
	616	return 1;
	617	}