static char *newKickstartLocation(const char *origLocation) {
const char *location;
char *retval = NULL;
newtComponent f, okay, cancel, answer, locationEntry;
newtGrid grid, buttons;
startNewt();
locationEntry = newtEntry(-1, -1, NULL, 60, &location, NEWT_FLAG_SCROLL);
newtEntrySet(locationEntry, origLocation, 1);
/* button bar at the bottom of the window */
buttons = newtButtonBar(_("OK"), &okay, _("Cancel"), &cancel, NULL);
grid = newtCreateGrid(1, 3);
newtGridSetField(grid, 0, 0, NEWT_GRID_COMPONENT,
newtTextboxReflowed(-1, -1, _("Unable to download the kickstart file. Please modify the kickstart parameter below or press Cancel to proceed as an interactive installation."), 60, 0, 0, 0),
0, 0, 0, 0, NEWT_ANCHOR_LEFT, 0);
newtGridSetField(grid, 0, 1, NEWT_GRID_COMPONENT, locationEntry,
0, 1, 0, 0, NEWT_ANCHOR_LEFT, 0);
newtGridSetField(grid, 0, 2, NEWT_GRID_SUBGRID, buttons,
0, 1, 0, 0, 0, NEWT_GRID_FLAG_GROWX);
f = newtForm(NULL, NULL, 0);
newtGridAddComponentsToForm(grid, f, 1);
newtGridWrappedWindow(grid, _("Error downloading kickstart file"));
newtGridFree(grid, 1);
/* run the form */
answer = newtRunForm(f);
if (answer != cancel)
retval = strdup(location);
newtFormDestroy(f);
newtPopWindow();
return retval;
}
static void
nmt_newt_dialog_g_log_handler (const char *log_domain,
GLogLevelFlags log_level,
const char *message,
gpointer user_data)
{
const char *level_name;
char *full_message;
int screen_width, screen_height;
newtComponent text, ok, form;
newtGrid grid;
g_assert (!(log_level & G_LOG_FLAG_RECURSION));
if (log_level & G_LOG_LEVEL_DEBUG)
return;
switch (log_level & G_LOG_LEVEL_MASK) {
case G_LOG_LEVEL_ERROR:
level_name = "ERROR";
break;
case G_LOG_LEVEL_CRITICAL:
level_name = "CRITICAL";
break;
case G_LOG_LEVEL_WARNING:
level_name = "WARNING";
break;
case G_LOG_LEVEL_MESSAGE:
level_name = "Message";
break;
default:
level_name = NULL;
}
full_message = g_strdup_printf ("%s%s%s%s%s",
log_domain ? log_domain : "",
log_domain && level_name ? " " : "",
level_name ? level_name : "",
log_domain || level_name ? ": " : "",
message);
/* newtWinMessage() wraps the window too narrowly by default, so
* we don't want to use that. But we intentionally avoid using any
* NmtNewt classes, to avoid possible error recursion.
*/
newtGetScreenSize (&screen_width, &screen_height);
text = newtTextboxReflowed (-1, -1, full_message, MAX (70, screen_width - 10), 0, 0, 0);
g_free (full_message);
ok = newtButton (-1, -1, "OK");
grid = newtCreateGrid (1, 2);
newtGridSetField (grid, 0, 0, NEWT_GRID_COMPONENT, text, 0, 0, 0, 0, 0, 0);
newtGridSetField (grid, 0, 1, NEWT_GRID_COMPONENT, ok, 0, 1, 0, 0,
NEWT_ANCHOR_RIGHT, 0);
newtGridWrappedWindow (grid, (char *) (level_name ? level_name : ""));
newtGridFree (grid, TRUE);
form = newtForm (NULL, NULL, 0);
newtFormAddComponents (form, text, ok, NULL);
newtRunForm (form);
newtFormDestroy (form);
newtPopWindow ();
}
/* only supports up to 50 buttons and entries -- shucks! */
static int mynewtWinEntries(char * title, char * text, int suggestedWidth, int flexDown,
int flexUp, int dataWidth, void (*callback_func)(char ** strings),
struct newtWinEntry * items, char * button1, ...) {
newtComponent buttons[50], result, form, textw;
newtGrid grid, buttonBar, subgrid;
int numItems;
int rc, i;
int numButtons;
char * buttonName;
newtComponent entries[50];
va_list args;
textw = newtTextboxReflowed(-1, -1, text, suggestedWidth, flexDown,
flexUp, 0);
for (numItems = 0; items[numItems].text; numItems++);
buttonName = button1, numButtons = 0;
va_start(args, button1);
while (buttonName) {
buttons[numButtons] = newtButton(-1, -1, buttonName);
numButtons++;
buttonName = va_arg(args, char *);
}
va_end(args);
buttonBar = newtCreateGrid(numButtons, 1);
for (i = 0; i < numButtons; i++) {
newtGridSetField(buttonBar, i, 0, NEWT_GRID_COMPONENT,
buttons[i],
i ? 1 : 0, 0, 0, 0, 0, 0);
}
if (callback_func) {
callback_real_function = callback_func;
entries[numItems] = NULL;
}
else
callback_real_function = NULL;
subgrid = newtCreateGrid(2, numItems);
for (i = 0; i < numItems; i++) {
newtComponent entr = newtEntry(-1, -1, items[i].value ?
*items[i].value : NULL, dataWidth,
(const char**)items[i].value, items[i].flags);
newtGridSetField(subgrid, 0, i, NEWT_GRID_COMPONENT,
newtLabel(-1, -1, items[i].text),
0, 0, 0, 0, NEWT_ANCHOR_LEFT, 0);
newtGridSetField(subgrid, 1, i, NEWT_GRID_COMPONENT,
entr,
1, 0, 0, 0, 0, 0);
if (callback_func) {
entries[i] = entr;
newtComponentAddCallback(entr, default_callback, entries);
}
}
grid = newtCreateGrid(1, 3);
form = newtForm(NULL, 0, 0);
newtGridSetField(grid, 0, 0, NEWT_GRID_COMPONENT, textw,
0, 0, 0, 0, NEWT_ANCHOR_LEFT, 0);
newtGridSetField(grid, 0, 1, NEWT_GRID_SUBGRID, subgrid,
0, 1, 0, 0, 0, 0);
newtGridSetField(grid, 0, 2, NEWT_GRID_SUBGRID, buttonBar,
0, 1, 0, 0, 0, NEWT_GRID_FLAG_GROWX);
newtGridAddComponentsToForm(grid, form, 1);
newtGridWrappedWindow(grid, title);
newtGridFree(grid, 1);
result = newtRunForm(form);
for (rc = 0; rc < numItems; rc++)
*items[rc].value = strdup(*items[rc].value);
for (rc = 0; result != buttons[rc] && rc < numButtons; rc++);
if (rc == numButtons)
rc = 0; /* F12 */
else
rc++;
newtFormDestroy(form);
newtPopWindow();
return rc;
}
int handledhcp(void)
{
char *results[MAX_BOXES];
char enabledresult;
char startenabled;
struct newtExitStruct es;
newtComponent header;
newtComponent labels[MAX_BOXES];
newtComponent ok, cancel;
char message[1000];
char *labeltexts[MAX_BOXES] = {
_("Start address:"),
_("End address:"),
_("Primary DNS:"),
_("Secondary DNS:"),
_("Default lease (mins):"),
_("Max lease (mins):"),
_("Domain name suffix:")
};
char *varnames[MAX_BOXES] = {
"START_ADDR_GREEN",
"END_ADDR_GREEN",
"DNS1_GREEN",
"DNS2_GREEN",
"DEFAULT_LEASE_TIME_GREEN",
"MAX_LEASE_TIME_GREEN",
"DOMAIN_NAME_GREEN"
};
char defaults[MAX_BOXES][STRING_SIZE];
int result;
int c;
char temp[STRING_SIZE];
struct keyvalue *mainkv = initkeyvalues();
struct keyvalue *dhcpkv = initkeyvalues();
struct keyvalue *ethernetkv = initkeyvalues();
int error;
FILE *file;
char greenaddress[STRING_SIZE];
char greennetaddress[STRING_SIZE];
char greennetmask[STRING_SIZE];
memset(defaults, 0, sizeof(char) * STRING_SIZE * MAX_BOXES);
if (!(readkeyvalues(dhcpkv, CONFIG_ROOT "/dhcp/settings")))
{
freekeyvalues(dhcpkv);
freekeyvalues(ethernetkv);
errorbox(_("Unable to open settings file"));
return 0;
}
if (!(readkeyvalues(ethernetkv, CONFIG_ROOT "/ethernet/settings")))
{
freekeyvalues(dhcpkv);
freekeyvalues(ethernetkv);
errorbox(_("Unable to open settings file"));
return 0;
}
if (!(readkeyvalues(mainkv, CONFIG_ROOT "/main/settings")))
{
freekeyvalues(dhcpkv);
freekeyvalues(ethernetkv);
freekeyvalues(mainkv);
errorbox(_("Unable to open settings file"));
return 0;
}
/* Set default values. */
findkey(ethernetkv, "GREEN_ADDRESS", defaults[PRIMARY_DNS]);
findkey(mainkv, "DOMAINNAME", defaults[DOMAIN_NAME_SUFFIX]);
strcpy(defaults[DEFAULT_LEASE_TIME], "60");
strcpy(defaults[MAX_LEASE_TIME], "120");
newtCenteredWindow(55, 18, _("DHCP server configuration"));
dhcpform = newtForm(NULL, NULL, 0);
header = newtTextboxReflowed(1, 1,
_("Configure the DHCP server by entering the settings information."),
52, 0, 0, 0);
newtFormAddComponent(dhcpform, header);
strcpy(temp, ""); findkey(dhcpkv, "ENABLE_GREEN", temp);
if (strcmp(temp, "on") == 0)
startenabled = '*';
else
startenabled = ' ';
enabledcheckbox = newtCheckbox(2, TOP + 0, _("Enabled"), startenabled, " *", &enabledresult);
newtFormAddComponent(dhcpform, enabledcheckbox);
newtComponentAddCallback(enabledcheckbox, dhcpdialogcallbackdhcp, NULL);
for (c = 0; c < MAX_BOXES; c++)
{
labels[c] = newtTextbox(2, TOP + 2 + c, 33, 1, 0);
newtTextboxSetText(labels[c], labeltexts[c]);
newtFormAddComponent(dhcpform, labels[c]);
strcpy(temp, defaults[c]); findkey(dhcpkv, varnames[c], temp);
entries[c] = newtEntry(34, TOP + 2 + c, temp, 18, &results[c], 0);
newtFormAddComponent(dhcpform, entries[c]);
if (startenabled == ' ')
newtEntrySetFlags(entries[c], NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
}
ok = newtButton(10, c + 7, _("OK"));
cancel = newtButton(34, c + 7, _("Cancel"));
newtFormAddComponents(dhcpform, ok, cancel, NULL);
do {
error = 0;
newtFormRun(dhcpform, &es);
if (es.u.co == ok)
{
/* OK was pressed; verify the contents of each entry. */
if (enabledresult == '*')
{
strcpy(message, _("The following fields are invalid:\n\n"));
if (inet_addr(results[START_ADDRESS]) == INADDR_NONE)
{
strcat(message, _("Start address"));
strcat(message, "\n");
error = 1;
}
if (inet_addr(results[END_ADDRESS]) == INADDR_NONE)
{
strcat(message, _("End address"));
strcat(message, "\n");
error = 1;
}
if (strlen(results[SECONDARY_DNS]))
{
if (inet_addr(results[PRIMARY_DNS]) == INADDR_NONE)
{
strcat(message, _("Primary DNS"));
strcat(message, "\n");
error = 1;
}
}
if (strlen(results[SECONDARY_DNS]))
{
if (inet_addr(results[SECONDARY_DNS]) == INADDR_NONE)
{
strcat(message, _("Secondary DNS"));
strcat(message, "\n");
error = 1;
}
}
if (!(atol(results[DEFAULT_LEASE_TIME])))
{
strcat(message, _("Default lease time"));
strcat(message, "\n");
error = 1;
}
if (!(atol(results[MAX_LEASE_TIME])))
{
strcat(message, _("Max. lease time"));
strcat(message, "\n");
error = 1;
}
}
if (error)
errorbox(message);
else
{
for (c = 0; c < MAX_BOXES; c++)
replacekeyvalue(dhcpkv, varnames[c], results[c]);
if (enabledresult == '*')
{
replacekeyvalue(dhcpkv, "ENABLE_GREEN", "on");
fclose(fopen(CONFIG_ROOT "/dhcp/enable_green", "w"));
chown(CONFIG_ROOT "/dhcp/enable_green", 99, 99);
mysystem(NULL, "/usr/local/bin/dhcpctrl enable");
}
else
{
replacekeyvalue(dhcpkv, "ENABLE_GREEN", "off");
unlink(CONFIG_ROOT "/dhcp/enable_green");
mysystem(NULL, "/usr/local/bin/dhcpctrl disable");
}
replacekeyvalue(dhcpkv, "VALID", "yes");
writekeyvalues(dhcpkv, CONFIG_ROOT "/dhcp/settings");
findkey(ethernetkv, "GREEN_ADDRESS", greenaddress);
findkey(ethernetkv, "GREEN_NETADDRESS", greennetaddress);
findkey(ethernetkv, "GREEN_NETMASK", greennetmask);
file = fopen(CONFIG_ROOT "/dhcp/dhcpd.conf", "w");
fprintf(file, "ddns-update-style none;\n");
fprintf(file, "authoritative;\n");
fprintf(file, "subnet %s netmask %s\n", greennetaddress, greennetmask);
fprintf(file, "{\n");
fprintf(file, "\toption subnet-mask %s;\n", greennetmask);
fprintf(file, "\toption domain-name \"%s\";\n", results[DOMAIN_NAME_SUFFIX]);
fprintf(file, "\toption routers %s;\n", greenaddress);
if (strlen(results[PRIMARY_DNS]))
{
fprintf(file, "\toption domain-name-servers ");
fprintf(file, "%s", results[PRIMARY_DNS]);
if (strlen(results[SECONDARY_DNS]))
fprintf(file, ", %s", results[SECONDARY_DNS]);
fprintf(file, ";\n");
}
fprintf(file, "\trange %s %s;\n", results[START_ADDRESS], results[END_ADDRESS]);
fprintf(file, "\tdefault-lease-time %d;\n", (int) atol(results[DEFAULT_LEASE_TIME]) * 60);
fprintf(file, "\tmax-lease-time %d;\n", (int) atol(results[MAX_LEASE_TIME]) * 60);
fprintf(file, "}\n");
fclose(file);
chown(CONFIG_ROOT "/dhcp/dhcpd.conf", 99, 99);
if (automode == 0)
mysystem(NULL, "/usr/local/bin/dhcpctrl enable");
}
result = 1;
}
else
result = 0;
} while (error);
newtFormDestroy(dhcpform);
newtPopWindow();
freekeyvalues(dhcpkv);
freekeyvalues(ethernetkv);
freekeyvalues(mainkv);
return result;
}
/**
* Pop up a dialog box with user-defined buttons.
* @param p The text to put in the dialog box.
* @param button1 The label on the first button.
* @param button2 The label on the second button, or "" if you only want one button.
* @return TRUE if @p button1 was pushed, FALSE otherwise.
*/
bool popup_with_buttons(char *p, char *button1, char *button2) {
/*@ buffers *********************************************************** */
char *prompt;
char *tmp = NULL;
size_t n = 0;
/*@ newt ************************************************************** */
newtComponent myForm;
newtComponent b_1;
newtComponent b_2;
newtComponent b_res;
newtComponent text;
assert_string_is_neither_NULL_nor_zerolength(p);
assert(button1 != NULL);
assert(button2 != NULL);
if (g_text_mode) {
if (strlen(button2) == 0) {
printf("%s (%s) --> ", p, button1);
} else {
printf("%s (%s or %s) --> ", p, button1, button2);
}
for (asprintf(&tmp, " ");
strcmp(tmp, button1) && (strlen(button2) == 0
|| strcmp(tmp, button2));) {
printf("--> ");
paranoid_free(tmp);
(void) getline(&tmp, &n, stdin);
}
if (!strcmp(tmp, button1)) {
paranoid_free(tmp);
return (TRUE);
} else {
paranoid_free(tmp);
return (FALSE);
}
}
asprintf(&prompt, p);
text = newtTextboxReflowed(1, 1, prompt, 40, 5, 5, 0);
b_1 =
newtButton(20 -
((button2[0] !=
'\0') ? strlen(button1) +
2 : strlen(button1) / 2),
newtTextboxGetNumLines(text) + 3, button1);
if (button2[0] != '\0') {
b_2 =
newtButton(24, newtTextboxGetNumLines(text) + 3, button2);
} else {
b_2 = NULL;
}
// newtOpenWindow (25, 5, 46, newtTextboxGetNumLines (text) + 7, "Alert");
newtCenteredWindow(46, newtTextboxGetNumLines(text) + 7, _("Alert"));
myForm = newtForm(NULL, NULL, 0);
newtFormAddComponents(myForm, text, b_1, b_2, NULL);
/* BERLIOS: center_string is now broken replace it ! */
//center_string(prompt, 80);
newtPushHelpLine(prompt);
paranoid_free(prompt);
b_res = newtRunForm(myForm);
newtPopHelpLine();
newtFormDestroy(myForm);
newtPopWindow();
if (b_res == b_1) {
return (TRUE);
} else {
return (FALSE);
}
}
/**
* Ask the user to enter a value.
* @param title The title of the dialog box.
* @param b The blurb (e.g. what you want the user to enter).
* @param output The string to put the user's answer in. It has to be freed by the caller
* @return TRUE if the user pressed OK, FALSE if they pressed Cancel.
*/
bool popup_and_get_string(char *title, char *b, char *output) {
/*@ newt ************************************************************ */
newtComponent myForm;
newtComponent b_1;
newtComponent b_2;
newtComponent b_res;
newtComponent text;
newtComponent type_here;
/*@ pointers ********************************************************* */
char *entry_value = NULL;
/*@ buffers ********************************************************** */
char *blurb = NULL;
size_t n = 0;
bool ret = TRUE;
assert_string_is_neither_NULL_nor_zerolength(title);
assert(b != NULL);
if (g_text_mode) {
printf
("---promptstring---1--- %s\r\n---promptstring---2--- %s\r\n---promptstring---Q---\r\n--> ",
title, b);
paranoid_free(output);
(void) getline(&output, &n, stdin);
if (output[strlen(output) - 1] == '\n')
output[strlen(output) - 1] = '\0';
return (ret);
}
asprintf(&blurb, b);
text = newtTextboxReflowed(2, 1, blurb, 48, 5, 5, 0);
type_here =
newtEntry(2, newtTextboxGetNumLines(text) + 2,
output, 50,
&entry_value, NEWT_FLAG_RETURNEXIT
);
b_1 = newtButton(6, newtTextboxGetNumLines(text) + 4, _(" OK "));
b_2 = newtButton(18, newtTextboxGetNumLines(text) + 4, _("Cancel"));
newtCenteredWindow(54, newtTextboxGetNumLines(text) + 9, title);
myForm = newtForm(NULL, NULL, 0);
newtFormAddComponents(myForm, text, type_here, b_1, b_2, NULL);
/* BERLIOS: center_string is now broken replace it ! */
//center_string(blurb, 80);
newtPushHelpLine(blurb);
paranoid_free(blurb);
b_res = newtRunForm(myForm);
newtPopHelpLine();
if (b_res == b_2) {
ret = FALSE;
} else {
// Copy entry_value before destroying the form
// clearing potentially output before
paranoid_alloc(output,entry_value);
}
newtFormDestroy(myForm);
newtPopWindow();
return(ret);
}
/* This is a groovie dialog for showing network info. Takes a keyvalue list,
* a colour and a dhcp flag. Shows the current settings, and rewrites them
* if necessary. DHCP flag sets wether to show the dhcp checkbox. */
int changeaddress(struct keyvalue *kv, char *colour, int typeflag,
char *defaultdhcphostname)
{
char *addressresult;
char *netmaskresult;
char *dhcphostnameresult;
char *dhcpforcemturesult;
struct newtExitStruct es;
newtComponent header;
newtComponent addresslabel;
newtComponent netmasklabel;
newtComponent dhcphostnamelabel;
newtComponent dhcpforcemtulabel;
newtComponent ok, cancel;
char message[1000];
char temp[STRING_SIZE];
char addressfield[STRING_SIZE];
char netmaskfield[STRING_SIZE];
char typefield[STRING_SIZE];
char dhcphostnamefield[STRING_SIZE];
char dhcpforcemtufield[STRING_SIZE];
int error;
int result = 0;
char type[STRING_SIZE];
int startstatictype = 0;
int startdhcptype = 0;
int startpppoetype = 0;
/* Build some key strings. */
sprintf(addressfield, "%s_ADDRESS", colour);
sprintf(netmaskfield, "%s_NETMASK", colour);
sprintf(typefield, "%s_TYPE", colour);
sprintf(dhcphostnamefield, "%s_DHCP_HOSTNAME", colour);
sprintf(dhcpforcemtufield, "%s_DHCP_FORCE_MTU", colour);
sprintf(message, _("Interface - %s"), colour);
newtCenteredWindow(44, (typeflag ? 18 : 12), message);
networkform = newtForm(NULL, NULL, 0);
sprintf(message, _("Enter the IP address information for the %s interface."), colour);
header = newtTextboxReflowed(1, 1, message, 42, 0, 0, 0);
newtFormAddComponent(networkform, header);
/* See if we need a dhcp checkbox. If we do, then we shift the contents
* of the window down two rows to make room. */
if (typeflag)
{
strcpy(temp, "STATIC"); findkey(kv, typefield, temp);
if (strcmp(temp, "STATIC") == 0) startstatictype = 1;
if (strcmp(temp, "DHCP") == 0) startdhcptype = 1;
if (strcmp(temp, "PPPOE") == 0) startpppoetype = 1;
statictyperadio = newtRadiobutton(2, 4, _("Static"), startstatictype, NULL);
dhcptyperadio = newtRadiobutton(2, 5, _("DHCP"), startdhcptype, statictyperadio);
pppoetyperadio = newtRadiobutton(2, 6, _("PPP DIALUP (PPPoE, modem, ATM ...)"),
startpppoetype, dhcptyperadio);
newtFormAddComponents(networkform, statictyperadio, dhcptyperadio,
pppoetyperadio, NULL);
newtComponentAddCallback(statictyperadio, networkdialogcallbacktype, NULL);
newtComponentAddCallback(dhcptyperadio, networkdialogcallbacktype, NULL);
newtComponentAddCallback(pppoetyperadio, networkdialogcallbacktype, NULL);
dhcphostnamelabel = newtTextbox(2, 8, 18, 1, 0);
newtTextboxSetText(dhcphostnamelabel, _("DHCP Hostname:"));
dhcpforcemtulabel = newtTextbox(2, 9, 18, 1, 0);
newtTextboxSetText(dhcpforcemtulabel, _("Force DHCP MTU:"));
strcpy(temp, defaultdhcphostname);
findkey(kv, dhcphostnamefield, temp);
dhcphostnameentry = newtEntry(20, 8, temp, 20, &dhcphostnameresult, 0);
strcpy(temp, "");
findkey(kv, dhcpforcemtufield, temp);
dhcpforcemtuentry = newtEntry(20, 9, temp, 20, &dhcpforcemturesult, 0);
newtFormAddComponent(networkform, dhcphostnamelabel);
newtFormAddComponent(networkform, dhcphostnameentry);
newtFormAddComponent(networkform, dhcpforcemtulabel);
newtFormAddComponent(networkform, dhcpforcemtuentry);
if (startdhcptype == 0)
{
newtEntrySetFlags(dhcphostnameentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
newtEntrySetFlags(dhcpforcemtuentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
}
}
/* Address */
addresslabel = newtTextbox(2, (typeflag ? 11 : 4) + 0, 18, 1, 0);
newtTextboxSetText(addresslabel, _("IP address:"));
strcpy(temp, "");
findkey(kv, addressfield, temp);
addressentry = newtEntry(20, (typeflag ? 11 : 4) + 0, temp, 20, &addressresult, 0);
newtEntrySetFilter(addressentry, ip_input_filter, NULL);
if (typeflag == 1 && startstatictype == 0)
newtEntrySetFlags(addressentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
newtFormAddComponent(networkform, addresslabel);
newtFormAddComponent(networkform, addressentry);
/* Netmask */
netmasklabel = newtTextbox(2, (typeflag ? 11 : 4) + 1, 18, 1, 0);
newtTextboxSetText(netmasklabel, _("Network mask:"));
strcpy(temp, "255.255.255.0"); findkey(kv, netmaskfield, temp);
netmaskentry = newtEntry(20, (typeflag ? 11 : 4) + 1, temp, 20, &netmaskresult, 0);
newtEntrySetFilter(netmaskentry, ip_input_filter, NULL);
if (typeflag == 1 && startstatictype == 0)
newtEntrySetFlags(netmaskentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
newtFormAddComponent(networkform, netmasklabel);
newtFormAddComponent(networkform, netmaskentry);
/* Buttons. */
ok = newtButton(8, (typeflag ? 14 : 7), _("OK"));
cancel = newtButton(26, (typeflag ? 14 : 7), _("Cancel"));
newtFormAddComponents(networkform, ok, cancel, NULL);
newtRefresh();
newtDrawForm(networkform);
do
{
error = 0;
newtFormRun(networkform, &es);
if (es.u.co == ok)
{
/* OK was pressed; verify the contents of each entry. */
strcpy(message, _("The following fields are invalid:"));
strcat(message, "\n\n");
strcpy(type, "STATIC");
if (typeflag)
gettype(type);
if (strcmp(type, "STATIC") == 0)
{
if (inet_addr(addressresult) == INADDR_NONE)
{
strcat(message, _("IP address"));
strcat(message, "\n");
error = 1;
}
if (inet_addr(netmaskresult) == INADDR_NONE)
{
strcat(message, _("Network mask"));
strcat(message, "\n");
error = 1;
}
}
if (strcmp(type, "DHCP") == 0)
{
if (!strlen(dhcphostnameresult))
{
strcat(message, _("DHCP hostname"));
strcat(message, "\n");
error = 1;
}
}
if (error)
errorbox(message);
else
{
/* No errors! Set new values, depending on dhcp flag etc. */
if (typeflag)
{
replacekeyvalue(kv, dhcphostnamefield, dhcphostnameresult);
replacekeyvalue(kv, dhcpforcemtufield, dhcpforcemturesult);
if (strcmp(type, "STATIC") != 0)
{
replacekeyvalue(kv, addressfield, "0.0.0.0");
replacekeyvalue(kv, netmaskfield, "0.0.0.0");
}
else
{
replacekeyvalue(kv, addressfield, addressresult);
replacekeyvalue(kv, netmaskfield, netmaskresult);
}
replacekeyvalue(kv, typefield, type);
}
else
{
replacekeyvalue(kv, addressfield, addressresult);
replacekeyvalue(kv, netmaskfield, netmaskresult);
}
setnetaddress(kv, colour);
result = 1;
}
}
/* Workaround for a bug that dhcp radiobutton also end the dialog at arm
*/
else {
if (es.u.co != cancel) {
error = 1;
}
}
}
while (error);
newtFormDestroy(networkform);
newtPopWindow();
return result;
}
/* Browse through a directory structure looking for a file.
* Returns the full path to the file.
*
* Parameters:
* title: Title for newt dialog window
* dirname: Directory to use for root of browsing. NOTE: you cannot go
* up above this root.
* filterfunc: An (optional) function to filter out files based on whatever
* criteria you want. Returns 1 if it passes, 0 if not.
* Function should take arguments of the directory name and
* the dirent for the file.
*/
char * newt_select_file(char * title, char * text, char * dirname,
int (*filterfunc)(char *, struct dirent *)) {
char ** files;
char * fn = NULL;
int i, done = 0;
char * topdir = dirname;
char * dir = malloc(PATH_MAX);
char * path = NULL;
newtGrid grid, buttons;
newtComponent f, tb, listbox, ok, cancel;
struct stat sb;
struct newtExitStruct es;
dir = realpath(dirname, dir);
do {
files = get_file_list(dir, filterfunc);
f = newtForm(NULL, NULL, 0);
grid = newtCreateGrid(1, 4);
tb = newtTextboxReflowed(-1, -1, text, 60, 0, 10, 0);
listbox = newtListbox(12, 65, 10,
NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
newtListboxSetWidth(listbox, 55);
buttons = newtButtonBar(_("OK"), &ok, _("Cancel"), &cancel, NULL);
newtGridSetField(grid, 0, 0, NEWT_GRID_COMPONENT, tb,
0, 0, 0, 1, 0, 0);
newtGridSetField(grid, 0, 1, NEWT_GRID_COMPONENT, listbox,
0, 0, 0, 1, 0, 0);
newtGridSetField(grid, 0, 3, NEWT_GRID_SUBGRID, buttons,
0, 0, 0, 0, 0, NEWT_GRID_FLAG_GROWX);
/* if this isn't our topdir, we want to let them go up a dir */
if (strcmp(topdir, dir))
newtListboxAppendEntry(listbox, "../", "..");
for (i = 0; (files[i] != NULL); i++) {
if ((files[i] == NULL) || (strlen(files[i]) == 0)) continue;
path = malloc(strlen(files[i]) + strlen(dir) + 2);
sprintf(path, "%s/%s", dir, files[i]);
stat(path, &sb);
free(path);
if (S_ISDIR(sb.st_mode)) {
char *dir = malloc(strlen(files[i]) + 2);
sprintf(dir, "%s/", files[i]);
newtListboxAppendEntry(listbox, dir, files[i]);
} else {
newtListboxAppendEntry(listbox, files[i], files[i]);
}
}
newtGridWrappedWindow(grid, title);
newtGridAddComponentsToForm(grid, f, 1);
newtFormRun(f, &es);
if (es.reason == NEWT_EXIT_COMPONENT && es.u.co == cancel) {
fn = NULL;
done = -1;
} else {
fn = (char *) newtListboxGetCurrent(listbox);
path = malloc(strlen(fn) + strlen(dir) + 2);
sprintf(path, "%s/%s", dir, fn);
stat(path, &sb);
if (!S_ISDIR(sb.st_mode)) {
fn = path;
done = 1;
} else {
dir = realpath(path, dir);
free(path);
}
}
newtGridFree(grid, 1);
newtFormDestroy(f);
newtPopWindow();
} while (done == 0);
return fn;
}
static int getManualModuleArgs(struct moduleInfo * mod, char *** moduleArgs) {
newtGrid grid, buttons;
newtComponent text, f, ok, back, entry;
struct newtExitStruct es;
int done = 0, i;
char * buf;
char *argsEntry = "";
if (*moduleArgs) {
for (i = 0; (*moduleArgs)[i]; i++)
argsEntry = strcat(argsEntry, (*moduleArgs)[i]);
}
f = newtForm(NULL, NULL, 0);
if (asprintf(&buf,
_("Please enter any parameters which you wish to pass "
"to the %s module separated by spaces. If you don't "
"know what parameters to supply, skip this screen "
"by pressing the \"OK\" button."), mod->moduleName) == -1) {
logMessage(CRITICAL, "%s: %d: %m", __func__, __LINE__);
abort();
}
text = newtTextboxReflowed(-1, -1, buf, 60, 0, 10, 0);
entry = newtEntry(-1, -1, argsEntry, 50, (const char **) &argsEntry,
NEWT_ENTRY_SCROLL);
newtFormAddHotKey(f, NEWT_KEY_F12);
buttons = newtButtonBar(_("OK"), &ok, _("Back"), &back, NULL);
grid = newtCreateGrid(1, 3);
newtGridSetField(grid, 0, 0, NEWT_GRID_COMPONENT, text,
0, 0, 0, 1, 0, 0);
newtGridSetField(grid, 0, 1, NEWT_GRID_COMPONENT, entry,
0, 0, 0, 1, 0, 0);
newtGridSetField(grid, 0, 2, NEWT_GRID_SUBGRID, buttons,
0, 0, 0, 0, 0, NEWT_GRID_FLAG_GROWX);
newtGridWrappedWindow(grid, _("Enter Module Parameters"));
newtGridAddComponentsToForm(grid, f, 1);
do {
newtFormRun(f, &es);
if (es.reason == NEWT_EXIT_COMPONENT && es.u.co == back) {
done = -1;
} else {
done = 1;
}
} while (done == 0);
free(buf);
newtGridFree(grid, 1);
if (done == -1) {
newtFormDestroy(f);
newtPopWindow();
return LOADER_BACK;
}
logMessage(INFO, "specified args of %s for %s", argsEntry, mod->moduleName);
if (strlen(argsEntry) > 0) {
int numAlloced = 5;
char * start;
char * end;
i = 0;
*moduleArgs = malloc((numAlloced + 1) * sizeof(*moduleArgs));
start = argsEntry;
while (start && *start) {
end = start;
while (!isspace(*end) && *end) end++;
*end = '\0';
(*moduleArgs)[i++] = strdup(start);
start = end + 1;
*end = ' ';
start = strchr(end, ' ');
if (start) start++;
if (i >= numAlloced) {
numAlloced += 5;
*moduleArgs = realloc(*moduleArgs,
sizeof(*moduleArgs) * (numAlloced + 1));
}
}
(*moduleArgs)[i] = NULL;
}
newtFormDestroy(f);
newtPopWindow();
return LOADER_OK;
}
/* setup hard drive based install from a partition with a filesystem and
* ISO images on that filesystem
*/
char * mountHardDrive(struct installMethod * method,
char * location, struct loaderData_s * loaderData) {
int rc;
int i;
newtComponent listbox, label, dirEntry, form, okay, back, text;
struct newtExitStruct es;
newtGrid entryGrid, grid, buttons;
int done = 0;
char * dir = strdup("");
char * tmpDir;
char * url = NULL;
char * buf, *substr;
int numPartitions;
char **partition_list;
char *selpart;
char *kspartition = NULL, *ksdirectory = NULL;
/* handle kickstart/stage2= data first if available */
if (loaderData->method == METHOD_HD && loaderData->stage2Data) {
kspartition = ((struct hdInstallData *)loaderData->stage2Data)->partition;
ksdirectory = ((struct hdInstallData *)loaderData->stage2Data)->directory;
logMessage(INFO, "partition is %s, dir is %s", kspartition, ksdirectory);
/* if exist, duplicate */
if (kspartition)
kspartition = strdup(kspartition);
if (ksdirectory) {
ksdirectory = strdup(ksdirectory);
} else {
ksdirectory = strdup("/images/install.img");
}
if (!kspartition || !ksdirectory) {
logMessage(ERROR, "missing partition or directory specification");
loaderData->method = -1;
if (loaderData->inferredStage2)
loaderData->invalidRepoParam = 1;
} else {
/* if we start with /dev, strip it (#121486) */
char *kspart = kspartition;
if (!strncmp(kspart, "/dev/", 5))
kspart = kspart + 5;
url = setupIsoImages(kspart, ksdirectory, location);
if (!url) {
logMessage(ERROR, "unable to find %s installation images on hd",
getProductName());
loaderData->method = -1;
if (loaderData->inferredStage2)
loaderData->invalidRepoParam = 1;
} else {
free(kspartition);
free(ksdirectory);
return url;
}
}
} else {
kspartition = NULL;
ksdirectory = NULL;
}
/* if we're here its either because this is interactive, or the */
/* hd kickstart directive was faulty and we have to prompt for */
/* location of harddrive image */
partition_list = NULL;
while (!done) {
/* if we're doing another pass free this up first */
if (partition_list)
freePartitionsList(partition_list);
partition_list = getPartitionsList(NULL);
numPartitions = lenPartitionsList(partition_list);
/* no partitions found, try to load a device driver disk for storage */
if (!numPartitions) {
rc = newtWinChoice(_("Hard Drives"), _("Yes"), _("Back"),
_("You don't seem to have any hard drives on "
"your system! Would you like to configure "
"additional devices?"));
if (rc == 2) {
loaderData->stage2Data = NULL;
return NULL;
}
rc = loadDriverFromMedia(DEVICE_DISK, loaderData, 0, 0);
continue;
}
/* now find out which partition has the stage2 image */
checked_asprintf(&buf, _("What partition and directory on that "
"partition holds the installation image "
"for %s? If you don't see the disk drive "
"you're using listed here, press F2 to "
"configure additional devices."),
getProductName());
text = newtTextboxReflowed(-1, -1, buf, 62, 5, 5, 0);
free(buf);
listbox = newtListbox(-1, -1, numPartitions > 5 ? 5 : numPartitions,
NEWT_FLAG_RETURNEXIT |
(numPartitions > 5 ? NEWT_FLAG_SCROLL : 0));
for (i = 0; i < numPartitions; i++)
newtListboxAppendEntry(listbox,partition_list[i],partition_list[i]);
/* if we had ks data around use it to prime entry, then get rid of it*/
if (kspartition) {
newtListboxSetCurrentByKey(listbox, kspartition);
free(kspartition);
kspartition = NULL;
}
label = newtLabel(-1, -1, _("Directory holding image:"));
dirEntry = newtEntry(28, 11, dir, 28, (const char **) &tmpDir,
NEWT_ENTRY_SCROLL);
/* if we had ks data around use it to prime entry, then get rid of it*/
if (ksdirectory) {
newtEntrySet(dirEntry, ksdirectory, 1);
free(ksdirectory);
ksdirectory = NULL;
}
entryGrid = newtGridHStacked(NEWT_GRID_COMPONENT, label,
NEWT_GRID_COMPONENT, dirEntry,
NEWT_GRID_EMPTY);
buttons = newtButtonBar(_("OK"), &okay, _("Back"), &back, NULL);
grid = newtCreateGrid(1, 4);
newtGridSetField(grid, 0, 0, NEWT_GRID_COMPONENT, text,
0, 0, 0, 1, 0, 0);
newtGridSetField(grid, 0, 1, NEWT_GRID_COMPONENT, listbox,
0, 0, 0, 1, 0, 0);
newtGridSetField(grid, 0, 2, NEWT_GRID_SUBGRID, entryGrid,
0, 0, 0, 1, 0, 0);
newtGridSetField(grid, 0, 3, NEWT_GRID_SUBGRID, buttons,
0, 0, 0, 0, 0, NEWT_GRID_FLAG_GROWX);
newtGridWrappedWindow(grid, _("Select Partition"));
form = newtForm(NULL, NULL, 0);
newtFormAddHotKey(form, NEWT_KEY_F2);
newtFormAddHotKey(form, NEWT_KEY_F12);
newtGridAddComponentsToForm(grid, form, 1);
newtGridFree(grid, 1);
newtFormRun(form, &es);
selpart = newtListboxGetCurrent(listbox);
free(dir);
if (tmpDir && *tmpDir) {
/* Protect from form free. */
dir = strdup(tmpDir);
} else {
dir = strdup("");
}
newtFormDestroy(form);
newtPopWindow();
if (es.reason == NEWT_EXIT_COMPONENT && es.u.co == back) {
loaderData->stage2Data = NULL;
return NULL;
} else if (es.reason == NEWT_EXIT_HOTKEY && es.u.key == NEWT_KEY_F2) {
rc = loadDriverFromMedia(DEVICE_DISK, loaderData, 0, 0);
continue;
}
logMessage(INFO, "partition %s selected", selpart);
/* If the user-provided URL points at a repo instead of a stage2
* image, fix that up now.
*/
substr = strstr(dir, ".img");
if (!substr || (substr && *(substr+4) != '\0')) {
checked_asprintf(&dir, "%s/images/install.img", dir);
}
loaderData->invalidRepoParam = 1;
url = setupIsoImages(selpart, dir, location);
if (!url) {
newtWinMessage(_("Error"), _("OK"),
_("Device %s does not appear to contain "
"an installation image."), selpart, getProductName());
continue;
}
done = 1;
}
free(dir);
return url;
}
/* Small window to change IP and Netmask of some colour */
void changeaddress(char *colour, int *changed_flag)
{
newtComponent networkform;
newtComponent text;
newtComponent ok, cancel;
struct newtExitStruct exitstruct;
char keyvalue[STRING_SIZE];
char addresskey[STRING_SIZE];
char netmaskkey[STRING_SIZE];
char netaddresskey[STRING_SIZE];
newtComponent addresslabel;
newtComponent netmasklabel;
newtComponent addressentry;
newtComponent netmaskentry;
const char *addressresult;
const char *netmaskresult;
char message[STRING_SIZE_LARGE];
int error;
int numLines;
char *tmpstring;
/* Build some key strings. */
sprintf(addresskey, "%s_1_ADDRESS", colour);
sprintf(netmaskkey, "%s_1_NETMASK", colour);
sprintf(netaddresskey, "%s_1_NETADDRESS", colour);
/* workaround gcc warning, there is really 1 %s there */
tmpstring=strdup(gettext("TR_ENTER_THE_IP_ADDRESS_INFORMATION"));
snprintf(message, STRING_SIZE, tmpstring, colour);
free(tmpstring);
text = newtTextboxReflowed(1, 1, message, 68, 0, 0, 0);
numLines = newtTextboxGetNumLines(text);
/* workaround gcc warning, there is really 1 %s there */
tmpstring=strdup(gettext("TR_INTERFACE"));
snprintf(message, STRING_SIZE, tmpstring, colour);
free(tmpstring);
newtCenteredWindow(72, 10 + numLines, message);
networkform = newtForm(NULL, NULL, 0);
newtFormAddComponent(networkform, text);
/* Address */
addresslabel = newtTextbox(2, 2 + numLines, 18, 1, 0);
newtTextboxSetText(addresslabel, gettext("TR_IP_ADDRESS_PROMPT"));
if (!strcmp(colour, "GREEN")) {
/* green only for now */
strcpy(keyvalue, DEFAULT_IP);
}
else {
strcpy(keyvalue, "");
}
find_kv_default(eth_kv, addresskey, keyvalue);
addressentry = newtEntry(20, 2 + numLines, keyvalue, 20, &addressresult, 0);
newtEntrySetFilter(addressentry, filterip, NULL);
newtFormAddComponent(networkform, addresslabel);
newtFormAddComponent(networkform, addressentry);
/* Netmask */
netmasklabel = newtTextbox(2, 3 + numLines, 18, 1, 0);
newtTextboxSetText(netmasklabel, gettext("TR_NETMASK_PROMPT"));
strcpy(keyvalue, DEFAULT_NETMASK);
find_kv_default(eth_kv, netmaskkey, keyvalue);
netmaskentry = newtEntry(20, 3 + numLines, keyvalue, 20, &netmaskresult, 0);
newtEntrySetFilter(netmaskentry, filterip, NULL);
newtFormAddComponent(networkform, netmasklabel);
newtFormAddComponent(networkform, netmaskentry);
ok = newtButton(6, 5 + numLines, gettext("TR_OK"));
/* In case of installer we need a valid address, no turning back */
if (flag_is_state == setupchroot) {
newtFormAddComponent(networkform, ok);
}
else {
cancel = newtButton(26, 5 + numLines, gettext("TR_GO_BACK"));
newtFormAddComponents(networkform, ok, cancel, NULL);
}
newtRefresh();
newtDrawForm(networkform);
do {
error = 0;
newtFormRun(networkform, &exitstruct);
if (exitstruct.u.co == ok) {
strcpy(message, gettext("TR_INVALID_FIELDS"));
if (VALID_IP(addressresult) == FALSE) {
strcat(message, gettext("TR_IP_ADDRESS_CR"));
error = 1;
newtFormSetCurrent(networkform, addressentry);
}
if (VALID_IP(netmaskresult) == FALSE) {
strcat(message, gettext("TR_NETWORK_MASK_CR"));
error = 1;
newtFormSetCurrent(networkform, netmaskentry);
}
// TODO: additional network mask validation
if (error) {
errorbox(message);
}
else {
/* all is well, calc netaddress and store everything */
unsigned long int intaddress;
unsigned long int intnetaddress;
unsigned long int intnetmask;
struct in_addr i_addr;
char *netaddress;
update_kv(ð_kv, addresskey, (char *) addressresult);
update_kv(ð_kv, netmaskkey, (char *) netmaskresult);
/* calculate netaddress */
intaddress = inet_addr(addressresult);
intnetmask = inet_addr(netmaskresult);
intnetaddress = intaddress & intnetmask;
i_addr.s_addr = intnetaddress;
netaddress = inet_ntoa(i_addr);
update_kv(ð_kv, netaddresskey, (char *) netaddress);
changed_config = 1;
*changed_flag = 1;
}
}
}
while (error);
newtFormDestroy(networkform);
newtPopWindow();
}