static UI_CALLBACK(load_save_fliplist)
{
char *filename, *title;
int what = vice_ptr_to_int(UI_MENU_CB_PARAM);
ui_button_t button;
uilib_file_filter_enum_t filter[] = { UILIB_FILTER_FLIPLIST, UILIB_FILTER_ALL };
vsync_suspend_speed_eval();
title = util_concat(what ? _("Load ") : _("Save"), _("Flip list file"), NULL);
filename = ui_select_file(title, NULL, 0, load_save_fliplist_last_dir, filter, sizeof(filter) / sizeof(*filter), &button, 1, NULL, what ? UI_FC_LOAD : UI_FC_SAVE);
lib_free(title);
switch (button) {
case UI_BUTTON_OK:
if (what) {
if (fliplist_load_list(FLIPLIST_ALL_UNITS, filename, 0) == 0) {
ui_message(_("Successfully read `%s'."), filename);
} else {
ui_error(_("Error reading `%s'."), filename);
}
} else {
if (fliplist_save_list(FLIPLIST_ALL_UNITS, filename) == 0) {
ui_message(_("Successfully wrote `%s'"), filename);
} else {
ui_error(_("Error writing `%s'."), filename);
}
}
lib_free(load_save_fliplist_last_dir);
util_fname_split(filename, &load_save_fliplist_last_dir, NULL);
break;
default:
break;
}
}
static UI_CALLBACK(load_save_fliplist)
{
char *filename, *title;
int what = (int)UI_MENU_CB_PARAM;
ui_button_t button;
vsync_suspend_speed_eval();
title = util_concat(what ? _("Load ") : _("Save"), _("Fliplist File"),
NULL);
filename = ui_select_file(title, NULL, 0, 0,
load_save_fliplist_last_dir, "*.vfl",
&button, 1, NULL);
lib_free(title);
switch (button) {
case UI_BUTTON_OK:
if (what) {
if (fliplist_load_list((unsigned int)-1, filename, 0) == 0)
ui_message(_("Successfully read `%s'."), filename);
else
ui_error(_("Error reading `%s'."), filename);
} else {
if (fliplist_save_list((unsigned int)-1, filename) == 0)
ui_message(_("Successfully wrote `%s'."), filename);
else
ui_error(_("Error writing `%s'."), filename);
}
if (load_save_fliplist_last_dir)
lib_free(load_save_fliplist_last_dir);
util_fname_split(filename, &load_save_fliplist_last_dir, NULL);
break;
default:
break;
}
}
static UI_CALLBACK(save_resources_file)
{
char *filename;
ui_button_t button;
int len = 1024;
#ifndef HAVE_DIRNAME
char *tmp;
#endif
uilib_file_filter_enum_t filter = UILIB_FILTER_ALL;
vsync_suspend_speed_eval();
filename = lib_malloc(len + 1);
strcpy(filename, "");
filename = ui_select_file(_("File to save settings to"), NULL, 0, resources_last_dir, &filter, 1, &button, 0, NULL, UI_FC_SAVE);
if (button == UI_BUTTON_OK && filename != NULL) {
if (resources_save(filename) < 0) {
ui_error(_("Cannot save settings."));
} else {
if (w != NULL) {
ui_message(_("Settings saved successfully."));
}
}
lib_free(resources_last_dir);
util_fname_split(filename, &resources_last_dir, NULL);
}
lib_free(filename);
ui_update_menus();
}
void ui_debug(Tcl_Interp *interp, const char *format, ...) {
va_list va;
va_start(va, format);
ui_message(interp, "debug", format, va);
va_end(va);
}
void ui_notice(Tcl_Interp *interp, const char *format, ...) {
va_list va;
va_start(va, format);
ui_message(interp, "notice", format, va);
va_end(va);
}
static UI_CALLBACK(save_resources)
{
char *fname;
vsync_suspend_speed_eval();
if (resources_save(NULL) < 0) {
ui_error(_("Cannot save settings."));
}else {
if (w != NULL) {
ui_message(_("Settings saved successfully."));
}
}
fname = archdep_default_fliplist_file_name();
fliplist_save_list((unsigned int) -1, fname);
lib_free(fname);
ui_update_menus();
}
void ui_cartridge_save_dialog(int type)
{
gint res;
char *name;
if (cartridge_dialog) {
gdk_window_show(gtk_widget_get_window(cartridge_dialog));
gdk_window_raise(gtk_widget_get_window(cartridge_dialog));
gtk_widget_show(cartridge_dialog);
} else {
uilib_file_filter_enum_t filter = UILIB_FILTER_ALL;
cartridge_dialog = vice_file_entry(_("Save cartridge image"), NULL, NULL, &filter, 1, UI_FC_SAVE);
g_signal_connect(G_OBJECT(cartridge_dialog), "destroy", G_CALLBACK(gtk_widget_destroyed), &cartridge_dialog);
}
ui_popup(cartridge_dialog, _("Save cartridge image"), FALSE);
res = gtk_dialog_run(GTK_DIALOG(cartridge_dialog));
ui_popdown(cartridge_dialog);
if (res != GTK_RESPONSE_ACCEPT) {
return;
}
name = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(cartridge_dialog));
if (!name) {
ui_error(_("Invalid filename"));
return;
}
if (cartridge_save_image (type, name) < 0) {
ui_error(_("Cannot write cartridge image file\n`%s'\n"), name);
} else {
ui_message(_("Successfully wrote `%s'"), name);
}
lib_free(name);
}
void video_resources_check_win32_newpal(void)
{
int pal_enabled = 0;
int pal_mode = 0;
resources_get_int("PALEmulation", &pal_enabled);
if (pal_enabled)
resources_get_int("PALMode", &pal_mode);
if (video_current_canvas==NULL)
return;
if (video_current_canvas->videoconfig==NULL)
return;
if (pal_enabled != 0 && pal_mode == 2 &&
video_current_canvas->videoconfig->fullscreen_enabled == 0 &&
video_current_canvas->videoconfig->doublescan != 0 &&
video_current_canvas->videoconfig->double_size_enabled != 0)
{
ui_message("This combination has a performance problem\nplease switch to old PAL emulation");
}
}
static void handle_wm_command(WPARAM wparam, LPARAM lparam, HWND hwnd)
{
TCHAR *st_name = NULL;
char *name = NULL;
int i;
switch (wparam) {
case IDM_LOAD_PSID_FILE:
st_name = uilib_select_file(hwnd, translate_text(IDS_PSID_FILE), UILIB_FILTER_ALL, UILIB_SELECTOR_TYPE_FILE_LOAD, UILIB_SELECTOR_STYLE_DEFAULT);
if (st_name != NULL) {
name = system_wcstombs_alloc(st_name);
if (machine_autodetect_psid(st_name) >= 0) {
vsid_disp(0, 0, NULL, NULL);
psid_init_driver();
vsid_ui_init();
machine_play_psid(0);
for (i = 0; i < VSID_S_LASTLINE; i++) {
*vsidstrings[i] = 0;
}
machine_trigger_reset(MACHINE_RESET_MODE_SOFT);
songs = psid_tunes(&default_song);
current_song = default_song;
psid_ui_set_tune(uint_to_void_ptr(current_song), NULL);
vsid_ui_display_tune_nr(current_song);
vsid_ui_set_default_tune(default_song);
vsid_ui_display_nr_of_tunes(songs);
}
system_wcstombs_free(name);
lib_free(st_name);
}
break;
case IDM_SELECT_TUNE:
ui_select_vsid_tune(hwnd);
break;
case IDM_NEXT_TUNE:
if (current_song < songs) {
current_song++;
psid_ui_set_tune(uint_to_void_ptr(current_song), NULL);
vsid_ui_display_tune_nr(current_song);
vsid_ui_set_default_tune(default_song);
vsid_ui_display_nr_of_tunes(songs);
}
break;
case IDM_PREVIOUS_TUNE:
if (current_song > 1) {
current_song--;
psid_ui_set_tune(uint_to_void_ptr(current_song), NULL);
vsid_ui_display_tune_nr(current_song);
vsid_ui_set_default_tune(default_song);
vsid_ui_display_nr_of_tunes(songs);
}
break;
case IDM_RESET_HARD:
machine_trigger_reset(MACHINE_RESET_MODE_HARD);
break;
case IDM_RESET_SOFT:
machine_trigger_reset(MACHINE_RESET_MODE_SOFT);
break;
case IDM_MONITOR:
monitor_startup_trap();
break;
case IDM_EXIT:
PostMessage(hwnd, WM_CLOSE, wparam, lparam);
break;
case IDM_SOUND_RECORD_START:
ui_sound_record_settings_dialog(hwnd);
break;
case IDM_SOUND_RECORD_STOP:
resources_set_string("SoundRecordDeviceName", "");
break;
case IDM_MAXIMUM_SPEED_CUSTOM:
ui_speed_settings_dialog(hwnd);
break;
case IDM_SOUND_SETTINGS:
ui_sound_settings_dialog(hwnd);
break;
case IDM_SID_SETTINGS:
ui_sid_settings_dialog(hwnd, c64_sid_baseaddress);
break;
case IDM_SETTINGS_SAVE_FILE:
if ((st_name = uilib_select_file(hwnd, translate_text(IDS_SAVE_CONFIG_FILE), UILIB_FILTER_ALL, UILIB_SELECTOR_TYPE_FILE_SAVE, UILIB_SELECTOR_STYLE_DEFAULT)) != NULL) {
char *name;
name = system_wcstombs_alloc(st_name);
if (resources_save(st_name) < 0) {
ui_error(translate_text(IDS_CANNOT_SAVE_SETTINGS));
} else {
ui_message(translate_text(IDS_SETTINGS_SAVED_SUCCESS));
}
system_wcstombs_free(name);
lib_free(st_name);
}
break;
case IDM_SETTINGS_LOAD_FILE:
if ((st_name = uilib_select_file(hwnd, translate_text(IDS_LOAD_CONFIG_FILE), UILIB_FILTER_ALL, UILIB_SELECTOR_TYPE_FILE_LOAD, UILIB_SELECTOR_STYLE_DEFAULT)) != NULL) {
char *name;
name = system_wcstombs_alloc(st_name);
if (resources_load(st_name) < 0) {
ui_error(translate_text(IDS_CANNOT_LOAD_SETTINGS));
} else {
ui_message(translate_text(IDS_SETTINGS_LOADED_SUCCESS));
}
system_wcstombs_free(name);
lib_free(st_name);
}
break;
case IDM_SETTINGS_SAVE:
if (resources_save(NULL) < 0) {
ui_error(translate_text(IDS_CANNOT_SAVE_SETTINGS));
} else {
ui_message(translate_text(IDS_SETTINGS_SAVED_SUCCESS));
}
break;
case IDM_SETTINGS_LOAD:
if (resources_load(NULL) < 0) {
ui_error(translate_text(IDS_CANNOT_LOAD_SETTINGS));
} else {
ui_message(translate_text(IDS_SETTINGS_LOADED_SUCCESS));
}
break;
case IDM_SETTINGS_DEFAULT:
resources_set_defaults();
ui_message(translate_text(IDS_DEFAULT_SETTINGS_RESTORED));
break;
case IDM_LANG_EN:
case IDM_LANG_DA:
case IDM_LANG_DE:
case IDM_LANG_ES:
case IDM_LANG_FR:
case IDM_LANG_HU:
case IDM_LANG_IT:
case IDM_LANG_KO:
case IDM_LANG_NL:
case IDM_LANG_PL:
case IDM_LANG_RU:
case IDM_LANG_SV:
case IDM_LANG_TR:
ui_set_language((unsigned int)wparam);
vsid_ui_translate();
break;
case IDM_ABOUT:
case IDM_HELP:
case IDM_CONTRIBUTORS:
case IDM_LICENSE:
case IDM_WARRANTY:
case IDM_CMDLINE:
uihelp_dialog(hwnd, wparam);
break;
default:
handle_default_command(wparam, lparam, hwnd);
}
}
int ui_screenshot_dialog(char *name, struct video_canvas_s *wid)
{
int res, i;
char *fn, *tmp;
const char *driver, *ext;
if (screenshot_dialog) {
gdk_window_show(screenshot_dialog->window);
gdk_window_raise(screenshot_dialog->window);
gtk_widget_show(screenshot_dialog);
} else {
screenshot_dialog = build_screenshot_dialog();
if (screenshot_dialog)
g_signal_connect(G_OBJECT(screenshot_dialog),
"destroy",
G_CALLBACK(gtk_widget_destroyed),
&screenshot_dialog);
else
return -1;
}
ui_popup(screenshot_dialog, _("Save Screenshot"), FALSE);
res = gtk_dialog_run(GTK_DIALOG(screenshot_dialog));
ui_popdown(screenshot_dialog);
if (res != GTK_RESPONSE_ACCEPT)
return -1;
fn = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fileentry));
if (!fn) {
ui_error(_("Invalid filename"));
return -1;
}
i = gtk_combo_box_get_active(GTK_COMBO_BOX(drv_menu));
if (i < 0)
return -1;
driver = buttons[i].driver;
ext = buttons[i].ext;
#ifdef HAVE_FFMPEG
if (strcmp(driver, "FFMPEG") == 0)
{
int audio_bitrate, video_bitrate;
audio_bitrate = (int)
gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(ffmpg_audio));
resources_set_int("FFMPEGAudioBitrate", audio_bitrate);
video_bitrate = (int)
gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(ffmpg_video));
resources_set_int("FFMPEGVideoBitrate", video_bitrate);
resources_set_string("FFMPEGFormat", selected_driver);
resources_set_int("FFMPEGAudioCodec", selected_ac);
resources_set_int("FFMPEGVideoCodec", selected_vc);
log_message(LOG_DEFAULT, "FFMPEG: Driver: %s, ac: %d, vc: %d\n",
selected_driver, selected_ac, selected_vc);
}
#endif
tmp = lib_stralloc(fn);
lib_free(fn);
if (!util_get_extension(tmp))
util_add_extension(&tmp, ext);
if (screenshot_save(driver, tmp, wid) < 0) {
ui_error(_("Couldn't write screenshot to `%s' with driver `%s'."),
tmp, driver);
lib_free(tmp);
return -1;
} else {
if (screenshot_is_recording())
gtk_widget_show(video_ctrl_checkbox);
ui_message(_("Successfully wrote `%s'"), tmp);
lib_free(tmp);
}
return 0;
}
int install_from_cwd(Options *op)
{
Package *p;
CommandList *c;
int ret;
int ran_pre_install_hook = FALSE;
HookScriptStatus res;
static const char* edit_your_xf86config =
"Please update your XF86Config or xorg.conf file as "
"appropriate; see the file /usr/share/doc/"
"NVIDIA_GLX-1.0/README.txt for details.";
/*
* validate the manifest file in the cwd, and process it, building
* a Package struct
*/
if ((p = parse_manifest(op)) == NULL) goto failed;
if (!op->x_files_packaged) {
edit_your_xf86config = "";
}
ui_set_title(op, "%s (%s)", p->description, p->version);
/*
* warn the user if "legacy" GPUs are installed in this system
* and if no supported GPU is found, at all.
*/
check_for_nvidia_graphics_devices(op, p);
/* check that we are not running any X server */
if (!check_for_running_x(op)) goto failed;
/* make sure the kernel module is unloaded */
if (!check_for_unloaded_kernel_module(op)) goto failed;
/* ask the user to accept the license */
if (!get_license_acceptance(op)) goto exit_install;
ui_log(op, "Installing NVIDIA driver version %s.", p->version);
/*
* determine the current NVIDIA version (if any); ask the user if
* they really want to overwrite the existing installation
*/
if (!check_for_existing_driver(op, p)) goto exit_install;
/*
* check to see if an alternate method of installation is already installed
* or is available, but not installed; ask the user if they really want to
* install anyway despite the presence/availability of an alternate install.
*/
if (!check_for_alternate_install(op)) goto exit_install;
/* run the distro preinstall hook */
res = run_distro_hook(op, "pre-install");
if (res == HOOK_SCRIPT_FAIL) {
if (ui_multiple_choice(op, CONTINUE_ABORT_CHOICES,
NUM_CONTINUE_ABORT_CHOICES,
CONTINUE_CHOICE, /* Default choice */
"The distribution-provided pre-install "
"script failed! Are you sure you want "
"to continue?") == ABORT_CHOICE) {
goto failed;
}
} else if (res == HOOK_SCRIPT_SUCCESS) {
if (ui_multiple_choice(op, CONTINUE_ABORT_CHOICES,
NUM_CONTINUE_ABORT_CHOICES,
CONTINUE_CHOICE, /* Default choice */
"The distribution-provided pre-install script "
"completed successfully. If this is the first "
"time you have run the installer, this script "
"may have helped disable Nouveau, but a reboot "
"may be required first. "
"Would you like to continue, or would you "
"prefer to abort installation to reboot the "
"system?") == ABORT_CHOICE) {
goto exit_install;
}
ran_pre_install_hook = TRUE;
}
/* fail if the nouveau driver is currently in use */
if (!check_for_nouveau(op)) goto failed;
/* ask if we should install the UVM kernel module */
should_install_uvm(op, p);
/* attempt to build the kernel modules for the target kernel */
if (!op->no_kernel_module) {
if (!install_kernel_modules(op, p)) {
goto failed;
}
} else {
ui_warn(op, "You specified the '--no-kernel-module' command line "
"option, nvidia-installer will not install a kernel "
"module as part of this driver installation, and it will "
"not remove existing NVIDIA kernel modules not part of "
"an earlier NVIDIA driver installation. Please ensure "
"that an NVIDIA kernel module matching this driver version "
"is installed seperately.");
/* no_kernel_module should imply no DKMS */
if (op->dkms) {
ui_warn(op, "You have specified both the '--no-kernel-module' "
"and the '--dkms' command line options. The '--dkms' "
"option will be ignored.");
op->dkms = FALSE;
}
}
/*
* if we are only installing the kernel module, then remove
* everything else from the package; otherwise do some
* OpenGL-specific stuff
*/
if (op->kernel_module_only) {
remove_non_kernel_module_files_from_package(op, p);
} else {
/* ask for the XFree86 and OpenGL installation prefixes. */
if (!get_prefixes(op)) goto failed;
/* ask if we should install the OpenGL header files */
should_install_opengl_headers(op, p);
/*
* select the appropriate TLS class, modifying the package as
* necessary.
*/
select_tls_class(op, p);
/*
* if the package contains any libGL.la or .desktop files,
* process them (perform some search and replacing so
* that they reflect the correct installation path, etc)
* and add them to the package list (files to be installed).
*/
process_libGL_la_files(op, p);
process_dot_desktop_files(op, p);
#if defined(NV_X86_64)
/*
* ask if we should install the 32bit compatibility files on
* this machine.
*/
should_install_compat32_files(op, p);
#endif /* NV_X86_64 */
}
if (op->no_opengl_files) {
remove_opengl_files_from_package(op, p);
}
/*
* now that we have the installation prefixes, build the
* destination for each file to be installed
*/
if (!set_destinations(op, p)) goto failed;
/*
* if we are installing OpenGL libraries, ensure that a symlink gets
* installed to /usr/lib/libGL.so.1. add_libgl_abi_symlink() sets its own
* destination, so it must be called after set_destinations().
*/
if (!op->kernel_module_only && !op->no_opengl_files) {
add_libgl_abi_symlink(op, p);
}
/*
* uninstall the existing driver; this needs to be done before
* building the command list.
*
* XXX if we uninstall now, then build the command list, and
* then ask the user if they really want to execute the
* command list, if the user decides not to execute the
* command list, they'll be left with no driver installed.
*/
if (!op->kernel_module_only) {
if (!run_existing_uninstaller(op)) goto failed;
}
if (!check_libglvnd_files(op, p)) {
goto failed;
}
/* build a list of operations to execute to do the install */
if ((c = build_command_list(op, p)) == NULL) goto failed;
/* call the ui to get approval for the list of commands */
if (!ui_approve_command_list(op, c, "%s", p->description)) {
goto exit_install;
}
/* initialize the backup log file */
if (!op->kernel_module_only) {
if (!init_backup(op, p)) goto failed;
}
/* execute the command list */
if (!do_install(op, p, c)) goto failed;
/* Register, build, and install the module with DKMS, if requested */
if (op->dkms && !dkms_install_module(op, p->version, get_kernel_name(op)))
goto failed;
/*
* Leave the RM loaded in case an X server with OutputClass-based driver
* matching is being used.
*/
if (!op->no_kernel_module || op->dkms) {
if (!load_kernel_module(op, p->kernel_modules[0].module_name)) {
goto failed;
}
}
/* run the distro postinstall script */
run_distro_hook(op, "post-install");
/*
* check that everything is installed properly (post-install
* sanity check)
*/
check_installed_files_from_package(op, p);
if (!check_runtime_configuration(op, p)) goto failed;
/* done */
if (op->kernel_module_only || op->no_nvidia_xconfig_question) {
ui_message(op, "Installation of the kernel module for the %s "
"(version %s) is now complete.",
p->description, p->version);
} else {
/* ask the user if they would like to run nvidia-xconfig */
const char *msg = "Would you like to run the nvidia-xconfig utility "
"to automatically update your X configuration file "
"so that the NVIDIA X driver will be used when you "
"restart X? Any pre-existing X configuration "
"file will be backed up.";
ret = run_nvidia_xconfig(op, FALSE, msg, op->run_nvidia_xconfig);
if (ret) {
ui_message(op, "Your X configuration file has been successfully "
"updated. Installation of the %s (version: %s) is now "
"complete.", p->description, p->version);
} else {
ui_message(op, "Installation of the %s (version: %s) is now "
"complete. %s", p->description,
p->version, edit_your_xf86config);
}
}
free_package(p);
return TRUE;
failed:
/*
* something bad happened during installation; print an error
* message and return FALSE
*/
if (op->logging) {
ui_error(op, "Installation has failed. Please see the file '%s' "
"for details. You may find suggestions on fixing "
"installation problems in the README available on the "
"Linux driver download page at www.nvidia.com.",
op->log_file_name);
} else {
ui_error(op, "Installation has failed. You may find suggestions "
"on fixing installation problems in the README available "
"on the Linux driver download page at www.nvidia.com.");
}
if (ran_pre_install_hook)
run_distro_hook(op, "failed-install");
/* fall through into exit_install... */
exit_install:
/*
* we are exiting installation; this can happen for reasons that
* do not merit the error message (e.g., the user declined the
* license agreement)
*/
free_package(p);
return FALSE;
} /* install_from_cwd() */
static int assisted_module_signing(Options *op, Package *p)
{
int generate_keys = FALSE, do_sign = FALSE, secureboot, i;
secureboot = secure_boot_enabled();
if (secureboot < 0) {
ui_log(op, "Unable to determine if Secure Boot is enabled: %s",
strerror(-secureboot));
}
if (op->kernel_module_signed) {
/* The kernel module is already signed, e.g. from linking a precompiled
* interface + appending a detached signature */
return TRUE;
}
if (test_kernel_config_option(op, p, "CONFIG_DUMMY_OPTION") ==
KERNEL_CONFIG_OPTION_UNKNOWN) {
/* Unable to test kernel configuration options, possibly due to
* missing kernel headers. Since we might be installing on a
* system that doesn't have the headers, bail out. */
return TRUE;
}
if (op->module_signing_secret_key && op->module_signing_public_key) {
/* If the user supplied signing keys, sign the module, regardless of
* whether or not we actually need to. */
do_sign = TRUE;
} else if (test_kernel_config_option(op, p, "CONFIG_MODULE_SIG_FORCE") ==
KERNEL_CONFIG_OPTION_DEFINED) {
/* If CONFIG_MODULE_SIG_FORCE is set, we must sign. */
ui_message(op, "The target kernel has CONFIG_MODULE_SIG_FORCE set, "
"which means that it requires that kernel modules be "
"cryptographically signed by a trusted key.");
do_sign = TRUE;
} else if (secureboot != 1 && !op->expert) {
/* If this is a non-UEFI system, or a UEFI system with secure boot
* disabled, or we are unable to determine whether the system has
* secure boot enabled, bail out unless in expert mode. */
return TRUE;
} else if (test_kernel_config_option(op, p, "CONFIG_MODULE_SIG") ==
KERNEL_CONFIG_OPTION_DEFINED){
/* The kernel may or may not enforce module signatures; ask the user
* whether to sign the module. */
const char *choices[2] = {
"Sign the kernel module",
"Install without signing"
};
const char* sb_message = (secureboot == 1) ?
"This system also has UEFI Secure Boot "
"enabled; many distributions enforce "
"module signature verification on UEFI "
"systems when Secure Boot is enabled. " :
"";
do_sign = (ui_multiple_choice(op, choices, 2, 1, "The target kernel "
"has CONFIG_MODULE_SIG set, which means "
"that it supports cryptographic "
"signatures on kernel modules. On some "
"systems, the kernel may refuse to load "
"modules without a valid signature from "
"a trusted key. %sWould you like to sign "
"the NVIDIA kernel module?",
sb_message) == 0);
}
if (!do_sign) {
/* The user explicitly opted out of module signing, or the kernel does
* not support module signatures, and no signing keys were provided;
* there is nothing for us to do here. */
return TRUE;
}
/* If we're missing either key, we need to get both from the user. */
if (!op->module_signing_secret_key || !op->module_signing_public_key) {
const char *choices[2] = {
"Use an existing key pair",
"Generate a new key pair"
};
generate_keys = (ui_multiple_choice(op, choices, 2, 1, "Would you like "
"to sign the NVIDIA kernel module "
"with an existing key pair, or "
"would you like to generate a new "
"one?") == 1);
if (generate_keys) {
char *cmdline, *x509_hash, *private_key_path, *public_key_path;
int ret, generate_failed = FALSE;
if (!op->utils[OPENSSL]) {
ui_error(op, "Unable to generate key pair: openssl not "
"found!");
return FALSE;
}
/* Determine what hashing algorithm to use for the generated X.509
* certificate. XXX The default is to use the same hash that is
* used for signing modules; the two hashes are actually orthognal
* to each other, but by choosing the module signing hash we are
* guaranteed that the chosen hash will be built into the kernel.
*/
if (op->module_signing_x509_hash) {
x509_hash = nvstrdup(op->module_signing_x509_hash);
} else {
char *guess, *guess_trimmed, *warn = NULL;
char *no_guess = "Unable to guess the module signing hash.";
char *common_warn = "The module signing certificate generated "
"by nvidia-installer will be signed with "
"sha256 as a fallback. If the resulting "
"certificate fails to import into your "
"kernel's trusted keyring, please run the "
"installer again, and either use a pre-"
"generated key pair, or set the "
"--module-signing-x509-hash option if you "
"plan to generate a new key pair with "
"nvidia-installer.";
guess = guess_module_signing_hash(op,
p->kernel_module_build_directory);
if (guess == NULL) {
warn = no_guess;
goto guess_fail;
}
guess_trimmed = nv_trim_space(guess);
guess_trimmed = nv_trim_char_strict(guess_trimmed, '"');
if (guess_trimmed) {
if (strlen(guess_trimmed) == 0) {
warn = no_guess;
goto guess_fail;
}
x509_hash = nvstrdup(guess_trimmed);
} else {
warn = "Error while parsing the detected module signing "
"hash.";
goto guess_fail;
}
guess_fail:
nvfree(guess);
if (warn) {
ui_warn(op, "%s %s", warn, common_warn);
x509_hash = nvstrdup("sha256");
}
}
log_printf(op, NULL, "Generating key pair for module signing...");
/* Generate temporary files for the signing key and certificate */
private_key_path = write_temp_file(op, 0, NULL, 0600);
public_key_path = write_temp_file(op, 0, NULL, 0644);
if (!private_key_path || !public_key_path) {
ui_error(op, "Failed to create one or more temporary files for "
"the module signing keys.");
generate_failed = TRUE;
goto generate_done;
}
/* Generate a key pair using openssl.
* XXX We assume that sign-file requires the X.509 certificate
* in DER format; if this changes in the future we will need
* to be able to accommodate the actual required format. */
cmdline = nvstrcat("cd ", p->kernel_module_build_directory, "; ",
op->utils[OPENSSL], " req -new -x509 -newkey "
"rsa:2048 -days 7300 -nodes -subj "
"\"/CN=nvidia-installer generated signing key/\""
" -keyout ", private_key_path,
" -outform DER -out ", public_key_path,
" -", x509_hash, NULL);
nvfree(x509_hash);
ret = run_command(op, cmdline, NULL, TRUE, 8, TRUE);
nvfree(cmdline);
if (ret != 0) {
ui_error(op, "Failed to generate key pair!");
generate_failed = TRUE;
goto generate_done;
}
log_printf(op, NULL, "Signing keys generated successfully.");
/* Set the signing keys to the newly generated pair. */
op->module_signing_secret_key = nvstrdup(private_key_path);
op->module_signing_public_key = nvstrdup(public_key_path);
generate_done:
nvfree(private_key_path);
nvfree(public_key_path);
if (generate_failed) {
return FALSE;
}
} else {
/* The user already has keys; prompt for their locations. */
op->module_signing_secret_key =
get_filename(op, op->module_signing_secret_key,
"Please provide the path to the private key");
op->module_signing_public_key =
get_filename(op, op->module_signing_public_key,
"Please provide the path to the public key");
}
}
/* Now that we have keys (user-supplied or installer-generated),
* sign the kernel module/s which we built earlier. */
for (i = 0; i < p->num_kernel_modules; i++) {
if (!sign_kernel_module(op, p->kernel_module_build_directory,
p->kernel_modules[i].module_filename, TRUE)) {
return FALSE;
}
}
if (generate_keys) {
/* If keys were generated, we should install the verification cert
* so that the user can make the kernel trust it, and either delete
* or install the private signing key. */
char *name, *result = NULL, *fingerprint, *cmdline;
char short_fingerprint[9];
int ret, delete_secret_key;
delete_secret_key = ui_yes_no(op, TRUE, "The NVIDIA kernel module was "
"successfully signed with a newly "
"generated key pair. Would you like to "
"delete the private signing key?");
/* Get the fingerprint of the X.509 certificate. We already used
openssl to create a keypair at this point, so we know we have it;
otherwise, we would have already returned by now. */
cmdline = nvstrcat(op->utils[OPENSSL], " x509 -noout -fingerprint ",
"-inform DER -in ", op->module_signing_public_key,
NULL);
ret = run_command(op, cmdline, &result, FALSE, 0, FALSE);
nvfree(cmdline);
/* Format: "SHA1 Fingerprint=00:00:00:00:..." */
fingerprint = strchr(result, '=') + 1;
if (ret != 0 || !fingerprint || strlen(fingerprint) < 40) {
char *sha1sum = find_system_util("sha1sum");
if (sha1sum) {
/* the openssl command failed, or we parsed its output
* incorrectly; try to get a sha1sum of the DER certificate */
cmdline = nvstrcat(sha1sum, " ", op->module_signing_public_key,
NULL);
ret = run_command(op, cmdline, &result, FALSE, 0, FALSE);
nvfree(sha1sum);
nvfree(cmdline);
fingerprint = result;
}
if (!sha1sum || ret != 0 || !fingerprint ||
strlen(fingerprint) < 40) {
/* Unable to determine fingerprint */
fingerprint = "UNKNOWN";
} else {
char *end = strchr(fingerprint, ' ');
*end = '\0';
}
} else {
/* Remove any ':' characters from fingerprint and truncate */
char *tmp = nv_strreplace(fingerprint, ":", "");
strncpy(short_fingerprint, tmp, sizeof(short_fingerprint));
nvfree(tmp);
}
short_fingerprint[sizeof(short_fingerprint) - 1] = '\0';
/* Add the public key to the package */
/* XXX name will be leaked when freeing package */
name = nvstrcat("nvidia-modsign-crt-", short_fingerprint, ".der", NULL);
add_package_entry(p,
nvstrdup(op->module_signing_public_key),
NULL, /* path */
name,
NULL, /* target */
NULL, /* dst */
FILE_TYPE_MODULE_SIGNING_KEY,
FILE_TLS_CLASS_NONE,
FILE_COMPAT_ARCH_NONE,
0444);
ui_message(op, "An X.509 certificate containing the public signing "
"key will be installed to %s/%s. The SHA1 fingerprint of "
"this certificate is: %s.\n\nThis certificate must be "
"added to a key database which is trusted by your kernel "
"in order for the kernel to be able to verify the module "
"signature.", op->module_signing_key_path, name,
fingerprint);
nvfree(result);
/* Delete or install the private key */
if (delete_secret_key) {
secure_delete(op, op->module_signing_secret_key);
} else {
/* Add the private key to the package */
name = nvstrcat("nvidia-modsign-key-", short_fingerprint, ".key",
NULL);
add_package_entry(p,
nvstrdup(op->module_signing_secret_key),
NULL, /* path */
name,
NULL, /* target */
NULL, /* dst */
FILE_TYPE_MODULE_SIGNING_KEY,
FILE_TLS_CLASS_NONE,
FILE_COMPAT_ARCH_NONE,
0400);
ui_message(op, "The private signing key will be installed to %s/%s. "
"After the public key is added to a key database which "
"is trusted by your kernel, you may reuse the saved "
"public/private key pair to sign additional kernel "
"modules, without needing to re-enroll the public key. "
"Please take some reasonable precautions to secure the "
"private key: see the README for suggestions.",
op->module_signing_key_path, name);
}
} /* if (generate_keys) */
return TRUE;
} /* assisted_module_signing() */
static void dump_shortcuts(void)
{
FILE *fp;
char *complete_path;
char str[32];
char *p;
ACCEL accel;
int mod_keys, i, j;
int item_used[MAXACCEL];
memset(item_used, 0, MAXACCEL * sizeof(int));
/* adapted patch of iAN CooG */
complete_path = util_concat(archdep_boot_path(), "\\", machine_name, "\\win_shortcuts.vsc", NULL);
fp = fopen(complete_path, "wt");
if (fp == NULL) {
ui_error("Failed to write file %s", complete_path);
lib_free(complete_path);
return;
}
fprintf(fp, "#\n"
"# VICE definition file for Keyboard Shortcuts in Win32\n"
"#\n"
"# Syntax:\n"
"# First column: Combination of ALT|CTRL|SHIFT to or just KEY\n"
"# Second column: (virtual) Keycode for the shortcut\n"
"# Code can be character ('X'), hex (0xAB) or decimal (168)\n"
"# Have a look at winuser.h for the list of virtual key codes (VK_..)\n"
"# Third column: command identifier that is executed with the shortcut\n"
"# Fourth column: text to display in the menu item; missing this lets\n"
"# the keycode char be displayed.\n\n");
for (i = 0; i < accelnum; i++) {
accel = accellist[i];
for (j = 0; idmlist[j].str; j++) {
if (idmlist[j].cmd == accel.cmd) {
item_used[j] = 1;
break;
}
}
mod_keys = accel.fVirt & (FCONTROL | FALT | FSHIFT);
sprintf(str, "%s", mod_keys & FCONTROL ? "CTRL" : "");
mod_keys &= ~FCONTROL;
if (str[0] && (mod_keys & FALT)) {
sprintf(str, "%s%s", str, "|");
}
sprintf(str, "%s%s", str, mod_keys & FALT ? "ALT" : "");
mod_keys &= ~FALT;
if (str[0] && (mod_keys & FSHIFT)) {
sprintf(str, "%s%s", str, "|");
}
sprintf(str, "%s%s", str, mod_keys & FSHIFT ? "SHIFT" : "");
if (!str[0]) {
sprintf(str, "KEY");
}
fprintf(fp, "%-16s", str);
if (accel.key >= '0' && accel.key <= '9' || accel.key >= 'A' && accel.key <= 'Z') {
fprintf(fp, "'%c' %-34s", accel.key, idmlist[j].str);
} else {
fprintf(fp, "0x%02X %-34s", accel.key, idmlist[j].str);
}
if (menuitemmodifier[idmlist[j].cmd] != NULL ) {
p = strrchr(menuitemmodifier[idmlist[j].cmd], '\t');
if (strrchr(p, '+')) {
p = strrchr(p, '+');
}
if (*(p + 1)) {
p++;
}
fprintf(fp, "%s\n", p);
} else {
fprintf(fp, "\n");
}
}
fprintf(fp, "\n#\n"
"# Other command identifier that can be used in shortcuts\n"
"#\n");
i = 0;
for (j = 0; idmlist[j].str; j++) {
if (item_used[j] == 0) {
if (++i & 1) {
fprintf(fp, "# %-40s", idmlist[j].str);
} else {
fprintf(fp, "%s\n", idmlist[j].str);
}
}
}
fprintf(fp, "\n");
fclose(fp);
ui_message("Successfully dumped shortcuts to %s", complete_path);
lib_free(complete_path);
}
void res_parser(response *res, char *input) {
char row[RESPONSE_ROW_MAX_LENGTH];
char *d;
char *item;
char *save;
int empty;
size_t ln;
memset(row, '\0', sizeof(row));
empty = 0;
d = row;
do {
if (*input == '\n') {
input++;
d = row;
ui_message(UI_DEBUG, "Response", "row: %s", row);
if (empty > 0) {
ln = strlen(res->data) + strlen(row) + 1;
res->data = (char *) realloc(res->data, ln * sizeof(char));
strcat(res->data, row);
memset(row, '\0', sizeof(row));
continue;
}
if (strncmp(row, "HTTP", 4) == 0) {
item = strtok_r(row, " ", &save);
item = strtok_r(NULL, " ", &save);
res->code = atoi(item);
memset(row, '\0', sizeof(row));
continue;
}
if (strncmp(row, "Content-Type", 12) == 0) {
item = strtok_r(row, " ", &save);
item = strtok_r(NULL, " ", &save);
res->type = (char *) realloc(res->type, (strlen(item) + 1) * sizeof(char));
strcpy(res->type, item);
memset(row, '\0', sizeof(row));
continue;
}
if (strncmp(row, "Content-Length", 14) == 0) {
item = strtok_r(row, " ", &save);
item = strtok_r(NULL, " ", &save);
res->len = atoi(item);
memset(row, '\0', sizeof(row));
continue;
}
if (strlen(row) == 0) {
empty++;
}
memset(row, '\0', sizeof(row));
continue;
}
*d = *input;
input++;
d++;
} while (*input != '\0');
ui_message(UI_DEBUG, "Response", "CODE: %d", res->code);
ui_message(UI_DEBUG, "Response", "TYPE: %s", res->type);
ui_message(UI_DEBUG, "Response", "LENGTH: %d", res->len);
ui_message(UI_DEBUG, "Response", "DATA: %s", res->data);
}
static int vsid_menu_handle(int idm)
{
char *fname = NULL;
char *curlang;
int i;
switch (idm) {
case IDM_NEXT_TUNE:
if (current_song < songs) {
current_song++;
psid_ui_set_tune(uint_to_void_ptr(current_song), NULL);
vsid_ui_display_tune_nr(current_song);
vsid_ui_set_default_tune(default_song);
vsid_ui_display_nr_of_tunes(songs);
}
break;
case IDM_PREVIOUS_TUNE:
if (current_song > 1) {
current_song--;
psid_ui_set_tune(uint_to_void_ptr(current_song), NULL);
vsid_ui_display_tune_nr(current_song);
vsid_ui_set_default_tune(default_song);
vsid_ui_display_nr_of_tunes(songs);
}
break;
case IDM_LOAD_PSID_FILE:
fname = VSID_BrowseFile(translate_text(IDS_PSID_SELECT), "#?");
if (fname != NULL) {
if (machine_autodetect_psid(fname) >= 0) {
psid_init_driver();
machine_play_psid(0);
for (i = 0; i < VSID_S_LASTLINE; i++) {
*vsidstrings[i] = 0;
}
machine_trigger_reset(MACHINE_RESET_MODE_SOFT);
songs = psid_tunes(&default_song);
current_song = default_song;
psid_ui_set_tune(uint_to_void_ptr(current_song), NULL);
vsid_ui_display_tune_nr(current_song);
vsid_ui_set_default_tune(default_song);
vsid_ui_display_nr_of_tunes(songs);
}
}
break;
case IDM_RESET_HARD:
machine_trigger_reset(MACHINE_RESET_MODE_HARD);
break;
case IDM_RESET_SOFT:
machine_trigger_reset(MACHINE_RESET_MODE_SOFT);
break;
case IDM_EXIT:
do_quit_vice = 1;
break;
case IDM_SETTINGS_SAVE_FILE:
fname = VSID_BrowseFile(translate_text(IDS_CONFIG_FILENAME_SELECT), "#?");
if (fname != NULL) {
if (resources_save(fname) < 0) {
ui_error(translate_text(IDMES_CANNOT_SAVE_SETTINGS));
} else {
ui_message(translate_text(IDMES_SETTINGS_SAVED_SUCCESS));
}
}
break;
case IDM_SETTINGS_LOAD_FILE:
fname = VSID_BrowseFile(translate_text(IDS_CONFIG_FILENAME_SELECT), "#?");
if (fname != NULL) {
if (resources_load(fname) < 0) {
ui_error(translate_text(IDMES_CANNOT_LOAD_SETTINGS));
} else {
ui_message(translate_text(IDMES_SETTINGS_LOAD_SUCCESS));
}
}
break;
case IDM_SETTINGS_SAVE:
if (resources_save(NULL) < 0) {
ui_error(translate_text(IDMES_CANNOT_SAVE_SETTINGS));
} else {
ui_message(translate_text(IDMES_SETTINGS_SAVED_SUCCESS));
}
break;
case IDM_SETTINGS_LOAD:
if (resources_load(NULL) < 0) {
ui_error(translate_text(IDMES_CANNOT_LOAD_SETTINGS));
} else {
ui_message(translate_text(IDMES_SETTINGS_LOAD_SUCCESS));
}
break;
case IDM_SETTINGS_DEFAULT:
resources_set_defaults();
ui_message(translate_text(IDMES_DFLT_SETTINGS_RESTORED));
break;
case IDM_SAMPLE_RATE:
i = vsid_requester(translate_text(IDS_SAMPLE_RATE), translate_text(IDS_SAMPLE_RATE), "11025 Hz | 22050 Hz | 44100 Hz | 8000 Hz", 0);
resources_set_int("SoundSampleRate", vsid_sample_rates[i]);
break;
case IDM_BUFFER_SIZE:
i = vsid_requester(translate_text(IDS_BUFFER_SIZE), translate_text(IDS_BUFFER_SIZE), "150 msec | 200 msec | 250 msec | 300 msec | 350 msec | 100 msec", 0);
resources_set_int("SoundBufferSize", vsid_buffer_sizes[i]);
break;
case IDM_FRAGMENT_SIZE:
fname = util_concat(translate_text(IDS_MEDIUM), " | ", translate_text(IDS_LARGE), " | ", translate_text(IDS_SMALL), NULL);
i = vsid_requester(translate_text(IDS_FRAGMENT_SIZE), translate_text(IDS_FRAGMENT_SIZE), fname, 0);
resources_set_int("SoundFragmentSize", vsid_fragment_sizes[i]);
lib_free(fname);
break;
case IDM_SPEED_ADJUSTMENT:
fname = util_concat(translate_text(IDS_ADJUSTING), " | ", translate_text(IDS_EXACT), " | ", translate_text(IDS_FLEXIBLE), NULL);
i = vsid_requester(translate_text(IDS_SPEED_ADJUSTMENT), translate_text(IDS_SPEED_ADJUSTMENT), fname, 0);
resources_set_int("SoundSpeedAdjustment", vsid_speed_adjustments[i]);
lib_free(fname);
break;
case IDM_VOLUME:
i = vsid_requester(translate_text(IDS_VOLUME), translate_text(IDS_VOLUME), "50% | 25% | 10% | 5% | 0% | 100%", 0);
resources_set_int("SoundVolume", vsid_volumes[i]);
break;
case IDM_SOUND_OUTPUT_MODE:
fname = util_concat(translate_text(IDS_MONO), " | ", translate_text(IDS_STEREO), " | ", translate_text(IDS_SYSTEM), NULL);
i = vsid_requester(translate_text(IDS_SOUND_OUTPUT_MODE), translate_text(IDS_SOUND_OUTPUT_MODE), fname, 0);
resources_set_int("SoundOutput", vsid_output_modes[i]);
lib_free(fname);
break;
case IDM_SID_ENGINE_MODEL:
fname = util_concat(
#ifdef HAVE_RESID
"ReSID | ",
#endif
#ifdef HAVE_CATWEASELMKIII
"Catweasel MK3 | ",
#endif
#ifdef HAVE_HARDSID
"HardSID | ",
#endif
#ifdef HAVE_RESID_FP
"ReSID-fp | ",
#endif
"Fast SID", NULL);
i = vsid_requester(translate_text(IDS_SID_ENGINE), translate_text(IDS_SID_ENGINE), fname, 0);
resources_set_int("SidEngine", vsid_sid_engines[i]);
lib_free(fname);
switch (vsid_sid_engines[i]) {
case SID_ENGINE_FASTSID:
i = vsid_requester(translate_text(IDS_SID_MODEL), translate_text(IDS_SID_MODEL), "8580 | 6581", 0);
resources_set_int("SidModel", vsid_fastsid_models[i]);
break;
#ifdef HAVE_RESID
case SID_ENGINE_RESID:
i = vsid_requester(translate_text(IDS_SID_MODEL), translate_text(IDS_SID_MODEL), "8580 | 8580D | 6581", 0);
resources_set_int("SidModel", vsid_resid_models[i]);
break;
#endif
#ifdef HAVE_RESID_FP
case SID_ENGINE_RESID_FP:
i = vsid_requester(translate_text(IDS_SID_MODEL), translate_text(IDS_SID_MODEL), "6581R3 0486S | 6581R3 3984 | 6581R4AR 3789 | 6581R3 4485 | 6581R4 1986S | 8580R5 3691 | 8580R5 3691D | 8580R5 1489 | 8580R5 1489D | 6581R3 4885", 0);
resources_set_int("SidModel", vsid_residfp_models[i]);
break;
#endif
}
break;
case IDM_AMOUNT_OF_EXTRA_SIDS:
i = vsid_requester(translate_text(IDS_AMOUNT_OF_EXTRA_SIDS), translate_text(IDS_AMOUNT_OF_EXTRA_SIDS), "1 | 2 | 0", 0);
resources_get_int("SidStereo", i);
break;
#ifdef HAVE_RESID
case IDM_SAMPLE_METHOD:
fname = util_concat(translate_text(IDS_INTERPOLATING), " | ", translate_text(IDS_RESAMPLING), " | ", translate_text(IDS_FAST_RESAMPLING), " | ", translate_text(IDS_FAST), NULL);
i = vsid_requester(translate_text(IDS_SAMPLE_METHOD), translate_text(IDS_SAMPLE_METHOD), fname, 0);
resources_set_int("SidResidSampling", i);
lib_free(fname);
break;
#endif
case IDM_SOUND_RECORD_START:
#ifndef USE_LAMEMP3
i = vsid_requester(translate_text(IDS_SOUND_RECORD_FORMAT), translate_text(IDS_SOUND_RECORD_FORMAT), "AIFF | VOC | WAV | IFF", 0);
#else
i = vsid_requester(translate_text(IDS_SOUND_RECORD_FORMAT), translate_text(IDS_SOUND_RECORD_FORMAT), "AIFF | VOC | WAV | MP3 | IFF", 0);
#endif
resources_set_string("SoundRecordDeviceName", "");
resources_set_string("SoundRecordDeviceName", vsid_sound_formats[i]);
break;
case IDM_SOUND_RECORD_STOP:
resources_set_string("SoundRecordDeviceName", "");
break;
case IDM_LANGUAGE_ENGLISH:
resources_get_value("Language", (void *)&curlang);
if (strcasecmp(curlang, "en")) {
resources_set_value("Language", (resource_value_t *)"en");
vsid_menu_rebuild();
}
break;
case IDM_LANGUAGE_DANISH:
resources_get_value("Language", (void *)&curlang);
if (strcasecmp(curlang, "da")) {
resources_set_value("Language", (resource_value_t *)"da");
vsid_menu_rebuild();
}
break;
case IDM_LANGUAGE_GERMAN:
resources_get_value("Language", (void *)&curlang);
if (strcasecmp(curlang, "de")) {
resources_set_value("Language", (resource_value_t *)"de");
vsid_menu_rebuild();
}
break;
case IDM_LANGUAGE_SPANISH:
resources_get_value("Language", (void *)&curlang);
if (strcasecmp(curlang, "es")) {
resources_set_value("Language", (resource_value_t *)"es");
vsid_menu_rebuild();
}
break;
case IDM_LANGUAGE_FRENCH:
resources_get_value("Language", (void *)&curlang);
if (strcasecmp(curlang, "fr")) {
resources_set_value("Language", (resource_value_t *)"fr");
vsid_menu_rebuild();
}
break;
case IDM_LANGUAGE_ITALIAN:
resources_get_value("Language", (void *)&curlang);
if (strcasecmp(curlang, "it")) {
resources_set_value("Language", (resource_value_t *)"it");
vsid_menu_rebuild();
}
break;
case IDM_LANGUAGE_KOREAN:
resources_get_value("Language", (void *)&curlang);
if (strcasecmp(curlang, "ko")) {
resources_set_value("Language", (resource_value_t *)"ko");
vsid_menu_rebuild();
}
break;
case IDM_LANGUAGE_DUTCH:
resources_get_value("Language", (void *)&curlang);
if (strcasecmp(curlang, "nl")) {
resources_set_value("Language", (resource_value_t *)"nl");
vsid_menu_rebuild();
}
break;
case IDM_LANGUAGE_POLISH:
resources_get_value("Language", (void *)&curlang);
if (strcasecmp(curlang, "pl")) {
resources_set_value("Language", (resource_value_t *)"pl");
vsid_menu_rebuild();
}
break;
case IDM_LANGUAGE_HUNGARIAN:
resources_get_value("Language", (void *)&curlang);
if (strcasecmp(curlang, "hu")) {
resources_set_value("Language", (resource_value_t *)"hu");
vsid_menu_rebuild();
}
break;
case IDM_LANGUAGE_RUSSIAN:
resources_get_value("Language", (void *)&curlang);
if (strcasecmp(curlang, "ru")) {
resources_set_value("Language", (resource_value_t *)"ru");
vsid_menu_rebuild();
}
break;
case IDM_LANGUAGE_SWEDISH:
resources_get_value("Language", (void *)&curlang);
if (strcasecmp(curlang, "sv")) {
resources_set_value("Language", (resource_value_t *)"sv");
vsid_menu_rebuild();
}
break;
case IDM_LANGUAGE_TURKISH:
resources_get_value("Language", (void *)&curlang);
if (strcasecmp(curlang, "tr")) {
resources_set_value("Language", (resource_value_t *)"tr");
vsid_menu_rebuild();
}
break;
default:
{
int i, j, command_found = 0;
for (i = 0; toggle_list[i].name != NULL && !command_found; i++) {
if (toggle_list[i].idm == idm) {
resources_toggle(toggle_list[i].name, NULL);
command_found = 1;
}
}
for (i = 0; value_list[i].name != NULL && !command_found; i++) {
for (j = 0; value_list[i].vals[j].idm != 0 && !command_found; j++) {
if (value_list[i].vals[j].idm == idm) {
resources_set_value(value_list[i].name, (resource_value_t) value_list[i].vals[j].value);
command_found = 1;
}
}
}
}
break;
}
return 0;
}
