neulab/tldr huggingface dataset:
--open (Show only open (or possibly open) ports) Sometimes you only care about ports you can actually connect to (open ones), and don't want results cluttered with closed, filtered, and closed|filtered ports. Output customization is normally done after the scan using tools such as grep, awk, and Perl, but this feature was added due to overwhelming requests. Specify --open to only see hosts with at least one open, open|filtered, or unfiltered port, and only see ports in those states. These three states are treated just as they normally are, which means that open|filtered and unfiltered may be condensed into counts if there are an overwhelming number of them.
Beginning with Nmap 7.40, the --open option implies
--defeat-rst-ratelimit, because that option only affects closed and filtered ports, which are hidden by --open.
--iflist (List interfaces and routes) Prints the interface list and system routes as detected by Nmap and quits. This is useful for debugging routing problems or device mischaracterization (such as Nmap treating a PPP connection as ethernet).
Miscellaneous output options
--append-output (Append to rather than clobber output files) When you specify a filename to an output format flag such as -oX or -oN, that file is overwritten by default. If you prefer to keep the existing content of the file and append the new results, specify the --append-output option. All output filenames specified in that Nmap execution will then be appended to rather than clobbered. This doesn't work well for XML (-oX) scan data as the resultant file generally won't parse properly until you fix it up by hand.
--resume filename (Resume aborted scan) Some extensive Nmap runs take a very long time—on the order of days. Such scans don't always run to completion. Restrictions may prevent Nmap from being run during working hours, the network could go down, the machine Nmap is running on might suffer a planned or unplanned reboot, or Nmap itself could crash. The administrator running Nmap could cancel it for any other reason as well, by pressing ctrl-C. Restarting the whole scan from the beginning may be undesirable. Fortunately, if scan output files were kept, the user can ask Nmap to resume scanning with the target it was working on when execution ceased. Simply specify the --resume option and pass the output file as its argument. No other arguments are permitted, as Nmap parses the output file to use the same ones specified previously. Simply call Nmap as nmap --resume logfilename. Nmap will append new results to the data files specified in the previous execution. Scans can be resumed from any of the 3 major output formats: Normal, Grepable, or XML
--noninteractive (Disable runtime interactions) At times, such as when running Nmap in a shell background, it might be undesirable for Nmap to monitor and respond to user keyboard input when running. (See the section called “RUNTIME INTERACTION” about how to control Nmap during a scan.) Use option --noninteractive to prevent Nmap taking control of the terminal.
--stylesheet path or URL (Set XSL stylesheet to transform XML output) Nmap ships with an XSL stylesheet named nmap.xsl for viewing or translating XML output to HTML.  The XML output includes an xml-stylesheet directive which points to nmap.xml where it was initially installed by Nmap. Run the XML file through an XSLT processor such as xsltproc[16] to produce an HTML file. Directly opening the XML file in a browser no longer works well because modern browsers limit the locations a stylesheet may be loaded from. If you wish to use a different stylesheet, specify it as the argument to --stylesheet. You must pass the full pathname or URL. One common invocation is --stylesheet https://nmap.org/svn/docs/nmap.xsl. This tells an XSLT processor to load the latest version of the stylesheet from Nmap.Org. The --webxml option does the same thing with less typing and memorization. Loading the XSL from Nmap.Org makes it easier to view results on a machine that doesn't have Nmap (and thus nmap.xsl) installed. So the URL is often more useful, but the local filesystem location of nmap.xsl is used by default for privacy reasons.
--webxml (Load stylesheet from Nmap.Org) This is a convenience option, nothing more than an alias for --stylesheet https://nmap.org/svn/docs/nmap.xsl.
--no-stylesheet (Omit XSL stylesheet declaration from XML) Specify this option to prevent Nmap from associating any XSL stylesheet with its XML output. The xml-stylesheet directive is omitted.
This section describes some important (and not-so-important) options that don't really fit anywhere else.
-6 (Enable IPv6 scanning) Nmap has IPv6 support for its most popular features. Ping scanning, port scanning, version detection, and the Nmap Scripting Engine all support IPv6. The command syntax is the same as usual except that you also add the -6 option. Of course, you must use IPv6 syntax if you specify an address rather than a hostname. An address might look like 3ffe:7501:4819:2000:210:f3ff:fe03:14d0, so hostnames are recommended. The output looks the same as usual, with the IPv6 address on the “interesting ports” line being the only IPv6 giveaway.
While IPv6 hasn't exactly taken the world by storm, it gets significant use in some (usually Asian) countries and most modern operating systems support it. To use Nmap with IPv6, both the source and target of your scan must be configured for IPv6. If your ISP (like most of them) does not allocate IPv6 addresses to you, free tunnel brokers are widely available and work fine with Nmap. I use the free IPv6 tunnel broker service at http://www.tunnelbroker.net. Other tunnel brokers are listed at Wikipedia[17]. 6to4 tunnels are another popular, free approach.
On Windows, raw-socket IPv6 scans are supported only on ethernet devices (not tunnels), and only on Windows Vista and later. Use the --unprivileged option in other situations.
-A (Aggressive scan options) This option enables additional advanced and aggressive options. Presently this enables OS detection (-O), version scanning (-sV), script scanning (-sC) and traceroute (--traceroute).  More features may be added in the future. The point is to enable a comprehensive set of scan options without people having to remember a large set of flags. However, because script scanning with the default set is considered intrusive, you should not use -A against target networks without permission. This option only enables features, and not timing options (such as -T4) or verbosity options (-v) that you might want as well. Options which require privileges (e.g. root access) such as OS detection and traceroute will only be enabled if those privileges are available.
--datadir directoryname (Specify custom Nmap data file location) Nmap obtains some special data at runtime in files named nmap-service-probes, nmap-services, nmap-protocols, nmap-rpc, nmap-mac-prefixes, and nmap-os-db. If the location of any of these files has been specified (using the --servicedb or --versiondb options), that location is used for that file. After that, Nmap searches these files in the directory specified with the --datadir option (if any). Any files not found there, are searched for in the directory specified by the NMAPDIR environment variable. Next comes ~/.nmap for real and effective UIDs; or on Windows, HOME\AppData\Roaming\nmap (where HOME is the user's home directory, like C:\Users\user). This is followed by the location of the nmap executable and the same location with ../share/nmap appended. Then a compiled-in location such as /usr/local/share/nmap or /usr/share/nmap.
--servicedb services file (Specify custom services file) Asks Nmap to use the specified services file rather than the nmap-services data file that comes with Nmap. Using this option also causes a fast scan (-F) to be used. See the description for --datadir for more information on Nmap's data files.
--versiondb service probes file (Specify custom service probes file) Asks Nmap to use the specified service probes file rather than the nmap-service-probes data file that comes with Nmap. See the description for --datadir for more information on Nmap's data files.
--send-eth (Use raw ethernet sending) Asks Nmap to send packets at the raw ethernet (data link) layer rather than the higher IP (network) layer. By default, Nmap chooses the one which is generally best for the platform it is running on. Raw sockets (IP layer) are generally most efficient for Unix machines, while ethernet frames are required for Windows operation since Microsoft disabled raw socket support. Nmap still uses raw IP packets on Unix despite this option when there is no other choice (such as non-ethernet connections).
--send-ip (Send at raw IP level) Asks Nmap to send packets via raw IP sockets rather than sending lower level ethernet frames. It is the complement to the --send-eth option discussed previously.
--privileged (Assume that the user is fully privileged) Tells Nmap to simply assume that it is privileged enough to perform raw socket sends, packet sniffing, and similar operations that usually require root privileges on Unix systems. By default Nmap quits if such operations are requested but geteuid is not zero. --privileged is useful with Linux kernel capabilities and similar systems that may be configured to allow unprivileged users to perform raw-packet scans. Be sure to provide this option flag before any flags for options that require privileges (SYN scan, OS detection, etc.). The NMAP_PRIVILEGED environment variable may be set as an equivalent alternative to --privileged.
--unprivileged (Assume that the user lacks raw socket privileges) This option is the opposite of --privileged. It tells Nmap to treat the user as lacking network raw socket and sniffing privileges. This is useful for testing, debugging, or when the raw network functionality of your operating system is somehow broken. The NMAP_UNPRIVILEGED environment variable may be set as an equivalent alternative to --unprivileged.
--release-memory (Release memory before quitting) This option is only useful for memory-leak debugging. It causes Nmap to release allocated memory just before it quits so that actual memory leaks are easier to spot. Normally Nmap skips this as the OS does this anyway upon process termination.
-V; --version (Print version number) Prints the Nmap version number and exits.
-h; --help (Print help summary page) Prints a short help screen with the most common command flags. Running Nmap without any arguments does the same thing.
During the execution of Nmap, all key presses are captured. This allows you to interact with the program without aborting and restarting it. Certain special keys will change options, while any other keys will print out a status message telling you about the scan. The convention is that lowercase letters increase the amount of printing, and uppercase letters decrease the printing. You may also press ‘?’ for help.
v / V Increase / decrease the verbosity level
d / D Increase / decrease the debugging Level
p / P Turn on / off packet tracing
? Print a runtime interaction help screen
Anything else Print out a status message like this:
Stats: 0:00:07 elapsed; 20 hosts completed (1 up), 1 undergoing Service Scan Service scan Timing: About 33.33% done; ETC: 20:57 (0:00:12 remaining)
Here are some Nmap usage examples, from the simple and routine to a little more complex and esoteric. Some actual IP addresses and domain names are used to make things more concrete. In their place you should substitute addresses/names from your own network. While I don't think port scanning other networks is or should be illegal, some network administrators don't appreciate unsolicited scanning of their networks and may complain. Getting permission first is the best approach.
For testing purposes, you have permission to scan the host scanme.nmap.org.  This permission only includes scanning via Nmap and not testing exploits or denial of service attacks. To conserve bandwidth, please do not initiate more than a dozen scans against that host per day. If this free scanning target service is abused, it will be taken down and Nmap will report Failed to resolve given hostname/IP: scanme.nmap.org. These permissions also apply to the hosts scanme2.nmap.org, scanme3.nmap.org, and so on, though those hosts do not currently exist.
nmap -v scanme.nmap.org
This option scans all reserved TCP ports on the machine scanme.nmap.org . The -v option enables verbose mode.
nmap -sS -O scanme.nmap.org/24
Launches a stealth SYN scan against each machine that is up out of the 256 IPs on the /24 sized network where Scanme resides. It also tries to determine what operating system is running on each host that is up and running. This requires root privileges because of the SYN scan and OS detection.
nmap -sV -p 22,53,110,143,4564 198.116.0-255.1-127
Launches host enumeration and a TCP scan at the first half of each of the 255 possible eight-bit subnets in the 198.116.0.0/16 address space. This tests whether the systems run SSH, DNS, POP3, or IMAP on their standard ports, or anything on port 4564. For any of these ports found open, version detection is used to determine what application is running.
nmap -v -iR 100000 -Pn -p 80
Asks Nmap to choose 100,000 hosts at random and scan them for web servers (port 80). Host enumeration is disabled with -Pn since first sending a couple probes to determine whether a host is up is wasteful when you are only probing one port on each target host anyway.
nmap -Pn -p80 -oX logs/pb-port80scan.xml -oG logs/pb-port80scan.gnmap 216.163.128.20/20
This scans 4096 IPs for any web servers (without pinging them) and saves the output in grepable and XML formats.
While this reference guide details all material Nmap options, it can't fully demonstrate how to apply those features to quickly solve real-world tasks. For that, we released Nmap Network Scanning: The Official Nmap Project Guide to Network Discovery and Security Scanning.  Topics include subverting firewalls and intrusion detection systems, optimizing Nmap performance, and automating common networking tasks with the Nmap Scripting Engine. Hints and instructions are provided for common Nmap tasks such as taking network inventory, penetration testing, detecting rogue wireless access points, and quashing network worm outbreaks. Examples and diagrams show actual communication on the wire. More than half of the book is available free online. See https://nmap.org/book for more information.
Like its author, Nmap isn't perfect. But you can help make it better by sending bug reports or even writing patches. If Nmap doesn't behave the way you expect, first upgrade to the latest version available from https://nmap.org. If the problem persists, do some research to determine whether it has already been discovered and addressed. Try searching for the problem or error message on Google since that aggregates so many forums. If nothing comes of this, create an Issue on our tracker (‐ http://issues.nmap.org) and/or mail a bug report to <dev@nmap.org>. If you subscribe to the nmap-dev list before posting, your message will bypass moderation and get through more quickly. Subscribe at https://nmap.org/mailman/listinfo/dev. Please include everything you have learned about the problem, as well as what version of Nmap you are using and what operating system version it is running on. Other suggestions for improving Nmap may be sent to the Nmap dev mailing list as well.
If you are able to write a patch improving Nmap or fixing a bug, that is even better! Instructions for submitting patches or git pull requests are available from https://github.com/nmap/nmap/blob/master/CONTRIBUTING.md
Particularly sensitive issues such as a security reports may be sent directly to Nmap's author Fyodor directly at <fyodor@nmap.org>. All other reports and comments should use the dev list or issue tracker instead because more people read, follow, and respond to those.
Gordon “Fyodor” Lyon <fyodor@nmap.org> wrote and released Nmap in 1997. Since then, hundreds of people have made valuable contributions, as detailed in the CHANGELOG file distributed with Nmap and also available from https://nmap.org/changelog.html. David Fifield and Daniel Miller deserve special recognition for their enormous multi-year contributions!
Nmap Copyright and Licensing The Nmap Security Scanner is (C) 1996–2020 Insecure.Com LLC ("The Nmap Project"). Nmap is also a registered trademark of the Nmap Project. It is published under the Nmap Public Source License[18]. This generally allows end users to download and use Nmap for free. It doesn't not allow Nmap to be used and redistributed within commercial software or hardware products (including appliances, virtual machines, and traditional applications). We fund the project by selling a special Nmap OEM Edition for this purpose, as described at https://nmap.org/oem. Hundreds of large and small software vendors have already purchased OEM licenses to embed Nmap technology such as host discovery, port scanning, OS detection, version detection, and the Nmap Scripting Engine within their products.
The Nmap Project has permission to redistribute Npcap, a packet capturing driver and library for the Microsoft Windows platform. Npcap is a separate work with it's own license rather than this Nmap license. Since the Npcap license does not permit redistribution without special permission, our Nmap Windows binary packages which contain Npcap may not be redistributed without special permission.
Even though the NPSL is based on GPLv2, it contains different provisions and is not directly compatible. It is incompatible with some other open source licenses as well. In some cases we can relicense portions of Nmap or grant special permissions to use it in other open source software. Please contact fyodor@nmap.org with any such requests. Similarly, we don't incorporate incompatible open source software into Nmap without special permission from the copyright holders.
If you have received a written license agreement or contract for Nmap stating terms other than these, you may choose to use and redistribute Nmap under those terms instead.
Creative Commons License for this Nmap Guide This Nmap Reference Guide is (C) 2005–2020 Insecure.Com LLC. It is hereby placed under version 3.0 of the Creative Commons Attribution License[19]. This allows you redistribute and modify the work as you desire, as long as you credit the original source. Alternatively, you may choose to treat this document as falling under the same license as Nmap itself (discussed previously).
Source Code Availability and Community Contributions Source is provided to this software because we believe users have a right to know exactly what a program is going to do before they run it. This also allows you to audit the software for security holes.
Source code also allows you to port Nmap to new platforms, fix bugs, and add new features. You are highly encouraged to submit your changes as Github Pull Requests (PR) or send them to <dev@nmap.org> for possible incorporation into the main distribution. By submitting such changes, it is assumed that you are offering the Nmap Project the unlimited, non-exclusive right to reuse, modify, and relicense the code. This is important because the inability to relicense code has caused devastating problems for other Free Software projects (such as KDE and NASM). We also sell commercial licenses to Nmap OEM[20]. If you wish to specify special license conditions of your contributions, just say so when you send them.
No Warranty This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
It should also be noted that Nmap has occasionally been known to crash poorly written applications, TCP/IP stacks, and even operating systems. While this is extremely rare, it is important to keep in mind.  Nmap should never be run against mission critical systems unless you are prepared to suffer downtime. We acknowledge here that Nmap may crash your systems or networks and we disclaim all liability for any damage or problems Nmap could cause.
Inappropriate Usage Because of the slight risk of crashes and because a few black hats like to use Nmap for reconnaissance prior to attacking systems, there are administrators who become upset and may complain when their system is scanned. Thus, it is often advisable to request permission before doing even a light scan of a network.
Nmap should never be installed with special privileges (e.g. suid root). That would open up a major security vulnerability as other users on the system (or attackers) could use it for privilege escalation.
Nmap is not designed, manufactured, or intended for use in hazardous environments requiring fail- safe performance where the failure of the software could lead directly to death, personal injury, or significant physical or environmental damage.
Third-Party Software and Funding Notices This product includes software developed by the Apache Software Foundation[21]. A modified version of the Libpcap portable packet capture library[22] is distributed along with Nmap. The Windows version of Nmap utilizes the Libpcap-derived Ncap library[23] instead. Regular expression support is provided by the PCRE library[24], which is open-source software, written by Philip Hazel.  Certain raw networking functions use the Libdnet[25] networking library, which was written by Dug Song.  A modified version is distributed with Nmap. Nmap can optionally link with the OpenSSL cryptography toolkit[26] for SSL version detection support. The Nmap Scripting Engine uses an embedded version of the Lua programming language[27].  The Liblinear linear classification library[28] is used for our IPv6 OS detection machine learning techniques[29].
All of the third-party software described in this paragraph is freely redistributable under BSD-style software licenses.
Binary packages for Windows and Mac OS X include support libraries necessary to run Zenmap and Ndiff with Python and PyGTK. (Unix platforms commonly make these libraries easy to install, so they are not part of the packages.) A listing of these support libraries and their licenses is included in the LICENSES files.
This software was supported in part through the Google Summer of Code[30] and the DARPA CINDER program[31] (DARPA-BAA-10-84).
United States Export Control Nmap only uses encryption when compiled with the optional OpenSSL support and linked with OpenSSL. When compiled without OpenSSL support, the Nmap Project believes that Nmap is not subject to U.S.  Export Administration Regulations (EAR)[32] export control. As such, there is no applicable ECCN (export control classification number) and exportation does not require any special license, permit, or other governmental authorization.
When compiled with OpenSSL support or distributed as source code, the Nmap Project believes that Nmap falls under U.S. ECCN 5D002[33] (“Information Security Software”). We distribute Nmap under the TSU exception for publicly available encryption software defined in EAR 740.13(e)[34].
1. Nmap Network Scanning: The Official Nmap Project Guide to Network Discovery and Security Scanning https://nmap.org/book/
2. RFC 1122 http://www.rfc-editor.org/rfc/rfc1122.txt
3. RFC 792 http://www.rfc-editor.org/rfc/rfc792.txt
4. RFC 950 http://www.rfc-editor.org/rfc/rfc950.txt
5. UDP http://www.rfc-editor.org/rfc/rfc768.txt
6. SCTP http://www.rfc-editor.org/rfc/rfc4960.txt
7. TCP RFC http://www.rfc-editor.org/rfc/rfc793.txt
8. RFC 959 http://www.rfc-editor.org/rfc/rfc959.txt
9. RFC 1323 http://www.rfc-editor.org/rfc/rfc1323.txt
10. Lua programming language http://lua.org
11. precedence http://www.lua.org/manual/5.1/manual.html#2.5.3
12. IP protocol http://www.rfc-editor.org/rfc/rfc791.txt
13. RFC 2960 http://www.rfc-editor.org/rfc/rfc2960.txt
14. Nmap::Scanner http://sourceforge.net/projects/nmap-scanner/
15. Nmap::Parser http://nmapparser.wordpress.com/
16. xsltproc http://xmlsoft.org/XSLT/
17. listed at Wikipedia http://en.wikipedia.org/wiki/List_of_IPv6_tunnel_brokers
18. Nmap Public Source License https://nmap.org/npsl
19. Creative Commons Attribution License http://creativecommons.org/licenses/by/3.0/
20. Nmap OEM https://nmap.org/oem
21. Apache Software Foundation https://www.apache.org
22. Libpcap portable packet capture library https://www.tcpdump.org
23. Ncap library https://npcap.org
24. PCRE library https://pcre.org
25. Libdnet http://libdnet.sourceforge.net
26. OpenSSL cryptography toolkit https://openssl.org
27. Lua programming language https://lua.org
28. Liblinear linear classification library https://www.csie.ntu.edu.tw/~cjlin/liblinear/
29. IPv6 OS detection machine learning techniques https://nmap.org/book/osdetect-guess.html#osdetect-guess-ipv6
30. Google Summer of Code https://nmap.org/soc/
31. DARPA CINDER program https://www.fbo.gov/index?s=opportunity&mode=form&id=585e02a51f77af5cb3c9e06b9cc82c48&tab=core&_cview=1
32. Export Administration Regulations (EAR) https://www.bis.doc.gov/index.php/regulations/export-administration-regulations-ear
33. 5D002 https://www.bis.doc.gov/index.php/documents/regulations-docs/federal-register-notices/federal-register-2014/951-ccl5-pt2/file
34. EAR 740.13(e) https://www.bis.doc.gov/index.php/documents/regulations-docs/2341-740-2/file
docker-images - List images
docker images [OPTIONS] [REPOSITORY[:TAG]]
Alias for docker image ls.
-a, --all[=false]      Show all images (default hides intermediate images)
--digests[=false]      Show digests
-h, --help[=false]      help for images
-q, --quiet[=false]      Only show image IDs
OBS(1)                             obs-studio                             OBS(1)
obs - OBS Studio
obs (OBS Studio) provides efficient recording and streaming of live video content. It supports live RTP streaming to various streaming sites.
Other features include:
• Encoding using H264 (x264) and AAC
• Unlimited number of scenes and sources
• File output to MP4 or FLV
• GPU-based game capture for high performance game streaming
• Bilinear or lanczos3 resampling
Note that OBS Studio requires an OpenGL 3.2 compatible video card.
SYNC(1)                           User Commands                          SYNC(1)
sync - Synchronize cached writes to persistent storage
sync [OPTION] [FILE]...
Synchronize cached writes to persistent storage
If one or more files are specified, sync only them, or their containing file systems.
-d, --data sync only file data, no unneeded metadata
-f, --file-system sync the file systems that contain the files
Persistence guarantees vary per system.  See the system calls below for more details.
Written by Jim Meyering and Giuseppe Scrivano.
fdatasync(2), fsync(2), sync(2), syncfs(2)
Full documentation <https://www.gnu.org/software/coreutils/sync> or available locally via: info '(coreutils) sync invocation'
LDCONFIG(8)                 Linux Programmer's Manual                LDCONFIG(8)
ldconfig - configure dynamic linker run-time bindings
/sbin/ldconfig [-nNvXV] [-f conf] [-C cache] [-r root] directory... /sbin/ldconfig -l [-v] library... /sbin/ldconfig -p
ldconfig creates the necessary links and cache to the most recent shared libraries found in the directories specified on the command line, in the file /etc/ld.so.conf, and in the trusted directories, /lib and /usr/lib (on some 64-bit architectures such as x86-64, /lib and /usr/lib are the trusted directories for 32-bit libraries, while /lib64 and /usr/lib64 are used for 64-bit libraries).
The cache is used by the run-time linker, ld.so or ld-linux.so.  ldconfig checks the header and filenames of the libraries it encounters when determining which versions should have their links updated.
ldconfig will attempt to deduce the type of ELF libraries (i.e., libc5 or libc6/glibc) based on what C libraries, if any, the library was linked against.
Some existing libraries do not contain enough information to allow the deduction of their type.  Therefore, the /etc/ld.so.conf file format allows the specification of an expected type.  This is used only for those ELF libraries which we can not work out.  The format is "dirname=TYPE", where TYPE can be libc4, libc5, or libc6.  (This syntax also works on the command line.)  Spaces are not allowed.  Also see the -p option.  ldconfig should normally be run by the superuser as it may require write permission on some root owned directories and files.
Note that ldconfig will only look at files that are named lib*.so* (for regular shared objects) or ld-*.so* (for the dynamic loader itself). Other files will be ignored.  Also, ldconfig expects a certain pattern to how the symlinks are set up, like this example, where the middle file (libfoo.so.1 here) is the SONAME for the library:
libfoo.so -> libfoo.so.1 -> libfoo.so.1.12
Failure to follow this pattern may result in compatibility issues after an upgrade.
-c fmt, --format=fmt (Since glibc 2.2) Cache format to use: old, new, or compat.  Since glibc 2.32, the default is new.  Before that, it was compat.
-C cache Use cache instead of /etc/ld.so.cache.
-f conf Use conf instead of /etc/ld.so.conf.
-i, --ignore-aux-cache (Since glibc 2.7) Ignore auxiliary cache file.
-l     (Since glibc 2.2) Library mode.  Manually link individual libraries.  Intended for use by experts only.
-n     Process only the directories specified on the command line.  Don't process the trusted directories, nor those specified in /etc/ld.so.conf.  Implies -N.
-N     Don't rebuild the cache.  Unless -X is also specified, links are still updated.
-p, --print-cache Print the lists of directories and candidate libraries stored in the current cache.
-r root Change to and use root as the root directory.
-v, --verbose Verbose mode.  Print current version number, the name of each directory as it is scanned, and any links that are created. Overrides quiet mode.
-X     Don't update links.  Unless -N is also specified, the cache is still rebuilt.
/lib/ld.so Run-time linker/loader. /etc/ld.so.conf File containing a list of directories, one per line, in which to search for libraries. /etc/ld.so.cache File containing an ordered list of libraries found in the directories specified in /etc/ld.so.conf, as well as those found in the trusted directories.
ldd(1), ld.so(8)
docker-service - Manage services
Manage services
-h, --help[=false]      help for service
docker(1), docker-service-create(1), docker-service-inspect(1), docker- service-logs(1), docker-service-ls(1), docker-service-ps(1), docker- service-rm(1), docker-service-rollback(1), docker-service-scale(1), docker-service-update(1)
TIME(1P)                    POSIX Programmer's Manual                   TIME(1P)
time — time a simple command
time [-p] utility [argument...]
The time utility shall invoke the utility named by the utility operand with arguments supplied as the argument operands and write a message to standard error that lists timing statistics for the utility. The message shall include the following information:
*  The elapsed (real) time between invocation of utility and its termination.
*  The User CPU time, equivalent to the sum of the tms_utime and tms_cutime fields returned by the times() function defined in the System Interfaces volume of POSIX.1‐2017 for the process in which utility is executed.
*  The System CPU time, equivalent to the sum of the tms_stime and tms_cstime fields returned by the times() function for the process in which utility is executed.
The precision of the timing shall be no less than the granularity defined for the size of the clock tick unit on the system, but the results shall be reported in terms of standard time units (for example, 0.02 seconds, 00:00:00.02, 1m33.75s, 365.21 seconds), not numbers of clock ticks.
When time is used as part of a pipeline, the times reported are unspecified, except when it is the sole command within a grouping command (see Section 2.9.4.1, Grouping Commands) in that pipeline. For example, the commands on the left are unspecified; those on the right report on utilities a and c, respectively:
time a | b | c    { time a; } | b | c a | b | time c    a | b | (time c)
The time utility shall conform to the Base Definitions volume of POSIX.1‐2017, Section 12.2, Utility Syntax Guidelines.
-p        Write the timing output to standard error in the format shown in the STDERR section.
The following environment variables shall affect the execution of time:
LC_MESSAGES Determine the locale that should be used to affect the format and contents of diagnostic and informative messages written to standard error.
LC_NUMERIC Determine the locale for numeric formatting.
PATH      Determine the search path that shall be used to locate the utility to be invoked; see the Base Definitions volume of POSIX.1‐2017, Chapter 8, Environment Variables.
If the utility utility is invoked, the standard error shall be used to write the timing statistics and may be used to write a diagnostic message if the utility terminates abnormally; otherwise, the standard error shall be used to write diagnostic messages and may also be used to write the timing statistics.
If -p is specified, the following format shall be used for the timing statistics in the POSIX locale:
"real %f\nuser %f\nsys %f\n", <real seconds>, <user seconds>, <system seconds>
where each floating-point number shall be expressed in seconds. The precision used may be less than the default six digits of %f, but shall be sufficiently precise to accommodate the size of the clock tick on the system (for example, if there were 60 clock ticks per second, at least two digits shall follow the radix character). The number of digits following the radix character shall be no less than one, even if this always results in a trailing zero. The implementation may append white space and additional information following the format shown here. The implementation may also prepend a single empty line before the format shown here.
If the utility utility is invoked, the exit status of time shall be the exit status of utility; otherwise, the time utility shall exit with one of the following values:
1‐125   An error occurred in the time utility.
It is frequently desirable to apply time to pipelines or lists of commands. This can be done by placing pipelines and command lists in a single file; this file can then be invoked as a utility, and the time applies to everything in the file.
Alternatively, the following command can be used to apply time to a complex command:
time sh -c 'complex-command-line'
When the time utility was originally proposed to be included in the ISO POSIX‐2:1993 standard, questions were raised about its suitability for inclusion on the grounds that it was not useful for conforming applications, specifically:
*  The underlying CPU definitions from the System Interfaces volume of POSIX.1‐2017 are vague, so the numeric output could not be compared accurately between systems or even between invocations.
*  The creation of portable benchmark programs was outside the scope this volume of POSIX.1‐2017.
However, time does fit in the scope of user portability. Human judgement can be applied to the analysis of the output, and it could be very useful in hands-on debugging of applications or in providing subjective measures of system performance. Hence it has been included in this volume of POSIX.1‐2017.
The default output format has been left unspecified because historical implementations differ greatly in their style of depicting this numeric output. The -p option was invented to provide scripts with a common means of obtaining this information.
In the KornShell, time is a shell reserved word that can be used to time an entire pipeline, rather than just a simple command. The POSIX definition has been worded to allow this implementation. Consideration was given to invalidating this approach because of the historical model from the C shell and System V shell. However, since the System V time utility historically has not produced accurate results in pipeline timing (because the constituent processes are not all owned by the same parent process, as allowed by POSIX), it did not seem worthwhile to break historical KornShell usage.
The term utility is used, rather than command, to highlight the fact that shell compound commands, pipelines, special built-ins, and so on, cannot be used directly.  However, utility includes user application programs and shell scripts, not just the standard utilities.
Chapter 2, Shell Command Language, sh
The System Interfaces volume of POSIX.1‐2017, times()
SHUTDOWN(8)                         shutdown                         SHUTDOWN(8)
shutdown - Halt, power-off or reboot the machine
shutdown [OPTIONS...] [TIME] [WALL...]
shutdown may be used to halt, power-off or reboot the machine.
The first argument may be a time string (which is usually "now"). Optionally, this may be followed by a wall message to be sent to all logged-in users before going down.
The time string may either be in the format "hh:mm" for hour/minutes specifying the time to execute the shutdown at, specified in 24h clock format. Alternatively it may be in the syntax "+m" referring to the specified number of minutes m from now.  "now" is an alias for "+0", i.e. for triggering an immediate shutdown. If no time argument is specified, "+1" is implied.
Note that to specify a wall message you must specify a time argument, too.
If the time argument is used, 5 minutes before the system goes down the /run/nologin file is created to ensure that further logins shall not be allowed.
-H, --halt Halt the machine.
-P, --poweroff Power-off the machine (the default).
-r, --reboot Reboot the machine.
-h Equivalent to --poweroff, unless --halt is specified.
-k Do not halt, power-off, reboot, just write wall message.
-c Cancel a pending shutdown. This may be used to cancel the effect of an invocation of shutdown with a time argument that is not "+0" or "now".
systemd(1), systemctl(1), halt(8), wall(1)
NIM(1)                            User Commands                           NIM(1)
nim - Nim Language Compiler
Nim Compiler Version 1.6.0 [Linux: amd64] Compiled at 2021-10-26 Copyright Â© 2006-2021 by Andreas Rumpf ::
nim command [options] [projectfile] [arguments]
Command: compile, c compile project with default code generator (C)
r      compile to $nimcache/projname, run with [arguments] using backend specified by `--backend` (default: c)
doc    generate the documentation for inputfile for backend specified by `--backend` (default: c)
Arguments: arguments are passed to the program being run (if --run option is selected)
-p, --path:PATH add path to search paths
-d, --define:SYMBOL(:VAL) define a conditional symbol (Optionally: Define the value for that symbol, see: "compile time define pragmas")
-u, --undef:SYMBOL undefine a conditional symbol
-f, --forceBuild:on|off force rebuilding of all modules
--stackTrace:on|off turn stack tracing on|off
--lineTrace:on|off turn line tracing on|off
--threads:on|off turn support for multi-threading on|off
-x, --checks:on|off turn all runtime checks on|off
-a, --assertions:on|off turn assertions on|off
--opt:none|speed|size optimize not at all or for speed|size Note: use -d:release for a release build!
--debugger:native Use native debugger (gdb)
--app:console|gui|lib|staticlib generate a console app|GUI app|DLL|static library
-r, --run run the compiled program with given arguments
--eval:cmd evaluates nim code directly; e.g.: `nim --eval:"echo 1"` defaults to `e` (nimscript) but customizable: `nim r --eval:'for a in stdin.lines: echo a'`
--fullhelp show all command line switches
-h, --help show this help
-v, --version show detailed version information
Note, single letter options that take an argument require a colon. E.g. -p:PATH.
HTTPING(1)                   General Commands Manual                  HTTPING(1)
httping - measure the latency and throughput of a webserver
httping [options]
options: [-g url] [-h hostname] [-p portnumber] [-x proxyhost:port] [-c count] [-i interval] [-t timeout] [-s] [-G] [-b] [-L xferlimit] [-X] [-l] [-z] [-f] [-m] [-o rc,...] [-e string] [-I useragent string] [-R referer string] [-r] [-n warn,crit] [-N mode] [-q] [-V]
The program httping lets you measure the latency of a webserver. Since version 1.0.6 also the throughput can be measured.
-5     The proxy server selected is a SOCKS5 server.
-6     Enable IPv6 mode. Default is IPv4.
-a     Audible ping
-b     Use this switch together with '-G'. When this option is used, the transferspeed (in KB/s) is shown.
-B     Use this switch together with '-G'. Ask the HTTP server to compress the returned data: this will reduce the influence of the bandwidth of your connection while increasing the influence of the processorpower of the HTTP server.
-c count How many probes to send before exiting.
-D     Do not draw graphs in ncurses mode (-K).
-e str When the status-code differs from the ones selected with '-o', the given string is displayed.
-E     Retrieve proxy settings from environment variables ('http_proxy' and 'https_proxy').
-F     Attempt TCP Fast Open while trying to connect to a server (for Linux, version 3.7 onwards of the kernel)
-f     Flood ping: do not sit idle between each ping but ping as fast as the computer and network allow you to.
-G     Do a GET request instead of a HEAD request: this means that also the complete page/file must be transferred. Note that in this case you're no longer measuring the latency!
-g url This selects the url to probe. E.g.: http://localhost/
-h hostname Instead of '-g' one can also set a hostname to probe with -h: -h localhost
-I str UserAgent-string to send to the webserver (instead of 'HTTPing <version>').
-i interval How many seconds to sleep between every probe sent.
-K     Enable ncurses user interface.
-L x   Use this switch together with '-G'. Limit the amount of data transferred to 'x'. Note that this only affects the content of the page/file and not the headerdata.
-l     Connect using SSL: for this to work you need to give a 'https'-url or a 443 portnumber.
-m     Show machine readable output (also check '-o' and '-e').
-N x   Switches HTTPing to Nagios-plugin mode 2: return 0 when everything is fine, 'x' when anything fails. E.g.: 1 => Nagios warning state, 2 => Nagios critical state.
-n warn,crit Switches HTTPing to Nagios-plugin mode 1: return exitcode '1' when the average response time is bigger then 'warn', return exitcode '2' when the the average response time is bigger then 'crit'. In all other cases return exitcode '0'.
-o x,x,... This selects the HTTP status-codes which are regarded as an OK- state (only with '-m').
-p portnumber -p can be used together with -h. -p selects the portnumber to probe.
-q     Be quiet, only return an exit-code.
-R str Referer-string to send to the webserver.
-Q     Use a persistent connection, i.e. reuse the same TCP connection for multiple HTTP requests. Usually possible when 'Connection: Keep-Alive' is sent by server. Adds a 'C' to the output if httping had to reconnect.
-r     Only resolve the hostname once: this takes the resolving out of the loop so that the latency of the DNS is not measured. Also useful when you want to measure only 1 webserver while the DNS returns a different ip-address for each resolve ('roundrobin').
-S     Split measured latency in time to connect and time to exchange a request with the HTTP server.
-s     When a successfull transaction was done, show the HTTP statuscode (200, 404, etc.).
-T x   Read the password for website authentication from file 'x' (instead of entering it on the command line).
-t timeout How long to wait for answer from the other side.
-U     Enable authentication against website. Set username with -U, set password with -P (or -T to read the password from a file).
-v     Increase verbosity mode. To show standard deviation and dates in output.
-W     Do not abort program if resolving fails.
-X     Use this switch together with '-G'. For each "ping" show the amount of data transferred (excluding the headers).
-x proxyhost[:port] Probe using a proxyserver. Note that you're also measuring the latency of the proxyserver!
-Y     Enable colors
-z     When connecting using SSL, display the fingerprint of the X509 certificate(s) of the peer.
--abbreviate Abbreviate values bigger than thousand, million, billion, etc.
--adaptive-interval or --ai (Try to) ping on the same interval. E.g. if interval is set to 1.0 seconds and ping a ping t[n] occurs at 500s with duration 250ms, then the next ping (t[n+1]) will happen at 501 seconds and not at 501.25 seconds. Of course when the ping duration is > bigger than the interval, a ping will be "skipped" (not literally: the sequence number will continue) and t[n+1] will then be e.g. 502s instead of the expected 501s. This is useful for example in the ncurses output mode where an fft is calculated over the ping times.
--aggregates x[,y[,z[,etc.]]] Show aggregates every x[/y[/z[/etc]]] seconds.
--divert-connect x Ignore the hostname in the URL and connect to 'x' instead. The given URL will be requested at 'x'.
--draw-phase Not only draw the magnitude of the fourier transform, draw the phase as well.
--graph-limit x If values measured are bigger than x, then they're limitted to x.
--header x Add an additional request-header 'x'.
--keep-cookies When the server sends a cookie, it will be returned in the next request.
--max-mtu x Maximum MTU to use. Cannot be larger than network interface MTU.
--no-host-header Do not put a "Host:"-header in the request header.
--no-tcp-nodelay Do not disable "tcp delay" (Naggle).
--priority x Set priority of packets.
--tos x Set type of service.
--proxy-user x Use username 'x' to authenticate against proxy (http/socks5) server (optional).
--proxy-password x Use password 'x' to authenticate against proxy (http/socks5) server (optional).
--proxy-password-file x Read password from file 'x' to authenticate against proxy (http/socks5) server (optional).
--recv-buffer x Set the size of the receive buffer (in bytes).
--slow-log x When the duration is x or more, show ping line in the slow log window (the middle window).
--threshold-red x If the measured threshold is higher than x (and -Y is given), then the shown value is colored red. If you also use --threshold-yellow, then this value must be bigger.
--threshold-yellow x If the measured threshold is higher than x (and -Y is given), then the shown value is colored yellow.
--threshold-show x If the measured threshold is higher than x, then the result is shown (default is show always). The value x is in ms.
--timestamp or --ts Put a timestamp before the result-lines. Use -v to also show a date.
--tx-buffer x Set the size of the transmit buffer (in bytes).
-V     Show the version and exit.
In split mode (-S) something like "time=0.08+24.09+23.17+15.64+0.02=62.98 ms" is shown. The first value is the time it took to resolve the hostname (or 'n/a' if it did not resolve in this iteration, e.g. in "resolve once" (-r) mode), then the time it took to connect (or -1 for example in persistent connection (-Q, HTTP v1.1), after that the time it took to put the request on the wire, then the time it took for the HTTP server to process the request and send it back and lastly the time it took to close the connection.
The graph in the ncurses uses colors to encode a meaning. Green: value is less than 1 block. Red: the value did not fit in the graph. Blue: the value was limitted by --graph-limit. Cyan: no measurement for that point in time.
Press <CTRL> + <c> to exit the program. It will display a summary of what was measured.  In the ncurses gui, press <CTRL> + <l> to forcibly redraw the screen. Press 'H' to halt the graphs (and again to continue). Press 'q' to stop the program (<CTRL> + <c> will work too).
httping -g http://localhost/ Ping the webserver on host 'localhost'.
httping -h localhost -p 1000 Ping the webserver on host 'localhost' and portnumber 1000.
httping -l -g https://localhost/ Ping the webserver on host 'localhost' using an SSL connection.
httping -g http://localhost/ -U username -P password Ping the webserver on host 'localhost' using the Basic HTTP Authentication.
None. This program is totally bug-free.
http://www.vanheusden.com/httping/
This page describes httping as found in the httping-2.3 package; other versions may differ slightly.  Please mail corrections and additions to mail@vanheusden.com.  Report bugs in the program to mail@vanheusden.com. Please consider sending bitcoins to 1N5Sn4jny4xVwTwSYLnf7WnFQEGoVRmTQF
E2FSCK(8)                    System Manager's Manual                   E2FSCK(8)
e2fsck - check a Linux ext2/ext3/ext4 file system
e2fsck [ -pacnyrdfkvtDFV ] [ -b superblock ] [ -B blocksize ] [ -l|-L bad_blocks_file ] [ -C fd ] [ -j external-journal ] [ -E extended_options ] [ -z undo_file ] device