single word versions: hostname, filename, webpage

badwords.txt

@@ -31,3 +31,6 @@ you'd:you would
 you'll:you will
 can't:cannot
 that's:that is
+web page:webpage
+host name\W:hostname
+file name\W:filename

cmdline/urls/fragment.md

@@ -1,7 +1,7 @@
 # Fragment
 
 URLs offer a fragment part. That is usually seen as a hash symbol (#) and a
-name for a specific name within a web page in browsers. An example of such a
+name for a specific name within a webpage in browsers. An example of such a
 URL might look like:
 
     https://www.example.com/info.html#the-plot

cmdline/urls/host.md

@@ -1,6 +1,6 @@
 # Host
 
-The host name part of the URL is, of course, simply a name that can be resolved
+The hostname part of the URL is, of course, simply a name that can be resolved
 to an numerical IP address, or the numerical address itself.
 
     curl http://example.com
@@ -15,7 +15,7 @@ brackets:
 
     curl http://[2a04:4e42::561]/
 
-When a host name is used, the converting of the name to an IP address is
+When a hostname is used, the converting of the name to an IP address is
 typically done using the system's resolver functions. That normally lets a
 sysadmin provide local name lookups in the `/etc/hosts` file (or equivalent).
 

cmdline/urls/path.md

@@ -1,7 +1,7 @@
 # Path
 
 Every URL contains a path. If there is none given, `/` is implied. For example
-when you use just the host name like in:
+when you use just the hostname like in:
 
     curl https://example.com
 

cmdline/urls/port.md

@@ -2,7 +2,7 @@
 
 Each protocol has a default port number that curl uses, unless a specified
 port number is given. The optional port number can be provided within the URL
-after the host name part, as a colon and the port number written in
+after the hostname part, as a colon and the port number written in
 decimal. For example, asking for an HTTP document on port 8080:
 
     curl http://example.com:8080/

cmdline/urls/scheme.md

@@ -26,7 +26,7 @@ hostnames that are okay to use are `localhost`, `127.0.0.1` or a blank
     file://127.0.0.1/path/to/file
     file:///path/to/file
 
-Inserting any other host name in there makes recent versions of curl return an
+Inserting any other hostname in there makes recent versions of curl return an
 error.
 
 Pay special attention to the third example above
@@ -43,11 +43,11 @@ incorrect format:
 
 As a convenience, curl also allows users to leave out the scheme part from
 URLs. Then it guesses which protocol to use based on the first part of the
-host name. That guessing is basic, as it just checks if the first part of the
-host name matches one of a set of protocols, and assumes you meant to use that
+hostname. That guessing is basic, as it just checks if the first part of the
+hostname matches one of a set of protocols, and assumes you meant to use that
 protocol. This heuristic is based on the fact that servers traditionally used
 to be named like that. The protocols that are detected this way are FTP, DICT,
-LDAP, IMAP, SMTP and POP3. Any other host name in a scheme-less URL makes curl
+LDAP, IMAP, SMTP and POP3. Any other hostname in a scheme-less URL makes curl
 default to HTTP.
 
 For example, this gets a file from an FTP site:

cmdline/urls/trurl.md

@@ -19,7 +19,7 @@ trurl.
 
 ## trurl example command lines
 
-**Replace the host name of a URL:**
+**Replace the hostname of a URL:**
 
     $ trurl --url https://curl.se --set host=example.com
     https://example.com/

http/altsvc.md

@@ -5,7 +5,7 @@ which lets a server tell a client that there is one or more *alternatives* for
 that server at "another place" with the use of the `Alt-Svc:` response header.
 
 The *alternatives* the server suggests can include a server running on another
-port on the same host, on another completely different host name and it can
+port on the same host, on another completely different hostname and it can
 even perhaps offer the service over another protocol.
 
 ## Enable

http/auth.md

@@ -15,7 +15,7 @@ an associated `Proxy-Authenticate:` header that lists all the authentication
 methods that the proxy supports.
 
 It might be worth to note that most websites of today do not require HTTP
-authentication for login etc, but they instead ask users to login on web pages
+authentication for login etc, but they instead ask users to login on webpages
 and then the browser issues a POST with the user and password etc, and then
 subsequently maintain cookies for the session.
 

http/basics.md

@@ -55,8 +55,8 @@ request to the server. Let's take an example URL:
  - **https** means that curl uses TLS to the remote port 443 (which is the
    default port number when no specified is used in the URL).
 
- - **www.example.com** is the host name that curl resolves to one or more IP
-   address to connect to. This host name is also used in the HTTP request in
+ - **www.example.com** is the hostname that curl resolves to one or more IP
+   address to connect to. This hostname is also used in the HTTP request in
    the `Host:` header.
 
  - **/path/to/file** is used in the HTTP request to tell the server which exact

http/hsts.md

@@ -3,14 +3,14 @@
 HTTP Strict Transport Security, HSTS, is a protocol mechanism that helps to
 protect HTTPS servers against man-in-the-middle attacks such as protocol
 downgrade attacks and cookie hijacking. It allows an HTTPS server to declare
-that clients should automatically interact with this host name using only
+that clients should automatically interact with this hostname using only
 HTTPS connections going forward - and explicitly not use clear text protocols
 with it.
 
 ## HSTS cache
 
 The HSTS status for a certain server name is set in a response header and has
-an expire time. The status for every HSTS host name needs to be saved
+an expire time. The status for every HSTS hostname needs to be saved
 in a file for curl to pick it up and to update the status and expire time.
 
 Invoke curl and tell it which file to use as a hsts cache:
@@ -22,7 +22,7 @@ so not when done over a clear text protocol.
 
 ## Use HSTS to update insecure protocols
 
-If the cache file now contains an entry for the given host name, it
+If the cache file now contains an entry for the given hostname, it
 automatically switches over to a secure protocol even if you try to connect to
 it with an insecure one:
 

http/modify/referer.md

@@ -1,6 +1,6 @@
 # Referer
 
-When a user clicks on a link on a web page and the browser takes the user away
+When a user clicks on a link on a webpage and the browser takes the user away
 to the next URL, it sends the new URL a `Referer:` header in the new request
 telling it where it came from. That is the referer header. The `Referer:` is
 misspelled but that is how it is supposed to be!

http/modify/target.md

@@ -25,7 +25,7 @@ look like this:
 ## --path-as-is
 
 The path part of the URL is the part that starts with the first slash after
-the host name and ends either at the end of the URL or at a '?' or '#'
+the hostname and ends either at the end of the URL or at a '?' or '#'
 (roughly speaking).
 
 If you include substrings including `/../` or `/./` in the path, curl

http/multipart.md

@@ -127,15 +127,15 @@ An example action looks like this:
 
     <form action="submit.cgi" method="post" enctype="multipart/form-data">
 
-If the form is found in a web page hosted on a URL like for example
+If the form is found in a webpage hosted on a URL like for example
 `https://example.com/user/login` the `action=submit.cgi` is a relative path
 within the same "directory" as the form itself. The full URL to submit this
 form thus becomes `https://example.com/user/submit.cgi`. That is the URL to
 use in the curl command line.
 
 Next, you must identify every `<input>` tag used within the form, including
 the ones that are marked as "hidden". Hidden just means that they are not
-shown in the web page, but they should still be sent in the POST.
+shown in the webpage, but they should still be sent in the POST.
 
 For every `<input>` in the form there should be a corresponding `-F` in the
 command line.

http/post/hiddenfields.md

@@ -8,7 +8,7 @@ curl fill in a web form in an automated fashion.
 
 If you want to submit a form with curl and make it look as if it has been done
 with a browser, it is important to provide all the input fields from the
-form. A common method for web pages is to set a few hidden input fields to the
+form. A common method for webpages is to set a few hidden input fields to the
 form and have them assigned values directly in the HTML. A successful form
 submission, of course, also includes those fields and in order to do that
 automatically you may be forced to first download the HTML page that holds the

http/postvspost.md

@@ -16,7 +16,7 @@ data correctly. A client cannot just pick a format of its own choice.
 
 When we are talking browsers and HTML, the standard way is to offer a form to
 the user that sends off data when the form has been filled in. The `<form>`
-tag is what makes one of those appear on the web page. The tag instructs the
+tag is what makes one of those appear on the webpage. The tag instructs the
 browser how to format its POST. If the form tag includes
 `enctype=multipart/form-data`, it tells the browser to send the data as a
 [multipart formpost](multipart.md) which you make with curl's `-F`

http/versions/http3.md

@@ -22,7 +22,7 @@ definition always encrypted and secure. Therefore, curl only uses HTTP/3 for
 ## Enable
 
 As a shortcut straight to HTTP/3, to make curl attempt a QUIC connect directly
-to the given host name and port number, use `--http3`. Like this:
+to the given hostname and port number, use `--http3`. Like this:
 
     curl --http3 https://example.com/
 

internals/caches.md

@@ -8,7 +8,7 @@ on which libcurl API is used, easy or multi.
 
 ## DNS cache
 
-When libcurl resolves the IP addresses of a host name it stores the result in
+When libcurl resolves the IP addresses of a hostname it stores the result in
 its DNS cache (with a default life-time of 60 seconds), so that subsequent
 lookups can use the cached data immediately instead of doing the (potentially
 slow) resolve operation again. This cache exists in memory only.
@@ -40,10 +40,10 @@ amount. This cache exists in memory only. Added in 7.87.0.
 ## HSTS
 
 HSTS is HTTP Strict Transport Security. HTTPS servers can inform clients that
-they want the client to connect to its host name using only HTTPS going
-forward and not HTTP, even when `HTTP://` URLs are used. curl keeps this
-connection upgrade information in memory and can be told to load it from and
-save it to disk as well.
+they want the client to connect to its hostname using only HTTPS going forward
+and not HTTP, even when `HTTP://` URLs are used. curl keeps this connection
+upgrade information in memory and can be told to load it from and save it to
+disk as well.
 
 ## Alt-Svc
 

internals/memory-debugging.md

@@ -56,7 +56,7 @@ Add a line in your application code:
     curl_dbg_memdebug("dump");
 
 This makes the malloc debug system output a full trace of all resources using
-functions to the given file name. Make sure you rebuild your program and that
+functions to the given filename. Make sure you rebuild your program and that
 you link with the same libcurl you built for this purpose as described above.
 
 ### Run Your Application

internals/tests/debug.md

@@ -33,6 +33,6 @@ This is a poor-man's version of valgrind but does not at all compare with its
 features. It is however fairly portable and low-impact.
 
 In a debug build, the memdebug system is enabled by curl if the
-`CURL_MEMDEBUG` environment variable is set to a file name, which is used for
-the log. The test suite sets this variable for us (see `tests/log/memdump`) and
-verifies it after each test run, if present.
+`CURL_MEMDEBUG` environment variable is set to a filename, which is used for
+the log. The test suite sets this variable for us (see `tests/log/memdump`)
+and verifies it after each test run, if present.

libcurl-http/alt-svc.md

@@ -5,7 +5,7 @@ the client that there is one or more *alternatives* for that server at
 "another place" with the use of the `Alt-Svc:` response header.
 
 The *alternatives* the server suggests can include a server running on another
-port on the same host, on another completely different host name and it can
+port on the same host, on another completely different hostname and it can
 also offer the service *over another protocol*.
 
 ## Enable

libcurl-http/hsts.md

@@ -9,7 +9,7 @@ Here is how you use HSTS with libcurl.
 ## In-memory cache
 
 libcurl primarily features an in-memory cache for HSTS hosts, so that
-subsequent HTTP-only requests to a host name present in the cache gets
+subsequent HTTP-only requests to a hostname present in the cache gets
 internally "redirected" to the HTTPS version. Assuming you have this feature
 enabled.
 

libcurl-http/multiplexing.md

@@ -11,7 +11,7 @@ libcurl supports HTTP multiplexing for both HTTP/2 and HTTP/3.
 
 Make sure you do multiple transfers using the multi interface to a server that
 supports HTTP multiplexing. libcurl can only multiplex transfers when the same
-host name is used for subsequent transfers.
+hostname is used for subsequent transfers.
 
 For all practical purposes and API behaviors, an application does not have
 to care about if multiplexing is done or not.

libcurl/caches.md

@@ -13,12 +13,12 @@ You can instruct libcurl to share some of the caches with the
 
 ## DNS cache
 
-When libcurl resolves a host name to one or more IP addresses, that is stored
+When libcurl resolves a hostname to one or more IP addresses, that is stored
 in the DNS cache so that subsequent transfers in the near term do not have to
 redo the same resolve again. A name resolve can easily take several hundred
 milliseconds and sometimes even much longer.
 
-By default, each such host name is stored in the cache for 60 seconds
+By default, each such hostname is stored in the cache for 60 seconds
 (changeable with `CURLOPT_DNS_CACHE_TIMEOUT`).
 
 libcurl does in fact not usually know what the TTL (Time To Live) value is for
@@ -41,9 +41,9 @@ Connections are only reused if the name is identical. Even if two different
 host names resolve to the same IP addresses, they still always use two
 separate connections with libcurl.
 
-Since the connection reuse is based on the host name and the DNS resolve phase
+Since the connection reuse is based on the hostname and the DNS resolve phase
 is entirely skipped when a connection is reused for a transfer, libcurl does
-not know the current state of the host name in DNS as it can in fact change IP
+not know the current state of the hostname in DNS as it can in fact change IP
 over time while the connection might survive and continue to get reused over
 the original IP address.
 

libcurl/conn/names.md

@@ -9,9 +9,9 @@ libcurl tries hard to [re-use an existing connection](reuse.md) rather than to
 create a new one. The function that checks for an existing connection to use
 is based purely on the name and is performed before any name resolving is
 attempted. That is one of the reasons the re-use is so much faster. A transfer
-using a reused connection does not resolve the host name again.
+using a reused connection does not resolve the hostname again.
 
-If no connection can be reused, libcurl resolves the host name to the set of
+If no connection can be reused, libcurl resolves the hostname to the set of
 addresses it resolves to. Typically this means asking for both IPv4 and IPv6
 addresses and there may be a whole set of those returned to libcurl. That set
 of addresses is then tried until one works, or it returns failure.
@@ -77,7 +77,7 @@ would suggest.
 With the help of the
 [CURLOPT_RESOLVE](https://curl.se/libcurl/c/CURLOPT_RESOLVE.html) option,
 an application can pre-populate libcurl's DNS cache with a custom address for
-a given host name and port number.
+a given hostname and port number.
 
 To make libcurl connect to 127.0.0.1 when example.com on port 443 is
 requested, an application can do:

libcurl/conn/proxies.md

@@ -24,7 +24,7 @@ specifically, it supports both SOCKS4 and SOCKS5 with or without remote name
 lookup, as well as both HTTP and HTTPS to the local proxy.
 
 The easiest way to specify which kind of proxy you are talking to is to set
-the scheme part of the proxy host name string (`CURLOPT_PROXY`) to match it:
+the scheme part of the proxy hostname string (`CURLOPT_PROXY`) to match it:
 
     socks4://proxy.example.com:12345/
     socks4a://proxy.example.com:12345/
@@ -47,14 +47,14 @@ the scheme part of the proxy host name string (`CURLOPT_PROXY`) to match it:
 names.
 
 You can also opt to set the type of the proxy with a separate option if you
-prefer to only set the host name, using `CURLOPT_PROXYTYPE`. Similarly, you
+prefer to only set the hostname, using `CURLOPT_PROXYTYPE`. Similarly, you
 can set the proxy port number to use with `CURLOPT_PROXYPORT`.
 
 ## Local or proxy name lookup
 
 In a section above you can see that different proxy setups allow the name
 resolving to be done by different parties involved in the transfer. You can in
-several cases either have the client resolve the server host name and pass on
+several cases either have the client resolve the server hostname and pass on
 the IP address to the proxy to connect to - which of course assumes that the
 name lookup works accurately on the client system - or you can hand
 over the name to the proxy to have the proxy resolve the name; converting it to
@@ -80,7 +80,7 @@ named environment variables before it performs its transfer to see if a proxy
 is requested to get used.
 
 You can specify the proxy by setting a variable named `[scheme]_proxy` to hold
-the proxy host name (the same way you would specify the host with `-x`). If
+the proxy hostname (the same way you would specify the host with `-x`). If
 you want to tell curl to use a proxy when accessing an HTTP server, you set
 the `http_proxy` environment variable. Like this:
 

libcurl/conn/reuse.md

@@ -11,7 +11,7 @@ When libcurl is about to make a new connection for the purposes of doing a
 transfer, it first checks to see if there is an existing connection in the
 pool that it can reuse instead. The connection re-use check is done before any
 DNS or other name resolving mechanism is used, so it is purely host name
-based. If there is an existing live connection to the right host name, a lot
+based. If there is an existing live connection to the right hostname, a lot
 of other properties (port number, protocol, etc) are also checked to see that
 it can be used.
 

libcurl/options/all.md

@@ -53,7 +53,7 @@ This is a table of available options for `curl_easy_setopt()`.
 | `CURLOPT_DNS_SERVERS`                | DNS servers to use                                                     |
 | `CURLOPT_DNS_SHUFFLE_ADDRESSES`      | shuffle IP addresses for hostname                                      |
 | `CURLOPT_DNS_USE_GLOBAL_CACHE`       | global DNS cache                                                       |
-| `CURLOPT_DOH_SSL_VERIFYHOST`         | verify the host name in the DoH SSL certificate                        |
+| `CURLOPT_DOH_SSL_VERIFYHOST`         | verify the hostname in the DoH SSL certificate                        |
 | `CURLOPT_DOH_SSL_VERIFYPEER`         | verify the DoH SSL certificate                                         |
 | `CURLOPT_DOH_SSL_VERIFYSTATUS`       | verify the DoH SSL certificate's status                                |
 | `CURLOPT_DOH_URL`                    | provide the DNS-over-HTTPS URL                                         |
@@ -210,7 +210,7 @@ This is a table of available options for `curl_easy_setopt()`.
 | `CURLOPT_REDIR_PROTOCOLS`            | protocols allowed to redirect to                                       |
 | `CURLOPT_REFERER`                    | the HTTP referer header                                                |
 | `CURLOPT_REQUEST_TARGET`             | alternative target for this request                                    |
-| `CURLOPT_RESOLVE`                    | provide custom host name to IP address resolves                        |
+| `CURLOPT_RESOLVE`                    | provide custom hostname to IP address resolves                        |
 | `CURLOPT_RESOLVER_START_DATA`        | pointer passed to the resolver start callback                          |
 | `CURLOPT_RESOLVER_START_FUNCTION`    | callback called before a new name resolve is started                   |
 | `CURLOPT_RESUME_FROM_LARGE`          | offset to resume transfer from                                         |

libcurl/threading.md

@@ -4,4 +4,4 @@ libcurl is thread safe but has no internal thread synchronization. You may have
 to provide your own locking or change options to properly use libcurl threaded.
 Exactly what is required depends on how libcurl was built. Please refer to the
 [libcurl thread safety](https://curl.se/libcurl/c/threadsafe.html)
-web page, which contains the latest information.
+webpage, which contains the latest information.