net.c revision 1.30
1 /* $NetBSD: net.c,v 1.30 2019/06/22 20:46:07 christos 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 /* net.c -- routines to fetch files off the network. */ 36 37 #include <sys/ioctl.h> 38 #include <sys/param.h> 39 #include <sys/resource.h> 40 #include <sys/socket.h> 41 #include <sys/stat.h> 42 #include <sys/statvfs.h> 43 #include <sys/statvfs.h> 44 #include <sys/sysctl.h> 45 #include <sys/wait.h> 46 #include <arpa/inet.h> 47 #include <net/if.h> 48 #include <net/if_media.h> 49 #include <netinet/in.h> 50 51 #include <err.h> 52 #include <stdio.h> 53 #include <stdlib.h> 54 #include <string.h> 55 #include <curses.h> 56 #include <time.h> 57 #include <unistd.h> 58 59 #include "defs.h" 60 #include "md.h" 61 #include "msg_defs.h" 62 #include "menu_defs.h" 63 #include "txtwalk.h" 64 65 int network_up = 0; 66 /* Access to network information */ 67 #define MAX_NETS 15 68 struct net_desc { 69 char if_dev[STRSIZE]; 70 char name[STRSIZE]; // TODO 71 }; 72 73 static char net_dev[STRSIZE]; 74 static char net_domain[STRSIZE]; 75 static char net_host[STRSIZE]; 76 static char net_ip[SSTRSIZE]; 77 static char net_srv_ip[SSTRSIZE]; 78 static char net_mask[SSTRSIZE]; 79 char net_namesvr[STRSIZE]; 80 static char net_defroute[STRSIZE]; 81 static char net_media[STRSIZE]; 82 static char sl_flags[STRSIZE]; 83 static int net_dhcpconf; 84 #define DHCPCONF_IPADDR 0x01 85 #define DHCPCONF_NAMESVR 0x02 86 #define DHCPCONF_HOST 0x04 87 #define DHCPCONF_DOMAIN 0x08 88 #ifdef INET6 89 static char net_ip6[STRSIZE]; 90 #define IP6CONF_AUTOHOST 0x01 91 #endif 92 93 94 /* URL encode unsafe characters. */ 95 96 static char *url_encode (char *dst, const char *src, const char *ep, 97 const char *safe_chars, 98 int encode_leading_slash); 99 100 static void write_etc_hosts(FILE *f); 101 102 #define DHCPCD "/sbin/dhcpcd" 103 #include <signal.h> 104 static int config_dhcp(char *); 105 106 #ifdef INET6 107 static int is_v6kernel (void); 108 #endif 109 110 /* 111 * URL encode unsafe characters. See RFC 1738. 112 * 113 * Copies src string to dst, encoding unsafe or reserved characters 114 * in %hex form as it goes, and returning a pointer to the result. 115 * The result is always a nul-terminated string even if it had to be 116 * truncated to avoid overflowing the available space. 117 * 118 * This url_encode() function does not operate on complete URLs, it 119 * operates on strings that make up parts of URLs. For example, in a 120 * URL like "ftp://username:password@host/path", the username, password, 121 * host and path should each be encoded separately before they are 122 * joined together with the punctuation characters. 123 * 124 * In most ordinary use, the path portion of a URL does not start with 125 * a slash; the slash is a separator between the host portion and the 126 * path portion, and is dealt with by software outside the url_encode() 127 * function. However, it is valid for url_encode() to be passed a 128 * string that does begin with a slash. For example, the string might 129 * represent a password, or a path part of a URL that the user really 130 * does want to begin with a slash. 131 * 132 * len is the length of the destination buffer. The result will be 133 * truncated if necessary to fit in the destination buffer. 134 * 135 * safe_chars is a string of characters that should not be encoded. If 136 * safe_chars is non-NULL, any characters in safe_chars as well as any 137 * alphanumeric characters will be copied from src to dst without 138 * encoding. Some potentially useful settings for this parameter are: 139 * 140 * NULL Everything is encoded (even alphanumerics) 141 * "" Everything except alphanumerics are encoded 142 * "/" Alphanumerics and '/' remain unencoded 143 * "$-_.+!*'()," Consistent with a strict reading of RFC 1738 144 * "$-_.+!*'(),/" As above, except '/' is not encoded 145 * "-_.+!,/" As above, except shell special characters are encoded 146 * 147 * encode_leading_slash is a flag that determines whether or not to 148 * encode a leading slash in a string. If this flag is set, and if the 149 * first character in the src string is '/', then the leading slash will 150 * be encoded (as "%2F"), even if '/' is one of the characters in the 151 * safe_chars string. Note that only the first character of the src 152 * string is affected by this flag, and that leading slashes are never 153 * deleted, but either retained unchanged or encoded. 154 * 155 * Unsafe and reserved characters are defined in RFC 1738 section 2.2. 156 * The most important parts are: 157 * 158 * The characters ";", "/", "?", ":", "@", "=" and "&" are the 159 * characters which may be reserved for special meaning within a 160 * scheme. No other characters may be reserved within a scheme. 161 * [...] 162 * 163 * Thus, only alphanumerics, the special characters "$-_.+!*'(),", 164 * and reserved characters used for their reserved purposes may be 165 * used unencoded within a URL. 166 * 167 */ 168 169 #define RFC1738_SAFE "$-_.+!*'()," 170 #define RFC1738_SAFE_LESS_SHELL "-_.+!," 171 #define RFC1738_SAFE_LESS_SHELL_PLUS_SLASH "-_.+!,/" 172 173 static char * 174 url_encode(char *dst, const char *src, const char *ep, 175 const char *safe_chars, int encode_leading_slash) 176 { 177 int ch; 178 179 ep--; 180 181 for (; dst < ep; src++) { 182 ch = *src & 0xff; 183 if (ch == 0) 184 break; 185 if (safe_chars != NULL && 186 (ch != '/' || !encode_leading_slash) && 187 (isalnum(ch) || strchr(safe_chars, ch))) { 188 *dst++ = ch; 189 } else { 190 /* encode this char */ 191 if (ep - dst < 3) 192 break; 193 snprintf(dst, ep - dst, "%%%02X", ch); 194 dst += 3; 195 } 196 encode_leading_slash = 0; 197 } 198 *dst = '\0'; 199 return dst; 200 } 201 202 static const char *ignored_if_names[] = { 203 "gre", /* net */ 204 "ipip", /* netinet */ 205 "gif", /* netinet6 */ 206 "faith", /* netinet6 */ 207 "lo", /* net */ 208 "lo0", /* net */ 209 #if 0 210 "mdecap", /* netinet -- never in IF list (?) XXX */ 211 #endif 212 "ppp", /* net */ 213 #if 0 214 "sl", /* net */ 215 #endif 216 "strip", /* net */ 217 "tun", /* net */ 218 /* XXX others? */ 219 NULL, 220 }; 221 222 static int 223 get_ifconfig_info(struct net_desc *devs) 224 { 225 char *buf_in; 226 char *buf_tmp; 227 const char **ignore; 228 char *buf; 229 char *tmp; 230 int textsize; 231 int i; 232 233 /* Get ifconfig information */ 234 textsize = collect(T_OUTPUT, &buf_in, "/sbin/ifconfig -l 2>/dev/null"); 235 if (textsize < 0) { 236 if (logfp) 237 (void)fprintf(logfp, 238 "Aborting: Could not run ifconfig.\n"); 239 (void)fprintf(stderr, "Could not run ifconfig."); 240 exit(1); 241 } 242 243 buf = malloc (STRSIZE * sizeof(char)); 244 for (i = 0, buf_tmp = buf_in; strlen(buf_tmp) > 0 && buf_tmp < buf_in + 245 strlen(buf_in);) { 246 tmp = stpncpy(buf, buf_tmp, strcspn(buf_tmp," \n")); 247 *tmp='\0'; 248 buf_tmp += (strcspn(buf_tmp, " \n") + 1) * sizeof(char); 249 250 /* Skip ignored interfaces */ 251 for (ignore = ignored_if_names; *ignore != NULL; ignore++) { 252 size_t len = strlen(*ignore); 253 if (strncmp(buf, *ignore, len) == 0 && 254 isdigit((unsigned char)buf[len])) 255 break; 256 } 257 if (*ignore != NULL) 258 continue; 259 260 strlcpy (devs[i].if_dev, buf, STRSIZE); 261 i++; 262 } 263 strcpy(devs[i].if_dev, "\0"); 264 265 free(buf); 266 free(buf_in); 267 return i; 268 } 269 270 static int 271 do_ifreq(struct ifreq *ifr, unsigned long cmd) 272 { 273 int sock; 274 int rval; 275 276 sock = socket(PF_INET, SOCK_DGRAM, 0); 277 if (sock == -1) 278 return -1; 279 280 memset(ifr, 0, sizeof *ifr); 281 strncpy(ifr->ifr_name, net_dev, sizeof ifr->ifr_name); 282 rval = ioctl(sock, cmd, ifr); 283 close(sock); 284 285 return rval; 286 } 287 288 static int 289 do_ifmreq(struct ifmediareq *ifmr, unsigned long cmd) 290 { 291 int sock; 292 int rval; 293 294 sock = socket(PF_INET, SOCK_DGRAM, 0); 295 if (sock == -1) 296 return -1; 297 298 memset(ifmr, 0, sizeof *ifmr); 299 strncpy(ifmr->ifm_name, net_dev, sizeof ifmr->ifm_name); 300 rval = ioctl(sock, cmd, ifmr); 301 close(sock); 302 303 return rval; 304 } 305 306 /* Fill in defaults network values for the selected interface */ 307 static void 308 get_ifinterface_info(void) 309 { 310 struct ifreq ifr; 311 struct ifmediareq ifmr; 312 struct sockaddr_in *sa_in = (void*)&ifr.ifr_addr; 313 int modew; 314 const char *media_opt; 315 const char *sep; 316 317 if (do_ifreq(&ifr, SIOCGIFADDR) == 0 && sa_in->sin_addr.s_addr != 0) 318 strlcpy(net_ip, inet_ntoa(sa_in->sin_addr), sizeof net_ip); 319 320 if (do_ifreq(&ifr, SIOCGIFNETMASK) == 0 && sa_in->sin_addr.s_addr != 0) 321 strlcpy(net_mask, inet_ntoa(sa_in->sin_addr), sizeof net_mask); 322 323 if (do_ifmreq(&ifmr, SIOCGIFMEDIA) == 0) { 324 /* Get the name of the media word */ 325 modew = ifmr.ifm_current; 326 strlcpy(net_media, get_media_subtype_string(modew), 327 sizeof net_media); 328 /* and add any media options */ 329 sep = " mediaopt "; 330 while ((media_opt = get_media_option_string(&modew)) != NULL) { 331 strlcat(net_media, sep, sizeof net_media); 332 strlcat(net_media, media_opt, sizeof net_media); 333 sep = ","; 334 } 335 } 336 } 337 338 #ifndef INET6 339 #define get_if6interface_info() 340 #else 341 static void 342 get_if6interface_info(void) 343 { 344 char *textbuf, *t; 345 int textsize; 346 347 textsize = collect(T_OUTPUT, &textbuf, 348 "/sbin/ifconfig %s inet6 2>/dev/null", net_dev); 349 if (textsize >= 0) { 350 char *p; 351 352 (void)strtok(textbuf, "\n"); /* ignore first line */ 353 while ((t = strtok(NULL, "\n")) != NULL) { 354 if (strncmp(t, "\tinet6 ", 7) != 0) 355 continue; 356 t += 7; 357 if (strstr(t, "tentative") || strstr(t, "duplicated")) 358 continue; 359 if (strncmp(t, "fe80:", 5) == 0) 360 continue; 361 362 p = t; 363 while (*p && *p != ' ' && *p != '\n') 364 p++; 365 *p = '\0'; 366 strlcpy(net_ip6, t, sizeof(net_ip6)); 367 break; 368 } 369 } 370 free(textbuf); 371 } 372 #endif 373 374 static void 375 get_host_info(void) 376 { 377 char hostname[MAXHOSTNAMELEN + 1]; 378 char *dot; 379 380 /* Check host (and domain?) name */ 381 if (gethostname(hostname, sizeof(hostname)) == 0 && hostname[0] != 0) { 382 hostname[sizeof(hostname) - 1] = 0; 383 /* check for a . */ 384 dot = strchr(hostname, '.'); 385 if (dot == NULL) { 386 /* if not found its just a host, punt on domain */ 387 strlcpy(net_host, hostname, sizeof net_host); 388 } else { 389 /* split hostname into host/domain parts */ 390 *dot++ = 0; 391 strlcpy(net_host, hostname, sizeof net_host); 392 strlcpy(net_domain, dot, sizeof net_domain); 393 } 394 } 395 } 396 397 /* 398 * recombine name parts split in get_host_info and config_network 399 * (common code moved here from write_etc_hosts) 400 */ 401 static char * 402 recombine_host_domain(void) 403 { 404 static char recombined[MAXHOSTNAMELEN + 1]; 405 int l = strlen(net_host) - strlen(net_domain); 406 407 strlcpy(recombined, net_host, sizeof(recombined)); 408 409 if (strlen(net_domain) != 0 && (l <= 0 || 410 net_host[l - 1] != '.' || 411 strcasecmp(net_domain, net_host + l) != 0)) { 412 /* net_host isn't an FQDN. */ 413 strlcat(recombined, ".", sizeof(recombined)); 414 strlcat(recombined, net_domain, sizeof(recombined)); 415 } 416 return recombined; 417 } 418 419 #ifdef INET6 420 static int 421 is_v6kernel(void) 422 { 423 int s; 424 425 s = socket(PF_INET6, SOCK_DGRAM, 0); 426 if (s < 0) 427 return 0; 428 close(s); 429 return 1; 430 } 431 #endif 432 433 static int 434 handle_license(const char *dev) 435 { 436 static struct { 437 const char *dev; 438 const char *lic; 439 } licdev[] = { 440 { "iwi", "/libdata/firmware/if_iwi/LICENSE.ipw2200-fw" }, 441 { "ipw", "/libdata/firmware/if_ipw/LICENSE" }, 442 }; 443 444 size_t i; 445 446 for (i = 0; i < __arraycount(licdev); i++) 447 if (strncmp(dev, licdev[i].dev, 3) == 0) { 448 char buf[64]; 449 int val; 450 size_t len = sizeof(int); 451 (void)snprintf(buf, sizeof(buf), "hw.%s.accept_eula", 452 licdev[i].dev); 453 if (sysctlbyname(buf, &val, &len, NULL, 0) != -1 454 && val != 0) 455 return 1; 456 msg_fmt_display(MSG_license, "%s%s", 457 dev, licdev[i].lic); 458 if (ask_yesno(NULL)) { 459 val = 1; 460 if (sysctlbyname(buf, NULL, NULL, &val, 461 0) == -1) 462 return 0; 463 add_sysctl_conf("%s=1", buf); 464 return 1; 465 } else 466 return 0; 467 } 468 return 1; 469 } 470 471 /* 472 * Get the information to configure the network, configure it and 473 * make sure both the gateway and the name server are up. 474 */ 475 int 476 config_network(void) 477 { 478 char *textbuf; 479 int octet0; 480 int dhcp_config; 481 int nfs_root = 0; 482 int slip = 0; 483 int pid, status; 484 char **ap, *slcmd[10], *in_buf; 485 char buffer[STRSIZE]; 486 struct statvfs sb; 487 struct net_desc net_devs[MAX_NETS]; 488 menu_ent net_menu[5]; 489 int menu_no; 490 int num_devs; 491 int selected_net; 492 int i; 493 #ifdef INET6 494 int v6config = 1, rv; 495 #endif 496 497 FILE *f; 498 time_t now; 499 500 if (network_up) 501 return (1); 502 503 num_devs = get_ifconfig_info(net_devs); 504 505 if (num_devs < 1) { 506 /* No network interfaces found! */ 507 hit_enter_to_continue(NULL, MSG_nonet); 508 return (-1); 509 } 510 511 for (i = 0; i < num_devs; i++) { 512 net_menu[i].opt_name = net_devs[i].if_dev; 513 net_menu[i].opt_flags = OPT_EXIT; 514 net_menu[i].opt_action = set_menu_select; 515 } 516 again: 517 selected_net = -1; 518 menu_no = new_menu(MSG_netdevs, 519 net_menu, num_devs, -1, 4, 0, 0, 520 MC_SCROLL, 521 NULL, NULL, NULL, NULL, NULL); 522 msg_display(MSG_asknetdev); 523 process_menu(menu_no, &selected_net); 524 free_menu(menu_no); 525 526 if (selected_net == -1) 527 return 0; 528 529 network_up = 1; 530 dhcp_config = 0; 531 532 strncpy(net_dev, net_devs[selected_net].if_dev, STRSIZE); 533 534 if (!handle_license(net_dev)) 535 goto done; 536 537 slip = net_dev[0] == 's' && net_dev[1] == 'l' && 538 isdigit((unsigned char)net_dev[2]); 539 540 /* If root is on NFS do not reconfigure the interface. */ 541 if (statvfs("/", &sb) == 0 && strcmp(sb.f_fstypename, "nfs") == 0) { 542 nfs_root = 1; 543 get_ifinterface_info(); 544 get_if6interface_info(); 545 get_host_info(); 546 } else if (!slip) { 547 /* Preload any defaults we can find */ 548 get_ifinterface_info(); 549 get_if6interface_info(); 550 get_host_info(); 551 552 /* domain and host */ 553 msg_display(MSG_netinfo); 554 555 /* ethernet medium */ 556 for (;;) { 557 msg_prompt_add(MSG_net_media, net_media, net_media, 558 sizeof net_media); 559 560 /* 561 * ifconfig does not allow media specifiers on 562 * IFM_MANUAL interfaces. Our UI gives no way 563 * to set an option back 564 * to null-string if it gets accidentally set. 565 * Check for plausible alternatives. 566 */ 567 if (strcmp(net_media, "<default>") == 0 || 568 strcmp(net_media, "default") == 0 || 569 strcmp(net_media, "<manual>") == 0 || 570 strcmp(net_media, "manual") == 0 || 571 strcmp(net_media, "<none>") == 0 || 572 strcmp(net_media, "none") == 0 || 573 strcmp(net_media, " ") == 0) { 574 *net_media = '\0'; 575 } 576 577 if (*net_media == '\0') 578 break; 579 /* 580 * We must set the media type here - to give dhcp 581 * a chance 582 */ 583 if (run_program(0, "/sbin/ifconfig %s media %s", 584 net_dev, net_media) == 0) 585 break; 586 /* Failed to set - output the supported values */ 587 if (collect(T_OUTPUT, &textbuf, "/sbin/ifconfig -m %s |" 588 "while IFS=; read line;" 589 " do [ \"$line\" = \"${line#*media}\" ] || " 590 "echo $line;" 591 " done", net_dev ) > 0) 592 msg_display(textbuf); 593 free(textbuf); 594 } 595 596 net_dhcpconf = 0; 597 /* try a dhcp configuration */ 598 dhcp_config = config_dhcp(net_dev); 599 if (dhcp_config) { 600 char *nline; 601 602 /* Get newly configured data off interface. */ 603 get_ifinterface_info(); 604 get_if6interface_info(); 605 get_host_info(); 606 607 net_dhcpconf |= DHCPCONF_IPADDR; 608 609 /* 610 * Extract default route from output of 611 * 'route -n show' 612 */ 613 if (collect(T_OUTPUT, &textbuf, 614 "/sbin/route -n show | " 615 "while read dest gateway flags;" 616 " do [ \"$dest\" = default ] && {" 617 " echo \"$gateway\"; break; };" 618 " done" ) > 0) 619 strlcpy(net_defroute, textbuf, 620 sizeof net_defroute); 621 free(textbuf); 622 if ((nline = strchr(net_defroute, '\n'))) 623 *nline = '\0'; 624 625 /* pull nameserver info out of /etc/resolv.conf */ 626 if (collect(T_OUTPUT, &textbuf, 627 "cat /etc/resolv.conf 2>/dev/null |" 628 " while read keyword address rest;" 629 " do [ \"$keyword\" = nameserver ] &&" 630 " { echo \"$address\"; break; };" 631 " done" ) > 0) 632 strlcpy(net_namesvr, textbuf, 633 sizeof net_namesvr); 634 free(textbuf); 635 if ((nline = strchr(net_namesvr, '\n'))) 636 *nline = '\0'; 637 if (net_namesvr[0] != '\0') 638 net_dhcpconf |= DHCPCONF_NAMESVR; 639 640 /* pull domain info out of /etc/resolv.conf */ 641 if (collect(T_OUTPUT, &textbuf, 642 "cat /etc/resolv.conf 2>/dev/null |" 643 " while read keyword domain rest;" 644 " do [ \"$keyword\" = domain ] &&" 645 " { echo \"$domain\"; break; };" 646 " done" ) > 0) 647 strlcpy(net_domain, textbuf, 648 sizeof net_domain); 649 free(textbuf); 650 if (net_domain[0] == '\0') { 651 /* pull domain info out of /etc/resolv.conf */ 652 if (collect(T_OUTPUT, &textbuf, 653 "cat /etc/resolv.conf 2>/dev/null |" 654 " while read keyword search rest;" 655 " do [ \"$keyword\" = search ] &&" 656 " { echo \"$search\"; break; };" 657 " done" ) > 0) 658 strlcpy(net_domain, textbuf, 659 sizeof net_domain); 660 free(textbuf); 661 } 662 if ((nline = strchr(net_domain, '\n'))) 663 *nline = '\0'; 664 if (net_domain[0] != '\0') 665 net_dhcpconf |= DHCPCONF_DOMAIN; 666 667 if (gethostname(net_host, sizeof(net_host)) == 0 && 668 net_host[0] != 0) 669 net_dhcpconf |= DHCPCONF_HOST; 670 } 671 } 672 673 if (!(net_dhcpconf & DHCPCONF_HOST)) 674 msg_prompt_add(MSG_net_host, net_host, net_host, 675 sizeof net_host); 676 677 if (!(net_dhcpconf & DHCPCONF_DOMAIN)) 678 msg_prompt_add(MSG_net_domain, net_domain, net_domain, 679 sizeof net_domain); 680 681 if (!dhcp_config) { 682 /* Manually configure IPv4 */ 683 if (!nfs_root) 684 msg_prompt_add(MSG_net_ip, net_ip, net_ip, 685 sizeof net_ip); 686 if (slip) 687 msg_prompt_add(MSG_net_srv_ip, net_srv_ip, net_srv_ip, 688 sizeof net_srv_ip); 689 else if (!nfs_root) { 690 /* We don't want netmasks for SLIP */ 691 octet0 = atoi(net_ip); 692 if (!net_mask[0]) { 693 if (0 <= octet0 && octet0 <= 127) 694 strlcpy(net_mask, "0xff000000", 695 sizeof(net_mask)); 696 else if (128 <= octet0 && octet0 <= 191) 697 strlcpy(net_mask, "0xffff0000", 698 sizeof(net_mask)); 699 else if (192 <= octet0 && octet0 <= 223) 700 strlcpy(net_mask, "0xffffff00", 701 sizeof(net_mask)); 702 } 703 msg_prompt_add(MSG_net_mask, net_mask, net_mask, 704 sizeof net_mask); 705 } 706 msg_prompt_add(MSG_net_defroute, net_defroute, net_defroute, 707 sizeof net_defroute); 708 } 709 710 if (!(net_dhcpconf & DHCPCONF_NAMESVR)) { 711 #ifdef INET6 712 if (v6config) { 713 rv = 0; 714 process_menu(MENU_namesrv6, &rv); 715 if (!rv) 716 msg_prompt_add(MSG_net_namesrv, net_namesvr, 717 net_namesvr, sizeof net_namesvr); 718 } else 719 #endif 720 msg_prompt_add(MSG_net_namesrv, net_namesvr, net_namesvr, 721 sizeof net_namesvr); 722 } 723 724 /* confirm the setting */ 725 if (slip) 726 msg_fmt_display(MSG_netok_slip, "%s%s%s%s%s%s%s%s%s", 727 net_domain, 728 net_host, 729 *net_namesvr == '\0' ? "<none>" : net_namesvr, 730 net_dev, 731 *net_media == '\0' ? "<default>" : net_media, 732 *net_ip == '\0' ? "<none>" : net_ip, 733 *net_srv_ip == '\0' ? "<none>" : net_srv_ip, 734 *net_mask == '\0' ? "<none>" : net_mask, 735 *net_defroute == '\0' ? "<none>" : net_defroute); 736 else 737 msg_fmt_display(MSG_netok, "%s%s%s%s%s%s%s%s", 738 net_domain, 739 net_host, 740 *net_namesvr == '\0' ? "<none>" : net_namesvr, 741 net_dev, 742 *net_media == '\0' ? "<default>" : net_media, 743 *net_ip == '\0' ? "<none>" : net_ip, 744 *net_mask == '\0' ? "<none>" : net_mask, 745 *net_defroute == '\0' ? "<none>" : net_defroute); 746 #ifdef INET6 747 msg_fmt_display_add(MSG_netokv6, "%s", 748 !is_v6kernel() ? "<not supported>" : net_ip6); 749 #endif 750 done: 751 if (!ask_yesno(MSG_netok_ok)) 752 goto again; 753 754 run_program(0, "/sbin/ifconfig lo0 127.0.0.1"); 755 756 /* dhcpcd will have configured it all for us */ 757 if (dhcp_config) { 758 fflush(NULL); 759 network_up = 1; 760 return network_up; 761 } 762 763 /* 764 * we may want to perform checks against inconsistent configuration, 765 * like IPv4 DNS server without IPv4 configuration. 766 */ 767 768 /* Create /etc/resolv.conf if a nameserver was given */ 769 if (net_namesvr[0] != '\0') { 770 f = fopen("/etc/resolv.conf", "w"); 771 if (f == NULL) { 772 if (logfp) 773 (void)fprintf(logfp, 774 "%s", msg_string(MSG_resolv)); 775 (void)fprintf(stderr, "%s", msg_string(MSG_resolv)); 776 exit(1); 777 } 778 scripting_fprintf(NULL, "cat <<EOF >/etc/resolv.conf\n"); 779 time(&now); 780 scripting_fprintf(f, ";\n; BIND data file\n; %s %s;\n", 781 "Created by NetBSD sysinst on", safectime(&now)); 782 if (net_domain[0] != '\0') 783 scripting_fprintf(f, "search %s\n", net_domain); 784 if (net_namesvr[0] != '\0') 785 scripting_fprintf(f, "nameserver %s\n", net_namesvr); 786 scripting_fprintf(NULL, "EOF\n"); 787 fflush(NULL); 788 fclose(f); 789 } 790 791 if (net_ip[0] != '\0') { 792 if (slip) { 793 /* XXX: needs 'ifconfig sl0 create' much earlier */ 794 /* Set SLIP interface UP */ 795 run_program(0, "/sbin/ifconfig %s inet %s %s up", 796 net_dev, net_ip, net_srv_ip); 797 strcpy(sl_flags, "-s 115200 -l /dev/tty00"); 798 msg_prompt_win(MSG_slattach, -1, 12, 70, 0, 799 sl_flags, sl_flags, sizeof sl_flags); 800 801 /* XXX: wtf isn't run_program() used here? */ 802 pid = fork(); 803 if (pid == 0) { 804 strcpy(buffer, "/sbin/slattach "); 805 strcat(buffer, sl_flags); 806 in_buf = buffer; 807 808 for (ap = slcmd; (*ap = strsep(&in_buf, " ")) != NULL;) 809 if (**ap != '\0') 810 ++ap; 811 812 execvp(slcmd[0], slcmd); 813 } else 814 wait4(pid, &status, WNOHANG, 0); 815 } else if (!nfs_root) { 816 if (net_mask[0] != '\0') { 817 run_program(0, "/sbin/ifconfig %s inet %s netmask %s", 818 net_dev, net_ip, net_mask); 819 } else { 820 run_program(0, "/sbin/ifconfig %s inet %s", 821 net_dev, net_ip); 822 } 823 } 824 } 825 826 /* Set host name */ 827 if (net_host[0] != '\0') 828 sethostname(net_host, strlen(net_host)); 829 830 /* Set a default route if one was given */ 831 if (!nfs_root && net_defroute[0] != '\0') { 832 run_program(RUN_DISPLAY | RUN_PROGRESS, 833 "/sbin/route -n flush -inet"); 834 run_program(RUN_DISPLAY | RUN_PROGRESS, 835 "/sbin/route -n add default %s", net_defroute); 836 } 837 838 /* 839 * wait for addresses to become valid 840 */ 841 if (!nfs_root) { 842 msg_display_add(MSG_wait_network); 843 network_up = !run_program(RUN_DISPLAY | RUN_PROGRESS, 844 "/sbin/ifconfig -w 15 -W 5"); 845 } else { 846 /* Assume network is up. */ 847 network_up = 1; 848 } 849 850 fflush(NULL); 851 852 return network_up; 853 } 854 855 const char * 856 url_proto(unsigned int xfer) 857 { 858 switch (xfer) { 859 case XFER_FTP: return "ftp"; 860 case XFER_HTTP: return "http"; 861 } 862 863 return ""; 864 } 865 866 void 867 make_url(char *urlbuffer, struct ftpinfo *f, const char *dir) 868 { 869 char ftp_user_encoded[STRSIZE]; 870 char ftp_dir_encoded[STRSIZE]; 871 char *cp; 872 const char *dir2; 873 874 /* 875 * f->pass is quite likely to contain unsafe characters 876 * that need to be encoded in the URL (for example, 877 * "@", ":" and "/" need quoting). Let's be 878 * paranoid and also encode f->user and f->dir. (For 879 * example, f->dir could easily contain '~', which is 880 * unsafe by a strict reading of RFC 1738). 881 */ 882 if (strcmp("ftp", f->user) == 0 && f->pass[0] == 0) { 883 ftp_user_encoded[0] = 0; 884 } else { 885 cp = url_encode(ftp_user_encoded, f->user, 886 ftp_user_encoded + sizeof ftp_user_encoded - 1, 887 RFC1738_SAFE_LESS_SHELL, 0); 888 *cp++ = ':'; 889 cp = url_encode(cp, f->pass, 890 ftp_user_encoded + sizeof ftp_user_encoded - 1, 891 NULL, 0); 892 *cp++ = '@'; 893 *cp = 0; 894 } 895 cp = url_encode(ftp_dir_encoded, f->dir, 896 ftp_dir_encoded + sizeof ftp_dir_encoded - 1, 897 RFC1738_SAFE_LESS_SHELL_PLUS_SLASH, 1); 898 if (cp != ftp_dir_encoded && cp[-1] != '/') 899 *cp++ = '/'; 900 901 dir2 = dir; 902 while (*dir2 == '/') 903 ++dir2; 904 905 url_encode(cp, dir2, 906 ftp_dir_encoded + sizeof ftp_dir_encoded, 907 RFC1738_SAFE_LESS_SHELL_PLUS_SLASH, 0); 908 909 snprintf(urlbuffer, STRSIZE, "%s://%s%s/%s", url_proto(f->xfer), 910 ftp_user_encoded, f->xfer_host[f->xfer], ftp_dir_encoded); 911 } 912 913 914 /* ftp_fetch() and pkgsrc_fetch() are essentially the same, with a different 915 * ftpinfo var and pkgsrc always using .tgz suffix, while for 916 * regular sets we only use .tgz for source sets on some architectures. */ 917 static int do_ftp_fetch(const char *, bool, struct ftpinfo *); 918 919 static int 920 ftp_fetch(const char *set_name) 921 { 922 return do_ftp_fetch(set_name, use_tgz_for_set(set_name), &ftp); 923 } 924 925 static int 926 pkgsrc_fetch(const char *set_name) 927 { 928 return do_ftp_fetch(set_name, true, &pkgsrc); 929 } 930 931 static int 932 do_ftp_fetch(const char *set_name, bool force_tgz, struct ftpinfo *f) 933 { 934 const char *ftp_opt; 935 char url[STRSIZE]; 936 int rval; 937 938 /* 939 * Invoke ftp to fetch the file. 940 */ 941 if (strcmp("ftp", f->user) == 0 && f->pass[0] == 0) { 942 /* do anon ftp */ 943 ftp_opt = "-a "; 944 } else { 945 ftp_opt = ""; 946 } 947 948 make_url(url, f, set_dir_for_set(set_name)); 949 rval = run_program(RUN_DISPLAY | RUN_PROGRESS | RUN_XFER_DIR, 950 "/usr/bin/ftp %s%s/%s%s", 951 ftp_opt, url, set_name, 952 force_tgz ? dist_tgz_postfix : dist_postfix); 953 954 return rval ? SET_RETRY : SET_OK; 955 } 956 957 958 // XXX: check MSG_netnotup_continueanyway and MSG_netnotup 959 960 int 961 get_pkgsrc(void) 962 { 963 int rv = -1; 964 965 process_menu(MENU_pkgsrc, &rv); 966 967 if (rv == SET_SKIP) 968 return SET_SKIP; 969 970 fetch_fn = pkgsrc_fetch; 971 snprintf(ext_dir_pkgsrc, sizeof ext_dir_pkgsrc, "%s/%s", 972 target_prefix(), xfer_dir + (*xfer_dir == '/')); 973 974 return SET_OK; 975 } 976 977 int 978 get_via_ftp(unsigned int xfer) 979 { 980 arg_rv arg; 981 982 arg.rv = -1; 983 arg.arg = (void*)(uintptr_t)(xfer); 984 process_menu(MENU_ftpsource, &arg); 985 986 if (arg.rv == SET_RETRY) 987 return SET_RETRY; 988 989 /* We'll fetch each file just before installing it */ 990 fetch_fn = ftp_fetch; 991 ftp.xfer = xfer; 992 snprintf(ext_dir_bin, sizeof ext_dir_bin, "%s/%s", target_prefix(), 993 xfer_dir + (*xfer_dir == '/')); 994 snprintf(ext_dir_src, sizeof ext_dir_src, "%s/%s", target_prefix(), 995 xfer_dir + (*xfer_dir == '/')); 996 997 return SET_OK; 998 } 999 1000 int 1001 get_via_nfs(void) 1002 { 1003 struct statvfs sb; 1004 int rv; 1005 1006 /* If root is on NFS and we have sets, skip this step. */ 1007 if (statvfs(set_dir_bin, &sb) == 0 && 1008 strcmp(sb.f_fstypename, "nfs") == 0) { 1009 strlcpy(ext_dir_bin, set_dir_bin, sizeof ext_dir_bin); 1010 strlcpy(ext_dir_src, set_dir_src, sizeof ext_dir_src); 1011 return SET_OK; 1012 } 1013 1014 /* Get server and filepath */ 1015 rv = -1; 1016 process_menu(MENU_nfssource, &rv); 1017 1018 if (rv == SET_RETRY) 1019 return SET_RETRY; 1020 1021 /* Mount it */ 1022 if (run_program(0, "/sbin/mount -r -o -2,-i,-r=1024 -t nfs %s:%s /mnt2", 1023 nfs_host, nfs_dir)) 1024 return SET_RETRY; 1025 1026 mnt2_mounted = 1; 1027 1028 snprintf(ext_dir_bin, sizeof ext_dir_bin, "/mnt2/%s", set_dir_bin); 1029 snprintf(ext_dir_src, sizeof ext_dir_src, "/mnt2/%s", set_dir_src); 1030 1031 /* return location, don't clean... */ 1032 return SET_OK; 1033 } 1034 1035 /* 1036 * write the new contents of /etc/hosts to the specified file 1037 */ 1038 static void 1039 write_etc_hosts(FILE *f) 1040 { 1041 scripting_fprintf(f, "#\n"); 1042 scripting_fprintf(f, "# Added by NetBSD sysinst\n"); 1043 scripting_fprintf(f, "#\n"); 1044 1045 if (net_domain[0] != '\0') 1046 scripting_fprintf(f, "127.0.0.1 localhost.%s\n", net_domain); 1047 1048 scripting_fprintf(f, "%s\t", net_ip); 1049 if (net_domain[0] != '\0') 1050 scripting_fprintf(f, "%s ", recombine_host_domain()); 1051 scripting_fprintf(f, "%s\n", net_host); 1052 } 1053 1054 /* 1055 * Write the network config info the user entered via menus into the 1056 * config files in the target disk. Be careful not to lose any 1057 * information we don't immediately add back, in case the install 1058 * target is the currently-active root. 1059 */ 1060 void 1061 mnt_net_config(void) 1062 { 1063 char ifconfig_fn[STRSIZE]; 1064 FILE *ifconf = NULL; 1065 1066 if (!network_up) 1067 return; 1068 if (!ask_yesno(MSG_mntnetconfig)) 1069 return; 1070 1071 /* Write hostname to /etc/rc.conf */ 1072 if ((net_dhcpconf & DHCPCONF_HOST) == 0) 1073 if (del_rc_conf("hostname") == 0) 1074 add_rc_conf("hostname=%s\n", recombine_host_domain()); 1075 1076 /* Copy resolv.conf to target. If DHCP was used to create it, 1077 * it will be replaced on next boot anyway. */ 1078 if (net_namesvr[0] != '\0') 1079 dup_file_into_target("/etc/resolv.conf"); 1080 1081 /* 1082 * bring the interface up, it will be necessary for IPv6, and 1083 * it won't make trouble with IPv4 case either 1084 */ 1085 snprintf(ifconfig_fn, sizeof ifconfig_fn, "/etc/ifconfig.%s", net_dev); 1086 ifconf = target_fopen(ifconfig_fn, "w"); 1087 if (ifconf != NULL) { 1088 scripting_fprintf(NULL, "cat <<EOF >>%s%s\n", 1089 target_prefix(), ifconfig_fn); 1090 scripting_fprintf(ifconf, "up\n"); 1091 if (*net_media != '\0') 1092 scripting_fprintf(ifconf, "media %s\n", net_media); 1093 scripting_fprintf(NULL, "EOF\n"); 1094 } 1095 1096 if ((net_dhcpconf & DHCPCONF_IPADDR) == 0) { 1097 FILE *hosts; 1098 1099 /* Write IPaddr and netmask to /etc/ifconfig.if[0-9] */ 1100 if (ifconf != NULL) { 1101 scripting_fprintf(NULL, "cat <<EOF >>%s%s\n", 1102 target_prefix(), ifconfig_fn); 1103 if (*net_media != '\0') 1104 scripting_fprintf(ifconf, 1105 "%s netmask %s media %s\n", 1106 net_ip, net_mask, net_media); 1107 else 1108 scripting_fprintf(ifconf, "%s netmask %s\n", 1109 net_ip, net_mask); 1110 scripting_fprintf(NULL, "EOF\n"); 1111 } 1112 1113 /* 1114 * Add IPaddr/hostname to /etc/hosts. 1115 * Be careful not to clobber any existing contents. 1116 * Relies on ordered search of /etc/hosts. XXX YP? 1117 */ 1118 hosts = target_fopen("/etc/hosts", "a"); 1119 if (hosts != 0) { 1120 scripting_fprintf(NULL, "cat <<EOF >>%s/etc/hosts\n", 1121 target_prefix()); 1122 write_etc_hosts(hosts); 1123 (void)fclose(hosts); 1124 scripting_fprintf(NULL, "EOF\n"); 1125 } 1126 1127 if (del_rc_conf("defaultroute") == 0) 1128 add_rc_conf("defaultroute=\"%s\"\n", net_defroute); 1129 } else { 1130 /* 1131 * Start dhcpcd quietly and in master mode, but restrict 1132 * it to our interface 1133 */ 1134 add_rc_conf("dhcpcd=YES\n"); 1135 add_rc_conf("dhcpcd_flags=\"-qM %s\"\n", net_dev); 1136 } 1137 1138 if (ifconf) 1139 fclose(ifconf); 1140 1141 fflush(NULL); 1142 } 1143 1144 int 1145 config_dhcp(char *inter) 1146 { 1147 int dhcpautoconf; 1148 1149 /* 1150 * Don't bother checking for an existing instance of dhcpcd, just 1151 * ask it to renew the lease. It will fork and daemonize if there 1152 * wasn't already an instance. 1153 */ 1154 1155 if (!file_mode_match(DHCPCD, S_IFREG)) 1156 return 0; 1157 if (ask_yesno(MSG_Perform_autoconfiguration)) { 1158 /* spawn off dhcpcd and wait for parent to exit */ 1159 dhcpautoconf = run_program(RUN_DISPLAY | RUN_PROGRESS, 1160 "%s -d -n %s", DHCPCD, inter); 1161 return dhcpautoconf ? 0 : 1; 1162 } 1163 return 0; 1164 } 1165
Indexes created Tue Sep 30 20:09:53 GMT 2025