src/setup/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 // Translation
  15 #include <libintl.h>
  16 #define _(x) dgettext("setup", x)
  17
  18 #include "setup.h"
  19
  20 extern FILE *flog;
  21 extern char *mylog;
  22
  23 extern struct nic nics[];
  24 extern struct knic knics[];
  25
  26 char *ucolourcard[] = { "GREEN", "RED", "ORANGE", "BLUE", NULL };
  27 char *lcolourcard[] = { "green", "red", "orange", "blue", NULL };
  28
  29 int scanned_nics_read_done = 0;
  30
  31 newtComponent networkform;
  32 newtComponent addressentry;
  33 newtComponent netmaskentry;
  34 newtComponent statictyperadio;
  35 newtComponent dhcptyperadio;
  36 newtComponent pppoetyperadio;
  37 newtComponent dhcphostnameentry;
  38 newtComponent dhcpforcemtuentry;
  39
  40 /* acceptable character filter for IP and netmaks entry boxes */
  41 static int ip_input_filter(newtComponent entry, void * data, int ch, int cursor)
  42 {
  43         if ((ch >= '0' && ch <= '9') || ch == '.' || ch == '\r' || ch >= NEWT_KEY_EXTRA_BASE)
  44                 return ch;
  45         return 0;
  46 }
  47
  48 /* This is a groovie dialog for showing network info.  Takes a keyvalue list,
  49  * a colour and a dhcp flag.  Shows the current settings, and rewrites them
  50  * if necessary.  DHCP flag sets wether to show the dhcp checkbox. */
  51 int changeaddress(struct keyvalue *kv, char *colour, int typeflag,
  52         char *defaultdhcphostname)
  53 {
  54         char *addressresult;
  55         char *netmaskresult;
  56         char *dhcphostnameresult;
  57         char *dhcpforcemturesult;
  58         struct newtExitStruct es;
  59         newtComponent header;
  60         newtComponent addresslabel;
  61         newtComponent netmasklabel;
  62         newtComponent dhcphostnamelabel;
  63         newtComponent dhcpforcemtulabel;
  64         newtComponent ok, cancel;
  65         char message[1000];
  66         char temp[STRING_SIZE];
  67         char addressfield[STRING_SIZE];
  68         char netmaskfield[STRING_SIZE];
  69         char typefield[STRING_SIZE];
  70         char dhcphostnamefield[STRING_SIZE];
  71         char dhcpforcemtufield[STRING_SIZE];
  72         int error;
  73         int result = 0;
  74         char type[STRING_SIZE];
  75         int startstatictype = 0;
  76         int startdhcptype = 0;
  77         int startpppoetype = 0;
  78
  79         /* Build some key strings. */
  80         sprintf(addressfield, "%s_ADDRESS", colour);
  81         sprintf(netmaskfield, "%s_NETMASK", colour);
  82         sprintf(typefield, "%s_TYPE", colour);
  83         sprintf(dhcphostnamefield, "%s_DHCP_HOSTNAME", colour);
  84         sprintf(dhcpforcemtufield, "%s_DHCP_FORCE_MTU", colour);
  85
  86         sprintf(message, _("Interface - %s"), colour);
  87         newtCenteredWindow(44, (typeflag ? 18 : 12), message);
  88
  89         networkform = newtForm(NULL, NULL, 0);
  90
  91         sprintf(message, _("Enter the IP address information for the %s interface."), colour);
  92         header = newtTextboxReflowed(1, 1, message, 42, 0, 0, 0);
  93         newtFormAddComponent(networkform, header);
  94
  95         /* See if we need a dhcp checkbox.  If we do, then we shift the contents
  96          * of the window down two rows to make room. */
  97         if (typeflag)
  98         {
  99                 strcpy(temp, "STATIC"); findkey(kv, typefield, temp);
 100                 if (strcmp(temp, "STATIC") == 0) startstatictype = 1;
 101                 if (strcmp(temp, "DHCP") == 0) startdhcptype = 1;
 102                 if (strcmp(temp, "PPPOE") == 0) startpppoetype = 1;
 103                 statictyperadio = newtRadiobutton(2, 4, _("Static"), startstatictype, NULL);
 104                 dhcptyperadio = newtRadiobutton(2, 5, _("DHCP"), startdhcptype, statictyperadio);
 105                 pppoetyperadio = newtRadiobutton(2, 6, _("PPP DIALUP (PPPoE, modem, ATM ...)"),
 106                         startpppoetype, dhcptyperadio);
 107                 newtFormAddComponents(networkform, statictyperadio, dhcptyperadio,
 108                         pppoetyperadio, NULL);
 109                 newtComponentAddCallback(statictyperadio, networkdialogcallbacktype, NULL);
 110                 newtComponentAddCallback(dhcptyperadio, networkdialogcallbacktype, NULL);
 111                 newtComponentAddCallback(pppoetyperadio, networkdialogcallbacktype, NULL);
 112                 dhcphostnamelabel = newtTextbox(2, 8, 18, 1, 0);
 113                 newtTextboxSetText(dhcphostnamelabel, _("DHCP Hostname:"));
 114                 dhcpforcemtulabel = newtTextbox(2, 9, 18, 1, 0);
 115                 newtTextboxSetText(dhcpforcemtulabel, _("Force DHCP MTU:"));
 116                 strcpy(temp, defaultdhcphostname);
 117                 findkey(kv, dhcphostnamefield, temp);
 118                 dhcphostnameentry = newtEntry(20, 8, temp, 20, &dhcphostnameresult, 0);
 119                 strcpy(temp, "");
 120                 findkey(kv, dhcpforcemtufield, temp);
 121                 dhcpforcemtuentry = newtEntry(20, 9, temp, 20, &dhcpforcemturesult, 0);
 122                 newtFormAddComponent(networkform, dhcphostnamelabel);
 123                 newtFormAddComponent(networkform, dhcphostnameentry);
 124                 newtFormAddComponent(networkform, dhcpforcemtulabel);
 125                 newtFormAddComponent(networkform, dhcpforcemtuentry);
 126                 if (startdhcptype == 0)
 127                         {
 128                                 newtEntrySetFlags(dhcphostnameentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
 129                                 newtEntrySetFlags(dhcpforcemtuentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
 130                         }
 131         }
 132         /* Address */
 133         addresslabel = newtTextbox(2, (typeflag ? 11 : 4) + 0, 18, 1, 0);
 134         newtTextboxSetText(addresslabel, _("IP address:"));
 135         strcpy(temp, "");
 136         findkey(kv, addressfield, temp);
 137         addressentry = newtEntry(20, (typeflag ? 11 : 4) + 0, temp, 20, &addressresult, 0);
 138         newtEntrySetFilter(addressentry, ip_input_filter, NULL);
 139         if (typeflag == 1 && startstatictype == 0)
 140                 newtEntrySetFlags(addressentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
 141         newtFormAddComponent(networkform, addresslabel);
 142         newtFormAddComponent(networkform, addressentry);
 143
 144         /* Netmask */
 145         netmasklabel = newtTextbox(2, (typeflag ? 11 : 4) + 1, 18, 1, 0);
 146         newtTextboxSetText(netmasklabel, _("Network mask:"));
 147         strcpy(temp, "255.255.255.0"); findkey(kv, netmaskfield, temp);
 148         netmaskentry = newtEntry(20, (typeflag ? 11 : 4) + 1, temp, 20, &netmaskresult, 0);
 149         newtEntrySetFilter(netmaskentry, ip_input_filter, NULL);
 150         if (typeflag == 1 && startstatictype == 0)
 151                 newtEntrySetFlags(netmaskentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
 152
 153         newtFormAddComponent(networkform, netmasklabel);
 154         newtFormAddComponent(networkform, netmaskentry);
 155
 156         /* Buttons. */
 157         ok = newtButton(8, (typeflag ? 14 : 7), _("OK"));
 158         cancel = newtButton(26, (typeflag ? 14 : 7), _("Cancel"));
 159
 160         newtFormAddComponents(networkform, ok, cancel, NULL);
 161
 162         newtRefresh();
 163         newtDrawForm(networkform);
 164
 165         do
 166         {
 167                 error = 0;
 168                 newtFormRun(networkform, &es);
 169
 170                 if (es.u.co == ok)
 171                 {
 172                         /* OK was pressed; verify the contents of each entry. */
 173                         strcpy(message, _("The following fields are invalid:"));
 174                         strcat(message, "\n\n");
 175
 176                         strcpy(type, "STATIC");
 177                         if (typeflag)
 178                                 gettype(type);
 179                         if (strcmp(type, "STATIC") == 0)
 180                         {
 181                                 if (inet_addr(addressresult) == INADDR_NONE)
 182                                 {
 183                                         strcat(message, _("IP address"));
 184                                         strcat(message, "\n");
 185                                         error = 1;
 186                                 }
 187                                 if (inet_addr(netmaskresult) == INADDR_NONE)
 188                                 {
 189                                         strcat(message, _("Network mask"));
 190                                         strcat(message, "\n");
 191                                         error = 1;
 192                                 }
 193                         }
 194                         if (strcmp(type, "DHCP") == 0)
 195                         {
 196                                 if (!strlen(dhcphostnameresult))
 197                                 {
 198                                         strcat(message, _("DHCP hostname"));
 199                                         strcat(message, "\n");
 200                                         error = 1;
 201                                 }
 202                         }
 203                         if (error)
 204                                 errorbox(message);
 205                         else
 206                         {
 207                                 /* No errors!  Set new values, depending on dhcp flag etc. */
 208                                 if (typeflag)
 209                                 {
 210                                         replacekeyvalue(kv, dhcphostnamefield, dhcphostnameresult);
 211                                         replacekeyvalue(kv, dhcpforcemtufield, dhcpforcemturesult);
 212                                         if (strcmp(type, "STATIC") != 0)
 213                                         {
 214                                                 replacekeyvalue(kv, addressfield, "0.0.0.0");
 215                                                 replacekeyvalue(kv, netmaskfield, "0.0.0.0");
 216                                         }
 217                                         else
 218                                         {
 219                                                 replacekeyvalue(kv, addressfield, addressresult);
 220                                                 replacekeyvalue(kv, netmaskfield, netmaskresult);
 221                                         }
 222                                         replacekeyvalue(kv, typefield, type);
 223                                 }
 224                                 else
 225                                 {
 226                                         replacekeyvalue(kv, addressfield, addressresult);
 227                                         replacekeyvalue(kv, netmaskfield, netmaskresult);
 228                                 }
 229
 230                                 setnetaddress(kv, colour);
 231                                 result = 1;
 232                         }
 233                 }
 234                 /* Workaround for a bug that dhcp radiobutton also end the dialog at arm
 235                 */
 236                 else {
 237                         if (es.u.co != cancel) {
 238                                 error = 1;
 239                         }
 240                 }
 241         }
 242         while (error);
 243
 244         newtFormDestroy(networkform);
 245         newtPopWindow();
 246
 247         return result;
 248 }
 249
 250 /* for pppoe: return string thats type STATIC, DHCP or PPPOE */
 251 int gettype(char *type)
 252 {
 253         newtComponent selected = newtRadioGetCurrent(statictyperadio);
 254
 255         if (selected == statictyperadio)
 256                 strcpy(type, "STATIC");
 257         else if (selected == dhcptyperadio)
 258                 strcpy(type, "DHCP");
 259         else if (selected == pppoetyperadio)
 260                 strcpy(type, "PPPOE");
 261         else
 262                 strcpy(type, "ERROR");
 263
 264         return 0;
 265 }
 266
 267 /* 0.9.9: calculates broadcast too. */
 268 int setnetaddress(struct keyvalue *kv, char *colour)
 269 {
 270         char addressfield[STRING_SIZE];
 271         char netaddressfield[STRING_SIZE];
 272         char netmaskfield[STRING_SIZE];
 273         char broadcastfield[STRING_SIZE];
 274         char address[STRING_SIZE];
 275         char netmask[STRING_SIZE];
 276         unsigned long int intaddress;
 277         unsigned long int intnetaddress;
 278         unsigned long int intnetmask;
 279         unsigned long int intbroadcast;
 280         struct in_addr temp;
 281         char *netaddress;
 282         char *broadcast;
 283
 284         /* Build some key strings. */
 285         sprintf(addressfield, "%s_ADDRESS", colour);
 286         sprintf(netaddressfield, "%s_NETADDRESS", colour);
 287         sprintf(netmaskfield, "%s_NETMASK", colour);
 288         sprintf(broadcastfield, "%s_BROADCAST", colour);
 289
 290         strcpy(address, ""); findkey(kv, addressfield, address);
 291         strcpy(netmask, ""); findkey(kv, netmaskfield, netmask);
 292
 293         /* Calculate netaddress. Messy.. */
 294         intaddress = inet_addr(address);
 295         intnetmask = inet_addr(netmask);
 296
 297         intnetaddress = intaddress & intnetmask;
 298         temp.s_addr = intnetaddress;
 299         netaddress = inet_ntoa(temp);
 300
 301         replacekeyvalue(kv, netaddressfield, netaddress);
 302
 303         intbroadcast = intnetaddress | ~intnetmask;
 304         temp.s_addr = intbroadcast;
 305         broadcast = inet_ntoa(temp);
 306
 307         replacekeyvalue(kv, broadcastfield, broadcast);
 308
 309         return 1;
 310 }
 311
 312 /* Called when dhcp flag is toggled.  Toggle disabled state of other 3
 313  * controls. */
 314 void networkdialogcallbacktype(newtComponent cm, void *data)
 315 {
 316         char type[STRING_SIZE];
 317
 318         gettype(type);
 319
 320         if (strcmp(type, "STATIC") != 0)
 321         {
 322                 newtEntrySetFlags(addressentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
 323                 newtEntrySetFlags(netmaskentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
 324         }
 325         else
 326         {
 327                 newtEntrySetFlags(addressentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_RESET);
 328                 newtEntrySetFlags(netmaskentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_RESET);
 329         }
 330         if (strcmp(type, "DHCP") == 0)
 331         {
 332                 newtEntrySetFlags(dhcphostnameentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_RESET);
 333                 newtEntrySetFlags(dhcpforcemtuentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_RESET);
 334         }
 335         else
 336         {
 337                 newtEntrySetFlags(dhcphostnameentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
 338                 newtEntrySetFlags(dhcpforcemtuentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
 339         }
 340         newtRefresh();
 341         newtDrawForm(networkform);
 342 }
 343
 344 int interfacecheck(struct keyvalue *kv, char *colour)
 345 {
 346         char temp[STRING_SIZE];
 347         char colourfields[NETCHANGE_TOTAL][STRING_SIZE];
 348         int c;
 349
 350         sprintf(colourfields[ADDRESS], "%s_ADDRESS", colour);
 351         sprintf(colourfields[NETADDRESS], "%s_NETADDRESS", colour);
 352         sprintf(colourfields[NETMASK], "%s_NETMASK", colour);
 353
 354         for (c = 0; c < 3; c++)
 355         {
 356                 strcpy(temp, ""); findkey(kv, colourfields[c], temp);
 357                 if (!(strlen(temp))) return 0;
 358         }
 359         return 1;
 360 }
 361
 362 /* Funky routine for loading all drivers (cept those are already loaded.). */
 363 int probecards(char *driver, char *driveroptions )
 364 {
 365         return 0;
 366 }
 367
 368 int get_knic(int card)          //returns "0" for zero cards or error and "1" card is found.
 369 {
 370         struct keyvalue *kv = initkeyvalues();
 371         char temp[STRING_SIZE], searchstr[STRING_SIZE];
 372         int ret_value;
 373
 374         if (!(readkeyvalues(kv, CONFIG_ROOT "/ethernet/settings")))
 375         {
 376                 freekeyvalues(kv);
 377                 errorbox(_("Unable to open settings file"));
 378                 return 0;
 379         }
 380
 381         sprintf(searchstr, "%s_MACADDR", ucolourcard[card]);
 382         strcpy(temp, ""); findkey(kv, searchstr, temp);
 383         if (strlen(temp)) {
 384                 strcpy(knics[ card ].macaddr, temp);
 385                 strcpy(knics[ card ].colour, ucolourcard[card]);
 386
 387                 sprintf(searchstr, "%s_DESCRIPTION", ucolourcard[card]);
 388                 findkey(kv, searchstr, temp);
 389                 strcpy(knics[ card ].description, temp);
 390
 391                 sprintf(searchstr, "%s_DRIVER", ucolourcard[card]);
 392                 findkey(kv, searchstr, temp);
 393                 strcpy(knics[ card ].driver, temp);
 394                 ret_value = 1;
 395         } else {
 396                 strcpy(knics[ card ].description, _("Unset"));
 397                 ret_value = 0;
 398         }
 399         freekeyvalues(kv);
 400
 401         return ret_value;
 402 }
 403
 404 int init_knics(void)
 405 {
 406         int found = 0;
 407         found += get_knic(_GREEN_CARD_);
 408         found += get_knic(_RED_CARD_);
 409         found += get_knic(_ORANGE_CARD_);
 410         found += get_knic(_BLUE_CARD_);
 411
 412         return found;
 413 }
 414
 415 int fmt_exists(const char *fname) {     /* Check if it is any file or directory */
 416         struct stat st;
 417         if (stat(fname, &st) == -1) return 0;
 418         else return 1;
 419 }
 420
 421 int is_interface_up(char *card) {       /* Check if the interface is UP */
 422         char temp[STRING_SIZE];
 423
 424         sprintf(temp,"ip link show dev %s | grep -q UP", card);
 425         if (mysystem(NULL, temp)) return 0; else return 1;
 426 }
 427
 428 int rename_device(char *old_name, char *new_name) {
 429         char temp[STRING_SIZE];
 430
 431         sprintf(temp,SYSDIR "/%s", old_name);
 432         if (!(fmt_exists(temp))) {
 433                 fprintf(flog,"Device not found: %s\n",old_name);
 434                 return 0;
 435         }
 436         sprintf(temp,"/sbin/ip link set dev %s name %s",old_name ,new_name );
 437         mysystem(NULL, temp);
 438
 439         return 1;
 440 }
 441
 442 char g_temp[STRING_SIZE]="";
 443 char* readmac(char *card) {
 444         FILE *fp;
 445         char temp[STRING_SIZE], mac[20];
 446
 447         sprintf(temp,"/sys/class/net/%s/address",card);
 448         if( (fp = fopen(temp, "r")) == NULL ) {
 449                 fprintf(flog,"Couldn't open: %s\n",temp);
 450                 return NULL;
 451         }
 452         fgets(mac, 18, fp);
 453         strtok(mac,"\n");
 454         fclose(fp);
 455         strcpy(g_temp, mac);
 456         return g_temp;
 457 }
 458
 459 char* find_nic4mac(char *findmac) {
 460         DIR *dir;
 461         struct dirent *dirzeiger;
 462         char temp[STRING_SIZE], temp2[STRING_SIZE];
 463
 464         if((dir=opendir(SYSDIR)) == NULL) {
 465                 fprintf(flog,"Fehler bei opendir (find_name4nic) ...\n");
 466                 return NULL;
 467         }
 468
 469         sprintf(temp, "");
 470         while((dirzeiger=readdir(dir)) != NULL) {
 471                 if(*((*dirzeiger).d_name) != '.' & strcmp(((*dirzeiger).d_name), "lo") != 0) {
 472                         sprintf(temp2, "%s", readmac((*dirzeiger).d_name) );
 473                         if (strcmp(findmac, temp2) == 0) {
 474                                 sprintf(temp,"%s", (*dirzeiger).d_name);
 475                                 break;
 476                         }
 477                 }
 478         }
 479
 480         if(closedir(dir) == -1) fprintf(flog,"Fehler beim schliessen von %s\n", SYSDIR);
 481         strcpy(g_temp, temp);
 482         return g_temp;
 483 }
 484
 485 int nic_shutdown(char *nic) {
 486         char temp[STRING_SIZE];
 487
 488         sprintf(temp,"ip link set %s down", nic);
 489         mysystem(NULL, temp);
 490 }
 491
 492 int nic_startup(char *nic) {
 493         char temp[STRING_SIZE];
 494
 495         sprintf(temp,"ip link set %s up", nic);
 496         mysystem(NULL, temp);
 497
 498 }
 499
 500 int rename_nics(void) {
 501         int i, j, k;
 502         int fnics = scan_network_cards();
 503         char nic2find[STRING_SIZE], temp[STRING_SIZE];
 504
 505         for(i=0; i<4; i++)
 506                 if (strcmp(knics[i].macaddr, ""))
 507                         for(j=0; j<fnics; j++)
 508                                 if(strcmp(knics[i].macaddr, nics[j].macaddr) == 0) {
 509                                         sprintf(nic2find,"%s0",lcolourcard[i]);
 510                                         if(strcmp(nic2find, nics[j].nic)) {
 511                                                 if(is_interface_up(nics[j].nic)) {
 512                                                         nic_shutdown(nics[j].nic);
 513                                                 }
 514                                                 sprintf(temp,SYSDIR "/%s", nic2find);
 515                                                 if(fmt_exists(temp)) {
 516                                                         for(k=0; k<fnics; k++)
 517                                                                 if (strcmp(nics[k].nic, nic2find) == 0 ) {
 518                                                                         if(is_interface_up(nics[k].nic)) {
 519                                                                                 nic_shutdown(nics[k].nic);
 520                                                                         }
 521                                                                         sprintf(temp,"dummy%i",k);
 522                                                                         if (rename_device(nics[k].nic, temp)) strcpy(nics[k].nic, temp);
 523                                                                 }
 524                                                 }
 525                                                 if (rename_device(nics[j].nic, nic2find)) strcpy(nics[j].nic, nic2find);
 526                                         }
 527                                 }
 528 }
 529
 530 int create_udev(void)
 531 {
 532         #define UDEV_NET_CONF "/etc/udev/rules.d/30-persistent-network.rules"
 533         FILE *fp;
 534         int i;
 535
 536         if ( (fp = fopen(UDEV_NET_CONF, "w")) == NULL ) {
 537                 fprintf(stderr,"Couldn't open" UDEV_NET_CONF);
 538                 return 1;
 539         }
 540
 541         for (i = 0 ; i < 4 ; i++)
 542         {
 543                 if (strcmp(knics[i].macaddr, "")) {
 544                         fprintf(fp,"\n# %s\nACTION==\"add\", SUBSYSTEM==\"net\", ATTR{type}==\"1\", ATTR{address}==\"%s\", NAME=\"%s0\"\n", knics[i].description, knics[i].macaddr, lcolourcard[i]);
 545                 }
 546         }
 547         fclose(fp);
 548         return 0;
 549 }
 550
 551 int write_configs_netudev(int card , int colour)
 552 {
 553         char commandstring[STRING_SIZE];
 554         struct keyvalue *kv = initkeyvalues();
 555         char temp1[STRING_SIZE], temp2[STRING_SIZE], temp3[STRING_SIZE];
 556         char ucolour[STRING_SIZE];
 557
 558         sprintf(ucolour, ucolourcard[colour]);
 559         strcpy(knics[colour].driver, nics[card].driver);
 560         strcpy(knics[colour].description, nics[card].description);
 561         strcpy(knics[colour].macaddr, nics[card].macaddr);
 562
 563         if (!(readkeyvalues(kv, CONFIG_ROOT "/ethernet/settings")))
 564         {
 565                 freekeyvalues(kv);
 566                 errorbox(_("Unable to open settings file"));
 567                 return 0;
 568         }
 569
 570         sprintf(temp1, "%s_DEV", ucolour);
 571         sprintf(temp2, "%s_MACADDR", ucolour);
 572         sprintf(temp3, "%s0", lcolourcard[colour]);
 573         replacekeyvalue(kv, temp1, temp3);
 574         replacekeyvalue(kv, temp2, nics[card].macaddr);
 575         sprintf(temp1, "%s_DESCRIPTION", ucolour);
 576         replacekeyvalue(kv, temp1, nics[card].description);
 577         sprintf(temp1, "%s_DRIVER", ucolour);
 578         replacekeyvalue(kv, temp1, nics[card].driver);
 579
 580         writekeyvalues(kv, CONFIG_ROOT "/ethernet/settings");
 581         freekeyvalues(kv);
 582
 583         return 0;
 584 }
 585
 586 int scan_network_cards(void)
 587 {
 588         FILE *fp;
 589         char driver[STRING_SIZE], description[STRING_SIZE], macaddr[STRING_SIZE], temp_line[STRING_SIZE];
 590         int count = 0;
 591         const char _driver[]="driver: ";
 592         const char _desc[]="desc: ";
 593         const char _network_hwaddr[]="network.hwaddr: ";
 594
 595         if (!(scanned_nics_read_done))
 596         {
 597                 mysystem(NULL, "/usr/bin/probenic.sh");
 598                 if( (fp = fopen(SCANNED_NICS, "r")) == NULL )
 599                 {
 600                         fprintf(stderr,"Couldn't open "SCANNED_NICS);
 601                         return 1;
 602                 }
 603                 while (fgets(temp_line, STRING_SIZE, fp) != NULL)
 604                 {
 605                         temp_line[strlen(temp_line) -1] = 0;
 606                         if ( strncmp(temp_line, _driver,         strlen(_driver))         ==  0 ) sprintf(nics[count].driver,      "%s", temp_line+strlen(_driver));
 607                         if ( strncmp(temp_line, _desc,           strlen(_desc))           ==  0 ) sprintf(nics[count].description, "%s", temp_line+strlen(_desc));
 608                         if ( strncmp(temp_line, _network_hwaddr, strlen(_network_hwaddr)) ==  0 ) sprintf(nics[count].macaddr,     "%s", temp_line+strlen(_network_hwaddr));
 609                         if (strlen(nics[count].macaddr) > 15 ) {
 610                                 sprintf(nics[count].nic, "%s", find_nic4mac(nics[count].macaddr));
 611                                 count++;
 612                         }
 613                 }
 614                 fclose(fp);
 615                 scanned_nics_read_done = count;
 616         } else fprintf(flog,"Scan Networkcards does read.\n");
 617         return scanned_nics_read_done;
 618 }
 619
 620
 621
 622 int nicmenu(int colour)
 623 {
 624         int rc, choise = 0, count = 0, kcount = 0, mcount = 0, i, j, nic_in_use;
 625         int found_NIC_as_Card[4];
 626         char message[STRING_SIZE];
 627         char temp[STRING_SIZE];
 628
 629         char cMenuInhalt[STRING_SIZE];
 630         char MenuInhalt[20][180];
 631         char *pMenuInhalt[20];
 632
 633         while (strcmp(nics[count].macaddr, "")) count++;                        // 2 find how many nics in system
 634         for ( i=0 ; i<4;i++) if (strcmp(knics[i].macaddr, "")) kcount++;        // loop to find all knowing nics
 635
 636         // If new nics are found...
 637         if (count > kcount) {
 638                 for (i=0 ; i < count ; i++)
 639                 {
 640                         nic_in_use = 0;
 641                         for (j=0 ; j <= kcount ; j++) {
 642                                 if (strcmp(nics[ i ].macaddr, knics[ j ].macaddr) == 0 ) {
 643                                         nic_in_use = 1;
 644                                         break;
 645                                 }
 646                         }
 647                         if (!(nic_in_use)) {
 648                                 if ( strlen(nics[i].description) < 55 )
 649                                         sprintf(MenuInhalt[mcount], "%.*s",  strlen(nics[i].description)-2, nics[i].description+1);
 650                                 else {
 651                                         sprintf(cMenuInhalt, "%.50s", nics[i].description + 1);
 652                                         sprintf(MenuInhalt[mcount], cMenuInhalt);
 653                                         strcat (MenuInhalt[mcount], "...");
 654                                 }
 655
 656                                 while ( strlen(MenuInhalt[mcount]) < 53) strcat(MenuInhalt[mcount], " "); // Fill with space.
 657
 658                                 strcat(MenuInhalt[mcount], " (");
 659                                 strcat(MenuInhalt[mcount], nics[i].macaddr);
 660                                 strcat(MenuInhalt[mcount], ")");
 661                                 pMenuInhalt[mcount] = MenuInhalt[mcount];
 662                                 found_NIC_as_Card[mcount]=i;
 663                                 mcount++;
 664                         }
 665                 }
 666
 667                 pMenuInhalt[mcount] = NULL;
 668
 669                 sprintf(message, _("Please choose a networkcard for the following interface - %s."), ucolourcard[colour]);
 670                 rc=2;
 671                 while ( rc == 2 ) {
 672                         rc = newtWinMenu(_("Extended Network Menu"), message, 50, 5, 5, 6, pMenuInhalt, &choise,
 673                                 _("Select"), _("Identify"), _("Cancel"), NULL);
 674                         if ( rc == 2 ) {
 675                                 sprintf(temp, "/sbin/ip link set %s up", nics[found_NIC_as_Card[choise]].nic);
 676                                 mysystem(NULL, temp);
 677                                 sprintf(temp, "/usr/sbin/ethtool -p %s 10", nics[found_NIC_as_Card[choise]].nic);
 678                                 if (runcommandwithstatus(temp, _("Device Identification"), _("The lights on the selected port should flash now for 10 seconds..."), NULL) != 0) {
 679                                         errorbox(_("Identification is not supported by this interface."));
 680                                 sprintf(temp, "/sbin/ip link set %s down", nics[found_NIC_as_Card[choise]].nic);
 681                                 mysystem(NULL, temp);
 682                                 }
 683                         }
 684                 }
 685                 if ( rc == 0 || rc == 1) {
 686                         write_configs_netudev(found_NIC_as_Card[choise], colour);
 687                 }
 688                 return 0;
 689         } else {
 690                 // We have to add here that you can manually add a device
 691                 errorbox(_("There are no unassigned interfaces on your system."));
 692                 return 1;
 693         }
 694 }
 695
 696 int clear_card_entry(int card)
 697 {
 698         struct keyvalue *kv = initkeyvalues();
 699         char temp[STRING_SIZE];
 700
 701         if (!(readkeyvalues(kv, CONFIG_ROOT "/ethernet/settings")))
 702         {
 703                 freekeyvalues(kv);
 704                 errorbox(_("Unable to open settings file"));
 705                 return 0;
 706         }
 707
 708         strcpy(knics[card].driver, "");
 709         strcpy(knics[card].description, _("Unset"));
 710         strcpy(knics[card].macaddr, "");
 711         strcpy(knics[card].colour, "");
 712         sprintf(temp, "%s_DRIVER", ucolourcard[card]);
 713         replacekeyvalue(kv, temp, "");
 714         sprintf(temp, "%s_DEV", ucolourcard[card]);
 715         replacekeyvalue(kv, temp, "");
 716         sprintf(temp, "%s_MACADDR", ucolourcard[card]);
 717         replacekeyvalue(kv, temp, "");
 718         sprintf(temp, "%s_DESCRIPTION", ucolourcard[card]);
 719         replacekeyvalue(kv, temp, "");
 720
 721         writekeyvalues(kv, CONFIG_ROOT "/ethernet/settings");
 722         freekeyvalues(kv);
 723
 724         return 0;
 725 }
 726
 727 int ask_clear_card_entry(int card)
 728 {
 729         char message[STRING_SIZE];
 730         int rc;
 731
 732         sprintf(message, _("Do you really want to remove the assigned %s interface?"), ucolourcard[card]);
 733         rc = newtWinChoice(_("Warning"), _("OK"), _("Cancel"), message);
 734
 735         if ( rc = 0 || rc == 1) {
 736                 clear_card_entry(card);
 737         } else return 1;
 738
 739         return 0;
 740 }
 741
 742 /* Manual entry for gurus. */
 743 int manualdriver(char *driver, char *driveroptions)
 744 {
 745         char *values[] = { NULL, NULL };        /* pointers for the values. */
 746         struct newtWinEntry entries[] =
 747                 { { "", &values[0], 0,}, { NULL, NULL, 0 } };
 748         int rc;
 749         char commandstring[STRING_SIZE];
 750         char *driverend;
 751
 752         strcpy(driver, "");
 753         strcpy(driveroptions, "");
 754
 755         rc = newtWinEntries(_("Select network driver"), _("Set additional module parameters"),
 756                 50, 5, 5, 40, entries,  _("OK"), _("Cancel"), NULL);
 757         if (rc == 0 || rc == 1)
 758         {
 759                 if (strlen(values[0]))
 760                 {
 761                         sprintf(commandstring, "/sbin/modprobe %s", values[0]);
 762                         if (runcommandwithstatus(commandstring, _("Loading module..."), _("Loading module..."), NULL) == 0)
 763                         {
 764                                 if ((driverend = strchr(values[0], ' ')))
 765                                 {
 766                                         *driverend = '\0';
 767                                         strcpy(driver, values[0]);
 768                                         strcpy(driveroptions, driverend + 1);
 769                                 }
 770                                 else
 771                                 {
 772                                         strcpy(driver, values[0]);
 773                                         strcpy(driveroptions, "");
 774                                 }
 775                         }
 776                         else
 777                                 errorbox(_("Unable to load driver module."));
 778                 }
 779                 else
 780                         errorbox(_("Module name cannot be blank."));
 781         }
 782         free(values[0]);
 783
 784         return 1;
 785 }