src/install+setup/libsmooth/netstuff.c

   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  *
   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
  19 extern struct nic nics[];
  20 extern struct knic knics[];
  21
  22 char *ucolourcard[] = { "GREEN", "RED", "ORANGE", "BLUE", NULL };
  23 char *lcolourcard[] = { "green", "red", "orange", "blue", NULL };
  24
  25 int scanned_nics_read_done = 0;
  26
  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 }
 331
 332 /* Funky routine for loading all drivers (cept those are already loaded.). */
 333 int probecards(char *driver, char *driveroptions )
 334 {
 335         return 0;
 336 }
 337
 338 /* ### alter strupper ###
 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 }
 345 */
 346
 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 */
 356
 357 int write_configs_netudev(int card , int colour)
 358 {
 359         #define UDEV_NET_CONF "/etc/udev/rules.d/30-persistent-network.rules"
 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];
 365
 366 //      sprintf(ucolour, colour);
 367 //      strupper(ucolour);
 368
 369         sprintf(ucolour, ucolourcard[colour]);
 370         strcpy(knics[colour].driver, nics[card].driver);
 371         strcpy(knics[colour].description, nics[card].description);
 372         strcpy(knics[colour].macaddr, nics[card].macaddr);
 373
 374         if (!(readkeyvalues(kv, CONFIG_ROOT "/ethernet/settings")))
 375         {
 376                 freekeyvalues(kv);
 377                 errorbox(ctr[TR_UNABLE_TO_OPEN_SETTINGS_FILE]);
 378                 return 0;
 379         }
 380
 381         sprintf(temp1, "%s_DEV", ucolour);
 382         sprintf(temp2, "%s_MACADDR", ucolour);
 383         sprintf(temp3, "%s0", lcolourcard[colour]);
 384         replacekeyvalue(kv, temp1, temp3);
 385         replacekeyvalue(kv, temp2, nics[card].macaddr);
 386         sprintf(temp1, "%s_DESCRIPTION", ucolour);
 387         replacekeyvalue(kv, temp1, nics[card].description);
 388         sprintf(temp1, "%s_DRIVER", ucolour);
 389         replacekeyvalue(kv, temp1, nics[card].driver);
 390
 391         writekeyvalues(kv, CONFIG_ROOT "/ethernet/settings");
 392         freekeyvalues(kv);
 393
 394         // Make sure that there is no conflict
 395         snprintf(commandstring, STRING_SIZE, "/usr/bin/touch "UDEV_NET_CONF" >/dev/null 2>&1");
 396         system(commandstring);
 397
 398 //      snprintf(commandstring, STRING_SIZE, "/bin/cat "UDEV_NET_CONF" | /bin/grep -v \"%s\" > "UDEV_NET_CONF" 2>/dev/null", macaddr);
 399 //      system(commandstring);
 400
 401         snprintf(commandstring, STRING_SIZE, "/bin/cat "UDEV_NET_CONF" | /bin/grep -v \"%s0\" > "UDEV_NET_CONF" 2>/dev/null", lcolourcard[colour]);
 402         system(commandstring);
 403
 404         if( (fp = fopen(UDEV_NET_CONF, "a")) == NULL )
 405         {
 406                 fprintf(stderr,"Couldn't open" UDEV_NET_CONF);
 407                 return 1;
 408         }
 409         fprintf(fp,"ACTION==\"add\", SUBSYSTEM==\"net\", SYSFS{address}==\"%s\", NAME=\"%s0\" # %s\n", nics[card].macaddr, lcolourcard[colour], nics[card].description);
 410         fclose(fp);
 411
 412         return 0;
 413 }
 414
 415 int scan_network_cards(void)
 416 {
 417         FILE *fp;
 418         char driver[STRING_SIZE], description[STRING_SIZE], macaddr[STRING_SIZE], temp_line[STRING_SIZE];
 419         int count = 0;
 420
 421         if (!(scanned_nics_read_done))
 422         {
 423                 fprintf(flog,"Enter scan_network_cards\n"); // #### Debug ####
 424                 mysystem("/bin/probenic.sh");
 425                 // Read our scanned nics
 426                 if( (fp = fopen(SCANNED_NICS, "r")) == NULL )
 427                 {
 428                         fprintf(stderr,"Couldn't open "SCANNED_NICS);
 429                         return 1;
 430                 }
 431                 while (fgets(temp_line, STRING_SIZE, fp) != NULL)
 432                 {
 433                         strcpy(driver,      strtok(temp_line,";"));
 434                         strcpy(description, strtok(NULL,";"));
 435                         strcpy(macaddr,     strtok(NULL,";"));
 436                         if ( strlen(macaddr) ) {
 437                                 strcpy(nics[count].driver      , driver );
 438                                 strcpy(nics[count].description , description );
 439                                 strcpy(nics[count].macaddr     , macaddr );
 440                                 count++;
 441                         }
 442                 }
 443                 fclose(fp);
 444                 scanned_nics_read_done = count;
 445         } else fprintf(flog,"Scan Networkcards does read.\n");
 446         return scanned_nics_read_done;
 447 }
 448
 449
 450
 451 int nicmenu(int colour)
 452 {
 453         int rc, choise = 0, count = 0, kcount = 0, mcount = 0, i, j, nic_in_use;
 454         int found_NIC_as_Card[4];
 455         char message[STRING_SIZE];
 456
 457         char cMenuInhalt[STRING_SIZE];
 458         char MenuInhalt[20][180];
 459         char *pMenuInhalt[20];
 460
 461 //      strcpy( message , pnics[count].macaddr);
 462 //      while (strcmp(message, "")) {
 463 //              count++;
 464 //              strcpy( message , pnics[count].macaddr);
 465 //      }
 466
 467         while (strcmp(nics[count].macaddr, "")) count++;                        // 2 find how many nics in system
 468         for ( i=0 ; i<4;i++) if (strcmp(knics[i].macaddr, "")) kcount++;        // loop to find all knowing nics
 469         fprintf(flog, "Enter NicMenu\n");                                       // #### Debug ####
 470         fprintf(flog, "count nics %i\ncount knics %i\n", count, kcount);        // #### Debug ####
 471
 472         // If new nics are found...
 473         if (count > kcount) {
 474                 for (i=0 ; i < count ; i++)
 475                 {
 476                         nic_in_use = 0;
 477                         for (j=0 ; j <= kcount ; j++) {
 478                                 if (strcmp(nics[ i ].macaddr, knics[ j ].macaddr) == 0 ) {
 479                                         nic_in_use = 1;
 480                                         fprintf(flog,"NIC \"%s\" is in use.\n", nics[ i ].macaddr); // #### Debug ####
 481                                         break;
 482                                 }
 483                         }
 484                         if (!(nic_in_use)) {
 485                                 fprintf(flog,"NIC \"%s\" is free.\n", nics[ i ].macaddr); // #### Debug ####
 486                                 if ( strlen(nics[i].description) < 55 )
 487                                         sprintf(MenuInhalt[mcount], "%.*s",  strlen(nics[i].description)-2, nics[i].description+1);
 488                                 else {
 489                                         sprintf(cMenuInhalt, "%.50s", nics[i].description + 1);
 490                                         strncpy(MenuInhalt[mcount], cMenuInhalt,(strrchr(cMenuInhalt,' ') - cMenuInhalt));
 491                                         strcat (MenuInhalt[mcount], "...");
 492                                 }
 493
 494                                 while ( strlen(MenuInhalt[mcount]) < 50) strcat(MenuInhalt[mcount], " "); // Fill with space.
 495
 496                                 strcat(MenuInhalt[mcount], " (");
 497                                 strcat(MenuInhalt[mcount], nics[i].macaddr);
 498                                 strcat(MenuInhalt[mcount], ")");
 499                                 pMenuInhalt[mcount] = MenuInhalt[mcount];
 500                                 found_NIC_as_Card[mcount]=i;
 501                                 mcount++;
 502                         }
 503                 }
 504
 505                 pMenuInhalt[mcount] = NULL;
 506
 507 //              sprintf(message, "Es wurde(n) %d freie Netzwerkkarte(n) in Ihrem System gefunden.\nBitte waehlen Sie im naechsten Dialog eine davon aus.\n", count);
 508 //              newtWinMessage("NetcardMenu", ctr[TR_OK], message);
 509
 510                 sprintf(message, "(TR) Bitte wählen Sie eine der untenstehenden Netzwerkkarten fuer die Schnittstelle \"%s\" aus.\n", ucolourcard[colour]);
 511                 rc = newtWinMenu("(TR) NetcardMenu2", message, 50, 5, 5, 6, pMenuInhalt, &choise, ctr[TR_OK], ctr[TR_SELECT], ctr[TR_CANCEL], NULL);
 512
 513                 if ( rc == 0 || rc == 1) {
 514                         write_configs_netudev(found_NIC_as_Card[choise], colour);
 515                 } else if (rc == 2) {
 516 //                      manualdriver("pcnet32","");
 517                 }
 518                 return 0;
 519         } else {
 520                 // We have to add here that you can manually add a device
 521                 errorbox("(TR) Es wurden leider keine freien Netzwerkkarten fuer die Schnittstelle in ihrem System gefunden.");
 522                 return 1;
 523         }
 524 }
 525
 526 int clear_card_entry(int card)
 527 {
 528         struct keyvalue *kv = initkeyvalues();
 529         char temp[STRING_SIZE];
 530
 531         if (!(readkeyvalues(kv, CONFIG_ROOT "/ethernet/settings")))
 532         {
 533                 freekeyvalues(kv);
 534                 errorbox(ctr[TR_UNABLE_TO_OPEN_SETTINGS_FILE]);
 535                 return 0;
 536         }
 537
 538         strcpy(knics[card].driver, "");
 539         strcpy(knics[card].description, ctr[TR_UNSET]);
 540         strcpy(knics[card].macaddr, "");
 541         strcpy(knics[card].colour, "");
 542         sprintf(temp, "%s_DRIVER", ucolourcard[card]);
 543         replacekeyvalue(kv, temp, "");
 544         sprintf(temp, "%s_DEV", ucolourcard[card]);
 545         replacekeyvalue(kv, temp, "");
 546         sprintf(temp, "%s_MACADDR", ucolourcard[card]);
 547         replacekeyvalue(kv, temp, "");
 548         sprintf(temp, "%s_DESCRIPTION", ucolourcard[card]);
 549         replacekeyvalue(kv, temp, "");
 550
 551         writekeyvalues(kv, CONFIG_ROOT "/ethernet/settings");
 552         freekeyvalues(kv);
 553
 554         fprintf(flog,"Card \"%s\" cleared\n",ucolourcard[card]); // #### Debug ####
 555         return 0;
 556 }
 557
 558 int ask_clear_card_entry(int card)
 559 {
 560         char message[STRING_SIZE];
 561         int rc;
 562
 563         sprintf(message, "(TR) Soll die Zuordnung der Netzwerkkarte \"%s\" entfernt werden ?\n", ucolourcard[card]);
 564         rc = newtWinChoice(ctr[TR_WARNING], ctr[TR_OK], ctr[TR_CANCEL], message);
 565
 566         if ( rc = 0 || rc == 1) {
 567                 clear_card_entry(card);
 568 //              sprintf(temp1, "%s_DEV", ucolour);
 569 //              sprintf(temp2, "%s_MACADDR", ucolour);
 570 //              replacekeyvalue(kv, temp1, "");
 571 //              replacekeyvalue(kv, temp2, "");
 572 //              sprintf(temp1, "%s_DESCRIPTION", ucolour);
 573 //              replacekeyvalue(kv, temp1, "");
 574
 575 //              writekeyvalues(kv, CONFIG_ROOT "/ethernet/settings");
 576         } else return 1;
 577
 578         return 0;
 579 }
 580
 581 /* Manual entry for gurus. */
 582 int manualdriver(char *driver, char *driveroptions)
 583 {
 584         char *values[] = { NULL, NULL };        /* pointers for the values. */
 585         struct newtWinEntry entries[] =
 586                 { { "", &values[0], 0,}, { NULL, NULL, 0 } };
 587         int rc;
 588         char commandstring[STRING_SIZE];
 589         char *driverend;
 590
 591         strcpy(driver, "");
 592         strcpy(driveroptions, "");
 593
 594         rc = newtWinEntries(ctr[TR_SELECT_NETWORK_DRIVER],
 595                 ctr[TR_MODULE_PARAMETERS], 50, 5, 5, 40, entries,
 596                 ctr[TR_OK], ctr[TR_CANCEL], NULL);
 597         if (rc == 0 || rc == 1)
 598         {
 599                 if (strlen(values[0]))
 600                 {
 601                         sprintf(commandstring, "/sbin/modprobe %s", values[0]);
 602                         if (runcommandwithstatus(commandstring, ctr[TR_LOADING_MODULE]) == 0)
 603                         {
 604                                 if ((driverend = strchr(values[0], ' ')))
 605                                 {
 606                                         *driverend = '\0';
 607                                         strcpy(driver, values[0]);
 608                                         strcpy(driveroptions, driverend + 1);
 609                                 }
 610                                 else
 611                                 {
 612                                         strcpy(driver, values[0]);
 613                                         strcpy(driveroptions, "");
 614                                 }
 615                         }
 616                         else
 617                                 errorbox(ctr[TR_UNABLE_TO_LOAD_DRIVER_MODULE]);
 618                 }
 619                 else
 620                         errorbox(ctr[TR_MODULE_NAME_CANNOT_BE_BLANK]);
 621         }
 622         free(values[0]);
 623
 624         return 1;
 625 }