1 /* $NetBSD: util.c,v 1.78 2025/08/05 14:52:43 kim Exp $ */ 2 3 /* 4 * Copyright 1997 Piermont Information Systems Inc. 5 * All rights reserved. 6 * 7 * Written by Philip A. Nelson for Piermont Information Systems Inc. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. The name of Piermont Information Systems Inc. may not be used to endorse 18 * or promote products derived from this software without specific prior 19 * written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY PIERMONT INFORMATION SYSTEMS INC. ``AS IS'' 22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL PIERMONT INFORMATION SYSTEMS INC. BE 25 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 31 * THE POSSIBILITY OF SUCH DAMAGE. 32 * 33 */ 34 35 /* util.c -- routines that don't really fit anywhere else... */ 36 37 #include <assert.h> 38 #include <inttypes.h> 39 #include <stdio.h> 40 #include <stdarg.h> 41 #include <string.h> 42 #include <unistd.h> 43 #include <sys/mount.h> 44 #include <sys/dkio.h> 45 #include <sys/ioctl.h> 46 #include <sys/types.h> 47 #include <sys/param.h> 48 #include <sys/sysctl.h> 49 #include <sys/stat.h> 50 #include <sys/statvfs.h> 51 #include <isofs/cd9660/iso.h> 52 #include <curses.h> 53 #include <err.h> 54 #include <errno.h> 55 #include <dirent.h> 56 #include <util.h> 57 #include "defs.h" 58 #include "md.h" 59 #include "defsizes.h" 60 #include "msg_defs.h" 61 #include "menu_defs.h" 62 #ifdef MD_MAY_SWAP_TO 63 #include <sys/drvctlio.h> 64 #endif 65 #ifdef CHECK_ENTROPY 66 #include <sha2.h> 67 #include <paths.h> 68 #endif 69 70 #define MAX_CD_DEVS 256 /* how many cd drives do we expect to attach */ 71 #define ISO_BLKSIZE ISO_DEFAULT_BLOCK_SIZE 72 73 static const char *msg_yes, *msg_no, *msg_all, *msg_some, *msg_none; 74 static int select_menu_width; 75 76 static uint8_t set_status[SET_GROUP_END]; 77 #define SET_VALID 0x01 78 #define SET_SELECTED 0x02 79 #define SET_SKIPPED 0x04 80 #define SET_INSTALLED 0x08 81 #define SET_NO_EXTRACT 0x10 82 83 struct tarstats { 84 int nselected; 85 int nfound; 86 int nnotfound; 87 int nerror; 88 int nsuccess; 89 int nskipped; 90 } tarstats; 91 92 distinfo dist_list[] = { 93 #ifdef SET_KERNEL_1_NAME 94 {SET_KERNEL_1_NAME, SET_KERNEL_1, false, MSG_set_kernel_1, NULL}, 95 #endif 96 #ifdef SET_KERNEL_2_NAME 97 {SET_KERNEL_2_NAME, SET_KERNEL_2, false, MSG_set_kernel_2, NULL}, 98 #endif 99 #ifdef SET_KERNEL_3_NAME 100 {SET_KERNEL_3_NAME, SET_KERNEL_3, false, MSG_set_kernel_3, NULL}, 101 #endif 102 #ifdef SET_KERNEL_4_NAME 103 {SET_KERNEL_4_NAME, SET_KERNEL_4, false, MSG_set_kernel_4, NULL}, 104 #endif 105 #ifdef SET_KERNEL_5_NAME 106 {SET_KERNEL_5_NAME, SET_KERNEL_5, false, MSG_set_kernel_5, NULL}, 107 #endif 108 #ifdef SET_KERNEL_6_NAME 109 {SET_KERNEL_6_NAME, SET_KERNEL_6, false, MSG_set_kernel_6, NULL}, 110 #endif 111 #ifdef SET_KERNEL_7_NAME 112 {SET_KERNEL_7_NAME, SET_KERNEL_7, false, MSG_set_kernel_7, NULL}, 113 #endif 114 #ifdef SET_KERNEL_8_NAME 115 {SET_KERNEL_8_NAME, SET_KERNEL_8, false, MSG_set_kernel_8, NULL}, 116 #endif 117 #ifdef SET_KERNEL_9_NAME 118 {SET_KERNEL_9_NAME, SET_KERNEL_9, false, MSG_set_kernel_9, NULL}, 119 #endif 120 121 #ifdef HAVE_MODULES 122 {"modules", SET_MODULES, false, MSG_set_modules, NULL}, 123 #endif 124 {"base", SET_BASE, false, MSG_set_base, NULL}, 125 #ifdef HAVE_BASE32 126 {"base32", SET_BASE32, false, MSG_set_base32, NULL}, 127 #endif 128 #ifdef HAVE_BASE64 129 {"base64", SET_BASE64, false, MSG_set_base64, NULL}, 130 #endif 131 #ifdef HAVE_DTB 132 {"dtb", SET_DTB, false, MSG_set_dtb, NULL}, 133 #endif 134 {"etc", SET_ETC, false, MSG_set_system, NULL}, 135 {"comp", SET_COMPILER, false, MSG_set_compiler, NULL}, 136 {"games", SET_GAMES, false, MSG_set_games, NULL}, 137 {"gpufw", SET_GPUFW, false, MSG_set_gpufw, NULL}, 138 {"man", SET_MAN_PAGES, false, MSG_set_man_pages, NULL}, 139 {"manhtml", SET_MAN_PAGES_HTML, false, MSG_set_man_pages_html, NULL}, 140 {"misc", SET_MISC, false, MSG_set_misc, NULL}, 141 {"rescue", SET_RESCUE, false, MSG_set_rescue, NULL}, 142 {"tests", SET_TESTS, false, MSG_set_tests, NULL}, 143 {"text", SET_TEXT_TOOLS, false, MSG_set_text_tools, NULL}, 144 145 {NULL, SET_GROUP, false, MSG_set_X11, NULL}, 146 {"xbase", SET_X11_BASE, false, MSG_set_X11_base, NULL}, 147 {"xcomp", SET_X11_PROG, false, MSG_set_X11_prog, NULL}, 148 {"xetc", SET_X11_ETC, false, MSG_set_X11_etc, NULL}, 149 {"xfont", SET_X11_FONTS, false, MSG_set_X11_fonts, NULL}, 150 {"xserver", SET_X11_SERVERS, false, MSG_set_X11_servers, NULL}, 151 {NULL, SET_GROUP_END, false, NULL, NULL}, 152 153 #ifdef SET_MD_1_NAME 154 {SET_MD_1_NAME, SET_MD_1, false, MSG_set_md_1, NULL}, 155 #endif 156 #ifdef SET_MD_2_NAME 157 {SET_MD_2_NAME, SET_MD_2, false, MSG_set_md_2, NULL}, 158 #endif 159 #ifdef SET_MD_3_NAME 160 {SET_MD_3_NAME, SET_MD_3, false, MSG_set_md_3, NULL}, 161 #endif 162 #ifdef SET_MD_4_NAME 163 {SET_MD_4_NAME, SET_MD_4, false, MSG_set_md_4, NULL}, 164 #endif 165 166 {NULL, SET_GROUP, true, MSG_set_source, NULL}, 167 {"syssrc", SET_SYSSRC, true, MSG_set_syssrc, NULL}, 168 {"src", SET_SRC, true, MSG_set_src, NULL}, 169 {"sharesrc", SET_SHARESRC, true, MSG_set_sharesrc, NULL}, 170 {"gnusrc", SET_GNUSRC, true, MSG_set_gnusrc, NULL}, 171 {"xsrc", SET_XSRC, true, MSG_set_xsrc, NULL}, 172 {"debug", SET_DEBUG, false, MSG_set_debug, NULL}, 173 #ifdef HAVE_DEBUG32 174 {"debug32", SET_DEBUG32, false, MSG_set_debug32, NULL}, 175 #endif 176 #ifdef HAVE_DEBUG64 177 {"debug64", SET_DEBUG64, false, MSG_set_debug64, NULL}, 178 #endif 179 {"xdebug", SET_X11_DEBUG, false, MSG_set_xdebug, NULL}, 180 {NULL, SET_GROUP_END, false, NULL, NULL}, 181 182 {NULL, SET_LAST, false, NULL, NULL}, 183 }; 184 185 #define MAX_CD_INFOS 16 /* how many media can be found? */ 186 struct cd_info { 187 char device_name[16]; 188 char menu[100]; 189 }; 190 static struct cd_info cds[MAX_CD_INFOS]; 191 192 /* flags whether to offer the respective options (depending on helper 193 programs available on install media */ 194 int have_raid, have_vnd, have_cgd, have_lvm, have_gpt, have_dk; 195 196 /* 197 * local prototypes 198 */ 199 200 static int check_for(unsigned int mode, const char *pathname); 201 static int get_iso9660_volname(int dev, int sess, char *volname, 202 size_t volnamelen); 203 static int get_available_cds(void); 204 static int binary_available(const char *prog); 205 206 void 207 init_set_status(int flags) 208 { 209 static const uint8_t sets_valid[] = {MD_SETS_VALID}; 210 static const uint8_t sets_selected_full[] = {MD_SETS_SELECTED}; 211 static const uint8_t sets_selected_minimal[] = {MD_SETS_SELECTED_MINIMAL}; 212 static const uint8_t sets_selected_nox[] = {MD_SETS_SELECTED_NOX}; 213 static const uint8_t *sets_selected; 214 unsigned int nelem_selected; 215 unsigned int i, len; 216 const char *longest; 217 218 if (flags & SFLAG_MINIMAL) { 219 sets_selected = sets_selected_minimal; 220 nelem_selected = __arraycount(sets_selected_minimal); 221 } else if (flags & SFLAG_NOX) { 222 sets_selected = sets_selected_nox; 223 nelem_selected = __arraycount(sets_selected_nox); 224 } else { 225 sets_selected = sets_selected_full; 226 nelem_selected = __arraycount(sets_selected_full); 227 } 228 229 for (i = 0; i < __arraycount(sets_valid); i++) 230 set_status[sets_valid[i]] = SET_VALID; 231 for (i = 0; i < nelem_selected; i++) 232 set_status[sets_selected[i]] |= SET_SELECTED; 233 234 set_status[SET_GROUP] = SET_VALID; 235 236 /* Lookup some strings we need lots of times */ 237 msg_yes = msg_string(MSG_Yes); 238 msg_no = msg_string(MSG_No); 239 msg_all = msg_string(MSG_All); 240 msg_some = msg_string(MSG_Some); 241 msg_none = msg_string(MSG_None); 242 243 /* Find longest and use it to determine width of selection menu */ 244 len = strlen(msg_no); longest = msg_no; 245 i = strlen(msg_yes); if (i > len) {len = i; longest = msg_yes; } 246 i = strlen(msg_all); if (i > len) {len = i; longest = msg_all; } 247 i = strlen(msg_some); if (i > len) {len = i; longest = msg_some; } 248 i = strlen(msg_none); if (i > len) {len = i; longest = msg_none; } 249 select_menu_width = snprintf(NULL, 0, "%-40s %s", "", longest); 250 251 /* Give the md code a chance to choose the right kernel, etc. */ 252 md_init_set_status(flags); 253 } 254 255 int 256 dir_exists_p(const char *path) 257 { 258 259 return file_mode_match(path, S_IFDIR); 260 } 261 262 int 263 file_exists_p(const char *path) 264 { 265 266 return file_mode_match(path, S_IFREG); 267 } 268 269 int 270 file_mode_match(const char *path, unsigned int mode) 271 { 272 struct stat st; 273 274 return (stat(path, &st) == 0 && (st.st_mode & S_IFMT) == mode); 275 } 276 277 /* return ram size in MB */ 278 uint64_t 279 get_ramsize(void) 280 { 281 static uint64_t ramsize; 282 283 if (ramsize == 0) { 284 size_t len = sizeof ramsize; 285 int mib[2] = {CTL_HW, HW_PHYSMEM64}; 286 287 sysctl(mib, 2, &ramsize, &len, NULL, 0); 288 } 289 290 /* Find out how many Megs ... round up. */ 291 return (ramsize + MEG - 1) / MEG; 292 } 293 294 void 295 run_makedev(void) 296 { 297 char *owd; 298 299 msg_display_add("\n\n"); 300 msg_display_add(MSG_makedev); 301 302 owd = getcwd(NULL, 0); 303 304 /* make /dev, in case the user didn't extract it. */ 305 make_target_dir("/dev"); 306 target_chdir_or_die("/dev"); 307 run_program(0, "/bin/sh MAKEDEV all"); 308 309 chdir(owd); 310 free(owd); 311 } 312 313 /* 314 * Performs in-place replacement of a set of patterns in a file that lives 315 * inside the installed system. The patterns must be separated by a semicolon. 316 * For example: 317 * 318 * replace("/etc/some-file.conf", "s/prop1=NO/prop1=YES/;s/foo/bar/"); 319 */ 320 void 321 replace(const char *path, const char *patterns, ...) 322 { 323 char *spatterns; 324 va_list ap; 325 326 va_start(ap, patterns); 327 vasprintf(&spatterns, patterns, ap); 328 va_end(ap); 329 if (spatterns == NULL) 330 err(1, "vasprintf(&spatterns, \"%s\", ...)", patterns); 331 332 run_program(RUN_CHROOT, "sed -an -e '%s;H;$!d;g;w %s' %s", spatterns, 333 path, path); 334 335 free(spatterns); 336 } 337 338 static int 339 floppy_fetch(const char *set_name) 340 { 341 char post[4]; 342 msg errmsg; 343 int menu; 344 int status; 345 const char *write_mode = ">"; 346 347 strcpy(post, "aa"); 348 349 errmsg = ""; 350 menu = MENU_fdok; 351 for (;;) { 352 umount_mnt2(); 353 msg_display(errmsg); 354 msg_fmt_display_add(MSG_fdmount, "%s%s", set_name, post); 355 process_menu(menu, &status); 356 if (status != SET_CONTINUE) 357 return status; 358 menu = MENU_fdremount; 359 errmsg = MSG_fdremount; 360 if (run_program(0, "/sbin/mount -r -t %s %s /mnt2", 361 fd_type, fd_dev)) 362 continue; 363 mnt2_mounted = 1; 364 errmsg = MSG_fdnotfound; 365 366 /* Display this because it might take a while.... */ 367 if (run_program(RUN_DISPLAY, 368 "sh -c '/bin/cat /mnt2/%s.%s %s %s/%s/%s%s'", 369 set_name, post, write_mode, 370 target_prefix(), xfer_dir, set_name, 371 set_postfix(set_name))) 372 /* XXX: a read error will give a corrupt file! */ 373 continue; 374 375 /* We got that file, advance to next fragment */ 376 if (post[1] < 'z') 377 post[1]++; 378 else 379 post[1] = 'a', post[0]++; 380 write_mode = ">>"; 381 errmsg = ""; 382 menu = MENU_fdok; 383 } 384 } 385 386 /* 387 * Load files from floppy. Requires a /mnt2 directory for mounting them. 388 */ 389 int 390 get_via_floppy(void) 391 { 392 int rv = -1; 393 394 process_menu(MENU_floppysource, &rv); 395 if (rv == SET_RETRY) 396 return SET_RETRY; 397 398 fetch_fn = floppy_fetch; 399 400 /* Set ext_dir for absolute path. */ 401 snprintf(ext_dir_bin, sizeof ext_dir_bin, "%s/%s", target_prefix(), xfer_dir); 402 snprintf(ext_dir_src, sizeof ext_dir_src, "%s/%s", target_prefix(), xfer_dir); 403 404 return SET_OK; 405 } 406 407 /* 408 * Get the volume name of a ISO9660 file system 409 */ 410 static int 411 get_iso9660_volname(int dev, int sess, char *volname, size_t volnamelen) 412 { 413 int blkno, error, last; 414 static char buf[ISO_BLKSIZE] __aligned(8); 415 struct iso_volume_descriptor *vd = NULL; 416 struct iso_primary_descriptor *pd = NULL; 417 418 for (blkno = sess+16; blkno < sess+16+100; blkno++) { 419 error = pread(dev, buf, ISO_BLKSIZE, blkno*ISO_BLKSIZE); 420 if (error == -1) 421 return -1; 422 vd = (struct iso_volume_descriptor *)&buf; 423 if (memcmp(vd->id, ISO_STANDARD_ID, sizeof(vd->id)) != 0) 424 return -1; 425 if (isonum_711((const unsigned char *)&vd->type) 426 == ISO_VD_PRIMARY) { 427 pd = (struct iso_primary_descriptor*)buf; 428 strncpy(volname, pd->volume_id, volnamelen - 1); 429 volname[volnamelen - 1] = '\0'; 430 last = volnamelen - 1; 431 while (last >= 0 432 && (volname[last] == ' ' || volname[last] == 0)) 433 last--; 434 volname[last+1] = 0; 435 return 0; 436 } 437 } 438 return -1; 439 } 440 441 /* 442 * Local state while iterating CDs and collecting volumes 443 */ 444 struct get_available_cds_state { 445 size_t num_mounted; 446 struct statvfs *mounted; 447 struct cd_info *info; 448 size_t count; 449 }; 450 451 /* 452 * Callback function: if this is a CD, enumerate all volumes on it 453 */ 454 static bool 455 get_available_cds_helper(void *arg, const char *device) 456 { 457 struct get_available_cds_state *state = arg; 458 char dname[16], tname[16], volname[80], *t; 459 struct disklabel label; 460 int part, dev, error, sess, ready, tlen; 461 462 if (!is_cdrom_device(device, false)) 463 return true; 464 465 sprintf(dname, "/dev/r%s%c", device, 'a'+RAW_PART); 466 tlen = sprintf(tname, "/dev/%s", device); 467 468 /* check if this is mounted already */ 469 for (size_t i = 0; i < state->num_mounted; i++) { 470 if (strncmp(state->mounted[i].f_mntfromname, tname, tlen) 471 == 0) { 472 t = state->mounted[i].f_mntfromname + tlen; 473 if (t[0] >= 'a' && t[0] <= 'z' && t[1] == 0) 474 return true; 475 } 476 } 477 478 dev = open(dname, O_RDONLY, 0); 479 if (dev == -1) 480 return true; 481 482 ready = 0; 483 error = ioctl(dev, DIOCTUR, &ready); 484 if (error != 0 || ready == 0) { 485 close(dev); 486 return true; 487 } 488 error = ioctl(dev, DIOCGDINFO, &label); 489 close(dev); 490 if (error != 0) 491 return true; 492 493 for (part = 0; part < label.d_npartitions; part++) { 494 495 if (label.d_partitions[part].p_fstype == FS_UNUSED 496 || label.d_partitions[part].p_size == 0) 497 continue; 498 499 if (label.d_partitions[part].p_fstype == FS_ISO9660) { 500 sess = label.d_partitions[part].p_cdsession; 501 sprintf(dname, "/dev/r%s%c", device, 'a'+part); 502 dev = open(dname, O_RDONLY, 0); 503 if (dev == -1) 504 continue; 505 error = get_iso9660_volname(dev, sess, volname, 506 sizeof volname); 507 close(dev); 508 if (error) 509 continue; 510 sprintf(state->info->device_name, 511 "%s%c", device, 'a'+part); 512 sprintf(state->info->menu, "%s (%s)", 513 state->info->device_name, volname); 514 } else { 515 /* 516 * All install CDs use partition 517 * a for the sets. 518 */ 519 if (part > 0) 520 continue; 521 sprintf(state->info->device_name, 522 "%s%c", device, 'a'+part); 523 strcpy(state->info->menu, state->info->device_name); 524 } 525 state->info++; 526 if (++state->count >= MAX_CD_INFOS) 527 return false; 528 } 529 530 return true; 531 } 532 533 /* 534 * Get a list of all available CD media (not drives!), return 535 * the number of entries collected. 536 */ 537 static int 538 get_available_cds(void) 539 { 540 struct get_available_cds_state data; 541 int n, m; 542 543 memset(&data, 0, sizeof data); 544 data.info = cds; 545 546 n = getvfsstat(NULL, 0, ST_NOWAIT); 547 if (n > 0) { 548 data.mounted = calloc(n, sizeof(*data.mounted)); 549 m = getvfsstat(data.mounted, n*sizeof(*data.mounted), 550 ST_NOWAIT); 551 assert(m >= 0 && m <= n); 552 data.num_mounted = m; 553 } 554 555 enumerate_disks(&data, get_available_cds_helper); 556 557 free(data.mounted); 558 559 return data.count; 560 } 561 562 static int 563 cd_has_sets(void) 564 { 565 566 /* sanity check */ 567 if (cdrom_dev[0] == 0) 568 return 0; 569 570 /* Mount it */ 571 if (run_program(RUN_SILENT, "/sbin/mount -rt cd9660 /dev/%s /mnt2", 572 cdrom_dev) != 0) 573 return 0; 574 575 mnt2_mounted = 1; 576 577 snprintf(ext_dir_bin, sizeof ext_dir_bin, "%s/%s", "/mnt2", set_dir_bin); 578 snprintf(ext_dir_src, sizeof ext_dir_src, "%s/%s", "/mnt2", set_dir_src); 579 return dir_exists_p(ext_dir_bin); 580 } 581 582 /* 583 * Check whether we can remove the boot media. 584 * If it is not a local filesystem, return -1. 585 * If we can not decide for sure (can not tell MD content from plain ffs 586 * on hard disk, for example), return 0. 587 * If it is a CD/DVD, return 1. 588 */ 589 int 590 boot_media_still_needed(void) 591 { 592 struct statvfs sb; 593 594 if (statvfs("/", &sb) == 0) { 595 if (!(sb.f_flag & ST_LOCAL)) 596 return -1; 597 if (strcmp(sb.f_fstypename, MOUNT_CD9660) == 0 598 || strcmp(sb.f_fstypename, MOUNT_UDF) == 0) 599 return 1; 600 } 601 602 return 0; 603 } 604 605 bool 606 root_is_read_only(void) 607 { 608 struct statvfs sb; 609 610 if (statvfs("/", &sb) == 0) 611 return sb.f_flag & ST_RDONLY; 612 613 return false; 614 } 615 616 /* 617 * Get from a CDROM distribution. 618 * Also used on "installation using bootable install media" 619 * as the default option in the "distmedium" menu. 620 */ 621 int 622 get_via_cdrom(void) 623 { 624 menu_ent cd_menu[MAX_CD_INFOS]; 625 struct stat sb; 626 int rv, num_cds, menu_cd, i, selected_cd = 0; 627 int mib[2]; 628 char rootdev[SSTRSIZE] = ""; 629 size_t varlen; 630 631 /* If root is not md(4) and we have set dir, skip this step. */ 632 mib[0] = CTL_KERN; 633 mib[1] = KERN_ROOT_DEVICE; 634 varlen = sizeof(rootdev); 635 (void)sysctl(mib, 2, rootdev, &varlen, NULL, 0); 636 if (stat(set_dir_bin, &sb) == 0 && S_ISDIR(sb.st_mode) && 637 strncmp("md", rootdev, 2) != 0) { 638 strlcpy(ext_dir_bin, set_dir_bin, sizeof ext_dir_bin); 639 strlcpy(ext_dir_src, set_dir_src, sizeof ext_dir_src); 640 return SET_OK; 641 } 642 643 memset(cd_menu, 0, sizeof(cd_menu)); 644 num_cds = get_available_cds(); 645 if (num_cds <= 0) { 646 msg_display(MSG_No_cd_found); 647 cdrom_dev[0] = 0; 648 } else if (num_cds == 1) { 649 /* single CD found, check for sets on it */ 650 strcpy(cdrom_dev, cds[0].device_name); 651 if (cd_has_sets()) 652 return SET_OK; 653 } else { 654 for (i = 0; i< num_cds; i++) { 655 cd_menu[i].opt_name = cds[i].menu; 656 cd_menu[i].opt_flags = OPT_EXIT; 657 cd_menu[i].opt_action = set_menu_select; 658 } 659 /* create a menu offering available choices */ 660 menu_cd = new_menu(MSG_Available_cds, 661 cd_menu, num_cds, -1, 4, 0, 0, 662 MC_SCROLL | MC_NOEXITOPT, 663 NULL, NULL, NULL, NULL, NULL); 664 if (menu_cd == -1) 665 return SET_RETRY; 666 msg_display(MSG_ask_cd); 667 process_menu(menu_cd, &selected_cd); 668 free_menu(menu_cd); 669 strcpy(cdrom_dev, cds[selected_cd].device_name); 670 if (cd_has_sets()) 671 return SET_OK; 672 } 673 674 if (num_cds >= 1 && mnt2_mounted) { 675 umount_mnt2(); 676 hit_enter_to_continue(MSG_cd_path_not_found, NULL); 677 } 678 679 /* ask for paths on the CD */ 680 rv = -1; 681 process_menu(MENU_cdromsource, &rv); 682 if (rv == SET_RETRY || rv == SET_ABANDON) 683 return rv; 684 685 if (cd_has_sets()) 686 return SET_OK; 687 688 return SET_RETRY; 689 } 690 691 692 /* 693 * Get from a pathname inside an unmounted local filesystem 694 * (e.g., where sets were preloaded onto a local DOS partition) 695 */ 696 int 697 get_via_localfs(void) 698 { 699 int rv = -1; 700 701 /* Get device, filesystem, and filepath */ 702 process_menu (MENU_localfssource, &rv); 703 if (rv == SET_RETRY) 704 return SET_RETRY; 705 706 /* Mount it */ 707 if (run_program(0, "/sbin/mount -rt %s /dev/%s /mnt2", 708 localfs_fs, localfs_dev)) 709 return SET_RETRY; 710 711 mnt2_mounted = 1; 712 713 snprintf(ext_dir_bin, sizeof ext_dir_bin, "%s/%s/%s", 714 "/mnt2", localfs_dir, set_dir_bin); 715 snprintf(ext_dir_src, sizeof ext_dir_src, "%s/%s/%s", 716 "/mnt2", localfs_dir, set_dir_src); 717 718 return SET_OK; 719 } 720 721 /* 722 * Get from an already-mounted pathname. 723 */ 724 725 int 726 get_via_localdir(void) 727 { 728 int rv = -1; 729 730 /* Get filepath */ 731 process_menu(MENU_localdirsource, &rv); 732 if (rv == SET_RETRY) 733 return SET_RETRY; 734 735 /* 736 * We have to have an absolute path ('cos pax runs in a 737 * different directory), make it so. 738 */ 739 snprintf(ext_dir_bin, sizeof ext_dir_bin, "/%s/%s", localfs_dir, set_dir_bin); 740 snprintf(ext_dir_src, sizeof ext_dir_src, "/%s/%s", localfs_dir, set_dir_src); 741 742 return SET_OK; 743 } 744 745 746 /* 747 * Support for custom distribution fetches / unpacks. 748 */ 749 750 unsigned int 751 set_X11_selected(void) 752 { 753 int i; 754 755 for (i = SET_X11_FIRST; ++i < SET_X11_LAST;) 756 if (set_status[i] & SET_SELECTED) 757 return 1; 758 return 0; 759 } 760 761 unsigned int 762 get_kernel_set(void) 763 { 764 int i; 765 766 for (i = SET_KERNEL_FIRST; ++i < SET_KERNEL_LAST;) 767 if (set_status[i] & SET_SELECTED) 768 return i; 769 return SET_NONE; 770 } 771 772 void 773 set_kernel_set(unsigned int kernel_set) 774 { 775 int i; 776 777 /* only one kernel set is allowed */ 778 for (i = SET_KERNEL_FIRST; ++i < SET_KERNEL_LAST;) 779 set_status[i] &= ~SET_SELECTED; 780 set_status[kernel_set] |= SET_SELECTED; 781 } 782 783 void 784 set_noextract_set(unsigned int set) 785 { 786 787 set_status[set] |= SET_NO_EXTRACT; 788 } 789 790 static int 791 set_toggle(menudesc *menu, void *arg) 792 { 793 distinfo **distp = arg; 794 int set = distp[menu->cursel]->set; 795 796 if (set > SET_KERNEL_FIRST && set < SET_KERNEL_LAST && 797 !(set_status[set] & SET_SELECTED)) 798 set_kernel_set(set); 799 else 800 set_status[set] ^= SET_SELECTED; 801 return 0; 802 } 803 804 static int 805 set_all_none(menudesc *menu, void *arg, int set, int clr) 806 { 807 distinfo **distp = arg; 808 distinfo *dist = *distp; 809 int nested; 810 811 for (nested = 0; dist->set != SET_GROUP_END || nested--; dist++) { 812 if (dist->set == SET_GROUP) { 813 nested++; 814 continue; 815 } 816 set_status[dist->set] = (set_status[dist->set] & ~clr) | set; 817 } 818 return 0; 819 } 820 821 static int 822 set_all(menudesc *menu, void *arg) 823 { 824 return set_all_none(menu, arg, SET_SELECTED, 0); 825 } 826 827 static int 828 set_none(menudesc *menu, void *arg) 829 { 830 return set_all_none(menu, arg, 0, SET_SELECTED); 831 } 832 833 static void 834 set_label(menudesc *menu, int opt, void *arg) 835 { 836 distinfo **distp = arg; 837 distinfo *dist = distp[opt]; 838 const char *selected; 839 const char *desc; 840 int nested; 841 842 desc = dist->desc; 843 844 if (dist->set != SET_GROUP) 845 selected = set_status[dist->set] & SET_SELECTED ? msg_yes : msg_no; 846 else { 847 /* sub menu - display None/Some/All */ 848 nested = 0; 849 selected = "unknown"; 850 while ((++dist)->set != SET_GROUP_END || nested--) { 851 if (dist->set == SET_GROUP) { 852 nested++; 853 continue; 854 } 855 if (!(set_status[dist->set] & SET_VALID)) 856 continue; 857 if (set_status[dist->set] & SET_SELECTED) { 858 if (selected == msg_none) { 859 selected = msg_some; 860 break; 861 } 862 selected = msg_all; 863 } else { 864 if (selected == msg_all) { 865 selected = msg_some; 866 break; 867 } 868 selected = msg_none; 869 } 870 } 871 } 872 873 wprintw(menu->mw, "%-40s %s", msg_string(desc), selected); 874 } 875 876 static int set_sublist(menudesc *menu, void *arg); 877 878 static int 879 initialise_set_menu(distinfo *dist, menu_ent *me, distinfo **de, int all_none) 880 { 881 int set; 882 int sets; 883 int nested; 884 885 for (sets = 0; ; dist++) { 886 set = dist->set; 887 if (set == SET_LAST || set == SET_GROUP_END) 888 break; 889 if (!(set_status[set] & SET_VALID)) 890 continue; 891 *de = dist; 892 memset(me, 0, sizeof(*me)); 893 if (set != SET_GROUP) 894 me->opt_action = set_toggle; 895 else { 896 /* Collapse sublist */ 897 nested = 0; 898 while ((++dist)->set != SET_GROUP_END || nested--) { 899 if (dist->set == SET_GROUP) 900 nested++; 901 } 902 me->opt_action = set_sublist; 903 } 904 sets++; 905 de++; 906 me++; 907 } 908 909 if (all_none) { 910 me->opt_name = MSG_select_all; 911 me->opt_action = set_all; 912 me++; 913 me->opt_name = MSG_select_none; 914 me->opt_action = set_none; 915 sets += 2; 916 } 917 918 return sets; 919 } 920 921 static int 922 set_sublist(menudesc *menu, void *arg) 923 { 924 distinfo *de[SET_LAST]; 925 menu_ent me[SET_LAST]; 926 distinfo **dist = arg; 927 int menu_no; 928 int sets; 929 930 memset(me, 0, sizeof(me)); 931 sets = initialise_set_menu(dist[menu->cursel] + 1, me, de, 1); 932 933 menu_no = new_menu(NULL, me, sets, 20, 10, 0, select_menu_width, 934 MC_SUBMENU | MC_SCROLL | MC_DFLTEXIT, 935 NULL, set_label, NULL, NULL, 936 MSG_install_selected_sets); 937 938 process_menu(menu_no, de); 939 free_menu(menu_no); 940 941 return 0; 942 } 943 944 void 945 customise_sets(void) 946 { 947 distinfo *de[SET_LAST]; 948 menu_ent me[SET_LAST]; 949 int sets; 950 int menu_no; 951 952 msg_display(MSG_cur_distsets); 953 msg_table_add(MSG_cur_distsets_header); 954 955 memset(me, 0, sizeof(me)); 956 sets = initialise_set_menu(dist_list, me, de, 0); 957 958 menu_no = new_menu(NULL, me, sets, 0, 5, 0, select_menu_width, 959 MC_SCROLL | MC_NOBOX | MC_DFLTEXIT | MC_NOCLEAR, 960 NULL, set_label, NULL, NULL, 961 MSG_install_selected_sets); 962 963 process_menu(menu_no, de); 964 free_menu(menu_no); 965 } 966 967 /* 968 * Extract_file **REQUIRES** an absolute path in ext_dir. Any code 969 * that sets up xfer_dir for use by extract_file needs to put in the 970 * full path name to the directory. 971 */ 972 973 int 974 extract_file(distinfo *dist, int update) 975 { 976 const char *dest_dir = NULL; 977 978 if (update && (dist->set == SET_ETC || dist->set == SET_X11_ETC)) { 979 dest_dir = "/.sysinst"; 980 make_target_dir(dest_dir); 981 } else if (dist->set == SET_PKGSRC) 982 dest_dir = "/usr"; 983 else 984 dest_dir = "/"; 985 986 return extract_file_to(dist, update, dest_dir, NULL, true); 987 } 988 989 int 990 extract_file_to(distinfo *dist, int update, const char *dest_dir, 991 const char *extr_pattern, bool do_stats) 992 { 993 char path[STRSIZE]; 994 char *owd; 995 int rval; 996 997 /* If we might need to tidy up, ensure directory exists */ 998 if (fetch_fn != NULL) 999 make_target_dir(xfer_dir); 1000 1001 (void)snprintf(path, sizeof path, "%s/%s%s", 1002 ext_dir_for_set(dist->name), dist->name, set_postfix(dist->name)); 1003 1004 owd = getcwd(NULL, 0); 1005 1006 /* Do we need to fetch the file now? */ 1007 if (fetch_fn != NULL) { 1008 rval = fetch_fn(dist->name); 1009 if (rval != SET_OK) 1010 return rval; 1011 } 1012 1013 /* check tarfile exists */ 1014 if (!file_exists_p(path)) { 1015 1016 #ifdef SUPPORT_8_3_SOURCE_FILESYSTEM 1017 /* 1018 * Update path to use dist->name truncated to the first eight 1019 * characters and check again 1020 */ 1021 (void)snprintf(path, sizeof path, 1022 "%s/%.8s%.4s", /* 4 as includes '.' */ 1023 ext_dir_for_set(dist->name), dist->name, 1024 set_postfix(dist->name)); 1025 1026 if (!file_exists_p(path)) { 1027 #endif /* SUPPORT_8_3_SOURCE_FILESYSTEM */ 1028 if (do_stats) 1029 tarstats.nnotfound++; 1030 1031 char *err = str_arg_subst(msg_string(MSG_notarfile), 1032 1, &dist->name); 1033 hit_enter_to_continue(err, NULL); 1034 free(err); 1035 free(owd); 1036 return SET_RETRY; 1037 } 1038 #ifdef SUPPORT_8_3_SOURCE_FILESYSTEM 1039 } 1040 #endif /* SUPPORT_8_3_SOURCE_FILESYSTEM */ 1041 1042 if (do_stats) 1043 tarstats.nfound++; 1044 /* cd to the target root. */ 1045 target_chdir_or_die(dest_dir); 1046 1047 /* 1048 * /usr/X11R7/lib/X11/xkb/symbols/pc was a directory in 5.0 1049 * but is a file in 5.1 and beyond, so on upgrades we need to 1050 * delete it before extracting the xbase set. 1051 */ 1052 if (update && dist->set == SET_X11_BASE) 1053 run_program(0, "rm -rf usr/X11R7/lib/X11/xkb/symbols/pc"); 1054 1055 /* now extract set files into "./". */ 1056 if (extr_pattern != NULL) { 1057 rval = run_program(RUN_DISPLAY | RUN_PROGRESS, 1058 "progress -zf %s tar --chroot " 1059 TAR_EXTRACT_FLAGS " - '%s'", 1060 path, extr_pattern); 1061 } else { 1062 rval = run_program(RUN_DISPLAY | RUN_PROGRESS, 1063 "progress -zf %s tar --chroot " 1064 TAR_EXTRACT_FLAGS " -", path); 1065 } 1066 1067 chdir(owd); 1068 free(owd); 1069 1070 /* Check rval for errors and give warning. */ 1071 if (rval != 0) { 1072 if (do_stats) 1073 tarstats.nerror++; 1074 msg_fmt_display(MSG_tarerror, "%s", path); 1075 hit_enter_to_continue(NULL, NULL); 1076 return SET_RETRY; 1077 } 1078 1079 if (fetch_fn != NULL && clean_xfer_dir) { 1080 run_program(0, "rm %s", path); 1081 /* Plausibly we should unlink an empty xfer_dir as well */ 1082 } 1083 1084 set_status[dist->set] |= SET_INSTALLED; 1085 if (do_stats) 1086 tarstats.nsuccess++; 1087 return SET_OK; 1088 } 1089 1090 static void 1091 skip_set(distinfo *dist, int skip_type) 1092 { 1093 int nested; 1094 int set; 1095 1096 nested = 0; 1097 while ((++dist)->set != SET_GROUP_END || nested--) { 1098 set = dist->set; 1099 if (set == SET_GROUP) { 1100 nested++; 1101 continue; 1102 } 1103 if (set == SET_LAST) 1104 break; 1105 if (set_status[set] == (SET_SELECTED | SET_VALID)) 1106 set_status[set] |= SET_SKIPPED; 1107 tarstats.nskipped++; 1108 } 1109 } 1110 1111 distinfo* 1112 get_set_distinfo(int opt) 1113 { 1114 distinfo *dist; 1115 int set; 1116 1117 for (dist = dist_list; (set = dist->set) != SET_LAST; dist++) { 1118 if (set != opt) 1119 continue; 1120 if (dist->name == NULL) 1121 continue; 1122 if ((set_status[set] & (SET_VALID | SET_SELECTED)) 1123 != (SET_VALID | SET_SELECTED)) 1124 continue; 1125 return dist; 1126 } 1127 1128 return NULL; 1129 } 1130 1131 #ifdef CHECK_ENTROPY 1132 1133 char entropy_file[PATH_MAX]; 1134 1135 /* 1136 * Are we short of entropy? 1137 */ 1138 size_t 1139 entropy_needed(void) 1140 { 1141 int needed; 1142 size_t len; 1143 1144 len = sizeof(needed); 1145 if (sysctlbyname("kern.entropy.needed", &needed, &len, NULL, 0)) 1146 return 0; 1147 1148 if (needed < 0) 1149 return 0; 1150 1151 return needed; 1152 } 1153 1154 static void 1155 entropy_write_to_kernel(const uint8_t *data, size_t len) 1156 { 1157 int fd; 1158 1159 fd = open(_PATH_RANDOM, O_RDWR, 0); 1160 if (fd >= 0) { 1161 write(fd, data, len); 1162 close(fd); 1163 } 1164 } 1165 1166 static void 1167 entropy_add_manual(void) 1168 { 1169 SHA256_CTX ctx; 1170 char buf[256]; 1171 uint8_t digest[SHA256_DIGEST_LENGTH]; 1172 static const char prompt[] = "> "; 1173 size_t l; 1174 int txt_y; 1175 1176 msg_display(MSG_entropy_enter_manual1); 1177 msg_printf("\n\n"); 1178 msg_display_add(MSG_entropy_enter_manual2); 1179 msg_printf("\n\n dd if=/dev/random bs=32 count=1 | openssl base64\n\n"); 1180 msg_display_add(MSG_entropy_enter_manual3); 1181 msg_printf("\n\n"); 1182 SHA256_Init(&ctx); 1183 txt_y = getcury(mainwin)+1; 1184 1185 echo(); 1186 wmove(mainwin, txt_y, 0); 1187 msg_fmt_table_add(prompt, prompt); 1188 mvwgetnstr(mainwin, txt_y, 2, buf, sizeof buf); 1189 l = strlen(buf); 1190 if (l > 0) 1191 SHA256_Update(&ctx, (const uint8_t*)buf, l); 1192 noecho(); 1193 SHA256_Final(digest, &ctx); 1194 1195 wmove(mainwin, txt_y-1, 0); 1196 wclrtobot(mainwin); 1197 wrefresh(mainwin); 1198 1199 entropy_write_to_kernel(digest, sizeof digest); 1200 } 1201 1202 /* 1203 * Get a file by some means and return a (potentially only 1204 * temporary valid) path to the local copy. 1205 * If mountpt is nonempty, the caller should unmount that 1206 * directory after processing the file. 1207 * Return success if the file is available, or failure if 1208 * the user cancelled the request or network transfer failed. 1209 */ 1210 static bool 1211 entropy_get_file(bool use_netbsd_seed, char *path) 1212 { 1213 static struct ftpinfo server = { .user = "ftp" }; 1214 char url[STRSIZE], tmpf[PATH_MAX], mountpt[PATH_MAX]; 1215 const char *ftp_opt; 1216 arg_rv arg; 1217 int rv = 0; 1218 const char *file_desc = msg_string(use_netbsd_seed ? 1219 MSG_entropy_seed : MSG_entropy_data); 1220 char *dir; 1221 1222 path[0] = 0; 1223 mountpt[0] = 0; 1224 1225 sprintf(tmpf, "/tmp/entr.%06x", getpid()); 1226 1227 msg_display(use_netbsd_seed ? 1228 MSG_entropy_seed_hdr : MSG_entropy_data_hdr); 1229 msg_printf("\n\n %s\n\n", 1230 use_netbsd_seed ? 1231 "rndctl -S /tmp/entropy-file" : 1232 "dd if=/dev/random bs=32 count=1 of=/tmp/random.tmp"); 1233 strcpy(entropy_file, use_netbsd_seed ? 1234 "entropy-file" : "random.tmp"); 1235 process_menu(MENU_entropy_select_file, &rv); 1236 switch (rv) { 1237 case 1: 1238 case 2: 1239 #ifndef DEBUG 1240 if (!network_up) 1241 config_network(0); 1242 #endif 1243 server.xfer = rv == 1 ? XFER_HTTP : XFER_FTP; 1244 arg.arg = &server; 1245 arg.rv = -1; 1246 msg_display_add_subst(MSG_entropy_via_download, 1, file_desc); 1247 msg_printf("\n\n"); 1248 process_menu(MENU_entropy_ftpsource, &arg); 1249 if (arg.rv == SET_RETRY) 1250 return false; 1251 make_url(url, &server, entropy_file); 1252 if (server.xfer == XFER_FTP && 1253 strcmp("ftp", server.user) == 0 && server.pass[0] == 0) { 1254 /* do anon ftp */ 1255 ftp_opt = "-a "; 1256 } else { 1257 ftp_opt = ""; 1258 } 1259 rv = run_program(RUN_DISPLAY | RUN_PROGRESS, 1260 "/usr/bin/ftp %s -o %s %s", 1261 ftp_opt, tmpf, url); 1262 strcpy(path, tmpf); 1263 return rv == 0; 1264 case 3: 1265 #ifndef DEBUG 1266 if (!network_up) 1267 config_network(0); 1268 #endif 1269 rv = -1; 1270 msg_display_add_subst(MSG_entropy_via_nfs, 1, file_desc); 1271 msg_printf("\n\n"); 1272 process_menu(MENU_entropy_nfssource, &rv); 1273 if (rv == SET_RETRY) 1274 return false; 1275 if (nfs_host[0] != 0 && nfs_dir[0] != 0 && 1276 entropy_file[0] != 0) { 1277 strcpy(mountpt, "/tmp/ent-mnt.XXXXXX"); 1278 dir = mkdtemp(mountpt); 1279 if (dir == NULL) 1280 return false; 1281 sprintf(path, "%s/%s", mountpt, entropy_file); 1282 if (run_program(RUN_SILENT, 1283 "mount -t nfs -r %s:/%s %s", 1284 nfs_host, nfs_dir, mountpt) == 0) { 1285 run_program(RUN_SILENT, 1286 "cp %s %s", path, tmpf); 1287 run_program(RUN_SILENT, 1288 "umount %s", mountpt); 1289 rmdir(mountpt); 1290 strcpy(path, tmpf); 1291 } 1292 } 1293 break; 1294 case 4: 1295 rv = -1; 1296 /* Get device, filesystem, and filepath */ 1297 process_menu (MENU_entropy_localfs, &rv); 1298 if (rv == SET_RETRY) 1299 return false; 1300 if (localfs_dev[0] != 0 && localfs_fs[0] != 0 && 1301 entropy_file[0] != 0) { 1302 strcpy(mountpt, "/tmp/ent-mnt.XXXXXX"); 1303 dir = mkdtemp(mountpt); 1304 if (dir == NULL) 1305 return false; 1306 sprintf(path, "%s/%s", mountpt, entropy_file); 1307 if (run_program(RUN_SILENT, 1308 "mount -t %s -r /dev/%s %s", 1309 localfs_fs, localfs_dev, mountpt) == 0) { 1310 run_program(RUN_SILENT, 1311 "cp %s %s", path, tmpf); 1312 run_program(RUN_SILENT, 1313 "umount %s", mountpt); 1314 rmdir(mountpt); 1315 strcpy(path, tmpf); 1316 } 1317 } 1318 break; 1319 } 1320 return path[0] != 0; 1321 } 1322 1323 static void 1324 entropy_add_bin_file(void) 1325 { 1326 char fname[PATH_MAX]; 1327 1328 if (!entropy_get_file(false, fname)) 1329 return; 1330 if (access(fname, R_OK) == 0) 1331 run_program(RUN_SILENT, "dd if=%s of=" _PATH_RANDOM, 1332 fname); 1333 } 1334 1335 static void 1336 entropy_add_seed(void) 1337 { 1338 char fname[PATH_MAX]; 1339 1340 if (!entropy_get_file(true, fname)) 1341 return; 1342 if (access(fname, R_OK) == 0) 1343 run_program(RUN_SILENT, "rndctl -L %s", fname); 1344 } 1345 1346 /* 1347 * return true if we have enough entropy 1348 */ 1349 bool 1350 do_add_entropy(void) 1351 { 1352 int rv; 1353 1354 if (entropy_needed() == 0) 1355 return true; 1356 1357 for (;;) { 1358 if (entropy_needed() == 0) 1359 break; 1360 1361 msg_clear(); 1362 rv = 0; 1363 process_menu(MENU_not_enough_entropy, &rv); 1364 switch (rv) { 1365 case 0: 1366 return false; 1367 case 1: 1368 entropy_add_manual(); 1369 break; 1370 case 2: 1371 entropy_add_seed(); 1372 break; 1373 case 3: 1374 entropy_add_bin_file(); 1375 break; 1376 default: 1377 /* 1378 * retry after small delay to give a new USB device 1379 * a chance to attach and do deliver some 1380 * entropy 1381 */ 1382 msg_display("."); 1383 for (size_t i = 0; i < 10; i++) { 1384 if (entropy_needed() == 0) 1385 return true; 1386 sleep(1); 1387 msg_display_add("."); 1388 } 1389 } 1390 } 1391 1392 /* 1393 * Save entropy (maybe again) to give the seed file a good 1394 * entropy estimate. 1395 */ 1396 run_program(RUN_SILENT | RUN_CHROOT | RUN_ERROR_OK, 1397 "/etc/rc.d/random_seed stop"); 1398 1399 return true; 1400 } 1401 #endif 1402 1403 1404 1405 /* 1406 * Get and unpack the distribution. 1407 * Show success_msg if installation completes. 1408 * Otherwise show failure_msg and wait for the user to ack it before continuing. 1409 * success_msg and failure_msg must both be 0-adic messages. 1410 */ 1411 int 1412 get_and_unpack_sets(int update, msg setupdone_msg, msg success_msg, msg failure_msg) 1413 { 1414 distinfo *dist; 1415 int status; 1416 int set, olderror, oldfound; 1417 bool entropy_loaded = false; 1418 1419 /* Ensure mountpoint for distribution files exists in current root. */ 1420 (void)mkdir("/mnt2", S_IRWXU| S_IRGRP|S_IXGRP | S_IROTH|S_IXOTH); 1421 if (script) 1422 (void)fprintf(script, "mkdir -m 755 /mnt2\n"); 1423 1424 /* reset failure/success counters */ 1425 memset(&tarstats, 0, sizeof(tarstats)); 1426 1427 /* Find out which files to "get" if we get files. */ 1428 1429 /* Accurately count selected sets */ 1430 for (dist = dist_list; (set = dist->set) != SET_LAST; dist++) { 1431 if (dist->name == NULL) 1432 continue; 1433 if (set_status[set] & SET_NO_EXTRACT) 1434 continue; 1435 if ((set_status[set] & (SET_VALID | SET_SELECTED)) 1436 == (SET_VALID | SET_SELECTED)) 1437 tarstats.nselected++; 1438 } 1439 1440 status = SET_RETRY; 1441 for (dist = dist_list; (set = dist->set) != SET_LAST; dist++) { 1442 if (dist->name == NULL) 1443 continue; 1444 if (set_status[set] != (SET_VALID | SET_SELECTED)) 1445 continue; 1446 1447 /* save stats, in case we will retry */ 1448 oldfound = tarstats.nfound; 1449 olderror = tarstats.nerror; 1450 1451 if (status != SET_OK) { 1452 /* This might force a redraw.... */ 1453 clearok(curscr, 1); 1454 touchwin(stdscr); 1455 wrefresh(stdscr); 1456 /* Sort out the location of the set files */ 1457 do { 1458 umount_mnt2(); 1459 msg_fmt_display(MSG_distmedium, "%d%d%s", 1460 tarstats.nselected, 1461 tarstats.nsuccess + tarstats.nskipped, 1462 dist->name); 1463 fetch_fn = NULL; 1464 process_menu(MENU_distmedium, &status); 1465 } while (status == SET_RETRY); 1466 1467 if (status == SET_SKIP) { 1468 set_status[set] |= SET_SKIPPED; 1469 tarstats.nskipped++; 1470 continue; 1471 } 1472 if (status == SET_SKIP_GROUP) { 1473 skip_set(dist, status); 1474 continue; 1475 } 1476 if (status != SET_OK) { 1477 hit_enter_to_continue(failure_msg, NULL); 1478 return 1; 1479 } 1480 } 1481 1482 if (set_status[set] & SET_NO_EXTRACT) 1483 continue; 1484 1485 /* Try to extract this set */ 1486 status = extract_file(dist, update); 1487 if (status == SET_RETRY) { 1488 /* do this set again */ 1489 dist--; 1490 /* and reset statistics to what we had before this 1491 * set */ 1492 tarstats.nfound = oldfound; 1493 tarstats.nerror = olderror; 1494 } 1495 } 1496 1497 #ifdef MD_SET_EXTRACT_FINALIZE 1498 MD_SET_EXTRACT_FINALIZE(update); 1499 #endif 1500 1501 if (tarstats.nerror == 0 && tarstats.nsuccess == tarstats.nselected) { 1502 msg_display(MSG_endtarok); 1503 /* Give user a chance to see the success message */ 1504 sleep(1); 1505 } else { 1506 /* We encountered errors. Let the user know. */ 1507 msg_fmt_display(MSG_endtar, "%d%d%d%d%d%d", 1508 tarstats.nselected, tarstats.nnotfound, tarstats.nskipped, 1509 tarstats.nfound, tarstats.nsuccess, tarstats.nerror); 1510 hit_enter_to_continue(NULL, NULL); 1511 } 1512 1513 /* 1514 * postinstall needs to be run after extracting all sets, because 1515 * otherwise /var/db/obsolete will only have current information 1516 * from the base, comp, and etc sets. 1517 */ 1518 if (update && (set_status[SET_ETC] & SET_INSTALLED)) { 1519 int oldsendmail; 1520 oldsendmail = run_program(RUN_DISPLAY | RUN_CHROOT | 1521 RUN_ERROR_OK | RUN_PROGRESS, 1522 "/usr/sbin/postinstall -s /.sysinst -d / check mailerconf"); 1523 if (oldsendmail == 1) { 1524 msg_display(MSG_oldsendmail); 1525 if (ask_yesno(NULL)) { 1526 run_program(RUN_DISPLAY | RUN_CHROOT, 1527 "/usr/sbin/postinstall -s /.sysinst -d / fix mailerconf"); 1528 } 1529 } 1530 run_program(RUN_DISPLAY | RUN_CHROOT, 1531 "/usr/sbin/postinstall -s /.sysinst -d / fix"); 1532 1533 /* Don't discard the system's old entropy if any */ 1534 run_program(RUN_CHROOT | RUN_SILENT, 1535 "/etc/rc.d/random_seed start"); 1536 entropy_loaded = true; 1537 } 1538 1539 /* Configure the system */ 1540 if (set_status[SET_BASE] & SET_INSTALLED) { 1541 run_makedev(); 1542 if (!update) { 1543 run_program(RUN_CHROOT|RUN_DISPLAY, 1544 "/usr/sbin/certctl rehash"); 1545 } 1546 } 1547 1548 if (!update) { 1549 struct stat sb1, sb2; 1550 1551 if (stat(target_expand("/"), &sb1) == 0 1552 && stat(target_expand("/var"), &sb2) == 0 1553 && sb1.st_dev != sb2.st_dev) { 1554 add_rc_conf("random_file=/etc/entropy-file\n"); 1555 if (target_file_exists_p("/boot.cfg")) { 1556 run_program(RUN_CHROOT|RUN_FATAL, 1557 "sh -c 'sed -e s./var/db/./etc/. " 1558 "< /boot.cfg " 1559 "> /tmp/boot.cfg.tmp'"); 1560 mv_within_target_or_die("/tmp/boot.cfg.tmp", 1561 "/boot.cfg"); 1562 1563 } 1564 } 1565 1566 #ifdef MD_BOOT_CFG_FINALIZE 1567 if (target_file_exists_p("/boot.cfg")) { 1568 MD_BOOT_CFG_FINALIZE("/boot.cfg"); 1569 } 1570 #endif 1571 1572 /* Save keyboard type */ 1573 save_kb_encoding(); 1574 1575 /* Other configuration. */ 1576 mnt_net_config(); 1577 } 1578 1579 /* Mounted dist dir? */ 1580 umount_mnt2(); 1581 1582 #ifdef CHECK_ENTROPY 1583 entropy_loaded |= entropy_needed() == 0; 1584 #endif 1585 1586 /* Save entropy -- on some systems it's ~all we'll ever get */ 1587 if (!update || entropy_loaded) 1588 run_program(RUN_SILENT | RUN_CHROOT | RUN_ERROR_OK, 1589 "/etc/rc.d/random_seed stop"); 1590 /* Install/Upgrade complete ... reboot or exit to script */ 1591 hit_enter_to_continue(success_msg, NULL); 1592 return 0; 1593 } 1594 1595 void 1596 umount_mnt2(void) 1597 { 1598 if (!mnt2_mounted) 1599 return; 1600 run_program(RUN_SILENT, "/sbin/umount /mnt2"); 1601 mnt2_mounted = 0; 1602 } 1603 1604 1605 /* 1606 * Do a quick sanity check that the target can reboot. 1607 * return 1 if everything OK, 0 if there is a problem. 1608 * Uses a table of files we expect to find after a base install/upgrade. 1609 */ 1610 1611 /* test flag and pathname to check for after unpacking. */ 1612 struct check_table { unsigned int mode; const char *path;} checks[] = { 1613 { S_IFREG, "/netbsd" }, 1614 { S_IFDIR, "/etc" }, 1615 { S_IFREG, "/etc/fstab" }, 1616 { S_IFREG, "/sbin/init" }, 1617 { S_IFREG, "/bin/sh" }, 1618 { S_IFREG, "/etc/rc" }, 1619 { S_IFREG, "/etc/rc.subr" }, 1620 { S_IFREG, "/etc/rc.conf" }, 1621 { S_IFDIR, "/dev" }, 1622 { S_IFCHR, "/dev/console" }, 1623 /* XXX check for rootdev in target /dev? */ 1624 { S_IFREG, "/sbin/fsck" }, 1625 { S_IFREG, "/sbin/fsck_ffs" }, 1626 { S_IFREG, "/sbin/mount" }, 1627 { S_IFREG, "/sbin/mount_ffs" }, 1628 { S_IFREG, "/sbin/mount_nfs" }, 1629 #if defined(DEBUG) || defined(DEBUG_CHECK) 1630 { S_IFREG, "/foo/bar" }, /* bad entry to exercise warning */ 1631 #endif 1632 { 0, 0 } 1633 1634 }; 1635 1636 /* 1637 * Check target for a single file. 1638 */ 1639 static int 1640 check_for(unsigned int mode, const char *pathname) 1641 { 1642 int found; 1643 1644 found = (target_test(mode, pathname) == 0); 1645 if (found == 0) 1646 msg_fmt_display(MSG_rootmissing, "%s", pathname); 1647 return found; 1648 } 1649 1650 /* 1651 * Check that all the files in check_table are present in the 1652 * target root. Warn if not found. 1653 */ 1654 int 1655 sanity_check(void) 1656 { 1657 int target_ok = 1; 1658 struct check_table *p; 1659 1660 for (p = checks; p->path; p++) { 1661 target_ok = target_ok && check_for(p->mode, p->path); 1662 } 1663 if (target_ok) 1664 return 0; 1665 1666 /* Uh, oh. Something's missing. */ 1667 hit_enter_to_continue(MSG_badroot, NULL); 1668 return 1; 1669 } 1670 1671 /* 1672 * Some globals to pass things back from callbacks 1673 */ 1674 static char zoneinfo_dir[STRSIZE]; 1675 static int zonerootlen; 1676 static char *tz_selected; /* timezonename (relative to share/zoneinfo */ 1677 const char *tz_default; /* UTC, or whatever /etc/localtime points to */ 1678 static char tz_env[STRSIZE]; 1679 static int save_cursel, save_topline; 1680 static int time_menu = -1; 1681 1682 static void 1683 update_time_display(void) 1684 { 1685 time_t t; 1686 struct tm *tm; 1687 char cur_time[STRSIZE], *p; 1688 1689 t = time(NULL); 1690 tm = localtime(&t); 1691 strlcpy(cur_time, safectime(&t), sizeof cur_time); 1692 p = strchr(cur_time, '\n'); 1693 if (p != NULL) 1694 *p = 0; 1695 1696 msg_clear(); 1697 msg_fmt_table_add(MSG_choose_timezone, "%s%s%s%s", 1698 tz_default, tz_selected, cur_time, tm ? tm->tm_zone : "?"); 1699 } 1700 1701 /* 1702 * Callback from timezone menu 1703 */ 1704 static int 1705 set_tz_select(menudesc *m, void *arg) 1706 { 1707 char *new; 1708 1709 if (m && strcmp(tz_selected, m->opts[m->cursel].opt_name) != 0) { 1710 /* Change the displayed timezone */ 1711 new = strdup(m->opts[m->cursel].opt_name); 1712 if (new == NULL) 1713 return 0; 1714 free(tz_selected); 1715 tz_selected = new; 1716 snprintf(tz_env, sizeof tz_env, "%.*s%s", 1717 zonerootlen, zoneinfo_dir, tz_selected); 1718 setenv("TZ", tz_env, 1); 1719 } 1720 if (m) 1721 /* Warp curser to 'Exit' line on menu */ 1722 m->cursel = -1; 1723 1724 update_time_display(); 1725 if (time_menu >= 1) { 1726 WINDOW *w = get_menudesc(time_menu)->mw; 1727 if (w != NULL) { 1728 touchwin(w); 1729 wrefresh(w); 1730 } 1731 } 1732 return 0; 1733 } 1734 1735 static int 1736 set_tz_back(menudesc *m, void *arg) 1737 { 1738 1739 zoneinfo_dir[zonerootlen] = 0; 1740 m->cursel = save_cursel; 1741 m->topline = save_topline; 1742 return 0; 1743 } 1744 1745 static int 1746 set_tz_dir(menudesc *m, void *arg) 1747 { 1748 1749 strlcpy(zoneinfo_dir + zonerootlen, m->opts[m->cursel].opt_name, 1750 sizeof zoneinfo_dir - zonerootlen); 1751 save_cursel = m->cursel; 1752 save_topline = m->topline; 1753 m->cursel = 0; 1754 m->topline = 0; 1755 return 0; 1756 } 1757 1758 /* 1759 * Alarm-handler to update example-display 1760 */ 1761 static void 1762 /*ARGSUSED*/ 1763 timezone_sig(int sig) 1764 { 1765 1766 set_tz_select(NULL, NULL); 1767 alarm(60); 1768 } 1769 1770 static int 1771 tz_sort(const void *a, const void *b) 1772 { 1773 return strcmp(((const menu_ent *)a)->opt_name, ((const menu_ent *)b)->opt_name); 1774 } 1775 1776 static void 1777 tzm_set_names(menudesc *m, void *arg) 1778 { 1779 DIR *dir; 1780 struct dirent *dp; 1781 static int nfiles; 1782 static int maxfiles = 32; 1783 static menu_ent *tz_menu; 1784 static char **tz_names; 1785 void *p; 1786 int maxfname; 1787 char *fp; 1788 struct stat sb; 1789 1790 if (tz_menu == NULL) 1791 tz_menu = calloc(maxfiles, sizeof *tz_menu); 1792 if (tz_names == NULL) 1793 tz_names = malloc(maxfiles * sizeof *tz_names); 1794 if (tz_menu == NULL || tz_names == NULL) 1795 return; /* error - skip timezone setting */ 1796 while (nfiles > 0) 1797 free(tz_names[--nfiles]); 1798 1799 dir = opendir(zoneinfo_dir); 1800 fp = strchr(zoneinfo_dir, 0); 1801 if (fp != zoneinfo_dir + zonerootlen) { 1802 tz_names[0] = 0; 1803 tz_menu[0].opt_name = msg_string(MSG_tz_back); 1804 tz_menu[0].opt_action = set_tz_back; 1805 nfiles = 1; 1806 } 1807 maxfname = zoneinfo_dir + sizeof zoneinfo_dir - fp - 1; 1808 if (dir != NULL) { 1809 while ((dp = readdir(dir)) != NULL) { 1810 if (dp->d_namlen > maxfname || dp->d_name[0] == '.') 1811 continue; 1812 strlcpy(fp, dp->d_name, maxfname); 1813 if (stat(zoneinfo_dir, &sb) == -1) 1814 continue; 1815 if (nfiles >= maxfiles) { 1816 p = realloc(tz_menu, 1817 2 * maxfiles * sizeof *tz_menu); 1818 if (p == NULL) 1819 break; 1820 tz_menu = p; 1821 memset(tz_menu + maxfiles, 0, 1822 maxfiles * sizeof *tz_menu); 1823 p = realloc(tz_names, 1824 2 * maxfiles * sizeof *tz_names); 1825 if (p == NULL) 1826 break; 1827 tz_names = p; 1828 memset(tz_names + maxfiles, 0, 1829 maxfiles * sizeof *tz_names); 1830 maxfiles *= 2; 1831 } 1832 if (S_ISREG(sb.st_mode)) 1833 tz_menu[nfiles].opt_action = set_tz_select; 1834 else if (S_ISDIR(sb.st_mode)) { 1835 tz_menu[nfiles].opt_action = set_tz_dir; 1836 strlcat(fp, "/", 1837 sizeof(zoneinfo_dir) - (fp - zoneinfo_dir)); 1838 } else 1839 continue; 1840 tz_names[nfiles] = strdup(zoneinfo_dir + zonerootlen); 1841 tz_menu[nfiles].opt_name = tz_names[nfiles]; 1842 nfiles++; 1843 } 1844 closedir(dir); 1845 } 1846 *fp = 0; 1847 1848 m->opts = tz_menu; 1849 m->numopts = nfiles; 1850 qsort(tz_menu, nfiles, sizeof *tz_menu, tz_sort); 1851 } 1852 1853 void 1854 get_tz_default(void) 1855 { 1856 char localtime_link[STRSIZE]; 1857 static char localtime_target[STRSIZE]; 1858 int rc; 1859 1860 strlcpy(localtime_link, target_expand("/etc/localtime"), 1861 sizeof localtime_link); 1862 1863 /* Add sanity check that /mnt/usr/share/zoneinfo contains 1864 * something useful 1865 */ 1866 1867 rc = readlink(localtime_link, localtime_target, 1868 sizeof(localtime_target) - 1); 1869 if (rc < 0) { 1870 /* error, default to UTC */ 1871 tz_default = "UTC"; 1872 } else { 1873 localtime_target[rc] = '\0'; 1874 tz_default = strchr(strstr(localtime_target, "zoneinfo"), '/') + 1; 1875 } 1876 } 1877 1878 /* 1879 * Choose from the files in usr/share/zoneinfo and set etc/localtime 1880 */ 1881 int 1882 set_timezone(void) 1883 { 1884 char localtime_link[STRSIZE]; 1885 char localtime_target[STRSIZE]; 1886 int menu_no; 1887 1888 strlcpy(zoneinfo_dir, target_expand("/usr/share/zoneinfo/"), 1889 sizeof zoneinfo_dir - 1); 1890 zonerootlen = strlen(zoneinfo_dir); 1891 1892 get_tz_default(); 1893 1894 tz_selected = strdup(tz_default); 1895 snprintf(tz_env, sizeof(tz_env), "%s%s", zoneinfo_dir, tz_selected); 1896 setenv("TZ", tz_env, 1); 1897 update_time_display(); 1898 1899 signal(SIGALRM, timezone_sig); 1900 alarm(60); 1901 1902 menu_no = new_menu(NULL, NULL, 14, 23, 9, 1903 12, 32, MC_ALWAYS_SCROLL | MC_NOSHORTCUT, 1904 tzm_set_names, NULL, NULL, 1905 "\nPlease consult the install documents.", 1906 MSG_exit_menu_generic); 1907 if (menu_no >= 0) { 1908 time_menu = menu_no; 1909 process_menu(menu_no, NULL); 1910 time_menu = -1; 1911 1912 free_menu(menu_no); 1913 } 1914 1915 alarm(0); 1916 signal(SIGALRM, SIG_IGN); 1917 1918 if (menu_no >= 0) { 1919 snprintf(localtime_target, sizeof(localtime_target), 1920 "/usr/share/zoneinfo/%s", tz_selected); 1921 strlcpy(localtime_link, target_expand("/etc/localtime"), 1922 sizeof localtime_link); 1923 unlink(localtime_link); 1924 symlink(localtime_target, localtime_link); 1925 } 1926 1927 return 1; 1928 } 1929 1930 void 1931 scripting_vfprintf(FILE *f, const char *fmt, va_list ap) 1932 { 1933 va_list ap2; 1934 1935 va_copy(ap2, ap); 1936 if (f) 1937 (void)vfprintf(f, fmt, ap); 1938 if (script) 1939 (void)vfprintf(script, fmt, ap2); 1940 } 1941 1942 void 1943 scripting_fprintf(FILE *f, const char *fmt, ...) 1944 { 1945 va_list ap; 1946 1947 va_start(ap, fmt); 1948 scripting_vfprintf(f, fmt, ap); 1949 va_end(ap); 1950 } 1951 1952 void 1953 add_rc_conf(const char *fmt, ...) 1954 { 1955 FILE *f; 1956 va_list ap; 1957 1958 va_start(ap, fmt); 1959 f = target_fopen("/etc/rc.conf", "a"); 1960 if (f != 0) { 1961 scripting_fprintf(NULL, "cat <<EOF >>%s/etc/rc.conf\n", 1962 target_prefix()); 1963 scripting_vfprintf(f, fmt, ap); 1964 fclose(f); 1965 scripting_fprintf(NULL, "EOF\n"); 1966 } 1967 va_end(ap); 1968 } 1969 1970 int 1971 del_rc_conf(const char *value) 1972 { 1973 FILE *fp, *nfp; 1974 char buf[4096]; /* Ridiculously high, but should be enough in any way */ 1975 char *rcconf, *tempname = NULL, *bakname = NULL; 1976 char *cp; 1977 int done = 0; 1978 int fd; 1979 int retval = 0; 1980 1981 /* The paths might seem strange, but using /tmp would require copy instead 1982 * of rename operations. */ 1983 if (asprintf(&rcconf, "%s", target_expand("/etc/rc.conf")) < 0 1984 || asprintf(&tempname, "%s", target_expand("/etc/rc.conf.tmp.XXXXXX")) < 0 1985 || asprintf(&bakname, "%s", target_expand("/etc/rc.conf.bak.XXXXXX")) < 0) { 1986 if (rcconf) 1987 free(rcconf); 1988 if (tempname) 1989 free(tempname); 1990 msg_fmt_display(MSG_rcconf_delete_failed, "%s", value); 1991 hit_enter_to_continue(NULL, NULL); 1992 return -1; 1993 } 1994 1995 if ((fd = mkstemp(bakname)) < 0) { 1996 msg_fmt_display(MSG_rcconf_delete_failed, "%s", value); 1997 hit_enter_to_continue(NULL, NULL); 1998 return -1; 1999 } 2000 close(fd); 2001 2002 if (!(fp = fopen(rcconf, "r+")) || (fd = mkstemp(tempname)) < 0) { 2003 if (fp) 2004 fclose(fp); 2005 msg_fmt_display(MSG_rcconf_delete_failed, "%s", value); 2006 hit_enter_to_continue(NULL, NULL); 2007 return -1; 2008 } 2009 2010 nfp = fdopen(fd, "w"); 2011 if (!nfp) { 2012 fclose(fp); 2013 close(fd); 2014 msg_fmt_display(MSG_rcconf_delete_failed, "%s", value); 2015 hit_enter_to_continue(NULL, NULL); 2016 return -1; 2017 } 2018 2019 while (fgets(buf, sizeof buf, fp) != NULL) { 2020 2021 cp = buf + strspn(buf, " \t"); /* Skip initial spaces */ 2022 if (strncmp(cp, value, strlen(value)) == 0) { 2023 cp += strlen(value); 2024 if (*cp != '=') 2025 scripting_fprintf(nfp, "%s", buf); 2026 else 2027 done = 1; 2028 } else { 2029 scripting_fprintf(nfp, "%s", buf); 2030 } 2031 } 2032 fclose(fp); 2033 fclose(nfp); 2034 2035 if (done) { 2036 if (rename(rcconf, bakname)) { 2037 msg_display(MSG_rcconf_backup_failed); 2038 if (!ask_noyes(NULL)) { 2039 retval = -1; 2040 goto done; 2041 } 2042 } 2043 2044 if (rename(tempname, rcconf)) { 2045 if (rename(bakname, rcconf)) { 2046 hit_enter_to_continue(MSG_rcconf_restore_failed, 2047 NULL); 2048 } else { 2049 hit_enter_to_continue(MSG_rcconf_delete_failed, 2050 NULL); 2051 } 2052 } 2053 } 2054 2055 done: 2056 (void)unlink(bakname); 2057 (void)unlink(tempname); 2058 free(rcconf); 2059 free(tempname); 2060 free(bakname); 2061 return retval; 2062 } 2063 2064 void 2065 add_sysctl_conf(const char *fmt, ...) 2066 { 2067 FILE *f; 2068 va_list ap; 2069 2070 va_start(ap, fmt); 2071 f = target_fopen("/etc/sysctl.conf", "a"); 2072 if (f != 0) { 2073 scripting_fprintf(NULL, "cat <<EOF >>%s/etc/sysctl.conf\n", 2074 target_prefix()); 2075 scripting_vfprintf(f, fmt, ap); 2076 fclose(f); 2077 scripting_fprintf(NULL, "EOF\n"); 2078 } 2079 va_end(ap); 2080 } 2081 2082 void 2083 enable_rc_conf(void) 2084 { 2085 2086 replace("/etc/rc.conf", "s/^rc_configured=NO/rc_configured=YES/"); 2087 } 2088 2089 int 2090 check_lfs_progs(void) 2091 { 2092 2093 #ifndef NO_LFS 2094 return binary_available("fsck_lfs") && binary_available("mount_lfs") 2095 && binary_available("newfs_lfs"); 2096 #else 2097 return 0; 2098 #endif 2099 } 2100 2101 int 2102 set_is_source(const char *set_name) { 2103 int len = strlen(set_name); 2104 return len >= 3 && memcmp(set_name + len - 3, "src", 3) == 0; 2105 } 2106 2107 const char * 2108 set_dir_for_set(const char *set_name) { 2109 if (strcmp(set_name, "pkgsrc") == 0) 2110 return pkgsrc_dir; 2111 return set_is_source(set_name) ? set_dir_src : set_dir_bin; 2112 } 2113 2114 const char * 2115 ext_dir_for_set(const char *set_name) { 2116 if (strcmp(set_name, "pkgsrc") == 0) 2117 return ext_dir_pkgsrc; 2118 return set_is_source(set_name) ? ext_dir_src : ext_dir_bin; 2119 } 2120 2121 void 2122 do_coloring(unsigned int fg, unsigned int bg) { 2123 if (bg > COLOR_WHITE) 2124 bg = COLOR_BLUE; 2125 if (fg > COLOR_WHITE) 2126 fg = COLOR_WHITE; 2127 if (fg != bg && has_colors()) { 2128 init_pair(1, fg, bg); 2129 wbkgd(stdscr, COLOR_PAIR(1)); 2130 wbkgd(mainwin, COLOR_PAIR(1)); 2131 wattrset(stdscr, COLOR_PAIR(1)); 2132 wattrset(mainwin, COLOR_PAIR(1)); 2133 } 2134 /* redraw screen */ 2135 touchwin(stdscr); 2136 touchwin(mainwin); 2137 wrefresh(stdscr); 2138 wrefresh(mainwin); 2139 return; 2140 } 2141 2142 int 2143 set_menu_select(menudesc *m, void *arg) 2144 { 2145 *(int *)arg = m->cursel; 2146 return 1; 2147 } 2148 2149 /* 2150 * check whether a binary is available somewhere in PATH, 2151 * return 1 if found, 0 if not. 2152 */ 2153 static int 2154 binary_available(const char *prog) 2155 { 2156 char *p, tmp[MAXPATHLEN], *path = getenv("PATH"), *opath; 2157 2158 if (path == NULL) 2159 return access(prog, X_OK) == 0; 2160 path = strdup(path); 2161 if (path == NULL) 2162 return 0; 2163 2164 opath = path; 2165 2166 while ((p = strsep(&path, ":")) != NULL) { 2167 if (strlcpy(tmp, p, MAXPATHLEN) >= MAXPATHLEN) 2168 continue; 2169 if (strlcat(tmp, "/", MAXPATHLEN) >= MAXPATHLEN) 2170 continue; 2171 if (strlcat(tmp, prog, MAXPATHLEN) >= MAXPATHLEN) 2172 continue; 2173 if (access(tmp, X_OK) == 0) { 2174 free(opath); 2175 return 1; 2176 } 2177 } 2178 free(opath); 2179 return 0; 2180 } 2181 2182 const char * 2183 safectime(time_t *t) 2184 { 2185 const char *s = ctime(t); 2186 if (s != NULL) 2187 return s; 2188 2189 // Debugging. 2190 fprintf(stderr, "Can't convert to localtime 0x%jx (%s)\n", 2191 (intmax_t)*t, strerror(errno)); 2192 /*123456789012345678901234*/ 2193 return "preposterous clock time\n"; 2194 } 2195 2196 int 2197 ask_yesno(const char* msgtxt) 2198 { 2199 arg_rv p; 2200 2201 p.arg = __UNCONST(msgtxt); 2202 p.rv = -1; 2203 2204 process_menu(MENU_yesno, &p); 2205 return p.rv; 2206 } 2207 2208 int 2209 ask_noyes(const char *msgtxt) 2210 { 2211 arg_rv p; 2212 2213 p.arg = __UNCONST(msgtxt); 2214 p.rv = -1; 2215 2216 process_menu(MENU_noyes, &p); 2217 return p.rv; 2218 } 2219 2220 int 2221 ask_reedit(const struct disk_partitions *parts) 2222 { 2223 const char *args[2]; 2224 arg_rep_int arg; 2225 2226 args[0] = msg_string(parts->pscheme->name); 2227 args[1] = msg_string(parts->pscheme->short_name); 2228 arg.args.argv = args; 2229 arg.args.argc = 2; 2230 arg.rv = 0; 2231 process_menu(MENU_reedit, &arg); 2232 2233 return arg.rv; 2234 } 2235 2236 bool 2237 use_tgz_for_set(const char *set_name) 2238 { 2239 const struct distinfo *dist; 2240 2241 for (dist = dist_list; dist->set != SET_LAST; dist++) { 2242 if (dist->name == NULL) 2243 continue; 2244 if (strcmp(set_name, dist->name) == 0) 2245 return dist->force_tgz; 2246 } 2247 2248 return true; 2249 } 2250 2251 /* Return the postfix used for a given set */ 2252 const char * 2253 set_postfix(const char *set_name) 2254 { 2255 return use_tgz_for_set(set_name) ? dist_tgz_postfix : dist_postfix; 2256 } 2257 2258 /* 2259 * Replace positional arguments (encoded as $0 .. $N) in the string 2260 * passed by the contents of the passed argument array. 2261 * Caller must free() the result string. 2262 */ 2263 char* 2264 str_arg_subst(const char *src, size_t argc, const char **argv) 2265 { 2266 const char *p, *last; 2267 char *out, *t; 2268 size_t len; 2269 2270 len = strlen(src); 2271 for (p = strchr(src, '$'); p; p = strchr(p+1, '$')) { 2272 char *endp = NULL; 2273 size_t n; 2274 int e; 2275 2276 /* $ followed by a correct numeric position? */ 2277 n = strtou(p+1, &endp, 10, 0, INT_MAX, &e); 2278 if ((e == 0 || e == ENOTSUP) && n < argc) { 2279 len += strlen(argv[n]); 2280 len -= endp-p; 2281 p = endp-1; 2282 } 2283 } 2284 2285 out = malloc(len+1); 2286 if (out == NULL) 2287 return NULL; 2288 2289 t = out; 2290 for (last = src, p = strchr(src, '$'); p; p = strchr(p+1, '$')) { 2291 char *endp = NULL; 2292 size_t n; 2293 int e; 2294 2295 /* $ followed by a correct numeric position? */ 2296 n = strtou(p+1, &endp, 10, 0, INT_MAX, &e); 2297 if ((e == 0 || e == ENOTSUP) && n < argc) { 2298 size_t l = p-last; 2299 memcpy(t, last, l); 2300 t += l; 2301 strcpy(t, argv[n]); 2302 t += strlen(argv[n]); 2303 last = endp; 2304 } 2305 } 2306 if (*last) { 2307 strcpy(t, last); 2308 t += strlen(last); 2309 } else { 2310 *t = 0; 2311 } 2312 assert((size_t)(t-out) == len); 2313 2314 return out; 2315 } 2316 2317 /* 2318 * Does this string have any positional args that need expanding? 2319 */ 2320 bool 2321 needs_expanding(const char *src, size_t argc) 2322 { 2323 const char *p; 2324 2325 for (p = strchr(src, '$'); p; p = strchr(p+1, '$')) { 2326 char *endp = NULL; 2327 size_t n; 2328 int e; 2329 2330 /* $ followed by a correct numeric position? */ 2331 n = strtou(p+1, &endp, 10, 0, INT_MAX, &e); 2332 if ((e == 0 || e == ENOTSUP) && n < argc) 2333 return true; 2334 } 2335 return false; 2336 } 2337 2338 /* 2339 * Replace positional arguments (encoded as $0 .. $N) in the 2340 * message by the strings passed as ... and call outfunc 2341 * with the result. 2342 */ 2343 static void 2344 msg_display_subst_internal(void (*outfunc)(msg), 2345 const char *master, size_t argc, va_list ap) 2346 { 2347 const char **args, **arg; 2348 char *out; 2349 2350 args = calloc(argc, sizeof(*args)); 2351 if (args == NULL) 2352 return; 2353 2354 arg = args; 2355 for (size_t i = 0; i < argc; i++) 2356 *arg++ = va_arg(ap, const char*); 2357 2358 out = str_arg_subst(msg_string(master), argc, args); 2359 if (out != NULL) { 2360 outfunc(out); 2361 free(out); 2362 } 2363 free(args); 2364 } 2365 2366 /* 2367 * Replace positional arguments (encoded as $0 .. $N) in the 2368 * message by the strings passed as ... 2369 */ 2370 void 2371 msg_display_subst(const char *master, size_t argc, ...) 2372 { 2373 va_list ap; 2374 2375 va_start(ap, argc); 2376 msg_display_subst_internal(msg_display, master, argc, ap); 2377 va_end(ap); 2378 } 2379 2380 /* 2381 * Same as above, but add to message instead of starting a new one 2382 */ 2383 void 2384 msg_display_add_subst(const char *master, size_t argc, ...) 2385 { 2386 va_list ap; 2387 2388 va_start(ap, argc); 2389 msg_display_subst_internal(msg_display_add, master, argc, ap); 2390 va_end(ap); 2391 } 2392 2393 /* initialize have_* variables */ 2394 void 2395 check_available_binaries(void) 2396 { 2397 static int did_test = false; 2398 2399 if (did_test) return; 2400 did_test = 1; 2401 2402 have_raid = binary_available("raidctl"); 2403 have_vnd = binary_available("vndconfig"); 2404 have_cgd = binary_available("cgdconfig"); 2405 have_lvm = binary_available("lvm"); 2406 have_gpt = binary_available("gpt"); 2407 have_dk = binary_available("dkctl"); 2408 } 2409 2410 /* 2411 * Wait for enter and immediately clear the screen after user response 2412 * (in case some longer action follows, so the user has instant feedback) 2413 */ 2414 void 2415 hit_enter_to_continue(const char *prompt, const char *title) 2416 { 2417 if (prompt != NULL) 2418 msg_display(prompt); 2419 process_menu(MENU_ok, __UNCONST(title)); 2420 msg_clear(); 2421 wrefresh(mainwin); 2422 } 2423 2424 /* 2425 * On auto pilot: 2426 * convert an existing set of partitions ot a list of part_usage_info 2427 * so that we "want" exactly what is there already. 2428 */ 2429 static bool 2430 usage_info_list_from_parts(struct part_usage_info **list, size_t *count, 2431 struct disk_partitions *parts) 2432 { 2433 struct disk_part_info info; 2434 part_id pno; 2435 size_t no, num; 2436 2437 num = 0; 2438 for (pno = 0; pno < parts->num_part; pno++) { 2439 if (!parts->pscheme->get_part_info(parts, pno, &info)) 2440 continue; 2441 num++; 2442 } 2443 2444 *list = calloc(num, sizeof(**list)); 2445 if (*list == NULL) 2446 return false; 2447 2448 *count = num; 2449 for (no = pno = 0; pno < parts->num_part && no < num; pno++) { 2450 if (!parts->pscheme->get_part_info(parts, pno, &info)) 2451 continue; 2452 (*list)[no].size = info.size; 2453 if (info.last_mounted != NULL && *info.last_mounted != 0) { 2454 strlcpy((*list)[no].mount, info.last_mounted, 2455 sizeof((*list)[no].mount)); 2456 (*list)[no].instflags |= PUIINST_MOUNT; 2457 } 2458 (*list)[no].parts = parts; 2459 (*list)[no].cur_part_id = pno; 2460 (*list)[no].cur_start = info.start; 2461 (*list)[no].cur_flags = info.flags; 2462 (*list)[no].type = info.nat_type->generic_ptype; 2463 if ((*list)[no].type == PT_swap) { 2464 (*list)[no].fs_type = FS_SWAP; 2465 (*list)[no].fs_version = 0; 2466 } else { 2467 (*list)[no].fs_type = info.fs_type; 2468 (*list)[no].fs_version = info.fs_sub_type; 2469 } 2470 (*list)[no].fs_opt1 = info.fs_opt1; 2471 (*list)[no].fs_opt2 = info.fs_opt2; 2472 (*list)[no].fs_opt3 = info.fs_opt3; 2473 no++; 2474 } 2475 return true; 2476 } 2477 2478 bool 2479 empty_usage_set_from_parts(struct partition_usage_set *wanted, 2480 struct disk_partitions *parts) 2481 { 2482 usage_set_from_parts(wanted, parts); 2483 return true; 2484 } 2485 2486 bool 2487 usage_set_from_parts(struct partition_usage_set *wanted, 2488 struct disk_partitions *parts) 2489 { 2490 memset(wanted, 0, sizeof(*wanted)); 2491 wanted->parts = parts; 2492 2493 return usage_info_list_from_parts(&wanted->infos, &wanted->num, parts); 2494 } 2495 2496 bool 2497 usage_set_from_install_desc(struct partition_usage_set *pset, 2498 const struct install_partition_desc *install, 2499 struct disk_partitions *parts) 2500 { 2501 size_t cnt, i; 2502 2503 memset(pset, 0, sizeof(*pset)); 2504 pset->parts = parts; 2505 2506 if (!install->infos || !install->num) 2507 return false; 2508 2509 for (cnt = 0, i = 0; i < install->num; i++) { 2510 if (install->infos[i].parts != parts) 2511 continue; 2512 cnt++; 2513 } 2514 if (!cnt) 2515 return false; 2516 pset->num = cnt; 2517 pset->infos = calloc(cnt, sizeof(*pset->infos)); 2518 if (!pset->infos) 2519 return false; 2520 for (cnt = 0, i = 0; i < install->num; i++) { 2521 if (install->infos[i].parts != parts) 2522 continue; 2523 pset->infos[cnt] = install->infos[i]; 2524 cnt++; 2525 } 2526 return true; 2527 } 2528 2529 bool 2530 merge_usage_set_into_install_desc(struct install_partition_desc *install, 2531 const struct partition_usage_set *pset) 2532 { 2533 // XXX 2534 return false; 2535 } 2536 2537 struct disk_partitions * 2538 get_inner_parts(struct disk_partitions *parts) 2539 { 2540 daddr_t start, size; 2541 part_id pno; 2542 struct disk_part_info info; 2543 2544 if (parts->pscheme->secondary_scheme == NULL) 2545 return NULL; 2546 2547 start = -1; 2548 size = -1; 2549 if (parts->pscheme->guess_install_target == NULL || 2550 !parts->pscheme->guess_install_target(parts, &start, &size)) { 2551 for (pno = 0; pno < parts->num_part; pno++) { 2552 if (!parts->pscheme->get_part_info(parts, pno, &info)) 2553 continue; 2554 if (!(info.flags & PTI_SEC_CONTAINER)) 2555 continue; 2556 start = info.start; 2557 size = info.size; 2558 } 2559 } 2560 2561 if (size > 0) 2562 return parts->pscheme->secondary_partitions(parts, start, 2563 false); 2564 2565 return NULL; 2566 } 2567 2568 bool 2569 install_desc_from_parts(struct install_partition_desc *install, 2570 struct disk_partitions *parts) 2571 { 2572 struct disk_partitions *inner_parts; 2573 2574 memset(install, 0, sizeof(*install)); 2575 inner_parts = get_inner_parts(parts); 2576 if (inner_parts != NULL) 2577 parts = inner_parts; 2578 2579 return usage_info_list_from_parts(&install->infos, &install->num, 2580 parts); 2581 } 2582 2583 void 2584 free_usage_set(struct partition_usage_set *wanted) 2585 { 2586 /* XXX - free parts? free clone src? */ 2587 free(wanted->write_back); 2588 free(wanted->menu_opts); 2589 free(wanted->infos); 2590 } 2591 2592 void 2593 free_install_desc(struct install_partition_desc *install) 2594 { 2595 size_t i, j; 2596 2597 #ifndef NO_CLONES 2598 for (i = 0; i < install->num; i++) { 2599 struct selected_partitions *src = install->infos[i].clone_src; 2600 if (!(install->infos[i].flags & PUIFLG_CLONE_PARTS) || 2601 src == NULL) 2602 continue; 2603 free_selected_partitions(src); 2604 for (j = i+1; j < install->num; j++) 2605 if (install->infos[j].clone_src == src) 2606 install->infos[j].clone_src = NULL; 2607 } 2608 #endif 2609 2610 for (i = 0; i < install->num; i++) { 2611 struct disk_partitions * parts = install->infos[i].parts; 2612 2613 if (parts == NULL) 2614 continue; 2615 2616 if (parts->pscheme->free) 2617 parts->pscheme->free(parts); 2618 2619 /* NULL all other references to this parts */ 2620 for (j = i+1; j < install->num; j++) 2621 if (install->infos[j].parts == parts) 2622 install->infos[j].parts = NULL; 2623 } 2624 2625 free(install->write_back); 2626 free(install->infos); 2627 } 2628 2629 #ifdef MD_MAY_SWAP_TO 2630 bool 2631 may_swap_if_not_sdmmc(const char *disk) 2632 { 2633 int fd, res; 2634 prop_dictionary_t command_dict, args_dict, results_dict, data_dict; 2635 prop_string_t string; 2636 prop_number_t number; 2637 const char *parent = ""; 2638 2639 fd = open(DRVCTLDEV, O_RDONLY, 0); 2640 if (fd == -1) 2641 return true; 2642 2643 command_dict = prop_dictionary_create(); 2644 args_dict = prop_dictionary_create(); 2645 2646 string = prop_string_create_nocopy("get-properties"); 2647 prop_dictionary_set(command_dict, "drvctl-command", string); 2648 prop_object_release(string); 2649 2650 string = prop_string_create_copy(disk); 2651 prop_dictionary_set(args_dict, "device-name", string); 2652 prop_object_release(string); 2653 2654 prop_dictionary_set(command_dict, "drvctl-arguments", 2655 args_dict); 2656 prop_object_release(args_dict); 2657 2658 res = prop_dictionary_sendrecv_ioctl(command_dict, fd, 2659 DRVCTLCOMMAND, &results_dict); 2660 prop_object_release(command_dict); 2661 close(fd); 2662 if (res) 2663 return true; 2664 2665 number = prop_dictionary_get(results_dict, "drvctl-error"); 2666 if (prop_number_signed_value(number) == 0) { 2667 data_dict = prop_dictionary_get(results_dict, 2668 "drvctl-result-data"); 2669 if (data_dict != NULL) { 2670 string = prop_dictionary_get(data_dict, 2671 "device-parent"); 2672 if (string != NULL) 2673 parent = prop_string_value(string); 2674 } 2675 } 2676 2677 prop_object_release(results_dict); 2678 2679 if (parent == NULL) 2680 return true; 2681 2682 return strncmp(parent, "sdmmc", 5) != 0; 2683 } 2684 #endif 2685
Indexes created Sun Sep 21 19:09:51 GMT 2025