github.com/reiver/go-telnet (go): Package telnet provides TELNET and TELNETS client and server implementations in a style similar to the "net/http" library that is part of the Go standard library, including support for "middleware"; TELNETS is secure TELNET, with the TELNET protocol over a secured TLS (or SSL) connection.  ListenAndServe starts a (un-secure) TELNET server with a given address and handler.  ListenAndServeTLS starts a (secure) TELNETS server with a given address and handler, using the specified "cert.pem" and "key.pem" files.  Example TELNET Client:  DialToAndCall creates a (un-secure) TELNET client, which connects to a given address using the specified caller.  Example TELNETS Client:  DialToAndCallTLS creates a (secure) TELNETS client, which connects to a given address using the specified caller.  If you are communicating over the open Internet, you should be using (the secure) TELNETS protocol and ListenAndServeTLS.  If you are communicating just on localhost, then using just (the un-secure) TELNET protocol and telnet.ListenAndServe may be OK.  If you are not sure which to use, use TELNETS and ListenAndServeTLS.  The previous 2 exaple servers were very very simple. Specifically, they just echoed back whatever you submitted to it.  If you typed:  ... it would send back:  (Exactly the same data you sent it.)  A more useful TELNET server can be made using the "github.com/reiver/go-telnet/telsh" sub-package.  The `telsh` sub-package provides "middleware" that enables you to create a "shell" interface (also called a "command line interface" or "CLI") which most people would expect when using TELNET OR TELNETS.  For example:  Note that in the example, so far, we have registered 2 commands: `date` and `animate`.  For this to actually work, we need to have code for the `date` and `animate` commands.  The actual implemenation for the `date` command could be done like the following:  Note that your "real" work is in the `dateHandlerFunc` func.  And the actual implementation for the `animate` command could be done as follows:  Again, note that your "real" work is in the `animateHandlerFunc` func.  If you are using the telnet.ListenAndServeTLS func or the telnet.Server.ListenAndServeTLS method, you will need to supply "cert.pem" and "key.pem" files.  If you do not already have these files, the Go soure code contains a tool for generating these files for you.  It can be found at:  So, for example, if your `$GOROOT` is the "/usr/local/go" directory, then it would be at:  If you run the command:  ... then you get the help information for "generate_cert.go".  Of course, you would replace or set `$GOROOT` with whatever your path actually is. Again, for example, if your `$GOROOT` is the "/usr/local/go" directory, then it would be:  To demonstrate the usage of "generate_cert.go", you might run the following to generate certificates that were bound to the hosts `127.0.0.1` and `localhost`:  If you are not sure where "generate_cert.go" is on your computer, on Linux and Unix based systems, you might be able to find the file with the command:  (If it finds it, it should output the full path to this file.)  You can make a simple (un-secure) TELNET client with code like the following:  You can make a simple (secure) TELNETS client with code like the following:  The TELNET protocol is best known for providing a means of connecting to a remote computer, using a (text-based) shell interface, and being able to interact with it, (more or less) as if you were sitting at that computer.  (Shells are also known as command-line interfaces or CLIs.)  Although this was the original usage of the TELNET protocol, it can be (and is) used for other purposes as well.  The TELNET protocol came from an era in computing when text-based shell interface where the common way of interacting with computers.  The common interface for computers during this era was a keyboard and a monochromatic (i.e., single color) text-based monitors called "video terminals".  (The word "video" in that era of computing did not refer to things such as movies. But instead was meant to contrast it with paper. In particular, the teletype machines, which were typewriter like devices that had a keyboard, but instead of having a monitor had paper that was printed onto.)  In that era, in the early days of office computers, it was rare that an individual would have a computer at their desk. (A single computer was much too expensive.)  Instead, there would be a single central computer that everyone would share. The style of computer used (for the single central shared computer) was called a "mainframe".  What individuals would have at their desks, instead of their own compuer, would be some type of video terminal.  The different types of video terminals had named such as:  • VT52  • VT100  • VT220  • VT240  ("VT" in those named was short for "video terminal".)  To understand this era, we need to go back a bit in time to what came before it: teletypes.  Terminal codes (also sometimes called 'terminal control codes') are used to issue various kinds of commands to the terminal.  (Note that 'terminal control codes' are a completely separate concept for 'TELNET commands', and the two should NOT be conflated or confused.)  The most common types of 'terminal codes' are the 'ANSI escape codes'. (Although there are other types too.)  ANSI escape codes (also sometimes called 'ANSI escape sequences') are a common type of 'terminal code' used to do things such as:  • moving the cursor,  • erasing the display,  • erasing the line,  • setting the graphics mode,  • setting the foregroup color,  • setting the background color,  • setting the screen resolution, and  • setting keyboard strings.  One of the abilities of ANSI escape codes is to set the foreground color.  Here is a table showing codes for this:  (Note that in the `[]byte` that the first `byte` is the number `27` (which is the "escape" character) where the third and fouth characters are the **not** number literals, but instead character literals `'3'` and whatever.)  Another of the abilities of ANSI escape codes is to set the background color.  (Note that in the `[]byte` that the first `byte` is the number `27` (which is the "escape" character) where the third and fouth characters are the **not** number literals, but instead character literals `'4'` and whatever.)  In Go code, if I wanted to use an ANSI escape code to use a blue background, a white foreground, and bold, I could do that with the ANSI escape code:  Note that that start with byte value 27, which we have encoded as hexadecimal as \x1b. Followed by the '[' character.  Coming after that is the sub-string "44", which is the code that sets our background color to blue.  We follow that with the ';' character (which separates codes).  And the after that comes the sub-string "37", which is the code that set our foreground color to white.  After that, we follow with another ";" character (which, again, separates codes).  And then we follow it the sub-string "1", which is the code that makes things bold.  And finally, the ANSI escape sequence is finished off with the 'm' character.  To show this in a more complete example, our `dateHandlerFunc` from before could incorporate ANSI escape sequences as follows:  Note that in that example, in addition to using the ANSI escape sequence "\x1b[44;37;1m" to set the background color to blue, set the foreground color to white, and make it bold, we also used the ANSI escape sequence "\x1b[0m" to reset the background and foreground colors and boldness back to "normal".
Keywords: rfc-15|rfc-854|telnet|telnet-client|telnet-protocol|telnet-server|telnets