src/install+setup/setup/networking.c

   1 /* SmoothWall setup program.
   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  * The big one: networking.
   8  *
   9  */
  10
  11 #include "setup.h"
  12
  13 #define DNS1 0
  14 #define DNS2 1
  15 #define DEFAULT_GATEWAY 2
  16 #define DNSGATEWAY_TOTAL 3
  17
  18 extern FILE *flog;
  19 extern char *mylog;
  20
  21 extern char **ctr;
  22
  23 extern int automode;
  24
  25 #define HAS_GREEN 1
  26 #define HAS_RED (configtype == 1 || configtype == 2 || configtype == 3 || configtype == 4)
  27 #define HAS_ORANGE (configtype == 2 || configtype == 4)
  28 #define HAS_BLUE (configtype == 3 || configtype == 4)
  29 #define RED_IS_NOT_ETH (configtype == 0)
  30
  31 extern struct nic nics[];
  32 extern struct knic knics[];
  33
  34 char *configtypenames[] = {
  35         "GREEN + RED",
  36         "GREEN + RED + ORANGE",
  37         "GREEN + RED + BLUE",
  38         "GREEN + RED + ORANGE + BLUE",
  39         NULL };
  40 int configtypecards[] = {
  41         2,      // "GREEN + RED",
  42         3,      // "GREEN + RED + ORANGE",
  43         3,      // "GREEN + RED + BLUE",
  44         4         // "GREEN + RED + ORANGE + BLUE",
  45 };
  46
  47
  48 int netaddresschange;
  49
  50 int oktoleave(void);
  51 int firstmenu(void);
  52 int configtypemenu(void);
  53 int drivermenu(void);
  54 int changedrivers(void);
  55 int greenaddressmenu(void);
  56 int addressesmenu(void);
  57 int dnsgatewaymenu(void);
  58
  59 int handlenetworking(void)
  60 {
  61         int done;
  62         int choice;
  63         int found;
  64
  65         netaddresschange = 0;
  66
  67         found = scan_network_cards();
  68         found = init_knics();
  69
  70         done = 0;
  71         while (!done)
  72         {
  73                 choice = firstmenu();
  74
  75                 switch (choice)
  76                 {
  77                         case 1:
  78                                 configtypemenu();
  79                                 break;
  80
  81                         case 2:
  82                                 drivermenu();
  83                                 break;
  84
  85                         case 3:
  86                                 addressesmenu();
  87                                 break;
  88
  89                         case 4:
  90                                 dnsgatewaymenu();
  91                                 break;
  92
  93                         case 0:
  94                                 if (oktoleave()) done = 1;
  95                                 break;
  96
  97                         default:
  98                                 break;
  99                 }
 100         }
 101
 102         if (automode == 0)
 103         {
 104                 /* Restart networking! */
 105                 if (netaddresschange)
 106                 {
 107                         runcommandwithstatus("/etc/rc.d/init.d/network stop",
 108                                 ctr[TR_PUSHING_NETWORK_DOWN]);
 109
 110                         rename_nics();
 111
 112                         runcommandwithstatus("/etc/rc.d/init.d/network start",
 113                                 ctr[TR_PULLING_NETWORK_UP]);
 114                 }
 115         }
 116         create_udev();
 117         return 1;
 118 }
 119
 120 int oktoleave(void)
 121 {
 122         struct keyvalue *kv = initkeyvalues();
 123         char temp[STRING_SIZE];
 124         int configtype;
 125         int rc;
 126
 127         if (!(readkeyvalues(kv, CONFIG_ROOT "/ethernet/settings")))
 128         {
 129                 freekeyvalues(kv);
 130                 errorbox(ctr[TR_UNABLE_TO_OPEN_SETTINGS_FILE]);
 131                 return 0;
 132         }
 133
 134         strcpy(temp, "1"); findkey(kv, "CONFIG_TYPE", temp); configtype = atol(temp);
 135         if (configtype < 1 || configtype > 4) configtype = 1;
 136
 137         if (HAS_GREEN)
 138         {
 139                 strcpy(temp, ""); findkey(kv, "GREEN_DEV", temp);
 140                 if (!(strlen(temp)))
 141                 {
 142                         errorbox(ctr[TR_NO_GREEN_INTERFACE]);
 143                         freekeyvalues(kv);
 144                         return 0;
 145                 }
 146                 if (!(interfacecheck(kv, "GREEN")))
 147                 {
 148                         errorbox(ctr[TR_MISSING_GREEN_IP]);
 149                         freekeyvalues(kv);
 150                         return 0;
 151                 }
 152         }
 153         if (HAS_RED)
 154         {
 155
 156                 strcpy(temp, ""); findkey(kv, "RED_DEV", temp);
 157                 if (!(strlen(temp)))
 158                 {
 159                         rc = newtWinChoice(ctr[TR_ERROR], ctr[TR_OK], ctr[TR_IGNORE], ctr[TR_NO_RED_INTERFACE]);
 160                         if (rc == 0 || rc == 1)
 161                         {
 162                                 freekeyvalues(kv);
 163                                 return 0;
 164                         }
 165                 }
 166                 if (!(interfacecheck(kv, "RED")))
 167                 {
 168                         errorbox(ctr[TR_MISSING_RED_IP]);
 169                         freekeyvalues(kv);
 170                         return 0;
 171                 }
 172         }
 173         if (HAS_ORANGE)
 174         {
 175                 strcpy(temp, ""); findkey(kv, "ORANGE_DEV", temp);
 176                 if (!(strlen(temp)))
 177                 {
 178                         errorbox(ctr[TR_NO_ORANGE_INTERFACE]);
 179                         freekeyvalues(kv);
 180                         return 0;
 181                 }
 182                 if (!(interfacecheck(kv, "ORANGE")))
 183                 {
 184                         errorbox(ctr[TR_MISSING_ORANGE_IP]);
 185                         freekeyvalues(kv);
 186                         return 0;
 187                 }
 188         }
 189         if (HAS_BLUE)
 190         {
 191                 strcpy(temp, ""); findkey(kv, "BLUE_DEV", temp);
 192                 if (!(strlen(temp)))
 193                 {
 194                         errorbox(ctr[TR_NO_BLUE_INTERFACE]);
 195                         freekeyvalues(kv);
 196                         return 0;
 197                 }
 198                 if (!(interfacecheck(kv, "BLUE")))
 199                 {
 200                         errorbox(ctr[TR_MISSING_BLUE_IP]);
 201                         freekeyvalues(kv);
 202                         return 0;
 203                 }
 204         }
 205         if (configtype == 0)
 206         {
 207                 strcpy(temp, ""); findkey(kv, "DNS1", temp);
 208                 if (!(strlen(temp)))
 209                 {
 210                         errorbox(ctr[TR_MISSING_DNS]);
 211                         freekeyvalues(kv);
 212                         return 0;
 213                 }
 214                 strcpy(temp, ""); findkey(kv, "DEFAULT_GATEWAY", temp);
 215                 if (!(strlen(temp)))
 216                 {
 217                         errorbox(ctr[TR_MISSING_DEFAULT]);
 218                         freekeyvalues(kv);
 219                         return 0;
 220                 }
 221         }
 222         return 1;
 223 }
 224
 225
 226 /* Shows the main menu and a summary of the current settings. */
 227 int firstmenu(void)
 228 {
 229         char *sections[] = { ctr[TR_NETWORK_CONFIGURATION_TYPE],
 230                 ctr[TR_DRIVERS_AND_CARD_ASSIGNMENTS],
 231                 ctr[TR_ADDRESS_SETTINGS],
 232                 ctr[TR_DNS_AND_GATEWAY_SETTINGS], NULL };
 233         int rc;
 234         static int choice = 0;
 235         struct keyvalue *kv = initkeyvalues();
 236         char message[1000];
 237         char temp[STRING_SIZE] = "1";
 238         int x;
 239         int result;
 240         char networkrestart[STRING_SIZE] = "";
 241
 242         if (!(readkeyvalues(kv, CONFIG_ROOT "/ethernet/settings")))
 243         {
 244                 freekeyvalues(kv);
 245                 errorbox(ctr[TR_UNABLE_TO_OPEN_SETTINGS_FILE]);
 246                 return 0;
 247         }
 248
 249         if (netaddresschange)
 250                 strcpy(networkrestart, ctr[TR_RESTART_REQUIRED]);
 251
 252         strcpy(temp, ""); findkey(kv, "CONFIG_TYPE", temp);
 253         x = atol(temp);
 254         x--;
 255         if (x < 0 || x > 4) x = 0;
 256         /* Format heading bit. */
 257         snprintf(message, 1000, ctr[TR_CURRENT_CONFIG], configtypenames[x],
 258                 networkrestart);
 259         rc = newtWinMenu(ctr[TR_NETWORK_CONFIGURATION_MENU], message, 50, 5, 5, 6,
 260                         sections, &choice, ctr[TR_OK], ctr[TR_DONE], NULL);
 261
 262         if (rc == 0 || rc == 1)
 263                 result = choice + 1;
 264         else
 265                 result = 0;
 266
 267         return result;
 268 }
 269
 270 /* Here they choose general network config, number of nics etc. */
 271 int configtypemenu(void)
 272 {
 273         struct keyvalue *kv = initkeyvalues();
 274         char temp[STRING_SIZE] = "1";
 275         char message[1000];
 276         int choise, found;
 277         int rc, configtype;
 278
 279         if (!(readkeyvalues(kv, CONFIG_ROOT "/ethernet/settings")))
 280         {
 281                 freekeyvalues(kv);
 282                 errorbox(ctr[TR_UNABLE_TO_OPEN_SETTINGS_FILE]);
 283                 return 0;
 284         }
 285
 286         found = scan_network_cards();
 287
 288         findkey(kv, "CONFIG_TYPE", temp); choise = atol(temp);
 289         choise--;
 290
 291                 sprintf(message, ctr[TR_NETWORK_CONFIGURATION_TYPE_LONG], NAME);
 292                 rc = newtWinMenu(ctr[TR_NETWORK_CONFIGURATION_TYPE], message, 50, 5, 5,
 293                         6, configtypenames, &choise, ctr[TR_OK], ctr[TR_CANCEL], NULL);
 294                 if ( configtypecards[choise] > found ) {
 295                         sprintf(message, ctr[TR_NOT_ENOUGH_INTERFACES] , configtypecards[choise], found);
 296                         errorbox(message);
 297                 }
 298
 299         if (rc == 0 || rc == 1)
 300         {
 301                 choise++;
 302                 sprintf(temp, "%d", choise);
 303                 replacekeyvalue(kv, "CONFIG_TYPE", temp);
 304                 configtype = atol(temp);
 305                 if (!HAS_RED)
 306                         clear_card_entry(_RED_CARD_);
 307                 if (!HAS_ORANGE)
 308                         clear_card_entry(_ORANGE_CARD_);
 309                 if (!HAS_BLUE)
 310                         clear_card_entry(_BLUE_CARD_);
 311
 312                 writekeyvalues(kv, CONFIG_ROOT "/ethernet/settings");
 313                 netaddresschange = 1;
 314         }
 315         freekeyvalues(kv);
 316
 317         return 0;
 318 }
 319
 320 /* Driver menu.  Choose drivers.. */
 321 int drivermenu(void)
 322 {
 323         struct keyvalue *kv = initkeyvalues();
 324         char message[STRING_SIZE];
 325         char temp[STRING_SIZE] = "1";
 326
 327         int configtype;
 328         int i, rc, kcount = 0, neednics;
 329
 330         if (!(readkeyvalues(kv, CONFIG_ROOT "/ethernet/settings")))
 331         {
 332                 freekeyvalues(kv);
 333                 errorbox(ctr[TR_UNABLE_TO_OPEN_SETTINGS_FILE]);
 334                 return 0;
 335         }
 336
 337         if (findkey(kv, "CONFIG_TYPE", temp))
 338                 configtype = atol(temp);
 339         else {
 340                 fprintf(flog,"setting CONFIG_TYPE = %s\n",temp);
 341                 configtype = atol(temp);
 342                 replacekeyvalue(kv, "CONFIG_TYPE", temp);
 343                 writekeyvalues(kv, CONFIG_ROOT "/ethernet/settings");
 344         }
 345
 346         strcpy(message, ctr[TR_CONFIGURE_NETWORK_DRIVERS]);
 347
 348         kcount = 0;
 349         neednics = 0;
 350         if (HAS_GREEN) {
 351                 sprintf(temp, "GREEN:  %s\n", knics[_GREEN_CARD_].description);
 352                 strcat(message, temp);
 353                 if (strlen(knics[_GREEN_CARD_].macaddr) ) {
 354                         sprintf(temp, "GREEN:  (%s) %s green0\n", knics[_GREEN_CARD_].macaddr, ctr[TR_AS]);
 355                         strcat(message, temp);
 356                 }
 357                 neednics++;
 358         }
 359         if (HAS_RED) {
 360                 sprintf(temp, "RED:    %s\n", knics[_RED_CARD_].description);
 361                 strcat(message, temp);
 362                 if (strlen(knics[_RED_CARD_].macaddr) ) {
 363                         sprintf(temp, "RED:    (%s) %s red0\n", knics[_RED_CARD_].macaddr, ctr[TR_AS]);
 364                         strcat(message, temp);
 365                 }
 366                 neednics++;
 367         }
 368         if (HAS_ORANGE) {
 369                 sprintf(temp, "ORANGE: %s\n", knics[_ORANGE_CARD_].description);
 370                 strcat(message, temp);
 371                 if ( strlen(knics[_ORANGE_CARD_].macaddr) ) {
 372                         sprintf(temp, "ORANGE: (%s) %s orange0\n", knics[_ORANGE_CARD_].macaddr, ctr[TR_AS]);
 373                         strcat(message, temp);
 374                 }
 375                 neednics++;
 376         }
 377         if (HAS_BLUE) {
 378                 sprintf(temp, "BLUE:   %s\n", knics[_BLUE_CARD_].description);
 379                 strcat(message, temp);
 380                 if (strlen(knics[_BLUE_CARD_].macaddr)) {
 381                         sprintf(temp, "BLUE:   (%s) %s blue0\n", knics[_BLUE_CARD_].macaddr, ctr[TR_AS]);
 382                         strcat(message, temp);
 383                 }
 384                 neednics++;
 385         }
 386
 387         for ( i=0 ; i<4; i++)
 388                 if (strcmp(knics[i].macaddr, ""))
 389                         kcount++;
 390
 391         if (neednics = kcount)
 392         {
 393                 strcat(message, ctr[TR_DO_YOU_WISH_TO_CHANGE_THESE_SETTINGS]);
 394                 rc = newtWinChoice(ctr[TR_DRIVERS_AND_CARD_ASSIGNMENTS], ctr[TR_OK],
 395                 ctr[TR_CANCEL], message);
 396                 if (rc == 0 || rc == 1)
 397                 {
 398                         changedrivers();
 399                 }
 400         } else {
 401                 changedrivers();
 402         }
 403         freekeyvalues(kv);
 404
 405         return 1;
 406 }
 407
 408 int set_menu_entry_for(int *nr, int *card)
 409 {
 410
 411 }
 412
 413 int changedrivers(void)
 414 {
 415         struct keyvalue *kv = initkeyvalues();
 416         char temp[STRING_SIZE], message[STRING_SIZE];
 417         int configtype;
 418         int green = 0, red = 0, blue = 0, orange = 0;
 419         char MenuInhalt[10][180];
 420         char *pMenuInhalt[10];
 421         int count = 0, choise = 0, rc;
 422         int NicEntry[10];
 423
 424         if (!(readkeyvalues(kv, CONFIG_ROOT "/ethernet/settings")))
 425         {
 426                 freekeyvalues(kv);
 427                 errorbox(ctr[TR_UNABLE_TO_OPEN_SETTINGS_FILE]);
 428                 return 0;
 429         }
 430         if (automode == 0)
 431                 runcommandwithstatus("/etc/rc.d/init.d/network stop red blue orange",
 432                         ctr[TR_PUSHING_NON_LOCAL_NETWORK_DOWN]);
 433
 434         findkey(kv, "CONFIG_TYPE", temp); configtype = atol(temp);
 435         if (configtype == 1)
 436                 { green = 1; red = 1; }
 437         else if (configtype == 2)
 438                 { green = 1; red = 1; orange = 1; }
 439         else if (configtype == 3)
 440                 { green = 1; red = 1; blue = 1; }
 441         else if (configtype == 4)
 442                 { green = 1; red=1; orange=1; blue = 1; }
 443         else if (configtype == "")
 444           { green = 1; red = 1; }
 445
 446         do
 447         {
 448                 count = 0;
 449                 strcpy(message, ctr[TR_INTERFACE_CHANGE]);
 450
 451                 if (green) {
 452                         strcpy(MenuInhalt[count], "GREEN");
 453                         pMenuInhalt[count] = MenuInhalt[count];
 454                         NicEntry[_GREEN_CARD_] = count;
 455                         sprintf(temp, "GREEN:  %s\n", knics[_GREEN_CARD_].description);
 456                         strcat(message, temp);
 457                         if ( strlen(knics[_GREEN_CARD_].macaddr) ) {
 458                                 sprintf(temp, "GREEN:  (%s) %s green0\n", knics[_GREEN_CARD_].macaddr, ctr[TR_AS]);
 459                                 strcat(message, temp);
 460                         }
 461                         count++;
 462                 }
 463
 464                 if (red) {
 465                         strcpy(MenuInhalt[count], "RED");
 466                         pMenuInhalt[count] = MenuInhalt[count];
 467                         NicEntry[_RED_CARD_] = count;
 468                         sprintf(temp, "RED:    %s\n", knics[_RED_CARD_].description);
 469                         strcat(message, temp);
 470                         if ( strlen(knics[_RED_CARD_].macaddr) ) {
 471                                 sprintf(temp, "RED:    (%s) %s red0\n", knics[_RED_CARD_].macaddr, ctr[TR_AS]);
 472                                 strcat(message, temp);
 473                         }
 474                         count++;
 475                 }
 476
 477                 if (orange) {
 478                         strcpy(MenuInhalt[count], "ORANGE");
 479                         pMenuInhalt[count] = MenuInhalt[count];
 480                         NicEntry[_ORANGE_CARD_] = count;
 481                         sprintf(temp, "ORANGE: %s\n", knics[_ORANGE_CARD_].description);
 482                         strcat(message, temp);
 483                         if ( strlen(knics[_ORANGE_CARD_].macaddr) ) {
 484                                 sprintf(temp, "ORANGE: (%s) %s orange0\n", knics[_ORANGE_CARD_].macaddr, ctr[TR_AS]);
 485                                 strcat(message, temp);
 486                         }
 487                         count++;
 488                 }
 489
 490                 if (blue) {
 491                         strcpy(MenuInhalt[count], "BLUE");
 492                         pMenuInhalt[count] = MenuInhalt[count];
 493                         NicEntry[_BLUE_CARD_] = count;
 494                         sprintf(temp, "BLUE:   %s\n", knics[_BLUE_CARD_].description);
 495                         strcat(message, temp);
 496                         if ( strlen(knics[_BLUE_CARD_].macaddr) ) {
 497                                 sprintf(temp, "BLUE:   (%s) %s blue0\n", knics[_BLUE_CARD_].macaddr, ctr[TR_AS]);
 498                                 strcat(message, temp);
 499                         }
 500                         count++;
 501                 }
 502                 pMenuInhalt[count] = NULL;
 503
 504                 rc = newtWinMenu( ctr[TR_NETCARD_COLOR], message, 70, 5, 5, 6, pMenuInhalt, &choise, ctr[TR_SELECT], ctr[TR_REMOVE], ctr[TR_DONE], NULL);
 505
 506                 if ( rc == 0 || rc == 1) {
 507                         if ((green) && ( choise == NicEntry[0])) nicmenu(_GREEN_CARD_);
 508                         if ((red) && ( choise == NicEntry[1])) nicmenu(_RED_CARD_);
 509                         if ((orange) && ( choise == NicEntry[2])) nicmenu(_ORANGE_CARD_);
 510                         if ((blue) && ( choise == NicEntry[3])) nicmenu(_BLUE_CARD_);
 511                         netaddresschange = 1;
 512                 } else if (rc == 2) {
 513                         if ((green) && ( choise == NicEntry[0])) ask_clear_card_entry(_GREEN_CARD_);
 514                         if ((red) && ( choise == NicEntry[1])) ask_clear_card_entry(_RED_CARD_);
 515                         if ((orange) && ( choise == NicEntry[2])) ask_clear_card_entry(_ORANGE_CARD_);
 516                         if ((blue) && ( choise == NicEntry[3])) ask_clear_card_entry(_BLUE_CARD_);
 517                         netaddresschange = 1;
 518                 }
 519         }
 520         while ( rc <= 2);
 521
 522         freekeyvalues(kv);
 523         return 1;
 524 }
 525
 526 // Let user change GREEN address.
 527 int greenaddressmenu(void)
 528 {
 529         struct keyvalue *kv = initkeyvalues();
 530         char message[1000];
 531         int rc;
 532
 533         if (!(readkeyvalues(kv, CONFIG_ROOT "/ethernet/settings")))
 534         {
 535                 freekeyvalues(kv);
 536                 errorbox(ctr[TR_UNABLE_TO_OPEN_SETTINGS_FILE]);
 537                 return 0;
 538         }
 539
 540         sprintf(message, ctr[TR_WARNING_LONG], NAME);
 541         rc = newtWinChoice(ctr[TR_WARNING], ctr[TR_OK], ctr[TR_CANCEL], message);
 542
 543         if (rc == 0 || rc == 1)
 544         {
 545                 if (changeaddress(kv, "GREEN", 0, ""))
 546                 {
 547                         netaddresschange = 1;
 548                         writekeyvalues(kv, CONFIG_ROOT "/ethernet/settings");
 549                         writehostsfiles();
 550                 }
 551         }
 552
 553         freekeyvalues(kv);
 554
 555         return 0;
 556 }
 557
 558 // They can change BLUE, ORANGE and GREEN too :)
 559 int addressesmenu(void)
 560 {
 561         struct keyvalue *kv = initkeyvalues();
 562         struct keyvalue *mainkv = initkeyvalues();
 563         int rc = 0;
 564         char *sections[5];
 565         char *green = "GREEN";
 566         char *orange = "ORANGE";
 567         char *blue = "BLUE";
 568         char *red = "RED";
 569         int c = 0;
 570         char greenaddress[STRING_SIZE];
 571         char oldgreenaddress[STRING_SIZE];
 572         char temp[STRING_SIZE];
 573         char temp2[STRING_SIZE];
 574         char message[1000];
 575         int configtype;
 576         int done;
 577         int choice;
 578         char hostname[STRING_SIZE];
 579
 580         if (!(readkeyvalues(kv, CONFIG_ROOT "/ethernet/settings")))
 581         {
 582                 freekeyvalues(kv);
 583                 freekeyvalues(mainkv);
 584                 errorbox(ctr[TR_UNABLE_TO_OPEN_SETTINGS_FILE]);
 585                 return 0;
 586         }
 587         if (!(readkeyvalues(mainkv, CONFIG_ROOT "/main/settings")))
 588         {
 589                 freekeyvalues(kv);
 590                 freekeyvalues(mainkv);
 591                 errorbox(ctr[TR_UNABLE_TO_OPEN_SETTINGS_FILE]);
 592                 return 0;
 593         }
 594
 595         strcpy(temp, "0"); findkey(kv, "CONFIG_TYPE", temp);
 596         configtype = atol(temp);
 597
 598         sections[c] = green;
 599         c++;
 600         if (HAS_BLUE)
 601         {
 602                 sections[c] = blue;
 603                 c++;
 604         }
 605         if (HAS_ORANGE)
 606         {
 607                 sections[c] = orange;
 608                 c++;
 609         }
 610         if (HAS_RED)
 611         {
 612                 sections[c] = red;
 613                 c++;
 614         }
 615         sections[c] = NULL;
 616
 617         choice = 0;
 618         done = 0;
 619         while (!done)
 620         {
 621                 rc = newtWinMenu(ctr[TR_ADDRESS_SETTINGS],
 622                         ctr[TR_SELECT_THE_INTERFACE_YOU_WISH_TO_RECONFIGURE], 50, 5,
 623                         5, 6, sections, &choice, ctr[TR_OK], ctr[TR_DONE], NULL);
 624
 625                 if (rc == 0 || rc == 1)
 626                 {
 627                         if (strcmp(sections[choice], "GREEN") == 0)
 628                         {
 629                                 findkey(kv, "GREEN_ADDRESS", oldgreenaddress);
 630                                 sprintf(message, ctr[TR_WARNING_LONG], NAME);
 631                                 rc = newtWinChoice(ctr[TR_WARNING], ctr[TR_OK], ctr[TR_CANCEL],
 632                                         message);
 633                                 if (rc == 0 || rc == 1)
 634                                 {
 635                                         if (changeaddress(kv, "GREEN", 0, ""))
 636                                         {
 637                                                 netaddresschange = 1;
 638                                                 writekeyvalues(kv, CONFIG_ROOT "/ethernet/settings");
 639                                                 writehostsfiles();
 640                                                 findkey(kv, "GREEN_ADDRESS", greenaddress);
 641                                                 snprintf(temp, STRING_SIZE-1, "option routers %s", oldgreenaddress);
 642                                                 snprintf(temp2, STRING_SIZE-1, "option routers %s", greenaddress);
 643                                                 replace (CONFIG_ROOT "/dhcp/dhcpd.conf", temp, temp2);
 644                                                 chown  (CONFIG_ROOT "/dhcp/dhcpd.conf", 99, 99);
 645                                         }
 646                                 }
 647                         }
 648                         if (strcmp(sections[choice], "BLUE") == 0)
 649                         {
 650                                 if (changeaddress(kv, "BLUE", 0, ""))
 651                                         netaddresschange = 1;
 652                         }
 653                         if (strcmp(sections[choice], "ORANGE") == 0)
 654                         {
 655                                 if (changeaddress(kv, "ORANGE", 0, ""))
 656                                         netaddresschange = 1;
 657                         }
 658                         if (strcmp(sections[choice], "RED") == 0)
 659                         {
 660                                 strcpy(hostname, "");
 661                                 findkey(mainkv, "HOSTNAME", hostname);
 662                                 if (changeaddress(kv, "RED", 1, hostname))
 663                                         netaddresschange = 1;
 664                         }
 665                 }
 666                 else
 667                         done = 1;
 668         }
 669
 670         writekeyvalues(kv, CONFIG_ROOT "/ethernet/settings");
 671         freekeyvalues(kv);
 672         freekeyvalues(mainkv);
 673
 674         return 0;
 675 }
 676
 677 /* DNS and default gateway.... */
 678 int dnsgatewaymenu(void)
 679 {
 680         struct keyvalue *kv = initkeyvalues();
 681         char message[1000];
 682         char temp[STRING_SIZE] = "0";
 683         struct newtWinEntry entries[DNSGATEWAY_TOTAL+1];
 684         char *values[DNSGATEWAY_TOTAL];         /* pointers for the values. */
 685         int error;
 686         int configtype;
 687         int rc;
 688
 689         if (!(readkeyvalues(kv, CONFIG_ROOT "/ethernet/settings")))
 690         {
 691                 freekeyvalues(kv);
 692                 errorbox(ctr[TR_UNABLE_TO_OPEN_SETTINGS_FILE]);
 693                 return 0;
 694         }
 695
 696         entries[DNS1].text = ctr[TR_PRIMARY_DNS];
 697         strcpy(temp, ""); findkey(kv, "DNS1", temp);
 698         values[DNS1] = strdup(temp);
 699         entries[DNS1].value = &values[DNS1];
 700         entries[DNS1].flags = 0;
 701
 702         entries[DNS2].text = ctr[TR_SECONDARY_DNS];
 703         strcpy(temp, ""); findkey(kv, "DNS2", temp);
 704         values[DNS2] = strdup(temp);
 705         entries[DNS2].value = &values[DNS2];
 706         entries[DNS2].flags = 0;
 707
 708         entries[DEFAULT_GATEWAY].text = ctr[TR_DEFAULT_GATEWAY];
 709         strcpy(temp, ""); findkey(kv, "DEFAULT_GATEWAY", temp);
 710         values[DEFAULT_GATEWAY] = strdup(temp);
 711         entries[DEFAULT_GATEWAY].value = &values[DEFAULT_GATEWAY];
 712         entries[DEFAULT_GATEWAY].flags = 0;
 713
 714         entries[DNSGATEWAY_TOTAL].text = NULL;
 715         entries[DNSGATEWAY_TOTAL].value = NULL;
 716         entries[DNSGATEWAY_TOTAL].flags = 0;
 717
 718         do
 719         {
 720                 error = 0;
 721
 722                 rc = newtWinEntries(ctr[TR_DNS_AND_GATEWAY_SETTINGS],
 723                         ctr[TR_DNS_AND_GATEWAY_SETTINGS_LONG], 50, 5, 5, 18, entries,
 724                         ctr[TR_OK], ctr[TR_CANCEL], NULL);
 725                 if (rc == 0 || rc == 1)
 726                 {
 727                         strcpy(message, ctr[TR_INVALID_FIELDS]);
 728                         if (strlen(values[DNS1]))
 729                         {
 730                                 if (inet_addr(values[DNS1]) == INADDR_NONE)
 731                                 {
 732                                         strcat(message, ctr[TR_PRIMARY_DNS_CR]);
 733                                         error = 1;
 734                                 }
 735                         }
 736                         if (strlen(values[DNS2]))
 737                         {
 738                                 if (inet_addr(values[DNS2]) == INADDR_NONE)
 739                                 {
 740                                         strcat(message, ctr[TR_SECONDARY_DNS_CR]);
 741                                         error = 1;
 742                                 }
 743                         }
 744                         if (strlen(values[DEFAULT_GATEWAY]))
 745                         {
 746                                 if (inet_addr(values[DEFAULT_GATEWAY]) == INADDR_NONE)
 747                                 {
 748                                         strcat(message, ctr[TR_DEFAULT_GATEWAY_CR]);
 749                                         error = 1;
 750                                 }
 751                         }
 752                         if (!strlen(values[DNS1]) && strlen(values[DNS2]))
 753                         {
 754                                 strcpy(message, ctr[TR_SECONDARY_WITHOUT_PRIMARY_DNS]);
 755                                 error = 1;
 756                         }
 757
 758                         if (error)
 759                                 errorbox(message);
 760                         else
 761                         {
 762                                 replacekeyvalue(kv, "DNS1", values[DNS1]);
 763                                 replacekeyvalue(kv, "DNS2", values[DNS2]);
 764                                 replacekeyvalue(kv, "DEFAULT_GATEWAY", values[DEFAULT_GATEWAY]);
 765                                 netaddresschange = 1;
 766                                 free(values[DNS1]);
 767                                 free(values[DNS2]);
 768                                 free(values[DEFAULT_GATEWAY]);
 769                                 writekeyvalues(kv, CONFIG_ROOT "/ethernet/settings");
 770                         }
 771                 }
 772         }
 773         while (error);
 774
 775         freekeyvalues(kv);
 776
 777         return 1;
 778 }