src/install+setup/setup/dhcp.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  * Stuff for setting up the DHCP server from the setup prog.
   8  *
   9  * $Id: dhcp.c,v 1.9.2.3 2004/12/03 06:46:50 eoberlander Exp $
  10  *
  11  */
  12
  13 #include "setup.h"
  14
  15 #define TOP 4
  16
  17 #define START_ADDRESS 0
  18 #define END_ADDRESS 1
  19 #define PRIMARY_DNS 2
  20 #define SECONDARY_DNS 3
  21 #define DEFAULT_LEASE_TIME 4
  22 #define MAX_LEASE_TIME 5
  23 #define DOMAIN_NAME_SUFFIX 6
  24 #define MAX_BOXES 7
  25
  26 extern FILE *flog;
  27 extern char *mylog;
  28
  29 extern char **ctr;
  30
  31 extern int automode;
  32
  33 newtComponent dhcpform;
  34 newtComponent entries[MAX_BOXES];
  35 newtComponent enabledcheckbox;
  36
  37 void dhcpdialogcallbackdhcp(newtComponent cm, void *data);
  38
  39 int handledhcp(void)
  40 {
  41         char *results[MAX_BOXES];
  42         char enabledresult;
  43         char startenabled;
  44         struct newtExitStruct es;
  45         newtComponent header;
  46         newtComponent labels[MAX_BOXES];
  47         newtComponent ok, cancel;
  48         char message[1000];
  49         char *labeltexts[MAX_BOXES] = { ctr[TR_START_ADDRESS], ctr[TR_END_ADDRESS],
  50                 ctr[TR_PRIMARY_DNS], ctr[TR_SECONDARY_DNS], ctr[TR_DEFAULT_LEASE],
  51                 ctr[TR_MAX_LEASE], ctr[TR_DOMAIN_NAME_SUFFIX] };
  52         char *varnames[MAX_BOXES] = { "START_ADDR_GREEN", "END_ADDR_GREEN",
  53                 "DNS1_GREEN", "DNS2_GREEN",
  54                 "DEFAULT_LEASE_TIME_GREEN", "MAX_LEASE_TIME_GREEN",
  55                 "DOMAIN_NAME_GREEN"};
  56         char defaults[MAX_BOXES][STRING_SIZE];
  57         int result;
  58         int c;
  59         char temp[STRING_SIZE];
  60         struct keyvalue *mainkv = initkeyvalues();
  61         struct keyvalue *dhcpkv = initkeyvalues();
  62         struct keyvalue *ethernetkv = initkeyvalues();
  63         int error;
  64         FILE *file;
  65         char greenaddress[STRING_SIZE];
  66         char greennetaddress[STRING_SIZE];
  67         char greennetmask[STRING_SIZE];
  68
  69         memset(defaults, 0, sizeof(char) * STRING_SIZE * MAX_BOXES);
  70
  71         if (!(readkeyvalues(dhcpkv, CONFIG_ROOT "/dhcp/settings")))
  72         {
  73                 freekeyvalues(dhcpkv);
  74                 freekeyvalues(ethernetkv);
  75                 errorbox(ctr[TR_UNABLE_TO_OPEN_SETTINGS_FILE]);
  76                 return 0;
  77         }
  78         if (!(readkeyvalues(ethernetkv, CONFIG_ROOT "/ethernet/settings")))
  79         {
  80                 freekeyvalues(dhcpkv);
  81                 freekeyvalues(ethernetkv);
  82                 errorbox(ctr[TR_UNABLE_TO_OPEN_SETTINGS_FILE]);
  83                 return 0;
  84         }
  85         if (!(readkeyvalues(mainkv, CONFIG_ROOT "/main/settings")))
  86         {
  87                 freekeyvalues(dhcpkv);
  88                 freekeyvalues(ethernetkv);
  89                 freekeyvalues(mainkv);
  90                 errorbox(ctr[TR_UNABLE_TO_OPEN_SETTINGS_FILE]);
  91                 return 0;
  92         }
  93
  94         /* Set default values. */
  95         findkey(ethernetkv, "GREEN_ADDRESS", defaults[PRIMARY_DNS]);
  96         findkey(mainkv, "DOMAINNAME", defaults[DOMAIN_NAME_SUFFIX]);
  97         strcpy(defaults[DEFAULT_LEASE_TIME], "60");
  98         strcpy(defaults[MAX_LEASE_TIME], "120");
  99
 100         sprintf(message, ctr[TR_DHCP_SERVER_CONFIGURATION]);
 101         newtCenteredWindow(55, 18, message);
 102
 103         dhcpform = newtForm(NULL, NULL, 0);
 104
 105         sprintf(message, ctr[TR_CONFIGURE_DHCP]);
 106         header = newtTextboxReflowed(1, 1, message, 52, 0, 0, 0);
 107         newtFormAddComponent(dhcpform, header);
 108
 109         strcpy(temp, ""); findkey(dhcpkv, "ENABLE_GREEN", temp);
 110         if (strcmp(temp, "on") == 0)
 111                 startenabled = '*';
 112         else
 113                 startenabled = ' ';
 114         enabledcheckbox = newtCheckbox(2, TOP + 0, ctr[TR_ENABLED], startenabled, " *", &enabledresult);
 115         newtFormAddComponent(dhcpform, enabledcheckbox);
 116         newtComponentAddCallback(enabledcheckbox, dhcpdialogcallbackdhcp, NULL);
 117
 118         for (c = 0; c < MAX_BOXES; c++)
 119         {
 120                 labels[c] = newtTextbox(2, TOP + 2 + c, 33, 1, 0);
 121                 newtTextboxSetText(labels[c], labeltexts[c]);
 122                 newtFormAddComponent(dhcpform, labels[c]);
 123                 strcpy(temp, defaults[c]); findkey(dhcpkv, varnames[c], temp);
 124                 entries[c] = newtEntry(34, TOP + 2 + c, temp, 18, &results[c], 0);
 125                 newtFormAddComponent(dhcpform, entries[c]);
 126                 if (startenabled == ' ')
 127                         newtEntrySetFlags(entries[c], NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
 128
 129         }
 130
 131         ok = newtButton(10, c + 7, ctr[TR_OK]);
 132         cancel = newtButton(34, c + 7, ctr[TR_CANCEL]);
 133
 134         newtFormAddComponents(dhcpform, ok, cancel, NULL);
 135
 136         do
 137         {
 138                 error = 0;
 139                 newtFormRun(dhcpform, &es);
 140
 141                 if (es.u.co == ok)
 142                 {
 143                         /* OK was pressed; verify the contents of each entry. */
 144                         if (enabledresult == '*')
 145                         {
 146                                 strcpy(message, ctr[TR_INVALID_FIELDS]);
 147                                 if (inet_addr(results[START_ADDRESS]) == INADDR_NONE)
 148                                 {
 149                                         strcat(message, ctr[TR_START_ADDRESS_CR]);
 150                                         error = 1;
 151                                 }
 152                                 if (inet_addr(results[END_ADDRESS]) == INADDR_NONE)
 153                                 {
 154                                         strcat(message, ctr[TR_END_ADDRESS_CR]);
 155                                         error = 1;
 156                                 }
 157                                 if (strlen(results[SECONDARY_DNS]))
 158                                 {
 159                                         if (inet_addr(results[PRIMARY_DNS]) == INADDR_NONE)
 160                                         {
 161                                                 strcat(message, ctr[TR_PRIMARY_DNS_CR]);
 162                                                 error = 1;
 163                                         }
 164                                 }
 165                                 if (strlen(results[SECONDARY_DNS]))
 166                                 {
 167                                         if (inet_addr(results[SECONDARY_DNS]) == INADDR_NONE)
 168                                         {
 169                                                 strcat(message, ctr[TR_SECONDARY_DNS_CR]);
 170                                                 error = 1;
 171                                         }
 172                                 }
 173                                 if (!(atol(results[DEFAULT_LEASE_TIME])))
 174                                 {
 175                                         strcat(message, ctr[TR_DEFAULT_LEASE_CR]);
 176                                         error = 1;
 177                                 }
 178                                 if (!(atol(results[MAX_LEASE_TIME])))
 179                                 {
 180                                         strcat(message, ctr[TR_MAX_LEASE_CR]);
 181                                         error = 1;
 182                                 }
 183                         }
 184
 185                         if (error)
 186                                 errorbox(message);
 187                         else
 188                         {
 189                                 for (c = 0; c < MAX_BOXES; c++)
 190                                         replacekeyvalue(dhcpkv, varnames[c], results[c]);
 191                                 if (enabledresult == '*')
 192                                 {
 193                                         replacekeyvalue(dhcpkv, "ENABLE_GREEN", "on");
 194                                         fclose(fopen(CONFIG_ROOT "/dhcp/enable_green", "w"));
 195                                         chown(CONFIG_ROOT "/dhcp/enable_green", 99, 99);
 196                                 }
 197                                 else
 198                                 {
 199                                         replacekeyvalue(dhcpkv, "ENABLE_GREEN", "off");
 200                                         unlink(CONFIG_ROOT "/dhcp/enable_green");
 201                                 }
 202                                 replacekeyvalue(dhcpkv, "VALID", "yes");
 203                                 writekeyvalues(dhcpkv, CONFIG_ROOT "/dhcp/settings");
 204
 205                                 findkey(ethernetkv, "GREEN_ADDRESS", greenaddress);
 206                                 findkey(ethernetkv, "GREEN_NETADDRESS", greennetaddress);
 207                                 findkey(ethernetkv, "GREEN_NETMASK", greennetmask);
 208
 209                                 file = fopen(CONFIG_ROOT "/dhcp/dhcpd.conf", "w");
 210                                 fprintf(file, "ddns-update-style none;\n");
 211                                 fprintf(file, "subnet %s netmask %s\n", greennetaddress, greennetmask);
 212                                 fprintf(file, "{\n");
 213                                 fprintf(file, "\toption subnet-mask %s;\n", greennetmask);
 214                                 fprintf(file, "\toption domain-name \"%s\";\n", results[DOMAIN_NAME_SUFFIX]);
 215                                 fprintf(file, "\toption routers %s;\n", greenaddress);
 216                                 if (strlen(results[PRIMARY_DNS]))
 217                                 {
 218                                         fprintf(file, "\toption domain-name-servers ");
 219                                         fprintf(file, "%s", results[PRIMARY_DNS]);
 220                                         if (strlen(results[SECONDARY_DNS]))
 221                                                 fprintf(file, ", %s", results[SECONDARY_DNS]);
 222                                         fprintf(file, ";\n");
 223                                 }
 224
 225                                 fprintf(file, "\trange %s %s;\n",       results[START_ADDRESS], results[END_ADDRESS]);
 226                                 fprintf(file, "\tdefault-lease-time %d;\n", (int) atol(results[DEFAULT_LEASE_TIME]) * 60);
 227                                 fprintf(file, "\tmax-lease-time %d;\n", (int) atol(results[MAX_LEASE_TIME]) * 60);
 228                                 fprintf(file, "}\n");
 229                                 fclose(file);
 230                                 chown(CONFIG_ROOT "/dhcp/dhcpd.conf", 99, 99);
 231                                 if (automode == 0)
 232                                         mysystem("/usr/local/bin/restartdhcp");
 233                         }
 234                         result = 1;
 235                 }
 236                 else
 237                         result = 0;
 238         }
 239         while (error);
 240
 241         newtFormDestroy(dhcpform);
 242         newtPopWindow();
 243
 244         freekeyvalues(dhcpkv);
 245         freekeyvalues(ethernetkv);
 246         freekeyvalues(mainkv);
 247
 248         return result;
 249 }
 250
 251 /* Called when enabled flag is toggled.  Toggle disabled state of other 3
 252  * controls. */
 253 void dhcpdialogcallbackdhcp(newtComponent cm, void *data)
 254 {
 255         int c;
 256
 257         for (c = 0; c < MAX_BOXES; c++)
 258                 newtEntrySetFlags(entries[c], NEWT_FLAG_DISABLED, NEWT_FLAGS_TOGGLE);
 259
 260         newtRefresh();
 261         newtDrawForm(dhcpform);
 262 }