void
sysinstall(void)
{
dialog_sysinstall();
dialog_system();
dialog_partsel();
dialog_label();
dialog_useradd();
dialog_rootpass();
dialog_tzone();
dialog_medium();
dialog_components();
dialog_packages();
save_config();
do_install();
}
void __cdecl
_tmain(int argc, _TCHAR *argv[])
{
SERVICE_TABLE_ENTRY DispatchTable[] =
{
{ TEXT(""), ServiceMain },
{ NULL, NULL },
};
if (argc == 2 && lstrcmpi(argv[1], TEXT("install")) == 0)
{
do_install();
return;
}
if (argc == 2 && lstrcmpi(argv[1], TEXT("uninstall")) == 0)
{
do_uninstall();
return;
}
if (argc == 2 && lstrcmpi(argv[1], TEXT("test")) == 0)
{
logger_message("hello world!");
return;
}
if (!StartServiceCtrlDispatcher(DispatchTable))
{
if (GetLastError() != ERROR_FAILED_SERVICE_CONTROLLER_CONNECT)
{
fatal_win32_error(TEXT("StartServiceCtrlDispatcher"));
}
fprintf(stderr, "Error: no option specified\n");
fprintf(stderr, "Usage: %s install\n", argv[0]);
exit(1);
}
}
int
main (int argc,
char **argv)
{
gint argi;
gint i;
if (argc == 1)
usage (EXIT_SUCCESS);
/* First scan for flags that affect our behaviour globally, but
* are still allowed late on the command line.
*/
argi = 0;
while (++argi < argc)
{
if (strcmp (argv[argi], "-n") == 0 ||
strcmp (argv[argi], "--just-print") == 0 ||
strcmp (argv[argi], "--dry-run") == 0 ||
strcmp (argv[argi], "--recon") == 0)
{
dry_run = TRUE;
}
else if (strcmp (argv[argi], "--help") == 0)
{
usage (EXIT_SUCCESS);
}
else if (g_str_has_prefix (argv[argi], "--prefix="))
{
prefix = argv[argi] + strlen ("--prefix=");
}
else if (g_str_has_prefix (argv[argi], "--exec-prefix="))
{
exec_prefix = argv[argi] + strlen ("--exec_prefix=");
}
else if (strcmp (argv[argi], "--msvc-syntax") == 0)
{
msvc_syntax = TRUE;
}
}
#ifndef G_OS_WIN32
if (msvc_syntax)
{
g_printerr ("Ignoring --msvc-syntax\n");
msvc_syntax = FALSE;
}
#endif
find_out_env_flags ();
/* Second pass, actually do something. */
argi = 0;
while (++argi < argc)
{
for (i = 0; i < G_N_ELEMENTS (dirs); i++)
{
if (strcmp (argv[argi],
g_strconcat ("--", dirs[i].option, NULL)) == 0)
break;
}
if (i < G_N_ELEMENTS (dirs))
{
g_print ("%s\n", expand_and_munge (dirs[i].value));
}
else if (strcmp (argv[argi], "--quiet") == 0 ||
strcmp (argv[argi], "--silent") == 0)
{
silent = TRUE;
}
else if (strcmp (argv[argi], "--version") == 0)
{
g_print ("%d.%d.%d\n",
GIMP_MAJOR_VERSION, GIMP_MINOR_VERSION, GIMP_MICRO_VERSION);
exit (EXIT_SUCCESS);
}
else if (strcmp (argv[argi], "-n") == 0 ||
strcmp (argv[argi], "--just-print") == 0 ||
strcmp (argv[argi], "--dry-run") == 0 ||
strcmp (argv[argi], "--recon") == 0)
; /* Already handled */
else if (strcmp (argv[argi], "--includedir") == 0)
do_includedir ();
else if (strcmp (argv[argi], "--cflags") == 0)
do_cflags ();
else if (strcmp (argv[argi], "--cflags-noui") == 0)
do_cflags_noui ();
else if (strcmp (argv[argi], "--cflags-nogimpui") == 0)
do_cflags_nogimpui ();
else if (strcmp (argv[argi], "--libs") == 0)
do_libs ();
else if (strcmp (argv[argi], "--libs-noui") == 0)
do_libs_noui ();
else if (strcmp (argv[argi], "--libs-nogimpui") == 0)
do_libs_nogimpui ();
else if (g_str_has_prefix (argv[argi], "--prefix="))
;
else if (g_str_has_prefix (argv[argi], "--exec-prefix="))
;
else if (strcmp (argv[argi], "--msvc-syntax") == 0)
;
else if (strcmp (argv[argi], "--build") == 0)
do_build (argv[++argi]);
else if (strcmp (argv[argi], "--build-noui") == 0)
do_build_noui (argv[++argi]);
else if (strcmp (argv[argi], "--build-nogimpui") == 0)
do_build_nogimpui (argv[++argi]);
else if (strcmp (argv[argi], "--install") == 0)
do_install (argv[++argi]);
else if (strcmp (argv[argi], "--install-noui") == 0)
do_install_noui (argv[++argi]);
else if (strcmp (argv[argi], "--install-nogimpui") == 0)
do_install_nogimpui (argv[++argi]);
else if (strcmp (argv[argi], "--install-admin") == 0)
do_install_admin (argv[++argi]);
else if (strcmp (argv[argi], "--install-admin-noui") == 0)
do_install_admin_noui (argv[++argi]);
else if (strcmp (argv[argi], "--install-admin-nogimpui") == 0)
do_install_admin_nogimpui (argv[++argi]);
else if (strcmp (argv[argi], "--install-bin") == 0)
do_install_bin (argv[++argi]);
else if (strcmp (argv[argi], "--install-admin-bin") == 0)
do_install_admin_bin (argv[++argi]);
else if (strcmp (argv[argi], "--uninstall-bin") == 0)
do_uninstall_bin (argv[++argi]);
else if (strcmp (argv[argi], "--uninstall-admin-bin") == 0)
do_uninstall_admin_bin (argv[++argi]);
else if (strcmp (argv[argi], "--install-script") == 0)
do_install_script (argv[++argi]);
else if (strcmp (argv[argi], "--install-admin-script") == 0)
do_install_admin_script (argv[++argi]);
else if (strcmp (argv[argi], "--uninstall-script") == 0)
do_uninstall_script (argv[++argi]);
else if (strcmp (argv[argi], "--uninstall-admin-script") == 0)
do_uninstall_admin_script (argv[++argi]);
else
{
g_printerr ("Unrecognized switch %s\n", argv[argi]);
usage (EXIT_FAILURE);
}
}
exit (EXIT_SUCCESS);
}
static void
do_install_nogimpui (const gchar *what)
{
do_install (what);
}
/**
* Creates a veh_interact window based on the given parameters.
* @param v The vehicle the player is interacting with.
* @param x The x-coordinate of the square the player is 'e'xamining.
* @param y The y-coordinate of the square the player is 'e'xamining.
*/
void veh_interact::exec (game *gm, vehicle *v, int x, int y)
{
g = gm;
veh = v;
// x1 x2
// y1 ----+------+--
// | |
// y2 ----+------+
// |
// |
winw1 = 12;
winw2 = 35;
winh1 = 3;
winh2 = 12;
winw12 = winw1 + winw2 + 1;
winw3 = FULL_SCREEN_WIDTH - winw1 - winw2 - 2;
winh3 = FULL_SCREEN_HEIGHT - winh1 - winh2 - 2;
winh23 = winh2 + winh3 + 1;
winx1 = winw1;
winx2 = winw1 + winw2 + 1;
winy1 = winh1;
winy2 = winh1 + winh2 + 1;
// changed FALSE value to 1, to keep w_border from starting at a negative x,y
const int iOffsetX = (TERMX > FULL_SCREEN_WIDTH) ? (TERMX-FULL_SCREEN_WIDTH)/2 : 1;
const int iOffsetY = (TERMY > FULL_SCREEN_HEIGHT) ? (TERMY-FULL_SCREEN_HEIGHT)/2 : 1;
page_size = winh23;
// h w y x
WINDOW *w_border= newwin(FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, -1 + iOffsetY, -1 + iOffsetX);
w_grid = newwin(FULL_SCREEN_HEIGHT -2, FULL_SCREEN_WIDTH-2, iOffsetY, iOffsetX);
w_mode = newwin(1, FULL_SCREEN_WIDTH-2, iOffsetY, iOffsetX);
w_msg = newwin(winh1 - 1, FULL_SCREEN_WIDTH-2, 1 + iOffsetY, iOffsetX);
w_disp = newwin(winh2-1, winw1, winy1 + 1 + iOffsetY, iOffsetX);
w_parts = newwin(winh2-1, winw2, winy1 + 1 + iOffsetY, winx1 + 1 + iOffsetX);
w_stats = newwin(winh3-1, winw12, winy2 + iOffsetY, iOffsetX);
w_list = newwin(winh23, winw3, winy1 + 1 + iOffsetY, winx2 + 1 + iOffsetX);
wborder(w_border, LINE_XOXO, LINE_XOXO, LINE_OXOX, LINE_OXOX,
LINE_OXXO, LINE_OOXX, LINE_XXOO, LINE_XOOX );
mvwputch(w_border, 16, 0, c_ltgray, LINE_XXXO); // |-
mvwputch(w_border, 4, 0, c_ltgray, LINE_XXXO); // |-
mvwputch(w_border, 4, FULL_SCREEN_WIDTH-1, c_ltgray, LINE_XOXX); // -|
mvwputch(w_border, 24, 49, c_ltgray, LINE_XXOX);
wrefresh(w_border);
for (int i = 0; i < FULL_SCREEN_HEIGHT; i++)
{
mvwputch(w_grid, i, winx2, c_ltgray, i == winy1 || i == winy2-1? LINE_XOXX : LINE_XOXO);
if (i >= winy1 && i < winy2) {
mvwputch(w_grid, i, winx1, c_ltgray, LINE_XOXO);
}
}
for (int i = 0; i < FULL_SCREEN_WIDTH; i++)
{
mvwputch(w_grid, winy1, i, c_ltgray,
i == winx1? LINE_OXXX : (i == winx2? LINE_OXXX : LINE_OXOX));
if (i < winx2) {
mvwputch(w_grid, winy2-1, i, c_ltgray, i == winx1? LINE_XXOX : LINE_OXOX);
}
}
wrefresh(w_grid);
crafting_inv = gm->crafting_inventory(&gm->u);
int charges = static_cast<it_tool *>(g->itypes["welder"])->charges_per_use;
int charges_crude = static_cast<it_tool *>(g->itypes["welder_crude"])->charges_per_use;
has_wrench = crafting_inv.has_amount("wrench", 1) ||
crafting_inv.has_amount("toolset", 1);
has_hacksaw = crafting_inv.has_amount("hacksaw", 1) ||
crafting_inv.has_amount("toolset", 1);
has_welder = (crafting_inv.has_amount("welder", 1) &&
crafting_inv.has_charges("welder", charges)) ||
(crafting_inv.has_amount("welder_crude", 1) &&
crafting_inv.has_charges("welder_crude", charges_crude)) ||
(crafting_inv.has_amount("toolset", 1) &&
crafting_inv.has_charges("toolset", charges/20));
has_jack = crafting_inv.has_amount("jack", 1);
has_siphon = crafting_inv.has_amount("hose", 1);
has_wheel = crafting_inv.has_amount( "wheel", 1 ) ||
crafting_inv.has_amount( "wheel_wide", 1 ) ||
crafting_inv.has_amount( "wheel_bicycle", 1 ) ||
crafting_inv.has_amount( "wheel_motorbike", 1 ) ||
crafting_inv.has_amount( "wheel_small", 1 );
display_stats ();
display_veh ();
move_cursor (0, 0);
bool finish = false;
while (!finish)
{
char ch = input(); // See keypress.h
int dx, dy;
get_direction (dx, dy, ch);
if (ch == KEY_ESCAPE || ch == 'q' )
{
finish = true;
}
else
{
if (dx != -2 && (dx || dy) &&
cursor_x + dx >= -6 && cursor_x + dx < 6 &&
cursor_y + dy >= -6 && cursor_y + dy < 6)
{
move_cursor(dx, dy);
}
else
{
int mval = cant_do(ch);
display_mode (ch);
switch (ch)
{
case 'i': do_install(mval); break;
case 'r': do_repair(mval); break;
case 'f': do_refill(mval); break;
case 'o': do_remove(mval); break;
case 'e': do_rename(mval); break;
case 's': do_siphon(mval); break;
case 'c': do_tirechange(mval); break;
case 'd': do_drain(mval); break;
}
if (sel_cmd != ' ')
{
finish = true;
}
display_mode (' ');
}
}
}
werase(w_grid);
werase(w_mode);
werase(w_msg);
werase(w_disp);
werase(w_parts);
werase(w_stats);
werase(w_list);
delwin(w_grid);
delwin(w_mode);
delwin(w_msg);
delwin(w_disp);
delwin(w_parts);
delwin(w_stats);
delwin(w_list);
erase();
}
//void do_install(opkg_conf* conf, char* pkg_name, char* install_root_name, char* link_root_name, char** version_criteria)
void do_install(opkg_conf* conf, string_map* pkgs, char* install_root_name, char* link_root_name, int is_upgrade, int overwrite_config, int overwrite_other_package_files, int force_reinstall, char* tmp_root)
{
string_map* package_data = initialize_string_map(1);
string_map* matching_packages = initialize_string_map(1);
string_map* pkgs_from_file = initialize_string_map(1);
unsigned long num_destroyed;
char* install_root_path = (char*)get_string_map_element(conf->dest_names, install_root_name);
char* overlay_path = NULL; // no special treatment of overlay, can be reenabled by setting this variable here if we ever need it
char* test_dir = dynamic_strcat(2, (overlay_path != NULL ? overlay_path : install_root_path), "/usr/lib/opkg/info");
if(!create_dir_and_test_writable(test_dir))
{
fprintf(stderr, "ERROR: Specified install destination is not writable, exiting\n");
exit(1);
}
free(test_dir);
if(install_root_path == NULL)
{
printf("ERROR: No destination %s found, cannot install\n\n", install_root_name);
exit(1);
}
char* tmp_dir = (char*)malloc(1024);
if(create_tmp_dir(tmp_root == NULL ? "/tmp" : tmp_root, &tmp_dir) != 0)
{
fprintf(stderr, "ERROR: Could not create tmp dir, exiting\n");
exit(1);
}
/* Determine all packages to install by first loading all package names, status & dependencies (and no other variables) */
load_all_package_data(conf, package_data, matching_packages, NULL, LOAD_MINIMAL_PKG_VARIABLES_FOR_ALL, install_root_name, 1, NULL );
destroy_string_map(matching_packages, DESTROY_MODE_FREE_VALUES, &num_destroyed);
/* determine list of all packiages we are about to install, including dependencies */
string_map* install_pkgs_map = initialize_string_map(1);
char** install_pkg_list = NULL;
unsigned long install_pkg_list_len = 0;
char* unsatisfied_dep_err = NULL;
/* new string map var with all pkgs to install = pkgs, keys = version */
unsigned long num_pkg_names;
char** pkg_names = get_string_map_keys(pkgs, &num_pkg_names);
int pkg_name_index;
/*
* Load data for any packages being installed via ipk and
* determine if any packages we are about to install
* provide anything, and if so set package we are installing to preferred
*/
string_map* preferred_provides = initialize_string_map(1);
for(pkg_name_index=0;pkg_name_index < num_pkg_names; pkg_name_index++)
{
char* pkg_name = pkg_names[pkg_name_index];
char** version_criteria = get_string_map_element(pkgs, pkg_name);
char* install_pkg_version = NULL;
int install_pkg_is_current;
/* deal with case where we're installing from file */
if(path_exists(pkg_name))
{
//installing from file
char* pkg_file = pkg_name;
//extract control files
int err = 0;
char* tmp_control = dynamic_strcat(2, tmp_dir, "/tmp_ctrl");
char* tmp_control_prefix = dynamic_strcat(2, tmp_control, "/tmp.");
char* tmp_control_name = dynamic_strcat(2, tmp_control_prefix, "control");
mkdir_p(tmp_control, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH );
deb_extract( pkg_file,
stderr,
extract_control_tar_gz | extract_all_to_fs| extract_preserve_date | extract_unconditional,
tmp_control_prefix,
NULL,
&err);
if(err != 0)
{
fprintf(stderr, "ERROR: %s is not a valid package file, cannot install\n", pkg_file);
rm_r(tmp_dir);
exit(1);
}
string_map* tmp_control_pkg_data = initialize_string_map(1);
matching_packages = initialize_string_map(1);
load_package_data(tmp_control_name, 0, tmp_control_pkg_data, matching_packages, NULL, LOAD_ALL_PKG_VARIABLES, NULL, NULL);
unsigned long num_ctrl_names;
char** ctrl_name_list = get_string_map_keys(tmp_control_pkg_data, &num_ctrl_names);
destroy_string_map(matching_packages, DESTROY_MODE_FREE_VALUES, &num_destroyed);
err = 1; //set back to 0 when data successfully loaded
if(num_ctrl_names > 0)
{
int ctrl_name_index;
for(ctrl_name_index=0; ctrl_name_list[ctrl_name_index] != NULL; ctrl_name_index++)
{
if( strcmp(ctrl_name_list[ctrl_name_index], PROVIDES_STRING) != 0)
{
pkg_name = strdup(ctrl_name_list[ctrl_name_index]);
}
}
char* version = NULL;
int is_current;
string_map* pkg_info = get_package_current_or_latest(tmp_control_pkg_data, pkg_name, &is_current, &version);
if(pkg_info != NULL)
{
err = 0;
set_string_map_element(pkg_info, "Install-File-Location", strdup(pkg_file));
set_string_map_element(pkg_info, "Version", version); //we need to save this, since we are going to set a special version to make sure data doesn't get over-written later, also no need to free version now
char* special_version = dynamic_strcat(2, version, "@@_FILE_INSTALL_VERSION_@@");
char** new_version_criteria = malloc(3*sizeof(char*));
new_version_criteria[0] = strdup("=");
new_version_criteria[1] = special_version;
new_version_criteria[2] = NULL;
version_criteria = new_version_criteria;
string_map* all_current_versions = get_string_map_element(package_data, pkg_name);
if(all_current_versions == NULL)
{
all_current_versions=initialize_string_map(1);
set_string_map_element(package_data, pkg_name, all_current_versions);
}
set_string_map_element(all_current_versions, special_version, pkg_info);
set_string_map_element(all_current_versions, LATEST_VERSION_STRING, special_version);
free(pkg_names[pkg_name_index]);
pkg_names[pkg_name_index] = strdup(pkg_name);
set_string_map_element(pkgs, pkg_name, copy_null_terminated_string_array(new_version_criteria));
set_string_map_element(pkgs_from_file, pkg_name, strdup("D"));
}
}
free_null_terminated_string_array(ctrl_name_list);
if(err != 0)
{
fprintf(stderr, "ERROR: %s is not a valid package file, cannot install\n", pkg_file);
rm_r(tmp_dir);
exit(1);
}
free_if_not_null(tmp_control);
free_if_not_null(tmp_control_prefix);
free_if_not_null(tmp_control_name);
rm_r(tmp_control);
}
/* determine if package provides anything, and set this package to preferred if so*/
string_map* install_pkg_data = get_package_current_or_latest_matching(package_data, pkg_name, version_criteria, &install_pkg_is_current, &install_pkg_version);
if(install_pkg_data != NULL)
{
char* provides_str = get_string_map_element(install_pkg_data, "Provides");
if(provides_str != NULL)
{
if(strlen(provides_str) > 0)
{
unsigned long num_provides;
char package_separators[] = {' ', ',', ':', ';', '\'', '\"', '\t', '\r', '\n'};
char** provides_list = split_on_separators(provides_str, package_separators, 9, -1, 0, &num_provides);
int provides_index;
char* provides_unique_key = dynamic_strcat(3, pkg_name, "@", install_pkg_version);
for(provides_index=0; provides_index < num_provides; provides_index++)
{
char* provides_name = strdup(provides_list[provides_index]);
char* eq = strchr(provides_name, '=');
if(eq != NULL) { *eq = '\0' ; }
if(strlen(provides_name) > 0)
{
set_string_map_element(preferred_provides, provides_name, strdup(provides_unique_key));
}
}
}
}
}
}
/* reload with new preferred_provides */
free_recursive_package_vars(package_data);
matching_packages = initialize_string_map(1);
load_all_package_data(conf, package_data, matching_packages, NULL, LOAD_MINIMAL_PKG_VARIABLES_FOR_ALL, install_root_name, 1, preferred_provides );
destroy_string_map(matching_packages, DESTROY_MODE_FREE_VALUES, &num_destroyed);
/* load data and do sanity checks for packages we are about to install */
for(pkg_name_index=0;pkg_name_index < num_pkg_names; pkg_name_index++)
{
char* pkg_name = pkg_names[pkg_name_index];
char** version_criteria = get_string_map_element(pkgs, pkg_name);
char* install_pkg_version = NULL;
int install_pkg_is_current;
load_recursive_package_data_variables(package_data, pkg_name, 1, 0, 0); // load required-depends for package of interest only
string_map* install_pkg_data = get_package_current_or_latest_matching(package_data, pkg_name, version_criteria, &install_pkg_is_current, &install_pkg_version);
char* install_status = install_pkg_data == NULL ? NULL : get_string_map_element(install_pkg_data, "Status");
if(install_status != NULL)
{
char** old_el = set_string_map_element(install_pkgs_map, pkg_name, copy_null_terminated_string_array(version_criteria) );
if(old_el != NULL){ free_null_terminated_string_array(old_el); }
string_map* install_pkg_depend_map = get_string_map_element(install_pkg_data, "Required-Depends");
if(install_pkg_depend_map != NULL)
{
unsigned long num_keys;
char** load_detail_pkgs = get_string_map_keys(install_pkg_depend_map, &num_keys);
int ldp_index;
for(ldp_index=0;ldp_index < num_keys && unsatisfied_dep_err == NULL; ldp_index++)
{
char* dep_name = load_detail_pkgs[ldp_index];
char** dep_def= get_string_map_element(install_pkg_depend_map, dep_name);
if(get_string_map_element(install_pkgs_map, dep_name) != NULL)
{
/*
* We really should check here whether old dependency def can be reconciled with the new one, and report an error if it can't
* Right now we just use the heuristic that top-level (user specified, not dependency) package defs get preference, followed
* by first dependency encountered.
*
* Since right now versioning features aren't really being used very much other than kernel dependencies in Gargoyle/OpenWrt
* I'm just leaving this comment here as a reminder that this should be addressed at some point rather than messing with it now
*
*/
dep_def = get_string_map_element(install_pkgs_map, dep_name);
}
else
{
set_string_map_element(install_pkgs_map, dep_name, copy_null_terminated_string_array(dep_def));
}
//error checking, check that dependency definition exists
char* latest_version = NULL;
int latest_is_current = 0;
string_map* dep_info = get_package_current_or_latest_matching(package_data, dep_name, dep_def, &latest_is_current, &latest_version);
//check if we have a version installed different than what is required
int have_current;
char* current_version = NULL;
string_map* cur_info = get_package_current_or_latest(package_data, dep_name, &have_current, ¤t_version);
if(have_current && (latest_is_current == 0 || dep_info == NULL))
{
//should only get here if dep_def[1] is not null (version mismatch doesn't make sense if no version is specified)
char* cur_status = get_string_map_element(cur_info, "Status");
if(strstr(cur_status, " hold ") != NULL)
{
unsatisfied_dep_err = dynamic_strcat(11, "ERROR: Dependency ", dep_name, " (", dep_def[0], " ", dep_def[1], ") of package ", pkg_name, " is installed,\n\t\tbut has incompatible version ", current_version, " and is marked as 'hold'");
}
else
{
unsatisfied_dep_err = dynamic_strcat(10, "ERROR: Dependency ", dep_name, " (", dep_def[0], " ", dep_def[1], ") of package ", pkg_name, " is installed,\n\t\tbut has incompatible version ", current_version);
}
}
free_if_not_null(current_version);
free_if_not_null(latest_version);
// check that dependency definition exists
if(unsatisfied_dep_err == NULL && dep_info == NULL)
{
if(dep_def[1] != NULL)
{
unsatisfied_dep_err = dynamic_strcat(9, "ERROR: Dependency ", dep_name, " (", dep_def[0], " ", dep_def[1], ") of package ", pkg_name, " cannot be found, try updating your package lists");
}
else
{
unsatisfied_dep_err = dynamic_strcat(5, "ERROR: Dependency ", dep_name, " of package ", pkg_name, " cannot be found, try updating your package lists");
}
}
}
free_null_terminated_string_array(load_detail_pkgs);
}
}
install_status = install_pkg_data == NULL ? NULL : get_string_map_element(install_pkg_data, "Status");
/* error checking before we start install */
if(install_pkg_data == NULL || install_status == NULL)
{
fprintf(stderr, "ERROR: No package named %s found, try updating your package lists\n\n", pkg_name);
rm_r(tmp_dir);
exit(1);
}
if(strstr(install_status, " installed") != NULL)
{
if(force_reinstall)
{
fprintf(stderr, "WARNING: Package %s is already installed, forcing removal and reinstallation\n\n", pkg_name);
free_package_data(package_data);
string_map* rm_pkg = initialize_string_map(1);
set_string_map_element(rm_pkg, pkg_name, alloc_depend_def(NULL));
do_remove(conf, rm_pkg, (overwrite_config ? 0 : 1), 0, 1, 0, tmp_root);
//restart install
return do_install(conf, pkgs, install_root_name, link_root_name, is_upgrade, overwrite_config, overwrite_other_package_files, force_reinstall, tmp_root);
}
else
{
fprintf(stderr, "WARNING: Package %s is already installed, ignoring\n", pkg_name);
fprintf(stderr, " Use --force-reinstall to force reinstallation\n\n");
char** old_el = remove_string_map_element(install_pkgs_map, pkg_name);
if(old_el != NULL){ free_null_terminated_string_array(old_el); };
}
}
if(unsatisfied_dep_err != NULL)
{
fprintf(stderr, "%s\n", unsatisfied_dep_err);
rm_r(tmp_dir);
exit(1);
}
}
/* load more detailed data on packages we are about to install */
free_recursive_package_vars(package_data); /* note: whacks install_pkg_depend_map */
string_map* parameters = initialize_string_map(1);
matching_packages = initialize_string_map(1);
set_string_map_element(parameters, "package-list", install_pkgs_map);
load_all_package_data(conf, package_data, matching_packages, parameters, LOAD_MINIMAL_FOR_ALL_PKGS_ALL_FOR_MATCHING, install_root_name, 0, preferred_provides);
unsigned long from_file_pkg_list_len;
char** from_file_pkg_list = get_string_map_keys(pkgs_from_file, &from_file_pkg_list_len);
int from_file_index;
for(from_file_index=0; from_file_index < from_file_pkg_list_len; from_file_index++)
{
char* old = set_string_map_element(matching_packages, from_file_pkg_list[from_file_index], strdup("D"));
free_if_not_null(old);
}
free_null_terminated_string_array(from_file_pkg_list);
install_pkg_list = get_string_map_keys(matching_packages, &install_pkg_list_len);
destroy_string_map(matching_packages, DESTROY_MODE_FREE_VALUES, &num_destroyed);
destroy_string_map(parameters, DESTROY_MODE_IGNORE_VALUES, &num_destroyed);
char* all_pkg_list_str = join_strs(", ", install_pkg_list, install_pkg_list_len, 0, 0);
uint64_t combined_size = 0;
int pkg_index;
for(pkg_index=0; pkg_index < install_pkg_list_len; pkg_index++)
{
char** match_criteria = get_string_map_element(install_pkgs_map, install_pkg_list[pkg_index]);
string_map* pkg = get_package_current_or_latest_matching(package_data, install_pkg_list[pkg_index], match_criteria, NULL, NULL);
char* next_size_str = get_string_map_element(pkg, "Installed-Size");
uint64_t next_size = 0;
if(sscanf(next_size_str, SCANFU64, &next_size) > 0)
{
combined_size = combined_size + next_size;
}
}
uint64_t root_size = destination_bytes_free(conf, install_root_name);
if(combined_size >= root_size )
{
fprintf(stderr, "ERROR: Not enough space in destination %s to install specified packages:\n\t%s\n\n", install_root_name, all_pkg_list_str);
rm_r(tmp_dir);
exit(1);
}
if(all_pkg_list_str != NULL)
{
printf("Preparing to install the following packages, which will require " SCANFU64 " bytes:\n\t%s\n\n", combined_size, all_pkg_list_str);
}
else
{
fprintf(stderr, "No packages to install.\n\n");
}
/* Set status of new required packages to half-installed, set user-installed on requested package, installed time on all */
char* install_root_status_path = dynamic_strcat(2, install_root_path, "/usr/lib/opkg/status");
string_map* install_root_status = initialize_string_map(1);
matching_packages = initialize_string_map(1);
if(path_exists(install_root_status_path))
{
load_package_data(install_root_status_path, 0, install_root_status, matching_packages, NULL, LOAD_ALL_PKG_VARIABLES, install_root_name, preferred_provides);
}
destroy_string_map(matching_packages, DESTROY_MODE_FREE_VALUES, &num_destroyed);
time_t now = time(NULL);
char install_time[20];
sprintf(install_time, "%lu", now);
for(pkg_index=0; pkg_index < install_pkg_list_len; pkg_index++)
{
int is_installed;
char* install_version = NULL;
char** match_criteria = get_string_map_element(install_pkgs_map, install_pkg_list[pkg_index]);
string_map* pkg = get_package_current_or_latest_matching(package_data, install_pkg_list[pkg_index], match_criteria, &is_installed, &install_version);
if(is_installed == 0) /* should never be true, but check anyway */
{
char* old_status = remove_string_map_element(pkg, "Status");
free(old_status);
char* status_parts[3] = { "install", "ok", "half-installed" };
status_parts[1] = get_string_map_element(pkgs, install_pkg_list[pkg_index]) != NULL ? "user" : status_parts[1];
char* new_status = dynamic_strcat(5, status_parts[0], " ", status_parts[1], " ", status_parts[2]);
set_string_map_element(pkg, "Status", new_status);
set_string_map_element(pkg, "Installed-Time", strdup(install_time));
set_string_map_element(pkg, "Install-Destination", strdup(install_root_name));
if(link_root_name != NULL)
{
set_string_map_element(pkg, "Link-Destination", strdup(link_root_name));
}
add_package_data(install_root_status, &pkg, install_pkg_list[pkg_index], install_version, NULL);
/* Note: we just added pkg data structure from package_data to install_root_status, Be careful on cleanup! */
}
}
save_package_data_as_status_file(install_root_status, install_root_status_path);
string_map* install_called_pkgs = initialize_string_map(1);
int err = 0;
for(pkg_name_index=0;pkg_name_index < num_pkg_names; pkg_name_index++)
{
char* pkg_name = pkg_names[pkg_name_index];
if(get_string_map_element(install_pkgs_map, pkg_name) != NULL && get_string_map_element(install_called_pkgs, pkg_name) == NULL)
{
int install_pkg_is_current;
char* install_pkg_version = NULL;
char** version_criteria = get_string_map_element(pkgs, pkg_name);
get_package_current_or_latest_matching(package_data, pkg_name, version_criteria, &install_pkg_is_current, &install_pkg_version);
err = recursively_install(pkg_name, install_pkg_version, install_root_name, link_root_name, overlay_path, is_upgrade, overwrite_config, overwrite_other_package_files, tmp_dir, conf, package_data, install_called_pkgs);
free_if_not_null(install_pkg_version);
}
}
if(err)
{
fprintf(stderr, "An error occurred during Installation, removing partially installed packages.\n");
unsigned long num_install_called_pkgs;
char** install_called_pkg_list = get_string_map_keys(install_called_pkgs, &num_install_called_pkgs);
int pkg_index;
for(pkg_index=0; pkg_index < num_install_called_pkgs; pkg_index++)
{
remove_individual_package(install_called_pkg_list[pkg_index], conf, package_data, tmp_dir, 0, 0);
}
free_null_terminated_string_array(install_called_pkg_list);
//call remove function to do cleanup of partial install
//DO NOT EXIT HERE, fixup status file below
}
//remove tmp dir -- need to do this whether or not there is an error
rm_r(tmp_dir);
free(tmp_dir);
//set status of new packages to installed on success, and remove on failure
for(pkg_index=0; pkg_index < install_pkg_list_len; pkg_index++)
{
/* no need to check version, should only be one installed version at a time... */
string_map* pkg = get_package_current_or_latest(install_root_status, install_pkg_list[pkg_index], NULL, NULL);
if(pkg != NULL)
{
if(!err)
{
char* status = get_string_map_element(pkg, "Status");
if(strstr(status, " half-installed") != NULL)
{
char* status_parts[3] = { "install", "ok", "installed" };
status_parts[1] = get_string_map_element(pkgs, install_pkg_list[pkg_index]) != NULL ? "user" : status_parts[1];
char* new_status = dynamic_strcat(5, status_parts[0], " ", status_parts[1], " ", status_parts[2]);
char* old_status = set_string_map_element(pkg, "Status", new_status);
free_if_not_null(old_status);
}
}
else
{
string_map* all_pkg_versions = remove_string_map_element(install_root_status, install_pkg_list[pkg_index]);
free_all_package_versions(all_pkg_versions);
}
}
}
save_package_data_as_status_file(install_root_status, install_root_status_path);
if(!err)
{
if(all_pkg_list_str != NULL)
{
printf("Installation of packages successful.\n\n");
}
}
else
{
printf("Finished removing partially installed packages.\n\n");
}
}
int main(int argc, char* argv[])
{
CURL* curl;
bstring command;
bstring name;
bstring modpath;
int all;
// Define arguments.
struct arg_lit* show_help = arg_lit0("h", "help", "Show this help.");
struct arg_str* cmdopt = arg_str1(NULL, NULL, "<command>", "The command; either 'search', 'install', 'uninstall', 'enable' or 'disable'.");
struct arg_str* nameopt = arg_str0(NULL, NULL, "<name>", "The name of the module to search for, install, uninstall, enable or disable.");
struct arg_lit* all_flag = arg_lit0("a", "all", "Apply this command to all available / installed modules.");
struct arg_lit* verbose = arg_litn("v", NULL, 0, LEVEL_EVERYTHING - LEVEL_DEFAULT, "Increase verbosity.");
struct arg_lit* quiet = arg_litn("q", NULL, 0, LEVEL_DEFAULT - LEVEL_SILENT, "Decrease verbosity.");
struct arg_end* end = arg_end(20);
void* argtable[] = { show_help, cmdopt, all_flag, nameopt, verbose, quiet, end };
// Parse arguments.
int nerrors = arg_parse(argc, argv, argtable);
if (nerrors != 0 || show_help->count != 0 || (all_flag->count == 0 && nameopt->count == 0))
{
if (all_flag->count == 0 && nameopt->count == 0)
printd(LEVEL_ERROR, "error: must have either module name or -a.");
if (show_help->count != 0)
arg_print_errors(stderr, end, "mm");
fprintf(stderr, "syntax:\n dtmm");
arg_print_syntax(stderr, argtable, "\n");
fprintf(stderr, "options:\n");
arg_print_glossary(stderr, argtable, " %-25s %s\n");
arg_freetable(argtable, sizeof(argtable) / sizeof(argtable[0]));
return 1;
}
// Set verbosity level.
debug_setlevel(LEVEL_DEFAULT + verbose->count - quiet->count);
// Show version information.
version_print(bautofree(bfromcstr("Module Manager")));
// Set argument 0 and convert parameters.
osutil_setarg0(bautofree(bfromcstr(argv[0])));
command = bfromcstr(cmdopt->sval[0]);
name = bfromcstr(nameopt->sval[0]);
// Initialize curl or exit.
curl = curl_easy_init();
if (!curl)
{
printd(LEVEL_ERROR, "unable to initialize curl.\n");
return 1;
}
// Ensure module path exists.
modpath = osutil_getmodulepath();
if (modpath == NULL)
{
printd(LEVEL_ERROR, "module path does not exist (searched TOOLCHAIN_MODULES and modules/).\n");
return 1;
}
bdestroy(modpath);
// Convert all flag.
all = (all_flag->count > 0);
// If all is set, set the name back to "".
if (all)
bassigncstr(name, "");
// If the name is "all" or "*", handle this as the all
// boolean flag.
if (biseqcstr(name, "all") || biseqcstr(name, "*"))
{
bassigncstr(name, "");
all = 1;
printd(LEVEL_WARNING, "treating name as -a (all) flag");
}
if (biseqcstrcaseless(command, "search") || biseqcstrcaseless(command, "se"))
return do_search(curl, name, all);
else if (biseqcstrcaseless(command, "install") || biseqcstrcaseless(command, "in"))
{
if (all)
return do_install_all(curl);
else
return do_install(curl, name);
}
else if (biseqcstrcaseless(command, "uninstall") || biseqcstrcaseless(command, "rm"))
{
if (all)
return do_uninstall_all(curl);
else
return do_uninstall(curl, name);
}
else if (biseqcstrcaseless(command, "enable") || biseqcstrcaseless(command, "en"))
{
if (all)
return do_enable_all(curl);
else
return do_enable(curl, name);
}
else if (biseqcstrcaseless(command, "disable") || biseqcstrcaseless(command, "di") || biseqcstrcaseless(command, "dis"))
{
if (all)
return do_disable_all(curl);
else
return do_disable(curl, name);
}
else
{
printd(LEVEL_ERROR, "unknown command (must be search, install, uninstall, enable or disable).");
return 1;
}
return 0;
}
bool do_install_all(CURL* curl)
{
// define used variables
DIR* dir;
FILE* fp;
CURLcode res;
bool printed;
bool install_status;
bool something_errored;
bool if_something_was_installed;
list_t installed;
long httpcode = 0;
struct dirent* entry;
struct bStream* stream;
bstring buffer, fname, sstr;
bstring modpath = osutil_getmodulepath();
bstring ext = bfromcstr(".lua");
bstring url = bfromcstr("http://dms.dcputoolcha.in/modules/list");
list_init(&installed);
list_attributes_copy(&installed, list_meter_string, 1);
list_attributes_comparator(&installed, list_comparator_string);
// Attempt to open the modules directory.
dir = opendir(modpath->data);
if (dir == NULL)
{
printd(LEVEL_ERROR, "unable to query local repository.\n");
return 1;
}
// add the filename we wish to query to the modules folder path
bcatcstr(modpath, "/.all_avail");
// Open the file and do the cURL transfer.
printd(LEVEL_DEFAULT, "loading a list of all the modules...\n");
fp = fopen(modpath->data, "wb");
curl_easy_setopt(curl, CURLOPT_URL, url->data);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp);
res = curl_easy_perform(curl);
curl_easy_getinfo(curl, CURLINFO_HTTP_CODE, &httpcode);
if (res != 0 || httpcode != 200)
{
bdestroy(url);
bdestroy(modpath);
printd(LEVEL_ERROR, "curl failed with error code %i, HTTP error code %i.\n", res, httpcode);
return 1;
}
fclose(fp);
// create a list of already installed modules
while ((entry = readdir(dir)) != NULL)
{
fname = bfromcstr(&entry->d_name[0]);
if (binstr(fname, blength(fname) - 4, ext) == BSTR_ERR)
{
bdestroy(fname);
continue;
}
if (entry->d_type != DT_REG)
{
bdestroy(fname);
continue;
}
sstr = bmidstr(fname, 0, blength(fname) - 4);
list_append(&installed, sstr->data);
bdestroy(sstr);
bdestroy(fname);
}
printd(LEVEL_DEFAULT, "\n");
// Print the names of the modules, and install them through the do_install function
fp = fopen(modpath->data, "r");
stream = bsopen(&read_data, fp);
buffer = bfromcstr("");
printed = false;
if_something_was_installed = false;
something_errored = false;
while (bsreadln(buffer, stream, '\n') != BSTR_ERR)
{
btrimws(buffer);
sstr = bmidstr(buffer, 0, blength(buffer) - 4);
// if the module is not already installed
if (!list_contains(&installed, sstr->data))
{
install_status = do_install(curl, bfromcstr(sstr->data));
if_something_was_installed = true;
// check whether the installation was successful
if (install_status != 0)
{
printd(LEVEL_DEFAULT, " %s failed to install.\n", sstr->data);
something_errored = true;
}
printd(LEVEL_DEFAULT, "\n");
}
printed = true;
bdestroy(sstr);
}
if (!printed)
printd(LEVEL_DEFAULT, " <no modules available>\n");
if (something_errored)
printd(LEVEL_DEFAULT, "errors occured\n");
if (!if_something_was_installed)
printd(LEVEL_DEFAULT, "no changes were made\n");
bsclose(stream);
fclose(fp);
// Clean up.
curl_easy_cleanup(curl);
return 0;
}
void veh_interact::exec (game *gm, vehicle *v, int x, int y)
{
g = gm;
veh = v;
ex = x;
ey = y;
// x1 x2
// y1 ----+------+--
// | |
// y2 ----+------+
// |
// |
winw1 = 12;
winw2 = 35;
winh1 = 3;
winh2 = 12;
winw12 = winw1 + winw2 + 1;
winw3 = 80 - winw1 - winw2 - 2;
winh3 = 25 - winh1 - winh2 - 2;
winh23 = winh2 + winh3 + 1;
winx1 = winw1;
winx2 = winw1 + winw2 + 1;
winy1 = winh1;
winy2 = winh1 + winh2 + 1;
page_size = winh23;
// h w y x
w_grid = newwin(25, 80, 0, 0);
w_mode = newwin(1, 80, 0, 0);
w_msg = newwin(winh1 - 1, 80, 1, 0);
w_disp = newwin(winh2, winw1, winy1 + 1, 0);
w_parts = newwin(winh2, winw2, winy1 + 1, winx1 + 1);
w_stats = newwin(winh3, winw12, winy2 + 1, 0);
w_list = newwin(winh23, winw3, winy1 + 1, winx2 + 1);
for (int i = 0; i < 25; i++)
{
mvwputch(w_grid, i, winx2, c_ltgray, i == winy1 || i == winy2? LINE_XOXX : LINE_XOXO);
if (i >= winy1 && i < winy2)
mvwputch(w_grid, i, winx1, c_ltgray, LINE_XOXO);
}
for (int i = 0; i < 80; i++)
{
mvwputch(w_grid, winy1, i, c_ltgray, i == winx1? LINE_OXXX : (i == winx2? LINE_OXXX : LINE_OXOX));
if (i < winx2)
mvwputch(w_grid, winy2, i, c_ltgray, i == winx1? LINE_XXOX : LINE_OXOX);
}
wrefresh(w_grid);
crafting_inv = gm->crafting_inventory();
int charges = ((it_tool *) g->itypes["welder"])->charges_per_use;
has_wrench = crafting_inv.has_amount("wrench", 1) ||
crafting_inv.has_amount("toolset", 1);
has_hacksaw = crafting_inv.has_amount("hacksaw", 1) ||
crafting_inv.has_amount("toolset", 1);
has_welder = (crafting_inv.has_amount("welder", 1) &&
crafting_inv.has_charges("welder", charges)) ||
(crafting_inv.has_amount("toolset", 1) &&
crafting_inv.has_charges("toolset", charges/5));
display_stats ();
display_veh ();
move_cursor (0, 0);
bool finish = false;
while (!finish)
{
char ch = input(); // See keypress.h
int dx, dy;
get_direction (gm, dx, dy, ch);
if (ch == KEY_ESCAPE)
finish = true;
else
if (dx != -2 && (dx || dy) &&
cx + dx >= -6 && cx + dx < 6 &&
cy + dy >= -6 && cy + dy < 6)
move_cursor(dx, dy);
else
{
int mval = cant_do(ch);
display_mode (ch);
switch (ch)
{
case 'i': do_install(mval); break;
case 'r': do_repair(mval); break;
case 'f': do_refill(mval); break;
case 'o': do_remove(mval); break;
case 'e': do_rename(mval); break;
default:;
}
if (sel_cmd != ' ')
finish = true;
display_mode (' ');
}
}
werase(w_grid);
werase(w_mode);
werase(w_msg);
werase(w_disp);
werase(w_parts);
werase(w_stats);
werase(w_list);
delwin(w_grid);
delwin(w_mode);
delwin(w_msg);
delwin(w_disp);
delwin(w_parts);
delwin(w_stats);
delwin(w_list);
erase();
}
int
main(int argc, char *argv[])
{
char *subcmd;
int cmdnum;
int cmd_index = 0;
int rc = SUCCESS;
(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */
#endif
(void) textdomain(TEXT_DOMAIN);
cryptodebug_init(basename(argv[0]));
if (argc < REQ_ARG_CNT) {
usage();
return (ERROR_USAGE);
}
/* get the subcommand index */
cmd_index = 0;
subcmd = argv[1];
cmdnum = sizeof (cmd_table)/sizeof (cmd_table[0]);
while ((cmd_index < cmdnum) &&
(strcmp(subcmd, cmd_table[cmd_index]) != 0)) {
cmd_index++;
}
if (cmd_index >= cmdnum) {
usage();
return (ERROR_USAGE);
}
/* do the subcommand */
switch (cmd_index) {
case CRYPTO_LIST:
rc = do_list(argc, argv);
break;
case CRYPTO_DISABLE:
rc = do_disable(argc, argv);
break;
case CRYPTO_ENABLE:
rc = do_enable(argc, argv);
break;
case CRYPTO_INSTALL:
rc = do_install(argc, argv);
break;
case CRYPTO_UNINSTALL:
rc = do_uninstall(argc, argv);
break;
case CRYPTO_UNLOAD:
rc = do_unload(argc, argv);
break;
case CRYPTO_REFRESH:
rc = do_refresh(argc);
break;
case CRYPTO_START:
rc = do_start(argc);
break;
case CRYPTO_STOP:
rc = do_stop(argc);
break;
case CRYPTO_HELP:
usage();
rc = SUCCESS;
break;
default: /* should not come here */
usage();
rc = ERROR_USAGE;
break;
}
return (rc);
}
/**
* Creates a veh_interact window based on the given parameters.
* @param v The vehicle the player is interacting with.
* @param x The x-coordinate of the square the player is 'e'xamining.
* @param y The y-coordinate of the square the player is 'e'xamining.
*/
void veh_interact::exec (game *gm, vehicle *v, int x, int y)
{
veh = v;
// winw1 winw2 winw3
// winh1 | |
// ------+-------+------
// winh2 | |
// ------+-------+------
// winh3 | |
//
// +-------------------------+
// | w_mode |
// | w_msg |
// +-------+---------+-------+
// |w_disp | w_parts | w_list|
// +-------+---------+-------+
// | w_stats |
// +-------------------------+
int winw1 = 12;
int winw2 = 35;
int winh1 = 3;
int winh2 = 13;
int winw3 = FULL_SCREEN_WIDTH - winw1 - winw2 - 4;
int winh3 = FULL_SCREEN_HEIGHT - winh1 - winh2 - 2;
int winx1 = winw1;
int winx2 = winw1 + winw2 + 1;
int winy1 = winh1;
int winy2 = winh1 + winh2 + 1;
mode_h = 1;
mode_w = FULL_SCREEN_WIDTH - 2;
msg_h = winh1 - 1;
msg_w = FULL_SCREEN_WIDTH - 2;
disp_h = winh2 - 1;
disp_w = winw1;
parts_h = winh2 - 1;
parts_w = winw2;
stats_h = winh3 - 1;
stats_w = FULL_SCREEN_WIDTH - 2;
list_h = winh2 - 1;
list_w = winw3;
const int iOffsetX = 1 + ((TERMX > FULL_SCREEN_WIDTH) ? (TERMX-FULL_SCREEN_WIDTH)/2 : 0);
const int iOffsetY = 1 + ((TERMY > FULL_SCREEN_HEIGHT) ? (TERMY-FULL_SCREEN_HEIGHT)/2 : 0);
page_size = list_h;
// h w y x
WINDOW *w_border = newwin( FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, -1 + iOffsetY, -1 + iOffsetX );
w_grid = newwin( FULL_SCREEN_HEIGHT - 2, FULL_SCREEN_WIDTH - 2, iOffsetY, iOffsetX );
w_mode = newwin( mode_h, mode_w, iOffsetY, iOffsetX );
w_msg = newwin( msg_h, msg_w, mode_h + iOffsetY, iOffsetX );
w_disp = newwin( disp_h, disp_w, mode_h + msg_h + 1 + iOffsetY, iOffsetX );
w_parts = newwin( parts_h, parts_w, mode_h + msg_h + 1 + iOffsetY, disp_w + 1 + iOffsetX );
w_list = newwin( list_h, list_w, mode_h + msg_h + 1 + iOffsetY,
disp_w + 1 + parts_w + 1 + iOffsetX );
w_stats = newwin( stats_h, stats_w, mode_h + msg_h + 1 + disp_h + 1 + iOffsetY, iOffsetX );
wborder(w_border, LINE_XOXO, LINE_XOXO, LINE_OXOX, LINE_OXOX,
LINE_OXXO, LINE_OOXX, LINE_XXOO, LINE_XOOX );
mvwputch(w_border, mode_h + msg_h + 1 + disp_h + 1, 0, c_ltgray, LINE_XXXO); // |-
mvwputch(w_border, mode_h + msg_h + 1, 0, c_ltgray, LINE_XXXO); // |-
mvwputch(w_border, mode_h + msg_h + 1 + disp_h + 1, FULL_SCREEN_WIDTH - 1, c_ltgray, LINE_XOXX);
mvwputch(w_border, mode_h + msg_h + 1, FULL_SCREEN_WIDTH - 1, c_ltgray, LINE_XOXX);
wrefresh(w_border);
// Two lines dividing the three middle sections.
for (int i = winy1; i < winy2; i++) {
mvwputch(w_grid, i, winx2, c_ltgray, LINE_XOXO);
mvwputch(w_grid, i, winx1, c_ltgray, LINE_XOXO);
}
// Two lines dividing the vertical menu sections.
for (int i = 0; i < FULL_SCREEN_WIDTH; i++) {
mvwputch( w_grid, winy1, i, c_ltgray, LINE_OXOX );
mvwputch( w_grid, winy2-1, i, c_ltgray, LINE_OXOX );
}
// Fix up the line intersections.
mvwputch( w_grid, winy1, winx1, c_ltgray, LINE_OXXX );
mvwputch( w_grid, winy1, winx2, c_ltgray, LINE_OXXX );
mvwputch( w_grid, winy2 - 1, winx1, c_ltgray, LINE_XXOX );
mvwputch( w_grid, winy2 - 1, winx2, c_ltgray, LINE_XXOX );
wrefresh(w_grid);
crafting_inv = g->crafting_inventory(&g->u);
int charges = static_cast<it_tool *>(g->itypes["welder"])->charges_per_use;
int charges_crude = static_cast<it_tool *>(g->itypes["welder_crude"])->charges_per_use;
has_wrench = crafting_inv.has_amount("wrench", 1) ||
crafting_inv.has_amount("toolset", 1);
has_hacksaw = crafting_inv.has_amount("hacksaw", 1) ||
crafting_inv.has_amount("toolset", 1);
has_welder = (crafting_inv.has_amount("welder", 1) &&
crafting_inv.has_charges("welder", charges)) ||
(crafting_inv.has_amount("welder_crude", 1) &&
crafting_inv.has_charges("welder_crude", charges_crude)) ||
(crafting_inv.has_amount("toolset", 1) &&
crafting_inv.has_charges("toolset", charges/20));
has_jack = crafting_inv.has_amount("jack", 1);
has_siphon = crafting_inv.has_amount("hose", 1);
has_wheel = crafting_inv.has_amount( "wheel", 1 ) ||
crafting_inv.has_amount( "wheel_wide", 1 ) ||
crafting_inv.has_amount( "wheel_bicycle", 1 ) ||
crafting_inv.has_amount( "wheel_motorbike", 1 ) ||
crafting_inv.has_amount( "wheel_small", 1 );
display_stats ();
display_veh ();
move_cursor (0, 0);
bool finish = false;
while (!finish)
{
char ch = input(); // See keypress.h
int dx, dy;
get_direction (dx, dy, ch);
if (ch == KEY_ESCAPE || ch == 'q' ) {
finish = true;
} else {
if (dx != -2 && (dx || dy) &&
cursor_x + dx >= -6 && cursor_x + dx < 6 &&
cursor_y + dy >= -6 && cursor_y + dy < 6)
{
move_cursor(dx, dy);
}
else
{
int mval = cant_do(ch);
display_mode (ch);
switch (ch)
{
case 'i': do_install(mval); break;
case 'r': do_repair(mval); break;
case 'f': do_refill(mval); break;
case 'o': do_remove(mval); break;
case 'e': do_rename(mval); break;
case 's': do_siphon(mval); break;
case 'c': do_tirechange(mval); break;
case 'd': do_drain(mval); break;
}
if (sel_cmd != ' ')
{
finish = true;
}
display_mode (' ');
}
}
}
werase(w_grid);
werase(w_mode);
werase(w_msg);
werase(w_disp);
werase(w_parts);
werase(w_stats);
werase(w_list);
delwin(w_grid);
delwin(w_mode);
delwin(w_msg);
delwin(w_disp);
delwin(w_parts);
delwin(w_stats);
delwin(w_list);
erase();
}
int main(int argc, char** argv)
{
string_map* parameters = parse_parameters(argc, argv);
opkg_conf *conf = load_conf((char*)get_string_map_element(parameters, "config"));
char* run_type = get_string_map_element(parameters, "run-type");
int force_overwrite_other_files = get_string_map_element(parameters, "force-overwrite") != NULL ? 1 : 0;
int force_overwrite_configs = get_string_map_element(parameters, "force-overwrite-configs") != NULL ? 1 : 0;
int force_depends = get_string_map_element(parameters, "force-depends") != NULL ? 1 : 0;
int force_reinstall = get_string_map_element(parameters, "force-reinstall") != NULL ? 1 : 0;
int remove_orphaned_depends = get_string_map_element(parameters, "autoremove") != NULL ? REMOVE_ALL_ORPHANED_DEPENDENCIES : REMOVE_NO_ORPHANED_DEPENDENCIES;
remove_orphaned_depends = get_string_map_element(parameters, "autoremove-same-destination") != NULL ? REMOVE_ORPHANED_DEPENDENCIES_IN_SAME_DEST : remove_orphaned_depends;
char* install_root = get_string_map_element(parameters, "install-destination");
install_root = install_root == NULL ? strdup("root") : install_root;
char* link_root = get_string_map_element(parameters, "link-destination");
char* tmp_root = get_string_map_element(parameters, "tmp_dir");
tmp_root = tmp_root == NULL ? strdup("/tmp") : tmp_root;
string_map* pkgs = get_string_map_element(parameters, "package-list");
char* format_str = get_string_map_element(parameters, "output-format");
int format = OUTPUT_HUMAN_READABLE;
if(format_str != NULL)
{
format = strcmp(format_str, "json") == 0 ? OUTPUT_JSON : format;
format = strcmp(format_str, "js") == 0 || strcmp(format_str, "javascript") == 0 ? OUTPUT_JAVASCRIPT : format;
}
if(strcmp(run_type, "install") == 0)
{
do_install(conf, pkgs, install_root, link_root, 0, force_overwrite_configs, force_overwrite_other_files, force_reinstall, tmp_root);
}
else if(strcmp(run_type, "remove") == 0)
{
do_remove(conf, pkgs, !force_overwrite_configs, remove_orphaned_depends, force_depends, 1);
}
else if(strcmp(run_type, "upgrade") == 0)
{
do_upgrade(conf, pkgs, !force_overwrite_configs, install_root, link_root);
}
else if(strcmp(run_type, "update") == 0)
{
update(conf);
}
else if((strcmp(run_type, "list") == 0) || strcmp(run_type, "list-installed") == 0 || strcmp(run_type, "list_installed") == 0)
{
do_list(conf, parameters, format);
}
else if(strcmp(run_type, "dest-info") == 0 || strcmp(run_type, "dest_info") == 0)
{
do_print_dest_info(conf, format);
}
else if(strcmp(run_type, "info") == 0)
{
do_print_info(conf, parameters, install_root, format);
}
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() */
int i3_do_poldek_ts_install(struct poldek_ts *ts)
{
int i, nerr = 0, n, is_particle;
struct i3ctx ictx;
tn_array *pkgs = NULL;
n_assert(ts->type == POLDEK_TS_INSTALL);
if ((n = i3_pre_ts_install(ts, &pkgs)) <= 0) {
n_assert(pkgs == NULL);
return n == 0 ? 1 : 0; /* report success(1) if 'nothing to do' */
}
n_assert(pkgs);
n_assert(n_array_size(pkgs) > 0);
is_particle = ts->getop(ts, POLDEK_OP_PARTICLE); /* preserve option value */
if (n_array_size(pkgs) == 1)
ts->setop(ts, POLDEK_OP_PARTICLE, 0);
/* tests make sense on whole set only */
else if (ts->getop_v(ts, POLDEK_OP_TEST, POLDEK_OP_RPMTEST, 0))
ts->setop(ts, POLDEK_OP_PARTICLE, 0);
/* so JUSTPRINTs */
else if (ts->getop_v(ts, POLDEK_OP_JUSTPRINT, POLDEK_OP_JUSTPRINT_N, 0))
ts->setop(ts, POLDEK_OP_PARTICLE, 0);
if (poldek__is_in_testing_mode())
ts->setop(ts, POLDEK_OP_PARTICLE, 1);
i3ctx_init(&ictx, ts);
for (i = 0; i < n_array_size(pkgs); i++) {
struct pkg *pkg = n_array_nth(pkgs, i);
if (!pkg_is_marked_i(ts->pms, pkg))
continue;
if (sigint_reached())
goto l_end;
if (ts->getop(ts, POLDEK_OP_PARTICLE)) {
if (n > 1) {
if (poldek_VERBOSE > 0) {
poldek_term_printf_c(PRCOLOR_YELLOW,
"Installing set #%d\n", n);
fflush(stdout);
}
msgn_f(0, "** Installing set #%d\n", n);
}
n++;
pkgdb_reopen(ts->db, 0);
}
DBGF("mark %s\n", pkg_id(pkg));
i3_mark_package(&ictx, pkg, PKGMARK_MARK);
if (ts->getop(ts, POLDEK_OP_PARTICLE)) {
i3_mark_namegroup(&ictx, pkg, ts->ctx->ps->pkgs);
if (!do_install(&ictx))
nerr++;
ts_reset(ictx.ts);
i3ctx_reset(&ictx);
}
}
if (!ts->getop(ts, POLDEK_OP_PARTICLE))
nerr = !do_install(&ictx);
l_end:
i3ctx_destroy(&ictx);
MEMINF("END");
if (is_particle)
ts->setop(ts, POLDEK_OP_PARTICLE, 1);
return nerr == 0;
}
