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