Package finger implements the finger-protocol, for the Go programming language.
I.e., generally, what is defined in:
- IETF RFC-742 — https://datatracker.ietf.org/doc/html/rfc742
- IETF RFC-1288 — https://datatracker.ietf.org/doc/html/rfc1288
Although this package add some modernizations that are compatible with IETF RFC-742, and in the spirt of the finger-protocol, that you can choose whether to use or not use.
Online documentation, which includes examples, can be found at: http://godoc.org/github.com/reiver/go-finger
This is an example of how to create very very very simple finger-protocol client using this package.
It is meant for educational purposes. A more useful finger-protocol client would include a lot more features. But anyway....
We first need to decide what the finger-protocol target will be.
What is a finger-protocol "target"‽
Well, for example, if we were to run the finger program as:
finger joeblow@example.com
Then out target would be:
"joeblow"
So, in our Go code we would have something like:
package main
import (
"github.com/reiver/go-finger"
)
func main() {
var target finger.Target = finger.CreateTarget("joeblow")
//@TODO
}
Now we need to put the target
inside of a finger-protocol request.
We do that with the following code:
package main
import (
"github.com/reiver/go-finger"
)
func main() {
var target finger.Target = finger.CreateTarget("joeblow")
var request finger.Request = finger.AssembleRequestTarget(target)
//@TODO
}
Next, we need to figure out what is the TCP-address of the finger-protocol server our finger-protocol client will connect to.
TCP-addresses (as a string) look something like:
"example.com:79"
"reiver.link:1971"
"181.70.250.13:1079"
"12.23.34.45:7979"
I.e., it is a 'host' and a TCP-port (with a colon ":" between them).
We are using the following as our reference example:
finger joeblow@example.com
So what is our "address"‽
It cannot be just this:
"example.com"
Since it doesn't include a TCP-port.
But, as it turns out, this package can handle this situation. When the TCP-port (in the address) is missing, it defaults it to the default finger-protocol TCP-port. (Which is TCP-port 79.)
So, now our code becomes:
package main
import (
"github.com/reiver/go-finger"
)
func main() {
var target finger.Target = finger.CreateTarget("joeblow")
var request finger.Request = finger.AssembleRequestTarget(target)
var address finger.Address = finger.CreateAddressHost("example.com")
//@TODO
}
Now we need to connect to the server.
We will do that using net.Dial()
.
So....
package main
import (
"github.com/reiver/go-finger"
"fmt"
"net"
)
func main() {
var target finger.Target = finger.CreateTarget("joeblow")
var request finger.Request = finger.AssembleRequestTarget(target)
var address finger.Address = finger.CreateAddressHost("example.com")
conn, err := net.Dial("tcp", address.Resolve())
if nil != err {
fmt.Println("ERROR:", err)
return
}
defer conn.Close()
//@TODO
}
And now we need to create client that will use this TCP connection to make a finger-protocol request.
So, this will create the client:
package main
import (
"github.com/reiver/go-finger"
"fmt"
"net"
)
func main() {
var target finger.Target = finger.CreateTarget("joeblow")
var request finger.Request = finger.AssembleRequestTarget(target)
var address finger.Address = finger.CreateAddressHost("example.com")
conn, err := net.Dial("tcp", address.Resolve())
if nil != err {
fmt.Println("ERROR:", err)
return
}
defer conn.Close()
var client finger.Client = finger.AssembleClient(conn)
//@TODO
}
And then this will send the finger-protocol request.
package main
import (
"github.com/reiver/go-finger"
"fmt"
"net"
)
func main() {
var target finger.Target = finger.CreateTarget("joeblow")
var request finger.Request = finger.AssembleRequestTarget(target)
var address finger.Address = finger.CreateAddressHost("example.com")
conn, err := net.Dial("tcp", address.Resolve())
if nil != err {
fmt.Println("ERROR:", err)
return
}
defer conn.Close()
var client finger.Client = finger.AssembleClient(conn)
responseReader, err := client.Do(request)
if nil != err {
fmt.Println("ERROR:", err)
return
}
//@TODO
}
And finally, this will send the finger-protocol response this program received from the finger-protocol server to STDOUT (so that we can see it):
package main
import (
"github.com/reiver/go-finger"
"fmt"
"io"
"net"
"os"
)
func main() {
var target finger.Target = finger.CreateTarget("joeblow")
var request finger.Request = finger.AssembleRequestTarget(target)
var address finger.Address = finger.CreateAddressHost("example.com")
conn, err := net.Dial("tcp", address.Resolve())
if nil != err {
fmt.Println("ERROR:", err)
return
}
defer conn.Close()
var client finger.Client = finger.AssembleClient(conn)
responseReader, err := client.Do(request)
if nil != err {
fmt.Println("ERROR:", err)
return
}
io.Copy(os.Stdout, responseReader)
}
This package supports Unicode UTF-8 text encoding for the finger-protocol.
The finger-protocol existed before any IETF RFC was written about it, but —
There are 2 IETF RFCs that are relavent for the finger-protocol:
- IETF RFC-742 (released in 1977) — https://datatracker.ietf.org/doc/html/rfc742
- IETF RFC-1288 (released in 1991) — https://datatracker.ietf.org/doc/html/rfc1288
IETF RFC-742 does not directly or indirectly forbid the use of Unicode UTF-8 — because IETF RFC-742 does not seem to explicitly specify what character-set should be used. IETF RFC-1288 indirectly forbids the use of Unicode UTF-8.
This package sides with the original IETF RFC-742, and supports Unicode UTF-8 text.
This package does this (supports the Unicode UTF-8 encoding of text) to provide a more modern implementation of the finger-protocol.
Someone in the future can write a new IETF RFC for the finger-protocol that gives permission to use the Unicode UTF-8 text encoding.
To import package finger use import code like the follownig:
import "github.com/reiver/go-finger"
To install package finger do the following:
GOPROXY=direct go get https://github.com/reiver/go-finger
Package finger was written by Charles Iliya Krempeaux