File Manager

003 File Manager

Current Path: /usr/sbin

📁 ..
📄 ac(10.36 KB)
📄 accton(5.66 KB)
📄 acpiconf(9.14 KB)
📄 acpidb(496.75 KB)
📄 acpidump(39.86 KB)
📄 adduser(23.38 KB)
📄 ancontrol(34.19 KB)
📄 apm(13.1 KB)
📄 arp(17.88 KB)
📄 ath3kfw(14.51 KB)
📄 audit(5.98 KB)
📄 auditd(21.79 KB)
📄 auditdistd(127.49 KB)
📄 auditreduce(15.34 KB)
📄 authpf(20.57 KB)
📄 authpf-noip(20.57 KB)
📄 automount(50.65 KB)
📄 automountd(50.65 KB)
📄 autounmountd(50.65 KB)
📄 bcmfw(8.68 KB)
📄 bhyve(374.03 KB)
📄 bhyvectl(41.55 KB)
📄 bhyveload(16.41 KB)
📄 binmiscctl(14.12 KB)
📄 blacklistctl(33.88 KB)
📄 blacklistd(41.85 KB)
📄 bluetooth-config(9.71 KB)
📄 boot0cfg(15.09 KB)
📄 bootparamd(15.81 KB)
📄 bootpef(38.09 KB)
📄 bootptest(17.37 KB)
📄 bsdconfig(11.98 KB)
📄 bsdinstall(3.44 KB)
📄 bsnmpd(136.55 KB)
📄 bthidcontrol(36.06 KB)
📄 bthidd(55.51 KB)
📄 btpand(32.42 KB)
📄 btxld(13.49 KB)
📄 callbootd(9.26 KB)
📄 camdd(37.59 KB)
📄 cdcontrol(22.45 KB)
📄 certctl(7.74 KB)
📄 chkgrp(9.04 KB)
📄 chkprintcap(18.22 KB)
📄 chown(10.23 KB)
📄 chroot(8.31 KB)
📄 ckdist(16.18 KB)
📄 clear_locks(6.23 KB)
📄 config(56.23 KB)
📄 cpucontrol(20.03 KB)
📄 crashinfo(8.21 KB)
📄 cron(44.9 KB)
📄 ctladm(66.98 KB)
📄 ctld(123.97 KB)
📄 cxgbetool(2.86 MB)
📄 daemon(15.76 KB)
📄 dconschat(22.84 KB)
📄 devctl(11.83 KB)
📄 devinfo(8.68 KB)
📄 diskinfo(19.2 KB)
📄 dtrace(35.91 KB)
📄 dumpcis(26.69 KB)
📄 dwatch(36.59 KB)
📄 editmap(84.02 KB)
📄 edquota(22.9 KB)
📄 efibootmgr(22.04 KB)
📄 efidp(9.79 KB)
📄 efivar(14.77 KB)
📄 etcupdate(43.94 KB)
📄 extattrctl(16.63 KB)
📄 fdcontrol(14.94 KB)
📄 fdformat(18.52 KB)
📄 fdread(17.14 KB)
📄 fdwrite(10.19 KB)
📄 fifolog_create(9.03 KB)
📄 fifolog_reader(31.19 KB)
📄 fifolog_writer(15.57 KB)
📄 flowctl(12.19 KB)
📄 fmtree(36.11 KB)
📄 freebsd-update(91.6 KB)
📄 fstyp(19.38 KB)
📄 ftp-proxy(28.19 KB)
📄 fwcontrol(32.87 KB)
📄 gensnmptree(29.26 KB)
📄 getextattr(11.24 KB)
📄 getfmac(6.78 KB)
📄 getpmac(6.9 KB)
📄 gpioctl(11.71 KB)
📄 gssd(34.37 KB)
📄 gstat(23.22 KB)
📄 hccontrol(174.81 KB)
📄 hcsecd(30.18 KB)
📄 hcseriald(10.12 KB)
📄 hostapd(876.65 KB)
📄 hostapd_cli(79.18 KB)
📄 hoststat(8.41 KB)
📄 hv_kvp_daemon(21.99 KB)
📄 hv_vss_daemon(9.45 KB)
📄 i2c(14.99 KB)
📄 iasl(1.34 MB)
📄 idprio(7.61 KB)
📄 ifmcstat(12.74 KB)
📄 inetd(47.88 KB)
📄 iostat(19.66 KB)
📄 iovctl(19.91 KB)
📄 ip6addrctl(12.2 KB)
📄 ipfwpcap(10.79 KB)
📄 iprop-log(24.89 KB)
📄 iscsid(37.38 KB)
📄 iwmbtfw(19.09 KB)
📄 jail(68.96 KB)
📄 jexec(8.85 KB)
📄 jls(15.11 KB)
📄 kbdcontrol(39.62 KB)
📄 kbdmap(16.16 KB)
📄 keyserv(24.67 KB)
📄 kgmon(13.02 KB)
📄 kldxref(29.59 KB)
📄 kstash(9.68 KB)
📄 ktutil(38.81 KB)
📄 l2control(12.84 KB)
📄 l2ping(10.6 KB)
📄 lastlogin(8.5 KB)
📄 local-unbound(148.45 KB)
📄 local-unbound-anchor(38.63 KB)
📄 local-unbound-checkconf(29.43 KB)
📄 local-unbound-control(33.32 KB)
📄 local-unbound-setup(11.7 KB)
📄 lockstat(49.98 KB)
📄 lpc(55.95 KB)
📄 lpd(82.2 KB)
📄 lptcontrol(6.48 KB)
📄 lptest(6.03 KB)
📄 lsextattr(11.24 KB)
📄 mailstats(73.28 KB)
📄 mailwrapper(8.41 KB)
📄 makefs(183.64 KB)
📄 makemap(89.47 KB)
📄 manctl(7.75 KB)
📄 memcontrol(11.88 KB)
📄 mergemaster(43.59 KB)
📄 mfiutil(75.3 KB)
📄 mixer(12.14 KB)
📄 mld6query(10.53 KB)
📄 mlx5tool(11.54 KB)
📄 mlxcontrol(19.72 KB)
📄 mount_smbfs(15.29 KB)
📄 mountd(54.05 KB)
📄 moused(40.59 KB)
📄 mprutil(33.95 KB)
📄 mpsutil(33.95 KB)
📄 mptable(15.74 KB)
📄 mptutil(46.35 KB)
📄 mtest(17.24 KB)
📄 mtree(60.94 KB)
📄 ndis_events(9.19 KB)
📄 ndiscvt(39.78 KB)
📄 ndisgen(15.83 KB)
📄 ndp(24.03 KB)
📄 newsyslog(46.39 KB)
📄 nfscbd(10.15 KB)
📄 nfsd(22.62 KB)
📄 nfsdumpstate(8.02 KB)
📄 nfsrevoke(6.08 KB)
📄 nfsuserd(16.87 KB)
📄 ngctl(29.15 KB)
📄 nghook(10.09 KB)
📄 nmtree(60.94 KB)
📄 nologin(625.77 KB)
📄 nscd(87.91 KB)
📄 ntp-keygen(205.75 KB)
📄 ntpd(842.26 KB)
📄 ntpdate(126.85 KB)
📄 ntpdc(268.29 KB)
📄 ntptime(83.42 KB)
📄 pac(28.74 KB)
📄 pciconf(37.38 KB)
📄 periodic(4.19 KB)
📄 pkg(32.22 KB)
📄 plockstat(22.91 KB)
📄 pmc(167.45 KB)
📄 pmcannotate(15.8 KB)
📄 pmccontrol(11.81 KB)
📄 pmcstat(77.77 KB)
📄 pnfsdscopymr(9.09 KB)
📄 pnfsdsfile(10.01 KB)
📄 pnfsdskill(6.26 KB)
📄 portsnap(29.86 KB)
📄 powerd(15.97 KB)
📄 ppp(427.13 KB)
📄 pppctl(15.77 KB)
📄 praliases(86.38 KB)
📄 praudit(9.13 KB)
📄 prometheus_sysctl_exporter(13.91 KB)
📄 pstat(14.47 KB)
📄 purgestat(8.41 KB)
📄 pw(74.28 KB)
📄 pwd_mkdb(16.71 KB)
📄 pwm(10.45 KB)
📄 quot(14.92 KB)
📄 quotaoff(8.29 KB)
📄 quotaon(8.29 KB)
📄 rarpd(16.11 KB)
📄 repquota(11.14 KB)
📄 rfcomm_pppd(13.8 KB)
📄 rip6query(7.69 KB)
📄 rmextattr(11.24 KB)
📄 rmt(9.48 KB)
📄 rmuser(8.96 KB)
📄 route6d(46.17 KB)
📄 rpc.lockd(64.46 KB)
📄 rpc.statd(22.27 KB)
📄 rpc.umntall(12.3 KB)
📄 rpc.yppasswdd(41.08 KB)
📄 rpc.ypupdated(18.19 KB)
📄 rpc.ypxfrd(16.12 KB)
📄 rpcbind(43.91 KB)
📄 rrenumd(34.28 KB)
📄 rtadvctl(31.52 KB)
📄 rtadvd(70.95 KB)
📄 rtprio(7.61 KB)
📄 rtsold(40.09 KB)
📄 rwhod(17.15 KB)
📄 sa(23.57 KB)
📄 sade(48.1 KB)
📄 sdpcontrol(15.98 KB)
📄 sdpd(38.07 KB)
📄 sendmail(8.41 KB)
📄 service(4.84 KB)
📄 services_mkdb(14.02 KB)
📄 sesutil(20.83 KB)
📄 setextattr(11.24 KB)
📄 setfib(7.2 KB)
📄 setfmac(14.27 KB)
📄 setfsmac(14.27 KB)
📄 setpmac(6.11 KB)
📄 smbmsg(10.09 KB)
📄 snapinfo(7.46 KB)
📄 sntp(324.31 KB)
📄 spi(15.59 KB)
📄 spkrtest(3.62 KB)
📄 spray(7.8 KB)
📄 sshd(302.45 KB)
📄 swapinfo(14.47 KB)
📄 syslogd(53.15 KB)
📄 sysrc(22.64 KB)
📄 tcpdchk(19.85 KB)
📄 tcpdmatch(16.88 KB)
📄 tcpdrop(10.25 KB)
📄 tcpdump(936.43 KB)
📄 traceroute(33.23 KB)
📄 traceroute6(30.32 KB)
📄 trim(9.41 KB)
📄 trpt(11.45 KB)
📄 tzsetup(20.19 KB)
📄 uathload(9.28 KB)
📄 uefisign(20.87 KB)
📄 ugidfw(8.57 KB)
📄 uhsoctl(26.11 KB)
📄 usbconfig(26.59 KB)
📄 usbdump(16.42 KB)
📄 utx(7.81 KB)
📄 valectl(12.23 KB)
📄 vidcontrol(27.79 KB)
📄 vidfont(16.16 KB)
📄 vigr(2.42 KB)
📄 vipw(7.2 KB)
📄 wake(7.33 KB)
📄 watch(12.79 KB)
📄 watchdog(15.37 KB)
📄 watchdogd(15.37 KB)
📄 wlandebug(16.26 KB)
📄 wpa_cli(529.82 KB)
📄 wpa_passphrase(37.72 KB)
📄 wpa_supplicant(926.5 KB)
📄 yp_mkdb(11.82 KB)
📄 ypbind(20.45 KB)
📄 ypinit(8.8 KB)
📄 ypldap(93.28 KB)
📄 yppoll(7.91 KB)
📄 yppush(23.81 KB)
📄 ypserv(43.55 KB)
📄 ypset(7.36 KB)
📄 zdb(164.94 KB)
📄 zdump(13.48 KB)
📄 zfsd(102.01 KB)
📄 zhack(16.02 KB)
📄 zic(42.48 KB)
📄 zonectl(13.94 KB)
📄 zzz(1.23 KB)

Editing: portsnap

#!/bin/sh

#-
# SPDX-License-Identifier: BSD-2-Clause-FreeBSD
#
# Copyright 2004-2005 Colin Percival
# All rights reserved
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted providing that the following conditions 
# are met:
# 1. Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in the
#    documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.

# $FreeBSD$

#### Usage function -- called from command-line handling code.

# Usage instructions.  Options not listed:
# --debug	-- don't filter output from utilities
# --no-stats	-- don't show progress statistics while fetching files
usage() {
	cat <<EOF
usage: `basename $0` [options] command ... [path]

Options:
  -d workdir   -- Store working files in workdir
                  (default: /var/db/portsnap/)
  -f conffile  -- Read configuration options from conffile
                  (default: /etc/portsnap.conf)
  -I           -- Update INDEX only. (update command only)
  -k KEY       -- Trust an RSA key with SHA256 hash of KEY
  -l descfile  -- Merge the specified local describes file into the INDEX.
  -p portsdir  -- Location of uncompressed ports tree
                  (default: /usr/ports/)
  -s server    -- Server from which to fetch updates.
                  (default: portsnap.FreeBSD.org)
  --interactive -- interactive: override auto-detection of calling process
                  (use this when calling portsnap from an interactive, non-
                  terminal application AND NEVER ELSE).
  path         -- Extract only parts of the tree starting with the given
                  string.  (extract command only)
Commands:
  fetch        -- Fetch a compressed snapshot of the ports tree,
                  or update an existing snapshot.
  cron         -- Sleep rand(3600) seconds, and then fetch updates.
  extract      -- Extract snapshot of ports tree, replacing existing
                  files and directories.
  update       -- Update ports tree to match current snapshot, replacing
                  files and directories which have changed.
  auto         -- Fetch updates, and either extract a new ports tree or
                  update an existing tree.
EOF
	exit 0
}

#### Parameter handling functions.

# Initialize parameters to null, just in case they're
# set in the environment.
init_params() {
	KEYPRINT=""
	EXTRACTPATH=""
	WORKDIR=""
	PORTSDIR=""
	CONFFILE=""
	COMMAND=""
	COMMANDS=""
	QUIETREDIR=""
	QUIETFLAG=""
	STATSREDIR=""
	XARGST=""
	NDEBUG=""
	DDSTATS=""
	INDEXONLY=""
	SERVERNAME=""
	REFUSE=""
	LOCALDESC=""
	INTERACTIVE=""
}

# Parse the command line
parse_cmdline() {
	while [ $# -gt 0 ]; do
		case "$1" in
		-d)
			if [ $# -eq 1 ]; then usage; fi
			if [ ! -z "${WORKDIR}" ]; then usage; fi
			shift; WORKDIR="$1"
			;;
		--debug)
			QUIETREDIR="/dev/stderr"
			STATSREDIR="/dev/stderr"
			QUIETFLAG=" "
			NDEBUG=" "
			XARGST="-t"
			DDSTATS=".."
			;;
		--interactive)
			INTERACTIVE="YES"
			;;
		-f)
			if [ $# -eq 1 ]; then usage; fi
			if [ ! -z "${CONFFILE}" ]; then usage; fi
			shift; CONFFILE="$1"
			;;
		-h | --help | help)
			usage
			;;
		-I)
			INDEXONLY="YES"
			;;
		-k)
			if [ $# -eq 1 ]; then usage; fi
			if [ ! -z "${KEYPRINT}" ]; then usage; fi
			shift; KEYPRINT="$1"
			;;
		-l)
			if [ $# -eq 1 ]; then usage; fi
			if [ ! -z "${LOCALDESC}" ]; then usage; fi
			shift; LOCALDESC="$1"
			;;
		--no-stats)
			if [ -z "${STATSREDIR}" ]; then
				STATSREDIR="/dev/null"
				DDSTATS=".. "
			fi
			;;
		-p)
			if [ $# -eq 1 ]; then usage; fi
			if [ ! -z "${PORTSDIR}" ]; then usage; fi
			shift; PORTSDIR="$1"
			;;
		-s)
			if [ $# -eq 1 ]; then usage; fi
			if [ ! -z "${SERVERNAME}" ]; then usage; fi
			shift; SERVERNAME="$1"
			;;
		cron | extract | fetch | update | auto)
			COMMANDS="${COMMANDS} $1"
			;;
		up)
			COMMANDS="${COMMANDS} update"
			;;
		alfred)
			COMMANDS="${COMMANDS} auto"
			;;
		*)
			if [ $# -gt 1 ]; then usage; fi
			if echo ${COMMANDS} | grep -vq extract; then
				usage
			fi
			EXTRACTPATH="$1"
			;;
		esac
		shift
	done

if [ -z "${COMMANDS}" ]; then
		usage
	fi
}

# If CONFFILE was specified at the command-line, make
# sure that it exists and is readable.
sanity_conffile() {
	if [ ! -z "${CONFFILE}" ] && [ ! -r "${CONFFILE}" ]; then
		echo -n "File does not exist "
		echo -n "or is not readable: "
		echo ${CONFFILE}
		exit 1
	fi
}

# If a configuration file hasn't been specified, use
# the default value (/etc/portsnap.conf)
default_conffile() {
	if [ -z "${CONFFILE}" ]; then
		CONFFILE="/etc/portsnap.conf"
	fi
}

# Read {KEYPRINT, SERVERNAME, WORKDIR, PORTSDIR} from the configuration
# file if they haven't already been set.  If the configuration
# file doesn't exist, do nothing.
# Also read REFUSE (which cannot be set via the command line) if it is
# present in the configuration file.
parse_conffile() {
	if [ -r "${CONFFILE}" ]; then
		for X in KEYPRINT WORKDIR PORTSDIR SERVERNAME; do
			eval _=\$${X}
			if [ -z "${_}" ]; then
				eval ${X}=`grep "^${X}=" "${CONFFILE}" |
				    cut -f 2- -d '=' | tail -1`
			fi
		done

if grep -qE "^REFUSE[[:space:]]" ${CONFFILE}; then
			REFUSE="^(`
				grep -E "^REFUSE[[:space:]]" "${CONFFILE}" |
				    cut -c 7- | xargs echo | tr ' ' '|'
				`)"
		fi

if grep -qE "^INDEX[[:space:]]" ${CONFFILE}; then
			INDEXPAIRS="`
				grep -E "^INDEX[[:space:]]" "${CONFFILE}" |
				    cut -c 7- | tr ' ' '|' | xargs echo`"
		fi
	fi
}

# If parameters have not been set, use default values
default_params() {
	_QUIETREDIR="/dev/null"
	_QUIETFLAG="-q"
	_STATSREDIR="/dev/stdout"
	_WORKDIR="/var/db/portsnap"
	_PORTSDIR="/usr/ports"
	_NDEBUG="-n"
	_LOCALDESC="/dev/null"
	for X in QUIETREDIR QUIETFLAG STATSREDIR WORKDIR PORTSDIR	\
	    NDEBUG LOCALDESC; do
		eval _=\$${X}
		eval __=\$_${X}
		if [ -z "${_}" ]; then
			eval ${X}=${__}
		fi
	done
	if [ -z "${INTERACTIVE}" ]; then
		if [ -t 0 ]; then
			INTERACTIVE="YES"
		else
			INTERACTIVE="NO"
		fi
	fi
}

# Perform sanity checks and set some final parameters
# in preparation for fetching files.  Also chdir into
# the working directory.
fetch_check_params() {
	export HTTP_USER_AGENT="portsnap (${COMMAND}, `uname -r`)"

_SERVERNAME_z=\
"SERVERNAME must be given via command line or configuration file."
	_KEYPRINT_z="Key must be given via -k option or configuration file."
	_KEYPRINT_bad="Invalid key fingerprint: "
	_WORKDIR_bad="Directory does not exist or is not writable: "

if [ -z "${SERVERNAME}" ]; then
		echo -n "`basename $0`: "
		echo "${_SERVERNAME_z}"
		exit 1
	fi
	if [ -z "${KEYPRINT}" ]; then
		echo -n "`basename $0`: "
		echo "${_KEYPRINT_z}"
		exit 1
	fi
	if ! echo "${KEYPRINT}" | grep -qE "^[0-9a-f]{64}$"; then
		echo -n "`basename $0`: "
		echo -n "${_KEYPRINT_bad}"
		echo ${KEYPRINT}
		exit 1
	fi
	if ! [ -d "${WORKDIR}" -a -w "${WORKDIR}" ]; then
		echo -n "`basename $0`: "
		echo -n "${_WORKDIR_bad}"
		echo ${WORKDIR}
		exit 1
	fi
	cd ${WORKDIR} || exit 1

BSPATCH=/usr/bin/bspatch
	SHA256=/sbin/sha256
	PHTTPGET=/usr/libexec/phttpget
}

# Perform sanity checks and set some final parameters
# in preparation for extracting or updating ${PORTSDIR}
# Complain if ${PORTSDIR} exists but is not writable,
# but don't complain if ${PORTSDIR} doesn't exist.
extract_check_params() {
	_WORKDIR_bad="Directory does not exist: "
	_PORTSDIR_bad="Directory is not writable: "

if ! [ -d "${WORKDIR}" ]; then
		echo -n "`basename $0`: "
		echo -n "${_WORKDIR_bad}"
		echo ${WORKDIR}
		exit 1
	fi
	if [ -d "${PORTSDIR}" ] && ! [ -w "${PORTSDIR}" ]; then
		echo -n "`basename $0`: "
		echo -n "${_PORTSDIR_bad}"
		echo ${PORTSDIR}
		exit 1
	fi

if ! [ -d "${WORKDIR}/files" -a -r "${WORKDIR}/tag"	\
	    -a -r "${WORKDIR}/INDEX" -a -r "${WORKDIR}/tINDEX" ]; then
		echo "No snapshot available.  Try running"
		echo "# `basename $0` fetch"
		exit 1
	fi

MKINDEX=/usr/libexec/make_index
}

# Perform sanity checks and set some final parameters
# in preparation for updating ${PORTSDIR}
update_check_params() {
	extract_check_params

if ! [ -r ${PORTSDIR}/.portsnap.INDEX ]; then
		echo "${PORTSDIR} was not created by portsnap."
		echo -n "You must run '`basename $0` extract' before "
		echo "running '`basename $0` update'."
		exit 1
	fi

}

#### Core functionality -- the actual work gets done here

# Use an SRV query to pick a server.  If the SRV query doesn't provide
# a useful answer, use the server name specified by the user.
# Put another way... look up _http._tcp.${SERVERNAME} and pick a server
# from that; or if no servers are returned, use ${SERVERNAME}.
# This allows a user to specify "portsnap.freebsd.org" (in which case
# portsnap will select one of the mirrors) or "portsnap5.tld.freebsd.org"
# (in which case portsnap will use that particular server, since there
# won't be an SRV entry for that name).
#
# We ignore the Port field, since we are always going to use port 80.

# Fetch the mirror list, but do not pick a mirror yet.  Returns 1 if
# no mirrors are available for any reason.
fetch_pick_server_init() {
	: > serverlist_tried

# Check that host(1) exists (i.e., that the system wasn't built with the
# WITHOUT_BIND set) and don't try to find a mirror if it doesn't exist.
	if ! which -s host; then
		: > serverlist_full
		return 1
	fi

echo -n "Looking up ${SERVERNAME} mirrors... "

# Issue the SRV query and pull out the Priority, Weight, and Target fields.
# BIND 9 prints "$name has SRV record ..." while BIND 8 prints
# "$name server selection ..."; we allow either format.
	MLIST="_http._tcp.${SERVERNAME}"
	host -t srv "${MLIST}" |
	    sed -nE "s/${MLIST} (has SRV record|server selection) //Ip" |
	    cut -f 1,2,4 -d ' ' |
	    sed -e 's/\.$//' |
	    sort > serverlist_full

# If no records, give up -- we'll just use the server name we were given.
	if [ `wc -l < serverlist_full` -eq 0 ]; then
		echo "none found."
		return 1
	fi

# Report how many mirrors we found.
	echo `wc -l < serverlist_full` "mirrors found."

# Generate a random seed for use in picking mirrors.  If HTTP_PROXY
# is set, this will be used to generate the seed; otherwise, the seed
# will be random.
	if [ -n "${HTTP_PROXY}${http_proxy}" ]; then
		RANDVALUE=`sha256 -qs "${HTTP_PROXY}${http_proxy}" |
		    tr -d 'a-f' |
		    cut -c 1-9`
	else
		RANDVALUE=`jot -r 1 0 999999999`
	fi
}

# Pick a mirror.  Returns 1 if we have run out of mirrors to try.
fetch_pick_server() {
# Generate a list of not-yet-tried mirrors
	sort serverlist_tried |
	    comm -23 serverlist_full - > serverlist

# Have we run out of mirrors?
	if [ `wc -l < serverlist` -eq 0 ]; then
		echo "No mirrors remaining, giving up."
		return 1
	fi

# Find the highest priority level (lowest numeric value).
	SRV_PRIORITY=`cut -f 1 -d ' ' serverlist | sort -n | head -1`

# Add up the weights of the response lines at that priority level.
	SRV_WSUM=0;
	while read X; do
		case "$X" in
		${SRV_PRIORITY}\ *)
			SRV_W=`echo $X | cut -f 2 -d ' '`
			SRV_WSUM=$(($SRV_WSUM + $SRV_W))
			;;
		esac
	done < serverlist

# If all the weights are 0, pretend that they are all 1 instead.
	if [ ${SRV_WSUM} -eq 0 ]; then
		SRV_WSUM=`grep -E "^${SRV_PRIORITY} " serverlist | wc -l`
		SRV_W_ADD=1
	else
		SRV_W_ADD=0
	fi

# Pick a value between 0 and the sum of the weights - 1
	SRV_RND=`expr ${RANDVALUE} % ${SRV_WSUM}`

# Read through the list of mirrors and set SERVERNAME.  Write the line
# corresponding to the mirror we selected into serverlist_tried so that
# we won't try it again.
	while read X; do
		case "$X" in
		${SRV_PRIORITY}\ *)
			SRV_W=`echo $X | cut -f 2 -d ' '`
			SRV_W=$(($SRV_W + $SRV_W_ADD))
			if [ $SRV_RND -lt $SRV_W ]; then
				SERVERNAME=`echo $X | cut -f 3 -d ' '`
				echo "$X" >> serverlist_tried
				break
			else
				SRV_RND=$(($SRV_RND - $SRV_W))
			fi
			;;
		esac
	done < serverlist
}

# Check that we have a public key with an appropriate hash, or
# fetch the key if it doesn't exist.  Returns 1 if the key has
# not yet been fetched.
fetch_key() {
	if [ -r pub.ssl ] && [ `${SHA256} -q pub.ssl` = ${KEYPRINT} ]; then
		return 0
	fi

echo -n "Fetching public key from ${SERVERNAME}... "
	rm -f pub.ssl
	fetch ${QUIETFLAG} http://${SERVERNAME}/pub.ssl \
	    2>${QUIETREDIR} || true
	if ! [ -r pub.ssl ]; then
		echo "failed."
		return 1
	fi
	if ! [ `${SHA256} -q pub.ssl` = ${KEYPRINT} ]; then
		echo "key has incorrect hash."
		rm -f pub.ssl
		return 1
	fi
	echo "done."
}

# Fetch a snapshot tag
fetch_tag() {
	rm -f snapshot.ssl tag.new

echo ${NDEBUG} "Fetching snapshot tag from ${SERVERNAME}... "
	fetch ${QUIETFLAG} http://${SERVERNAME}/$1.ssl		\
	    2>${QUIETREDIR} || true
	if ! [ -r $1.ssl ]; then
		echo "failed."
		return 1
	fi

openssl rsautl -pubin -inkey pub.ssl -verify		\
	    < $1.ssl > tag.new 2>${QUIETREDIR} || true
	rm $1.ssl

if ! [ `wc -l < tag.new` = 1 ] ||
	    ! grep -qE "^portsnap\|[0-9]{10}\|[0-9a-f]{64}" tag.new; then
		echo "invalid snapshot tag."
		return 1
	fi

echo "done."

SNAPSHOTDATE=`cut -f 2 -d '|' < tag.new`
	SNAPSHOTHASH=`cut -f 3 -d '|' < tag.new`
}

# Sanity-check the date on a snapshot tag
fetch_snapshot_tagsanity() {
	if [ `date "+%s"` -gt `expr ${SNAPSHOTDATE} + 31536000` ]; then
		echo "Snapshot appears to be more than a year old!"
		echo "(Is the system clock correct?)"
		echo "Cowardly refusing to proceed any further."
		return 1
	fi
	if [ `date "+%s"` -lt `expr ${SNAPSHOTDATE} - 86400` ]; then
		echo -n "Snapshot appears to have been created more than "
		echo "one day into the future!"
		echo "(Is the system clock correct?)"
		echo "Cowardly refusing to proceed any further."
		return 1
	fi
}

# Sanity-check the date on a snapshot update tag
fetch_update_tagsanity() {
	fetch_snapshot_tagsanity || return 1

if [ ${OLDSNAPSHOTDATE} -gt ${SNAPSHOTDATE} ]; then
		echo -n "Latest snapshot on server is "
		echo "older than what we already have!"
		echo -n "Cowardly refusing to downgrade from "
		date -r ${OLDSNAPSHOTDATE}
		echo "to `date -r ${SNAPSHOTDATE}`."
		return 1
	fi
}

# Compare old and new tags; return 1 if update is unnecessary
fetch_update_neededp() {
	if [ ${OLDSNAPSHOTDATE} -eq ${SNAPSHOTDATE} ]; then
		echo -n "Latest snapshot on server matches "
		echo "what we already have."
		echo "No updates needed."
		rm tag.new
		return 1
	fi
	if [ ${OLDSNAPSHOTHASH} = ${SNAPSHOTHASH} ]; then
		echo -n "Ports tree hasn't changed since "
		echo "last snapshot."
		echo "No updates needed."
		rm tag.new
		return 1
	fi

return 0
}

# Fetch snapshot metadata file
fetch_metadata() {
	rm -f ${SNAPSHOTHASH} tINDEX.new

echo ${NDEBUG} "Fetching snapshot metadata... "
	fetch ${QUIETFLAG} http://${SERVERNAME}/t/${SNAPSHOTHASH} \
	    2>${QUIETREDIR} || return
	if [ "`${SHA256} -q ${SNAPSHOTHASH}`" != ${SNAPSHOTHASH} ]; then
		echo "snapshot metadata corrupt."
		return 1
	fi
	mv ${SNAPSHOTHASH} tINDEX.new
	echo "done."
}

# Warn user about bogus metadata
fetch_metadata_freakout() {
	echo
	echo "Portsnap metadata is correctly signed, but contains"
	echo "at least one line which appears bogus."
	echo "Cowardly refusing to proceed any further."
}

# Sanity-check a snapshot metadata file
fetch_metadata_sanity() {
	if grep -qvE "^[0-9A-Z.]+\|[0-9a-f]{64}$" tINDEX.new; then
		fetch_metadata_freakout
		return 1
	fi
	if [ `look INDEX tINDEX.new | wc -l` != 1 ]; then
		echo
		echo "Portsnap metadata appears bogus."
		echo "Cowardly refusing to proceed any further."
		return 1
	fi
}

# Take a list of ${oldhash}|${newhash} and output a list of needed patches
fetch_make_patchlist() {
	local IFS='|'
	echo "" 1>${QUIETREDIR}
	grep -vE "^([0-9a-f]{64})\|\1$" |
		while read X Y; do
			printf "Processing: $X $Y ...\r" 1>${QUIETREDIR}
			if [ -f "files/${Y}.gz" -o ! -f "files/${X}.gz" ]; then continue; fi
			echo "${X}|${Y}"
		done
	echo "" 1>${QUIETREDIR}
}

# Print user-friendly progress statistics
fetch_progress() {
	LNC=0
	while read x; do
		LNC=$(($LNC + 1))
		if [ $(($LNC % 10)) = 0 ]; then
			echo -n $LNC
		elif [ $(($LNC % 2)) = 0 ]; then
			echo -n .
		fi
	done
	echo -n " "
}

pct_fmt()
{
	if [ $TOTAL -gt 0 ]; then
		printf "                                     \r"
		printf "($1/$2) %02.2f%% " `echo "scale=4;$LNC / $TOTAL * 100"|bc`
	fi
}

fetch_progress_percent() {
	TOTAL=$1
	LNC=0
	pct_fmt $LNC $TOTAL
	while read x; do
		LNC=$(($LNC + 1))
		if [ $(($LNC % 100)) = 0 ]; then
                     pct_fmt $LNC $TOTAL
		elif [ $(($LNC % 10)) = 0 ]; then
			echo -n .
		fi
	done
	pct_fmt $LNC $TOTAL
	echo " done. "
}

# Sanity-check an index file
fetch_index_sanity() {
	if grep -qvE "^[-_+./@0-9A-Za-z]+\|[0-9a-f]{64}$" INDEX.new ||
	    fgrep -q "./" INDEX.new; then
		fetch_metadata_freakout
		return 1
	fi
}

# Verify a list of files
fetch_snapshot_verify() {
	while read F; do
		if [ "`gunzip -c < snap/${F}.gz | ${SHA256} -q`" != ${F} ]; then
			echo "snapshot corrupt."
			return 1
		fi
	done
	return 0
}

# Fetch a snapshot tarball, extract, and verify.
fetch_snapshot() {
	while ! fetch_tag snapshot; do
		fetch_pick_server || return 1
	done
	fetch_snapshot_tagsanity || return 1
	fetch_metadata || return 1
	fetch_metadata_sanity || return 1

rm -rf snap/

# Don't ask fetch(1) to be quiet -- downloading a snapshot of ~ 35MB will
# probably take a while, so the progrees reports that fetch(1) generates
# will be useful for keeping the users' attention from drifting.
	echo "Fetching snapshot generated at `date -r ${SNAPSHOTDATE}`:"
	fetch -r http://${SERVERNAME}/s/${SNAPSHOTHASH}.tgz || return 1

echo -n "Extracting snapshot... "
	tar -xz --numeric-owner -f ${SNAPSHOTHASH}.tgz snap/ || return 1
	rm ${SNAPSHOTHASH}.tgz
	echo "done."

echo -n "Verifying snapshot integrity... "
# Verify the metadata files
	cut -f 2 -d '|' tINDEX.new | fetch_snapshot_verify || return 1
# Extract the index
	rm -f INDEX.new
	gunzip -c < snap/`look INDEX tINDEX.new |
	    cut -f 2 -d '|'`.gz > INDEX.new
	fetch_index_sanity || return 1
# Verify the snapshot contents
	cut -f 2 -d '|' INDEX.new | fetch_snapshot_verify || return 1
	cut -f 2 -d '|' tINDEX.new INDEX.new | sort -u |
	    lam -s 'snap/' - -s '.gz' > files.expected
	find snap -mindepth 1 | sort > files.snap
	if ! cmp -s files.expected files.snap; then
		echo "unexpected files in snapshot."
		return 1
	fi
	rm files.expected files.snap
	echo "done."

# Move files into their proper locations
	rm -f tag INDEX tINDEX
	rm -rf files
	mv tag.new tag
	mv tINDEX.new tINDEX
	mv INDEX.new INDEX
	mv snap/ files/

return 0
}

# Update a compressed snapshot
fetch_update() {
	rm -f patchlist diff OLD NEW filelist INDEX.new

OLDSNAPSHOTDATE=`cut -f 2 -d '|' < tag`
	OLDSNAPSHOTHASH=`cut -f 3 -d '|' < tag`

while ! fetch_tag latest; do
		fetch_pick_server || return 1
	done
	fetch_update_tagsanity || return 1
	fetch_update_neededp || return 0
	fetch_metadata || return 1
	fetch_metadata_sanity || return 1

echo -n "Updating from `date -r ${OLDSNAPSHOTDATE}` "
	echo "to `date -r ${SNAPSHOTDATE}`."

# Generate a list of wanted metadata patches
	join -t '|' -o 1.2,2.2 tINDEX tINDEX.new |
	    fetch_make_patchlist > patchlist

# Attempt to fetch metadata patches
	echo -n "Fetching `wc -l < patchlist | tr -d ' '` "
	echo ${NDEBUG} "metadata patches.${DDSTATS}"
	tr '|' '-' < patchlist |
	    lam -s "tp/" - -s ".gz" |
	    xargs ${XARGST} ${PHTTPGET} ${SERVERNAME}	\
	    2>${STATSREDIR} | fetch_progress
	echo "done."

# Attempt to apply metadata patches
	echo -n "Applying metadata patches... "
	local oldifs="$IFS" IFS='|'
	while read X Y; do
		if [ ! -f "${X}-${Y}.gz" ]; then continue; fi
		gunzip -c < ${X}-${Y}.gz > diff
		gunzip -c < files/${X}.gz > OLD
		cut -c 2- diff | join -t '|' -v 2 - OLD > ptmp
		grep '^\+' diff | cut -c 2- |
		    sort -k 1,1 -t '|' -m - ptmp > NEW
		if [ `${SHA256} -q NEW` = ${Y} ]; then
			mv NEW files/${Y}
			gzip -n files/${Y}
		fi
		rm -f diff OLD NEW ${X}-${Y}.gz ptmp
	done < patchlist 2>${QUIETREDIR}
	IFS="$oldifs"
	echo "done."

# Update metadata without patches
	join -t '|' -v 2 tINDEX tINDEX.new |
	    cut -f 2 -d '|' /dev/stdin patchlist |
		while read Y; do
			if [ ! -f "files/${Y}.gz" ]; then
				echo ${Y};
			fi
		done > filelist
	echo -n "Fetching `wc -l < filelist | tr -d ' '` "
	echo ${NDEBUG} "metadata files... "
	lam -s "f/" - -s ".gz" < filelist |
	    xargs ${XARGST} ${PHTTPGET} ${SERVERNAME}	\
	    2>${QUIETREDIR}

while read Y; do
		echo -n "Verifying ${Y}... " 1>${QUIETREDIR}
		if [ `gunzip -c < ${Y}.gz | ${SHA256} -q` = ${Y} ]; then
			mv ${Y}.gz files/${Y}.gz
		else
			echo "metadata is corrupt."
			return 1
		fi
		echo "ok." 1>${QUIETREDIR}
	done < filelist
	echo "done."

# Extract the index
	echo -n "Extracting index... " 1>${QUIETREDIR}
	gunzip -c < files/`look INDEX tINDEX.new |
	    cut -f 2 -d '|'`.gz > INDEX.new
	fetch_index_sanity || return 1

# If we have decided to refuse certain updates, construct a hybrid index which
# is equal to the old index for parts of the tree which we don't want to
# update, and equal to the new index for parts of the tree which gets updates.
# This means that we should always have a "complete snapshot" of the ports
# tree -- with the caveat that it isn't actually a snapshot.
	if [ ! -z "${REFUSE}" ]; then
		echo "Refusing to download updates for ${REFUSE}"	\
		    >${QUIETREDIR}

grep -Ev "${REFUSE}" INDEX.new > INDEX.tmp
		grep -E "${REFUSE}" INDEX |
		    sort -m -k 1,1 -t '|' - INDEX.tmp > INDEX.new
		rm -f INDEX.tmp
	fi

# Generate a list of wanted ports patches
	echo -n "Generating list of wanted patches..." 1>${QUIETREDIR}
	join -t '|' -o 1.2,2.2 INDEX INDEX.new |
	    fetch_make_patchlist > patchlist
	echo " done." 1>${QUIETREDIR}

# Attempt to fetch ports patches
	patchcnt=`wc -l < patchlist | tr -d ' '`      
	echo -n "Fetching $patchcnt "
	echo ${NDEBUG} "patches.${DDSTATS}"
	echo " "
	tr '|' '-' < patchlist | lam -s "bp/" - |
	    xargs ${XARGST} ${PHTTPGET} ${SERVERNAME}	\
	    2>${STATSREDIR} | fetch_progress_percent $patchcnt
	echo "done."

# Attempt to apply ports patches
	PATCHCNT=`wc -l patchlist`
	echo "Applying patches... "
	local oldifs="$IFS" IFS='|'
	I=0
	while read X Y; do
		I=$(($I + 1))
		F="${X}-${Y}"
		if [ ! -f "${F}" ]; then
			printf "  Skipping ${F} (${I} of ${PATCHCNT}).\r"
			continue;
		fi
		echo "  Processing ${F}..." 1>${QUIETREDIR}
		gunzip -c < files/${X}.gz > OLD
		${BSPATCH} OLD NEW ${X}-${Y}
		if [ `${SHA256} -q NEW` = ${Y} ]; then
			mv NEW files/${Y}
			gzip -n files/${Y}
		fi
		rm -f diff OLD NEW ${X}-${Y}
	done < patchlist 2>${QUIETREDIR}
	IFS="$oldifs"
	echo "done."

# Update ports without patches
	join -t '|' -v 2 INDEX INDEX.new |
	    cut -f 2 -d '|' /dev/stdin patchlist |
		while read Y; do
			if [ ! -f "files/${Y}.gz" ]; then
				echo ${Y};
			fi
		done > filelist
	echo -n "Fetching `wc -l < filelist | tr -d ' '` "
	echo ${NDEBUG} "new ports or files... "
	lam -s "f/" - -s ".gz" < filelist |
	    xargs ${XARGST} ${PHTTPGET} ${SERVERNAME}	\
	    2>${QUIETREDIR}

I=0
	while read Y; do
		I=$(($I + 1))
		printf "   Processing ${Y} (${I} of ${PATCHCNT}).\r" 1>${QUIETREDIR}
		if [ `gunzip -c < ${Y}.gz | ${SHA256} -q` = ${Y} ]; then
			mv ${Y}.gz files/${Y}.gz
		else
			echo "snapshot is corrupt."
			return 1
		fi
	done < filelist
	echo "done."

# We're done!
	mv INDEX.new INDEX
	mv tINDEX.new tINDEX
	mv tag.new tag

return 0
}

# Do the actual work involved in "fetch" / "cron".
fetch_run() {
	fetch_pick_server_init && fetch_pick_server

while ! fetch_key; do
		fetch_pick_server || return 1
	done

if ! [ -d files -a -r tag -a -r INDEX -a -r tINDEX ]; then
		fetch_snapshot || return 1
	fi
	fetch_update || return 1
}

# Build a ports INDEX file
extract_make_index() {
	if ! look $1 ${WORKDIR}/tINDEX > /dev/null; then
		echo -n "$1 not provided by portsnap server; "
		echo "$2 not being generated."
	else
	gunzip -c < "${WORKDIR}/files/`look $1 ${WORKDIR}/tINDEX |
	    cut -f 2 -d '|'`.gz" |
	    cat - ${LOCALDESC} |
	    ${MKINDEX} /dev/stdin > ${PORTSDIR}/$2
	fi
}

# Create INDEX, INDEX-5, INDEX-6
extract_indices() {
	echo -n "Building new INDEX files... "
	for PAIR in ${INDEXPAIRS}; do
		INDEXFILE=`echo ${PAIR} | cut -f 1 -d '|'`
		DESCRIBEFILE=`echo ${PAIR} | cut -f 2 -d '|'`
		extract_make_index ${DESCRIBEFILE} ${INDEXFILE} || return 1
	done
	echo "done."
}

# Create .portsnap.INDEX; if we are REFUSEing to touch certain directories,
# merge the values from any exiting .portsnap.INDEX file.
extract_metadata() {
	if [ -z "${REFUSE}" ]; then
		sort ${WORKDIR}/INDEX > ${PORTSDIR}/.portsnap.INDEX
	elif [ -f ${PORTSDIR}/.portsnap.INDEX ]; then
		grep -E "${REFUSE}" ${PORTSDIR}/.portsnap.INDEX	\
		    > ${PORTSDIR}/.portsnap.INDEX.tmp
		grep -vE "${REFUSE}" ${WORKDIR}/INDEX | sort |
		    sort -m - ${PORTSDIR}/.portsnap.INDEX.tmp	\
		    > ${PORTSDIR}/.portsnap.INDEX
		rm -f ${PORTSDIR}/.portsnap.INDEX.tmp
	else
		grep -vE "${REFUSE}" ${WORKDIR}/INDEX | sort \
		    > ${PORTSDIR}/.portsnap.INDEX
	fi
}

# Do the actual work involved in "extract"
extract_run() {
	local oldifs="$IFS" IFS='|'
	mkdir -p ${PORTSDIR} || return 1

if !
		if ! [ -z "${EXTRACTPATH}" ]; then
			grep "^${EXTRACTPATH}" ${WORKDIR}/INDEX
		elif ! [ -z "${REFUSE}" ]; then
			grep -vE "${REFUSE}" ${WORKDIR}/INDEX
		else
			cat ${WORKDIR}/INDEX
		fi | while read FILE HASH; do
		echo ${PORTSDIR}/${FILE}
		if ! [ -s "${WORKDIR}/files/${HASH}.gz" ]; then
			echo "files/${HASH}.gz not found -- snapshot corrupt."
			return 1
		fi
		case ${FILE} in
		*/)
			rm -rf ${PORTSDIR}/${FILE%/}
			mkdir -p ${PORTSDIR}/${FILE}
			tar -xz --numeric-owner -f ${WORKDIR}/files/${HASH}.gz \
			    -C ${PORTSDIR}/${FILE}
			;;
		*)
			rm -f ${PORTSDIR}/${FILE}
			tar -xz --numeric-owner -f ${WORKDIR}/files/${HASH}.gz \
			    -C ${PORTSDIR} ${FILE}
			;;
		esac
	done; then
		return 1
	fi
	if [ ! -z "${EXTRACTPATH}" ]; then
		return 0;
	fi

IFS="$oldifs"

extract_metadata
	extract_indices
}

update_run_extract() {
	local IFS='|'

# Install new files
	echo "Extracting new files:"
	if !
		if ! [ -z "${REFUSE}" ]; then
			grep -vE "${REFUSE}" ${WORKDIR}/INDEX | sort
		else
			sort ${WORKDIR}/INDEX
		fi |
	    comm -13 ${PORTSDIR}/.portsnap.INDEX - |
	    while read FILE HASH; do
		echo ${PORTSDIR}/${FILE}
		if ! [ -s "${WORKDIR}/files/${HASH}.gz" ]; then
			echo "files/${HASH}.gz not found -- snapshot corrupt."
			return 1
		fi
		case ${FILE} in
		*/)
			mkdir -p ${PORTSDIR}/${FILE}
			tar -xz --numeric-owner -f ${WORKDIR}/files/${HASH}.gz \
			    -C ${PORTSDIR}/${FILE}
			;;
		*)
			tar -xz --numeric-owner -f ${WORKDIR}/files/${HASH}.gz \
			    -C ${PORTSDIR} ${FILE}
			;;
		esac
	done; then
		return 1
	fi
}

# Do the actual work involved in "update"
update_run() {
	if ! [ -z "${INDEXONLY}" ]; then
		extract_indices >/dev/null || return 1
		return 0
	fi

if sort ${WORKDIR}/INDEX |
	    cmp -s ${PORTSDIR}/.portsnap.INDEX -; then
		echo "Ports tree is already up to date."
		return 0
	fi

# If we are REFUSEing to touch certain directories, don't remove files
# from those directories (even if they are out of date)
	echo -n "Removing old files and directories... "
	if ! [ -z "${REFUSE}" ]; then 
		sort ${WORKDIR}/INDEX |
		    comm -23 ${PORTSDIR}/.portsnap.INDEX - | cut -f 1 -d '|' |
		    grep -vE "${REFUSE}" |
		    lam -s "${PORTSDIR}/" - |
		    sed -e 's|/$||' | xargs rm -rf
	else
		sort ${WORKDIR}/INDEX |
		    comm -23 ${PORTSDIR}/.portsnap.INDEX - | cut -f 1 -d '|' |
		    lam -s "${PORTSDIR}/" - |
		    sed -e 's|/$||' | xargs rm -rf
	fi
	echo "done."

update_run_extract || return 1
	extract_metadata
	extract_indices
}

#### Main functions -- call parameter-handling and core functions

# Using the command line, configuration file, and defaults,
# set all the parameters which are needed later.
get_params() {
	init_params
	parse_cmdline $@
	sanity_conffile
	default_conffile
	parse_conffile
	default_params
}

# Fetch command.  Make sure that we're being called
# interactively, then run fetch_check_params and fetch_run
cmd_fetch() {
	if [ "${INTERACTIVE}" != "YES" ]; then
		echo -n "`basename $0` fetch should not "
		echo "be run non-interactively."
		echo "Run `basename $0` cron instead"
		exit 1
	fi
	fetch_check_params
	fetch_run || exit 1
}

# Cron command.  Make sure the parameters are sensible; wait
# rand(3600) seconds; then fetch updates.  While fetching updates,
# send output to a temporary file; only print that file if the
# fetching failed.
cmd_cron() {
	fetch_check_params
	sleep `jot -r 1 0 3600`

TMPFILE=`mktemp /tmp/portsnap.XXXXXX` || exit 1
	if ! fetch_run >> ${TMPFILE}; then
		cat ${TMPFILE}
		rm ${TMPFILE}
		exit 1
	fi

rm ${TMPFILE}
}

# Extract command.  Make sure the parameters are sensible,
# then extract the ports tree (or part thereof).
cmd_extract() {
	extract_check_params
	extract_run || exit 1
}

# Update command.  Make sure the parameters are sensible,
# then update the ports tree.
cmd_update() {
	update_check_params
	update_run || exit 1
}

# Auto command.  Run 'fetch' or 'cron' depending on
# whether stdin is a terminal; then run 'update' or
# 'extract' depending on whether ${PORTSDIR} exists.
cmd_auto() {
	if [ "${INTERACTIVE}" = "YES" ]; then
		cmd_fetch
	else
		cmd_cron
	fi
	if [ -r ${PORTSDIR}/.portsnap.INDEX ]; then
		cmd_update
	else
		cmd_extract
	fi
}

#### Entry point

# Make sure we find utilities from the base system
export PATH=/sbin:/bin:/usr/sbin:/usr/bin:${PATH}

# Set LC_ALL in order to avoid problems with character ranges like [A-Z].
export LC_ALL=C

get_params $@
for COMMAND in ${COMMANDS}; do
	cmd_${COMMAND}
done

003 File Manager

Editing: portsnap

Upload File

Create Folder