1#!/bin/sh 2 3#- 4# SPDX-License-Identifier: BSD-2-Clause-FreeBSD 5# 6# Copyright 2004-2007 Colin Percival 7# All rights reserved 8# 9# Redistribution and use in source and binary forms, with or without 10# modification, are permitted providing 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# 18# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 19# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 20# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY 22# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 26# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 27# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 28# POSSIBILITY OF SUCH DAMAGE. 29 30# $FreeBSD$ 31 32#### Usage function -- called from command-line handling code. 33 34# Usage instructions. Options not listed: 35# --debug -- don't filter output from utilities 36# --no-stats -- don't show progress statistics while fetching files 37usage () { 38 cat <<EOF 39usage: `basename $0` [options] command ... [path] 40 41Options: 42 -b basedir -- Operate on a system mounted at basedir 43 (default: /) 44 -d workdir -- Store working files in workdir 45 (default: /var/db/freebsd-update/) 46 -f conffile -- Read configuration options from conffile 47 (default: /etc/freebsd-update.conf) 48 -F -- Force a fetch operation to proceed 49 -k KEY -- Trust an RSA key with SHA256 hash of KEY 50 -r release -- Target for upgrade (e.g., 11.1-RELEASE) 51 -s server -- Server from which to fetch updates 52 (default: update.FreeBSD.org) 53 -t address -- Mail output of cron command, if any, to address 54 (default: root) 55 --not-running-from-cron 56 -- Run without a tty, for use by automated tools 57 --currently-running release 58 -- Update as if currently running this release 59Commands: 60 fetch -- Fetch updates from server 61 cron -- Sleep rand(3600) seconds, fetch updates, and send an 62 email if updates were found 63 upgrade -- Fetch upgrades to FreeBSD version specified via -r option 64 install -- Install downloaded updates or upgrades 65 rollback -- Uninstall most recently installed updates 66 IDS -- Compare the system against an index of "known good" files. 67EOF 68 exit 0 69} 70 71#### Configuration processing functions 72 73#- 74# Configuration options are set in the following order of priority: 75# 1. Command line options 76# 2. Configuration file options 77# 3. Default options 78# In addition, certain options (e.g., IgnorePaths) can be specified multiple 79# times and (as long as these are all in the same place, e.g., inside the 80# configuration file) they will accumulate. Finally, because the path to the 81# configuration file can be specified at the command line, the entire command 82# line must be processed before we start reading the configuration file. 83# 84# Sound like a mess? It is. Here's how we handle this: 85# 1. Initialize CONFFILE and all the options to "". 86# 2. Process the command line. Throw an error if a non-accumulating option 87# is specified twice. 88# 3. If CONFFILE is "", set CONFFILE to /etc/freebsd-update.conf . 89# 4. For all the configuration options X, set X_saved to X. 90# 5. Initialize all the options to "". 91# 6. Read CONFFILE line by line, parsing options. 92# 7. For each configuration option X, set X to X_saved iff X_saved is not "". 93# 8. Repeat steps 4-7, except setting options to their default values at (6). 94 95CONFIGOPTIONS="KEYPRINT WORKDIR SERVERNAME MAILTO ALLOWADD ALLOWDELETE 96 KEEPMODIFIEDMETADATA COMPONENTS IGNOREPATHS UPDATEIFUNMODIFIED 97 BASEDIR VERBOSELEVEL TARGETRELEASE STRICTCOMPONENTS MERGECHANGES 98 IDSIGNOREPATHS BACKUPKERNEL BACKUPKERNELDIR BACKUPKERNELSYMBOLFILES" 99 100# Set all the configuration options to "". 101nullconfig () { 102 for X in ${CONFIGOPTIONS}; do 103 eval ${X}="" 104 done 105} 106 107# For each configuration option X, set X_saved to X. 108saveconfig () { 109 for X in ${CONFIGOPTIONS}; do 110 eval ${X}_saved=\$${X} 111 done 112} 113 114# For each configuration option X, set X to X_saved if X_saved is not "". 115mergeconfig () { 116 for X in ${CONFIGOPTIONS}; do 117 eval _=\$${X}_saved 118 if ! [ -z "${_}" ]; then 119 eval ${X}=\$${X}_saved 120 fi 121 done 122} 123 124# Set the trusted keyprint. 125config_KeyPrint () { 126 if [ -z ${KEYPRINT} ]; then 127 KEYPRINT=$1 128 else 129 return 1 130 fi 131} 132 133# Set the working directory. 134config_WorkDir () { 135 if [ -z ${WORKDIR} ]; then 136 WORKDIR=$1 137 else 138 return 1 139 fi 140} 141 142# Set the name of the server (pool) from which to fetch updates 143config_ServerName () { 144 if [ -z ${SERVERNAME} ]; then 145 SERVERNAME=$1 146 else 147 return 1 148 fi 149} 150 151# Set the address to which 'cron' output will be mailed. 152config_MailTo () { 153 if [ -z ${MAILTO} ]; then 154 MAILTO=$1 155 else 156 return 1 157 fi 158} 159 160# Set whether FreeBSD Update is allowed to add files (or directories, or 161# symlinks) which did not previously exist. 162config_AllowAdd () { 163 if [ -z ${ALLOWADD} ]; then 164 case $1 in 165 [Yy][Ee][Ss]) 166 ALLOWADD=yes 167 ;; 168 [Nn][Oo]) 169 ALLOWADD=no 170 ;; 171 *) 172 return 1 173 ;; 174 esac 175 else 176 return 1 177 fi 178} 179 180# Set whether FreeBSD Update is allowed to remove files/directories/symlinks. 181config_AllowDelete () { 182 if [ -z ${ALLOWDELETE} ]; then 183 case $1 in 184 [Yy][Ee][Ss]) 185 ALLOWDELETE=yes 186 ;; 187 [Nn][Oo]) 188 ALLOWDELETE=no 189 ;; 190 *) 191 return 1 192 ;; 193 esac 194 else 195 return 1 196 fi 197} 198 199# Set whether FreeBSD Update should keep existing inode ownership, 200# permissions, and flags, in the event that they have been modified locally 201# after the release. 202config_KeepModifiedMetadata () { 203 if [ -z ${KEEPMODIFIEDMETADATA} ]; then 204 case $1 in 205 [Yy][Ee][Ss]) 206 KEEPMODIFIEDMETADATA=yes 207 ;; 208 [Nn][Oo]) 209 KEEPMODIFIEDMETADATA=no 210 ;; 211 *) 212 return 1 213 ;; 214 esac 215 else 216 return 1 217 fi 218} 219 220# Add to the list of components which should be kept updated. 221config_Components () { 222 for C in $@; do 223 if [ "$C" = "src" ]; then 224 if [ -e /usr/src/COPYRIGHT ]; then 225 COMPONENTS="${COMPONENTS} ${C}" 226 else 227 echo "src component not installed, skipped" 228 fi 229 else 230 COMPONENTS="${COMPONENTS} ${C}" 231 fi 232 done 233} 234 235# Add to the list of paths under which updates will be ignored. 236config_IgnorePaths () { 237 for C in $@; do 238 IGNOREPATHS="${IGNOREPATHS} ${C}" 239 done 240} 241 242# Add to the list of paths which IDS should ignore. 243config_IDSIgnorePaths () { 244 for C in $@; do 245 IDSIGNOREPATHS="${IDSIGNOREPATHS} ${C}" 246 done 247} 248 249# Add to the list of paths within which updates will be performed only if the 250# file on disk has not been modified locally. 251config_UpdateIfUnmodified () { 252 for C in $@; do 253 UPDATEIFUNMODIFIED="${UPDATEIFUNMODIFIED} ${C}" 254 done 255} 256 257# Add to the list of paths within which updates to text files will be merged 258# instead of overwritten. 259config_MergeChanges () { 260 for C in $@; do 261 MERGECHANGES="${MERGECHANGES} ${C}" 262 done 263} 264 265# Work on a FreeBSD installation mounted under $1 266config_BaseDir () { 267 if [ -z ${BASEDIR} ]; then 268 BASEDIR=$1 269 else 270 return 1 271 fi 272} 273 274# When fetching upgrades, should we assume the user wants exactly the 275# components listed in COMPONENTS, rather than trying to guess based on 276# what's currently installed? 277config_StrictComponents () { 278 if [ -z ${STRICTCOMPONENTS} ]; then 279 case $1 in 280 [Yy][Ee][Ss]) 281 STRICTCOMPONENTS=yes 282 ;; 283 [Nn][Oo]) 284 STRICTCOMPONENTS=no 285 ;; 286 *) 287 return 1 288 ;; 289 esac 290 else 291 return 1 292 fi 293} 294 295# Upgrade to FreeBSD $1 296config_TargetRelease () { 297 if [ -z ${TARGETRELEASE} ]; then 298 TARGETRELEASE=$1 299 else 300 return 1 301 fi 302 if echo ${TARGETRELEASE} | grep -qE '^[0-9.]+$'; then 303 TARGETRELEASE="${TARGETRELEASE}-RELEASE" 304 fi 305} 306 307# Define what happens to output of utilities 308config_VerboseLevel () { 309 if [ -z ${VERBOSELEVEL} ]; then 310 case $1 in 311 [Dd][Ee][Bb][Uu][Gg]) 312 VERBOSELEVEL=debug 313 ;; 314 [Nn][Oo][Ss][Tt][Aa][Tt][Ss]) 315 VERBOSELEVEL=nostats 316 ;; 317 [Ss][Tt][Aa][Tt][Ss]) 318 VERBOSELEVEL=stats 319 ;; 320 *) 321 return 1 322 ;; 323 esac 324 else 325 return 1 326 fi 327} 328 329config_BackupKernel () { 330 if [ -z ${BACKUPKERNEL} ]; then 331 case $1 in 332 [Yy][Ee][Ss]) 333 BACKUPKERNEL=yes 334 ;; 335 [Nn][Oo]) 336 BACKUPKERNEL=no 337 ;; 338 *) 339 return 1 340 ;; 341 esac 342 else 343 return 1 344 fi 345} 346 347config_BackupKernelDir () { 348 if [ -z ${BACKUPKERNELDIR} ]; then 349 if [ -z "$1" ]; then 350 echo "BackupKernelDir set to empty dir" 351 return 1 352 fi 353 354 # We check for some paths which would be extremely odd 355 # to use, but which could cause a lot of problems if 356 # used. 357 case $1 in 358 /|/bin|/boot|/etc|/lib|/libexec|/sbin|/usr|/var) 359 echo "BackupKernelDir set to invalid path $1" 360 return 1 361 ;; 362 /*) 363 BACKUPKERNELDIR=$1 364 ;; 365 *) 366 echo "BackupKernelDir ($1) is not an absolute path" 367 return 1 368 ;; 369 esac 370 else 371 return 1 372 fi 373} 374 375config_BackupKernelSymbolFiles () { 376 if [ -z ${BACKUPKERNELSYMBOLFILES} ]; then 377 case $1 in 378 [Yy][Ee][Ss]) 379 BACKUPKERNELSYMBOLFILES=yes 380 ;; 381 [Nn][Oo]) 382 BACKUPKERNELSYMBOLFILES=no 383 ;; 384 *) 385 return 1 386 ;; 387 esac 388 else 389 return 1 390 fi 391} 392 393# Handle one line of configuration 394configline () { 395 if [ $# -eq 0 ]; then 396 return 397 fi 398 399 OPT=$1 400 shift 401 config_${OPT} $@ 402} 403 404#### Parameter handling functions. 405 406# Initialize parameters to null, just in case they're 407# set in the environment. 408init_params () { 409 # Configration settings 410 nullconfig 411 412 # No configuration file set yet 413 CONFFILE="" 414 415 # No commands specified yet 416 COMMANDS="" 417 418 # Force fetch to proceed 419 FORCEFETCH=0 420 421 # Run without a TTY 422 NOTTYOK=0 423 424 # Fetched first in a chain of commands 425 ISFETCHED=0 426} 427 428# Parse the command line 429parse_cmdline () { 430 while [ $# -gt 0 ]; do 431 case "$1" in 432 # Location of configuration file 433 -f) 434 if [ $# -eq 1 ]; then usage; fi 435 if [ ! -z "${CONFFILE}" ]; then usage; fi 436 shift; CONFFILE="$1" 437 ;; 438 -F) 439 FORCEFETCH=1 440 ;; 441 --not-running-from-cron) 442 NOTTYOK=1 443 ;; 444 --currently-running) 445 shift; export UNAME_r="$1" 446 ;; 447 448 # Configuration file equivalents 449 -b) 450 if [ $# -eq 1 ]; then usage; fi; shift 451 config_BaseDir $1 || usage 452 ;; 453 -d) 454 if [ $# -eq 1 ]; then usage; fi; shift 455 config_WorkDir $1 || usage 456 ;; 457 -k) 458 if [ $# -eq 1 ]; then usage; fi; shift 459 config_KeyPrint $1 || usage 460 ;; 461 -s) 462 if [ $# -eq 1 ]; then usage; fi; shift 463 config_ServerName $1 || usage 464 ;; 465 -r) 466 if [ $# -eq 1 ]; then usage; fi; shift 467 config_TargetRelease $1 || usage 468 ;; 469 -t) 470 if [ $# -eq 1 ]; then usage; fi; shift 471 config_MailTo $1 || usage 472 ;; 473 -v) 474 if [ $# -eq 1 ]; then usage; fi; shift 475 config_VerboseLevel $1 || usage 476 ;; 477 478 # Aliases for "-v debug" and "-v nostats" 479 --debug) 480 config_VerboseLevel debug || usage 481 ;; 482 --no-stats) 483 config_VerboseLevel nostats || usage 484 ;; 485 486 # Commands 487 cron | fetch | upgrade | install | rollback | IDS) 488 COMMANDS="${COMMANDS} $1" 489 ;; 490 491 # Anything else is an error 492 *) 493 usage 494 ;; 495 esac 496 shift 497 done 498 499 # Make sure we have at least one command 500 if [ -z "${COMMANDS}" ]; then 501 usage 502 fi 503} 504 505# Parse the configuration file 506parse_conffile () { 507 # If a configuration file was specified on the command line, check 508 # that it exists and is readable. 509 if [ ! -z "${CONFFILE}" ] && [ ! -r "${CONFFILE}" ]; then 510 echo -n "File does not exist " 511 echo -n "or is not readable: " 512 echo ${CONFFILE} 513 exit 1 514 fi 515 516 # If a configuration file was not specified on the command line, 517 # use the default configuration file path. If that default does 518 # not exist, give up looking for any configuration. 519 if [ -z "${CONFFILE}" ]; then 520 CONFFILE="/etc/freebsd-update.conf" 521 if [ ! -r "${CONFFILE}" ]; then 522 return 523 fi 524 fi 525 526 # Save the configuration options specified on the command line, and 527 # clear all the options in preparation for reading the config file. 528 saveconfig 529 nullconfig 530 531 # Read the configuration file. Anything after the first '#' is 532 # ignored, and any blank lines are ignored. 533 L=0 534 while read LINE; do 535 L=$(($L + 1)) 536 LINEX=`echo "${LINE}" | cut -f 1 -d '#'` 537 if ! configline ${LINEX}; then 538 echo "Error processing configuration file, line $L:" 539 echo "==> ${LINE}" 540 exit 1 541 fi 542 done < ${CONFFILE} 543 544 # Merge the settings read from the configuration file with those 545 # provided at the command line. 546 mergeconfig 547} 548 549# Provide some default parameters 550default_params () { 551 # Save any parameters already configured, and clear the slate 552 saveconfig 553 nullconfig 554 555 # Default configurations 556 config_WorkDir /var/db/freebsd-update 557 config_MailTo root 558 config_AllowAdd yes 559 config_AllowDelete yes 560 config_KeepModifiedMetadata yes 561 config_BaseDir / 562 config_VerboseLevel stats 563 config_StrictComponents no 564 config_BackupKernel yes 565 config_BackupKernelDir /boot/kernel.old 566 config_BackupKernelSymbolFiles no 567 568 # Merge these defaults into the earlier-configured settings 569 mergeconfig 570} 571 572# Set utility output filtering options, based on ${VERBOSELEVEL} 573fetch_setup_verboselevel () { 574 case ${VERBOSELEVEL} in 575 debug) 576 QUIETREDIR="/dev/stderr" 577 QUIETFLAG=" " 578 STATSREDIR="/dev/stderr" 579 DDSTATS=".." 580 XARGST="-t" 581 NDEBUG=" " 582 ;; 583 nostats) 584 QUIETREDIR="" 585 QUIETFLAG="" 586 STATSREDIR="/dev/null" 587 DDSTATS=".." 588 XARGST="" 589 NDEBUG="" 590 ;; 591 stats) 592 QUIETREDIR="/dev/null" 593 QUIETFLAG="-q" 594 STATSREDIR="/dev/stdout" 595 DDSTATS="" 596 XARGST="" 597 NDEBUG="-n" 598 ;; 599 esac 600} 601 602# Perform sanity checks and set some final parameters 603# in preparation for fetching files. Figure out which 604# set of updates should be downloaded: If the user is 605# running *-p[0-9]+, strip off the last part; if the 606# user is running -SECURITY, call it -RELEASE. Chdir 607# into the working directory. 608fetchupgrade_check_params () { 609 export HTTP_USER_AGENT="freebsd-update (${COMMAND}, `uname -r`)" 610 611 _SERVERNAME_z=\ 612"SERVERNAME must be given via command line or configuration file." 613 _KEYPRINT_z="Key must be given via -k option or configuration file." 614 _KEYPRINT_bad="Invalid key fingerprint: " 615 _WORKDIR_bad="Directory does not exist or is not writable: " 616 _WORKDIR_bad2="Directory is not on a persistent filesystem: " 617 618 if [ -z "${SERVERNAME}" ]; then 619 echo -n "`basename $0`: " 620 echo "${_SERVERNAME_z}" 621 exit 1 622 fi 623 if [ -z "${KEYPRINT}" ]; then 624 echo -n "`basename $0`: " 625 echo "${_KEYPRINT_z}" 626 exit 1 627 fi 628 if ! echo "${KEYPRINT}" | grep -qE "^[0-9a-f]{64}$"; then 629 echo -n "`basename $0`: " 630 echo -n "${_KEYPRINT_bad}" 631 echo ${KEYPRINT} 632 exit 1 633 fi 634 if ! [ -d "${WORKDIR}" -a -w "${WORKDIR}" ]; then 635 echo -n "`basename $0`: " 636 echo -n "${_WORKDIR_bad}" 637 echo ${WORKDIR} 638 exit 1 639 fi 640 case `df -T ${WORKDIR}` in */dev/md[0-9]* | *tmpfs*) 641 echo -n "`basename $0`: " 642 echo -n "${_WORKDIR_bad2}" 643 echo ${WORKDIR} 644 exit 1 645 ;; 646 esac 647 chmod 700 ${WORKDIR} 648 cd ${WORKDIR} || exit 1 649 650 # Generate release number. The s/SECURITY/RELEASE/ bit exists 651 # to provide an upgrade path for FreeBSD Update 1.x users, since 652 # the kernels provided by FreeBSD Update 1.x are always labelled 653 # as X.Y-SECURITY. 654 RELNUM=`uname -r | 655 sed -E 's,-p[0-9]+,,' | 656 sed -E 's,-SECURITY,-RELEASE,'` 657 ARCH=`uname -m` 658 FETCHDIR=${RELNUM}/${ARCH} 659 PATCHDIR=${RELNUM}/${ARCH}/bp 660 661 # Figure out what directory contains the running kernel 662 BOOTFILE=`sysctl -n kern.bootfile` 663 KERNELDIR=${BOOTFILE%/kernel} 664 if ! [ -d ${KERNELDIR} ]; then 665 echo "Cannot identify running kernel" 666 exit 1 667 fi 668 669 # Figure out what kernel configuration is running. We start with 670 # the output of `uname -i`, and then make the following adjustments: 671 # 1. Replace "SMP-GENERIC" with "SMP". Why the SMP kernel config 672 # file says "ident SMP-GENERIC", I don't know... 673 # 2. If the kernel claims to be GENERIC _and_ ${ARCH} is "amd64" 674 # _and_ `sysctl kern.version` contains a line which ends "/SMP", then 675 # we're running an SMP kernel. This mis-identification is a bug 676 # which was fixed in 6.2-STABLE. 677 KERNCONF=`uname -i` 678 if [ ${KERNCONF} = "SMP-GENERIC" ]; then 679 KERNCONF=SMP 680 fi 681 if [ ${KERNCONF} = "GENERIC" ] && [ ${ARCH} = "amd64" ]; then 682 if sysctl kern.version | grep -qE '/SMP$'; then 683 KERNCONF=SMP 684 fi 685 fi 686 687 # Define some paths 688 BSPATCH=/usr/bin/bspatch 689 SHA256=/sbin/sha256 690 PHTTPGET=/usr/libexec/phttpget 691 692 # Set up variables relating to VERBOSELEVEL 693 fetch_setup_verboselevel 694 695 # Construct a unique name from ${BASEDIR} 696 BDHASH=`echo ${BASEDIR} | sha256 -q` 697} 698 699# Perform sanity checks etc. before fetching updates. 700fetch_check_params () { 701 fetchupgrade_check_params 702 703 if ! [ -z "${TARGETRELEASE}" ]; then 704 echo -n "`basename $0`: " 705 echo -n "-r option is meaningless with 'fetch' command. " 706 echo "(Did you mean 'upgrade' instead?)" 707 exit 1 708 fi 709 710 # Check that we have updates ready to install 711 if [ -f ${BDHASH}-install/kerneldone -a $FORCEFETCH -eq 0 ]; then 712 echo "You have a partially completed upgrade pending" 713 echo "Run '$0 install' first." 714 echo "Run '$0 fetch -F' to proceed anyway." 715 exit 1 716 fi 717} 718 719# Perform sanity checks etc. before fetching upgrades. 720upgrade_check_params () { 721 fetchupgrade_check_params 722 723 # Unless set otherwise, we're upgrading to the same kernel config. 724 NKERNCONF=${KERNCONF} 725 726 # We need TARGETRELEASE set 727 _TARGETRELEASE_z="Release target must be specified via -r option." 728 if [ -z "${TARGETRELEASE}" ]; then 729 echo -n "`basename $0`: " 730 echo "${_TARGETRELEASE_z}" 731 exit 1 732 fi 733 734 # The target release should be != the current release. 735 if [ "${TARGETRELEASE}" = "${RELNUM}" ]; then 736 echo -n "`basename $0`: " 737 echo "Cannot upgrade from ${RELNUM} to itself" 738 exit 1 739 fi 740 741 # Turning off AllowAdd or AllowDelete is a bad idea for upgrades. 742 if [ "${ALLOWADD}" = "no" ]; then 743 echo -n "`basename $0`: " 744 echo -n "WARNING: \"AllowAdd no\" is a bad idea " 745 echo "when upgrading between releases." 746 echo 747 fi 748 if [ "${ALLOWDELETE}" = "no" ]; then 749 echo -n "`basename $0`: " 750 echo -n "WARNING: \"AllowDelete no\" is a bad idea " 751 echo "when upgrading between releases." 752 echo 753 fi 754 755 # Set EDITOR to /usr/bin/vi if it isn't already set 756 : ${EDITOR:='/usr/bin/vi'} 757} 758 759# Perform sanity checks and set some final parameters in 760# preparation for installing updates. 761install_check_params () { 762 # Check that we are root. All sorts of things won't work otherwise. 763 if [ `id -u` != 0 ]; then 764 echo "You must be root to run this." 765 exit 1 766 fi 767 768 # Check that securelevel <= 0. Otherwise we can't update schg files. 769 if [ `sysctl -n kern.securelevel` -gt 0 ]; then 770 echo "Updates cannot be installed when the system securelevel" 771 echo "is greater than zero." 772 exit 1 773 fi 774 775 # Check that we have a working directory 776 _WORKDIR_bad="Directory does not exist or is not writable: " 777 if ! [ -d "${WORKDIR}" -a -w "${WORKDIR}" ]; then 778 echo -n "`basename $0`: " 779 echo -n "${_WORKDIR_bad}" 780 echo ${WORKDIR} 781 exit 1 782 fi 783 cd ${WORKDIR} || exit 1 784 785 # Construct a unique name from ${BASEDIR} 786 BDHASH=`echo ${BASEDIR} | sha256 -q` 787 788 # Check that we have updates ready to install 789 if ! [ -L ${BDHASH}-install ]; then 790 echo "No updates are available to install." 791 if [ $ISFETCHED -eq 0 ]; then 792 echo "Run '$0 fetch' first." 793 fi 794 exit 0 795 fi 796 if ! [ -f ${BDHASH}-install/INDEX-OLD ] || 797 ! [ -f ${BDHASH}-install/INDEX-NEW ]; then 798 echo "Update manifest is corrupt -- this should never happen." 799 echo "Re-run '$0 fetch'." 800 exit 1 801 fi 802 803 # Figure out what directory contains the running kernel 804 BOOTFILE=`sysctl -n kern.bootfile` 805 KERNELDIR=${BOOTFILE%/kernel} 806 if ! [ -d ${KERNELDIR} ]; then 807 echo "Cannot identify running kernel" 808 exit 1 809 fi 810} 811 812# Perform sanity checks and set some final parameters in 813# preparation for UNinstalling updates. 814rollback_check_params () { 815 # Check that we are root. All sorts of things won't work otherwise. 816 if [ `id -u` != 0 ]; then 817 echo "You must be root to run this." 818 exit 1 819 fi 820 821 # Check that we have a working directory 822 _WORKDIR_bad="Directory does not exist or is not writable: " 823 if ! [ -d "${WORKDIR}" -a -w "${WORKDIR}" ]; then 824 echo -n "`basename $0`: " 825 echo -n "${_WORKDIR_bad}" 826 echo ${WORKDIR} 827 exit 1 828 fi 829 cd ${WORKDIR} || exit 1 830 831 # Construct a unique name from ${BASEDIR} 832 BDHASH=`echo ${BASEDIR} | sha256 -q` 833 834 # Check that we have updates ready to rollback 835 if ! [ -L ${BDHASH}-rollback ]; then 836 echo "No rollback directory found." 837 exit 1 838 fi 839 if ! [ -f ${BDHASH}-rollback/INDEX-OLD ] || 840 ! [ -f ${BDHASH}-rollback/INDEX-NEW ]; then 841 echo "Update manifest is corrupt -- this should never happen." 842 exit 1 843 fi 844} 845 846# Perform sanity checks and set some final parameters 847# in preparation for comparing the system against the 848# published index. Figure out which index we should 849# compare against: If the user is running *-p[0-9]+, 850# strip off the last part; if the user is running 851# -SECURITY, call it -RELEASE. Chdir into the working 852# directory. 853IDS_check_params () { 854 export HTTP_USER_AGENT="freebsd-update (${COMMAND}, `uname -r`)" 855 856 _SERVERNAME_z=\ 857"SERVERNAME must be given via command line or configuration file." 858 _KEYPRINT_z="Key must be given via -k option or configuration file." 859 _KEYPRINT_bad="Invalid key fingerprint: " 860 _WORKDIR_bad="Directory does not exist or is not writable: " 861 862 if [ -z "${SERVERNAME}" ]; then 863 echo -n "`basename $0`: " 864 echo "${_SERVERNAME_z}" 865 exit 1 866 fi 867 if [ -z "${KEYPRINT}" ]; then 868 echo -n "`basename $0`: " 869 echo "${_KEYPRINT_z}" 870 exit 1 871 fi 872 if ! echo "${KEYPRINT}" | grep -qE "^[0-9a-f]{64}$"; then 873 echo -n "`basename $0`: " 874 echo -n "${_KEYPRINT_bad}" 875 echo ${KEYPRINT} 876 exit 1 877 fi 878 if ! [ -d "${WORKDIR}" -a -w "${WORKDIR}" ]; then 879 echo -n "`basename $0`: " 880 echo -n "${_WORKDIR_bad}" 881 echo ${WORKDIR} 882 exit 1 883 fi 884 cd ${WORKDIR} || exit 1 885 886 # Generate release number. The s/SECURITY/RELEASE/ bit exists 887 # to provide an upgrade path for FreeBSD Update 1.x users, since 888 # the kernels provided by FreeBSD Update 1.x are always labelled 889 # as X.Y-SECURITY. 890 RELNUM=`uname -r | 891 sed -E 's,-p[0-9]+,,' | 892 sed -E 's,-SECURITY,-RELEASE,'` 893 ARCH=`uname -m` 894 FETCHDIR=${RELNUM}/${ARCH} 895 PATCHDIR=${RELNUM}/${ARCH}/bp 896 897 # Figure out what directory contains the running kernel 898 BOOTFILE=`sysctl -n kern.bootfile` 899 KERNELDIR=${BOOTFILE%/kernel} 900 if ! [ -d ${KERNELDIR} ]; then 901 echo "Cannot identify running kernel" 902 exit 1 903 fi 904 905 # Figure out what kernel configuration is running. We start with 906 # the output of `uname -i`, and then make the following adjustments: 907 # 1. Replace "SMP-GENERIC" with "SMP". Why the SMP kernel config 908 # file says "ident SMP-GENERIC", I don't know... 909 # 2. If the kernel claims to be GENERIC _and_ ${ARCH} is "amd64" 910 # _and_ `sysctl kern.version` contains a line which ends "/SMP", then 911 # we're running an SMP kernel. This mis-identification is a bug 912 # which was fixed in 6.2-STABLE. 913 KERNCONF=`uname -i` 914 if [ ${KERNCONF} = "SMP-GENERIC" ]; then 915 KERNCONF=SMP 916 fi 917 if [ ${KERNCONF} = "GENERIC" ] && [ ${ARCH} = "amd64" ]; then 918 if sysctl kern.version | grep -qE '/SMP$'; then 919 KERNCONF=SMP 920 fi 921 fi 922 923 # Define some paths 924 SHA256=/sbin/sha256 925 PHTTPGET=/usr/libexec/phttpget 926 927 # Set up variables relating to VERBOSELEVEL 928 fetch_setup_verboselevel 929} 930 931#### Core functionality -- the actual work gets done here 932 933# Use an SRV query to pick a server. If the SRV query doesn't provide 934# a useful answer, use the server name specified by the user. 935# Put another way... look up _http._tcp.${SERVERNAME} and pick a server 936# from that; or if no servers are returned, use ${SERVERNAME}. 937# This allows a user to specify "portsnap.freebsd.org" (in which case 938# portsnap will select one of the mirrors) or "portsnap5.tld.freebsd.org" 939# (in which case portsnap will use that particular server, since there 940# won't be an SRV entry for that name). 941# 942# We ignore the Port field, since we are always going to use port 80. 943 944# Fetch the mirror list, but do not pick a mirror yet. Returns 1 if 945# no mirrors are available for any reason. 946fetch_pick_server_init () { 947 : > serverlist_tried 948 949# Check that host(1) exists (i.e., that the system wasn't built with the 950# WITHOUT_BIND set) and don't try to find a mirror if it doesn't exist. 951 if ! which -s host; then 952 : > serverlist_full 953 return 1 954 fi 955 956 echo -n "Looking up ${SERVERNAME} mirrors... " 957 958# Issue the SRV query and pull out the Priority, Weight, and Target fields. 959# BIND 9 prints "$name has SRV record ..." while BIND 8 prints 960# "$name server selection ..."; we allow either format. 961 MLIST="_http._tcp.${SERVERNAME}" 962 host -t srv "${MLIST}" | 963 sed -nE "s/${MLIST} (has SRV record|server selection) //Ip" | 964 cut -f 1,2,4 -d ' ' | 965 sed -e 's/\.$//' | 966 sort > serverlist_full 967 968# If no records, give up -- we'll just use the server name we were given. 969 if [ `wc -l < serverlist_full` -eq 0 ]; then 970 echo "none found." 971 return 1 972 fi 973 974# Report how many mirrors we found. 975 echo `wc -l < serverlist_full` "mirrors found." 976 977# Generate a random seed for use in picking mirrors. If HTTP_PROXY 978# is set, this will be used to generate the seed; otherwise, the seed 979# will be random. 980 if [ -n "${HTTP_PROXY}${http_proxy}" ]; then 981 RANDVALUE=`sha256 -qs "${HTTP_PROXY}${http_proxy}" | 982 tr -d 'a-f' | 983 cut -c 1-9` 984 else 985 RANDVALUE=`jot -r 1 0 999999999` 986 fi 987} 988 989# Pick a mirror. Returns 1 if we have run out of mirrors to try. 990fetch_pick_server () { 991# Generate a list of not-yet-tried mirrors 992 sort serverlist_tried | 993 comm -23 serverlist_full - > serverlist 994 995# Have we run out of mirrors? 996 if [ `wc -l < serverlist` -eq 0 ]; then 997 echo "No mirrors remaining, giving up." 998 return 1 999 fi 1000 1001# Find the highest priority level (lowest numeric value). 1002 SRV_PRIORITY=`cut -f 1 -d ' ' serverlist | sort -n | head -1` 1003 1004# Add up the weights of the response lines at that priority level. 1005 SRV_WSUM=0; 1006 while read X; do 1007 case "$X" in 1008 ${SRV_PRIORITY}\ *) 1009 SRV_W=`echo $X | cut -f 2 -d ' '` 1010 SRV_WSUM=$(($SRV_WSUM + $SRV_W)) 1011 ;; 1012 esac 1013 done < serverlist 1014 1015# If all the weights are 0, pretend that they are all 1 instead. 1016 if [ ${SRV_WSUM} -eq 0 ]; then 1017 SRV_WSUM=`grep -E "^${SRV_PRIORITY} " serverlist | wc -l` 1018 SRV_W_ADD=1 1019 else 1020 SRV_W_ADD=0 1021 fi 1022 1023# Pick a value between 0 and the sum of the weights - 1 1024 SRV_RND=`expr ${RANDVALUE} % ${SRV_WSUM}` 1025 1026# Read through the list of mirrors and set SERVERNAME. Write the line 1027# corresponding to the mirror we selected into serverlist_tried so that 1028# we won't try it again. 1029 while read X; do 1030 case "$X" in 1031 ${SRV_PRIORITY}\ *) 1032 SRV_W=`echo $X | cut -f 2 -d ' '` 1033 SRV_W=$(($SRV_W + $SRV_W_ADD)) 1034 if [ $SRV_RND -lt $SRV_W ]; then 1035 SERVERNAME=`echo $X | cut -f 3 -d ' '` 1036 echo "$X" >> serverlist_tried 1037 break 1038 else 1039 SRV_RND=$(($SRV_RND - $SRV_W)) 1040 fi 1041 ;; 1042 esac 1043 done < serverlist 1044} 1045 1046# Take a list of ${oldhash}|${newhash} and output a list of needed patches, 1047# i.e., those for which we have ${oldhash} and don't have ${newhash}. 1048fetch_make_patchlist () { 1049 grep -vE "^([0-9a-f]{64})\|\1$" | 1050 tr '|' ' ' | 1051 while read X Y; do 1052 if [ -f "files/${Y}.gz" ] || 1053 [ ! -f "files/${X}.gz" ]; then 1054 continue 1055 fi 1056 echo "${X}|${Y}" 1057 done | sort -u 1058} 1059 1060# Print user-friendly progress statistics 1061fetch_progress () { 1062 LNC=0 1063 while read x; do 1064 LNC=$(($LNC + 1)) 1065 if [ $(($LNC % 10)) = 0 ]; then 1066 echo -n $LNC 1067 elif [ $(($LNC % 2)) = 0 ]; then 1068 echo -n . 1069 fi 1070 done 1071 echo -n " " 1072} 1073 1074# Function for asking the user if everything is ok 1075continuep () { 1076 while read -p "Does this look reasonable (y/n)? " CONTINUE; do 1077 case "${CONTINUE}" in 1078 y*) 1079 return 0 1080 ;; 1081 n*) 1082 return 1 1083 ;; 1084 esac 1085 done 1086} 1087 1088# Initialize the working directory 1089workdir_init () { 1090 mkdir -p files 1091 touch tINDEX.present 1092} 1093 1094# Check that we have a public key with an appropriate hash, or 1095# fetch the key if it doesn't exist. Returns 1 if the key has 1096# not yet been fetched. 1097fetch_key () { 1098 if [ -r pub.ssl ] && [ `${SHA256} -q pub.ssl` = ${KEYPRINT} ]; then 1099 return 0 1100 fi 1101 1102 echo -n "Fetching public key from ${SERVERNAME}... " 1103 rm -f pub.ssl 1104 fetch ${QUIETFLAG} http://${SERVERNAME}/${FETCHDIR}/pub.ssl \ 1105 2>${QUIETREDIR} || true 1106 if ! [ -r pub.ssl ]; then 1107 echo "failed." 1108 return 1 1109 fi 1110 if ! [ `${SHA256} -q pub.ssl` = ${KEYPRINT} ]; then 1111 echo "key has incorrect hash." 1112 rm -f pub.ssl 1113 return 1 1114 fi 1115 echo "done." 1116} 1117 1118# Fetch metadata signature, aka "tag". 1119fetch_tag () { 1120 echo -n "Fetching metadata signature " 1121 echo ${NDEBUG} "for ${RELNUM} from ${SERVERNAME}... " 1122 rm -f latest.ssl 1123 fetch ${QUIETFLAG} http://${SERVERNAME}/${FETCHDIR}/latest.ssl \ 1124 2>${QUIETREDIR} || true 1125 if ! [ -r latest.ssl ]; then 1126 echo "failed." 1127 return 1 1128 fi 1129 1130 openssl rsautl -pubin -inkey pub.ssl -verify \ 1131 < latest.ssl > tag.new 2>${QUIETREDIR} || true 1132 rm latest.ssl 1133 1134 if ! [ `wc -l < tag.new` = 1 ] || 1135 ! grep -qE \ 1136 "^freebsd-update\|${ARCH}\|${RELNUM}\|[0-9]+\|[0-9a-f]{64}\|[0-9]{10}" \ 1137 tag.new; then 1138 echo "invalid signature." 1139 return 1 1140 fi 1141 1142 echo "done." 1143 1144 RELPATCHNUM=`cut -f 4 -d '|' < tag.new` 1145 TINDEXHASH=`cut -f 5 -d '|' < tag.new` 1146 EOLTIME=`cut -f 6 -d '|' < tag.new` 1147} 1148 1149# Sanity-check the patch number in a tag, to make sure that we're not 1150# going to "update" backwards and to prevent replay attacks. 1151fetch_tagsanity () { 1152 # Check that we're not going to move from -pX to -pY with Y < X. 1153 RELPX=`uname -r | sed -E 's,.*-,,'` 1154 if echo ${RELPX} | grep -qE '^p[0-9]+$'; then 1155 RELPX=`echo ${RELPX} | cut -c 2-` 1156 else 1157 RELPX=0 1158 fi 1159 if [ "${RELPATCHNUM}" -lt "${RELPX}" ]; then 1160 echo 1161 echo -n "Files on mirror (${RELNUM}-p${RELPATCHNUM})" 1162 echo " appear older than what" 1163 echo "we are currently running (`uname -r`)!" 1164 echo "Cowardly refusing to proceed any further." 1165 return 1 1166 fi 1167 1168 # If "tag" exists and corresponds to ${RELNUM}, make sure that 1169 # it contains a patch number <= RELPATCHNUM, in order to protect 1170 # against rollback (replay) attacks. 1171 if [ -f tag ] && 1172 grep -qE \ 1173 "^freebsd-update\|${ARCH}\|${RELNUM}\|[0-9]+\|[0-9a-f]{64}\|[0-9]{10}" \ 1174 tag; then 1175 LASTRELPATCHNUM=`cut -f 4 -d '|' < tag` 1176 1177 if [ "${RELPATCHNUM}" -lt "${LASTRELPATCHNUM}" ]; then 1178 echo 1179 echo -n "Files on mirror (${RELNUM}-p${RELPATCHNUM})" 1180 echo " are older than the" 1181 echo -n "most recently seen updates" 1182 echo " (${RELNUM}-p${LASTRELPATCHNUM})." 1183 echo "Cowardly refusing to proceed any further." 1184 return 1 1185 fi 1186 fi 1187} 1188 1189# Fetch metadata index file 1190fetch_metadata_index () { 1191 echo ${NDEBUG} "Fetching metadata index... " 1192 rm -f ${TINDEXHASH} 1193 fetch ${QUIETFLAG} http://${SERVERNAME}/${FETCHDIR}/t/${TINDEXHASH} 1194 2>${QUIETREDIR} 1195 if ! [ -f ${TINDEXHASH} ]; then 1196 echo "failed." 1197 return 1 1198 fi 1199 if [ `${SHA256} -q ${TINDEXHASH}` != ${TINDEXHASH} ]; then 1200 echo "update metadata index corrupt." 1201 return 1 1202 fi 1203 echo "done." 1204} 1205 1206# Print an error message about signed metadata being bogus. 1207fetch_metadata_bogus () { 1208 echo 1209 echo "The update metadata$1 is correctly signed, but" 1210 echo "failed an integrity check." 1211 echo "Cowardly refusing to proceed any further." 1212 return 1 1213} 1214 1215# Construct tINDEX.new by merging the lines named in $1 from ${TINDEXHASH} 1216# with the lines not named in $@ from tINDEX.present (if that file exists). 1217fetch_metadata_index_merge () { 1218 for METAFILE in $@; do 1219 if [ `grep -E "^${METAFILE}\|" ${TINDEXHASH} | wc -l` \ 1220 -ne 1 ]; then 1221 fetch_metadata_bogus " index" 1222 return 1 1223 fi 1224 1225 grep -E "${METAFILE}\|" ${TINDEXHASH} 1226 done | 1227 sort > tINDEX.wanted 1228 1229 if [ -f tINDEX.present ]; then 1230 join -t '|' -v 2 tINDEX.wanted tINDEX.present | 1231 sort -m - tINDEX.wanted > tINDEX.new 1232 rm tINDEX.wanted 1233 else 1234 mv tINDEX.wanted tINDEX.new 1235 fi 1236} 1237 1238# Sanity check all the lines of tINDEX.new. Even if more metadata lines 1239# are added by future versions of the server, this won't cause problems, 1240# since the only lines which appear in tINDEX.new are the ones which we 1241# specifically grepped out of ${TINDEXHASH}. 1242fetch_metadata_index_sanity () { 1243 if grep -qvE '^[0-9A-Z.-]+\|[0-9a-f]{64}$' tINDEX.new; then 1244 fetch_metadata_bogus " index" 1245 return 1 1246 fi 1247} 1248 1249# Sanity check the metadata file $1. 1250fetch_metadata_sanity () { 1251 # Some aliases to save space later: ${P} is a character which can 1252 # appear in a path; ${M} is the four numeric metadata fields; and 1253 # ${H} is a sha256 hash. 1254 P="[-+./:=,%@_[~[:alnum:]]" 1255 M="[0-9]+\|[0-9]+\|[0-9]+\|[0-9]+" 1256 H="[0-9a-f]{64}" 1257 1258 # Check that the first four fields make sense. 1259 if gunzip -c < files/$1.gz | 1260 grep -qvE "^[a-z]+\|[0-9a-z-]+\|${P}+\|[fdL-]\|"; then 1261 fetch_metadata_bogus "" 1262 return 1 1263 fi 1264 1265 # Remove the first three fields. 1266 gunzip -c < files/$1.gz | 1267 cut -f 4- -d '|' > sanitycheck.tmp 1268 1269 # Sanity check entries with type 'f' 1270 if grep -E '^f' sanitycheck.tmp | 1271 grep -qvE "^f\|${M}\|${H}\|${P}*\$"; then 1272 fetch_metadata_bogus "" 1273 return 1 1274 fi 1275 1276 # Sanity check entries with type 'd' 1277 if grep -E '^d' sanitycheck.tmp | 1278 grep -qvE "^d\|${M}\|\|\$"; then 1279 fetch_metadata_bogus "" 1280 return 1 1281 fi 1282 1283 # Sanity check entries with type 'L' 1284 if grep -E '^L' sanitycheck.tmp | 1285 grep -qvE "^L\|${M}\|${P}*\|\$"; then 1286 fetch_metadata_bogus "" 1287 return 1 1288 fi 1289 1290 # Sanity check entries with type '-' 1291 if grep -E '^-' sanitycheck.tmp | 1292 grep -qvE "^-\|\|\|\|\|\|"; then 1293 fetch_metadata_bogus "" 1294 return 1 1295 fi 1296 1297 # Clean up 1298 rm sanitycheck.tmp 1299} 1300 1301# Fetch the metadata index and metadata files listed in $@, 1302# taking advantage of metadata patches where possible. 1303fetch_metadata () { 1304 fetch_metadata_index || return 1 1305 fetch_metadata_index_merge $@ || return 1 1306 fetch_metadata_index_sanity || return 1 1307 1308 # Generate a list of wanted metadata patches 1309 join -t '|' -o 1.2,2.2 tINDEX.present tINDEX.new | 1310 fetch_make_patchlist > patchlist 1311 1312 if [ -s patchlist ]; then 1313 # Attempt to fetch metadata patches 1314 echo -n "Fetching `wc -l < patchlist | tr -d ' '` " 1315 echo ${NDEBUG} "metadata patches.${DDSTATS}" 1316 tr '|' '-' < patchlist | 1317 lam -s "${FETCHDIR}/tp/" - -s ".gz" | 1318 xargs ${XARGST} ${PHTTPGET} ${SERVERNAME} \ 1319 2>${STATSREDIR} | fetch_progress 1320 echo "done." 1321 1322 # Attempt to apply metadata patches 1323 echo -n "Applying metadata patches... " 1324 tr '|' ' ' < patchlist | 1325 while read X Y; do 1326 if [ ! -f "${X}-${Y}.gz" ]; then continue; fi 1327 gunzip -c < ${X}-${Y}.gz > diff 1328 gunzip -c < files/${X}.gz > diff-OLD 1329 1330 # Figure out which lines are being added and removed 1331 grep -E '^-' diff | 1332 cut -c 2- | 1333 while read PREFIX; do 1334 look "${PREFIX}" diff-OLD 1335 done | 1336 sort > diff-rm 1337 grep -E '^\+' diff | 1338 cut -c 2- > diff-add 1339 1340 # Generate the new file 1341 comm -23 diff-OLD diff-rm | 1342 sort - diff-add > diff-NEW 1343 1344 if [ `${SHA256} -q diff-NEW` = ${Y} ]; then 1345 mv diff-NEW files/${Y} 1346 gzip -n files/${Y} 1347 else 1348 mv diff-NEW ${Y}.bad 1349 fi 1350 rm -f ${X}-${Y}.gz diff 1351 rm -f diff-OLD diff-NEW diff-add diff-rm 1352 done 2>${QUIETREDIR} 1353 echo "done." 1354 fi 1355 1356 # Update metadata without patches 1357 cut -f 2 -d '|' < tINDEX.new | 1358 while read Y; do 1359 if [ ! -f "files/${Y}.gz" ]; then 1360 echo ${Y}; 1361 fi 1362 done | 1363 sort -u > filelist 1364 1365 if [ -s filelist ]; then 1366 echo -n "Fetching `wc -l < filelist | tr -d ' '` " 1367 echo ${NDEBUG} "metadata files... " 1368 lam -s "${FETCHDIR}/m/" - -s ".gz" < filelist | 1369 xargs ${XARGST} ${PHTTPGET} ${SERVERNAME} \ 1370 2>${QUIETREDIR} 1371 1372 while read Y; do 1373 if ! [ -f ${Y}.gz ]; then 1374 echo "failed." 1375 return 1 1376 fi 1377 if [ `gunzip -c < ${Y}.gz | 1378 ${SHA256} -q` = ${Y} ]; then 1379 mv ${Y}.gz files/${Y}.gz 1380 else 1381 echo "metadata is corrupt." 1382 return 1 1383 fi 1384 done < filelist 1385 echo "done." 1386 fi 1387 1388# Sanity-check the metadata files. 1389 cut -f 2 -d '|' tINDEX.new > filelist 1390 while read X; do 1391 fetch_metadata_sanity ${X} || return 1 1392 done < filelist 1393 1394# Remove files which are no longer needed 1395 cut -f 2 -d '|' tINDEX.present | 1396 sort > oldfiles 1397 cut -f 2 -d '|' tINDEX.new | 1398 sort | 1399 comm -13 - oldfiles | 1400 lam -s "files/" - -s ".gz" | 1401 xargs rm -f 1402 rm patchlist filelist oldfiles 1403 rm ${TINDEXHASH} 1404 1405# We're done! 1406 mv tINDEX.new tINDEX.present 1407 mv tag.new tag 1408 1409 return 0 1410} 1411 1412# Extract a subset of a downloaded metadata file containing only the parts 1413# which are listed in COMPONENTS. 1414fetch_filter_metadata_components () { 1415 METAHASH=`look "$1|" tINDEX.present | cut -f 2 -d '|'` 1416 gunzip -c < files/${METAHASH}.gz > $1.all 1417 1418 # Fish out the lines belonging to components we care about. 1419 for C in ${COMPONENTS}; do 1420 look "`echo ${C} | tr '/' '|'`|" $1.all 1421 done > $1 1422 1423 # Remove temporary file. 1424 rm $1.all 1425} 1426 1427# Generate a filtered version of the metadata file $1 from the downloaded 1428# file, by fishing out the lines corresponding to components we're trying 1429# to keep updated, and then removing lines corresponding to paths we want 1430# to ignore. 1431fetch_filter_metadata () { 1432 # Fish out the lines belonging to components we care about. 1433 fetch_filter_metadata_components $1 1434 1435 # Canonicalize directory names by removing any trailing / in 1436 # order to avoid listing directories multiple times if they 1437 # belong to multiple components. Turning "/" into "" doesn't 1438 # matter, since we add a leading "/" when we use paths later. 1439 cut -f 3- -d '|' $1 | 1440 sed -e 's,/|d|,|d|,' | 1441 sed -e 's,/|-|,|-|,' | 1442 sort -u > $1.tmp 1443 1444 # Figure out which lines to ignore and remove them. 1445 for X in ${IGNOREPATHS}; do 1446 grep -E "^${X}" $1.tmp 1447 done | 1448 sort -u | 1449 comm -13 - $1.tmp > $1 1450 1451 # Remove temporary files. 1452 rm $1.tmp 1453} 1454 1455# Filter the metadata file $1 by adding lines with "/boot/$2" 1456# replaced by ${KERNELDIR} (which is `sysctl -n kern.bootfile` minus the 1457# trailing "/kernel"); and if "/boot/$2" does not exist, remove 1458# the original lines which start with that. 1459# Put another way: Deal with the fact that the FOO kernel is sometimes 1460# installed in /boot/FOO/ and is sometimes installed elsewhere. 1461fetch_filter_kernel_names () { 1462 grep ^/boot/$2 $1 | 1463 sed -e "s,/boot/$2,${KERNELDIR},g" | 1464 sort - $1 > $1.tmp 1465 mv $1.tmp $1 1466 1467 if ! [ -d /boot/$2 ]; then 1468 grep -v ^/boot/$2 $1 > $1.tmp 1469 mv $1.tmp $1 1470 fi 1471} 1472 1473# For all paths appearing in $1 or $3, inspect the system 1474# and generate $2 describing what is currently installed. 1475fetch_inspect_system () { 1476 # No errors yet... 1477 rm -f .err 1478 1479 # Tell the user why his disk is suddenly making lots of noise 1480 echo -n "Inspecting system... " 1481 1482 # Generate list of files to inspect 1483 cat $1 $3 | 1484 cut -f 1 -d '|' | 1485 sort -u > filelist 1486 1487 # Examine each file and output lines of the form 1488 # /path/to/file|type|device-inum|user|group|perm|flags|value 1489 # sorted by device and inode number. 1490 while read F; do 1491 # If the symlink/file/directory does not exist, record this. 1492 if ! [ -e ${BASEDIR}/${F} ]; then 1493 echo "${F}|-||||||" 1494 continue 1495 fi 1496 if ! [ -r ${BASEDIR}/${F} ]; then 1497 echo "Cannot read file: ${BASEDIR}/${F}" \ 1498 >/dev/stderr 1499 touch .err 1500 return 1 1501 fi 1502 1503 # Otherwise, output an index line. 1504 if [ -L ${BASEDIR}/${F} ]; then 1505 echo -n "${F}|L|" 1506 stat -n -f '%d-%i|%u|%g|%Mp%Lp|%Of|' ${BASEDIR}/${F}; 1507 readlink ${BASEDIR}/${F}; 1508 elif [ -f ${BASEDIR}/${F} ]; then 1509 echo -n "${F}|f|" 1510 stat -n -f '%d-%i|%u|%g|%Mp%Lp|%Of|' ${BASEDIR}/${F}; 1511 sha256 -q ${BASEDIR}/${F}; 1512 elif [ -d ${BASEDIR}/${F} ]; then 1513 echo -n "${F}|d|" 1514 stat -f '%d-%i|%u|%g|%Mp%Lp|%Of|' ${BASEDIR}/${F}; 1515 else 1516 echo "Unknown file type: ${BASEDIR}/${F}" \ 1517 >/dev/stderr 1518 touch .err 1519 return 1 1520 fi 1521 done < filelist | 1522 sort -k 3,3 -t '|' > $2.tmp 1523 rm filelist 1524 1525 # Check if an error occurred during system inspection 1526 if [ -f .err ]; then 1527 return 1 1528 fi 1529 1530 # Convert to the form 1531 # /path/to/file|type|user|group|perm|flags|value|hlink 1532 # by resolving identical device and inode numbers into hard links. 1533 cut -f 1,3 -d '|' $2.tmp | 1534 sort -k 1,1 -t '|' | 1535 sort -s -u -k 2,2 -t '|' | 1536 join -1 2 -2 3 -t '|' - $2.tmp | 1537 awk -F \| -v OFS=\| \ 1538 '{ 1539 if (($2 == $3) || ($4 == "-")) 1540 print $3,$4,$5,$6,$7,$8,$9,"" 1541 else 1542 print $3,$4,$5,$6,$7,$8,$9,$2 1543 }' | 1544 sort > $2 1545 rm $2.tmp 1546 1547 # We're finished looking around 1548 echo "done." 1549} 1550 1551# For any paths matching ${MERGECHANGES}, compare $1 and $2 and find any 1552# files which differ; generate $3 containing these paths and the old hashes. 1553fetch_filter_mergechanges () { 1554 # Pull out the paths and hashes of the files matching ${MERGECHANGES}. 1555 for F in $1 $2; do 1556 for X in ${MERGECHANGES}; do 1557 grep -E "^${X}" ${F} 1558 done | 1559 cut -f 1,2,7 -d '|' | 1560 sort > ${F}-values 1561 done 1562 1563 # Any line in $2-values which doesn't appear in $1-values and is a 1564 # file means that we should list the path in $3. 1565 comm -13 $1-values $2-values | 1566 fgrep '|f|' | 1567 cut -f 1 -d '|' > $2-paths 1568 1569 # For each path, pull out one (and only one!) entry from $1-values. 1570 # Note that we cannot distinguish which "old" version the user made 1571 # changes to; but hopefully any changes which occur due to security 1572 # updates will exist in both the "new" version and the version which 1573 # the user has installed, so the merging will still work. 1574 while read X; do 1575 look "${X}|" $1-values | 1576 head -1 1577 done < $2-paths > $3 1578 1579 # Clean up 1580 rm $1-values $2-values $2-paths 1581} 1582 1583# For any paths matching ${UPDATEIFUNMODIFIED}, remove lines from $[123] 1584# which correspond to lines in $2 with hashes not matching $1 or $3, unless 1585# the paths are listed in $4. For entries in $2 marked "not present" 1586# (aka. type -), remove lines from $[123] unless there is a corresponding 1587# entry in $1. 1588fetch_filter_unmodified_notpresent () { 1589 # Figure out which lines of $1 and $3 correspond to bits which 1590 # should only be updated if they haven't changed, and fish out 1591 # the (path, type, value) tuples. 1592 # NOTE: We don't consider a file to be "modified" if it matches 1593 # the hash from $3. 1594 for X in ${UPDATEIFUNMODIFIED}; do 1595 grep -E "^${X}" $1 1596 grep -E "^${X}" $3 1597 done | 1598 cut -f 1,2,7 -d '|' | 1599 sort > $1-values 1600 1601 # Do the same for $2. 1602 for X in ${UPDATEIFUNMODIFIED}; do 1603 grep -E "^${X}" $2 1604 done | 1605 cut -f 1,2,7 -d '|' | 1606 sort > $2-values 1607 1608 # Any entry in $2-values which is not in $1-values corresponds to 1609 # a path which we need to remove from $1, $2, and $3, unless it 1610 # that path appears in $4. 1611 comm -13 $1-values $2-values | 1612 sort -t '|' -k 1,1 > mlines.tmp 1613 cut -f 1 -d '|' $4 | 1614 sort | 1615 join -v 2 -t '|' - mlines.tmp | 1616 sort > mlines 1617 rm $1-values $2-values mlines.tmp 1618 1619 # Any lines in $2 which are not in $1 AND are "not present" lines 1620 # also belong in mlines. 1621 comm -13 $1 $2 | 1622 cut -f 1,2,7 -d '|' | 1623 fgrep '|-|' >> mlines 1624 1625 # Remove lines from $1, $2, and $3 1626 for X in $1 $2 $3; do 1627 sort -t '|' -k 1,1 ${X} > ${X}.tmp 1628 cut -f 1 -d '|' < mlines | 1629 sort | 1630 join -v 2 -t '|' - ${X}.tmp | 1631 sort > ${X} 1632 rm ${X}.tmp 1633 done 1634 1635 # Store a list of the modified files, for future reference 1636 fgrep -v '|-|' mlines | 1637 cut -f 1 -d '|' > modifiedfiles 1638 rm mlines 1639} 1640 1641# For each entry in $1 of type -, remove any corresponding 1642# entry from $2 if ${ALLOWADD} != "yes". Remove all entries 1643# of type - from $1. 1644fetch_filter_allowadd () { 1645 cut -f 1,2 -d '|' < $1 | 1646 fgrep '|-' | 1647 cut -f 1 -d '|' > filesnotpresent 1648 1649 if [ ${ALLOWADD} != "yes" ]; then 1650 sort < $2 | 1651 join -v 1 -t '|' - filesnotpresent | 1652 sort > $2.tmp 1653 mv $2.tmp $2 1654 fi 1655 1656 sort < $1 | 1657 join -v 1 -t '|' - filesnotpresent | 1658 sort > $1.tmp 1659 mv $1.tmp $1 1660 rm filesnotpresent 1661} 1662 1663# If ${ALLOWDELETE} != "yes", then remove any entries from $1 1664# which don't correspond to entries in $2. 1665fetch_filter_allowdelete () { 1666 # Produce a lists ${PATH}|${TYPE} 1667 for X in $1 $2; do 1668 cut -f 1-2 -d '|' < ${X} | 1669 sort -u > ${X}.nodes 1670 done 1671 1672 # Figure out which lines need to be removed from $1. 1673 if [ ${ALLOWDELETE} != "yes" ]; then 1674 comm -23 $1.nodes $2.nodes > $1.badnodes 1675 else 1676 : > $1.badnodes 1677 fi 1678 1679 # Remove the relevant lines from $1 1680 while read X; do 1681 look "${X}|" $1 1682 done < $1.badnodes | 1683 comm -13 - $1 > $1.tmp 1684 mv $1.tmp $1 1685 1686 rm $1.badnodes $1.nodes $2.nodes 1687} 1688 1689# If ${KEEPMODIFIEDMETADATA} == "yes", then for each entry in $2 1690# with metadata not matching any entry in $1, replace the corresponding 1691# line of $3 with one having the same metadata as the entry in $2. 1692fetch_filter_modified_metadata () { 1693 # Fish out the metadata from $1 and $2 1694 for X in $1 $2; do 1695 cut -f 1-6 -d '|' < ${X} > ${X}.metadata 1696 done 1697 1698 # Find the metadata we need to keep 1699 if [ ${KEEPMODIFIEDMETADATA} = "yes" ]; then 1700 comm -13 $1.metadata $2.metadata > keepmeta 1701 else 1702 : > keepmeta 1703 fi 1704 1705 # Extract the lines which we need to remove from $3, and 1706 # construct the lines which we need to add to $3. 1707 : > $3.remove 1708 : > $3.add 1709 while read LINE; do 1710 NODE=`echo "${LINE}" | cut -f 1-2 -d '|'` 1711 look "${NODE}|" $3 >> $3.remove 1712 look "${NODE}|" $3 | 1713 cut -f 7- -d '|' | 1714 lam -s "${LINE}|" - >> $3.add 1715 done < keepmeta 1716 1717 # Remove the specified lines and add the new lines. 1718 sort $3.remove | 1719 comm -13 - $3 | 1720 sort -u - $3.add > $3.tmp 1721 mv $3.tmp $3 1722 1723 rm keepmeta $1.metadata $2.metadata $3.add $3.remove 1724} 1725 1726# Remove lines from $1 and $2 which are identical; 1727# no need to update a file if it isn't changing. 1728fetch_filter_uptodate () { 1729 comm -23 $1 $2 > $1.tmp 1730 comm -13 $1 $2 > $2.tmp 1731 1732 mv $1.tmp $1 1733 mv $2.tmp $2 1734} 1735 1736# Fetch any "clean" old versions of files we need for merging changes. 1737fetch_files_premerge () { 1738 # We only need to do anything if $1 is non-empty. 1739 if [ -s $1 ]; then 1740 # Tell the user what we're doing 1741 echo -n "Fetching files from ${OLDRELNUM} for merging... " 1742 1743 # List of files wanted 1744 fgrep '|f|' < $1 | 1745 cut -f 3 -d '|' | 1746 sort -u > files.wanted 1747 1748 # Only fetch the files we don't already have 1749 while read Y; do 1750 if [ ! -f "files/${Y}.gz" ]; then 1751 echo ${Y}; 1752 fi 1753 done < files.wanted > filelist 1754 1755 # Actually fetch them 1756 lam -s "${OLDFETCHDIR}/f/" - -s ".gz" < filelist | 1757 xargs ${XARGST} ${PHTTPGET} ${SERVERNAME} \ 1758 2>${QUIETREDIR} 1759 1760 # Make sure we got them all, and move them into /files/ 1761 while read Y; do 1762 if ! [ -f ${Y}.gz ]; then 1763 echo "failed." 1764 return 1 1765 fi 1766 if [ `gunzip -c < ${Y}.gz | 1767 ${SHA256} -q` = ${Y} ]; then 1768 mv ${Y}.gz files/${Y}.gz 1769 else 1770 echo "${Y} has incorrect hash." 1771 return 1 1772 fi 1773 done < filelist 1774 echo "done." 1775 1776 # Clean up 1777 rm filelist files.wanted 1778 fi 1779} 1780 1781# Prepare to fetch files: Generate a list of the files we need, 1782# copy the unmodified files we have into /files/, and generate 1783# a list of patches to download. 1784fetch_files_prepare () { 1785 # Tell the user why his disk is suddenly making lots of noise 1786 echo -n "Preparing to download files... " 1787 1788 # Reduce indices to ${PATH}|${HASH} pairs 1789 for X in $1 $2 $3; do 1790 cut -f 1,2,7 -d '|' < ${X} | 1791 fgrep '|f|' | 1792 cut -f 1,3 -d '|' | 1793 sort > ${X}.hashes 1794 done 1795 1796 # List of files wanted 1797 cut -f 2 -d '|' < $3.hashes | 1798 sort -u | 1799 while read HASH; do 1800 if ! [ -f files/${HASH}.gz ]; then 1801 echo ${HASH} 1802 fi 1803 done > files.wanted 1804 1805 # Generate a list of unmodified files 1806 comm -12 $1.hashes $2.hashes | 1807 sort -k 1,1 -t '|' > unmodified.files 1808 1809 # Copy all files into /files/. We only need the unmodified files 1810 # for use in patching; but we'll want all of them if the user asks 1811 # to rollback the updates later. 1812 while read LINE; do 1813 F=`echo "${LINE}" | cut -f 1 -d '|'` 1814 HASH=`echo "${LINE}" | cut -f 2 -d '|'` 1815 1816 # Skip files we already have. 1817 if [ -f files/${HASH}.gz ]; then 1818 continue 1819 fi 1820 1821 # Make sure the file hasn't changed. 1822 cp "${BASEDIR}/${F}" tmpfile 1823 if [ `sha256 -q tmpfile` != ${HASH} ]; then 1824 echo 1825 echo "File changed while FreeBSD Update running: ${F}" 1826 return 1 1827 fi 1828 1829 # Place the file into storage. 1830 gzip -c < tmpfile > files/${HASH}.gz 1831 rm tmpfile 1832 done < $2.hashes 1833 1834 # Produce a list of patches to download 1835 sort -k 1,1 -t '|' $3.hashes | 1836 join -t '|' -o 2.2,1.2 - unmodified.files | 1837 fetch_make_patchlist > patchlist 1838 1839 # Garbage collect 1840 rm unmodified.files $1.hashes $2.hashes $3.hashes 1841 1842 # We don't need the list of possible old files any more. 1843 rm $1 1844 1845 # We're finished making noise 1846 echo "done." 1847} 1848 1849# Fetch files. 1850fetch_files () { 1851 # Attempt to fetch patches 1852 if [ -s patchlist ]; then 1853 echo -n "Fetching `wc -l < patchlist | tr -d ' '` " 1854 echo ${NDEBUG} "patches.${DDSTATS}" 1855 tr '|' '-' < patchlist | 1856 lam -s "${PATCHDIR}/" - | 1857 xargs ${XARGST} ${PHTTPGET} ${SERVERNAME} \ 1858 2>${STATSREDIR} | fetch_progress 1859 echo "done." 1860 1861 # Attempt to apply patches 1862 echo -n "Applying patches... " 1863 tr '|' ' ' < patchlist | 1864 while read X Y; do 1865 if [ ! -f "${X}-${Y}" ]; then continue; fi 1866 gunzip -c < files/${X}.gz > OLD 1867 1868 bspatch OLD NEW ${X}-${Y} 1869 1870 if [ `${SHA256} -q NEW` = ${Y} ]; then 1871 mv NEW files/${Y} 1872 gzip -n files/${Y} 1873 fi 1874 rm -f diff OLD NEW ${X}-${Y} 1875 done 2>${QUIETREDIR} 1876 echo "done." 1877 fi 1878 1879 # Download files which couldn't be generate via patching 1880 while read Y; do 1881 if [ ! -f "files/${Y}.gz" ]; then 1882 echo ${Y}; 1883 fi 1884 done < files.wanted > filelist 1885 1886 if [ -s filelist ]; then 1887 echo -n "Fetching `wc -l < filelist | tr -d ' '` " 1888 echo ${NDEBUG} "files... " 1889 lam -s "${FETCHDIR}/f/" - -s ".gz" < filelist | 1890 xargs ${XARGST} ${PHTTPGET} ${SERVERNAME} \ 1891 2>${QUIETREDIR} 1892 1893 while read Y; do 1894 if ! [ -f ${Y}.gz ]; then 1895 echo "failed." 1896 return 1 1897 fi 1898 if [ `gunzip -c < ${Y}.gz | 1899 ${SHA256} -q` = ${Y} ]; then 1900 mv ${Y}.gz files/${Y}.gz 1901 else 1902 echo "${Y} has incorrect hash." 1903 return 1 1904 fi 1905 done < filelist 1906 echo "done." 1907 fi 1908 1909 # Clean up 1910 rm files.wanted filelist patchlist 1911} 1912 1913# Create and populate install manifest directory; and report what updates 1914# are available. 1915fetch_create_manifest () { 1916 # If we have an existing install manifest, nuke it. 1917 if [ -L "${BDHASH}-install" ]; then 1918 rm -r ${BDHASH}-install/ 1919 rm ${BDHASH}-install 1920 fi 1921 1922 # Report to the user if any updates were avoided due to local changes 1923 if [ -s modifiedfiles ]; then 1924 echo 1925 echo -n "The following files are affected by updates, " 1926 echo "but no changes have" 1927 echo -n "been downloaded because the files have been " 1928 echo "modified locally:" 1929 cat modifiedfiles 1930 fi | $PAGER 1931 rm modifiedfiles 1932 1933 # If no files will be updated, tell the user and exit 1934 if ! [ -s INDEX-PRESENT ] && 1935 ! [ -s INDEX-NEW ]; then 1936 rm INDEX-PRESENT INDEX-NEW 1937 echo 1938 echo -n "No updates needed to update system to " 1939 echo "${RELNUM}-p${RELPATCHNUM}." 1940 return 1941 fi 1942 1943 # Divide files into (a) removed files, (b) added files, and 1944 # (c) updated files. 1945 cut -f 1 -d '|' < INDEX-PRESENT | 1946 sort > INDEX-PRESENT.flist 1947 cut -f 1 -d '|' < INDEX-NEW | 1948 sort > INDEX-NEW.flist 1949 comm -23 INDEX-PRESENT.flist INDEX-NEW.flist > files.removed 1950 comm -13 INDEX-PRESENT.flist INDEX-NEW.flist > files.added 1951 comm -12 INDEX-PRESENT.flist INDEX-NEW.flist > files.updated 1952 rm INDEX-PRESENT.flist INDEX-NEW.flist 1953 1954 # Report removed files, if any 1955 if [ -s files.removed ]; then 1956 echo 1957 echo -n "The following files will be removed " 1958 echo "as part of updating to ${RELNUM}-p${RELPATCHNUM}:" 1959 cat files.removed 1960 fi | $PAGER 1961 rm files.removed 1962 1963 # Report added files, if any 1964 if [ -s files.added ]; then 1965 echo 1966 echo -n "The following files will be added " 1967 echo "as part of updating to ${RELNUM}-p${RELPATCHNUM}:" 1968 cat files.added 1969 fi | $PAGER 1970 rm files.added 1971 1972 # Report updated files, if any 1973 if [ -s files.updated ]; then 1974 echo 1975 echo -n "The following files will be updated " 1976 echo "as part of updating to ${RELNUM}-p${RELPATCHNUM}:" 1977 1978 cat files.updated 1979 fi | $PAGER 1980 rm files.updated 1981 1982 # Create a directory for the install manifest. 1983 MDIR=`mktemp -d install.XXXXXX` || return 1 1984 1985 # Populate it 1986 mv INDEX-PRESENT ${MDIR}/INDEX-OLD 1987 mv INDEX-NEW ${MDIR}/INDEX-NEW 1988 1989 # Link it into place 1990 ln -s ${MDIR} ${BDHASH}-install 1991} 1992 1993# Warn about any upcoming EoL 1994fetch_warn_eol () { 1995 # What's the current time? 1996 NOWTIME=`date "+%s"` 1997 1998 # When did we last warn about the EoL date? 1999 if [ -f lasteolwarn ]; then 2000 LASTWARN=`cat lasteolwarn` 2001 else 2002 LASTWARN=`expr ${NOWTIME} - 63072000` 2003 fi 2004 2005 # If the EoL time is past, warn. 2006 if [ ${EOLTIME} -lt ${NOWTIME} ]; then 2007 echo 2008 cat <<-EOF 2009 WARNING: `uname -sr` HAS PASSED ITS END-OF-LIFE DATE. 2010 Any security issues discovered after `date -r ${EOLTIME}` 2011 will not have been corrected. 2012 EOF 2013 return 1 2014 fi 2015 2016 # Figure out how long it has been since we last warned about the 2017 # upcoming EoL, and how much longer we have left. 2018 SINCEWARN=`expr ${NOWTIME} - ${LASTWARN}` 2019 TIMELEFT=`expr ${EOLTIME} - ${NOWTIME}` 2020 2021 # Don't warn if the EoL is more than 3 months away 2022 if [ ${TIMELEFT} -gt 7884000 ]; then 2023 return 0 2024 fi 2025 2026 # Don't warn if the time remaining is more than 3 times the time 2027 # since the last warning. 2028 if [ ${TIMELEFT} -gt `expr ${SINCEWARN} \* 3` ]; then 2029 return 0 2030 fi 2031 2032 # Figure out what time units to use. 2033 if [ ${TIMELEFT} -lt 604800 ]; then 2034 UNIT="day" 2035 SIZE=86400 2036 elif [ ${TIMELEFT} -lt 2678400 ]; then 2037 UNIT="week" 2038 SIZE=604800 2039 else 2040 UNIT="month" 2041 SIZE=2678400 2042 fi 2043 2044 # Compute the right number of units 2045 NUM=`expr ${TIMELEFT} / ${SIZE}` 2046 if [ ${NUM} != 1 ]; then 2047 UNIT="${UNIT}s" 2048 fi 2049 2050 # Print the warning 2051 echo 2052 cat <<-EOF 2053 WARNING: `uname -sr` is approaching its End-of-Life date. 2054 It is strongly recommended that you upgrade to a newer 2055 release within the next ${NUM} ${UNIT}. 2056 EOF 2057 2058 # Update the stored time of last warning 2059 echo ${NOWTIME} > lasteolwarn 2060} 2061 2062# Do the actual work involved in "fetch" / "cron". 2063fetch_run () { 2064 workdir_init || return 1 2065 2066 # Prepare the mirror list. 2067 fetch_pick_server_init && fetch_pick_server 2068 2069 # Try to fetch the public key until we run out of servers. 2070 while ! fetch_key; do 2071 fetch_pick_server || return 1 2072 done 2073 2074 # Try to fetch the metadata index signature ("tag") until we run 2075 # out of available servers; and sanity check the downloaded tag. 2076 while ! fetch_tag; do 2077 fetch_pick_server || return 1 2078 done 2079 fetch_tagsanity || return 1 2080 2081 # Fetch the latest INDEX-NEW and INDEX-OLD files. 2082 fetch_metadata INDEX-NEW INDEX-OLD || return 1 2083 2084 # Generate filtered INDEX-NEW and INDEX-OLD files containing only 2085 # the lines which (a) belong to components we care about, and (b) 2086 # don't correspond to paths we're explicitly ignoring. 2087 fetch_filter_metadata INDEX-NEW || return 1 2088 fetch_filter_metadata INDEX-OLD || return 1 2089 2090 # Translate /boot/${KERNCONF} into ${KERNELDIR} 2091 fetch_filter_kernel_names INDEX-NEW ${KERNCONF} 2092 fetch_filter_kernel_names INDEX-OLD ${KERNCONF} 2093 2094 # For all paths appearing in INDEX-OLD or INDEX-NEW, inspect the 2095 # system and generate an INDEX-PRESENT file. 2096 fetch_inspect_system INDEX-OLD INDEX-PRESENT INDEX-NEW || return 1 2097 2098 # Based on ${UPDATEIFUNMODIFIED}, remove lines from INDEX-* which 2099 # correspond to lines in INDEX-PRESENT with hashes not appearing 2100 # in INDEX-OLD or INDEX-NEW. Also remove lines where the entry in 2101 # INDEX-PRESENT has type - and there isn't a corresponding entry in 2102 # INDEX-OLD with type -. 2103 fetch_filter_unmodified_notpresent \ 2104 INDEX-OLD INDEX-PRESENT INDEX-NEW /dev/null 2105 2106 # For each entry in INDEX-PRESENT of type -, remove any corresponding 2107 # entry from INDEX-NEW if ${ALLOWADD} != "yes". Remove all entries 2108 # of type - from INDEX-PRESENT. 2109 fetch_filter_allowadd INDEX-PRESENT INDEX-NEW 2110 2111 # If ${ALLOWDELETE} != "yes", then remove any entries from 2112 # INDEX-PRESENT which don't correspond to entries in INDEX-NEW. 2113 fetch_filter_allowdelete INDEX-PRESENT INDEX-NEW 2114 2115 # If ${KEEPMODIFIEDMETADATA} == "yes", then for each entry in 2116 # INDEX-PRESENT with metadata not matching any entry in INDEX-OLD, 2117 # replace the corresponding line of INDEX-NEW with one having the 2118 # same metadata as the entry in INDEX-PRESENT. 2119 fetch_filter_modified_metadata INDEX-OLD INDEX-PRESENT INDEX-NEW 2120 2121 # Remove lines from INDEX-PRESENT and INDEX-NEW which are identical; 2122 # no need to update a file if it isn't changing. 2123 fetch_filter_uptodate INDEX-PRESENT INDEX-NEW 2124 2125 # Prepare to fetch files: Generate a list of the files we need, 2126 # copy the unmodified files we have into /files/, and generate 2127 # a list of patches to download. 2128 fetch_files_prepare INDEX-OLD INDEX-PRESENT INDEX-NEW || return 1 2129 2130 # Fetch files. 2131 fetch_files || return 1 2132 2133 # Create and populate install manifest directory; and report what 2134 # updates are available. 2135 fetch_create_manifest || return 1 2136 2137 # Warn about any upcoming EoL 2138 fetch_warn_eol || return 1 2139} 2140 2141# If StrictComponents is not "yes", generate a new components list 2142# with only the components which appear to be installed. 2143upgrade_guess_components () { 2144 if [ "${STRICTCOMPONENTS}" = "no" ]; then 2145 # Generate filtered INDEX-ALL with only the components listed 2146 # in COMPONENTS. 2147 fetch_filter_metadata_components $1 || return 1 2148 2149 # Tell the user why his disk is suddenly making lots of noise 2150 echo -n "Inspecting system... " 2151 2152 # Look at the files on disk, and assume that a component is 2153 # supposed to be present if it is more than half-present. 2154 cut -f 1-3 -d '|' < INDEX-ALL | 2155 tr '|' ' ' | 2156 while read C S F; do 2157 if [ -e ${BASEDIR}/${F} ]; then 2158 echo "+ ${C}|${S}" 2159 fi 2160 echo "= ${C}|${S}" 2161 done | 2162 sort | 2163 uniq -c | 2164 sed -E 's,^ +,,' > compfreq 2165 grep ' = ' compfreq | 2166 cut -f 1,3 -d ' ' | 2167 sort -k 2,2 -t ' ' > compfreq.total 2168 grep ' + ' compfreq | 2169 cut -f 1,3 -d ' ' | 2170 sort -k 2,2 -t ' ' > compfreq.present 2171 join -t ' ' -1 2 -2 2 compfreq.present compfreq.total | 2172 while read S P T; do 2173 if [ ${P} -gt `expr ${T} / 2` ]; then 2174 echo ${S} 2175 fi 2176 done > comp.present 2177 cut -f 2 -d ' ' < compfreq.total > comp.total 2178 rm INDEX-ALL compfreq compfreq.total compfreq.present 2179 2180 # We're done making noise. 2181 echo "done." 2182 2183 # Sometimes the kernel isn't installed where INDEX-ALL 2184 # thinks that it should be: In particular, it is often in 2185 # /boot/kernel instead of /boot/GENERIC or /boot/SMP. To 2186 # deal with this, if "kernel|X" is listed in comp.total 2187 # (i.e., is a component which would be upgraded if it is 2188 # found to be present) we will add it to comp.present. 2189 # If "kernel|<anything>" is in comp.total but "kernel|X" is 2190 # not, we print a warning -- the user is running a kernel 2191 # which isn't part of the release. 2192 KCOMP=`echo ${KERNCONF} | tr 'A-Z' 'a-z'` 2193 grep -E "^kernel\|${KCOMP}\$" comp.total >> comp.present 2194 2195 if grep -qE "^kernel\|" comp.total && 2196 ! grep -qE "^kernel\|${KCOMP}\$" comp.total; then 2197 cat <<-EOF 2198 2199WARNING: This system is running a "${KCOMP}" kernel, which is not a 2200kernel configuration distributed as part of FreeBSD ${RELNUM}. 2201This kernel will not be updated: you MUST update the kernel manually 2202before running "$0 install". 2203 EOF 2204 fi 2205 2206 # Re-sort the list of installed components and generate 2207 # the list of non-installed components. 2208 sort -u < comp.present > comp.present.tmp 2209 mv comp.present.tmp comp.present 2210 comm -13 comp.present comp.total > comp.absent 2211 2212 # Ask the user to confirm that what we have is correct. To 2213 # reduce user confusion, translate "X|Y" back to "X/Y" (as 2214 # subcomponents must be listed in the configuration file). 2215 echo 2216 echo -n "The following components of FreeBSD " 2217 echo "seem to be installed:" 2218 tr '|' '/' < comp.present | 2219 fmt -72 2220 echo 2221 echo -n "The following components of FreeBSD " 2222 echo "do not seem to be installed:" 2223 tr '|' '/' < comp.absent | 2224 fmt -72 2225 echo 2226 continuep || return 1 2227 echo 2228 2229 # Suck the generated list of components into ${COMPONENTS}. 2230 # Note that comp.present.tmp is used due to issues with 2231 # pipelines and setting variables. 2232 COMPONENTS="" 2233 tr '|' '/' < comp.present > comp.present.tmp 2234 while read C; do 2235 COMPONENTS="${COMPONENTS} ${C}" 2236 done < comp.present.tmp 2237 2238 # Delete temporary files 2239 rm comp.present comp.present.tmp comp.absent comp.total 2240 fi 2241} 2242 2243# If StrictComponents is not "yes", COMPONENTS contains an entry 2244# corresponding to the currently running kernel, and said kernel 2245# does not exist in the new release, add "kernel/generic" to the 2246# list of components. 2247upgrade_guess_new_kernel () { 2248 if [ "${STRICTCOMPONENTS}" = "no" ]; then 2249 # Grab the unfiltered metadata file. 2250 METAHASH=`look "$1|" tINDEX.present | cut -f 2 -d '|'` 2251 gunzip -c < files/${METAHASH}.gz > $1.all 2252 2253 # If "kernel/${KCOMP}" is in ${COMPONENTS} and that component 2254 # isn't in $1.all, we need to add kernel/generic. 2255 for C in ${COMPONENTS}; do 2256 if [ ${C} = "kernel/${KCOMP}" ] && 2257 ! grep -qE "^kernel\|${KCOMP}\|" $1.all; then 2258 COMPONENTS="${COMPONENTS} kernel/generic" 2259 NKERNCONF="GENERIC" 2260 cat <<-EOF 2261 2262WARNING: This system is running a "${KCOMP}" kernel, which is not a 2263kernel configuration distributed as part of FreeBSD ${RELNUM}. 2264As part of upgrading to FreeBSD ${RELNUM}, this kernel will be 2265replaced with a "generic" kernel. 2266 EOF 2267 continuep || return 1 2268 fi 2269 done 2270 2271 # Don't need this any more... 2272 rm $1.all 2273 fi 2274} 2275 2276# Convert INDEX-OLD (last release) and INDEX-ALL (new release) into 2277# INDEX-OLD and INDEX-NEW files (in the sense of normal upgrades). 2278upgrade_oldall_to_oldnew () { 2279 # For each ${F}|... which appears in INDEX-ALL but does not appear 2280 # in INDEX-OLD, add ${F}|-|||||| to INDEX-OLD. 2281 cut -f 1 -d '|' < $1 | 2282 sort -u > $1.paths 2283 cut -f 1 -d '|' < $2 | 2284 sort -u | 2285 comm -13 $1.paths - | 2286 lam - -s "|-||||||" | 2287 sort - $1 > $1.tmp 2288 mv $1.tmp $1 2289 2290 # Remove lines from INDEX-OLD which also appear in INDEX-ALL 2291 comm -23 $1 $2 > $1.tmp 2292 mv $1.tmp $1 2293 2294 # Remove lines from INDEX-ALL which have a file name not appearing 2295 # anywhere in INDEX-OLD (since these must be files which haven't 2296 # changed -- if they were new, there would be an entry of type "-"). 2297 cut -f 1 -d '|' < $1 | 2298 sort -u > $1.paths 2299 sort -k 1,1 -t '|' < $2 | 2300 join -t '|' - $1.paths | 2301 sort > $2.tmp 2302 rm $1.paths 2303 mv $2.tmp $2 2304 2305 # Rename INDEX-ALL to INDEX-NEW. 2306 mv $2 $3 2307} 2308 2309# Helper for upgrade_merge: Return zero true iff the two files differ only 2310# in the contents of their RCS tags. 2311samef () { 2312 X=`sed -E 's/\\$FreeBSD.*\\$/\$FreeBSD\$/' < $1 | ${SHA256}` 2313 Y=`sed -E 's/\\$FreeBSD.*\\$/\$FreeBSD\$/' < $2 | ${SHA256}` 2314 2315 if [ $X = $Y ]; then 2316 return 0; 2317 else 2318 return 1; 2319 fi 2320} 2321 2322# From the list of "old" files in $1, merge changes in $2 with those in $3, 2323# and update $3 to reflect the hashes of merged files. 2324upgrade_merge () { 2325 # We only need to do anything if $1 is non-empty. 2326 if [ -s $1 ]; then 2327 cut -f 1 -d '|' $1 | 2328 sort > $1-paths 2329 2330 # Create staging area for merging files 2331 rm -rf merge/ 2332 while read F; do 2333 D=`dirname ${F}` 2334 mkdir -p merge/old/${D} 2335 mkdir -p merge/${OLDRELNUM}/${D} 2336 mkdir -p merge/${RELNUM}/${D} 2337 mkdir -p merge/new/${D} 2338 done < $1-paths 2339 2340 # Copy in files 2341 while read F; do 2342 # Currently installed file 2343 V=`look "${F}|" $2 | cut -f 7 -d '|'` 2344 gunzip < files/${V}.gz > merge/old/${F} 2345 2346 # Old release 2347 if look "${F}|" $1 | fgrep -q "|f|"; then 2348 V=`look "${F}|" $1 | cut -f 3 -d '|'` 2349 gunzip < files/${V}.gz \ 2350 > merge/${OLDRELNUM}/${F} 2351 fi 2352 2353 # New release 2354 if look "${F}|" $3 | cut -f 1,2,7 -d '|' | 2355 fgrep -q "|f|"; then 2356 V=`look "${F}|" $3 | cut -f 7 -d '|'` 2357 gunzip < files/${V}.gz \ 2358 > merge/${RELNUM}/${F} 2359 fi 2360 done < $1-paths 2361 2362 # Attempt to automatically merge changes 2363 echo -n "Attempting to automatically merge " 2364 echo -n "changes in files..." 2365 : > failed.merges 2366 while read F; do 2367 # If the file doesn't exist in the new release, 2368 # the result of "merging changes" is having the file 2369 # not exist. 2370 if ! [ -f merge/${RELNUM}/${F} ]; then 2371 continue 2372 fi 2373 2374 # If the file didn't exist in the old release, we're 2375 # going to throw away the existing file and hope that 2376 # the version from the new release is what we want. 2377 if ! [ -f merge/${OLDRELNUM}/${F} ]; then 2378 cp merge/${RELNUM}/${F} merge/new/${F} 2379 continue 2380 fi 2381 2382 # Some files need special treatment. 2383 case ${F} in 2384 /etc/spwd.db | /etc/pwd.db | /etc/login.conf.db) 2385 # Don't merge these -- we're rebuild them 2386 # after updates are installed. 2387 cp merge/old/${F} merge/new/${F} 2388 ;; 2389 *) 2390 if ! diff3 -E -m -L "current version" \ 2391 -L "${OLDRELNUM}" -L "${RELNUM}" \ 2392 merge/old/${F} \ 2393 merge/${OLDRELNUM}/${F} \ 2394 merge/${RELNUM}/${F} \ 2395 > merge/new/${F} 2>/dev/null; then 2396 echo ${F} >> failed.merges 2397 fi 2398 ;; 2399 esac 2400 done < $1-paths 2401 echo " done." 2402 2403 # Ask the user to handle any files which didn't merge. 2404 while read F; do 2405 # If the installed file differs from the version in 2406 # the old release only due to RCS tag expansion 2407 # then just use the version in the new release. 2408 if samef merge/old/${F} merge/${OLDRELNUM}/${F}; then 2409 cp merge/${RELNUM}/${F} merge/new/${F} 2410 continue 2411 fi 2412 2413 cat <<-EOF 2414 2415The following file could not be merged automatically: ${F} 2416Press Enter to edit this file in ${EDITOR} and resolve the conflicts 2417manually... 2418 EOF 2419 read dummy </dev/tty 2420 ${EDITOR} `pwd`/merge/new/${F} < /dev/tty 2421 done < failed.merges 2422 rm failed.merges 2423 2424 # Ask the user to confirm that he likes how the result 2425 # of merging files. 2426 while read F; do 2427 # Skip files which haven't changed except possibly 2428 # in their RCS tags. 2429 if [ -f merge/old/${F} ] && [ -f merge/new/${F} ] && 2430 samef merge/old/${F} merge/new/${F}; then 2431 continue 2432 fi 2433 2434 # Skip files where the installed file differs from 2435 # the old file only due to RCS tags. 2436 if [ -f merge/old/${F} ] && 2437 [ -f merge/${OLDRELNUM}/${F} ] && 2438 samef merge/old/${F} merge/${OLDRELNUM}/${F}; then 2439 continue 2440 fi 2441 2442 # Warn about files which are ceasing to exist. 2443 if ! [ -f merge/new/${F} ]; then 2444 cat <<-EOF 2445 2446The following file will be removed, as it no longer exists in 2447FreeBSD ${RELNUM}: ${F} 2448 EOF 2449 continuep < /dev/tty || return 1 2450 continue 2451 fi 2452 2453 # Print changes for the user's approval. 2454 cat <<-EOF 2455 2456The following changes, which occurred between FreeBSD ${OLDRELNUM} and 2457FreeBSD ${RELNUM} have been merged into ${F}: 2458EOF 2459 diff -U 5 -L "current version" -L "new version" \ 2460 merge/old/${F} merge/new/${F} || true 2461 continuep < /dev/tty || return 1 2462 done < $1-paths 2463 2464 # Store merged files. 2465 while read F; do 2466 if [ -f merge/new/${F} ]; then 2467 V=`${SHA256} -q merge/new/${F}` 2468 2469 gzip -c < merge/new/${F} > files/${V}.gz 2470 echo "${F}|${V}" 2471 fi 2472 done < $1-paths > newhashes 2473 2474 # Pull lines out from $3 which need to be updated to 2475 # reflect merged files. 2476 while read F; do 2477 look "${F}|" $3 2478 done < $1-paths > $3-oldlines 2479 2480 # Update lines to reflect merged files 2481 join -t '|' -o 1.1,1.2,1.3,1.4,1.5,1.6,2.2,1.8 \ 2482 $3-oldlines newhashes > $3-newlines 2483 2484 # Remove old lines from $3 and add new lines. 2485 sort $3-oldlines | 2486 comm -13 - $3 | 2487 sort - $3-newlines > $3.tmp 2488 mv $3.tmp $3 2489 2490 # Clean up 2491 rm $1-paths newhashes $3-oldlines $3-newlines 2492 rm -rf merge/ 2493 fi 2494 2495 # We're done with merging files. 2496 rm $1 2497} 2498 2499# Do the work involved in fetching upgrades to a new release 2500upgrade_run () { 2501 workdir_init || return 1 2502 2503 # Prepare the mirror list. 2504 fetch_pick_server_init && fetch_pick_server 2505 2506 # Try to fetch the public key until we run out of servers. 2507 while ! fetch_key; do 2508 fetch_pick_server || return 1 2509 done 2510 2511 # Try to fetch the metadata index signature ("tag") until we run 2512 # out of available servers; and sanity check the downloaded tag. 2513 while ! fetch_tag; do 2514 fetch_pick_server || return 1 2515 done 2516 fetch_tagsanity || return 1 2517 2518 # Fetch the INDEX-OLD and INDEX-ALL. 2519 fetch_metadata INDEX-OLD INDEX-ALL || return 1 2520 2521 # If StrictComponents is not "yes", generate a new components list 2522 # with only the components which appear to be installed. 2523 upgrade_guess_components INDEX-ALL || return 1 2524 2525 # Generate filtered INDEX-OLD and INDEX-ALL files containing only 2526 # the components we want and without anything marked as "Ignore". 2527 fetch_filter_metadata INDEX-OLD || return 1 2528 fetch_filter_metadata INDEX-ALL || return 1 2529 2530 # Merge the INDEX-OLD and INDEX-ALL files into INDEX-OLD. 2531 sort INDEX-OLD INDEX-ALL > INDEX-OLD.tmp 2532 mv INDEX-OLD.tmp INDEX-OLD 2533 rm INDEX-ALL 2534 2535 # Adjust variables for fetching files from the new release. 2536 OLDRELNUM=${RELNUM} 2537 RELNUM=${TARGETRELEASE} 2538 OLDFETCHDIR=${FETCHDIR} 2539 FETCHDIR=${RELNUM}/${ARCH} 2540 2541 # Try to fetch the NEW metadata index signature ("tag") until we run 2542 # out of available servers; and sanity check the downloaded tag. 2543 while ! fetch_tag; do 2544 fetch_pick_server || return 1 2545 done 2546 2547 # Fetch the new INDEX-ALL. 2548 fetch_metadata INDEX-ALL || return 1 2549 2550 # If StrictComponents is not "yes", COMPONENTS contains an entry 2551 # corresponding to the currently running kernel, and said kernel 2552 # does not exist in the new release, add "kernel/generic" to the 2553 # list of components. 2554 upgrade_guess_new_kernel INDEX-ALL || return 1 2555 2556 # Filter INDEX-ALL to contain only the components we want and without 2557 # anything marked as "Ignore". 2558 fetch_filter_metadata INDEX-ALL || return 1 2559 2560 # Convert INDEX-OLD (last release) and INDEX-ALL (new release) into 2561 # INDEX-OLD and INDEX-NEW files (in the sense of normal upgrades). 2562 upgrade_oldall_to_oldnew INDEX-OLD INDEX-ALL INDEX-NEW 2563 2564 # Translate /boot/${KERNCONF} or /boot/${NKERNCONF} into ${KERNELDIR} 2565 fetch_filter_kernel_names INDEX-NEW ${NKERNCONF} 2566 fetch_filter_kernel_names INDEX-OLD ${KERNCONF} 2567 2568 # For all paths appearing in INDEX-OLD or INDEX-NEW, inspect the 2569 # system and generate an INDEX-PRESENT file. 2570 fetch_inspect_system INDEX-OLD INDEX-PRESENT INDEX-NEW || return 1 2571 2572 # Based on ${MERGECHANGES}, generate a file tomerge-old with the 2573 # paths and hashes of old versions of files to merge. 2574 fetch_filter_mergechanges INDEX-OLD INDEX-PRESENT tomerge-old 2575 2576 # Based on ${UPDATEIFUNMODIFIED}, remove lines from INDEX-* which 2577 # correspond to lines in INDEX-PRESENT with hashes not appearing 2578 # in INDEX-OLD or INDEX-NEW. Also remove lines where the entry in 2579 # INDEX-PRESENT has type - and there isn't a corresponding entry in 2580 # INDEX-OLD with type -. 2581 fetch_filter_unmodified_notpresent \ 2582 INDEX-OLD INDEX-PRESENT INDEX-NEW tomerge-old 2583 2584 # For each entry in INDEX-PRESENT of type -, remove any corresponding 2585 # entry from INDEX-NEW if ${ALLOWADD} != "yes". Remove all entries 2586 # of type - from INDEX-PRESENT. 2587 fetch_filter_allowadd INDEX-PRESENT INDEX-NEW 2588 2589 # If ${ALLOWDELETE} != "yes", then remove any entries from 2590 # INDEX-PRESENT which don't correspond to entries in INDEX-NEW. 2591 fetch_filter_allowdelete INDEX-PRESENT INDEX-NEW 2592 2593 # If ${KEEPMODIFIEDMETADATA} == "yes", then for each entry in 2594 # INDEX-PRESENT with metadata not matching any entry in INDEX-OLD, 2595 # replace the corresponding line of INDEX-NEW with one having the 2596 # same metadata as the entry in INDEX-PRESENT. 2597 fetch_filter_modified_metadata INDEX-OLD INDEX-PRESENT INDEX-NEW 2598 2599 # Remove lines from INDEX-PRESENT and INDEX-NEW which are identical; 2600 # no need to update a file if it isn't changing. 2601 fetch_filter_uptodate INDEX-PRESENT INDEX-NEW 2602 2603 # Fetch "clean" files from the old release for merging changes. 2604 fetch_files_premerge tomerge-old 2605 2606 # Prepare to fetch files: Generate a list of the files we need, 2607 # copy the unmodified files we have into /files/, and generate 2608 # a list of patches to download. 2609 fetch_files_prepare INDEX-OLD INDEX-PRESENT INDEX-NEW || return 1 2610 2611 # Fetch patches from to-${RELNUM}/${ARCH}/bp/ 2612 PATCHDIR=to-${RELNUM}/${ARCH}/bp 2613 fetch_files || return 1 2614 2615 # Merge configuration file changes. 2616 upgrade_merge tomerge-old INDEX-PRESENT INDEX-NEW || return 1 2617 2618 # Create and populate install manifest directory; and report what 2619 # updates are available. 2620 fetch_create_manifest || return 1 2621 2622 # Leave a note behind to tell the "install" command that the kernel 2623 # needs to be installed before the world. 2624 touch ${BDHASH}-install/kernelfirst 2625 2626 # Remind the user that they need to run "freebsd-update install" 2627 # to install the downloaded bits, in case they didn't RTFM. 2628 echo "To install the downloaded upgrades, run \"$0 install\"." 2629} 2630 2631# Make sure that all the file hashes mentioned in $@ have corresponding 2632# gzipped files stored in /files/. 2633install_verify () { 2634 # Generate a list of hashes 2635 cat $@ | 2636 cut -f 2,7 -d '|' | 2637 grep -E '^f' | 2638 cut -f 2 -d '|' | 2639 sort -u > filelist 2640 2641 # Make sure all the hashes exist 2642 while read HASH; do 2643 if ! [ -f files/${HASH}.gz ]; then 2644 echo -n "Update files missing -- " 2645 echo "this should never happen." 2646 echo "Re-run '$0 fetch'." 2647 return 1 2648 fi 2649 done < filelist 2650 2651 # Clean up 2652 rm filelist 2653} 2654 2655# Remove the system immutable flag from files 2656install_unschg () { 2657 # Generate file list 2658 cat $@ | 2659 cut -f 1 -d '|' > filelist 2660 2661 # Remove flags 2662 while read F; do 2663 if ! [ -e ${BASEDIR}/${F} ]; then 2664 continue 2665 else 2666 echo ${BASEDIR}/${F} 2667 fi 2668 done < filelist | xargs chflags noschg || return 1 2669 2670 # Clean up 2671 rm filelist 2672} 2673 2674# Decide which directory name to use for kernel backups. 2675backup_kernel_finddir () { 2676 CNT=0 2677 while true ; do 2678 # Pathname does not exist, so it is OK use that name 2679 # for backup directory. 2680 if [ ! -e $BASEDIR/$BACKUPKERNELDIR ]; then 2681 return 0 2682 fi 2683 2684 # If directory do exist, we only use if it has our 2685 # marker file. 2686 if [ -d $BASEDIR/$BACKUPKERNELDIR -a \ 2687 -e $BASEDIR/$BACKUPKERNELDIR/.freebsd-update ]; then 2688 return 0 2689 fi 2690 2691 # We could not use current directory name, so add counter to 2692 # the end and try again. 2693 CNT=$((CNT + 1)) 2694 if [ $CNT -gt 9 ]; then 2695 echo "Could not find valid backup dir ($BASEDIR/$BACKUPKERNELDIR)" 2696 exit 1 2697 fi 2698 BACKUPKERNELDIR="`echo $BACKUPKERNELDIR | sed -Ee 's/[0-9]\$//'`" 2699 BACKUPKERNELDIR="${BACKUPKERNELDIR}${CNT}" 2700 done 2701} 2702 2703# Backup the current kernel using hardlinks, if not disabled by user. 2704# Since we delete all files in the directory used for previous backups 2705# we create a marker file called ".freebsd-update" in the directory so 2706# we can determine on the next run that the directory was created by 2707# freebsd-update and we then do not accidentally remove user files in 2708# the unlikely case that the user has created a directory with a 2709# conflicting name. 2710backup_kernel () { 2711 # Only make kernel backup is so configured. 2712 if [ $BACKUPKERNEL != yes ]; then 2713 return 0 2714 fi 2715 2716 # Decide which directory name to use for kernel backups. 2717 backup_kernel_finddir 2718 2719 # Remove old kernel backup files. If $BACKUPKERNELDIR was 2720 # "not ours", backup_kernel_finddir would have exited, so 2721 # deleting the directory content is as safe as we can make it. 2722 if [ -d $BASEDIR/$BACKUPKERNELDIR ]; then 2723 rm -fr $BASEDIR/$BACKUPKERNELDIR 2724 fi 2725 2726 # Create directories for backup. 2727 mkdir -p $BASEDIR/$BACKUPKERNELDIR 2728 mtree -cdn -p "${BASEDIR}/${KERNELDIR}" | \ 2729 mtree -Ue -p "${BASEDIR}/${BACKUPKERNELDIR}" > /dev/null 2730 2731 # Mark the directory as having been created by freebsd-update. 2732 touch $BASEDIR/$BACKUPKERNELDIR/.freebsd-update 2733 if [ $? -ne 0 ]; then 2734 echo "Could not create kernel backup directory" 2735 exit 1 2736 fi 2737 2738 # Disable pathname expansion to be sure *.symbols is not 2739 # expanded. 2740 set -f 2741 2742 # Use find to ignore symbol files, unless disabled by user. 2743 if [ $BACKUPKERNELSYMBOLFILES = yes ]; then 2744 FINDFILTER="" 2745 else 2746 FINDFILTER="-a ! -name *.debug -a ! -name *.symbols" 2747 fi 2748 2749 # Backup all the kernel files using hardlinks. 2750 (cd ${BASEDIR}/${KERNELDIR} && find . -type f $FINDFILTER -exec \ 2751 cp -pl '{}' ${BASEDIR}/${BACKUPKERNELDIR}/'{}' \;) 2752 2753 # Re-enable patchname expansion. 2754 set +f 2755} 2756 2757# Install new files 2758install_from_index () { 2759 # First pass: Do everything apart from setting file flags. We 2760 # can't set flags yet, because schg inhibits hard linking. 2761 sort -k 1,1 -t '|' $1 | 2762 tr '|' ' ' | 2763 while read FPATH TYPE OWNER GROUP PERM FLAGS HASH LINK; do 2764 case ${TYPE} in 2765 d) 2766 # Create a directory 2767 install -d -o ${OWNER} -g ${GROUP} \ 2768 -m ${PERM} ${BASEDIR}/${FPATH} 2769 ;; 2770 f) 2771 if [ -z "${LINK}" ]; then 2772 # Create a file, without setting flags. 2773 gunzip < files/${HASH}.gz > ${HASH} 2774 install -S -o ${OWNER} -g ${GROUP} \ 2775 -m ${PERM} ${HASH} ${BASEDIR}/${FPATH} 2776 rm ${HASH} 2777 else 2778 # Create a hard link. 2779 ln -f ${BASEDIR}/${LINK} ${BASEDIR}/${FPATH} 2780 fi 2781 ;; 2782 L) 2783 # Create a symlink 2784 ln -sfh ${HASH} ${BASEDIR}/${FPATH} 2785 ;; 2786 esac 2787 done 2788 2789 # Perform a second pass, adding file flags. 2790 tr '|' ' ' < $1 | 2791 while read FPATH TYPE OWNER GROUP PERM FLAGS HASH LINK; do 2792 if [ ${TYPE} = "f" ] && 2793 ! [ ${FLAGS} = "0" ]; then 2794 chflags ${FLAGS} ${BASEDIR}/${FPATH} 2795 fi 2796 done 2797} 2798 2799# Remove files which we want to delete 2800install_delete () { 2801 # Generate list of new files 2802 cut -f 1 -d '|' < $2 | 2803 sort > newfiles 2804 2805 # Generate subindex of old files we want to nuke 2806 sort -k 1,1 -t '|' $1 | 2807 join -t '|' -v 1 - newfiles | 2808 sort -r -k 1,1 -t '|' | 2809 cut -f 1,2 -d '|' | 2810 tr '|' ' ' > killfiles 2811 2812 # Remove the offending bits 2813 while read FPATH TYPE; do 2814 case ${TYPE} in 2815 d) 2816 rmdir ${BASEDIR}/${FPATH} 2817 ;; 2818 f) 2819 rm ${BASEDIR}/${FPATH} 2820 ;; 2821 L) 2822 rm ${BASEDIR}/${FPATH} 2823 ;; 2824 esac 2825 done < killfiles 2826 2827 # Clean up 2828 rm newfiles killfiles 2829} 2830 2831# Install new files, delete old files, and update linker.hints 2832install_files () { 2833 # If we haven't already dealt with the kernel, deal with it. 2834 if ! [ -f $1/kerneldone ]; then 2835 grep -E '^/boot/' $1/INDEX-OLD > INDEX-OLD 2836 grep -E '^/boot/' $1/INDEX-NEW > INDEX-NEW 2837 2838 # Backup current kernel before installing a new one 2839 backup_kernel || return 1 2840 2841 # Install new files 2842 install_from_index INDEX-NEW || return 1 2843 2844 # Remove files which need to be deleted 2845 install_delete INDEX-OLD INDEX-NEW || return 1 2846 2847 # Update linker.hints if necessary 2848 if [ -s INDEX-OLD -o -s INDEX-NEW ]; then 2849 kldxref -R ${BASEDIR}/boot/ 2>/dev/null 2850 fi 2851 2852 # We've finished updating the kernel. 2853 touch $1/kerneldone 2854 2855 # Do we need to ask for a reboot now? 2856 if [ -f $1/kernelfirst ] && 2857 [ -s INDEX-OLD -o -s INDEX-NEW ]; then 2858 cat <<-EOF 2859 2860Kernel updates have been installed. Please reboot and run 2861"$0 install" again to finish installing updates. 2862 EOF 2863 exit 0 2864 fi 2865 fi 2866 2867 # If we haven't already dealt with the world, deal with it. 2868 if ! [ -f $1/worlddone ]; then 2869 # Create any necessary directories first 2870 grep -vE '^/boot/' $1/INDEX-NEW | 2871 grep -E '^[^|]+\|d\|' > INDEX-NEW 2872 install_from_index INDEX-NEW || return 1 2873 2874 # Install new runtime linker 2875 grep -vE '^/boot/' $1/INDEX-NEW | 2876 grep -vE '^[^|]+\|d\|' | 2877 grep -E '^/libexec/ld-elf[^|]*\.so\.[0-9]+\|' > INDEX-NEW 2878 install_from_index INDEX-NEW || return 1 2879 2880 # Install new shared libraries next 2881 grep -vE '^/boot/' $1/INDEX-NEW | 2882 grep -vE '^[^|]+\|d\|' | 2883 grep -vE '^/libexec/ld-elf[^|]*\.so\.[0-9]+\|' | 2884 grep -E '^[^|]*/lib/[^|]*\.so\.[0-9]+\|' > INDEX-NEW 2885 install_from_index INDEX-NEW || return 1 2886 2887 # Deal with everything else 2888 grep -vE '^/boot/' $1/INDEX-OLD | 2889 grep -vE '^[^|]+\|d\|' | 2890 grep -vE '^/libexec/ld-elf[^|]*\.so\.[0-9]+\|' | 2891 grep -vE '^[^|]*/lib/[^|]*\.so\.[0-9]+\|' > INDEX-OLD 2892 grep -vE '^/boot/' $1/INDEX-NEW | 2893 grep -vE '^[^|]+\|d\|' | 2894 grep -vE '^/libexec/ld-elf[^|]*\.so\.[0-9]+\|' | 2895 grep -vE '^[^|]*/lib/[^|]*\.so\.[0-9]+\|' > INDEX-NEW 2896 install_from_index INDEX-NEW || return 1 2897 install_delete INDEX-OLD INDEX-NEW || return 1 2898 2899 # Rebuild /etc/spwd.db and /etc/pwd.db if necessary. 2900 if [ ${BASEDIR}/etc/master.passwd -nt ${BASEDIR}/etc/spwd.db ] || 2901 [ ${BASEDIR}/etc/master.passwd -nt ${BASEDIR}/etc/pwd.db ]; then 2902 pwd_mkdb -d ${BASEDIR}/etc ${BASEDIR}/etc/master.passwd 2903 fi 2904 2905 # Rebuild /etc/login.conf.db if necessary. 2906 if [ ${BASEDIR}/etc/login.conf -nt ${BASEDIR}/etc/login.conf.db ]; then 2907 cap_mkdb ${BASEDIR}/etc/login.conf 2908 fi 2909 2910 # We've finished installing the world and deleting old files 2911 # which are not shared libraries. 2912 touch $1/worlddone 2913 2914 # Do we need to ask the user to portupgrade now? 2915 grep -vE '^/boot/' $1/INDEX-NEW | 2916 grep -E '^[^|]*/lib/[^|]*\.so\.[0-9]+\|' | 2917 cut -f 1 -d '|' | 2918 sort > newfiles 2919 if grep -vE '^/boot/' $1/INDEX-OLD | 2920 grep -E '^[^|]*/lib/[^|]*\.so\.[0-9]+\|' | 2921 cut -f 1 -d '|' | 2922 sort | 2923 join -v 1 - newfiles | 2924 grep -q .; then 2925 cat <<-EOF 2926 2927Completing this upgrade requires removing old shared object files. 2928Please rebuild all installed 3rd party software (e.g., programs 2929installed from the ports tree) and then run "$0 install" 2930again to finish installing updates. 2931 EOF 2932 rm newfiles 2933 exit 0 2934 fi 2935 rm newfiles 2936 fi 2937 2938 # Remove old shared libraries 2939 grep -vE '^/boot/' $1/INDEX-NEW | 2940 grep -vE '^[^|]+\|d\|' | 2941 grep -E '^[^|]*/lib/[^|]*\.so\.[0-9]+\|' > INDEX-NEW 2942 grep -vE '^/boot/' $1/INDEX-OLD | 2943 grep -vE '^[^|]+\|d\|' | 2944 grep -E '^[^|]*/lib/[^|]*\.so\.[0-9]+\|' > INDEX-OLD 2945 install_delete INDEX-OLD INDEX-NEW || return 1 2946 2947 # Remove old directories 2948 grep -vE '^/boot/' $1/INDEX-NEW | 2949 grep -E '^[^|]+\|d\|' > INDEX-NEW 2950 grep -vE '^/boot/' $1/INDEX-OLD | 2951 grep -E '^[^|]+\|d\|' > INDEX-OLD 2952 install_delete INDEX-OLD INDEX-NEW || return 1 2953 2954 # Remove temporary files 2955 rm INDEX-OLD INDEX-NEW 2956} 2957 2958# Rearrange bits to allow the installed updates to be rolled back 2959install_setup_rollback () { 2960 # Remove the "reboot after installing kernel", "kernel updated", and 2961 # "finished installing the world" flags if present -- they are 2962 # irrelevant when rolling back updates. 2963 if [ -f ${BDHASH}-install/kernelfirst ]; then 2964 rm ${BDHASH}-install/kernelfirst 2965 rm ${BDHASH}-install/kerneldone 2966 fi 2967 if [ -f ${BDHASH}-install/worlddone ]; then 2968 rm ${BDHASH}-install/worlddone 2969 fi 2970 2971 if [ -L ${BDHASH}-rollback ]; then 2972 mv ${BDHASH}-rollback ${BDHASH}-install/rollback 2973 fi 2974 2975 mv ${BDHASH}-install ${BDHASH}-rollback 2976} 2977 2978# Actually install updates 2979install_run () { 2980 echo -n "Installing updates..." 2981 2982 # Make sure we have all the files we should have 2983 install_verify ${BDHASH}-install/INDEX-OLD \ 2984 ${BDHASH}-install/INDEX-NEW || return 1 2985 2986 # Remove system immutable flag from files 2987 install_unschg ${BDHASH}-install/INDEX-OLD \ 2988 ${BDHASH}-install/INDEX-NEW || return 1 2989 2990 # Install new files, delete old files, and update linker.hints 2991 install_files ${BDHASH}-install || return 1 2992 2993 # Rearrange bits to allow the installed updates to be rolled back 2994 install_setup_rollback 2995 2996 echo " done." 2997} 2998 2999# Rearrange bits to allow the previous set of updates to be rolled back next. 3000rollback_setup_rollback () { 3001 if [ -L ${BDHASH}-rollback/rollback ]; then 3002 mv ${BDHASH}-rollback/rollback rollback-tmp 3003 rm -r ${BDHASH}-rollback/ 3004 rm ${BDHASH}-rollback 3005 mv rollback-tmp ${BDHASH}-rollback 3006 else 3007 rm -r ${BDHASH}-rollback/ 3008 rm ${BDHASH}-rollback 3009 fi 3010} 3011 3012# Install old files, delete new files, and update linker.hints 3013rollback_files () { 3014 # Install old shared library files which don't have the same path as 3015 # a new shared library file. 3016 grep -vE '^/boot/' $1/INDEX-NEW | 3017 grep -E '/lib/.*\.so\.[0-9]+\|' | 3018 cut -f 1 -d '|' | 3019 sort > INDEX-NEW.libs.flist 3020 grep -vE '^/boot/' $1/INDEX-OLD | 3021 grep -E '/lib/.*\.so\.[0-9]+\|' | 3022 sort -k 1,1 -t '|' - | 3023 join -t '|' -v 1 - INDEX-NEW.libs.flist > INDEX-OLD 3024 install_from_index INDEX-OLD || return 1 3025 3026 # Deal with files which are neither kernel nor shared library 3027 grep -vE '^/boot/' $1/INDEX-OLD | 3028 grep -vE '/lib/.*\.so\.[0-9]+\|' > INDEX-OLD 3029 grep -vE '^/boot/' $1/INDEX-NEW | 3030 grep -vE '/lib/.*\.so\.[0-9]+\|' > INDEX-NEW 3031 install_from_index INDEX-OLD || return 1 3032 install_delete INDEX-NEW INDEX-OLD || return 1 3033 3034 # Install any old shared library files which we didn't install above. 3035 grep -vE '^/boot/' $1/INDEX-OLD | 3036 grep -E '/lib/.*\.so\.[0-9]+\|' | 3037 sort -k 1,1 -t '|' - | 3038 join -t '|' - INDEX-NEW.libs.flist > INDEX-OLD 3039 install_from_index INDEX-OLD || return 1 3040 3041 # Delete unneeded shared library files 3042 grep -vE '^/boot/' $1/INDEX-OLD | 3043 grep -E '/lib/.*\.so\.[0-9]+\|' > INDEX-OLD 3044 grep -vE '^/boot/' $1/INDEX-NEW | 3045 grep -E '/lib/.*\.so\.[0-9]+\|' > INDEX-NEW 3046 install_delete INDEX-NEW INDEX-OLD || return 1 3047 3048 # Deal with kernel files 3049 grep -E '^/boot/' $1/INDEX-OLD > INDEX-OLD 3050 grep -E '^/boot/' $1/INDEX-NEW > INDEX-NEW 3051 install_from_index INDEX-OLD || return 1 3052 install_delete INDEX-NEW INDEX-OLD || return 1 3053 if [ -s INDEX-OLD -o -s INDEX-NEW ]; then 3054 kldxref -R /boot/ 2>/dev/null 3055 fi 3056 3057 # Remove temporary files 3058 rm INDEX-OLD INDEX-NEW INDEX-NEW.libs.flist 3059} 3060 3061# Actually rollback updates 3062rollback_run () { 3063 echo -n "Uninstalling updates..." 3064 3065 # If there are updates waiting to be installed, remove them; we 3066 # want the user to re-run 'fetch' after rolling back updates. 3067 if [ -L ${BDHASH}-install ]; then 3068 rm -r ${BDHASH}-install/ 3069 rm ${BDHASH}-install 3070 fi 3071 3072 # Make sure we have all the files we should have 3073 install_verify ${BDHASH}-rollback/INDEX-NEW \ 3074 ${BDHASH}-rollback/INDEX-OLD || return 1 3075 3076 # Remove system immutable flag from files 3077 install_unschg ${BDHASH}-rollback/INDEX-NEW \ 3078 ${BDHASH}-rollback/INDEX-OLD || return 1 3079 3080 # Install old files, delete new files, and update linker.hints 3081 rollback_files ${BDHASH}-rollback || return 1 3082 3083 # Remove the rollback directory and the symlink pointing to it; and 3084 # rearrange bits to allow the previous set of updates to be rolled 3085 # back next. 3086 rollback_setup_rollback 3087 3088 echo " done." 3089} 3090 3091# Compare INDEX-ALL and INDEX-PRESENT and print warnings about differences. 3092IDS_compare () { 3093 # Get all the lines which mismatch in something other than file 3094 # flags. We ignore file flags because sysinstall doesn't seem to 3095 # set them when it installs FreeBSD; warning about these adds a 3096 # very large amount of noise. 3097 cut -f 1-5,7-8 -d '|' $1 > $1.noflags 3098 sort -k 1,1 -t '|' $1.noflags > $1.sorted 3099 cut -f 1-5,7-8 -d '|' $2 | 3100 comm -13 $1.noflags - | 3101 fgrep -v '|-|||||' | 3102 sort -k 1,1 -t '|' | 3103 join -t '|' $1.sorted - > INDEX-NOTMATCHING 3104 3105 # Ignore files which match IDSIGNOREPATHS. 3106 for X in ${IDSIGNOREPATHS}; do 3107 grep -E "^${X}" INDEX-NOTMATCHING 3108 done | 3109 sort -u | 3110 comm -13 - INDEX-NOTMATCHING > INDEX-NOTMATCHING.tmp 3111 mv INDEX-NOTMATCHING.tmp INDEX-NOTMATCHING 3112 3113 # Go through the lines and print warnings. 3114 local IFS='|' 3115 while read FPATH TYPE OWNER GROUP PERM HASH LINK P_TYPE P_OWNER P_GROUP P_PERM P_HASH P_LINK; do 3116 # Warn about different object types. 3117 if ! [ "${TYPE}" = "${P_TYPE}" ]; then 3118 echo -n "${FPATH} is a " 3119 case "${P_TYPE}" in 3120 f) echo -n "regular file, " 3121 ;; 3122 d) echo -n "directory, " 3123 ;; 3124 L) echo -n "symlink, " 3125 ;; 3126 esac 3127 echo -n "but should be a " 3128 case "${TYPE}" in 3129 f) echo -n "regular file." 3130 ;; 3131 d) echo -n "directory." 3132 ;; 3133 L) echo -n "symlink." 3134 ;; 3135 esac 3136 echo 3137 3138 # Skip other tests, since they don't make sense if 3139 # we're comparing different object types. 3140 continue 3141 fi 3142 3143 # Warn about different owners. 3144 if ! [ "${OWNER}" = "${P_OWNER}" ]; then 3145 echo -n "${FPATH} is owned by user id ${P_OWNER}, " 3146 echo "but should be owned by user id ${OWNER}." 3147 fi 3148 3149 # Warn about different groups. 3150 if ! [ "${GROUP}" = "${P_GROUP}" ]; then 3151 echo -n "${FPATH} is owned by group id ${P_GROUP}, " 3152 echo "but should be owned by group id ${GROUP}." 3153 fi 3154 3155 # Warn about different permissions. We do not warn about 3156 # different permissions on symlinks, since some archivers 3157 # don't extract symlink permissions correctly and they are 3158 # ignored anyway. 3159 if ! [ "${PERM}" = "${P_PERM}" ] && 3160 ! [ "${TYPE}" = "L" ]; then 3161 echo -n "${FPATH} has ${P_PERM} permissions, " 3162 echo "but should have ${PERM} permissions." 3163 fi 3164 3165 # Warn about different file hashes / symlink destinations. 3166 if ! [ "${HASH}" = "${P_HASH}" ]; then 3167 if [ "${TYPE}" = "L" ]; then 3168 echo -n "${FPATH} is a symlink to ${P_HASH}, " 3169 echo "but should be a symlink to ${HASH}." 3170 fi 3171 if [ "${TYPE}" = "f" ]; then 3172 echo -n "${FPATH} has SHA256 hash ${P_HASH}, " 3173 echo "but should have SHA256 hash ${HASH}." 3174 fi 3175 fi 3176 3177 # We don't warn about different hard links, since some 3178 # some archivers break hard links, and as long as the 3179 # underlying data is correct they really don't matter. 3180 done < INDEX-NOTMATCHING 3181 3182 # Clean up 3183 rm $1 $1.noflags $1.sorted $2 INDEX-NOTMATCHING 3184} 3185 3186# Do the work involved in comparing the system to a "known good" index 3187IDS_run () { 3188 workdir_init || return 1 3189 3190 # Prepare the mirror list. 3191 fetch_pick_server_init && fetch_pick_server 3192 3193 # Try to fetch the public key until we run out of servers. 3194 while ! fetch_key; do 3195 fetch_pick_server || return 1 3196 done 3197 3198 # Try to fetch the metadata index signature ("tag") until we run 3199 # out of available servers; and sanity check the downloaded tag. 3200 while ! fetch_tag; do 3201 fetch_pick_server || return 1 3202 done 3203 fetch_tagsanity || return 1 3204 3205 # Fetch INDEX-OLD and INDEX-ALL. 3206 fetch_metadata INDEX-OLD INDEX-ALL || return 1 3207 3208 # Generate filtered INDEX-OLD and INDEX-ALL files containing only 3209 # the components we want and without anything marked as "Ignore". 3210 fetch_filter_metadata INDEX-OLD || return 1 3211 fetch_filter_metadata INDEX-ALL || return 1 3212 3213 # Merge the INDEX-OLD and INDEX-ALL files into INDEX-ALL. 3214 sort INDEX-OLD INDEX-ALL > INDEX-ALL.tmp 3215 mv INDEX-ALL.tmp INDEX-ALL 3216 rm INDEX-OLD 3217 3218 # Translate /boot/${KERNCONF} to ${KERNELDIR} 3219 fetch_filter_kernel_names INDEX-ALL ${KERNCONF} 3220 3221 # Inspect the system and generate an INDEX-PRESENT file. 3222 fetch_inspect_system INDEX-ALL INDEX-PRESENT /dev/null || return 1 3223 3224 # Compare INDEX-ALL and INDEX-PRESENT and print warnings about any 3225 # differences. 3226 IDS_compare INDEX-ALL INDEX-PRESENT 3227} 3228 3229#### Main functions -- call parameter-handling and core functions 3230 3231# Using the command line, configuration file, and defaults, 3232# set all the parameters which are needed later. 3233get_params () { 3234 init_params 3235 parse_cmdline $@ 3236 parse_conffile 3237 default_params 3238} 3239 3240# Fetch command. Make sure that we're being called 3241# interactively, then run fetch_check_params and fetch_run 3242cmd_fetch () { 3243 if [ ! -t 0 -a $NOTTYOK -eq 0 ]; then 3244 echo -n "`basename $0` fetch should not " 3245 echo "be run non-interactively." 3246 echo "Run `basename $0` cron instead." 3247 exit 1 3248 fi 3249 fetch_check_params 3250 fetch_run || exit 1 3251 ISFETCHED=1 3252} 3253 3254# Cron command. Make sure the parameters are sensible; wait 3255# rand(3600) seconds; then fetch updates. While fetching updates, 3256# send output to a temporary file; only print that file if the 3257# fetching failed. 3258cmd_cron () { 3259 fetch_check_params 3260 sleep `jot -r 1 0 3600` 3261 3262 TMPFILE=`mktemp /tmp/freebsd-update.XXXXXX` || exit 1 3263 if ! fetch_run >> ${TMPFILE} || 3264 ! grep -q "No updates needed" ${TMPFILE} || 3265 [ ${VERBOSELEVEL} = "debug" ]; then 3266 mail -s "`hostname` security updates" ${MAILTO} < ${TMPFILE} 3267 fi 3268 3269 rm ${TMPFILE} 3270} 3271 3272# Fetch files for upgrading to a new release. 3273cmd_upgrade () { 3274 upgrade_check_params 3275 upgrade_run || exit 1 3276} 3277 3278# Install downloaded updates. 3279cmd_install () { 3280 install_check_params 3281 install_run || exit 1 3282} 3283 3284# Rollback most recently installed updates. 3285cmd_rollback () { 3286 rollback_check_params 3287 rollback_run || exit 1 3288} 3289 3290# Compare system against a "known good" index. 3291cmd_IDS () { 3292 IDS_check_params 3293 IDS_run || exit 1 3294} 3295 3296#### Entry point 3297 3298# Make sure we find utilities from the base system 3299export PATH=/sbin:/bin:/usr/sbin:/usr/bin:${PATH} 3300 3301# Set a pager if the user doesn't 3302if [ -z "$PAGER" ]; then 3303 PAGER=/usr/bin/more 3304fi 3305 3306# Set LC_ALL in order to avoid problems with character ranges like [A-Z]. 3307export LC_ALL=C 3308 3309get_params $@ 3310for COMMAND in ${COMMANDS}; do 3311 cmd_${COMMAND} 3312done 3313