Index: head/lib/libfetch/fetch.3
===================================================================
--- head/lib/libfetch/fetch.3	(revision 186123)
+++ head/lib/libfetch/fetch.3	(revision 186124)
@@ -1,684 +1,707 @@
 .\"-
 .\" Copyright (c) 1998-2004 Dag-Erling Coïdan Smørgrav
 .\" All rights reserved.
 .\"
 .\" Redistribution and use in source and binary forms, with or without
 .\" modification, are permitted provided 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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$
 .\"
-.Dd December 18, 2007
+.Dd December 14, 2008
 .Dt FETCH 3
 .Os
 .Sh NAME
 .Nm fetchMakeURL ,
 .Nm fetchParseURL ,
 .Nm fetchFreeURL ,
 .Nm fetchXGetURL ,
 .Nm fetchGetURL ,
 .Nm fetchPutURL ,
 .Nm fetchStatURL ,
 .Nm fetchListURL ,
 .Nm fetchXGet ,
 .Nm fetchGet ,
 .Nm fetchPut ,
 .Nm fetchStat ,
 .Nm fetchList ,
 .Nm fetchXGetFile ,
 .Nm fetchGetFile ,
 .Nm fetchPutFile ,
 .Nm fetchStatFile ,
 .Nm fetchListFile ,
 .Nm fetchXGetHTTP ,
 .Nm fetchGetHTTP ,
 .Nm fetchPutHTTP ,
 .Nm fetchStatHTTP ,
 .Nm fetchListHTTP ,
 .Nm fetchXGetFTP ,
 .Nm fetchGetFTP ,
 .Nm fetchPutFTP ,
 .Nm fetchStatFTP ,
 .Nm fetchListFTP
 .Nd file transfer functions
 .Sh LIBRARY
 .Lb libfetch
 .Sh SYNOPSIS
 .In sys/param.h
 .In stdio.h
 .In fetch.h
 .Ft struct url *
 .Fn fetchMakeURL "const char *scheme" "const char *host" "int port" "const char *doc" "const char *user" "const char *pwd"
 .Ft struct url *
 .Fn fetchParseURL "const char *URL"
 .Ft void
 .Fn fetchFreeURL "struct url *u"
 .Ft FILE *
 .Fn fetchXGetURL "const char *URL" "struct url_stat *us" "const char *flags"
 .Ft FILE *
 .Fn fetchGetURL "const char *URL" "const char *flags"
 .Ft FILE *
 .Fn fetchPutURL "const char *URL" "const char *flags"
 .Ft int
 .Fn fetchStatURL "const char *URL" "struct url_stat *us" "const char *flags"
 .Ft struct url_ent *
 .Fn fetchListURL "const char *URL" "const char *flags"
 .Ft FILE *
 .Fn fetchXGet "struct url *u" "struct url_stat *us" "const char *flags"
 .Ft FILE *
 .Fn fetchGet "struct url *u" "const char *flags"
 .Ft FILE *
 .Fn fetchPut "struct url *u" "const char *flags"
 .Ft int
 .Fn fetchStat "struct url *u" "struct url_stat *us" "const char *flags"
 .Ft struct url_ent *
 .Fn fetchList "struct url *u" "const char *flags"
 .Ft FILE *
 .Fn fetchXGetFile "struct url *u" "struct url_stat *us" "const char *flags"
 .Ft FILE *
 .Fn fetchGetFile "struct url *u" "const char *flags"
 .Ft FILE *
 .Fn fetchPutFile "struct url *u" "const char *flags"
 .Ft int
 .Fn fetchStatFile "struct url *u" "struct url_stat *us" "const char *flags"
 .Ft struct url_ent *
 .Fn fetchListFile "struct url *u" "const char *flags"
 .Ft FILE *
 .Fn fetchXGetHTTP "struct url *u" "struct url_stat *us" "const char *flags"
 .Ft FILE *
 .Fn fetchGetHTTP "struct url *u" "const char *flags"
 .Ft FILE *
 .Fn fetchPutHTTP "struct url *u" "const char *flags"
 .Ft int
 .Fn fetchStatHTTP "struct url *u" "struct url_stat *us" "const char *flags"
 .Ft struct url_ent *
 .Fn fetchListHTTP "struct url *u" "const char *flags"
 .Ft FILE *
 .Fn fetchXGetFTP "struct url *u" "struct url_stat *us" "const char *flags"
 .Ft FILE *
 .Fn fetchGetFTP "struct url *u" "const char *flags"
 .Ft FILE *
 .Fn fetchPutFTP "struct url *u" "const char *flags"
 .Ft int
 .Fn fetchStatFTP "struct url *u" "struct url_stat *us" "const char *flags"
 .Ft struct url_ent *
 .Fn fetchListFTP "struct url *u" "const char *flags"
 .Sh DESCRIPTION
 These functions implement a high-level library for retrieving and
 uploading files using Uniform Resource Locators (URLs).
 .Pp
 .Fn fetchParseURL
 takes a URL in the form of a null-terminated string and splits it into
 its components function according to the Common Internet Scheme Syntax
 detailed in RFC1738.
 A regular expression which produces this syntax is:
 .Bd -literal
     <scheme>:(//(<user>(:<pwd>)?@)?<host>(:<port>)?)?/(<document>)?
 .Ed
 .Pp
 If the URL does not seem to begin with a scheme name, the following
 syntax is assumed:
 .Bd -literal
     ((<user>(:<pwd>)?@)?<host>(:<port>)?)?/(<document>)?
 .Ed
 .Pp
 Note that some components of the URL are not necessarily relevant to
 all URL schemes.
 For instance, the file scheme only needs the <scheme> and <document>
 components.
 .Pp
 .Fn fetchMakeURL
 and
 .Fn fetchParseURL
 return a pointer to a
 .Vt url
 structure, which is defined as follows in
 .In fetch.h :
 .Bd -literal
 #define URL_SCHEMELEN 16
 #define URL_USERLEN 256
 #define URL_PWDLEN 256
 
 struct url {
     char	 scheme[URL_SCHEMELEN+1];
     char	 user[URL_USERLEN+1];
     char	 pwd[URL_PWDLEN+1];
     char	 host[MAXHOSTNAMELEN+1];
     int		 port;
     char	*doc;
     off_t	 offset;
     size_t	 length;
+    time_t	 ims_time;
 };
 .Ed
 .Pp
+The
+.Va ims_time
+field stores the time value for
+.Li If-Modified-Since
+HTTP requests.
+.Pp
 The pointer returned by
 .Fn fetchMakeURL
 or
 .Fn fetchParseURL
 should be freed using
 .Fn fetchFreeURL .
 .Pp
 .Fn fetchXGetURL ,
 .Fn fetchGetURL ,
 and
 .Fn fetchPutURL
 constitute the recommended interface to the
 .Nm fetch
 library.
 They examine the URL passed to them to determine the transfer
 method, and call the appropriate lower-level functions to perform the
 actual transfer.
 .Fn fetchXGetURL
 also returns the remote document's metadata in the
 .Vt url_stat
 structure pointed to by the
 .Fa us
 argument.
 .Pp
 The
 .Fa flags
 argument is a string of characters which specify transfer options.
 The
 meaning of the individual flags is scheme-dependent, and is detailed
 in the appropriate section below.
 .Pp
 .Fn fetchStatURL
 attempts to obtain the requested document's metadata and fill in the
 structure pointed to by its second argument.
 The
 .Vt url_stat
 structure is defined as follows in
 .In fetch.h :
 .Bd -literal
 struct url_stat {
     off_t	 size;
     time_t	 atime;
     time_t	 mtime;
 };
 .Ed
 .Pp
 If the size could not be obtained from the server, the
 .Fa size
 field is set to -1.
 If the modification time could not be obtained from the server, the
 .Fa mtime
 field is set to the epoch.
 If the access time could not be obtained from the server, the
 .Fa atime
 field is set to the modification time.
 .Pp
 .Fn fetchListURL
 attempts to list the contents of the directory pointed to by the URL
 provided.
 If successful, it returns a malloced array of
 .Vt url_ent
 structures.
 The
 .Vt url_ent
 structure is defined as follows in
 .In fetch.h :
 .Bd -literal
 struct url_ent {
     char         name[PATH_MAX];
     struct url_stat stat;
 };
 .Ed
 .Pp
 The list is terminated by an entry with an empty name.
 .Pp
 The pointer returned by
 .Fn fetchListURL
 should be freed using
 .Fn free .
 .Pp
 .Fn fetchXGet ,
 .Fn fetchGet ,
 .Fn fetchPut
 and
 .Fn fetchStat
 are similar to
 .Fn fetchXGetURL ,
 .Fn fetchGetURL ,
 .Fn fetchPutURL
 and
 .Fn fetchStatURL ,
 except that they expect a pre-parsed URL in the form of a pointer to
 a
 .Vt struct url
 rather than a string.
 .Pp
 All of the
 .Fn fetchXGetXXX ,
 .Fn fetchGetXXX
 and
 .Fn fetchPutXXX
 functions return a pointer to a stream which can be used to read or
 write data from or to the requested document, respectively.
 Note that
 although the implementation details of the individual access methods
 vary, it can generally be assumed that a stream returned by one of the
 .Fn fetchXGetXXX
 or
 .Fn fetchGetXXX
 functions is read-only, and that a stream returned by one of the
 .Fn fetchPutXXX
 functions is write-only.
 .Sh FILE SCHEME
 .Fn fetchXGetFile ,
 .Fn fetchGetFile
 and
 .Fn fetchPutFile
 provide access to documents which are files in a locally mounted file
 system.
 Only the <document> component of the URL is used.
 .Pp
 .Fn fetchXGetFile
 and
 .Fn fetchGetFile
 do not accept any flags.
 .Pp
 .Fn fetchPutFile
 accepts the
 .Ql a
 (append to file) flag.
 If that flag is specified, the data written to
 the stream returned by
 .Fn fetchPutFile
 will be appended to the previous contents of the file, instead of
 replacing them.
 .Sh FTP SCHEME
 .Fn fetchXGetFTP ,
 .Fn fetchGetFTP
 and
 .Fn fetchPutFTP
 implement the FTP protocol as described in RFC959.
 .Pp
 If the
 .Ql p
 (passive) flag is specified, a passive (rather than active) connection
 will be attempted.
 .Pp
 If the
 .Ql l
 (low) flag is specified, data sockets will be allocated in the low (or
 default) port range instead of the high port range (see
 .Xr ip 4 ) .
 .Pp
 If the
 .Ql d
 (direct) flag is specified,
 .Fn fetchXGetFTP ,
 .Fn fetchGetFTP
 and
 .Fn fetchPutFTP
 will use a direct connection even if a proxy server is defined.
 .Pp
 If no user name or password is given, the
 .Nm fetch
 library will attempt an anonymous login, with user name "anonymous"
 and password "anonymous@<hostname>".
 .Sh HTTP SCHEME
 The
 .Fn fetchXGetHTTP ,
 .Fn fetchGetHTTP
 and
 .Fn fetchPutHTTP
 functions implement the HTTP/1.1 protocol.
 With a little luck, there is
 even a chance that they comply with RFC2616 and RFC2617.
 .Pp
 If the
 .Ql d
 (direct) flag is specified,
 .Fn fetchXGetHTTP ,
 .Fn fetchGetHTTP
 and
 .Fn fetchPutHTTP
 will use a direct connection even if a proxy server is defined.
+.Pp
+If the
+.Ql i
+(if-modified-since) flag is specified, and
+the
+.Va ims_time
+field is set in 
+.Vt "struct url" ,
+then
+.Fn fetchXGetHTTP
+and
+.Fn fetchGetHTTP
+will send a conditional
+.Li If-Modified-Since
+HTTP header to only fetch the content if it is newer than
+.Va ims_time .
 .Pp
 Since there seems to be no good way of implementing the HTTP PUT
 method in a manner consistent with the rest of the
 .Nm fetch
 library,
 .Fn fetchPutHTTP
 is currently unimplemented.
 .Sh AUTHENTICATION
 Apart from setting the appropriate environment variables and
 specifying the user name and password in the URL or the
 .Vt struct url ,
 the calling program has the option of defining an authentication
 function with the following prototype:
 .Pp
 .Ft int
 .Fn myAuthMethod "struct url *u"
 .Pp
 The callback function should fill in the
 .Fa user
 and
 .Fa pwd
 fields in the provided
 .Vt struct url
 and return 0 on success, or any other value to indicate failure.
 .Pp
 To register the authentication callback, simply set
 .Va fetchAuthMethod
 to point at it.
 The callback will be used whenever a site requires authentication and
 the appropriate environment variables are not set.
 .Pp
 This interface is experimental and may be subject to change.
 .Sh RETURN VALUES
 .Fn fetchParseURL
 returns a pointer to a
 .Vt struct url
 containing the individual components of the URL.
 If it is
 unable to allocate memory, or the URL is syntactically incorrect,
 .Fn fetchParseURL
 returns a NULL pointer.
 .Pp
 The
 .Fn fetchStat
 functions return 0 on success and -1 on failure.
 .Pp
 All other functions return a stream pointer which may be used to
 access the requested document, or NULL if an error occurred.
 .Pp
 The following error codes are defined in
 .In fetch.h :
 .Bl -tag -width 18n
 .It Bq Er FETCH_ABORT
 Operation aborted
 .It Bq Er FETCH_AUTH
 Authentication failed
 .It Bq Er FETCH_DOWN
 Service unavailable
 .It Bq Er FETCH_EXISTS
 File exists
 .It Bq Er FETCH_FULL
 File system full
 .It Bq Er FETCH_INFO
 Informational response
 .It Bq Er FETCH_MEMORY
 Insufficient memory
 .It Bq Er FETCH_MOVED
 File has moved
 .It Bq Er FETCH_NETWORK
 Network error
 .It Bq Er FETCH_OK
 No error
 .It Bq Er FETCH_PROTO
 Protocol error
 .It Bq Er FETCH_RESOLV
 Resolver error
 .It Bq Er FETCH_SERVER
 Server error
 .It Bq Er FETCH_TEMP
 Temporary error
 .It Bq Er FETCH_TIMEOUT
 Operation timed out
 .It Bq Er FETCH_UNAVAIL
 File is not available
 .It Bq Er FETCH_UNKNOWN
 Unknown error
 .It Bq Er FETCH_URL
 Invalid URL
 .El
 .Pp
 The accompanying error message includes a protocol-specific error code
 and message, e.g.\& "File is not available (404 Not Found)"
 .Sh ENVIRONMENT
 .Bl -tag -width ".Ev FETCH_BIND_ADDRESS"
 .It Ev FETCH_BIND_ADDRESS
 Specifies a hostname or IP address to which sockets used for outgoing
 connections will be bound.
 .It Ev FTP_LOGIN
 Default FTP login if none was provided in the URL.
 .It Ev FTP_PASSIVE_MODE
 If set to anything but
 .Ql no ,
 forces the FTP code to use passive mode.
 .It Ev FTP_PASSWORD
 Default FTP password if the remote server requests one and none was
 provided in the URL.
 .It Ev FTP_PROXY
 URL of the proxy to use for FTP requests.
 The document part is ignored.
 FTP and HTTP proxies are supported; if no scheme is specified, FTP is
 assumed.
 If the proxy is an FTP proxy,
 .Nm libfetch
 will send
 .Ql user@host
 as user name to the proxy, where
 .Ql user
 is the real user name, and
 .Ql host
 is the name of the FTP server.
 .Pp
 If this variable is set to an empty string, no proxy will be used for
 FTP requests, even if the
 .Ev HTTP_PROXY
 variable is set.
 .It Ev ftp_proxy
 Same as
 .Ev FTP_PROXY ,
 for compatibility.
 .It Ev HTTP_AUTH
 Specifies HTTP authorization parameters as a colon-separated list of
 items.
 The first and second item are the authorization scheme and realm
 respectively; further items are scheme-dependent.
 Currently, only basic authorization is supported.
 .Pp
 Basic authorization requires two parameters: the user name and
 password, in that order.
 .Pp
 This variable is only used if the server requires authorization and
 no user name or password was specified in the URL.
 .It Ev HTTP_PROXY
 URL of the proxy to use for HTTP requests.
 The document part is ignored.
 Only HTTP proxies are supported for HTTP requests.
 If no port number is specified, the default is 3128.
 .Pp
 Note that this proxy will also be used for FTP documents, unless the
 .Ev FTP_PROXY
 variable is set.
 .It Ev http_proxy
 Same as
 .Ev HTTP_PROXY ,
 for compatibility.
 .It Ev HTTP_PROXY_AUTH
 Specifies authorization parameters for the HTTP proxy in the same
 format as the
 .Ev HTTP_AUTH
 variable.
 .Pp
 This variable is used if and only if connected to an HTTP proxy, and
 is ignored if a user and/or a password were specified in the proxy
 URL.
 .It Ev HTTP_REFERER
 Specifies the referrer URL to use for HTTP requests.
 If set to
 .Dq auto ,
 the document URL will be used as referrer URL.
 .It Ev HTTP_USER_AGENT
 Specifies the User-Agent string to use for HTTP requests.
 This can be useful when working with HTTP origin or proxy servers that
 differentiate between user agents.
 .It Ev NETRC
 Specifies a file to use instead of
 .Pa ~/.netrc
 to look up login names and passwords for FTP sites.
 See
 .Xr ftp 1
 for a description of the file format.
 This feature is experimental.
 .It Ev NO_PROXY
 Either a single asterisk, which disables the use of proxies
 altogether, or a comma- or whitespace-separated list of hosts for
 which proxies should not be used.
 .It Ev no_proxy
 Same as
 .Ev NO_PROXY ,
 for compatibility.
 .El
 .Sh EXAMPLES
 To access a proxy server on
 .Pa proxy.example.com
 port 8080, set the
 .Ev HTTP_PROXY
 environment variable in a manner similar to this:
 .Pp
 .Dl HTTP_PROXY=http://proxy.example.com:8080
 .Pp
 If the proxy server requires authentication, there are
 two options available for passing the authentication data.
 The first method is by using the proxy URL:
 .Pp
 .Dl HTTP_PROXY=http://<user>:<pwd>@proxy.example.com:8080
 .Pp
 The second method is by using the
 .Ev HTTP_PROXY_AUTH
 environment variable:
 .Bd -literal -offset indent
 HTTP_PROXY=http://proxy.example.com:8080
 HTTP_PROXY_AUTH=basic:*:<user>:<pwd>
 .Ed
 .Pp
 To disable the use of a proxy for an HTTP server running on the local
 host, define
 .Ev NO_PROXY
 as follows:
 .Bd -literal -offset indent
 NO_PROXY=localhost,127.0.0.1
 .Ed
 .Sh SEE ALSO
 .Xr fetch 1 ,
 .Xr ftpio 3 ,
 .Xr ip 4
 .Rs
 .%A J. Postel
 .%A J. K. Reynolds
 .%D October 1985
 .%B File Transfer Protocol
 .%O RFC959
 .Re
 .Rs
 .%A P. Deutsch
 .%A A. Emtage
 .%A A. Marine.
 .%D May 1994
 .%T How to Use Anonymous FTP
 .%O RFC1635
 .Re
 .Rs
 .%A T. Berners-Lee
 .%A L. Masinter
 .%A M. McCahill
 .%D December 1994
 .%T Uniform Resource Locators (URL)
 .%O RFC1738
 .Re
 .Rs
 .%A R. Fielding
 .%A J. Gettys
 .%A J. Mogul
 .%A H. Frystyk
 .%A L. Masinter
 .%A P. Leach
 .%A T. Berners-Lee
 .%D January 1999
 .%B Hypertext Transfer Protocol -- HTTP/1.1
 .%O RFC2616
 .Re
 .Rs
 .%A J. Franks
 .%A P. Hallam-Baker
 .%A J. Hostetler
 .%A S. Lawrence
 .%A P. Leach
 .%A A. Luotonen
 .%A L. Stewart
 .%D June 1999
 .%B HTTP Authentication: Basic and Digest Access Authentication
 .%O RFC2617
 .Re
 .Sh HISTORY
 The
 .Nm fetch
 library first appeared in
 .Fx 3.0 .
 .Sh AUTHORS
 .An -nosplit
 The
 .Nm fetch
 library was mostly written by
 .An Dag-Erling Sm\(/orgrav Aq des@FreeBSD.org
 with numerous suggestions from
 .An Jordan K. Hubbard Aq jkh@FreeBSD.org ,
 .An Eugene Skepner Aq eu@qub.com
 and other
 .Fx
 developers.
 It replaces the older
 .Nm ftpio
 library written by
 .An Poul-Henning Kamp Aq phk@FreeBSD.org
 and
 .An Jordan K. Hubbard Aq jkh@FreeBSD.org .
 .Pp
 This manual page was written by
 .An Dag-Erling Sm\(/orgrav Aq des@FreeBSD.org .
 .Sh BUGS
 Some parts of the library are not yet implemented.
 The most notable
 examples of this are
 .Fn fetchPutHTTP ,
 .Fn fetchListHTTP ,
 .Fn fetchListFTP
 and FTP proxy support.
 .Pp
 There is no way to select a proxy at run-time other than setting the
 .Ev HTTP_PROXY
 or
 .Ev FTP_PROXY
 environment variables as appropriate.
 .Pp
 .Nm libfetch
 does not understand or obey 305 (Use Proxy) replies.
 .Pp
 Error numbers are unique only within a certain context; the error
 codes used for FTP and HTTP overlap, as do those used for resolver and
 system errors.
 For instance, error code 202 means "Command not
 implemented, superfluous at this site" in an FTP context and
 "Accepted" in an HTTP context.
 .Pp
 .Fn fetchStatFTP
 does not check that the result of an MDTM command is a valid date.
 .Pp
 The man page is incomplete, poorly written and produces badly
 formatted text.
 .Pp
 The error reporting mechanism is unsatisfactory.
 .Pp
 Some parts of the code are not fully reentrant.
Index: head/lib/libfetch/fetch.h
===================================================================
--- head/lib/libfetch/fetch.h	(revision 186123)
+++ head/lib/libfetch/fetch.h	(revision 186124)
@@ -1,150 +1,151 @@
 /*-
  * Copyright (c) 1998-2004 Dag-Erling Coïdan Smørgrav
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided 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
  *    in this position and unchanged.
  * 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.
  * 3. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission
  *
  * 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$
  */
 
 #ifndef _FETCH_H_INCLUDED
 #define _FETCH_H_INCLUDED
 
 #define _LIBFETCH_VER "libfetch/2.0"
 
 #define URL_SCHEMELEN 16
 #define URL_USERLEN 256
 #define URL_PWDLEN 256
 
 struct url {
 	char		 scheme[URL_SCHEMELEN+1];
 	char		 user[URL_USERLEN+1];
 	char		 pwd[URL_PWDLEN+1];
 	char		 host[MAXHOSTNAMELEN+1];
 	int		 port;
 	char		*doc;
 	off_t		 offset;
 	size_t		 length;
+	time_t		 ims_time;
 };
 
 struct url_stat {
 	off_t		 size;
 	time_t		 atime;
 	time_t		 mtime;
 };
 
 struct url_ent {
 	char		 name[PATH_MAX];
 	struct url_stat	 stat;
 };
 
 /* Recognized schemes */
 #define SCHEME_FTP	"ftp"
 #define SCHEME_HTTP	"http"
 #define SCHEME_HTTPS	"https"
 #define SCHEME_FILE	"file"
 
 /* Error codes */
 #define	FETCH_ABORT	 1
 #define	FETCH_AUTH	 2
 #define	FETCH_DOWN	 3
 #define	FETCH_EXISTS	 4
 #define	FETCH_FULL	 5
 #define	FETCH_INFO	 6
 #define	FETCH_MEMORY	 7
 #define	FETCH_MOVED	 8
 #define	FETCH_NETWORK	 9
 #define	FETCH_OK	10
 #define	FETCH_PROTO	11
 #define	FETCH_RESOLV	12
 #define	FETCH_SERVER	13
 #define	FETCH_TEMP	14
 #define	FETCH_TIMEOUT	15
 #define	FETCH_UNAVAIL	16
 #define	FETCH_UNKNOWN	17
 #define	FETCH_URL	18
 #define	FETCH_VERBOSE	19
 
 __BEGIN_DECLS
 
 /* FILE-specific functions */
 FILE		*fetchXGetFile(struct url *, struct url_stat *, const char *);
 FILE		*fetchGetFile(struct url *, const char *);
 FILE		*fetchPutFile(struct url *, const char *);
 int		 fetchStatFile(struct url *, struct url_stat *, const char *);
 struct url_ent	*fetchListFile(struct url *, const char *);
 
 /* HTTP-specific functions */
 FILE		*fetchXGetHTTP(struct url *, struct url_stat *, const char *);
 FILE		*fetchGetHTTP(struct url *, const char *);
 FILE		*fetchPutHTTP(struct url *, const char *);
 int		 fetchStatHTTP(struct url *, struct url_stat *, const char *);
 struct url_ent	*fetchListHTTP(struct url *, const char *);
 
 /* FTP-specific functions */
 FILE		*fetchXGetFTP(struct url *, struct url_stat *, const char *);
 FILE		*fetchGetFTP(struct url *, const char *);
 FILE		*fetchPutFTP(struct url *, const char *);
 int		 fetchStatFTP(struct url *, struct url_stat *, const char *);
 struct url_ent	*fetchListFTP(struct url *, const char *);
 
 /* Generic functions */
 FILE		*fetchXGetURL(const char *, struct url_stat *, const char *);
 FILE		*fetchGetURL(const char *, const char *);
 FILE		*fetchPutURL(const char *, const char *);
 int		 fetchStatURL(const char *, struct url_stat *, const char *);
 struct url_ent	*fetchListURL(const char *, const char *);
 FILE		*fetchXGet(struct url *, struct url_stat *, const char *);
 FILE		*fetchGet(struct url *, const char *);
 FILE		*fetchPut(struct url *, const char *);
 int		 fetchStat(struct url *, struct url_stat *, const char *);
 struct url_ent	*fetchList(struct url *, const char *);
 
 /* URL parsing */
 struct url	*fetchMakeURL(const char *, const char *, int,
 		     const char *, const char *, const char *);
 struct url	*fetchParseURL(const char *);
 void		 fetchFreeURL(struct url *);
 
 __END_DECLS
 
 /* Authentication */
 typedef int (*auth_t)(struct url *);
 extern auth_t		 fetchAuthMethod;
 
 /* Last error code */
 extern int		 fetchLastErrCode;
 #define MAXERRSTRING 256
 extern char		 fetchLastErrString[MAXERRSTRING];
 
 /* I/O timeout */
 extern int		 fetchTimeout;
 
 /* Restart interrupted syscalls */
 extern int		 fetchRestartCalls;
 
 /* Extra verbosity */
 extern int		 fetchDebug;
 
 #endif
Index: head/lib/libfetch/http.c
===================================================================
--- head/lib/libfetch/http.c	(revision 186123)
+++ head/lib/libfetch/http.c	(revision 186124)
@@ -1,1222 +1,1244 @@
 /*-
  * Copyright (c) 2000-2004 Dag-Erling Coïdan Smørgrav
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided 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
  *    in this position and unchanged.
  * 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.
  * 3. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
  *
  * 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.
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 /*
  * The following copyright applies to the base64 code:
  *
  *-
  * Copyright 1997 Massachusetts Institute of Technology
  *
  * Permission to use, copy, modify, and distribute this software and
  * its documentation for any purpose and without fee is hereby
  * granted, provided that both the above copyright notice and this
  * permission notice appear in all copies, that both the above
  * copyright notice and this permission notice appear in all
  * supporting documentation, and that the name of M.I.T. not be used
  * in advertising or publicity pertaining to distribution of the
  * software without specific, written prior permission.  M.I.T. makes
  * no representations about the suitability of this software for any
  * purpose.  It is provided "as is" without express or implied
  * warranty.
  *
  * THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''.  M.I.T. DISCLAIMS
  * ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE,
  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT
  * SHALL M.I.T. 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.
  */
 
 #include <sys/param.h>
 #include <sys/socket.h>
+#include <sys/time.h>
 
 #include <ctype.h>
 #include <err.h>
 #include <errno.h>
 #include <locale.h>
 #include <netdb.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h>
 
 #include <netinet/in.h>
 #include <netinet/tcp.h>
 
 #include "fetch.h"
 #include "common.h"
 #include "httperr.h"
 
 /* Maximum number of redirects to follow */
 #define MAX_REDIRECT 5
 
 /* Symbolic names for reply codes we care about */
 #define HTTP_OK			200
 #define HTTP_PARTIAL		206
 #define HTTP_MOVED_PERM		301
 #define HTTP_MOVED_TEMP		302
 #define HTTP_SEE_OTHER		303
+#define HTTP_NOT_MODIFIED	304
 #define HTTP_TEMP_REDIRECT	307
 #define HTTP_NEED_AUTH		401
 #define HTTP_NEED_PROXY_AUTH	407
 #define HTTP_BAD_RANGE		416
 #define HTTP_PROTOCOL_ERROR	999
 
 #define HTTP_REDIRECT(xyz) ((xyz) == HTTP_MOVED_PERM \
 			    || (xyz) == HTTP_MOVED_TEMP \
 			    || (xyz) == HTTP_TEMP_REDIRECT \
 			    || (xyz) == HTTP_SEE_OTHER)
 
 #define HTTP_ERROR(xyz) ((xyz) > 400 && (xyz) < 599)
 
 
 /*****************************************************************************
  * I/O functions for decoding chunked streams
  */
 
 struct httpio
 {
 	conn_t		*conn;		/* connection */
 	int		 chunked;	/* chunked mode */
 	char		*buf;		/* chunk buffer */
 	size_t		 bufsize;	/* size of chunk buffer */
 	ssize_t		 buflen;	/* amount of data currently in buffer */
 	int		 bufpos;	/* current read offset in buffer */
 	int		 eof;		/* end-of-file flag */
 	int		 error;		/* error flag */
 	size_t		 chunksize;	/* remaining size of current chunk */
 #ifndef NDEBUG
 	size_t		 total;
 #endif
 };
 
 /*
  * Get next chunk header
  */
 static int
 http_new_chunk(struct httpio *io)
 {
 	char *p;
 
 	if (fetch_getln(io->conn) == -1)
 		return (-1);
 
 	if (io->conn->buflen < 2 || !isxdigit((unsigned char)*io->conn->buf))
 		return (-1);
 
 	for (p = io->conn->buf; *p && !isspace((unsigned char)*p); ++p) {
 		if (*p == ';')
 			break;
 		if (!isxdigit((unsigned char)*p))
 			return (-1);
 		if (isdigit((unsigned char)*p)) {
 			io->chunksize = io->chunksize * 16 +
 			    *p - '0';
 		} else {
 			io->chunksize = io->chunksize * 16 +
 			    10 + tolower((unsigned char)*p) - 'a';
 		}
 	}
 
 #ifndef NDEBUG
 	if (fetchDebug) {
 		io->total += io->chunksize;
 		if (io->chunksize == 0)
 			fprintf(stderr, "%s(): end of last chunk\n", __func__);
 		else
 			fprintf(stderr, "%s(): new chunk: %lu (%lu)\n",
 			    __func__, (unsigned long)io->chunksize,
 			    (unsigned long)io->total);
 	}
 #endif
 
 	return (io->chunksize);
 }
 
 /*
  * Grow the input buffer to at least len bytes
  */
 static inline int
 http_growbuf(struct httpio *io, size_t len)
 {
 	char *tmp;
 
 	if (io->bufsize >= len)
 		return (0);
 
 	if ((tmp = realloc(io->buf, len)) == NULL)
 		return (-1);
 	io->buf = tmp;
 	io->bufsize = len;
 	return (0);
 }
 
 /*
  * Fill the input buffer, do chunk decoding on the fly
  */
 static int
 http_fillbuf(struct httpio *io, size_t len)
 {
 	if (io->error)
 		return (-1);
 	if (io->eof)
 		return (0);
 
 	if (io->chunked == 0) {
 		if (http_growbuf(io, len) == -1)
 			return (-1);
 		if ((io->buflen = fetch_read(io->conn, io->buf, len)) == -1) {
 			io->error = 1;
 			return (-1);
 		}
 		io->bufpos = 0;
 		return (io->buflen);
 	}
 
 	if (io->chunksize == 0) {
 		switch (http_new_chunk(io)) {
 		case -1:
 			io->error = 1;
 			return (-1);
 		case 0:
 			io->eof = 1;
 			return (0);
 		}
 	}
 
 	if (len > io->chunksize)
 		len = io->chunksize;
 	if (http_growbuf(io, len) == -1)
 		return (-1);
 	if ((io->buflen = fetch_read(io->conn, io->buf, len)) == -1) {
 		io->error = 1;
 		return (-1);
 	}
 	io->chunksize -= io->buflen;
 
 	if (io->chunksize == 0) {
 		char endl[2];
 
 		if (fetch_read(io->conn, endl, 2) != 2 ||
 		    endl[0] != '\r' || endl[1] != '\n')
 			return (-1);
 	}
 
 	io->bufpos = 0;
 
 	return (io->buflen);
 }
 
 /*
  * Read function
  */
 static int
 http_readfn(void *v, char *buf, int len)
 {
 	struct httpio *io = (struct httpio *)v;
 	int l, pos;
 
 	if (io->error)
 		return (-1);
 	if (io->eof)
 		return (0);
 
 	for (pos = 0; len > 0; pos += l, len -= l) {
 		/* empty buffer */
 		if (!io->buf || io->bufpos == io->buflen)
 			if (http_fillbuf(io, len) < 1)
 				break;
 		l = io->buflen - io->bufpos;
 		if (len < l)
 			l = len;
 		memcpy(buf + pos, io->buf + io->bufpos, l);
 		io->bufpos += l;
 	}
 
 	if (!pos && io->error)
 		return (-1);
 	return (pos);
 }
 
 /*
  * Write function
  */
 static int
 http_writefn(void *v, const char *buf, int len)
 {
 	struct httpio *io = (struct httpio *)v;
 
 	return (fetch_write(io->conn, buf, len));
 }
 
 /*
  * Close function
  */
 static int
 http_closefn(void *v)
 {
 	struct httpio *io = (struct httpio *)v;
 	int r;
 
 	r = fetch_close(io->conn);
 	if (io->buf)
 		free(io->buf);
 	free(io);
 	return (r);
 }
 
 /*
  * Wrap a file descriptor up
  */
 static FILE *
 http_funopen(conn_t *conn, int chunked)
 {
 	struct httpio *io;
 	FILE *f;
 
 	if ((io = calloc(1, sizeof(*io))) == NULL) {
 		fetch_syserr();
 		return (NULL);
 	}
 	io->conn = conn;
 	io->chunked = chunked;
 	f = funopen(io, http_readfn, http_writefn, NULL, http_closefn);
 	if (f == NULL) {
 		fetch_syserr();
 		free(io);
 		return (NULL);
 	}
 	return (f);
 }
 
 
 /*****************************************************************************
  * Helper functions for talking to the server and parsing its replies
  */
 
 /* Header types */
 typedef enum {
 	hdr_syserror = -2,
 	hdr_error = -1,
 	hdr_end = 0,
 	hdr_unknown = 1,
 	hdr_content_length,
 	hdr_content_range,
 	hdr_last_modified,
 	hdr_location,
 	hdr_transfer_encoding,
 	hdr_www_authenticate
 } hdr_t;
 
 /* Names of interesting headers */
 static struct {
 	hdr_t		 num;
 	const char	*name;
 } hdr_names[] = {
 	{ hdr_content_length,		"Content-Length" },
 	{ hdr_content_range,		"Content-Range" },
 	{ hdr_last_modified,		"Last-Modified" },
 	{ hdr_location,			"Location" },
 	{ hdr_transfer_encoding,	"Transfer-Encoding" },
 	{ hdr_www_authenticate,		"WWW-Authenticate" },
 	{ hdr_unknown,			NULL },
 };
 
 /*
  * Send a formatted line; optionally echo to terminal
  */
 static int
 http_cmd(conn_t *conn, const char *fmt, ...)
 {
 	va_list ap;
 	size_t len;
 	char *msg;
 	int r;
 
 	va_start(ap, fmt);
 	len = vasprintf(&msg, fmt, ap);
 	va_end(ap);
 
 	if (msg == NULL) {
 		errno = ENOMEM;
 		fetch_syserr();
 		return (-1);
 	}
 
 	r = fetch_putln(conn, msg, len);
 	free(msg);
 
 	if (r == -1) {
 		fetch_syserr();
 		return (-1);
 	}
 
 	return (0);
 }
 
 /*
  * Get and parse status line
  */
 static int
 http_get_reply(conn_t *conn)
 {
 	char *p;
 
 	if (fetch_getln(conn) == -1)
 		return (-1);
 	/*
 	 * A valid status line looks like "HTTP/m.n xyz reason" where m
 	 * and n are the major and minor protocol version numbers and xyz
 	 * is the reply code.
 	 * Unfortunately, there are servers out there (NCSA 1.5.1, to name
 	 * just one) that do not send a version number, so we can't rely
 	 * on finding one, but if we do, insist on it being 1.0 or 1.1.
 	 * We don't care about the reason phrase.
 	 */
 	if (strncmp(conn->buf, "HTTP", 4) != 0)
 		return (HTTP_PROTOCOL_ERROR);
 	p = conn->buf + 4;
 	if (*p == '/') {
 		if (p[1] != '1' || p[2] != '.' || (p[3] != '0' && p[3] != '1'))
 			return (HTTP_PROTOCOL_ERROR);
 		p += 4;
 	}
 	if (*p != ' ' ||
 	    !isdigit((unsigned char)p[1]) ||
 	    !isdigit((unsigned char)p[2]) ||
 	    !isdigit((unsigned char)p[3]))
 		return (HTTP_PROTOCOL_ERROR);
 
 	conn->err = (p[1] - '0') * 100 + (p[2] - '0') * 10 + (p[3] - '0');
 	return (conn->err);
 }
 
 /*
  * Check a header; if the type matches the given string, return a pointer
  * to the beginning of the value.
  */
 static const char *
 http_match(const char *str, const char *hdr)
 {
 	while (*str && *hdr &&
 	    tolower((unsigned char)*str++) == tolower((unsigned char)*hdr++))
 		/* nothing */;
 	if (*str || *hdr != ':')
 		return (NULL);
 	while (*hdr && isspace((unsigned char)*++hdr))
 		/* nothing */;
 	return (hdr);
 }
 
 /*
  * Get the next header and return the appropriate symbolic code.
  */
 static hdr_t
 http_next_header(conn_t *conn, const char **p)
 {
 	int i;
 
 	if (fetch_getln(conn) == -1)
 		return (hdr_syserror);
 	while (conn->buflen && isspace((unsigned char)conn->buf[conn->buflen - 1]))
 		conn->buflen--;
 	conn->buf[conn->buflen] = '\0';
 	if (conn->buflen == 0)
 		return (hdr_end);
 	/*
 	 * We could check for malformed headers but we don't really care.
 	 * A valid header starts with a token immediately followed by a
 	 * colon; a token is any sequence of non-control, non-whitespace
 	 * characters except "()<>@,;:\\\"{}".
 	 */
 	for (i = 0; hdr_names[i].num != hdr_unknown; i++)
 		if ((*p = http_match(hdr_names[i].name, conn->buf)) != NULL)
 			return (hdr_names[i].num);
 	return (hdr_unknown);
 }
 
 /*
  * Parse a last-modified header
  */
 static int
 http_parse_mtime(const char *p, time_t *mtime)
 {
 	char locale[64], *r;
 	struct tm tm;
 
 	strncpy(locale, setlocale(LC_TIME, NULL), sizeof(locale));
 	setlocale(LC_TIME, "C");
 	r = strptime(p, "%a, %d %b %Y %H:%M:%S GMT", &tm);
 	/* XXX should add support for date-2 and date-3 */
 	setlocale(LC_TIME, locale);
 	if (r == NULL)
 		return (-1);
 	DEBUG(fprintf(stderr, "last modified: [%04d-%02d-%02d "
 		  "%02d:%02d:%02d]\n",
 		  tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
 		  tm.tm_hour, tm.tm_min, tm.tm_sec));
 	*mtime = timegm(&tm);
 	return (0);
 }
 
 /*
  * Parse a content-length header
  */
 static int
 http_parse_length(const char *p, off_t *length)
 {
 	off_t len;
 
 	for (len = 0; *p && isdigit((unsigned char)*p); ++p)
 		len = len * 10 + (*p - '0');
 	if (*p)
 		return (-1);
 	DEBUG(fprintf(stderr, "content length: [%lld]\n",
 	    (long long)len));
 	*length = len;
 	return (0);
 }
 
 /*
  * Parse a content-range header
  */
 static int
 http_parse_range(const char *p, off_t *offset, off_t *length, off_t *size)
 {
 	off_t first, last, len;
 
 	if (strncasecmp(p, "bytes ", 6) != 0)
 		return (-1);
 	p += 6;
 	if (*p == '*') {
 		first = last = -1;
 		++p;
 	} else {
 		for (first = 0; *p && isdigit((unsigned char)*p); ++p)
 			first = first * 10 + *p - '0';
 		if (*p != '-')
 			return (-1);
 		for (last = 0, ++p; *p && isdigit((unsigned char)*p); ++p)
 			last = last * 10 + *p - '0';
 	}
 	if (first > last || *p != '/')
 		return (-1);
 	for (len = 0, ++p; *p && isdigit((unsigned char)*p); ++p)
 		len = len * 10 + *p - '0';
 	if (*p || len < last - first + 1)
 		return (-1);
 	if (first == -1) {
 		DEBUG(fprintf(stderr, "content range: [*/%lld]\n",
 		    (long long)len));
 		*length = 0;
 	} else {
 		DEBUG(fprintf(stderr, "content range: [%lld-%lld/%lld]\n",
 		    (long long)first, (long long)last, (long long)len));
 		*length = last - first + 1;
 	}
 	*offset = first;
 	*size = len;
 	return (0);
 }
 
 
 /*****************************************************************************
  * Helper functions for authorization
  */
 
 /*
  * Base64 encoding
  */
 static char *
 http_base64(const char *src)
 {
 	static const char base64[] =
 	    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 	    "abcdefghijklmnopqrstuvwxyz"
 	    "0123456789+/";
 	char *str, *dst;
 	size_t l;
 	int t, r;
 
 	l = strlen(src);
 	if ((str = malloc(((l + 2) / 3) * 4 + 1)) == NULL)
 		return (NULL);
 	dst = str;
 	r = 0;
 
 	while (l >= 3) {
 		t = (src[0] << 16) | (src[1] << 8) | src[2];
 		dst[0] = base64[(t >> 18) & 0x3f];
 		dst[1] = base64[(t >> 12) & 0x3f];
 		dst[2] = base64[(t >> 6) & 0x3f];
 		dst[3] = base64[(t >> 0) & 0x3f];
 		src += 3; l -= 3;
 		dst += 4; r += 4;
 	}
 
 	switch (l) {
 	case 2:
 		t = (src[0] << 16) | (src[1] << 8);
 		dst[0] = base64[(t >> 18) & 0x3f];
 		dst[1] = base64[(t >> 12) & 0x3f];
 		dst[2] = base64[(t >> 6) & 0x3f];
 		dst[3] = '=';
 		dst += 4;
 		r += 4;
 		break;
 	case 1:
 		t = src[0] << 16;
 		dst[0] = base64[(t >> 18) & 0x3f];
 		dst[1] = base64[(t >> 12) & 0x3f];
 		dst[2] = dst[3] = '=';
 		dst += 4;
 		r += 4;
 		break;
 	case 0:
 		break;
 	}
 
 	*dst = 0;
 	return (str);
 }
 
 /*
  * Encode username and password
  */
 static int
 http_basic_auth(conn_t *conn, const char *hdr, const char *usr, const char *pwd)
 {
 	char *upw, *auth;
 	int r;
 
 	DEBUG(fprintf(stderr, "usr: [%s]\n", usr));
 	DEBUG(fprintf(stderr, "pwd: [%s]\n", pwd));
 	if (asprintf(&upw, "%s:%s", usr, pwd) == -1)
 		return (-1);
 	auth = http_base64(upw);
 	free(upw);
 	if (auth == NULL)
 		return (-1);
 	r = http_cmd(conn, "%s: Basic %s", hdr, auth);
 	free(auth);
 	return (r);
 }
 
 /*
  * Send an authorization header
  */
 static int
 http_authorize(conn_t *conn, const char *hdr, const char *p)
 {
 	/* basic authorization */
 	if (strncasecmp(p, "basic:", 6) == 0) {
 		char *user, *pwd, *str;
 		int r;
 
 		/* skip realm */
 		for (p += 6; *p && *p != ':'; ++p)
 			/* nothing */ ;
 		if (!*p || strchr(++p, ':') == NULL)
 			return (-1);
 		if ((str = strdup(p)) == NULL)
 			return (-1); /* XXX */
 		user = str;
 		pwd = strchr(str, ':');
 		*pwd++ = '\0';
 		r = http_basic_auth(conn, hdr, user, pwd);
 		free(str);
 		return (r);
 	}
 	return (-1);
 }
 
 
 /*****************************************************************************
  * Helper functions for connecting to a server or proxy
  */
 
 /*
  * Connect to the correct HTTP server or proxy.
  */
 static conn_t *
 http_connect(struct url *URL, struct url *purl, const char *flags)
 {
 	conn_t *conn;
 	int verbose;
 	int af, val;
 
 #ifdef INET6
 	af = AF_UNSPEC;
 #else
 	af = AF_INET;
 #endif
 
 	verbose = CHECK_FLAG('v');
 	if (CHECK_FLAG('4'))
 		af = AF_INET;
 #ifdef INET6
 	else if (CHECK_FLAG('6'))
 		af = AF_INET6;
 #endif
 
 	if (purl && strcasecmp(URL->scheme, SCHEME_HTTPS) != 0) {
 		URL = purl;
 	} else if (strcasecmp(URL->scheme, SCHEME_FTP) == 0) {
 		/* can't talk http to an ftp server */
 		/* XXX should set an error code */
 		return (NULL);
 	}
 
 	if ((conn = fetch_connect(URL->host, URL->port, af, verbose)) == NULL)
 		/* fetch_connect() has already set an error code */
 		return (NULL);
 	if (strcasecmp(URL->scheme, SCHEME_HTTPS) == 0 &&
 	    fetch_ssl(conn, verbose) == -1) {
 		fetch_close(conn);
 		/* grrr */
 		errno = EAUTH;
 		fetch_syserr();
 		return (NULL);
 	}
 
 	val = 1;
 	setsockopt(conn->sd, IPPROTO_TCP, TCP_NOPUSH, &val, sizeof(val));
 
 	return (conn);
 }
 
 static struct url *
 http_get_proxy(struct url * url, const char *flags)
 {
 	struct url *purl;
 	char *p;
 
 	if (flags != NULL && strchr(flags, 'd') != NULL)
 		return (NULL);
 	if (fetch_no_proxy_match(url->host))
 		return (NULL);
 	if (((p = getenv("HTTP_PROXY")) || (p = getenv("http_proxy"))) &&
 	    *p && (purl = fetchParseURL(p))) {
 		if (!*purl->scheme)
 			strcpy(purl->scheme, SCHEME_HTTP);
 		if (!purl->port)
 			purl->port = fetch_default_proxy_port(purl->scheme);
 		if (strcasecmp(purl->scheme, SCHEME_HTTP) == 0)
 			return (purl);
 		fetchFreeURL(purl);
 	}
 	return (NULL);
 }
 
 static void
 http_print_html(FILE *out, FILE *in)
 {
 	size_t len;
 	char *line, *p, *q;
 	int comment, tag;
 
 	comment = tag = 0;
 	while ((line = fgetln(in, &len)) != NULL) {
 		while (len && isspace((unsigned char)line[len - 1]))
 			--len;
 		for (p = q = line; q < line + len; ++q) {
 			if (comment && *q == '-') {
 				if (q + 2 < line + len &&
 				    strcmp(q, "-->") == 0) {
 					tag = comment = 0;
 					q += 2;
 				}
 			} else if (tag && !comment && *q == '>') {
 				p = q + 1;
 				tag = 0;
 			} else if (!tag && *q == '<') {
 				if (q > p)
 					fwrite(p, q - p, 1, out);
 				tag = 1;
 				if (q + 3 < line + len &&
 				    strcmp(q, "<!--") == 0) {
 					comment = 1;
 					q += 3;
 				}
 			}
 		}
 		if (!tag && q > p)
 			fwrite(p, q - p, 1, out);
 		fputc('\n', out);
 	}
 }
 
 
 /*****************************************************************************
  * Core
  */
 
 /*
  * Send a request and process the reply
  *
  * XXX This function is way too long, the do..while loop should be split
  * XXX off into a separate function.
  */
 FILE *
 http_request(struct url *URL, const char *op, struct url_stat *us,
     struct url *purl, const char *flags)
 {
+	char timebuf[80];
+	char hbuf[MAXHOSTNAMELEN + 7], *host;
 	conn_t *conn;
 	struct url *url, *new;
-	int chunked, direct, need_auth, noredirect, verbose;
+	int chunked, direct, ims, need_auth, noredirect, verbose;
 	int e, i, n, val;
 	off_t offset, clength, length, size;
 	time_t mtime;
 	const char *p;
 	FILE *f;
 	hdr_t h;
-	char hbuf[MAXHOSTNAMELEN + 7], *host;
+	struct tm *timestruct;
 
 	direct = CHECK_FLAG('d');
 	noredirect = CHECK_FLAG('A');
 	verbose = CHECK_FLAG('v');
+	ims = CHECK_FLAG('i');
 
 	if (direct && purl) {
 		fetchFreeURL(purl);
 		purl = NULL;
 	}
 
 	/* try the provided URL first */
 	url = URL;
 
 	/* if the A flag is set, we only get one try */
 	n = noredirect ? 1 : MAX_REDIRECT;
 	i = 0;
 
 	e = HTTP_PROTOCOL_ERROR;
 	need_auth = 0;
 	do {
 		new = NULL;
 		chunked = 0;
 		offset = 0;
 		clength = -1;
 		length = -1;
 		size = -1;
 		mtime = 0;
 
 		/* check port */
 		if (!url->port)
 			url->port = fetch_default_port(url->scheme);
 
 		/* were we redirected to an FTP URL? */
 		if (purl == NULL && strcmp(url->scheme, SCHEME_FTP) == 0) {
 			if (strcmp(op, "GET") == 0)
 				return (ftp_request(url, "RETR", us, purl, flags));
 			else if (strcmp(op, "HEAD") == 0)
 				return (ftp_request(url, "STAT", us, purl, flags));
 		}
 
 		/* connect to server or proxy */
 		if ((conn = http_connect(url, purl, flags)) == NULL)
 			goto ouch;
 
 		host = url->host;
 #ifdef INET6
 		if (strchr(url->host, ':')) {
 			snprintf(hbuf, sizeof(hbuf), "[%s]", url->host);
 			host = hbuf;
 		}
 #endif
 		if (url->port != fetch_default_port(url->scheme)) {
 			if (host != hbuf) {
 				strcpy(hbuf, host);
 				host = hbuf;
 			}
 			snprintf(hbuf + strlen(hbuf),
 			    sizeof(hbuf) - strlen(hbuf), ":%d", url->port);
 		}
 
 		/* send request */
 		if (verbose)
 			fetch_info("requesting %s://%s%s",
 			    url->scheme, host, url->doc);
 		if (purl) {
 			http_cmd(conn, "%s %s://%s%s HTTP/1.1",
 			    op, url->scheme, host, url->doc);
 		} else {
 			http_cmd(conn, "%s %s HTTP/1.1",
 			    op, url->doc);
 		}
 
+		if (ims && url->ims_time) {
+			timestruct = gmtime((time_t *)&url->ims_time);
+			(void)strftime(timebuf, 80, "%a, %d %b %Y %T GMT",
+			    timestruct);
+			if (verbose)
+				fetch_info("If-Modified-Since: %s", timebuf);
+			http_cmd(conn, "If-Modified-Since: %s", timebuf);
+		}
 		/* virtual host */
 		http_cmd(conn, "Host: %s", host);
 
 		/* proxy authorization */
 		if (purl) {
 			if (*purl->user || *purl->pwd)
 				http_basic_auth(conn, "Proxy-Authorization",
 				    purl->user, purl->pwd);
 			else if ((p = getenv("HTTP_PROXY_AUTH")) != NULL && *p != '\0')
 				http_authorize(conn, "Proxy-Authorization", p);
 		}
 
 		/* server authorization */
 		if (need_auth || *url->user || *url->pwd) {
 			if (*url->user || *url->pwd)
 				http_basic_auth(conn, "Authorization", url->user, url->pwd);
 			else if ((p = getenv("HTTP_AUTH")) != NULL && *p != '\0')
 				http_authorize(conn, "Authorization", p);
 			else if (fetchAuthMethod && fetchAuthMethod(url) == 0) {
 				http_basic_auth(conn, "Authorization", url->user, url->pwd);
 			} else {
 				http_seterr(HTTP_NEED_AUTH);
 				goto ouch;
 			}
 		}
 
 		/* other headers */
 		if ((p = getenv("HTTP_REFERER")) != NULL && *p != '\0') {
 			if (strcasecmp(p, "auto") == 0)
 				http_cmd(conn, "Referer: %s://%s%s",
 				    url->scheme, host, url->doc);
 			else
 				http_cmd(conn, "Referer: %s", p);
 		}
 		if ((p = getenv("HTTP_USER_AGENT")) != NULL && *p != '\0')
 			http_cmd(conn, "User-Agent: %s", p);
 		else
 			http_cmd(conn, "User-Agent: %s " _LIBFETCH_VER, getprogname());
 		if (url->offset > 0)
 			http_cmd(conn, "Range: bytes=%lld-", (long long)url->offset);
 		http_cmd(conn, "Connection: close");
 		http_cmd(conn, "");
 
 		/*
 		 * Force the queued request to be dispatched.  Normally, one
 		 * would do this with shutdown(2) but squid proxies can be
 		 * configured to disallow such half-closed connections.  To
 		 * be compatible with such configurations, fiddle with socket
 		 * options to force the pending data to be written.
 		 */
 		val = 0;
 		setsockopt(conn->sd, IPPROTO_TCP, TCP_NOPUSH, &val,
 			   sizeof(val));
 		val = 1;
 		setsockopt(conn->sd, IPPROTO_TCP, TCP_NODELAY, &val,
 			   sizeof(val));
 
 		/* get reply */
 		switch (http_get_reply(conn)) {
 		case HTTP_OK:
 		case HTTP_PARTIAL:
+		case HTTP_NOT_MODIFIED:
 			/* fine */
 			break;
 		case HTTP_MOVED_PERM:
 		case HTTP_MOVED_TEMP:
 		case HTTP_SEE_OTHER:
 			/*
 			 * Not so fine, but we still have to read the
 			 * headers to get the new location.
 			 */
 			break;
 		case HTTP_NEED_AUTH:
 			if (need_auth) {
 				/*
 				 * We already sent out authorization code,
 				 * so there's nothing more we can do.
 				 */
 				http_seterr(conn->err);
 				goto ouch;
 			}
 			/* try again, but send the password this time */
 			if (verbose)
 				fetch_info("server requires authorization");
 			break;
 		case HTTP_NEED_PROXY_AUTH:
 			/*
 			 * If we're talking to a proxy, we already sent
 			 * our proxy authorization code, so there's
 			 * nothing more we can do.
 			 */
 			http_seterr(conn->err);
 			goto ouch;
 		case HTTP_BAD_RANGE:
 			/*
 			 * This can happen if we ask for 0 bytes because
 			 * we already have the whole file.  Consider this
 			 * a success for now, and check sizes later.
 			 */
 			break;
 		case HTTP_PROTOCOL_ERROR:
 			/* fall through */
 		case -1:
 			fetch_syserr();
 			goto ouch;
 		default:
 			http_seterr(conn->err);
 			if (!verbose)
 				goto ouch;
 			/* fall through so we can get the full error message */
 		}
 
 		/* get headers */
 		do {
 			switch ((h = http_next_header(conn, &p))) {
 			case hdr_syserror:
 				fetch_syserr();
 				goto ouch;
 			case hdr_error:
 				http_seterr(HTTP_PROTOCOL_ERROR);
 				goto ouch;
 			case hdr_content_length:
 				http_parse_length(p, &clength);
 				break;
 			case hdr_content_range:
 				http_parse_range(p, &offset, &length, &size);
 				break;
 			case hdr_last_modified:
 				http_parse_mtime(p, &mtime);
 				break;
 			case hdr_location:
 				if (!HTTP_REDIRECT(conn->err))
 					break;
 				if (new)
 					free(new);
 				if (verbose)
 					fetch_info("%d redirect to %s", conn->err, p);
 				if (*p == '/')
 					/* absolute path */
 					new = fetchMakeURL(url->scheme, url->host, url->port, p,
 					    url->user, url->pwd);
 				else
 					new = fetchParseURL(p);
 				if (new == NULL) {
 					/* XXX should set an error code */
 					DEBUG(fprintf(stderr, "failed to parse new URL\n"));
 					goto ouch;
 				}
 				if (!*new->user && !*new->pwd) {
 					strcpy(new->user, url->user);
 					strcpy(new->pwd, url->pwd);
 				}
 				new->offset = url->offset;
 				new->length = url->length;
 				break;
 			case hdr_transfer_encoding:
 				/* XXX weak test*/
 				chunked = (strcasecmp(p, "chunked") == 0);
 				break;
 			case hdr_www_authenticate:
 				if (conn->err != HTTP_NEED_AUTH)
 					break;
 				/* if we were smarter, we'd check the method and realm */
 				break;
 			case hdr_end:
 				/* fall through */
 			case hdr_unknown:
 				/* ignore */
 				break;
 			}
 		} while (h > hdr_end);
 
 		/* we need to provide authentication */
 		if (conn->err == HTTP_NEED_AUTH) {
 			e = conn->err;
 			need_auth = 1;
 			fetch_close(conn);
 			conn = NULL;
 			continue;
 		}
 
 		/* requested range not satisfiable */
 		if (conn->err == HTTP_BAD_RANGE) {
 			if (url->offset == size && url->length == 0) {
 				/* asked for 0 bytes; fake it */
 				offset = url->offset;
 				clength = -1;
 				conn->err = HTTP_OK;
 				break;
 			} else {
 				http_seterr(conn->err);
 				goto ouch;
 			}
 		}
 
 		/* we have a hit or an error */
-		if (conn->err == HTTP_OK || conn->err == HTTP_PARTIAL || HTTP_ERROR(conn->err))
+		if (conn->err == HTTP_OK
+		    || conn->err == HTTP_NOT_MODIFIED
+		    || conn->err == HTTP_PARTIAL
+		    || HTTP_ERROR(conn->err))
 			break;
 
 		/* all other cases: we got a redirect */
 		e = conn->err;
 		need_auth = 0;
 		fetch_close(conn);
 		conn = NULL;
 		if (!new) {
 			DEBUG(fprintf(stderr, "redirect with no new location\n"));
 			break;
 		}
 		if (url != URL)
 			fetchFreeURL(url);
 		url = new;
 	} while (++i < n);
 
 	/* we failed, or ran out of retries */
 	if (conn == NULL) {
 		http_seterr(e);
 		goto ouch;
 	}
 
 	DEBUG(fprintf(stderr, "offset %lld, length %lld,"
 		  " size %lld, clength %lld\n",
 		  (long long)offset, (long long)length,
 		  (long long)size, (long long)clength));
+
+	if (conn->err == HTTP_NOT_MODIFIED) {
+		http_seterr(HTTP_NOT_MODIFIED);
+		return (NULL);
+	}
 
 	/* check for inconsistencies */
 	if (clength != -1 && length != -1 && clength != length) {
 		http_seterr(HTTP_PROTOCOL_ERROR);
 		goto ouch;
 	}
 	if (clength == -1)
 		clength = length;
 	if (clength != -1)
 		length = offset + clength;
 	if (length != -1 && size != -1 && length != size) {
 		http_seterr(HTTP_PROTOCOL_ERROR);
 		goto ouch;
 	}
 	if (size == -1)
 		size = length;
 
 	/* fill in stats */
 	if (us) {
 		us->size = size;
 		us->atime = us->mtime = mtime;
 	}
 
 	/* too far? */
 	if (URL->offset > 0 && offset > URL->offset) {
 		http_seterr(HTTP_PROTOCOL_ERROR);
 		goto ouch;
 	}
 
 	/* report back real offset and size */
 	URL->offset = offset;
 	URL->length = clength;
 
 	/* wrap it up in a FILE */
 	if ((f = http_funopen(conn, chunked)) == NULL) {
 		fetch_syserr();
 		goto ouch;
 	}
 
 	if (url != URL)
 		fetchFreeURL(url);
 	if (purl)
 		fetchFreeURL(purl);
 
 	if (HTTP_ERROR(conn->err)) {
 		http_print_html(stderr, f);
 		fclose(f);
 		f = NULL;
 	}
 
 	return (f);
 
 ouch:
 	if (url != URL)
 		fetchFreeURL(url);
 	if (purl)
 		fetchFreeURL(purl);
 	if (conn != NULL)
 		fetch_close(conn);
 	return (NULL);
 }
 
 
 /*****************************************************************************
  * Entry points
  */
 
 /*
  * Retrieve and stat a file by HTTP
  */
 FILE *
 fetchXGetHTTP(struct url *URL, struct url_stat *us, const char *flags)
 {
 	return (http_request(URL, "GET", us, http_get_proxy(URL, flags), flags));
 }
 
 /*
  * Retrieve a file by HTTP
  */
 FILE *
 fetchGetHTTP(struct url *URL, const char *flags)
 {
 	return (fetchXGetHTTP(URL, NULL, flags));
 }
 
 /*
  * Store a file by HTTP
  */
 FILE *
 fetchPutHTTP(struct url *URL __unused, const char *flags __unused)
 {
 	warnx("fetchPutHTTP(): not implemented");
 	return (NULL);
 }
 
 /*
  * Get an HTTP document's metadata
  */
 int
 fetchStatHTTP(struct url *URL, struct url_stat *us, const char *flags)
 {
 	FILE *f;
 
 	f = http_request(URL, "HEAD", us, http_get_proxy(URL, flags), flags);
 	if (f == NULL)
 		return (-1);
 	fclose(f);
 	return (0);
 }
 
 /*
  * List a directory
  */
 struct url_ent *
 fetchListHTTP(struct url *url __unused, const char *flags __unused)
 {
 	warnx("fetchListHTTP(): not implemented");
 	return (NULL);
 }
Index: head/usr.bin/fetch/fetch.1
===================================================================
--- head/usr.bin/fetch/fetch.1	(revision 186123)
+++ head/usr.bin/fetch/fetch.1	(revision 186124)
@@ -1,289 +1,303 @@
 .\"-
 .\" Copyright (c) 2000-2004 Dag-Erling Coïdan Smørgrav
 .\" All rights reserved.
 .\" Portions Copyright (c) 1999 Massachusetts Institute of Technology; used
 .\" by permission.
 .\"
 .\" Redistribution and use in source and binary forms, with or without
 .\" modification, are permitted provided 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
 .\"    in this position and unchanged.
 .\" 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.
 .\" 3. The name of the author may not be used to endorse or promote products
 .\"    derived from this software without specific prior written permission.
 .\"
 .\" 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$
 .\"
-.Dd March 11, 2003
+.Dd December 14, 2008
 .Dt FETCH 1
 .Os
 .Sh NAME
 .Nm fetch
 .Nd retrieve a file by Uniform Resource Locator
 .Sh SYNOPSIS
 .Nm
 .Op Fl 146AadFlMmnPpqRrsUv
 .Op Fl B Ar bytes
+.Op Fl i Ar file
 .Op Fl N Ar file
 .Op Fl o Ar file
 .Op Fl S Ar bytes
 .Op Fl T Ar seconds
 .Op Fl w Ar seconds
 .Ar URL ...
 .Nm
 .Op Fl 146AadFlMmnPpqRrsUv
 .Op Fl B Ar bytes
+.Op Fl i Ar file
 .Op Fl N Ar file
 .Op Fl o Ar file
 .Op Fl S Ar bytes
 .Op Fl T Ar seconds
 .Op Fl w Ar seconds
 .Fl h Ar host Fl f Ar file Oo Fl c Ar dir Oc
 .Sh DESCRIPTION
 The
 .Nm
 utility provides a command-line interface to the
 .Xr fetch 3
 library.
 Its purpose is to retrieve the file(s) pointed to by the URL(s) on the
 command line.
 .Pp
 The following options are available:
 .Bl -tag -width Fl
 .It Fl 1
 Stop and return exit code 0 at the first successfully retrieved file.
 .It Fl 4
 Forces
 .Nm
 to use IPv4 addresses only.
 .It Fl 6
 Forces
 .Nm
 to use IPv6 addresses only.
 .It Fl A
 Do not automatically follow ``temporary'' (302) redirects.
 Some broken Web sites will return a redirect instead of a not-found
 error when the requested object does not exist.
 .It Fl a
 Automatically retry the transfer upon soft failures.
 .It Fl B Ar bytes
 Specify the read buffer size in bytes.
 The default is 4096 bytes.
 Attempts to set a buffer size lower than this will be silently
 ignored.
 The number of reads actually performed is reported at verbosity level
 two or higher (see the
 .Fl v
 flag).
 .It Fl c Ar dir
 The file to retrieve is in directory
 .Ar dir
 on the remote host.
 This option is deprecated and is provided for backward compatibility
 only.
 .It Fl d
 Use a direct connection even if a proxy is configured.
 .It Fl F
 In combination with the
 .Fl r
 flag, forces a restart even if the local and remote files have
 different modification times.
 Implies
 .Fl R .
 .It Fl f Ar file
 The file to retrieve is named
 .Ar file
 on the remote host.
 This option is deprecated and is provided for backward compatibility
 only.
 .It Fl h Ar host
 The file to retrieve is located on the host
 .Ar host .
 This option is deprecated and is provided for backward compatibility
 only.
+.It Fl i Ar file
+If-Modified-Since mode: the remote file will only be retrieved if it
+is newer than
+.Ar file
+on the local host.
+(HTTP only)
 .It Fl l
 If the target is a file-scheme URL, make a symbolic link to the target
 rather than trying to copy it.
 .It Fl M
 .It Fl m
 Mirror mode: if the file already exists locally and has the same size
 and modification time as the remote file, it will not be fetched.
 Note that the
 .Fl m
 and
 .Fl r
 flags are mutually exclusive.
 .It Fl N Ar file
 Use
 .Ar file
 instead of
 .Pa ~/.netrc
 to look up login names and passwords for FTP sites.
 See
 .Xr ftp 1
 for a description of the file format.
 This feature is experimental.
 .It Fl n
 Do not preserve the modification time of the transferred file.
 .It Fl o Ar file
 Set the output file name to
 .Ar file .
 By default, a ``pathname'' is extracted from the specified URI, and
 its basename is used as the name of the output file.
 A
 .Ar file
 argument of
 .Sq Li \&-
 indicates that results are to be directed to the standard output.
 If the
 .Ar file
 argument is a directory, fetched file(s) will be placed within the
 directory, with name(s) selected as in the default behaviour.
 .It Fl P
 .It Fl p
 Use passive FTP.
 This is useful if you are behind a firewall which blocks incoming
 connections.
 Try this flag if
 .Nm
 seems to hang when retrieving FTP URLs.
 .It Fl q
 Quiet mode.
 .It Fl R
 The output files are precious, and should not be deleted under any
 circumstances, even if the transfer failed or was incomplete.
 .It Fl r
 Restart a previously interrupted transfer.
 Note that the
 .Fl m
 and
 .Fl r
 flags are mutually exclusive.
 .It Fl S Ar bytes
 Require the file size reported by the server to match the specified
 value.
 If it does not, a message is printed and the file is not fetched.
 If the server does not support reporting file sizes, this option is
 ignored and the file is fetched unconditionally.
 .It Fl s
 Print the size in bytes of each requested file, without fetching it.
 .It Fl T Ar seconds
 Set timeout value to
 .Ar seconds .
 Overrides the environment variables
 .Ev FTP_TIMEOUT
 for FTP transfers or
 .Ev HTTP_TIMEOUT
 for HTTP transfers if set.
 .It Fl U
 When using passive FTP, allocate the port for the data connection from
 the low (default) port range.
 See
 .Xr ip 4
 for details on how to specify which port range this corresponds to.
 .It Fl v
 Increase verbosity level.
 .It Fl w Ar seconds
 When the
 .Fl a
 flag is specified, wait this many seconds between successive retries.
 .El
 .Pp
 If
 .Nm
 receives a
 .Dv SIGINFO
 signal (see the
 .Cm status
 argument for
 .Xr stty 1 ) ,
 the current transfer rate statistics will be written to the
 standard error output, in the same format as the standard completion
 message.
 .Sh ENVIRONMENT
 .Bl -tag -width HTTP_TIMEOUT
 .It Ev FTP_TIMEOUT
 Maximum time, in seconds, to wait before aborting an FTP connection.
 .It Ev HTTP_TIMEOUT
 Maximum time, in seconds, to wait before aborting an HTTP connection.
 .El
 .Pp
 See
 .Xr fetch 3
 for a description of additional environment variables, including
 .Ev FETCH_BIND_ADDRESS ,
 .Ev FTP_LOGIN ,
 .Ev FTP_PASSIVE_MODE ,
 .Ev FTP_PASSWORD ,
 .Ev FTP_PROXY ,
 .Ev ftp_proxy ,
 .Ev HTTP_AUTH ,
 .Ev HTTP_PROXY ,
 .Ev http_proxy ,
 .Ev HTTP_PROXY_AUTH ,
 .Ev HTTP_REFERER ,
 .Ev HTTP_USER_AGENT ,
 .Ev NETRC ,
 .Ev NO_PROXY and
 .Ev no_proxy .
 .Sh EXIT STATUS
 The
 .Nm
 command returns zero on success, or one on failure.
 If multiple URLs are listed on the command line,
 .Nm
 will attempt to retrieve each one of them in turn, and will return
 zero only if they were all successfully retrieved.
+.Pp
+If the
+.Fl i
+argument is used and the remote file is not newer than the
+specified file then the command will still return success,
+although no file is transferred.
 .Sh SEE ALSO
 .Xr fetch 3
 .Sh HISTORY
 The
 .Nm
 command appeared in
 .Fx 2.1.5 .
 This implementation first appeared in
 .Fx 4.1 .
 .Sh AUTHORS
 .An -nosplit
 The original implementation of
 .Nm
 was done by
 .An Jean-Marc Zucconi Aq jmz@FreeBSD.org .
 It was extensively re-worked for
 .Fx 2.2
 by
 .An Garrett Wollman Aq wollman@FreeBSD.org ,
 and later completely rewritten to use the
 .Xr fetch 3
 library by
 .An Dag-Erling Sm\(/orgrav Aq des@FreeBSD.org .
 .Sh NOTES
 The
 .Fl b
 and
 .Fl t
 options are no longer supported and will generate warnings.
 They were workarounds for bugs in other OSes which this implementation
 does not trigger.
 .Pp
 One cannot both use the
 .Fl h ,
 .Fl c
 and
 .Fl f
 options and specify URLs on the command line.
Index: head/usr.bin/fetch/fetch.c
===================================================================
--- head/usr.bin/fetch/fetch.c	(revision 186123)
+++ head/usr.bin/fetch/fetch.c	(revision 186124)
@@ -1,987 +1,1008 @@
 /*-
  * Copyright (c) 2000-2004 Dag-Erling Coïdan Smørgrav
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided 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
  *    in this position and unchanged.
  * 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.
  * 3. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission
  *
  * 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.
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include <sys/param.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 
 #include <ctype.h>
 #include <err.h>
 #include <errno.h>
 #include <signal.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sysexits.h>
 #include <termios.h>
 #include <unistd.h>
 
 #include <fetch.h>
 
 #define MINBUFSIZE	4096
 
 /* Option flags */
 int	 A_flag;	/*    -A: do not follow 302 redirects */
 int	 a_flag;	/*    -a: auto retry */
 off_t	 B_size;	/*    -B: buffer size */
 int	 b_flag;	/*!   -b: workaround TCP bug */
 char    *c_dirname;	/*    -c: remote directory */
 int	 d_flag;	/*    -d: direct connection */
 int	 F_flag;	/*    -F: restart without checking mtime  */
 char	*f_filename;	/*    -f: file to fetch */
 char	*h_hostname;	/*    -h: host to fetch from */
+int	 i_flag;	/*    -i: specify input file for mtime comparison */
+char	*i_filename;	/*        name of input file */
 int	 l_flag;	/*    -l: link rather than copy file: URLs */
 int	 m_flag;	/* -[Mm]: mirror mode */
 char	*N_filename;	/*    -N: netrc file name */
 int	 n_flag;	/*    -n: do not preserve modification time */
 int	 o_flag;	/*    -o: specify output file */
 int	 o_directory;	/*        output file is a directory */
 char	*o_filename;	/*        name of output file */
 int	 o_stdout;	/*        output file is stdout */
 int	 once_flag;	/*    -1: stop at first successful file */
 int	 p_flag;	/* -[Pp]: use passive FTP */
 int	 R_flag;	/*    -R: don't delete partially transferred files */
 int	 r_flag;	/*    -r: restart previously interrupted transfer */
 off_t	 S_size;        /*    -S: require size to match */
 int	 s_flag;        /*    -s: show size, don't fetch */
 long	 T_secs = 120;	/*    -T: transfer timeout in seconds */
 int	 t_flag;	/*!   -t: workaround TCP bug */
 int	 U_flag;	/*    -U: do not use high ports */
 int	 v_level = 1;	/*    -v: verbosity level */
 int	 v_tty;		/*        stdout is a tty */
 pid_t	 pgrp;		/*        our process group */
 long	 w_secs;	/*    -w: retry delay */
 int	 family = PF_UNSPEC;	/* -[46]: address family to use */
 
 int	 sigalrm;	/* SIGALRM received */
 int	 siginfo;	/* SIGINFO received */
 int	 sigint;	/* SIGINT received */
 
 long	 ftp_timeout;	/* default timeout for FTP transfers */
 long	 http_timeout;	/* default timeout for HTTP transfers */
 char	*buf;		/* transfer buffer */
 
 
 /*
  * Signal handler
  */
 static void
 sig_handler(int sig)
 {
 	switch (sig) {
 	case SIGALRM:
 		sigalrm = 1;
 		break;
 	case SIGINFO:
 		siginfo = 1;
 		break;
 	case SIGINT:
 		sigint = 1;
 		break;
 	}
 }
 
 struct xferstat {
 	char		 name[64];
 	struct timeval	 start;
 	struct timeval	 last;
 	off_t		 size;
 	off_t		 offset;
 	off_t		 rcvd;
 };
 
 /*
  * Compute and display ETA
  */
 static const char *
 stat_eta(struct xferstat *xs)
 {
 	static char str[16];
 	long elapsed, eta;
 	off_t received, expected;
 
 	elapsed = xs->last.tv_sec - xs->start.tv_sec;
 	received = xs->rcvd - xs->offset;
 	expected = xs->size - xs->rcvd;
 	eta = (long)((double)elapsed * expected / received);
 	if (eta > 3600)
 		snprintf(str, sizeof str, "%02ldh%02ldm",
 		    eta / 3600, (eta % 3600) / 60);
 	else
 		snprintf(str, sizeof str, "%02ldm%02lds",
 		    eta / 60, eta % 60);
 	return (str);
 }
 
 /*
  * Format a number as "xxxx YB" where Y is ' ', 'k', 'M'...
  */
 static const char *prefixes = " kMGTP";
 static const char *
 stat_bytes(off_t bytes)
 {
 	static char str[16];
 	const char *prefix = prefixes;
 
 	while (bytes > 9999 && prefix[1] != '\0') {
 		bytes /= 1024;
 		prefix++;
 	}
 	snprintf(str, sizeof str, "%4jd %cB", (intmax_t)bytes, *prefix);
 	return (str);
 }
 
 /*
  * Compute and display transfer rate
  */
 static const char *
 stat_bps(struct xferstat *xs)
 {
 	static char str[16];
 	double delta, bps;
 
 	delta = (xs->last.tv_sec + (xs->last.tv_usec / 1.e6))
 	    - (xs->start.tv_sec + (xs->start.tv_usec / 1.e6));
 	if (delta == 0.0) {
 		snprintf(str, sizeof str, "?? Bps");
 	} else {
 		bps = (xs->rcvd - xs->offset) / delta;
 		snprintf(str, sizeof str, "%sps", stat_bytes((off_t)bps));
 	}
 	return (str);
 }
 
 /*
  * Update the stats display
  */
 static void
 stat_display(struct xferstat *xs, int force)
 {
 	struct timeval now;
 	int ctty_pgrp;
 
 	/* check if we're the foreground process */
 	if (ioctl(STDERR_FILENO, TIOCGPGRP, &ctty_pgrp) == -1 ||
 	    (pid_t)ctty_pgrp != pgrp)
 		return;
 
 	gettimeofday(&now, NULL);
 	if (!force && now.tv_sec <= xs->last.tv_sec)
 		return;
 	xs->last = now;
 
 	fprintf(stderr, "\r%-46.46s", xs->name);
 	if (xs->size <= 0) {
 		setproctitle("%s [%s]", xs->name, stat_bytes(xs->rcvd));
 		fprintf(stderr, "        %s", stat_bytes(xs->rcvd));
 	} else {
 		setproctitle("%s [%d%% of %s]", xs->name,
 		    (int)((100.0 * xs->rcvd) / xs->size),
 		    stat_bytes(xs->size));
 		fprintf(stderr, "%3d%% of %s",
 		    (int)((100.0 * xs->rcvd) / xs->size),
 		    stat_bytes(xs->size));
 	}
 	fprintf(stderr, " %s", stat_bps(xs));
 	if (xs->size > 0 && xs->rcvd > 0 &&
 	    xs->last.tv_sec >= xs->start.tv_sec + 10)
 		fprintf(stderr, " %s", stat_eta(xs));
 }
 
 /*
  * Initialize the transfer statistics
  */
 static void
 stat_start(struct xferstat *xs, const char *name, off_t size, off_t offset)
 {
 	snprintf(xs->name, sizeof xs->name, "%s", name);
 	gettimeofday(&xs->start, NULL);
 	xs->last.tv_sec = xs->last.tv_usec = 0;
 	xs->size = size;
 	xs->offset = offset;
 	xs->rcvd = offset;
 	if (v_tty && v_level > 0)
 		stat_display(xs, 1);
 	else if (v_level > 0)
 		fprintf(stderr, "%-46s", xs->name);
 }
 
 /*
  * Update the transfer statistics
  */
 static void
 stat_update(struct xferstat *xs, off_t rcvd)
 {
 	xs->rcvd = rcvd;
 	if (v_tty && v_level > 0)
 		stat_display(xs, 0);
 }
 
 /*
  * Finalize the transfer statistics
  */
 static void
 stat_end(struct xferstat *xs)
 {
 	gettimeofday(&xs->last, NULL);
 	if (v_tty && v_level > 0) {
 		stat_display(xs, 1);
 		putc('\n', stderr);
 	} else if (v_level > 0) {
 		fprintf(stderr, "        %s %s\n",
 		    stat_bytes(xs->size), stat_bps(xs));
 	}
 }
 
 /*
  * Ask the user for authentication details
  */
 static int
 query_auth(struct url *URL)
 {
 	struct termios tios;
 	tcflag_t saved_flags;
 	int i, nopwd;
 
 	fprintf(stderr, "Authentication required for <%s://%s:%d/>!\n",
 	    URL->scheme, URL->host, URL->port);
 
 	fprintf(stderr, "Login: ");
 	if (fgets(URL->user, sizeof URL->user, stdin) == NULL)
 		return (-1);
 	for (i = strlen(URL->user); i >= 0; --i)
 		if (URL->user[i] == '\r' || URL->user[i] == '\n')
 			URL->user[i] = '\0';
 
 	fprintf(stderr, "Password: ");
 	if (tcgetattr(STDIN_FILENO, &tios) == 0) {
 		saved_flags = tios.c_lflag;
 		tios.c_lflag &= ~ECHO;
 		tios.c_lflag |= ECHONL|ICANON;
 		tcsetattr(STDIN_FILENO, TCSAFLUSH|TCSASOFT, &tios);
 		nopwd = (fgets(URL->pwd, sizeof URL->pwd, stdin) == NULL);
 		tios.c_lflag = saved_flags;
 		tcsetattr(STDIN_FILENO, TCSANOW|TCSASOFT, &tios);
 	} else {
 		nopwd = (fgets(URL->pwd, sizeof URL->pwd, stdin) == NULL);
 	}
 	if (nopwd)
 		return (-1);
 	for (i = strlen(URL->pwd); i >= 0; --i)
 		if (URL->pwd[i] == '\r' || URL->pwd[i] == '\n')
 			URL->pwd[i] = '\0';
 
 	return (0);
 }
 
 /*
  * Fetch a file
  */
 static int
 fetch(char *URL, const char *path)
 {
 	struct url *url;
 	struct url_stat us;
 	struct stat sb, nsb;
 	struct xferstat xs;
 	FILE *f, *of;
 	size_t size, wr;
 	off_t count;
 	char flags[8];
 	const char *slash;
 	char *tmppath;
 	int r;
 	unsigned timeout;
 	char *ptr;
 
 	f = of = NULL;
 	tmppath = NULL;
 
 	timeout = 0;
 	*flags = 0;
 	count = 0;
 
 	/* set verbosity level */
 	if (v_level > 1)
 		strcat(flags, "v");
 	if (v_level > 2)
 		fetchDebug = 1;
 
 	/* parse URL */
 	if ((url = fetchParseURL(URL)) == NULL) {
 		warnx("%s: parse error", URL);
 		goto failure;
 	}
 
 	/* if no scheme was specified, take a guess */
 	if (!*url->scheme) {
 		if (!*url->host)
 			strcpy(url->scheme, SCHEME_FILE);
 		else if (strncasecmp(url->host, "ftp.", 4) == 0)
 			strcpy(url->scheme, SCHEME_FTP);
 		else if (strncasecmp(url->host, "www.", 4) == 0)
 			strcpy(url->scheme, SCHEME_HTTP);
 	}
 
 	/* common flags */
 	switch (family) {
 	case PF_INET:
 		strcat(flags, "4");
 		break;
 	case PF_INET6:
 		strcat(flags, "6");
 		break;
 	}
 
 	/* FTP specific flags */
 	if (strcmp(url->scheme, SCHEME_FTP) == 0) {
 		if (p_flag)
 			strcat(flags, "p");
 		if (d_flag)
 			strcat(flags, "d");
 		if (U_flag)
 			strcat(flags, "l");
 		timeout = T_secs ? T_secs : ftp_timeout;
 	}
 
 	/* HTTP specific flags */
 	if (strcmp(url->scheme, SCHEME_HTTP) == 0 ||
 	    strcmp(url->scheme, SCHEME_HTTPS) == 0) {
 		if (d_flag)
 			strcat(flags, "d");
 		if (A_flag)
 			strcat(flags, "A");
 		timeout = T_secs ? T_secs : http_timeout;
+		if (i_flag) {
+			if (stat(i_filename, &sb)) {
+				warn("%s: stat()", i_filename);
+				goto failure;
+			}
+			url->ims_time = sb.st_mtime;
+			strcat(flags, "i");
+		}
 	}
 
 	/* set the protocol timeout. */
 	fetchTimeout = timeout;
 
 	/* just print size */
 	if (s_flag) {
 		if (timeout)
 			alarm(timeout);
 		r = fetchStat(url, &us, flags);
 		if (timeout)
 			alarm(0);
 		if (sigalrm || sigint)
 			goto signal;
 		if (r == -1) {
 			warnx("%s", fetchLastErrString);
 			goto failure;
 		}
 		if (us.size == -1)
 			printf("Unknown\n");
 		else
 			printf("%jd\n", (intmax_t)us.size);
 		goto success;
 	}
 
 	/*
 	 * If the -r flag was specified, we have to compare the local
 	 * and remote files, so we should really do a fetchStat()
 	 * first, but I know of at least one HTTP server that only
 	 * sends the content size in response to GET requests, and
 	 * leaves it out of replies to HEAD requests.  Also, in the
 	 * (frequent) case that the local and remote files match but
 	 * the local file is truncated, we have sufficient information
 	 * before the compare to issue a correct request.  Therefore,
 	 * we always issue a GET request as if we were sure the local
 	 * file was a truncated copy of the remote file; we can drop
 	 * the connection later if we change our minds.
 	 */
 	sb.st_size = -1;
 	if (!o_stdout) {
 		r = stat(path, &sb);
 		if (r == 0 && r_flag && S_ISREG(sb.st_mode)) {
 			url->offset = sb.st_size;
 		} else if (r == -1 || !S_ISREG(sb.st_mode)) {
 			/*
 			 * Whatever value sb.st_size has now is either
 			 * wrong (if stat(2) failed) or irrelevant (if the
 			 * path does not refer to a regular file)
 			 */
 			sb.st_size = -1;
 		}
 		if (r == -1 && errno != ENOENT) {
 			warnx("%s: stat()", path);
 			goto failure;
 		}
 	}
 
 	/* start the transfer */
 	if (timeout)
 		alarm(timeout);
 	f = fetchXGet(url, &us, flags);
 	if (timeout)
 		alarm(0);
 	if (sigalrm || sigint)
 		goto signal;
 	if (f == NULL) {
 		warnx("%s: %s", URL, fetchLastErrString);
-		goto failure;
+		if (i_flag && strcmp(url->scheme, SCHEME_HTTP) == 0
+		    && fetchLastErrCode == FETCH_OK
+		    && strcmp(fetchLastErrString, "Not Modified") == 0) {
+			/* HTTP Not Modified Response, return OK. */
+			r = 0;
+			goto done;
+		} else
+			goto failure;
 	}
 	if (sigint)
 		goto signal;
 
 	/* check that size is as expected */
 	if (S_size) {
 		if (us.size == -1) {
 			warnx("%s: size unknown", URL);
 		} else if (us.size != S_size) {
 			warnx("%s: size mismatch: expected %jd, actual %jd",
 			    URL, (intmax_t)S_size, (intmax_t)us.size);
 			goto failure;
 		}
 	}
 
 	/* symlink instead of copy */
 	if (l_flag && strcmp(url->scheme, "file") == 0 && !o_stdout) {
 		if (symlink(url->doc, path) == -1) {
 			warn("%s: symlink()", path);
 			goto failure;
 		}
 		goto success;
 	}
 
 	if (us.size == -1 && !o_stdout && v_level > 0)
 		warnx("%s: size of remote file is not known", URL);
 	if (v_level > 1) {
 		if (sb.st_size != -1)
 			fprintf(stderr, "local size / mtime: %jd / %ld\n",
 			    (intmax_t)sb.st_size, (long)sb.st_mtime);
 		if (us.size != -1)
 			fprintf(stderr, "remote size / mtime: %jd / %ld\n",
 			    (intmax_t)us.size, (long)us.mtime);
 	}
 
 	/* open output file */
 	if (o_stdout) {
 		/* output to stdout */
 		of = stdout;
 	} else if (r_flag && sb.st_size != -1) {
 		/* resume mode, local file exists */
 		if (!F_flag && us.mtime && sb.st_mtime != us.mtime) {
 			/* no match! have to refetch */
 			fclose(f);
 			/* if precious, warn the user and give up */
 			if (R_flag) {
 				warnx("%s: local modification time "
 				    "does not match remote", path);
 				goto failure_keep;
 			}
 		} else if (us.size != -1) {
 			if (us.size == sb.st_size)
 				/* nothing to do */
 				goto success;
 			if (sb.st_size > us.size) {
 				/* local file too long! */
 				warnx("%s: local file (%jd bytes) is longer "
 				    "than remote file (%jd bytes)", path,
 				    (intmax_t)sb.st_size, (intmax_t)us.size);
 				goto failure;
 			}
 			/* we got it, open local file */
 			if ((of = fopen(path, "a")) == NULL) {
 				warn("%s: fopen()", path);
 				goto failure;
 			}
 			/* check that it didn't move under our feet */
 			if (fstat(fileno(of), &nsb) == -1) {
 				/* can't happen! */
 				warn("%s: fstat()", path);
 				goto failure;
 			}
 			if (nsb.st_dev != sb.st_dev ||
 			    nsb.st_ino != nsb.st_ino ||
 			    nsb.st_size != sb.st_size) {
 				warnx("%s: file has changed", URL);
 				fclose(of);
 				of = NULL;
 				sb = nsb;
 			}
 		}
 	} else if (m_flag && sb.st_size != -1) {
 		/* mirror mode, local file exists */
 		if (sb.st_size == us.size && sb.st_mtime == us.mtime)
 			goto success;
 	}
 
 	if (of == NULL) {
 		/*
 		 * We don't yet have an output file; either this is a
 		 * vanilla run with no special flags, or the local and
 		 * remote files didn't match.
 		 */
 
 		if (url->offset > 0) {
 			/*
 			 * We tried to restart a transfer, but for
 			 * some reason gave up - so we have to restart
 			 * from scratch if we want the whole file
 			 */
 			url->offset = 0;
 			if ((f = fetchXGet(url, &us, flags)) == NULL) {
 				warnx("%s: %s", URL, fetchLastErrString);
 				goto failure;
 			}
 			if (sigint)
 				goto signal;
 		}
 
 		/* construct a temp file name */
 		if (sb.st_size != -1 && S_ISREG(sb.st_mode)) {
 			if ((slash = strrchr(path, '/')) == NULL)
 				slash = path;
 			else
 				++slash;
 			asprintf(&tmppath, "%.*s.fetch.XXXXXX.%s",
 			    (int)(slash - path), path, slash);
 			if (tmppath != NULL) {
 				mkstemps(tmppath, strlen(slash) + 1);
 				of = fopen(tmppath, "w");
 				chown(tmppath, sb.st_uid, sb.st_gid);
 				chmod(tmppath, sb.st_mode & ALLPERMS);
 			}
 		}
 		if (of == NULL)
 			of = fopen(path, "w");
 		if (of == NULL) {
 			warn("%s: open()", path);
 			goto failure;
 		}
 	}
 	count = url->offset;
 
 	/* start the counter */
 	stat_start(&xs, path, us.size, count);
 
 	sigalrm = siginfo = sigint = 0;
 
 	/* suck in the data */
 	signal(SIGINFO, sig_handler);
 	while (!sigint) {
 		if (us.size != -1 && us.size - count < B_size &&
 		    us.size - count >= 0)
 			size = us.size - count;
 		else
 			size = B_size;
 		if (siginfo) {
 			stat_end(&xs);
 			siginfo = 0;
 		}
 		if ((size = fread(buf, 1, size, f)) == 0) {
 			if (ferror(f) && errno == EINTR && !sigint)
 				clearerr(f);
 			else
 				break;
 		}
 		stat_update(&xs, count += size);
 		for (ptr = buf; size > 0; ptr += wr, size -= wr)
 			if ((wr = fwrite(ptr, 1, size, of)) < size) {
 				if (ferror(of) && errno == EINTR && !sigint)
 					clearerr(of);
 				else
 					break;
 			}
 		if (size != 0)
 			break;
 	}
 	if (!sigalrm)
 		sigalrm = ferror(f) && errno == ETIMEDOUT;
 	signal(SIGINFO, SIG_DFL);
 
 	stat_end(&xs);
 
 	/*
 	 * If the transfer timed out or was interrupted, we still want to
 	 * set the mtime in case the file is not removed (-r or -R) and
 	 * the user later restarts the transfer.
 	 */
  signal:
 	/* set mtime of local file */
 	if (!n_flag && us.mtime && !o_stdout && of != NULL &&
 	    (stat(path, &sb) != -1) && sb.st_mode & S_IFREG) {
 		struct timeval tv[2];
 
 		fflush(of);
 		tv[0].tv_sec = (long)(us.atime ? us.atime : us.mtime);
 		tv[1].tv_sec = (long)us.mtime;
 		tv[0].tv_usec = tv[1].tv_usec = 0;
 		if (utimes(tmppath ? tmppath : path, tv))
 			warn("%s: utimes()", tmppath ? tmppath : path);
 	}
 
 	/* timed out or interrupted? */
 	if (sigalrm)
 		warnx("transfer timed out");
 	if (sigint) {
 		warnx("transfer interrupted");
 		goto failure;
 	}
 
 	/* timeout / interrupt before connection completley established? */
 	if (f == NULL)
 		goto failure;
 
 	if (!sigalrm) {
 		/* check the status of our files */
 		if (ferror(f))
 			warn("%s", URL);
 		if (ferror(of))
 			warn("%s", path);
 		if (ferror(f) || ferror(of))
 			goto failure;
 	}
 
 	/* did the transfer complete normally? */
 	if (us.size != -1 && count < us.size) {
 		warnx("%s appears to be truncated: %jd/%jd bytes",
 		    path, (intmax_t)count, (intmax_t)us.size);
 		goto failure_keep;
 	}
 
 	/*
 	 * If the transfer timed out and we didn't know how much to
 	 * expect, assume the worst (i.e. we didn't get all of it)
 	 */
 	if (sigalrm && us.size == -1) {
 		warnx("%s may be truncated", path);
 		goto failure_keep;
 	}
 
  success:
 	r = 0;
 	if (tmppath != NULL && rename(tmppath, path) == -1) {
 		warn("%s: rename()", path);
 		goto failure_keep;
 	}
 	goto done;
  failure:
 	if (of && of != stdout && !R_flag && !r_flag)
 		if (stat(path, &sb) != -1 && (sb.st_mode & S_IFREG))
 			unlink(tmppath ? tmppath : path);
 	if (R_flag && tmppath != NULL && sb.st_size == -1)
 		rename(tmppath, path); /* ignore errors here */
  failure_keep:
 	r = -1;
 	goto done;
  done:
 	if (f)
 		fclose(f);
 	if (of && of != stdout)
 		fclose(of);
 	if (url)
 		fetchFreeURL(url);
 	if (tmppath != NULL)
 		free(tmppath);
 	return (r);
 }
 
 static void
 usage(void)
 {
 	fprintf(stderr, "%s\n%s\n%s\n%s\n",
 "usage: fetch [-146AadFlMmnPpqRrsUv] [-B bytes] [-N file] [-o file] [-S bytes]",
-"       [-T seconds] [-w seconds] URL ...",
+"       [-T seconds] [-w seconds] [-i file] URL ...",
 "       fetch [-146AadFlMmnPpqRrsUv] [-B bytes] [-N file] [-o file] [-S bytes]",
-"       [-T seconds] [-w seconds] -h host -f file [-c dir]");
+"       [-T seconds] [-w seconds] [-i file] -h host -f file [-c dir]");
 }
 
 
 /*
  * Entry point
  */
 int
 main(int argc, char *argv[])
 {
 	struct stat sb;
 	struct sigaction sa;
 	const char *p, *s;
 	char *end, *q;
 	int c, e, r;
 
 	while ((c = getopt(argc, argv,
-	    "146AaB:bc:dFf:Hh:lMmN:nPpo:qRrS:sT:tUvw:")) != -1)
+	    "146AaB:bc:dFf:Hh:i:lMmN:nPpo:qRrS:sT:tUvw:")) != -1)
 		switch (c) {
 		case '1':
 			once_flag = 1;
 			break;
 		case '4':
 			family = PF_INET;
 			break;
 		case '6':
 			family = PF_INET6;
 			break;
 		case 'A':
 			A_flag = 1;
 			break;
 		case 'a':
 			a_flag = 1;
 			break;
 		case 'B':
 			B_size = (off_t)strtol(optarg, &end, 10);
 			if (*optarg == '\0' || *end != '\0')
 				errx(1, "invalid buffer size (%s)", optarg);
 			break;
 		case 'b':
 			warnx("warning: the -b option is deprecated");
 			b_flag = 1;
 			break;
 		case 'c':
 			c_dirname = optarg;
 			break;
 		case 'd':
 			d_flag = 1;
 			break;
 		case 'F':
 			F_flag = 1;
 			break;
 		case 'f':
 			f_filename = optarg;
 			break;
 		case 'H':
 			warnx("the -H option is now implicit, "
 			    "use -U to disable");
 			break;
 		case 'h':
 			h_hostname = optarg;
+			break;
+		case 'i':
+			i_flag = 1;
+			i_filename = optarg;
 			break;
 		case 'l':
 			l_flag = 1;
 			break;
 		case 'o':
 			o_flag = 1;
 			o_filename = optarg;
 			break;
 		case 'M':
 		case 'm':
 			if (r_flag)
 				errx(1, "the -m and -r flags "
 				    "are mutually exclusive");
 			m_flag = 1;
 			break;
 		case 'N':
 			N_filename = optarg;
 			break;
 		case 'n':
 			n_flag = 1;
 			break;
 		case 'P':
 		case 'p':
 			p_flag = 1;
 			break;
 		case 'q':
 			v_level = 0;
 			break;
 		case 'R':
 			R_flag = 1;
 			break;
 		case 'r':
 			if (m_flag)
 				errx(1, "the -m and -r flags "
 				    "are mutually exclusive");
 			r_flag = 1;
 			break;
 		case 'S':
 			S_size = (off_t)strtol(optarg, &end, 10);
 			if (*optarg == '\0' || *end != '\0')
 				errx(1, "invalid size (%s)", optarg);
 			break;
 		case 's':
 			s_flag = 1;
 			break;
 		case 'T':
 			T_secs = strtol(optarg, &end, 10);
 			if (*optarg == '\0' || *end != '\0')
 				errx(1, "invalid timeout (%s)", optarg);
 			break;
 		case 't':
 			t_flag = 1;
 			warnx("warning: the -t option is deprecated");
 			break;
 		case 'U':
 			U_flag = 1;
 			break;
 		case 'v':
 			v_level++;
 			break;
 		case 'w':
 			a_flag = 1;
 			w_secs = strtol(optarg, &end, 10);
 			if (*optarg == '\0' || *end != '\0')
 				errx(1, "invalid delay (%s)", optarg);
 			break;
 		default:
 			usage();
 			exit(EX_USAGE);
 		}
 
 	argc -= optind;
 	argv += optind;
 
 	if (h_hostname || f_filename || c_dirname) {
 		if (!h_hostname || !f_filename || argc) {
 			usage();
 			exit(EX_USAGE);
 		}
 		/* XXX this is a hack. */
 		if (strcspn(h_hostname, "@:/") != strlen(h_hostname))
 			errx(1, "invalid hostname");
 		if (asprintf(argv, "ftp://%s/%s/%s", h_hostname,
 		    c_dirname ? c_dirname : "", f_filename) == -1)
 			errx(1, "%s", strerror(ENOMEM));
 		argc++;
 	}
 
 	if (!argc) {
 		usage();
 		exit(EX_USAGE);
 	}
 
 	/* allocate buffer */
 	if (B_size < MINBUFSIZE)
 		B_size = MINBUFSIZE;
 	if ((buf = malloc(B_size)) == NULL)
 		errx(1, "%s", strerror(ENOMEM));
 
 	/* timeouts */
 	if ((s = getenv("FTP_TIMEOUT")) != NULL) {
 		ftp_timeout = strtol(s, &end, 10);
 		if (*s == '\0' || *end != '\0' || ftp_timeout < 0) {
 			warnx("FTP_TIMEOUT (%s) is not a positive integer", s);
 			ftp_timeout = 0;
 		}
 	}
 	if ((s = getenv("HTTP_TIMEOUT")) != NULL) {
 		http_timeout = strtol(s, &end, 10);
 		if (*s == '\0' || *end != '\0' || http_timeout < 0) {
 			warnx("HTTP_TIMEOUT (%s) is not a positive integer", s);
 			http_timeout = 0;
 		}
 	}
 
 	/* signal handling */
 	sa.sa_flags = 0;
 	sa.sa_handler = sig_handler;
 	sigemptyset(&sa.sa_mask);
 	sigaction(SIGALRM, &sa, NULL);
 	sa.sa_flags = SA_RESETHAND;
 	sigaction(SIGINT, &sa, NULL);
 	fetchRestartCalls = 0;
 
 	/* output file */
 	if (o_flag) {
 		if (strcmp(o_filename, "-") == 0) {
 			o_stdout = 1;
 		} else if (stat(o_filename, &sb) == -1) {
 			if (errno == ENOENT) {
 				if (argc > 1)
 					errx(EX_USAGE, "%s is not a directory",
 					    o_filename);
 			} else {
 				err(EX_IOERR, "%s", o_filename);
 			}
 		} else {
 			if (sb.st_mode & S_IFDIR)
 				o_directory = 1;
 		}
 	}
 
 	/* check if output is to a tty (for progress report) */
 	v_tty = isatty(STDERR_FILENO);
 	if (v_tty)
 		pgrp = getpgrp();
 
 	r = 0;
 
 	/* authentication */
 	if (v_tty)
 		fetchAuthMethod = query_auth;
 	if (N_filename != NULL)
 		setenv("NETRC", N_filename, 1);
 
 	while (argc) {
 		if ((p = strrchr(*argv, '/')) == NULL)
 			p = *argv;
 		else
 			p++;
 
 		if (!*p)
 			p = "fetch.out";
 
 		fetchLastErrCode = 0;
 
 		if (o_flag) {
 			if (o_stdout) {
 				e = fetch(*argv, "-");
 			} else if (o_directory) {
 				asprintf(&q, "%s/%s", o_filename, p);
 				e = fetch(*argv, q);
 				free(q);
 			} else {
 				e = fetch(*argv, o_filename);
 			}
 		} else {
 			e = fetch(*argv, p);
 		}
 
 		if (sigint)
 			kill(getpid(), SIGINT);
 
 		if (e == 0 && once_flag)
 			exit(0);
 
 		if (e) {
 			r = 1;
 			if ((fetchLastErrCode
 			    && fetchLastErrCode != FETCH_UNAVAIL
 			    && fetchLastErrCode != FETCH_MOVED
 			    && fetchLastErrCode != FETCH_URL
 			    && fetchLastErrCode != FETCH_RESOLV
 			    && fetchLastErrCode != FETCH_UNKNOWN)) {
 				if (w_secs && v_level)
 					fprintf(stderr, "Waiting %ld seconds "
 					    "before retrying\n", w_secs);
 				if (w_secs)
 					sleep(w_secs);
 				if (a_flag)
 					continue;
 			}
 		}
 
 		argc--, argv++;
 	}
 
 	exit(r);
 }