[BACK]Return to install-sh CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libiconv / build-aux

Diff for /embedaddon/libiconv/build-aux/install-sh between versions 1.1.1.1 and 1.1.1.2

version 1.1.1.1, 2012/02/21 22:57:49 version 1.1.1.2, 2021/03/17 13:38:46
Line 1 Line 1
 #!/bin/sh  #!/bin/sh
 # install - install a program, script, or datafile  # install - install a program, script, or datafile
   
scriptversion=2005-02-02.21scriptversion=2018-03-11.20; # UTC
   
 # This originates from X11R5 (mit/util/scripts/install.sh), which was  # This originates from X11R5 (mit/util/scripts/install.sh), which was
 # later released in X11R6 (xc/config/util/install.sh) with the  # later released in X11R6 (xc/config/util/install.sh) with the
Line 35  scriptversion=2005-02-02.21 Line 35  scriptversion=2005-02-02.21
 # FSF changes to this file are in the public domain.  # FSF changes to this file are in the public domain.
 #  #
 # Calling this script install-sh is preferred over install.sh, to prevent  # Calling this script install-sh is preferred over install.sh, to prevent
# `make' implicit rules from creating a file called install from it# 'make' implicit rules from creating a file called install from it
 # when there is no Makefile.  # when there is no Makefile.
 #  #
 # This script is compatible with the BSD install script, but was written  # This script is compatible with the BSD install script, but was written
# from scratch.  It can only install one file at a time, a restriction# from scratch.
# shared with many OS's install programs. 
   
# set DOITPROG to echo to test this scripttab='   '
 nl='
 '
 IFS=" $tab$nl"
   
# Don't use :- since 4.3BSD and earlier shells don't like it.# Set DOITPROG to "echo" to test this script.
doit="${DOITPROG-}" 
   
# put in absolute paths if you don't have them in your path; or use env. vars.doit=${DOITPROG-}
 doit_exec=${doit:-exec}
   
mvprog="${MVPROG-mv}"# Put in absolute file names if you don't have them in your path;
cpprog="${CPPROG-cp}"# or use environment vars.
chmodprog="${CHMODPROG-chmod}" 
chownprog="${CHOWNPROG-chown}" 
chgrpprog="${CHGRPPROG-chgrp}" 
stripprog="${STRIPPROG-strip}" 
rmprog="${RMPROG-rm}" 
mkdirprog="${MKDIRPROG-mkdir}" 
   
chmodcmd="$chmodprog 0755"chgrpprog=${CHGRPPROG-chgrp}
chowncmd=chmodprog=${CHMODPROG-chmod}
 chownprog=${CHOWNPROG-chown}
 cmpprog=${CMPPROG-cmp}
 cpprog=${CPPROG-cp}
 mkdirprog=${MKDIRPROG-mkdir}
 mvprog=${MVPROG-mv}
 rmprog=${RMPROG-rm}
 stripprog=${STRIPPROG-strip}
 
 posix_mkdir=
 
 # Desired mode of installed file.
 mode=0755
 
 chgrpcmd=  chgrpcmd=
stripcmd=chmodcmd=$chmodprog
 chowncmd=
 mvcmd=$mvprog
 rmcmd="$rmprog -f"  rmcmd="$rmprog -f"
mvcmd="$mvprog"stripcmd=
 
 src=  src=
 dst=  dst=
 dir_arg=  dir_arg=
dstarg=dst_arg=
no_target_directory= 
   
usage="Usage: $0 [OPTION]... [-T] SRCFILE DSTFILEcopy_on_change=false
 is_target_a_directory=possibly
 
 usage="\
 Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
    or: $0 [OPTION]... SRCFILES... DIRECTORY     or: $0 [OPTION]... SRCFILES... DIRECTORY
    or: $0 [OPTION]... -t DIRECTORY SRCFILES...     or: $0 [OPTION]... -t DIRECTORY SRCFILES...
    or: $0 [OPTION]... -d DIRECTORIES...     or: $0 [OPTION]... -d DIRECTORIES...
Line 80  In the 2nd and 3rd, copy all SRCFILES to DIRECTORY. Line 95  In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
 In the 4th, create DIRECTORIES.  In the 4th, create DIRECTORIES.
   
 Options:  Options:
-c         (ignored)     --help     display this help and exit.
-d         create directories instead of installing files.     --version  display version info and exit.
-g GROUP   $chgrpprog installed files to GROUP. 
-m MODE    $chmodprog installed files to MODE. 
-o USER    $chownprog installed files to USER. 
-s         $stripprog installed files. 
-t DIRECTORY  install into DIRECTORY. 
-T         report an error if DSTFILE is a directory. 
--help     display this help and exit. 
--version  display version info and exit. 
   
     -c            (ignored)
     -C            install only if different (preserve the last data modification time)
     -d            create directories instead of installing files.
     -g GROUP      $chgrpprog installed files to GROUP.
     -m MODE       $chmodprog installed files to MODE.
     -o USER       $chownprog installed files to USER.
     -s            $stripprog installed files.
     -t DIRECTORY  install into DIRECTORY.
     -T            report an error if DSTFILE is a directory.
   
 Environment variables override the default commands:  Environment variables override the default commands:
  CHGRPPROG CHMODPROG CHOWNPROG CPPROG MKDIRPROG MVPROG RMPROG STRIPPROG  CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
   RMPROG STRIPPROG
 "  "
   
while test -n "$1"; dowhile test $# -ne 0; do
   case $1 in    case $1 in
    -c) shift    -c) ;;
        continue;; 
   
    -d) dir_arg=true    -C) copy_on_change=true;;
        shift 
        continue;; 
   
       -d) dir_arg=true;;
   
     -g) chgrpcmd="$chgrpprog $2"      -g) chgrpcmd="$chgrpprog $2"
        shift        shift;;
        shift 
        continue;; 
   
     --help) echo "$usage"; exit $?;;      --help) echo "$usage"; exit $?;;
   
    -m) chmodcmd="$chmodprog $2"    -m) mode=$2
        shift        case $mode in
        shift          *' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *'['*)
        continue;;            echo "$0: invalid mode: $mode" >&2
             exit 1;;
         esac
         shift;;
   
     -o) chowncmd="$chownprog $2"      -o) chowncmd="$chownprog $2"
        shift        shift;;
        shift 
        continue;; 
   
    -s) stripcmd=$stripprog    -s) stripcmd=$stripprog;;
        shift 
        continue;; 
   
    -t) dstarg=$2    -t)
        shift        is_target_a_directory=always
        shift        dst_arg=$2
        continue;;        # Protect names problematic for 'test' and other utilities.
         case $dst_arg in
           -* | [=\(\)!]) dst_arg=./$dst_arg;;
         esac
         shift;;
   
    -T) no_target_directory=true    -T) is_target_a_directory=never;;
        shift 
        continue;; 
   
     --version) echo "$0 $scriptversion"; exit $?;;      --version) echo "$0 $scriptversion"; exit $?;;
   
    *)  # When -d is used, all remaining arguments are directories to create.    --) shift
        # When -t is used, the destination is already specified.        break;;
        test -n "$dir_arg$dstarg" && break
        # Otherwise, the last argument is the destination.  Remove it from $@.    -*) echo "$0: invalid option: $1" >&2
        for arg        exit 1;;
        do
          if test -n "$dstarg"; then    *)  break;;
            # $@ is not empty: it contains at least $arg. 
            set fnord "$@" "$dstarg" 
            shift # fnord 
          fi 
          shift # arg 
          dstarg=$arg 
        done 
        break;; 
   esac    esac
     shift
 done  done
   
if test -z "$1"; then# We allow the use of options -d and -T together, by making -d
 # take the precedence; this is for compatibility with GNU install.
 
 if test -n "$dir_arg"; then
   if test -n "$dst_arg"; then
     echo "$0: target directory not allowed when installing a directory." >&2
     exit 1
   fi
 fi
 
 if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
   # When -d is used, all remaining arguments are directories to create.
   # When -t is used, the destination is already specified.
   # Otherwise, the last argument is the destination.  Remove it from $@.
   for arg
   do
     if test -n "$dst_arg"; then
       # $@ is not empty: it contains at least $arg.
       set fnord "$@" "$dst_arg"
       shift # fnord
     fi
     shift # arg
     dst_arg=$arg
     # Protect names problematic for 'test' and other utilities.
     case $dst_arg in
       -* | [=\(\)!]) dst_arg=./$dst_arg;;
     esac
   done
 fi
 
 if test $# -eq 0; then
   if test -z "$dir_arg"; then    if test -z "$dir_arg"; then
     echo "$0: no input file specified." >&2      echo "$0: no input file specified." >&2
     exit 1      exit 1
   fi    fi
  # It's OK to call `install-sh -d' without argument.  # It's OK to call 'install-sh -d' without argument.
   # This can happen when creating conditional directories.    # This can happen when creating conditional directories.
   exit 0    exit 0
 fi  fi
   
   if test -z "$dir_arg"; then
     if test $# -gt 1 || test "$is_target_a_directory" = always; then
       if test ! -d "$dst_arg"; then
         echo "$0: $dst_arg: Is not a directory." >&2
         exit 1
       fi
     fi
   fi
   
   if test -z "$dir_arg"; then
     do_exit='(exit $ret); exit $ret'
     trap "ret=129; $do_exit" 1
     trap "ret=130; $do_exit" 2
     trap "ret=141; $do_exit" 13
     trap "ret=143; $do_exit" 15
   
     # Set umask so as not to create temps with too-generous modes.
     # However, 'strip' requires both read and write access to temps.
     case $mode in
       # Optimize common cases.
       *644) cp_umask=133;;
       *755) cp_umask=22;;
   
       *[0-7])
         if test -z "$stripcmd"; then
           u_plus_rw=
         else
           u_plus_rw='% 200'
         fi
         cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
       *)
         if test -z "$stripcmd"; then
           u_plus_rw=
         else
           u_plus_rw=,u+rw
         fi
         cp_umask=$mode$u_plus_rw;;
     esac
   fi
   
 for src  for src
 do  do
  # Protect names starting with `-'.  # Protect names problematic for 'test' and other utilities.
   case $src in    case $src in
    -*) src=./$src ;;    -* | [=\(\)!]) src=./$src;;
   esac    esac
   
   if test -n "$dir_arg"; then    if test -n "$dir_arg"; then
     dst=$src      dst=$src
    src=    dstdir=$dst
    test -d "$dstdir"
    if test -d "$dst"; then    dstdir_status=$?
      mkdircmd=: 
      chmodcmd= 
    else 
      mkdircmd=$mkdirprog 
    fi 
   else    else
   
     # Waiting for this to be detected by the "$cpprog $src $dsttmp" command      # Waiting for this to be detected by the "$cpprog $src $dsttmp" command
     # might cause directories to be created, which would be especially bad      # might cause directories to be created, which would be especially bad
     # if $src (and thus $dsttmp) contains '*'.      # if $src (and thus $dsttmp) contains '*'.
Line 190  do Line 265  do
       exit 1        exit 1
     fi      fi
   
    if test -z "$dstarg"; then    if test -z "$dst_arg"; then
       echo "$0: no destination specified." >&2        echo "$0: no destination specified." >&2
       exit 1        exit 1
     fi      fi
       dst=$dst_arg
   
    dst=$dstarg    # If destination is a directory, append the input filename.
    # Protect names starting with `-'. 
    case $dst in 
      -*) dst=./$dst ;; 
    esac 
 
    # If destination is a directory, append the input filename; won't work 
    # if double slashes aren't ignored. 
     if test -d "$dst"; then      if test -d "$dst"; then
      if test -n "$no_target_directory"; then      if test "$is_target_a_directory" = never; then
        echo "$0: $dstarg: Is a directory" >&2        echo "$0: $dst_arg: Is a directory" >&2
        exit 1        exit 1
       fi        fi
      dst=$dst/`basename "$src"`      dstdir=$dst
       dstbase=`basename "$src"`
       case $dst in
         */) dst=$dst$dstbase;;
         *)  dst=$dst/$dstbase;;
       esac
       dstdir_status=0
     else
       dstdir=`dirname "$dst"`
       test -d "$dstdir"
       dstdir_status=$?
     fi      fi
   fi    fi
   
  # This sed command emulates the dirname command.  case $dstdir in
  dstdir=`echo "$dst" | sed -e 's,/*$,,;s,[^/]*$,,;s,/*$,,;s,^$,.,'`    */) dstdirslash=$dstdir;;
     *)  dstdirslash=$dstdir/;;
   esac
   
  # Make sure that the destination directory exists.  obsolete_mkdir_used=false
   
  # Skip lots of stat calls in the usual case.  if test $dstdir_status != 0; then
  if test ! -d "$dstdir"; then    case $posix_mkdir in
    defaultIFS='      '')
         '        # Create intermediate dirs using mode 755 as modified by the umask.
    IFS="${IFS-$defaultIFS}"        # This is like FreeBSD 'install' as of 1997-10-28.
         umask=`umask`
         case $stripcmd.$umask in
           # Optimize common cases.
           *[2367][2367]) mkdir_umask=$umask;;
           .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;;
   
    oIFS=$IFS          *[0-7])
    # Some sh's can't handle IFS=/ for some reason.            mkdir_umask=`expr $umask + 22 \
    IFS='%'              - $umask % 100 % 40 + $umask % 20 \
    set x `echo "$dstdir" | sed -e 's@/@%@g' -e 's@^%@/@'`              - $umask % 10 % 4 + $umask % 2
    shift            `;;
    IFS=$oIFS          *) mkdir_umask=$umask,go-w;;
         esac
   
    pathcomp=        # With -d, create the new directory with the user-specified mode.
         # Otherwise, rely on $mkdir_umask.
         if test -n "$dir_arg"; then
           mkdir_mode=-m$mode
         else
           mkdir_mode=
         fi
   
    while test $# -ne 0 ; do        posix_mkdir=false
      pathcomp=$pathcomp$1        case $umask in
           *[123567][0-7][0-7])
             # POSIX mkdir -p sets u+wx bits regardless of umask, which
             # is incompatible with FreeBSD 'install' when (umask & 300) != 0.
             ;;
           *)
             # Note that $RANDOM variable is not portable (e.g. dash);  Use it
             # here however when possible just to lower collision chance.
             tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
 
             trap 'ret=$?; rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null; exit $ret' 0
 
             # Because "mkdir -p" follows existing symlinks and we likely work
             # directly in world-writeable /tmp, make sure that the '$tmpdir'
             # directory is successfully created first before we actually test
             # 'mkdir -p' feature.
             if (umask $mkdir_umask &&
                 $mkdirprog $mkdir_mode "$tmpdir" &&
                 exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/dev/null 2>&1
             then
               if test -z "$dir_arg" || {
                    # Check for POSIX incompatibilities with -m.
                    # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
                    # other-writable bit of parent directory when it shouldn't.
                    # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
                    test_tmpdir="$tmpdir/a"
                    ls_ld_tmpdir=`ls -ld "$test_tmpdir"`
                    case $ls_ld_tmpdir in
                      d????-?r-*) different_mode=700;;
                      d????-?--*) different_mode=755;;
                      *) false;;
                    esac &&
                    $mkdirprog -m$different_mode -p -- "$test_tmpdir" && {
                      ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"`
                      test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
                    }
                  }
               then posix_mkdir=:
               fi
               rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir"
             else
               # Remove any dirs left behind by ancient mkdir implementations.
               rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 2>/dev/null
             fi
             trap '' 0;;
         esac;;
     esac
 
     if
       $posix_mkdir && (
         umask $mkdir_umask &&
         $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
       )
     then :
     else
 
       # The umask is ridiculous, or mkdir does not conform to POSIX,
       # or it failed possibly due to a race condition.  Create the
       # directory the slow way, step by step, checking for races as we go.
 
       case $dstdir in
         /*) prefix='/';;
         [-=\(\)!]*) prefix='./';;
         *)  prefix='';;
       esac
 
       oIFS=$IFS
       IFS=/
       set -f
       set fnord $dstdir
       shift        shift
      if test ! -d "$pathcomp"; then      set +f
        $mkdirprog "$pathcomp"      IFS=$oIFS
        # mkdir can fail with a `File exist' error in case several
        # install-sh are creating the directory concurrently.  This      prefixes=
        # is OK.
        test -d "$pathcomp" || exit      for d
       do
         test X"$d" = X && continue
 
         prefix=$prefix$d
         if test -d "$prefix"; then
           prefixes=
         else
           if $posix_mkdir; then
             (umask=$mkdir_umask &&
              $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
             # Don't fail if two instances are running concurrently.
             test -d "$prefix" || exit 1
           else
             case $prefix in
               *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
               *) qprefix=$prefix;;
             esac
             prefixes="$prefixes '$qprefix'"
           fi
         fi
         prefix=$prefix/
       done
 
       if test -n "$prefixes"; then
         # Don't fail if two instances are running concurrently.
         (umask $mkdir_umask &&
          eval "\$doit_exec \$mkdirprog $prefixes") ||
           test -d "$dstdir" || exit 1
         obsolete_mkdir_used=true
       fi        fi
      pathcomp=$pathcomp/    fi
    done 
   fi    fi
   
   if test -n "$dir_arg"; then    if test -n "$dir_arg"; then
    $doit $mkdircmd "$dst" \    { test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&
      && { test -z "$chowncmd" || $doit $chowncmd "$dst"; } \    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&
      && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } \    { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||
      && { test -z "$stripcmd" || $doit $stripcmd "$dst"; } \      test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1
      && { test -z "$chmodcmd" || $doit $chmodcmd "$dst"; } 
 
   else    else
     dstfile=`basename "$dst"`  
   
     # Make a couple of temp file names in the proper directory.      # Make a couple of temp file names in the proper directory.
    dsttmp=$dstdir/_inst.$$_    dsttmp=${dstdirslash}_inst.$$_
    rmtmp=$dstdir/_rm.$$_    rmtmp=${dstdirslash}_rm.$$_
   
     # Trap to clean up those temp files at exit.      # Trap to clean up those temp files at exit.
     trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0      trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
     trap '(exit $?); exit' 1 2 13 15  
   
     # Copy the file name to the temp name.      # Copy the file name to the temp name.
    $doit $cpprog "$src" "$dsttmp" &&    (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") &&
   
     # and set any options; do chmod last to preserve setuid bits.      # and set any options; do chmod last to preserve setuid bits.
     #      #
Line 273  do Line 459  do
     # ignore errors from any of these, just make sure not to ignore      # ignore errors from any of these, just make sure not to ignore
     # errors from the above "$doit $cpprog $src $dsttmp" command.      # errors from the above "$doit $cpprog $src $dsttmp" command.
     #      #
    { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } \    { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&
      && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } \    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&
      && { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } \    { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&
      && { test -z "$chmodcmd" || $doit $chmodcmd "$dsttmp"; } &&    { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&
   
    # Now rename the file to the real destination.    # If -C, don't bother to copy if it wouldn't change the file.
    { $doit $mvcmd -f "$dsttmp" "$dstdir/$dstfile" 2>/dev/null \    if $copy_on_change &&
      || {       old=`LC_ALL=C ls -dlL "$dst"     2>/dev/null` &&
           # The rename failed, perhaps because mv can't rename something else       new=`LC_ALL=C ls -dlL "$dsttmp"  2>/dev/null` &&
           # to itself, or perhaps because mv is so ancient that it does not       set -f &&
           # support -f.       set X $old && old=:$2:$4:$5:$6 &&
        set X $new && new=:$2:$4:$5:$6 &&
        set +f &&
        test "$old" = "$new" &&
        $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
     then
       rm -f "$dsttmp"
     else
       # Rename the file to the real destination.
       $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||
   
           # Now remove or move aside any old file at destination location.      # The rename failed, perhaps because mv can't rename something else
           # We try this two ways since rm can't unlink itself on some      # to itself, or perhaps because mv is so ancient that it does not
           # systems and the destination file might be busy for other      # support -f.
           # reasons.  In this case, the final cleanup might fail but the new      {
           # file should still install successfully.        # Now remove or move aside any old file at destination location.
           {        # We try this two ways since rm can't unlink itself on some
             if test -f "$dstdir/$dstfile"; then        # systems and the destination file might be busy for other
               $doit $rmcmd -f "$dstdir/$dstfile" 2>/dev/null \        # reasons.  In this case, the final cleanup might fail but the new
               || $doit $mvcmd -f "$dstdir/$dstfile" "$rmtmp" 2>/dev/null \        # file should still install successfully.
               || {        {
                 echo "$0: cannot unlink or rename $dstdir/$dstfile" >&2          test ! -f "$dst" ||
                 (exit 1); exit 1          $doit $rmcmd -f "$dst" 2>/dev/null ||
               }          { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
             else            { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
               :          } ||
             fi          { echo "$0: cannot unlink or rename $dst" >&2
           } &&            (exit 1); exit 1
           }
         } &&
   
           # Now rename the file to the real destination.        # Now rename the file to the real destination.
           $doit $mvcmd "$dsttmp" "$dstdir/$dstfile"        $doit $mvcmd "$dsttmp" "$dst"
         }      }
    }    fi || exit 1
  fi || { (exit 1); exit 1; }
     trap '' 0
   fi
 done  done
   
 # The final little trick to "correctly" pass the exit status to the exit trap.  
 {  
   (exit 0); exit 0  
 }  
   
 # Local variables:  # Local variables:
# eval: (add-hook 'write-file-hooks 'time-stamp)# eval: (add-hook 'before-save-hook 'time-stamp)
 # time-stamp-start: "scriptversion="  # time-stamp-start: "scriptversion="
 # time-stamp-format: "%:y-%02m-%02d.%02H"  # time-stamp-format: "%:y-%02m-%02d.%02H"
# time-stamp-end: "$"# time-stamp-time-zone: "UTC0"
 # time-stamp-end: "; # UTC"
 # End:  # End:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.2

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>