WGET(1)                            GNU Wget
WGET(1)



NNAAMMEE
       Wget - The non-interactive network downloader.

SSYYNNOOPPSSIISS
       wget [_o_p_t_i_o_n]... [_U_R_L]...

DDEESSCCRRIIPPTTIIOONN
       GNU Wget is a free utility for non-interactive download
       of files from the Web.  It supports HTTP, HTTPS, and FTP
       protocols, as well as retrieval through HTTP proxies.

       Wget is non-interactive, meaning that it can work
       in the background, while the user is not logged on.
       This allows you to start a retrieval and disconnect
       from the system, letting Wget finish the work.
       By contrast, most of the Web browsers require constant
       user's presence, which can be a great hindrance when
       transferring a lot of data.

       Wget can follow links in HTML and XHTML pages and create
       local versions of remote web sites, fully recreating
       the directory structure of the original site.  This is
       sometimes referred to as ``recursive downloading.''
       While doing that, Wget respects the Robot Exclusion
       Standard (_/_r_o_b_o_t_s_._t_x_t).  Wget can
       be instructed to convert the links in downloaded HTML
       files to the local files for offline viewing.

       Wget has been designed for robustness over slow or
       unstable network connections; if a download fails due
       to a network problem, it will keep retrying until the
       whole file has been retrieved.  If the server supports
       regetting, it will instruct the server to continue
       the download from where it left off.

OOPPTTIIOONNSS
   BBaassiicc SSttaarrttuupp OOppttiioonnss
       --VV ----vveerrssiioonn
           Display the version of Wget.

       --hh ----hheellpp
           Print a help message describing all of Wget's
           command-line options.

       --bb ----bbaacckkggrroouunndd
           Go to background immediately after startup.
           If no output file is specified via the --oo,
           output is redirected to _w_g_e_t_-_l_o_g.

       --ee _c_o_m_m_a_n_d ----eexxeeccuuttee
       _c_o_m_m_a_n_d
           Execute _c_o_m_m_a_n_d as if it were a part
           of _._w_g_e_t_r_c.  A command thus invoked
           will be executed _a_f_t_e_r the commands
           in _._w_g_e_t_r_c, thus taking precedence
           over them.

   LLooggggiinngg aanndd IInnppuutt FFiillee
   OOppttiioonnss
       --oo _l_o_g_f_i_l_e
       ----oouuttppuutt--ffiillee==_l_o_g_f_i_l_e
           Log all messages to _l_o_g_f_i_l_e.  The
           messages are normally reported to standard error.

       --aa _l_o_g_f_i_l_e
       ----aappppeenndd--oouuttppuutt==_l_o_g_f_i_l_e
           Append to _l_o_g_f_i_l_e.  This is the same
           as --oo, only it appends to _l_o_g_f_i_l_e
           instead of overwriting the old log file.
           If _l_o_g_f_i_l_e does not exist, a new
           file is created.

       --dd ----ddeebbuugg
           Turn on debug output, meaning various information
           important to the developers of Wget if it does not
           work properly.  Your system administrator may have
           chosen to compile Wget without debug support, in
           which case --dd will not work.  Please note that
           compiling with debug support is always safe---Wget
           compiled with the debug support will _n_o_t
           print any debug info unless requested with --dd.

       --qq ----qquuiieett
           Turn off Wget's output.

       --vv ----vveerrbboossee
           Turn on verbose output, with all the available data.
           The default output is verbose.

       --nnvv ----nnoonn--vveerrbboossee
           Non-verbose output---turn off verbose without being
           completely quiet (use --qq for that), which
           means that error messages and basic information
           still get printed.

       --ii _f_i_l_e
       ----iinnppuutt--ffiillee==_f_i_l_e
           Read URLs from _f_i_l_e, in which case no URLs
           need to be on the command line.  If there are URLs
           both on the command line and in an input file,
           those on the command lines will be the first ones
           to be retrieved.  The _f_i_l_e need not be
           an HTML document (but no harm if it is)---it is
           enough if the URLs are just listed sequentially.

           However, if you specify
           ----ffoorrccee--hhttmmll, the document
           will be regarded as hhttmmll.  In that case
           you may have problems with relative links,
           which you can solve either by adding "<base
           href="_u_r_l_"_>_" to the documents or by
           specifying ----bbaassee==_u_r_l on the
           command line.

       --FF ----ffoorrccee--hhttmmll
           When input is read from a file, force it to
           be treated as an HTML file.  This enables you
           to retrieve relative links from existing HTML
           files on your local disk, by adding "<base
           href="_u_r_l_"_>_" to HTML, or using the
           ----bbaassee command-line option.

       --BB _U_R_L ----bbaassee==_U_R_L
           When used in conjunction with --FF, prepends
           _U_R_L to relative links in the file specified
           by --ii.

   DDoowwnnllooaadd OOppttiioonnss
       ----bbiinndd--aaddddrreessss==_A_D_D_R_E_S_S
           When making client TCP/IP connections, "bind()"
           to _A_D_D_R_E_S_S on the local machine.
           _A_D_D_R_E_S_S may be specified as a hostname
           or IP address.  This option can be useful if your
           machine is bound to multiple IPs.

       --tt _n_u_m_b_e_r
       ----ttrriieess==_n_u_m_b_e_r
           Set number of retries to _n_u_m_b_e_r.
           Specify 0 or iinnff for infinite retrying.
           The default is to retry 20 times, with the exception
           of fatal errors like ``connection refused'' or
           ``not found'' (404), which are not retried.

       --OO _f_i_l_e
       ----oouuttppuutt--ddooccuummeenntt==_f_i_l_e
           The documents will not be written to the appropriate
           files, but all will be concatenated together and
           written to _f_i_l_e.  If _f_i_l_e already
           exists, it will be overwritten.  If the _f_i_l_e
           is --, the documents will be written to standard
           output.  Including this option automatically sets
           the number of tries to 1.

       --nncc ----nnoo--cclloobbbbeerr
           If a file is downloaded more than once in the
           same directory, Wget's behavior depends on a few
           options, including --nncc.  In certain cases,
           the local file will be _c_l_o_b_b_e_r_e_d,
           or overwritten, upon repeated download.  In other
           cases it will be preserved.

           When running Wget without --NN, --nncc, or
           --rr, downloading the same file in the same
           directory will result in the original copy of
           _f_i_l_e being preserved and the second copy
           being named _f_i_l_e..11.  If that file is
           downloaded yet again, the third copy will be named
           _f_i_l_e..22, and so on.  When --nncc
           is specified, this behavior is suppressed,
           and Wget will refuse to download newer copies
           of _f_i_l_e.  Therefore, ``"no-clobber"''
           is actually a misnomer in this mode---it's not
           clobbering that's prevented (as the numeric suffixes
           were already preventing clobbering), but rather
           the multiple version saving that's prevented.

           When running Wget with --rr, but without
           --NN or --nncc, re-downloading a file will
           result in the new copy simply overwriting the old.
           Adding --nncc will prevent this behavior, instead
           causing the original version to be preserved and
           any newer copies on the server to be ignored.

           When running Wget with --NN, with or without
           --rr, the decision as to whether or not to
           download a newer copy of a file depends on the
           local and remote timestamp and size of the file.
           --nncc may not be specified at the same time
           as --NN.

           Note that when --nncc is specified, files with
           the suffixes ..hhttmmll or (yuck) ..hhttmm
           will be loaded from the local disk and parsed as
           if they had been retrieved from the Web.

       --cc ----ccoonnttiinnuuee
           Continue getting a partially-downloaded file.
           This is useful when you want to finish up a
           download started by a previous instance of Wget,
           or by another program.  For instance:

                   wget -c ftp://sunsite.doc.ic.ac.uk/ls-lR.Z

           If there is a file named _l_s_-_l_R_._Z in
           the current directory, Wget will assume that it
           is the first portion of the remote file, and will
           ask the server to continue the retrieval from an
           offset equal to the length of the local file.

           Note that you don't need to specify this option
           if you just want the current invocation of Wget to
           retry downloading a file should the connection be
           lost midway through.  This is the default behavior.
           --cc only affects resumption of downloads started
           _p_r_i_o_r to this invocation of Wget, and
           whose local files are still sitting around.

           Without --cc, the previous example
           would just download the remote file to
           _l_s_-_l_R_._Z_._1, leaving the truncated
           _l_s_-_l_R_._Z file alone.

           Beginning with Wget 1.7, if you use --cc on a
           non-empty file, and it turns out that the server
           does not support continued downloading, Wget will
           refuse to start the download from scratch, which
           would effectively ruin existing contents.  If you
           really want the download to start from scratch,
           remove the file.

           Also beginning with Wget 1.7, if you use --cc
           on a file which is of equal size as the one on the
           server, Wget will refuse to download the file and
           print an explanatory message.  The same happens
           when the file is smaller on the server than locally
           (presumably because it was changed on the server
           since your last download attempt)---because
           ``continuing'' is not meaningful, no download
           occurs.

           On the other side of the coin, while using --cc,
           any file that's bigger on the server than locally
           will be considered an incomplete download and only
           "(length(remote) - length(local))" bytes will be
           downloaded and tacked onto the end of the local
           file.  This behavior can be desirable in certain
           cases---for instance, you can use wwggeett
           --cc to download just the new portion that's
           been appended to a data collection or log file.

           However, if the file is bigger on the server because
           it's been _c_h_a_n_g_e_d, as opposed to just
           _a_p_p_e_n_d_e_d to, you'll end up with a
           garbled file.  Wget has no way of verifying that
           the local file is really a valid prefix of the
           remote file.  You need to be especially careful
           of this when using --cc in conjunction with
           --rr, since every file will be considered as an
           "incomplete download" candidate.

           Another instance where you'll get a garbled file
           if you try to use --cc is if you have a lame HTTP
           proxy that inserts a ``transfer interrupted'' string
           into the local file.  In the future a ``rollback''
           option may be added to deal with this case.

           Note that --cc only works with FTP servers and
           with HTTP servers that support the "Range" header.

       ----pprrooggrreessss==_t_y_p_e
           Select the type of the progress indicator you wish
           to use.  Legal indicators are ``dot'' and ``bar''.

           The ``bar'' indicator is used by default.
           It draws an ASCII progress bar graphics (a.k.a
           ``thermometer'' display) indicating the status
           of retrieval.  If the output is not a TTY, the
           ``dot'' bar will be used by default.

           Use ----pprrooggrreessss==ddoott
           to switch to the ``dot'' display.  It traces the
           retrieval by printing dots on the screen, each
           dot representing a fixed amount of downloaded data.

           When using the dotted retrieval, you may also
           set the _s_t_y_l_e by specifying the type
           as ddoott::_s_t_y_l_e.  Different styles
           assign different meaning to one dot.  With the
           "default" style each dot represents 1K, there
           are ten dots in a cluster and 50 dots in a line.
           The "binary" style has a more ``computer''-like
           orientation---8K dots, 16-dots clusters and
           48 dots per line (which makes for 384K lines).
           The "mega" style is suitable for downloading very
           large files---each dot represents 64K retrieved,
           there are eight dots in a cluster, and 48 dots on
           each line (so each line contains 3M).

           Note that you can set the default style using
           the "progress" command in _._w_g_e_t_r_c.
           That setting may be overridden from the command
           line.  The exception is that, when the output is
           not a TTY, the ``dot'' progress will be favored
           over ``bar''.  To force the bar output, use
           ----pprrooggrreessss==bbaarr::ffoorrccee.

       --NN ----ttiimmeessttaammppiinngg
           Turn on time-stamping.

       --SS
       ----sseerrvveerr--rreessppoonnssee
           Print the headers sent by HTTP servers and responses
           sent by FTP servers.

       ----ssppiiddeerr
           When invoked with this option, Wget will behave
           as a Web _s_p_i_d_e_r, which means that it
           will not download the pages, just check that they
           are there.  For example, you can use Wget to check
           your bookmarks:

                   wget --spider --force-html -i bookmarks.html

           This feature needs much more work for Wget to get
           close to the functionality of real web spiders.

       --TT sseeccoonnddss
       ----ttiimmeeoouutt==_s_e_c_o_n_d_s
           Set the network timeout to _s_e_c_o_n_d_s
           seconds.  This is equivalent to specifying
           ----ddnnss--ttiimmeeoouutt,
           ----ccoonnnneecctt--ttiimmeeoouutt,
           and ----rreeaadd--ttiimmeeoouutt,
           all at the same time.

           Whenever Wget connects to or reads from a remote
           host, it checks for a timeout and aborts the
           operation if the time expires.  This prevents
           anomalous occurrences such as hanging reads or
           infinite connects.  The only timeout enabled
           by default is a 900-second timeout for reading.
           Setting timeout to 0 disables checking for timeouts.

           Unless you know what you are doing, it is best
           not to set any of the timeout-related options.

       ----ddnnss--ttiimmeeoouutt==_s_e_c_o_n_d_s
           Set the DNS lookup timeout to _s_e_c_o_n_d_s
           seconds.  DNS lookups that don't complete within
           the specified time will fail.  By default, there
           is no timeout on DNS lookups, other than that
           implemented by system libraries.

       ----ccoonnnneecctt--ttiimmeeoouutt==_s_e_c_o_n_d_s
           Set the connect timeout to _s_e_c_o_n_d_s
           seconds.  TCP connections that take longer to
           establish will be aborted.  By default, there is
           no connect timeout, other than that implemented
           by system libraries.

       ----rreeaadd--ttiimmeeoouutt==_s_e_c_o_n_d_s
           Set the read (and write) timeout to
           _s_e_c_o_n_d_s seconds.  Reads that take
           longer will fail.  The default value for read
           timeout is 900 seconds.

       ----lliimmiitt--rraattee==_a_m_o_u_n_t
           Limit the download speed to _a_m_o_u_n_t
           bytes per second.  Amount may be expressed
           in bytes, kilobytes with the kk suffix, or
           megabytes with the mm suffix.  For example,
           ----lliimmiitt--rraattee==2200kk
           will limit the retrieval rate to 20KB/s.  This kind
           of thing is useful when, for whatever reason, you
           don't want Wget to consume the entire available
           bandwidth.

           Note that Wget implements the limiting by sleeping
           the appropriate amount of time after a network read
           that took less time than specified by the rate.
           Eventually this strategy causes the TCP transfer
           to slow down to approximately the specified rate.
           However, it may take some time for this balance
           to be achieved, so don't be surprised if limiting
           the rate doesn't work well with very small files.

       --ww _s_e_c_o_n_d_s
       ----wwaaiitt==_s_e_c_o_n_d_s
           Wait the specified number of seconds between the
           retrievals.  Use of this option is recommended, as
           it lightens the server load by making the requests
           less frequent.  Instead of in seconds, the time can
           be specified in minutes using the "m" suffix, in
           hours using "h" suffix, or in days using "d" suffix.

           Specifying a large value for this option is useful
           if the network or the destination host is down, so
           that Wget can wait long enough to reasonably expect
           the network error to be fixed before the retry.

       ----wwaaiittrreettrryy==_s_e_c_o_n_d_s
           If you don't want Wget to wait between
           _e_v_e_r_y retrieval, but only between retries
           of failed downloads, you can use this option.  Wget
           will use _l_i_n_e_a_r _b_a_c_k_o_f_f,
           waiting 1 second after the first failure on a given
           file, then waiting 2 seconds after the second
           failure on that file, up to the maximum number
           of _s_e_c_o_n_d_s you specify.  Therefore,
           a value of 10 will actually make Wget wait up to
           (1 + 2 + ... + 10) = 55 seconds per file.

           Note that this option is turned on by default in
           the global _w_g_e_t_r_c file.

       ----rraannddoomm--wwaaiitt
           Some web sites may perform log analysis to identify
           retrieval programs such as Wget by looking for
           statistically significant similarities in the
           time between requests. This option causes the
           time between requests to vary between 0 and 2 *
           _w_a_i_t seconds, where _w_a_i_t was
           specified using the ----wwaaiitt option,
           in order to mask Wget's presence from such analysis.

           A recent article in a publication devoted
           to development on a popular consumer platform
           provided code to perform this analysis on the fly.
           Its author suggested blocking at the class C address
           level to ensure automated retrieval programs were
           blocked despite changing DHCP-supplied addresses.

           The ----rraannddoomm--wwaaiitt option
           was inspired by this ill-advised recommendation
           to block many unrelated users from a web site due
           to the actions of one.

       --YY oonn//ooffff
       ----pprrooxxyy==oonn//ooffff
           Turn proxy support on or off.  The proxy is on by
           default if the appropriate environment variable
           is defined.

           For more information about the use of proxies
           with Wget,

       --QQ _q_u_o_t_a
       ----qquuoottaa==_q_u_o_t_a
           Specify download quota for automatic retrievals.
           The value can be specified in bytes (default),
           kilobytes (with kk suffix), or megabytes (with
           mm suffix).

           Note that quota will never
           affect downloading a single file.
           So if you specify wwggeett --QQ1100kk
           ffttpp::////wwuuaarrcchhiivvee..wwuussttll..eedduu//llss--llRR..ggzz,
           all of the _l_s_-_l_R_._g_z will be
           downloaded.  The same goes even when several URLs
           are specified on the command-line.  However,
           quota is respected when retrieving either
           recursively, or from an input file.  Thus you
           may safely type wwggeett --QQ22mm --ii
           ssiitteess---download will be aborted when
           the quota is exceeded.

           Setting quota to 0 or to iinnff unlimits the
           download quota.

       ----ddnnss--ccaacchhee==ooffff
           Turn off caching of DNS lookups.  Normally, Wget
           remembers the addresses it looked up from DNS so it
           doesn't have to repeatedly contact the DNS server
           for the same (typically small) set of addresses it
           retrieves from.  This cache exists in memory only;
           a new Wget run will contact DNS again.

           However, in some cases it is not desirable to
           cache host names, even for the duration of a
           short-running application like Wget.  For example,
           some HTTP servers are hosted on machines with
           dynamically allocated IP addresses that change
           from time to time.  Their DNS entries are updated
           along with each change.  When Wget's download from
           such a host gets interrupted by IP address change,
           Wget retries the download, but (due to DNS caching)
           it contacts the old address.  With the DNS cache
           turned off, Wget will repeat the DNS lookup for
           every connect and will thus get the correct dynamic
           address every time---at the cost of additional
           DNS lookups where they're probably not needed.

           If you don't understand the above description,
           you probably won't need this option.

       ----rreessttrriicctt--ffiillee--nnaammeess==_m_o_d_e
           Change which characters found in remote URLs
           may show up in local file names generated
           from those URLs.  Characters that are
           _r_e_s_t_r_i_c_t_e_d by this option
           are escaped, i.e. replaced with %%HHHH, where
           HHHH is the hexadecimal number that corresponds
           to the restricted character.

           By default, Wget escapes the characters that are
           not valid as part of file names on your operating
           system, as well as control characters that are
           typically unprintable.  This option is useful
           for changing these defaults, either because
           you are downloading to a non-native partition,
           or because you want to disable escaping of the
           control characters.

           When mode is set to ``unix'', Wget escapes the
           character // and the control characters in the
           ranges 0--31 and 128--159.  This is the default
           on Unix-like OS'es.

           When mode is set to ``windows'', Wget escapes
           the characters \\, ||, //, ::, ??, "",
           **, <<, >>, and the control characters in
           the ranges 0--31 and 128--159.  In addition to
           this, Wget in Windows mode uses ++ instead of
           :: to separate host and port in local file
           names, and uses @@}} iinnsstteeaadd
           ooff @@ssaammpp{{?? to separate
           the query portion of the file name from
           the rest.  Therefore, a URL that would be saved as
           wwwwww..xxeemmaaccss..oorrgg::44330000//sseeaarrcchh..ppll??iinnppuutt==bbllaahh
           in Unix mode would be saved as
           wwwwww..xxeemmaaccss..oorrgg++44330000//sseeaarrcchh..ppll@@iinnppuutt==bbllaahh
           in Windows mode.  This mode is the default on
           Windows.

           If you append ,,nnooccoonnttrrooll
           to the mode, as in
           uunniixx,,nnooccoonnttrrooll,
           escaping of the control
           characters is also switched off.  You can use
           ----rreessttrriicctt--ffiillee--nnaammeess==nnooccoonnttrrooll
           to turn off escaping of control characters without
           affecting the choice of the OS to use as file name
           restriction mode.

   DDiirreeccttoorryy OOppttiioonnss
       --nndd
       ----nnoo--ddiirreeccttoorriieess
           Do not create a hierarchy of directories when
           retrieving recursively.  With this option turned on,
           all files will get saved to the current directory,
           without clobbering (if a name shows up more than
           once, the filenames will get extensions ..nn).

       --xx
       ----ffoorrccee--ddiirreeccttoorriieess
           The opposite of --nndd---create a hierarchy
           of directories, even if one would not have
           been created otherwise.  E.g. wwggeett --xx
           hhttttpp::////ffllyy..ssrrkk..ffeerr..hhrr//rroobboottss..ttxxtt
           will save the downloaded file to
           _f_l_y_._s_r_k_._f_e_r_._h_r_/_r_o_b_o_t_s_._t_x_t.

       --nnHH
       ----nnoo--hhoosstt--ddiirreeccttoorriieess
           Disable generation of host-prefixed
           directories.  By default, invoking Wget with --rr
           hhttttpp::////ffllyy..ssrrkk..ffeerr..hhrr//
           will create a structure of directories beginning
           with _f_l_y_._s_r_k_._f_e_r_._h_r_/.
           This option disables such behavior.

       ----ccuutt--ddiirrss==_n_u_m_b_e_r
           Ignore _n_u_m_b_e_r directory components.
           This is useful for getting a fine-grained control
           over the directory where recursive retrieval will
           be saved.

           Take, for example, the directory at
           ffttpp::////ffttpp..xxeemmaaccss..oorrgg//ppuubb//xxeemmaaccss//.
           If you retrieve it with
           --rr, it will be saved locally under
           _f_t_p_._x_e_m_a_c_s_._o_r_g_/_p_u_b_/_x_e_m_a_c_s_/.
           While the --nnHH option can remove the
           _f_t_p_._x_e_m_a_c_s_._o_r_g_/
           part, you are still stuck with
           _p_u_b_/_x_e_m_a_c_s.  This is where
           ----ccuutt--ddiirrss comes in handy; it
           makes Wget not ``see'' _n_u_m_b_e_r remote
           directory components.  Here are several examples
           of how ----ccuutt--ddiirrss option works.

                   No options        ->
                   ftp.xemacs.org/pub/xemacs/ -nH
                   -> pub/xemacs/ -nH --cut-dirs=1  -> xemacs/
                   -nH --cut-dirs=2  -> .

                   --cut-dirs=1      -> ftp.xemacs.org/xemacs/
                   ...

           If you just want to get rid of the directory
           structure, this option is similar to a combination
           of --nndd and --PP.  However, unlike
           --nndd, ----ccuutt--ddiirrss does
           not lose with subdirectories---for instance, with
           --nnHH ----ccuutt--ddiirrss==11,
           a _b_e_t_a_/ subdirectory will be placed
           to _x_e_m_a_c_s_/_b_e_t_a, as one
           would expect.

       --PP _p_r_e_f_i_x
       ----ddiirreeccttoorryy--pprreeffiixx==_p_r_e_f_i_x
           Set directory prefix to _p_r_e_f_i_x.
           The _d_i_r_e_c_t_o_r_y _p_r_e_f_i_x
           is the directory where all other files and
           subdirectories will be saved to, i.e. the top
           of the retrieval tree.  The default is .. (the
           current directory).

   HHTTTTPP OOppttiioonnss
       --EE ----hhttmmll--eexxtteennssiioonn
           If a file of type
           aapppplliiccaattiioonn//xxhhttmmll++xxmmll
           or tteexxtt//hhttmmll is downloaded
           and the URL does not end with the regexp
           \\..[[HHhh]][[TTtt]][[MMmm]][[LLll]]??,
           this option will cause the suffix ..hhttmmll to
           be appended to the local filename.  This is useful,
           for instance, when you're mirroring a remote site
           that uses ..aasspp pages, but you want the
           mirrored pages to be viewable on your stock Apache
           server.  Another good use for this is when you're
           downloading CGI-generated materials.  A URL like
           hhttttpp::////ssiittee..ccoomm//aarrttiiccllee..ccggii??2255
           will be saved as
           _a_r_t_i_c_l_e_._c_g_i_?_2_5_._h_t_m_l.

           Note that filenames changed in this way will
           be re-downloaded every time you re-mirror a
           site, because Wget can't tell that the local
           _X_._h_t_m_l file corresponds to remote URL
           _X (since it doesn't yet know that the URL produces
           output of type tteexxtt//hhttmmll or
           aapppplliiccaattiioonn//xxhhttmmll++xxmmll.
           To prevent this re-downloading, you must use --kk
           and --KK so that the original version of the
           file will be saved as _X_._o_r_i_g.

       ----hhttttpp--uusseerr==_u_s_e_r
       ----hhttttpp--ppaasssswwdd==_p_a_s_s_w_o_r_d
           Specify the username _u_s_e_r and password
           _p_a_s_s_w_o_r_d on an HTTP server.
           According to the type of the challenge, Wget will
           encode them using either the "basic" (insecure)
           or the "digest" authentication scheme.

           Another way to specify username and password
           is in the URL itself.  Either method reveals
           your password to anyone who bothers to run "ps".
           To prevent the passwords from being seen, store them
           in _._w_g_e_t_r_c or _._n_e_t_r_c,
           and make sure to protect those files from other
           users with "chmod".  If the passwords are really
           important, do not leave them lying in those files
           either---edit the files and delete them after Wget
           has started the download.

           For more information about security issues with
           Wget,

       --CC oonn//ooffff
       ----ccaacchhee==oonn//ooffff
           When set to off, disable server-side cache.
           In this case, Wget will send the remote server
           an appropriate directive (PPrraaggmmaa::
           nnoo-- ccaacchhee) to get the file from the
           remote service, rather than returning the cached
           version.  This is especially useful for retrieving
           and flushing out-of-date documents on proxy servers.

           Caching is allowed by default.

       ----ccooookkiieess==oonn//ooffff
           When set to off, disable the use of cookies.
           Cookies are a mechanism for maintaining server-side
           state.  The server sends the client a cookie using
           the "Set-Cookie" header, and the client responds
           with the same cookie upon further requests.
           Since cookies allow the server owners to keep
           track of visitors and for sites to exchange
           this information, some consider them a breach of
           privacy.  The default is to use cookies; however,
           _s_t_o_r_i_n_g cookies is not on by default.

       ----llooaadd--ccooookkiieess _f_i_l_e
           Load cookies from _f_i_l_e before the first
           HTTP retrieval.  _f_i_l_e is a textual file
           in the format originally used by Netscape's
           _c_o_o_k_i_e_s_._t_x_t file.

           You will typically use this option when mirroring
           sites that require that you be logged in to
           access some or all of their content.  The login
           process typically works by the web server issuing
           an HTTP cookie upon receiving and verifying your
           credentials.  The cookie is then resent by the
           browser when accessing that part of the site,
           and so proves your identity.

           Mirroring such a site requires Wget to send
           the same cookies your browser sends when
           communicating with the site.  This is achieved by
           ----llooaadd--ccooookkiieess---simply
           point Wget to the location of the
           _c_o_o_k_i_e_s_._t_x_t file, and it
           will send the same cookies your browser would send
           in the same situation.  Different browsers keep
           textual cookie files in different locations:

           @asis<Netscape 4.x.>
               The cookies are in
               _~_/_._n_e_t_s_c_a_p_e_/_c_o_o_k_i_e_s_._t_x_t.

           @asis<Mozilla and Netscape 6.x.>
               Mozilla's cookie file is also named
               _c_o_o_k_i_e_s_._t_x_t, located
               somewhere under _~_/_._m_o_z_i_l_l_a,
               in the directory of your profile.  The full
               path usually ends up looking somewhat like
               _~_/_._m_o_z_i_l_l_a_/_d_e_f_a_u_l_t_/_s_o_m_e_-_w_e_i_r_d_-_s_t_r_i_n_g_/_c_o_o_k_i_e_s_._t_x_t.

           @asis<Internet Explorer.>
               You can produce a cookie file Wget can use
               by using the File menu, Import and Export,
               Export Cookies.  This has been tested with
               Internet Explorer 5; it is not guaranteed to
               work with earlier versions.

           @asis<Other browsers.>
               If you are using a different
               browser to create your cookies,
               ----llooaadd--ccooookkiieess will
               only work if you can locate or produce a cookie
               file in the Netscape format that Wget expects.

           If you cannot use
           ----llooaadd--ccooookkiieess, there
           might still be an alternative.  If your browser
           supports a ``cookie manager'', you can use it
           to view the cookies used when accessing the site
           you're mirroring.  Write down the name and value of
           the cookie, and manually instruct Wget to send those
           cookies, bypassing the ``official'' cookie support:

                   wget --cookies=off --header "Cookie:
                   <name>=<value>"

       ----ssaavvee--ccooookkiieess _f_i_l_e
           Save cookies to _f_i_l_e at the end of session.
           Cookies whose expiry time is not specified, or
           those that have already expired, are not saved.

       ----iiggnnoorree--lleennggtthh
           Unfortunately, some HTTP servers (CGI programs, to
           be more precise) send out bogus "Content-Length"
           headers, which makes Wget go wild, as it thinks
           not all the document was retrieved.  You can spot
           this syndrome if Wget retries getting the same
           document again and again, each time claiming that
           the (otherwise normal) connection has closed on
           the very same byte.

           With this option, Wget will ignore the
           "Content-Length" header---as if it never existed.

       ----hheeaaddeerr==_a_d_d_i_t_i_o_n_a_l_-_h_e_a_d_e_r
           Define an
           _a_d_d_i_t_i_o_n_a_l_-_h_e_a_d_e_r
           to be passed to the HTTP servers.  Headers must
           contain a :: preceded by one or more non-blank
           characters, and must not contain newlines.

           You may define more than one additional header by
           specifying ----hheeaaddeerr more than once.

                   wget --header='Accept-Charset: iso-8859-2' \
                        --header='Accept-Language: hr'        \
                          http://fly.srk.fer.hr/

           Specification of an empty string as the header
           value will clear all previous user-defined headers.

       ----pprrooxxyy--uusseerr==_u_s_e_r
       ----pprrooxxyy--ppaasssswwdd==_p_a_s_s_w_o_r_d
           Specify the username _u_s_e_r and password
           _p_a_s_s_w_o_r_d for authentication on
           a proxy server.  Wget will encode them using the
           "basic" authentication scheme.

           Security considerations similar to those with
           ----hhttttpp--ppaasssswwdd pertain
           here as well.

       ----rreeffeerreerr==_u_r_l
           Include `Referer: _u_r_l' header in HTTP request.
           Useful for retrieving documents with server-side
           processing that assume they are always being
           retrieved by interactive web browsers and only
           come out properly when Referer is set to one of
           the pages that point to them.

       --ss ----ssaavvee--hheeaaddeerrss
           Save the headers sent by the HTTP server to the
           file, preceding the actual contents, with an empty
           line as the separator.

       --UU _a_g_e_n_t_-_s_t_r_i_n_g
       ----uusseerr--aaggeenntt==_a_g_e_n_t_-_s_t_r_i_n_g
           Identify as _a_g_e_n_t_-_s_t_r_i_n_g
           to the HTTP server.

           The HTTP protocol allows the clients to identify
           themselves using a "User-Agent" header field.
           This enables distinguishing the WWW software,
           usually for statistical purposes or for tracing of
           protocol violations.  Wget normally identifies
           as WWggeett//_v_e_r_s_i_o_n,
           _v_e_r_s_i_o_n being the current version
           number of Wget.

           However, some sites have been known to impose
           the policy of tailoring the output according
           to the "User-Agent"-supplied information.
           While conceptually this is not such a bad idea,
           it has been abused by servers denying information
           to clients other than "Mozilla" or Microsoft
           "Internet Explorer".  This option allows you to
           change the "User-Agent" line issued by Wget.
           Use of this option is discouraged, unless you
           really know what you are doing.

       ----ppoosstt--ddaattaa==_s_t_r_i_n_g
       ----ppoosstt--ffiillee==_f_i_l_e
           Use POST as the method for all HTTP requests
           and send the specified data in the request body.
           "--post-data" sends _s_t_r_i_n_g as data,
           whereas "--post-file" sends the contents of
           _f_i_l_e.  Other than that, they work in
           exactly the same way.

           Please be aware that Wget needs to know the size
           of the POST data in advance.  Therefore the
           argument to "--post-file" must be a regular
           file; specifying a FIFO or something like
           _/_d_e_v_/_s_t_d_i_n won't work.  It's not
           quite clear how to work around this limitation
           inherent in HTTP/1.0.  Although HTTP/1.1 introduces
           _c_h_u_n_k_e_d transfer that doesn't
           require knowing the request length in advance,
           a client can't use chunked unless it knows it's
           talking to an HTTP/1.1 server.  And it can't know
           that until it receives a response, which in turn
           requires the request to have been completed --
           a chicken-and-egg problem.

           Note: if Wget is redirected after the POST request
           is completed, it will not send the POST data to
           the redirected URL.  This is because URLs that
           process POST often respond with a redirection
           to a regular page (although that's technically
           disallowed), which does not desire or accept POST.
           It is not yet clear that this behavior is optimal;
           if it doesn't work out, it will be changed.

           This example shows how to log to a server using
           POST and then proceed to download the desired pages,
           presumably only accessible to authorized users:

                   # Log in to the server.  This can be
                   done only once.  wget --save-cookies
                   cookies.txt \
                        --post-data 'user=foo&password=bar'
                        \ http://server.com/auth.php

                   # Now grab the page or pages we care about.
                   wget --load-cookies cookies.txt \
                        -p
                        http://server.com/interesting/article.php

   FFTTPP OOppttiioonnss
       --nnrr
       ----ddoonntt--rreemmoovvee--lliissttiinngg
           Don't remove the temporary _._l_i_s_t_i_n_g
           files generated by FTP retrievals.  Normally,
           these files contain the raw directory listings
           received from FTP servers.  Not removing them
           can be useful for debugging purposes, or when you
           want to be able to easily check on the contents
           of remote server directories (e.g. to verify that
           a mirror you're running is complete).

           Note that even though Wget writes to a
           known filename for this file, this is not a
           security hole in the scenario of a user making
           _._l_i_s_t_i_n_g a symbolic link to
           _/_e_t_c_/_p_a_s_s_w_d or something and
           asking "root" to run Wget in his or her directory.
           Depending on the options used, either Wget will
           refuse to write to _._l_i_s_t_i_n_g, making
           the globbing/recursion/time-stamping operation
           fail, or the symbolic link will be deleted and
           replaced with the actual _._l_i_s_t_i_n_g
           file, or the listing will be written to a
           _._l_i_s_t_i_n_g_._n_u_m_b_e_r file.

           Even though this situation isn't a problem, though,
           "root" should never run Wget in a non-trusted
           user's directory.  A user could do something as
           simple as linking _i_n_d_e_x_._h_t_m_l
           to _/_e_t_c_/_p_a_s_s_w_d and asking
           "root" to run Wget with --NN or --rr so the
           file will be overwritten.

       --gg oonn//ooffff
       ----gglloobb==oonn//ooffff
           Turn FTP globbing on or off.  Globbing means
           you may use the shell- like special characters
           (_w_i_l_d_c_a_r_d_s), like **, ??,
           [[ and ]] to retrieve more than one file from
           the same directory at once, like:

                   wget ftp://gnjilux.srk.fer.hr/*.msg

           By default, globbing will be turned on if the URL
           contains a globbing character.  This option may
           be used to turn globbing on or off permanently.

           You may have to quote the URL to protect it from
           being expanded by your shell.  Globbing makes
           Wget look for a directory listing, which is
           system-specific.  This is why it currently works
           only with Unix FTP servers (and the ones emulating
           Unix "ls" output).

       ----ppaassssiivvee--ffttpp
           Use the _p_a_s_s_i_v_e FTP retrieval scheme,
           in which the client initiates the data connection.
           This is sometimes required for FTP to work behind
           firewalls.

       ----rreettrr--ssyymmlliinnkkss
           Usually, when retrieving FTP directories recursively
           and a symbolic link is encountered, the linked-to
           file is not downloaded.  Instead, a matching
           symbolic link is created on the local filesystem.
           The pointed-to file will not be downloaded unless
           this recursive retrieval would have encountered
           it separately and downloaded it anyway.

           When ----rreettrr--ssyymmlliinnkkss
           is specified, however, symbolic links are traversed
           and the pointed-to files are retrieved.  At this
           time, this option does not cause Wget to traverse
           symlinks to directories and recurse through them,
           but in the future it should be enhanced to do this.

           Note that when retrieving a file (not a directory)
           because it was specified on the command-line, rather
           than because it was recursed to, this option has
           no effect.  Symbolic links are always traversed
           in this case.

   RReeccuurrssiivvee RReettrriieevvaall
   OOppttiioonnss
       --rr ----rreeccuurrssiivvee
           Turn on recursive retrieving.

       --ll _d_e_p_t_h
       ----lleevveell==_d_e_p_t_h
           Specify recursion maximum depth level
           _d_e_p_t_h.  The default maximum depth is 5.

       ----ddeelleettee--aafftteerr
           This option tells Wget to delete every single
           file it downloads, _a_f_t_e_r having done so.
           It is useful for pre-fetching popular pages through
           a proxy, e.g.:

                   wget -r -nd --delete-after
                   http://whatever.com/~popular/page/

           The --rr option is to retrieve recursively,
           and --nndd to not create directories.

           Note that ----ddeelleettee--aafftteerr
           deletes files on the local machine.  It does
           not issue the DDEELLEE command to remote
           FTP sites, for instance.  Also note that when
           ----ddeelleettee--aafftteerr
           is specified,
           ----ccoonnvveerrtt--lliinnkkss is
           ignored, so ..oorriigg files are simply not
           created in the first place.

       --kk ----ccoonnvveerrtt--lliinnkkss
           After the download is complete, convert the
           links in the document to make them suitable for
           local viewing.  This affects not only the visible
           hyperlinks, but any part of the document that links
           to external content, such as embedded images,
           links to style sheets, hyperlinks to non-HTML
           content, etc.

           Each link will be changed in one of the two ways:

           ·   The links to files that have been downloaded
           by Wget will be
               changed to refer to the file they point to as
               a relative link.

               Example: if the downloaded file
               _/_f_o_o_/_d_o_c_._h_t_m_l links
               to _/_b_a_r_/_i_m_g_._g_i_f,
               also downloaded, then the link
               in _d_o_c_._h_t_m_l
               will be modified to point to
               ....//bbaarr//iimmgg..ggiiff.
               This kind of transformation works reliably
               for arbitrary combinations of directories.

           ·   The links to files that have not been
           downloaded by Wget will
               be changed to include host name and absolute
               path of the location they point to.

               Example: if the downloaded file
               _/_f_o_o_/_d_o_c_._h_t_m_l links
               to _/_b_a_r_/_i_m_g_._g_i_f (or to
               _._._/_b_a_r_/_i_m_g_._g_i_f),
               then the link in _d_o_c_._h_t_m_l
               will be modified to point to
               _h_t_t_p_:_/_/_h_o_s_t_n_a_m_e_/_b_a_r_/_i_m_g_._g_i_f.

           Because of this, local browsing works reliably:
           if a linked file was downloaded, the link will
           refer to its local name; if it was not downloaded,
           the link will refer to its full Internet address
           rather than presenting a broken link.  The fact
           that the former links are converted to relative
           links ensures that you can move the downloaded
           hierarchy to another directory.

           Note that only at the end of the download can Wget
           know which links have been downloaded.  Because of
           that, the work done by --kk will be performed
           at the end of all the downloads.

       --KK
       ----bbaacckkuupp--ccoonnvveerrtteedd
           When converting a file, back up the original version
           with a ..oorriigg suffix.  Affects the behavior
           of --NN.

       --mm ----mmiirrrroorr
           Turn on options suitable for mirroring.  This option
           turns on recursion and time-stamping, sets infinite
           recursion depth and keeps FTP directory listings.
           It is currently equivalent to --rr --NN --ll
           iinnff --nnrr.

       --pp
       ----ppaaggee--rreeqquuiissiitteess
           This option causes Wget to download all the files
           that are necessary to properly display a given
           HTML page.  This includes such things as inlined
           images, sounds, and referenced stylesheets.

           Ordinarily, when downloading a single HTML page, any
           requisite documents that may be needed to display
           it properly are not downloaded.  Using --rr
           together with --ll can help, but since Wget does
           not ordinarily distinguish between external and
           inlined documents, one is generally left with ``leaf
           documents'' that are missing their requisites.

           For instance, say document _1_._h_t_m_l
           contains an "<IMG>" tag referencing _1_._g_i_f
           and an "<A>" tag pointing to external document
           _2_._h_t_m_l.  Say that _2_._h_t_m_l
           is similar but that its image is _2_._g_i_f
           and it links to _3_._h_t_m_l.  Say this
           continues up to some arbitrarily high number.

           If one executes the command:

                   wget -r -l 2 http://<site>/1.html

           then _1_._h_t_m_l, _1_._g_i_f,
           _2_._h_t_m_l, _2_._g_i_f, and
           _3_._h_t_m_l will be downloaded.  As you
           can see, _3_._h_t_m_l is without its
           requisite _3_._g_i_f because Wget is simply
           counting the number of hops (up to 2) away from
           _1_._h_t_m_l in order to determine where to
           stop the recursion.  However, with this command:

                   wget -r -l 2 -p http://<site>/1.html

           all the above files _a_n_d _3_._h_t_m_l's
           requisite _3_._g_i_f will be downloaded.
           Similarly,

                   wget -r -l 1 -p http://<site>/1.html

           will cause _1_._h_t_m_l, _1_._g_i_f,
           _2_._h_t_m_l, and _2_._g_i_f to be
           downloaded.  One might think that:

                   wget -r -l 0 -p http://<site>/1.html

           would download just _1_._h_t_m_l and
           _1_._g_i_f, but unfortunately this is not
           the case, because --ll 00 is equivalent to
           --ll iinnff---that is, infinite recursion.
           To download a single HTML page (or a handful
           of them, all specified on the command-line or
           in a --ii URL input file) and its (or their)
           requisites, simply leave off --rr and --ll:

                   wget -p http://<site>/1.html

           Note that Wget will behave as if --rr had been
           specified, but only that single page and its
           requisites will be downloaded.  Links from that
           page to external documents will not be followed.
           Actually, to download a single page and all
           its requisites (even if they exist on separate
           websites), and make sure the lot displays properly
           locally, this author likes to use a few options
           in addition to --pp:

                   wget -E -H -k -K -p http://<site>/<document>

           To finish off this topic, it's worth knowing that
           Wget's idea of an external document link is any URL
           specified in an "<A>" tag, an "<AREA>" tag, or a
           "<LINK>" tag other than "<LINK REL="stylesheet">".

       ----ssttrriicctt--ccoommmmeennttss
           Turn on strict parsing of HTML comments.
           The default is to terminate comments at the first
           occurrence of ---->>.

           According to specifications,
           HTML comments are expressed as SGML
           _d_e_c_l_a_r_a_t_i_o_n_s.  Declaration
           is special markup that begins with <<!!  and ends
           with >>, such as <<!!DDOOCCTTYYPPEE
           ......>>, that may contain comments between
           a pair of ---- delimiters.  HTML comments
           are ``empty declarations'', SGML declarations
           without any non-comment text.  Therefore,
           <<!!----ffoooo---->> is a valid
           comment, and so is <<!!----oonnee----
           ----ttwwoo---->>, but
           <<!!----11----22---->> is not.

           On the other hand, most HTML writers don't perceive
           comments as anything other than text delimited
           with <<!!---- and ---->>, which is not
           quite the same.  For example, something like
           <<!!------------------------>>
           works as a valid comment as long as the number
           of dashes is a multiple of four (!).  If not, the
           comment technically lasts until the next ----,
           which may be at the other end of the document.
           Because of this, many popular browsers completely
           ignore the specification and implement what users
           have come to expect: comments delimited with
           <<!!---- and ---->>.

           Until version 1.9, Wget interpreted comments
           strictly, which resulted in missing links in many
           web pages that displayed fine in browsers, but
           had the misfortune of containing non-compliant
           comments.  Beginning with version 1.9, Wget
           has joined the ranks of clients that implements
           ``naive'' comments, terminating each comment at
           the first occurrence of ---->>.

           If, for whatever reason, you want strict comment
           parsing, use this option to turn it on.

   RReeccuurrssiivvee
   AAcccceepptt//RReejjeecctt
   OOppttiioonnss
       --AA _a_c_c_l_i_s_t ----aacccceepptt
       _a_c_c_l_i_s_t --RR _r_e_j_l_i_s_t
       ----rreejjeecctt _r_e_j_l_i_s_t
           Specify comma-separated lists of file name suffixes
           or patterns to accept or reject (@pxref{Types of
           Files} for more details).

       --DD _d_o_m_a_i_n_-_l_i_s_t
       ----ddoommaaiinnss==_d_o_m_a_i_n_-_l_i_s_t
           Set domains to be followed.
           _d_o_m_a_i_n_-_l_i_s_t is a
           comma-separated list of domains.  Note that it
           does _n_o_t turn on --HH.

       ----eexxcclluuddee--ddoommaaiinnss
       _d_o_m_a_i_n_-_l_i_s_t
           Specify the domains that are _n_o_t to be
           followed..

       ----ffoollllooww--ffttpp
           Follow FTP links from HTML documents.  Without this
           option, Wget will ignore all the FTP links.

       ----ffoollllooww--ttaaggss==_l_i_s_t
           Wget has an internal table of HTML tag / attribute
           pairs that it considers when looking for linked
           documents during a recursive retrieval.  If a user
           wants only a subset of those tags to be considered,
           however, he or she should be specify such tags in
           a comma-separated _l_i_s_t with this option.

       --GG _l_i_s_t
       ----iiggnnoorree--ttaaggss==_l_i_s_t
           This is the opposite of the
           ----ffoollllooww--ttaaggss option.
           To skip certain HTML tags when recursively looking
           for documents to download, specify them in a
           comma-separated _l_i_s_t.

           In the past, the --GG option was the best bet
           for downloading a single page and its requisites,
           using a command-line like:

                   wget -Ga,area -H -k -K -r
                   http://<site>/<document>

           However, the author of this option came across a
           page with tags like "<LINK REL="home" HREF="/">"
           and came to the realization that --GG was
           not enough.  One can't just tell Wget to ignore
           "<LINK>", because then stylesheets will not be
           downloaded.  Now the best bet for downloading a
           single page and its requisites is the dedicated
           ----ppaaggee--rreeqquuiissiitteess
           option.

       --HH ----ssppaann--hhoossttss
           Enable spanning across hosts when doing recursive
           retrieving.

       --LL ----rreellaattiivvee
           Follow relative links only.  Useful for retrieving
           a specific home page without any distractions,
           not even those from the same hosts.

       --II _l_i_s_t
       ----iinncclluuddee--ddiirreeccttoorriieess==_l_i_s_t
           Specify a comma-separated list of
           directories you wish to follow when downloading
           (@pxref{Directory-Based Limits} for more details.)
           Elements of _l_i_s_t may contain wildcards.

       --XX _l_i_s_t
       ----eexxcclluuddee--ddiirreeccttoorriieess==_l_i_s_t
           Specify a comma-separated list of
           directories you wish to exclude from download
           (@pxref{Directory-Based Limits} for more details.)
           Elements of _l_i_s_t may contain wildcards.

       --nnpp ----nnoo--ppaarreenntt
           Do not ever ascend to the parent directory
           when retrieving recursively.  This is a useful
           option, since it guarantees that only the files
           _b_e_l_o_w a certain hierarchy will be
           downloaded.

FFIILLEESS
       //uussrr//llooccaall//eettcc//wwggeettrrcc
           Default location of the _g_l_o_b_a_l
           startup file.

       ..wwggeettrrcc
           User startup file.

BBUUGGSS
       You are welcome to send bug reports about GNU Wget
       to <bbuugg--wwggeett@@ggnnuu..oorrgg>.

       Before actually submitting a bug report, please try
       to follow a few simple guidelines.

       1.  Please try to ascertain that the behavior you see
       really is a bug.
           If Wget crashes, it's a bug.  If Wget does not
           behave as documented, it's a bug.  If things work
           strange, but you are not sure about the way they
           are supposed to work, it might well be a bug.

       2.  Try to repeat the bug in as simple circumstances
       as possible.  E.g.
           if Wget crashes while downloading wwggeett
           --rrll00 --kkKKEE --tt55 --YY00
           hhttttpp::////yyooyyooddyynnee..ccoomm
           --oo //ttmmpp//lloogg, you should try
           to see if the crash is repeatable, and if will
           occur with a simpler set of options.  You might
           even try to start the download at the page where
           the crash occurred to see if that page somehow
           triggered the crash.

           Also, while I will probably be interested to know
           the contents of your _._w_g_e_t_r_c file,
           just dumping it into the debug message is probably
           a bad idea.  Instead, you should first try to
           see if the bug repeats with _._w_g_e_t_r_c
           moved out of the way.  Only if it turns out that
           _._w_g_e_t_r_c settings affect the bug,
           mail me the relevant parts of the file.

       3.  Please start Wget with --dd option and send the
       log (or the relevant
           parts of it).  If Wget was compiled without debug
           support, recompile it.  It is _m_u_c_h easier
           to trace bugs with debug support on.

       4.  If Wget has crashed, try to run it in a debugger,
       e.g. "gdb `which
           wget` core" and type "where" to get the backtrace.

SSEEEE AALLSSOO
       GNU Info entry for _w_g_e_t.

AAUUTTHHOORR
       Originally written by Hrvoje Niksic
       <hniksic@xemacs.org>.

CCOOPPYYRRIIGGHHTT
       Copyright (c) 1996, 1997, 1998, 2000, 2001, 2002,
       2003 Free Software Foundation, Inc.

       Permission is granted to make and distribute verbatim
       copies of this manual provided the copyright notice
       and this permission notice are preserved on all copies.

       Permission is granted to copy, distribute and/or
       modify this document under the terms of the GNU
       Free Documentation License, Version 1.1 or any later
       version published by the Free Software Foundation;
       with the Invariant Sections being ``GNU General Public
       License'' and ``GNU Free Documentation License'', with
       no Front-Cover Texts, and with no Back- Cover Texts.
       A copy of the license is included in the section
       entitled ``GNU Free Documentation License''.



GNU Wget 1.9.1                    2012-02-27
WGET(1)
