Provided by: wget2_1.99.1-2.2_amd64 bug

Name

       Wget2 - a recursive metalink/file/website downloader.

Synopsis

       wget2 [options]... [URL]...

Description

       GNU  Wget2  is  a  free  utility  for  non-interactive download of files from the Web.  It
       supports HTTP and HTTPS protocols, as well as retrieval through HTTP(S) proxies.

       Wget2 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 Wget2 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.

       Wget2  can  follow  links in HTML, XHTML, CSS, RSS, Atom and sitemap files to 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, Wget2
       respects the Robot Exclusion Standard (/robots.txt).  Wget2 can be instructed  to  convert
       the links in downloaded files to point at the local files, for offline viewing.

       Wget2  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 partial downloads, it may continue the download
       from where it left off.

Options

   Option Syntax
       Every option has a long form and sometimes also  a  short  one.   Long  options  are  more
       convenient  to  remember,  but  take  time  to  type.  You may freely mix different option
       styles.  Thus you may write:

                wget2 -r --tries=10 https://example.com/ -o log

       The space between the option accepting an  argument  and  the  argument  may  be  omitted.
       Instead of -o log you can write -olog.

       You may put several options that do not require arguments together, like:

                wget2 -drc <URL>

       This is equivalent to:

                wget2 -d -r -c <URL>

       Since  the  options  can be specified after the arguments, you may terminate them with --.
       So the following will try to download URL -x, reporting failure to log:

                wget2 -o log -- -x

       The options that accept comma-separated lists all respect the convention  that  specifying
       an  empty  list  clears its value.  This can be useful to clear the .wgetrc settings.  For
       instance, if your .wgetrc sets exclude-directories to /cgi-bin, the following example will
       first  reset  it,  and then set it to exclude /~nobody and /~somebody.  You can also clear
       the lists in .wgetrc.

                wget2 -X '' -X /~nobody,/~somebody

       Most options that do not accept arguments are boolean  options,  so  named  because  their
       state  can  be captured with a yes-or-no (“boolean”) variable.  A boolean option is either
       affirmative  or  negative  (beginning  with  --no-).   All  such  options  share   several
       properties.

       Affirmative  options  can  be negated by prepending the --no- to the option name; negative
       options can be negated by omitting the --no- prefix.  This might seem superfluous - if the
       default  for  an  affirmative  option  is  to  not do something, then why provide a way to
       explicitly turn it off?  But the startup  file  may  in  fact  change  the  default.   For
       instance,  using  timestamping  =  on  in .wgetrc makes Wget2 download updated files only.
       Using --no-timestamping is the only way to restore the factory default  from  the  command
       line.

   Basic Startup Options
   -V, --version
       Display the version of Wget2.

   -h, --help
       Print a help message describing all of Wget2’s command-line options.

   -b, --background
       Go  to  background  immediately after startup.  If no output file is specified via the -o,
       output is redirected to wget-log.

   -e, --execute=command
       Execute command as if it were a part of .wgetrc.  A command thus invoked will be  executed
       after  the  commands in .wgetrc, thus taking precedence over them.  If you need to specify
       more than one wgetrc command, use multiple instances of -e.

   Logging and Input File Options
   -o, --output-file=logfile
       Log all messages to logfile.  The messages are normally reported to standard error.

   -a, --append-output=logfile
       Append to logfile.  This is the same  as  -o,  only  it  appends  to  logfile  instead  of
       overwriting the old log file.  If logfile does not exist, a new file is created.

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

   -q, --quiet
       Turn off Wget2’s output.

   -v, --verbose
       Turn on verbose output, with all the available data.  The default output is verbose.

   -nv, --no-verbose
       Turn  off verbose without being completely quiet (use -q for that), which means that error
       messages and basic information still get printed.

   --report-speed=type
       Output bandwidth as type.  The only accepted values are bytes (which is  set  by  default)
       and bits.  This option only works if --progress=bar is also set.

   -i, --input-file=file
       Read  URLs  from  a local or external file.  If - is specified as file, URLs are read from
       the standard input.  (Use ./- to read from a file literally named -.)

       If this function is used, no URLs need be present 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.  file is expected to contain one URL per line, except  one  of
       the –force- options specifies a different format.

       If  you  specify –force-html, the document will be regarded as HTML.  In that case you may
       have problems with relative links, which  you  can  solve  either  by  adding  “”  to  the
       documents or by specifying –base=url on the command line.

       If you specify --force-css, the document will be regarded as CSS.

       If you specify --force-sitemap, the document will be regarded as XML sitemap.

       If you specify --force-atom, the document will be regarded as Atom Feed.

       If you specify --force-rss, the document will be regarded as RSS Feed.

       If you specify --force-metalink, the document will be regarded as Metalink description.

       If you have problems with relative links, you should use –base=url on the command line.

   -F, --force-html
       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  “”  to
       HTML, or using the –base command-line option.

   --force-css
       Read  and  parse  the input file as CSS.  This enables you to retrieve links from existing
       CSS files on your local disk.  You will need –base to handle relative links correctly.

   --force-sitemap
       Read and parse the input file as sitemap XML.  This enables you  to  retrieve  links  from
       existing  sitemap  files on your local disk.  You will need –base to handle relative links
       correctly.

   --force-atom
       Read and parse the input file as Atom Feed XML.  This enables you to retrieve  links  from
       existing  sitemap  files on your local disk.  You will need –base to handle relative links
       correctly.

   --force-rss
       Read and parse the input file as RSS Feed XML.  This enables you to  retrieve  links  from
       existing  sitemap  files on your local disk.  You will need –base to handle relative links
       correctly.

   --force-metalink
       Read and parse the input file as Metalink.   This  enables  you  to  retrieve  links  from
       existing  Metalink files on your local disk.  You will need –base to handle relative links
       correctly.

   -B, --base=URL
       Resolves relative links using URL as the point of reference, when reading  links  from  an
       HTML  file  specified  via the -i/–input-file option (together with a –force... option, or
       when the input file was fetched remotely from a server describing it as HTML, CSS, Atom or
       RSS).  This is equivalent to the presence of a “BASE” tag in the HTML input file, with URL
       as the value for the “href” attribute.

       For instance, if you specify  https://example.com/bar/a.html  for  URL,  and  Wget2  reads
       ../baz/b.html from the input file, it would be resolved to https://example.com/baz/b.html.

   --config=FILE
       Specify the location of configuration files you wish to use.  If you specify more than one
       file, either by using a comma-separated list or several --config options, these files  are
       read  in  left-to-right  order.   The  files  given  in  $SYSTEM_WGET2RC  and ($WGET2RC or
       ~/.wget2rc) are read in that order and then the user-provided  config  file(s).   If  set,
       $WGET2RC replaces ~/.wget2rc.

       --no-config  empties the internal list of config files.  So if you want to prevent reading
       any config files, give –no-config on the command line.

       --no-config followed by --config=file just reads file and skips reading the default config
       files.

       Wget will attempt to tilde-expand filenames written in the configuration file on supported
       platforms.  To use a file that starts with the character literal  `~',  use  “./~”  or  an
       absolute path.

   --rejected-log=logfile
       Logs  all  URL  rejections  to  logfile as comma separated values.  The values include the
       reason of rejection, the URL and the parent URL it was found in.

   --local-db
       Enables reading/writing to local database files (default: on).

       These are the files for --hsts, --hpkp, --ocsp, etc.

       With --no-local-db you can switch reading/writing off, e.g. useful for testing.

       This option does not influence the reading of config files.

   --stats-dns[=[FORMAT:]FILE]
       Save DNS stats in format FORMAT, in file FILE.

       FORMAT can be human or csv.  - is shorthand for stdout and h is shorthand for human.

       The CSV output format is

       Hostname,IP,Port,Duration

              `Duration` is given in milliseconds.

   --stats-tls[=[FORMAT:]FILE]
       Save TLS stats in format FORMAT, in file FILE.

       FORMAT can be human or csv.  - is shorthand for stdout and h is shorthand for human.

       The CSV output format is

       Hostname,TLSVersion,FalseStart,TFO,Resumed,ALPN,HTTPVersion,Certificates,Duration

              `TLSVersion` can be 1,2,3,4,5 for SSL3, TLS1.0, TLS1.1, TLS1.2 and TLS1.3. -1 means 'None'.

              `FalseStart` whether the connection used TLS False Start. -1 if not applicable.

              `TFO` whether the connection used TCP Fast Open. -1 is TFO was disabled.

              `Resumed` whether the TLS session was resumed or not.

              `ALPN` is the ALPN negotiation string.

              `HTTPVersion` is 0 for HTTP 1.1 and 1 is for HTTP 2.0.

              `Certificates` is the size of the server's certificate chain.

              `Duration` is given in milliseconds.

   --stats-ocsp[=[FORMAT:]FILE]
       Save OCSP stats in format FORMAT, in file FILE.

       FORMAT can be human or csv.  - is shorthand for stdout and h is shorthand for human.

       The CSV output format is

       Hostname,Stapling,Valid,Revoked,Ignored

              `Stapling` whether an OCSP response was stapled or not.

              `Valid` how many server certificates were valid regarding OCSP.

              `Revoked` how many server certificates were revoked regarding OCSP.

              `Ignored` how many server certificates had been ignored or OCSP responses missing.

   --stats-server[=[FORMAT:]FILE]
       Save Server stats in format FORMAT, in file FILE.

       FORMAT can be human or csv.  - is shorthand for stdout and h is shorthand for human.

       The CSV output format is

       Hostname,IP,Scheme,HPKP,NewHPKP,HSTS,CSP

              `Scheme` 0,1,2 mean `None`, `http`, `https`.

               `HPKP` values 0,1,2,3 mean 'No HPKP', 'HPKP matched', 'HPKP doesn't match', 'HPKP error'.

              `NewHPKP` whether server sent HPKP (Public-Key-Pins) header.

              `HSTS` whether server sent HSTS (Strict-Transport-Security) header.

              `CSP` whether server sent CSP (Content-Security-Policy) header.

   --stats-site[=[FORMAT:]FILE]
       Save Site stats in format FORMAT, in file FILE.

       FORMAT can be human or csv.  - is shorthand for stdout and h is shorthand for human.

       The CSV output format is

       ID,ParentID,URL,Status,Link,Method,Size,SizeDecompressed,TransferTime,ResponseTime,Encoding,Verification

              `ID` unique ID for a stats record.

              `ParentID` ID of the parent document, relevant for `--recursive` mode.

              `URL` URL of the document.

              `Status` HTTP response code or 0 if not applicable.

              `Link` 1 means 'direkt link', 0 means 'redirection link'.

              `Method` 1,2,3 mean GET, HEAD, POST request type.

              `Size` size of downloaded body (theoretical value for HEAD requests).

              `SizeDecompressed` size of decompressed body (0 for HEAD requests).

              `TransferTime` ms between start of request and completed download.

              `ResponseTime` ms between start of request and first response packet.

              `Encoding` 0,1,2,3,4,5 mean server side compression was 'identity', 'gzip', 'deflate', 'lzma/xz', 'bzip2', 'brotli'

              `Verification` PGP verification status. 0,1,2,3 mean 'none',  'valid', 'invalid', 'bad', 'missing'.

   --stats-all[=[FORMAT:]FILE]
       Save DNS, TLS, OCSP, Server and Site stats in format FORMAT, in file FILE.

       FORMAT can be human or csv.  - is shorthand for stdout and h is shorthand for human.

       Saving different csv output records into one file might break later parsing.

   Download Options
   --bind-address=ADDRESS
       When  making client TCP/IP connections, bind to ADDRESS on the local machine.  ADDRESS may
       be specified as a hostname or IP address.  This option can be useful if  your  machine  is
       bound to multiple IPs.

   -t, --tries=number
       Set number of tries to number.  Specify 0 or inf 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, --output-document=file
       The  documents  will not be written to the appropriate files, but all will be concatenated
       together and written to file.  If - is used as file, documents will be printed to standard
       output, disabling link conversion.  (Use ./- to print to a file literally named -.)

       Using  -r  or  -p  with -O may not work as you expect: Wget2 won’t just download the first
       file to file and then download the rest to their normal names: all downloaded content will
       be placed in file.

       A combination with -nc is only accepted if the given output file does not exist.

       When  used  along  with the -c option, Wget2 will attempt to continue downloading the file
       whose name is passed to the option, irrespective of whether the actual file already exists
       on  disk or not.  This allows users to download a file with a temporary name alongside the
       actual file.

       Note that a combination with -k is only permitted when downloading a single  document,  as
       in  that  case  it will just convert all relative URIs to external ones; -k makes no sense
       for multiple URIs when they’re all being downloaded to a single file; -k can be used  only
       when the output is a regular file.

       Compatibility-Note:  Wget  1.x  used to treat -O as analogous to shell redirection.  Wget2
       does not handle the option similarly.  Hence, the file will not always be  newly  created.
       The file’s timestamps will not be affected unless it is actually written to.  As a result,
       both -c and -N options are now supported in conjunction with this option.

   -nc, --no-clobber
       If a file is downloaded more than once in the same directory, Wget2’s behavior depends  on
       a  few  options,  including  -nc.   In certain cases, the local file will be clobbered, or
       overwritten, upon repeated download.  In other cases it will be preserved.

       When running Wget2 without -N, -nc, -r, or -p, downloading  the  same  file  in  the  same
       directory  will  result  in  the original copy of file being preserved and the second copy
       being named file.1.  If that file is downloaded yet again, the third copy  will  be  named
       file.2,  and so on.  (This is also the behavior with -nd, even if -r or -p are in effect.)
       When -nc is specified, this behavior is suppressed, and  Wget2  will  refuse  to  download
       newer  copies of file.  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 Wget2 with -r or -p, but without -N, -nd, or -nc, re-downloading a file will
       result in the new copy simply overwriting the old.  Adding -nc will prevent this behavior,
       instead causing the original version to be preserved and any newer copies on the server to
       be ignored.

       When running Wget2 with -N, with or without -r or -p, 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.  -nc may not be specified at the same time as -N.

       A combination with -O/--output-document is only accepted if the given output file does not
       exist.

       Note that when -nc is specified, files with the suffixes .html or .htm will be loaded from
       the local disk and parsed as if they had been retrieved from the Web.

   --backups=backups
       Before (over)writing a file, back up an existing file by adding a .1 suffix (_1 on VMS) to
       the  file  name.   Such  backup files are rotated to .2, .3, and so on, up to backups (and
       lost beyond that).

   -c, --continue
       Continue getting a partially-downloaded file.  This is useful when you want to finish up a
       download started by a previous instance of Wget2, or by another program.  For instance:

                wget2 -c https://example.com/tarball.gz

       If there is a file named tarball.gz in the current directory, Wget2 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
       Wget2 to retry downloading a file should the connection be lost midway through.   This  is
       the  default  behavior.   -c  only  affects  resumption of downloads started prior to this
       invocation of Wget2, and whose local files are still sitting around.

       Without -c, the previous example would just download  the  remote  file  to  tarball.gz.1,
       leaving the truncated tarball.gz file alone.

       If  you  use  -c  on  a  non-empty file, and it turns out that the server does not support
       continued downloading, Wget2 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.

       If you use -c on a file which is of equal size as the one on the server, Wget2 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, 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 wget2 -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 changed, as opposed to just
       appended to, you’ll end up with a garbled file.  Wget2 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 in conjunction with -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 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 only works with HTTP servers that support the “Range” header.

   --start-pos=OFFSET
       Start  downloading  at  zero-based  position  OFFSET.   Offset  may be expressed in bytes,
       kilobytes with the k'   suffix, or megabytes with them’ suffix, etc.

       --start-pos has higher precedence over --continue.  When --start-pos  and  --continue  are
       both specified, Wget2 will emit a warning then proceed as if --continue was absent.

       Server  support for continued download is required, otherwise –start-pos cannot help.  See
       -c for details.

   --progress=type
       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  --progress=dot  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.

       The progress type can also take one or more parameters.  The parameters vary based on  the
       type  selected.  Parameters to type are passed by appending them to the type sperated by a
       colon (:) like this: --progress=type:parameter1:parameter2.

       When using the dotted retrieval,  you  may  set  the  style  by  specifying  the  type  as
       dot:style.   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
       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).  If “mega” is not enough then  you  can  use
       the  “giga” style—each dot represents 1M retrieved, there are eight dots in a cluster, and
       32 dots on each line (so each line contains 32M).

       With --progress=bar, there are currently two possible parameters, force and noscroll.

       When the output is not a TTY, the progress  bar  always  falls  back  to  “dot”,  even  if
       --progress=bar  was  passed  to Wget2 during invokation.  This behaviour can be overridden
       and the “bar” output forced by using the “force” parameter as --progress=bar:force.

       By default, the bar style progress bar scroll the name of the file from left to right  for
       the  file  being  downloaded  if  the filename exceeds the maximum length allotted for its
       display.  In certain cases, such  as  with  –progress=bar:force,  one  may  not  want  the
       scrolling filename in the progress bar.  By passing the “noscroll” parameter, Wget2 can be
       forced to display as much of the filename as possible without scrolling through it.

       Note that you can set the default style using the “progress”  command  in  .wgetrc.   That
       setting  may  be  overridden  from the command line.  For example, to force the bar output
       without scrolling, use –progress=bar:force:noscroll.

   --force-progress
       Force Wget2 to display the progress bar in any verbosity.

       By default, Wget2 only displays the progress bar in verbose mode.  One may  however,  want
       Wget2  to display the progress bar on screen in conjunction with any other verbosity modes
       like –no-verbose or –quiet.  This is often a desired a property  when  invoking  Wget2  to
       download  several  small/large  files.  In such a case, Wget2 could simply be invoked with
       this parameter to get a much cleaner output on the screen.

       This option will also force the progress bar to be printed to stderr when  used  alongside
       the –logfile option.

   -N, --timestamping
       Turn on time-stamping.

   --no-if-modified-since
       Do  not  send If-Modified-Since header in -N mode.  Send preliminary HEAD request instead.
       This has only effect in -N mode.

   --no-use-server-timestamps
       Don’t set the local file’s timestamp by the one on the server.

       By default, when a file is downloaded, its timestamps are set  to  match  those  from  the
       remote  file.   This  allows  the use of –timestamping on subsequent invocations of Wget2.
       However, it is sometimes useful to base the local file’s timestamp on when it was actually
       downloaded; for that purpose, the –no-use-server-timestamps option has been provided.

   -S, --server-response
       Print the response headers sent by HTTP servers.

   --spider
       When invoked with this option, Wget2 will behave as a Web spider, which means that it will
       not download the pages, just check that they are there.  For example, you can use Wget2 to
       check your bookmarks:

                wget2 --spider --force-html -i bookmarks.html

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

   -T seconds, --timeout=seconds
       Set the network timeout to seconds seconds.   This  is  equivalent  to  specifying  --dns-
       timeout, --connect-timeout, and --read-timeout, all at the same time.

       When  interacting with the network, Wget2 can check for timeout and abort the operation if
       it takes too long.  This prevents anomalies like hanging reads and infinite connects.  The
       only  timeout  enabled  by  default  is a 900-second read timeout.  Setting a timeout to 0
       disables it altogether.  Unless you know what you are doing, it is best not to change  the
       default timeout settings.

       All  timeout-related  options  accept  decimal  values,  as well as subsecond values.  For
       example, 0.1 seconds is a legal (though unwise) choice of timeout.  Subsecond timeouts are
       useful for checking server response times or for testing network latency.

   --dns-timeout=seconds
       Set the DNS lookup timeout to seconds 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.

   --connect-timeout=seconds
       Set the connect timeout to seconds 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.

   --read-timeout=seconds
       Set the read (and write) timeout to seconds seconds.  The “time” of this timeout refers to
       idle time: if, at any point in the download,  no  data  is  received  for  more  than  the
       specified  number  of  seconds,  reading fails and the download is restarted.  This option
       does not directly affect the duration of the entire download.

       Of course, the remote server may choose to  terminate  the  connection  sooner  than  this
       option requires.  The default read timeout is 900 seconds.

   --limit-rate=amount
       Limit  the  download  speed to amount bytes per second.  Amount may be expressed in bytes,
       kilobytes with the k suffix, or megabytes with the m suffix.  For example, –limit-rate=20k
       will  limit  the  retrieval rate to 20KB/s.  This is useful when, for whatever reason, you
       don’t want Wget2 to consume the entire available bandwidth.

       This option allows the use of decimal numbers, usually in conjunction with power suffixes;
       for example, –limit-rate=2.5k is a legal value.

       Note that Wget2 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 seconds, --wait=seconds
       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 Wget2 can wait long enough to reasonably expect the network error to be
       fixed before the retry.  The waiting interval specified by this function is influenced  by
       “–random-wait”, which see.

   --waitretry=seconds
       If  you  don’t  want  Wget2  to  wait between every retrieval, but only between retries of
       failed downloads, you can use this option.  Wget2  will  use  linear  backoff,  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 seconds you specify.

       By default, Wget2 will assume a value of 10 seconds.

   --random-wait
       Some web sites may perform log analysis to identify retrieval programs such  as  Wget2  by
       looking  for  statistically  significant  similarities in the time between requests.  This
       option causes the time between requests to vary between 0.5  and  1.5  ###  wait  seconds,
       where  wait  was  specified using the –wait option, in order to mask Wget2’s presence from
       such analysis.

       A 2001 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  --random-wait  option  was  inspired by this ill-advised recommendation to block many
       unrelated users from a web site due to the actions of one.

   --no-proxy[=exceptions]
       If no argument is given, we try to stay backward compatible with  Wget1.x  and  don’t  use
       proxies, even if the appropriate *_proxy environment variable is defined.

       If  a  comma-separated  list  of  exceptions  (domains/IPs) is given, these exceptions are
       accessed without usign a proxy.  It overrides the `no_proxy' environment variable.

   -Q quota, --quota=quota
       Specify download quota for automatic retrievals.  The value  can  be  specified  in  bytes
       (default), kilobytes (with k suffix), or megabytes (with m suffix).

       Note that quota will never affect downloading a single file.  So if you specify

                wget2 -Q10k https://example.com/bigfile.gz

       all  of  the  bigfile.gz  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

                wget2 -Q2m -i sites

       download will be aborted when the quota is exceeded.

       Setting quota to 0 or to inf unlimits the download quota.

   --no-dns-cache
       Turn  off caching of DNS lookups.  Normally, Wget2 remembers the IP addresses it looked up
       from DNS so it doesn’t have to repeatedly contact the DNS server for the  same  (typically
       small)  set of hosts it retrieves from.  This cache exists in memory only; a new Wget2 run
       will contact DNS again.

       However, it has been reported that in some situations it is not desirable  to  cache  host
       names,  even for the duration of a short-running application like Wget2.  With this option
       Wget2 issues a  new  DNS  lookup  (more  precisely,  a  new  call  to  “gethostbyname”  or
       “getaddrinfo”) each time it makes a new connection.  Please note that this option will not
       affect caching that might be performed by the resolving library or by an external  caching
       layer, such as NSCD.

       If you don’t understand exactly what this option does, you probably won’t need it.

   --restrict-file-names=modes
       Change  which  characters  found in remote URLs must be escaped during generation of local
       filenames.  Characters that are restricted by this option are escaped, i.e. replaced  with
       %HH,  where  HH  is  the  hexadecimal number that corresponds to the restricted character.
       This option may also be used to force all  alphabetical  cases  to  be  either  lower-  or
       uppercase.

       By  default, Wget2 escapes the characters that are not valid or safe 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, perhaps because you are downloading to
       a non-native partition, or because you want to disable escaping of the control characters,
       or you want to further restrict characters to only those in the ASCII range of values.

       The  modes  are  a  comma-separated  set  of text values.  The acceptable values are unix,
       windows, nocontrol, ascii, lowercase, and uppercase.  The  values  unix  and  windows  are
       mutually  exclusive  (one will override the other), as are lowercase and uppercase.  Those
       last are special cases, as they do not change the set of characters that would be escaped,
       but rather force local file paths to be converted either to lower- or uppercase.

       When  “unix” is specified, Wget2 escapes the character / and the control characters in the
       ranges 0–31 and 128–159.  This is the default on Unix-like operating systems.

       When “windows” is given, Wget2 escapes the characters , |, /, :, ?, ", *, <,  >,  and  the
       control  characters in the ranges 0–31 and 128–159.  In addition to this, Wget2 in Windows
       mode uses + instead of : to separate host and port in local file names, and uses @ instead
       of ?  to separate the query portion of the file name from the rest.  Therefore, a URL that
       would be saved as www.xemacs.org:4300/search.pl?input=blah in Unix mode would be saved  as
       www.xemacs.org+4300/search.pl@input=blah  in  Windows  mode.   This mode is the default on
       Windows.

       If you specify nocontrol, then the escaping of the control  characters  is  also  switched
       off.   This  option may make sense when you are downloading URLs whose names contain UTF-8
       characters, on a system which can save and display filenames in UTF-8 (some possible  byte
       values  used  in  UTF-8  byte sequences fall in the range of values designated by Wget2 as
       “controls”).

       The ascii mode is used to specify that any bytes whose values are  outside  the  range  of
       ASCII  characters  (that  is, greater than 127) shall be escaped.  This can be useful when
       saving filenames whose encoding does not match the one used locally.

   -4, --inet4-only, -6, --inet6-only
       Force connecting to IPv4 or IPv6 addresses.  With  –inet4-only  or  -4,  Wget2  will  only
       connect  to  IPv4  hosts,  ignoring  AAAA  records in DNS, and refusing to connect to IPv6
       addresses specified in URLs.  Conversely, with –inet6-only or -6, Wget2 will only  connect
       to IPv6 hosts and ignore A records and IPv4 addresses.

       Neither  options  should be needed normally.  By default, an IPv6-aware Wget2 will use the
       address family specified by the host’s DNS record.  If the DNS responds with both IPv4 and
       IPv6  addresses,  Wget2  will  try  them in sequence until it finds one it can connect to.
       (Also see “–prefer-family” option described below.)

       These options can be used to deliberately force the use of IPv4 or IPv6  address  families
       on  dual  family  systems,  usually  to  aid  debugging  or  to  deal  with broken network
       configuration.  Only one of –inet6-only and –inet4-only may be specified at the same time.
       Neither option is available in Wget2 compiled without IPv6 support.

   --prefer-family=none/IPv4/IPv6
       When  given a choice of several addresses, connect to the addresses with specified address
       family first.  The address order returned by DNS is used without change by default.

       This avoids spurious errors and connect attempts when accessing hosts that resolve to both
       IPv6  and  IPv4  addresses  from  IPv4  networks.   For  example, www.kame.net resolves to
       2001:200:0:8002:203:47ff:fea5:3085 and to 203.178.141.194.  When the preferred  family  is
       “IPv4”,  the  IPv4  address  is  used first; when the preferred family is “IPv6”, the IPv6
       address is used first; if the specified value is “none”, the address order returned by DNS
       is used without change.

       Unlike  -4  and  -6,  this  option  doesn’t  inhibit access to any address family, it only
       changes the order in which the addresses are accessed.   Also  note  that  the  reordering
       performed  by  this  option  is  stable—it  doesn’t  affect order of addresses of the same
       family.  That is, the relative order of all IPv4  addresses  and  of  all  IPv6  addresses
       remains intact in all cases.

   --tcp-fastopen
       Enable support for TCP Fast Open (TFO) (default: on).

       TFO  reduces  connection latency by 1 RT on “hot” connections (2nd+ connection to the same
       host in a certain amount of time).

       Currently this works on recent Linux and OSX kernels, on HTTP and HTTPS.

   --dns-caching
       Enable DNS caching (default: on).

       Keep results of DNS lookups in memory to speed up connections.

   --retry-connrefused
       Consider “connection refused” a transient error and try again.  Normally Wget2 gives up on
       a  URL  when  it is unable to connect to the site because failure to connect is taken as a
       sign that the server is not running at all and that retries would not help.   This  option
       is  for  mirroring  unreliable  sites whose servers tend to disappear for short periods of
       time.

   --user=user, --password=password
       Specify the username user and password password for HTTP file retrieval.   This  overrides
       the  lookup  of  credentials  in  the  .netrc  file (–netrc is enabled by default).  These
       parameters can be overridden using the –http-user and –http-password options  for  HTTP(S)
       connections.

       If  neither  –http-proxy-user  nor  –http-proxy-password  is given these settings are also
       taken for proxy authentication.

   --ask-password
       Prompt for a password on the command line.  Overrides the password set  by  –password  (if
       any).

   --use-askpass=command
       Prompt  for  a  user  and password using the specified command.  Overrides the user and/or
       password set by –user/–password (if any).

   --no-iri
       Turn off internationalized URI (IRI) support.  Use –iri to turn it  on.   IRI  support  is
       activated by default.

       You  can  set  the  default state of IRI support using the “iri” command in .wgetrc.  That
       setting may be overridden from the command line.

   --local-encoding=encoding
       Force Wget2 to use encoding as the  default  system  encoding.   That  affects  how  Wget2
       converts URLs specified as arguments from locale to UTF-8 for IRI support.

       Wget2  use the function “nl_langinfo()” and then the “CHARSET” environment variable to get
       the locale.  If it fails, ASCII is used.

   --remote-encoding=encoding
       Force Wget2 to use encoding as the default remote server encoding.  That affects how Wget2
       converts URIs found in files from remote encoding to UTF-8 during a recursive fetch.  This
       options is only useful for IRI support, for the interpretation of non-ASCII characters.

       For HTTP, remote encoding can be found in HTTP “Content-Type” header and in HTML “Content-
       Type http-equiv” meta tag.

   --input-encoding=encoding
       Use  the specified encoding for the URLs read from --input-file.  The default is the local
       encoding.

   --unlink
       Force Wget2 to unlink file instead of clobbering existing file.  This option is useful for
       downloading to the directory with hardlinks.

   --cut-url-get-vars
       Remove  HTTP  GET  Variables  from  URLs.  For example “main.css?v=123” will be changed to
       “main.css”.   Be  aware  that  this  may  have  unintended  side  effects,   for   example
       “image.php?name=sun”  will  be  changed to “image.php”.  The cutting happens before adding
       the URL to the download queue.

   --cut-file-get-vars
       Remove HTTP GET Variables from filenames.  For example “main.css?v=123” will be changed to
       “main.css”.

       Be aware that this may have unintended side effects, for example “image.php?name=sun” will
       be changed to “image.php”.  The cutting happens when saving the file, after downloading.

       File names obtained from a “Content-Disposition” header are not affected by  this  setting
       (see –content-disposition), and can be a solution for this problem.

       When “–trust-server-names” is used, the redirection URL is affected by this setting.

   --chunk-size=size
       Download  large  files  in  multithreaded  chunks.   This switch specifies the size of the
       chunks, given in bytes if no other byte multiple unit is specified.  By default  it’s  set
       on 0/off.

   --max-threads=number
       Specifies  the  maximum number of concurrent download threads for a resource.  The default
       is 5 but if you want to allow more or fewer this is the option to use.

   -s, --verify-sig
       Enable PGP signature verification.  When enabled Wget2 will attempt to download and verify
       PGP  signatures against their corresponding files.  When enabled, any file downloaded that
       has a content type beginning with application/ will cause Wget2  to  request  a  signature
       file for that file.  The name of the signature file is computed by appending the extension
       to the full path of the file that was just downloaded.  The extension used is  defined  by
       the  --signature-extensions  option.   If  the  content  type for the signature request is
       application/pgp-signature, Wget2 will attempt to verify the signature against the original
       file.

   --signature-extensions
       Specify the file extensions for signature files, without the leading “.”.  You may specify
       multiple extensions as a comma separated list.  All the provided extensions will be  tried
       simultaneously when looking for the signature file.  The default is “sig”.

   --gnupg-homedir
       Specifies  the  gnupg  home  directory  to use when verifying PGP signatures on downloaded
       files.  The default for this is your system’s default home directory.

   --verify-save-failed
       Instructs Wget2 to keep files that don’t pass PGP signature validation.  The default is to
       delete files that fail validation.

   --xattr
       Saves  documents metadata as “user POSIX Extended Attributes” (default: on).  This feature
       only    works    if    the    file    system    supports     it.      More     info     on
       https://freedesktop.org/wiki/CommonExtendedAttributes.

       Wget2  currently  sets  *  user.xdg.origin.url  * user.xdg.referrer.url * user.mime_type *
       user.charset

       To display the extended attributes of a file (Linux): getfattr -d <file>

   --metalink
       Follow/process metalink URLs without saving them (default: on).

       Metalink files describe  downloads  incl. mirrors,  files,  checksums,  signatures.   This
       allows chunked downloads, automatically taking the nearest mirrors, preferring the fastest
       mirrors and checking the download for integrity.

   --fsync-policy
       Enables disk synching after each write (default: off).

   --http2-request-window=number
       Set max.  number of parallel streams per HTTP/2 connection (default: 30).

   Directory Options
   -nd, --no-directories
       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).

   -x, --force-directories
       The opposite of -nd—create a hierarchy of directories, even if one  would  not  have  been
       created otherwise.  E.g.  wget2 -x https://example.com/robots.txt will save the downloaded
       file to example.com/robots.txt.

   -nH, --no-host-directories
       Disable generation of host-prefixed directories.   By  default,  invoking  Wget2  with  -r
       https://example.com/  will  create a structure of directories beginning with example.com/.
       This option disables such behavior.

   --protocol-directories
       Use the protocol name as a directory component of local file  names.   For  example,  with
       this option, wget2 -r   https://example.com will save to https/example.com/... rather than
       just to example.com/....

   --cut-dirs=number
       Ignore a number of 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 https://example.com/pub/sub/.  If you retrieve it with
       -r, it will be saved locally under example.com/pub/sub/.  While the -nH option can  remove
       the  example.com/ part, you are still stuck with pub/sub/.  This is where --cut-dirs comes
       in handy; it makes Wget2 not “see” a number of  remote  directory  components.   Here  are
       several    examples    of   how   --cut-dirs   option   works.    No   options          ->
       example.com/pub/sub/      --cut-dirs=1      -> example.com/sub/      --cut-dirs=2       ->
       example.com/       -nH                ->  pub/sub/      -nH --cut-dirs=1  -> sub/      -nH
       --cut-dirs=2  -> .  If you just want to get rid of the directory structure, this option is
       similar  to  a  combination  of -nd and -P.  However, unlike -nd, --cut-dirs does not lose
       with subdirectories.  For instance, with -nH --cut-dirs=1, a beta/  subdirectory  will  be
       placed to sub/beta/, as one would expect.

   -P prefix, --directory-prefix=prefix
       Set  directory  prefix  to  prefix.  The directory prefix 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).

   HTTP Options
   --default-page=name
       Use  name  as  the  default  file  name  when it isn’t known (i.e., for URLs that end in a
       slash), instead of index.html.

   --default-http-port=port
       Set the default port for HTTP URLs (default: 80).

       This is mainly for testing purposes.

   --default-https-port=port
       Set the default port for HTTPS URLs (default: 443).

       This is mainly for testing purposes.

   -E, --adjust-extension
       If a file of type application/xhtml+xml or text/html is downloaded and the  URL  does  not
       end  with  the  regexp  \.[Hh][Tt][Mm][Ll]?, this option will cause the suffix .html to be
       appended to the local filename.  This is useful, for instance,  when  you’re  mirroring  a
       remote  site  that uses .asp 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   https://example.com/article.cgi?25   will   be   saved   as
       article.cgi?25.html.

       Note that filenames changed in this way will be re-downloaded every time you  re-mirror  a
       site,  because  Wget2  can’t  tell  that the local X.html file corresponds to remote URL X
       (since  it  doesn’t  yet  know  that  the  URL  produces  output  of  type  text/html   or
       application/xhtml+xml.

       Wget2 will also ensure that any downloaded files of type text/css end in the suffix .css.

       At  some  point  in  the  future, this option may well be expanded to include suffixes for
       other types of content, including content types that are not parsed by Wget.

   --http-user=user, --http-password=password
       Specify the user and password for HTTP authentication.   According  to  the  type  of  the
       challenge, Wget will encode them using either the “basic” (insecure), the “digest”, or the
       Windows “NTLM” authentication scheme.

       If possible, put your  credentials  into  ~/.netrc  (see  also  --netrc  and  --netrc-file
       options) or into ~/.wgetrc.  This is far more secure than using the command line which can
       be seen by any other user.  If the passwords are really important, do not leave them lying
       in  those  files  either.   Edit  the  files  and  delete them after Wget2 has started the
       download.

       Also see --use-askpass and --ask-password  for  an  interactive  method  to  provide  your
       password.

   --http-proxy-user=user, --http-proxy-password=password
       Specify the user and password for HTTP proxy authentication.  See --http-user for details.

   --http-proxy=proxies
       Set  comma-separated  list of HTTP proxies.  The environment variable `http_proxy' will be
       overridden.

       Exceptions can be set via the environment variable `no_proxy' or via --no-proxy.

   --https-proxy=proxies
       Set comma-separated list of HTTPS proxies.  The environment variable `https_proxy' will be
       overridden.

       Exceptions can be set via the environment variable `no_proxy' or via --no-proxy.

   --no-http-keep-alive
       Turn  off the “keep-alive” feature for HTTP(S) downloads.  Normally, Wget2 asks the server
       to keep the connection open so that, when you download more than  one  document  from  the
       same  server,  they  get transferred over the same TCP connection.  This saves time and at
       the same time reduces the load on the server.

       This option is useful when, for some reason,  persistent  (keep-alive)  connections  don’t
       work  for  you,  for  example  due  to a server bug or due to the inability of server-side
       scripts to cope with the connections.

   --no-cache
       Disable server-side cache.  In this case, Wget2 will send the remote server an appropriate
       directive  (Pragma:  no-  cache)  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.

   --no-cookies
       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, storing cookies is not
       on by default.

   --load-cookies file
       Load cookies from file before the first HTTP(S) retrieval.  file is a textual file in  the
       format originally used by Netscape’s cookies.txt 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  Wget2 to send the same cookies your browser sends when
       communicating with the site.  This is achieved by –load-cookies—simply point Wget2 to  the
       location  of  the  cookies.txt  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:

       “Netscape 4.x.” The cookies are in ~/.netscape/cookies.txt.

       “Mozilla  and  Netscape  6.x.”  Mozilla’s  cookie  file is also named cookies.txt, located
       somewhere under ~/.mozilla, in the directory of your profile.  The full path usually  ends
       up looking somewhat like ~/.mozilla/default/some-weird- string/cookies.txt.

       “Internet  Explorer.”  You can produce a cookie file Wget2 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.

       “Other  browsers.”  If  you  are  using a different browser to create your cookies, –load-
       cookies will only work if you can locate or produce a cookie file in the  Netscape  format
       that Wget2 expects.

       If  you  cannot  use --load-cookies, 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
       Wget2 to send those cookies, bypassing the “official” cookie support:

                wget2 --no-cookies --header "Cookie: <name>=<value>"

   --save-cookies file
       Save cookies to file before exiting.  This will not save cookies that have expired or that
       have no expiry time (so-called “session cookies”), but also see –keep-session-cookies.

   --keep-session-cookies
       When  specified,  causes  –save-cookies to also save session cookies.  Session cookies are
       normally not saved because they are meant to be kept in memory and forgotten when you exit
       the  browser.   Saving  them is useful on sites that require you to log in or to visit the
       home page before you can access some pages.  With this option,  multiple  Wget2  runs  are
       considered a single browser session as far as the site is concerned.

       Since  the  cookie  file  format does not normally carry session cookies, Wget2 marks them
       with an expiry timestamp of 0.  Wget2’s –load-cookies recognizes those as session cookies,
       but  it might confuse other browsers.  Also note that cookies so loaded will be treated as
       other session cookies, which means that if you want –save-cookies to preserve them  again,
       you must use –keep-session-cookies again.

   --cookie-suffixes=file
       Load the public suffixes used for cookie checking from the given file.

       Normally,  the  underlying  libpsl  loads  this data from a system file or it has the data
       built  in.   In  some  cases  you  might  want  to  load   an   updated   PSL,   e.g. from
       https://publicsuffix.org/list/public_suffix_list.dat.

       The  PSL allows to prevent setting of “super-cookies” that lead to cookie privacy leakage.
       More details can be found on https://publicsuffix.org/.

   --ignore-length
       Unfortunately, some HTTP servers (CGI  programs,  to  be  more  precise)  send  out  bogus
       “Content-Length” headers, which makes Wget2 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, Wget2 will ignore the “Content-Length” header—as if it never existed.

   --header=header-line
       Send header-line along with the rest of the headers in each HTTP  request.   The  supplied
       header  is  sent as-is, which means it must contain name and value separated by colon, and
       must not contain newlines.

       You may define more than one additional header by specifying –header more than once.

                wget2 --header='Accept-Charset: iso-8859-2' \
                     --header='Accept-Language: hr'        \
                       https://example.com/

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

       This  option  can  be  used  to  override headers otherwise generated automatically.  This
       example instructs Wget2 to connect to localhost, but to specify example.com in the  “Host”
       header:

                wget2 --header="Host: example.com" http://localhost/

   --max-redirect=number
       Specifies the maximum number of redirections to follow for a resource.  The default is 20,
       which is usually far more than necessary.  However, on those occasions where you  want  to
       allow more (or fewer), this is the option to use.

   --proxy-user=user, --proxy-password=password
       Specify  the  username  user  and  password password for authentication on a proxy server.
       Wget2 will encode them using the “basic” authentication scheme.

       Security considerations similar to those with --http-password pertain here as well.

   --referer=url
       Include `Referer: url’ 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.

   --save-headers
       Save  the headers sent by the HTTP server to the file, preceding the actual contents, with
       an empty line as the separator.

   -U agent-string, --user-agent=agent-string
       Identify as agent-string 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  Wget/version,  version
       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 this is not such a bad idea in theory, it
       has  been  abused  by  servers  denying  information  to clients other than (historically)
       Netscape or, more frequently, 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.

       Specifying empty user agent with –user-agent="" instructs Wget2 not  to  send  the  “User-
       Agent” header in HTTP requests.

   --post-data=string, --post-file=file
       Use  POST  as  the method for all HTTP requests and send the specified data in the request
       body.  –post-data sends string as data, whereas –post-file sends  the  contents  of  file.
       Other  than  that,  they  work  in  exactly the same way.  In particular, they both expect
       content  of  the  form  “key1=value1&key2=value2”,  with  percent-encoding   for   special
       characters;  the  only  difference  is  that  one  expects  its  content as a command-line
       parameter and the other accepts its content from a file.  In particular, –post-file is not
       for  transmitting  files  as form attachments: those must appear as “key=value” data (with
       appropriate percent-coding) just like everything else.  Wget2 does not  currently  support
       “multipart/form-data”   for   transmitting   POST   data;   only  “application/x-www-form-
       urlencoded”.  Only one of –post-data and –post-file should be specified.

       Please  note  that  wget2  does  not   require   the   content   to   be   of   the   form
       “key1=value1&key2=value2”,  and  neither  does it test for it.  Wget2 will simply transmit
       whatever data is provided to it.  Most servers however expect the POST data to be  in  the
       above format when processing HTML Forms.

       When  sending  a  POST  request  using  the --post-file option, Wget2 treats the file as a
       binary file and will send every character in the POST request without  stripping  trailing
       newline  or  formfeed  characters.   Any other control characters in the text will also be
       sent as-is in the POST request.

       Please be aware that Wget2 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
       /dev/stdin won’t work.  It’s not quite clear how to work around this  limitation  inherent
       in  HTTP/1.0.   Although HTTP/1.1 introduces chunked 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.

       If Wget2 is redirected after the POST request is completed, its behaviour depends  on  the
       response  code  returned  by  the  server.   In case of a 301 Moved Permanently, 302 Moved
       Temporarily or 307 Temporary Redirect, Wget2 will, in accordance with RFC2616, continue to
       send  a POST request.  In case a server wants the client to change the Request method upon
       redirection, it should send a 303 See Other response code.

       This example shows how to log in 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.
                wget2 --save-cookies cookies.txt \
                     --post-data  'user=foo&password=bar' \
                     http://example.com/auth.php

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

       If  the  server  is using session cookies to track user authentication, the above will not
       work because --save-cookies will not  save  them  (and  neither  will  browsers)  and  the
       cookies.txt  file will be empty.  In that case use –keep-session-cookies along with –save-
       cookies to force saving of session cookies.

   --method=HTTP-Method
       For the purpose of RESTful scripting, Wget2 allows sending of other HTTP  Methods  without
       the need to explicitly set them using –header=Header-Line.  Wget2 will use whatever string
       is passed to it after –method as the HTTP Method to the server.

   --body-data=Data-String, --body-file=Data-File
       Must be set when additional data needs to be sent to the  server  along  with  the  Method
       specified  using --method.  --body-data sends string as data, whereas –body-file sends the
       contents of file.  Other than that, they work in exactly the same way.

       Currently, --body-file is not for transmitting files as a whole.  Wget2 does not currently
       support   “multipart/form-data”   for  transmitting  data;  only  “application/x-www-form-
       urlencoded”.  In the future, this may be changed so that wget2 sends the –body-file  as  a
       complete  file  instead of sending its contents to the server.  Please be aware that Wget2
       needs to know the contents of BODY Data in advance, and hence the argument  to  –body-file
       should  be  a  regular file.  See –post-file for a more detailed explanation.  Only one of
       –body-data and –body-file should be specified.

       If Wget2 is redirected after the request is completed,  Wget2  will  suspend  the  current
       method  and  send  a  GET request till the redirection is completed.  This is true for all
       redirection response codes except 307 Temporary  Redirect  which  is  used  to  explicitly
       specify  that  the request method should not change.  Another exception is when the method
       is set to “POST”, in which case the redirection  rules  specified  under  --post-data  are
       followed.

   --content-disposition
       If  this  is  set  to  on,  experimental  (not  fully-functional)  support  for  “Content-
       Disposition” headers is enabled.  This can currently result in extra  round-trips  to  the
       server  for  a  “HEAD” request, and is known to suffer from a few bugs, which is why it is
       not currently enabled by default.

       This  option  is  useful  for  some  file-downloading  CGI  programs  that  use  “Content-
       Disposition” headers to describe what the name of a downloaded file should be.

   --content-on-error
       If this is set to on, wget2 will not skip the content when the server responds with a http
       status code that indicates error.

   --trust-server-names
       If this is set to on, on a redirect the last component of the redirection URL will be used
       as the local file name.  By default it is used the last component in the original URL.

   --auth-no-challenge
       If  this option is given, Wget2 will send Basic HTTP authentication information (plaintext
       username and password) for all requests.

       Use of this option is not recommended, and is intended only to support  some  few  obscure
       servers,  which  never  send  HTTP  authentication challenges, but accept unsolicited auth
       info, say, in addition to form-based authentication.

   --compression=TYPE
       If this TYPE(identity, gzip, deflate, xz, lzma, br, bzip2 or any  combination  of  it)  is
       given,  Wget2  will  set  “Accept-Encoding” header accordingly.  --no-compression means no
       “Accept-Encoding” header at all.  To set “Accept-Encoding” to a custom  value,  use  --no-
       compression in combination with --header="Accept-Encoding: xxx".

       Compatibility-Note: none type in Wget 1.X has the same meaning as identity type in Wget2.

   HTTPS (SSL/TLS) Options
       To  support  encrypted HTTP (HTTPS) downloads, Wget2 must be compiled with an external SSL
       library.  The current default is GnuTLS.  In addition,  Wget2  also  supports  HSTS  (HTTP
       Strict  Transport  Security).   If  Wget2  is  compiled without SSL support, none of these
       options are available.

   --secure-protocol=protocol
       Choose the secure protocol to be used (default: auto).

       Legal values are auto, SSLv3, TLSv1 and PFS.  If auto is used, the TLS  library’s  default
       is used.

       Specifying SSLv3, TLSv1 forces the use of the corresponding protocol.  This is useful when
       talking to old and buggy SSL server implementations that make it hard for  the  underlying
       TLS library to choose the correct protocol version.

       Specifying  PFS  enforces the use of the so-called Perfect Forward Security cipher suites.
       In short, PFS adds security by creating a one-time key for each TLS connection.  It has  a
       bit more CPU impact on client and server.  We use known to be secure ciphers (e.g. no MD4)
       and the TLS protocol.

       Any other protocol string is directly given to the TLS library,  currently  GnuTLS,  as  a
       “priority” or “cipher” string.  This is for users who know what they are doing.

   --https-only
       When in recursive mode, only HTTPS links are followed.

   --no-check-certificate
       Don’t  check  the  server certificate against the available certificate authorities.  Also
       don’t require the URL host name to match the common name presented by the certificate.

       The default is to verify the  server’s  certificate  against  the  recognized  certificate
       authorities,  breaking  the  SSL  handshake  and aborting the download if the verification
       fails.  Although this provides more secure downloads, it does break interoperability  with
       some  sites that worked with previous Wget versions, particularly those using self-signed,
       expired, or otherwise invalid certificates.  This option  forces  an  “insecure”  mode  of
       operation  that  turns the certificate verification errors into warnings and allows you to
       proceed.

       If you encounter “certificate verification”  errors  or  ones  saying  that  “common  name
       doesn’t match requested host name”, you can use this option to bypass the verification and
       proceed with the download.  Only use this option if you are  otherwise  convinced  of  the
       site’s  authenticity,  or  if you really don’t care about the validity of its certificate.
       It is  almost  always  a  bad  idea  not  to  check  the  certificates  when  transmitting
       confidential  or  important  data.   For  self-signed/internal  certificates,  you  should
       download the certificate and verify against that instead of forcing  this  insecure  mode.
       If  you  are  really  sure  of  not desiring any certificate verification, you can specify
       –check-certificate=quiet  to  tell  Wget2  to  not  print  any   warning   about   invalid
       certificates, albeit in most cases this is the wrong thing to do.

   --certificate=file
       Use the client certificate stored in file.  This is needed for servers that are configured
       to require certificates from the clients that connect to them.  Normally a certificate  is
       not required and this switch is optional.

   --certificate-type=type
       Specify the type of the client certificate.  Legal values are PEM (assumed by default) and
       DER, also known as ASN1.

   --private-key=file
       Read the private key from file.  This allows you to provide the  private  key  in  a  file
       separate from the certificate.

   --private-key-type=type
       Specify the type of the private key.  Accepted values are PEM (the default) and DER.

   --ca-certificate=file
       Use  file  as  the  file  with  the bundle of certificate authorities (“CA”) to verify the
       peers.  The certificates must be in PEM format.

       Without this option Wget2 looks for CA certificates  at  the  system-specified  locations,
       chosen at OpenSSL installation time.

   --ca-directory=directory
       Specifies  directory  containing CA certificates in PEM format.  Each file contains one CA
       certificate, and the file name is based on a hash  value  derived  from  the  certificate.
       This  is  achieved  by  processing  a  certificate  directory  with the “c_rehash” utility
       supplied with OpenSSL.  Using --ca-directory is more efficient than --ca-certificate  when
       many certificates are installed because it allows Wget2 to fetch certificates on demand.

       Without  this  option  Wget2  looks for CA certificates at the system-specified locations,
       chosen at OpenSSL installation time.

   --crl-file=file
       Specifies a CRL file in file.  This is needed for certificates that have been revocated by
       the CAs.

   --random-file=file
       [OpenSSL  and LibreSSL only] Use file as the source of random data for seeding the pseudo-
       random number generator on systems without /dev/urandom.

       On such systems the SSL library needs an external  source  of  randomness  to  initialize.
       Randomness  may  be  provided by EGD (see –egd-file below) or read from an external source
       specified by the user.  If this option is not specified, Wget2 looks for  random  data  in
       $RANDFILE or, if that is unset, in $HOME/.rnd.

       If  you’re  getting  the  “Could  not seed OpenSSL PRNG; disabling SSL.” error, you should
       provide random data using some of the methods described above.

   --egd-file=file
       [OpenSSL only] Use file as the EGD socket.  EGD stands for  Entropy  Gathering  Daemon,  a
       user-space  program that collects data from various unpredictable system sources and makes
       it available to other programs that might need it.  Encryption software, such as  the  SSL
       library,  needs  sources  of  non-repeating randomness to seed the random number generator
       used to produce cryptographically strong keys.

       OpenSSL allows the user to specify  his  own  source  of  entropy  using  the  “RAND_FILE”
       environment  variable.   If  this  variable  is  unset,  or if the specified file does not
       produce enough randomness, OpenSSL will read random data from EGD socket  specified  using
       this option.

       If  this  option is not specified (and the equivalent startup command is not used), EGD is
       never contacted.  EGD is not needed on modern Unix systems that support /dev/urandom.

   --hsts
       Wget2 supports HSTS (HTTP Strict Transport Security, RFC 6797) by default.  Use  --no-hsts
       to  make  Wget2  act as a non-HSTS-compliant UA.  As a consequence, Wget2 would ignore all
       the “Strict-Transport-Security” headers, and would not enforce any existing HSTS policy.

   --hsts-file=file
       By default, Wget2 stores its HSTS database in ~/.wget-hsts.  You  can  use  –hsts-file  to
       override  this.   Wget2  will  use the supplied file as the HSTS database.  Such file must
       conform to the correct HSTS database format used by  Wget.   If  Wget2  cannot  parse  the
       provided file, the behaviour is unspecified.

       The  Wget2’s HSTS database is a plain text file.  Each line contains an HSTS entry (ie.  a
       site that has issued a “Strict-Transport-Security” header and that therefore has specified
       a  concrete  HSTS  policy to be applied).  Lines starting with a dash (“#”) are ignored by
       Wget.  Please note that in spite of this  convenient  human-readability  hand-hacking  the
       HSTS database is generally not a good idea.

       An HSTS entry line consists of several fields separated by one or more whitespace:

                <hostname> SP [<port>] SP <include subdomains> SP <created> SP <max-age>

       The hostname and port fields indicate the hostname and port to which the given HSTS policy
       applies.  The port field may be zero, and it will, in most of the cases.  That means  that
       the  port  number  will  not  be taken into account when deciding whether such HSTS policy
       should be applied on a given request (only the hostname will be evaluated).  When port  is
       different  to  zero,  both the target hostname and the port will be evaluated and the HSTS
       policy will only be applied if both of them match.  This feature  has  been  included  for
       testing/development  purposes  only.   The  Wget2  testsuite  (in  testenv/)  creates HSTS
       databases with explicit ports with the purpose  of  ensuring  Wget2’s  correct  behaviour.
       Applying  HSTS  policies  to  ports other than the default ones is discouraged by RFC 6797
       (see Appendix B “Differences between HSTS Policy and  Same-Origin  Policy”).   Thus,  this
       functionality  should  not  be  used in production environments and port will typically be
       zero.  The last three fields do what they are expected to.  The  field  include_subdomains
       can  either be 1 or 0 and it signals whether the subdomains of the target domain should be
       part of the given HSTS policy as well.  The created and max-age fields hold the  timestamp
       values  of  when  such  entry  was created (first seen by Wget) and the HSTS-defined value
       `max-age', which states how long should  that  HSTS  policy  remain  active,  measured  in
       seconds  elapsed  since  the timestamp stored in created.  Once that time has passed, that
       HSTS policy will no longer be valid and will eventually be removed from the database.

       If you supply your own HSTS database via –hsts-file, be aware that Wget2  may  modify  the
       provided  file  if  any  change  occurs  between the HSTS policies requested by the remote
       servers and those in the file.   When  Wget2  exists,  it  effectively  updates  the  HSTS
       database by rewriting the database file with the new entries.

       If  the  supplied  file does not exist, Wget2 will create one.  This file will contain the
       new HSTS entries.  If no  HSTS  entries  were  generated  (no  “Strict-Transport-Security”
       headers  were  sent by any of the servers) then no file will be created, not even an empty
       one.  This behaviour applies to the default database file (~/.wget-hsts) as well: it  will
       not be created until some server enforces an HSTS policy.

       Care  is  taken not to override possible changes made by other Wget2 processes at the same
       time over the HSTS database.  Before dumping the updated HSTS entries on the  file,  Wget2
       will re-read it and merge the changes.

       Using  a  custom  HSTS database and/or modifying an existing one is discouraged.  For more
       information about the potential security threats arised from such practice, see section 14
       “Security  Considerations”  of  RFC 6797, specially section 14.9 “Creative Manipulation of
       HSTS Policy Store”.

   --hpkp
       Enable HTTP Public Key Pinning (HPKP) (default: on).

       This is a Trust On First Use (TOFU) mechanism to add another security layer to HTTPS  (RFC
       7469).   It  persistently  stores  the data into ~/.wget-hpkp which can be changed via the
       --hpkp-fileoption.

   --hpkp-file=file
       For HPKP (--hpkp) you need the certificate  key  data  of  a  previously  established  TLS
       session.  Wget2 persistently stores this data in the given file (default: ~/.wget-hpkp).

       To disable persistent storage use --no-hpkp-file.

   --tls-resume
       Enable TLS Session Resumption which is disabled as default.

       There are several security flaws related to TLS 1.2 session resumption which are explained
       in detail at:  https://web.archive.org/web/20171103231804/https://blog.filippo.io/we-need-
       to-talk-about-session-tickets/

   --tls-session-file=file
       For  TLS  Session  Resumption  (--tls-resume)  you  need  the session data of a previously
       established TLS session.  Wget2 persistently stores this data in the given file  (default:
       ~/.wget-session).

       To disable persistent storage use --no-tls-session-file.

   --tls-false-start
       Enable TLS False start (default: on).

       This reduces TLS negotiation by one RT and thus speeds up HTTPS connections.

       More details at https://tools.ietf.org/html/rfc7918.

   --check-hostname
       Enable TLS SNI verification (default: on).

   --ocsp
       Enable OCSP server access to check the possible revocation the HTTPS server certificate(s)
       (default: on).

       This procedure is pretty slow (connect to server, HTTP  request,  response)  and  thus  we
       support  OSCP  stapling  (server  sends OCSP response within TLS handshake) and persistent
       OCSP caching.

   --ocsp-stapling
       Enable support for OCSP stapling (default: on).

   --ocsp-file=file
       Set the file for persistent OCSP response caching (default: ~/.wget-ocsp).

       To disable persistent OCSP caching use --no-ocsp-file.

   --http2
       Enable HTTP/2 protocol (default: on).

       Wget2 requests HTTP/2 via ALPN.  If available it is preferred over  HTTP/1.1.   Up  to  30
       streams are used in parallel within a single connection.

   --gnutls-options=options
       Sets  the  GnuTLS  “priority”  string  (see  https://gnutls.org/manual/html_node/Priority-
       Strings.html).

       This is for experts only.  Normally you would  use  --secure-protocol  to  set  predefined
       priority strings.

   --https-enforce=mode
       Sets  how  to  deal  with URLs that are not explicitly HTTPS (where scheme isn’t https://)
       (default: none)

   mode=none
       Use HTTP for URLs without scheme.   In  recursive  operation  the  scheme  of  the  parent
       document is taken as default.

   mode=soft
       Try HTTPS first when the scheme is HTTP or not given.  On failure fall back to HTTP.

   mode=hard
       Only use HTTPS, no matter if a HTTP scheme is given or not.  Do not fall back to HTTP.

   Recursive Retrieval Options
   -r, --recursive
       Turn on recursive retrieving.  The default maximum depth is 5.

   -l depth, --level=depth
       Specify recursion maximum depth level depth.

   --delete-after
       This  option  tells  Wget2 to delete every single file it downloads, after having done so.
       It is useful for pre- fetching popular pages through a proxy, e.g.:

                wget2 -r -nd --delete-after https://example.com/~popular/page/

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

       Note that when –delete-after is specified, –convert-links is ignored, so .orig  files  are
       simply not created in the first place.

   -k, --convert-links
       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:

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

           Example:  if the downloaded file /foo/doc.html links to /bar/img.gif, also downloaded,
           then the link in doc.html will be modified to point to ../bar/img.gif.  This  kind  of
           transformation works reliably for arbitrary combinations of directories.

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

           Example:  if  the  downloaded  file  /foo/doc.html  links  to  /bar/img.gif   (or   to
           ../bar/img.gif),   then   the   link   in  doc.html  will  be  modified  to  point  to
           https://example.com/bar/img.gif.

       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 Wget2 know which links have been downloaded.
       Because of that, the work done by -k will be performed at the end of all the downloads.

   --convert-file-only
       This  option  converts  only  the  filename part of the URLs, leaving the rest of the URLs
       untouched.  This filename part is sometimes referred to as  the  “basename”,  although  we
       avoid that term here in order not to cause confusion.

       It  works particularly well in conjunction with --adjust-extension, although this coupling
       is not enforced.  It proves useful to populate Internet caches with files downloaded  from
       different hosts.

       Example:  if some link points to //foo.com/bar.cgi?xyz with –adjust-extension asserted and
       its local destination is intended to be ./foo.com/bar.cgi?xyz.css, then the link would  be
       converted  to  //foo.com/bar.cgi?xyz.css.   Note  that  only  the  filename  part has been
       modified.  The rest of the URL has been left untouched,  including  the  net  path  (“//”)
       which  would  otherwise  be  processed by Wget2 and converted to the effective scheme (ie.
       “https://”).

   -K, --backup-converted
       When converting a file, back up the original version with a  .orig  suffix.   Affects  the
       behavior of -N.

   -m, --mirror
       Turn on options suitable for mirroring.  This option turns on recursion and time-stamping,
       sets infinite recursion depth.  It is currently equivalent to -r -N -l inf.

   -p, --page-requisites
       This option causes Wget2 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 together with -l can help, but
       since Wget2 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.html contains an <IMG> tag referencing 1.gif and an <A> tag
       pointing to external document 2.html.  Say that 2.html is similar but that  its  image  is
       2.gif and it links to 3.html.  Say this continues up to some arbitrarily high number.

       If one executes the command:

                wget2 -r -l 2 https://<site>/1.html

       then  1.html, 1.gif, 2.html, 2.gif, and 3.html will be downloaded.  As you can see, 3.html
       is without its requisite 3.gif because Wget2 is simply counting the number of hops (up  to
       2) away from 1.html in order to determine where to stop the recursion.  However, with this
       command:

                wget2 -r -l 2 -p https://<site>/1.html

       all the above files and 3.html’s requisite 3.gif will be downloaded.  Similarly,

                wget2 -r -l 1 -p https://<site>/1.html

       will cause 1.html, 1.gif, 2.html, and 2.gif to be downloaded.  One might think that:

                wget2 -r -l 0 -p https://<site>/1.html

       would download just 1.html and 1.gif, but unfortunately this is not the case, because -l 0
       is equivalent to -l inf—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 URL input file) and its  (or
       their) requisites, simply leave off -r and -l:

                wget2 -p https://<site>/1.html

       Note that Wget2 will behave as if -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:

                wget2 -E -H -k -K -p https://<site>/<document>

       To  finish  off  this  topic, it’s worth knowing that Wget2’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">.

   --strict-comments
       Obsolete  option  for compatibility with Wget1.x.  Wget2 always terminates comments at the
       first occurrence of -->, as popular browsers do.

   --robots
       Enable the Robots Exclusion Standard (default: on).

       For each visited domain, download /robots.txt first and follow  it’s  rules.   You  should
       respect the domain owner’s rules and turn this off only for very good reasons.

       When  enabled, the robots.txt file is also scanned for sitemaps.  These are lists of pages
       / files available for download that not necessarily are available via recursive scanning.

   Recursive Accept/Reject Options
   -A acclist, --accept=acclist, -R rejlist, --reject=rejlist
       Specify comma-separated lists of file name suffixes or patterns to accept or reject.  Note
       that  if  any  of  the wildcard characters, *, ?, [, ], appear in an element of acclist or
       rejlist, it will be treated as a pattern, rather than a suffix.  In this case, you have to
       enclose  the  pattern  into  quotes  to  prevent  your shell from expanding it, like in -A
       "*.mp3" or -A '*.mp3'.

   --accept-regex=urlregex, --reject-regex=urlregex
       Specify a regular expression to accept or reject file names.

   --regex-type=regextype
       Specify the regular expression type.  Possible types are posix or pcre.  Note that  to  be
       able to use pcre type, wget2 has to be compiled with libpcre support.

   --filter-urls
       Apply the accept and reject filters on the URL before starting a download.

   -D domain-list, --domains=domain-list
       Set  domains to be followed.  domain-list is a comma-separated list of domains.  Note that
       it does not turn on -H.

   --exclude-domains=domain-list
       Specify the domains that are not to be followed.

   --follow-tags=list
       Wget2 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
       list with this option.

   --ignore-tags=list
       This  is  the  opposite  of  the  –follow-tags  option.   To  skip  certain HTML tags when
       recursively looking for documents to download, specify them in a comma-separated list.

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

                wget2 --ignore-tags=a,area -H -k -K -r https://<site>/<document>

       However,  the  author  of this option came across a page with tags like “” and came to the
       realization that specifying tags to ignore was not enough.  One can’t just tell  Wget2  to
       ignore  “”,  because  then  stylesheets  will  not  be  downloaded.   Now the best bet for
       downloading a single page and its requisites is the dedicated –page-requisites option.

   --ignore-case
       Ignore case when matching files and directories.  This influences the behavior of -R,  -A,
       -I,  and  -X options.  For example, with this option, -A "*.txt" will match file1.txt, but
       also file2.TXT, file3.TxT, and so on.  The quotes in the example are to prevent the  shell
       from expanding the pattern.

   -H, --span-hosts
       Enable spanning across hosts when doing recursive retrieving.

   -L, --relative
       Follow  relative  links  only.   Useful  for  retrieving  a specific home page without any
       distractions, not even those from the same hosts.

   -I list, --include-directories=list
       Specify a comma-separated list  of  directories  you  wish  to  follow  when  downloading.
       Elements of list may contain wildcards.

   -X list, --exclude-directories=list
       Specify a comma-separated list of directories you wish to exclude from download.  Elements
       of list may contain wildcards.

   -np, --no-parent
       Do not ever ascend to the parent directory when retrieving recursively.  This is a  useful
       option,  since  it  guarantees  that  only  the  files  below  a certain hierarchy will be
       downloaded.

   --filter-mime-type=list
       Specify a comma-separated list of MIME types that will be downloaded.   Elements  of  list
       may  contain  wildcards.   If  a  MIME  type  starts  with  the  character `!' it won’t be
       downloaded, this is useful  when  trying  to  download  something  with  exceptions.   For
       example, download everything except images:

                wget2 https://<site>/<document> --filter-mime-type=*,\!image/*

       It  is  also  useful  to  download  files  that are compatible with an application of your
       system.  For instance, download every file that is compatible with LibreOffice Writer from
       a website using the recursive mode:

                wget2 -r https://<site>/<document> --filter-mime-type=$(sed -r '/^MimeType=/!d;s/^MimeType=//;s/;/,/g' /usr/share/applications/libreoffice-writer.desktop)

   Plugin Options
   --list-plugins
       Print a list all available plugins and exit.

   --local-plugin=file
       Load file as plugin.

   --plugin=name
       Load a plugin with a given name from the configured plugin directories.

   --plugin-dirs=directories
       Set plugin directories.  directories is a comma-separated list of directories.

   --plugin-help
       Print the help messages from all loaded plugins.

   --plugin-opt=option
       Set a plugin specific command line option.

       option is in the format <plugin_name>.<option>[=value].

Environment

       Wget2  supports  proxies  for both HTTP and HTTPS retrievals.  The standard way to specify
       proxy location, which Wget recognizes, is using the following environment variables:

       http_proxy

       https_proxy

       If set, the http_proxy and https_proxy variables should contain the URLs  of  the  proxies
       for HTTP and HTTPS connections respectively.

       no_proxy

       This  variable should contain a comma-separated list of domain extensions proxy should not
       be used for.  For instance, if the value of no_proxy is .example.com, proxy  will  not  be
       used to retrieve documents from *.example.com.

Exit Status

       Wget2 may return one of several error codes if it encounters problems.

                0   No problems occurred.

                1   Generic error code.

                2   Parse error---for instance, when parsing command-line options, the .wgetrc or .netrc...

                3   File I/O error.

                4   Network failure.

                5   SSL verification failure.

                6   Username/password authentication failure.

                7   Protocol errors.

                8   Server issued an error response.

                9   Public key missing from keyring.

                10  A Signature verification failed.

       With the exceptions of 0 and 1, the lower-numbered exit codes take precedence over higher-
       numbered ones, when multiple types of errors are encountered.

Files

       /etc/wgetrc

       Default location of the global startup file.

       ~/.wgetrc

       User startup file.

Bugs

       You  are   welcome   to   submit   bug   reports   via   the   GNU   Wget2   bug   tracker
       (https://gitlab.com/gnuwget/wget2/issues).

       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 Wget2 crashes,
          it’s a bug.  If Wget2 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, but you might want to double-check the documentation and the mailing lists.

       2. Try to repeat the bug in as simple circumstances as possible.  E.g.  if  Wget2  crashes
          while downloading wget2 -rl0   -kKE -t5 --no-proxy https://example.com -o /tmp/log, 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 .wgetrc 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 .wgetrc moved out of the way.  Only if it  turns  out  that
       .wgetrc settings affect the bug, mail me the relevant parts of the file.

       3. Please  start  Wget2 with -d option and send us the resulting output (or relevant parts
          thereof).  If Wget2 was compiled without debug support, recompile it—it is much  easier
          to trace bugs with debug support on.

       Note:  please make sure to remove any potentially sensitive information from the debug log
       before sending it to the bug address.  The -d won’t go out of its way to collect sensitive
       information,   but   the  log  will  contain  a  fairly  complete  transcript  of  Wget2’s
       communication with the server, which may include passwords and pieces of downloaded  data.
       Since  the  bug  address  is  publically archived, you may assume that all bug reports are
       visible to the public.

       4. If Wget2 has crashed, try to run it in a debugger, e.g. gdb `which wget` core and  type
          “where”  to  get  the  backtrace.   This  may  not work if the system administrator has
          disabled core files, but it is safe to try.

See also

       This is not the complete manual for GNU Wget.  For more  complete  information,  including
       more  detailed explanations of some of the options, and a number of commands available for
       use with .wgetrc files and the -e option, see the GNU Info entry for wget.

Author

       Wget2 written by Tim Rühsen <tim.ruehsen@gmx.de>

       Wget 1.x originally written by Hrvoje Nikšić <hniksic@xemacs.org>

Copyright

       Copyright (C) 2012-2015 Tim Rühsen

       Copyright (C) 2015-2018 Free Software Foundation, Inc.

       Permission is granted to copy, distribute and/or modify this document under the  terms  of
       the GNU Free Documentation License, Version 1.3 or any later version published by the Free
       Software Foundation; with no Invariant Sections, 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”.