Initial commit
This commit is contained in:
adnano
commit
257b807675
100
README.md
Normal file
100
README.md
Normal file
@ -0,0 +1,100 @@
|
||||
# go-gemini
|
||||
|
||||
`go-gemini` implements the [Gemini protocol](https://gemini.circumlunar.space) in
|
||||
Go.
|
||||
|
||||
It aims to provide an interface similar to that of `net/http` to make it easy
|
||||
to develop Gemini clients and servers.
|
||||
|
||||
## Usage
|
||||
|
||||
First generate TLS keys for your server to use.
|
||||
|
||||
```sh
|
||||
openssl genrsa -out server.key 2048
|
||||
openssl ecparam -genkey -name secp384r1 -out server.key
|
||||
openssl req -new -x509 -sha256 -key server.key -out server.crt -days 3650
|
||||
```
|
||||
|
||||
Next, import and use `go-gemini`. Here is a simple server:
|
||||
|
||||
```go
|
||||
import (
|
||||
"git.sr.ht/~adnano/go-gemini"
|
||||
)
|
||||
|
||||
func main() {
|
||||
config := &tls.Config{}
|
||||
cert, err := tls.LoadX509KeyPair("server.crt", "server.key")
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
config.Certificates = append(config.Certificates, cert)
|
||||
|
||||
mux := &gemini.Mux{}
|
||||
mux.HandleFunc("/", func(url *url.URL) *gemini.Response {
|
||||
return &gemini.Response{
|
||||
Status: gemini.StatusSuccess,
|
||||
Meta: "text/gemini",
|
||||
Body: []byte("You requested " + url.String()),
|
||||
}
|
||||
})
|
||||
|
||||
server := gemini.Server{
|
||||
TLSConfig: config,
|
||||
Handler: mux,
|
||||
}
|
||||
server.ListenAndServe()
|
||||
}
|
||||
```
|
||||
|
||||
And a simple client:
|
||||
|
||||
```go
|
||||
import (
|
||||
"git.sr.ht/~adnano/go-gemini"
|
||||
)
|
||||
|
||||
var client gemini.Client
|
||||
|
||||
func makeRequest(url string) {
|
||||
resp, err := client.Get(url)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
fmt.Println("Status code:", resp.Status)
|
||||
fmt.Println("Meta:", resp.Meta)
|
||||
|
||||
switch resp.Status / 10 {
|
||||
case gemini.StatusClassInput:
|
||||
scanner := bufio.NewScanner(os.Stdin)
|
||||
fmt.Printf("%s: ", resp.Meta)
|
||||
scanner.Scan()
|
||||
query := scanner.Text()
|
||||
makeRequest(url + "?" + query)
|
||||
return
|
||||
case gemini.StatusClassSuccess:
|
||||
fmt.Print("Body:\n", string(resp.Body))
|
||||
case gemini.StatusClassRedirect:
|
||||
log.Print("Redirecting to ", resp.Meta)
|
||||
makeRequest(resp.Meta)
|
||||
return
|
||||
case gemini.StatusClassTemporaryFailure:
|
||||
log.Fatal("Temporary failure")
|
||||
case gemini.StatusClassPermanentFailure:
|
||||
log.Fatal("Permanent failure")
|
||||
case gemini.StatusClassClientCertificateRequired:
|
||||
log.Fatal("Client certificate required")
|
||||
default:
|
||||
log.Fatal("Protocol error: invalid status code")
|
||||
}
|
||||
}
|
||||
|
||||
func main() {
|
||||
if len(os.Args) < 2 {
|
||||
log.Fatalf("usage: %s gemini://...", os.Args[0])
|
||||
}
|
||||
makeRequest(os.Args[1])
|
||||
}
|
||||
```
|
||||
135
client.go
Normal file
135
client.go
Normal file
@ -0,0 +1,135 @@
|
||||
package gemini
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"crypto/tls"
|
||||
"errors"
|
||||
"io/ioutil"
|
||||
"net/url"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
var (
|
||||
ProtocolError = errors.New("Protocol error")
|
||||
)
|
||||
|
||||
// Client is a Gemini client.
|
||||
type Client struct {
|
||||
TLSConfig tls.Config
|
||||
}
|
||||
|
||||
func (c *Client) Get(url string) (*Response, error) {
|
||||
req, err := NewRequest(url)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return c.Do(req)
|
||||
}
|
||||
|
||||
func (c *Client) GetProxy(host, url string) (*Response, error) {
|
||||
req, err := NewProxyRequest(host, url)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return c.Do(req)
|
||||
}
|
||||
|
||||
// Request is a Gemini request.
|
||||
type Request struct {
|
||||
Host string // host or host:port
|
||||
URL *url.URL // The URL to request
|
||||
}
|
||||
|
||||
// NewRequest returns a new request. The host is inferred from the provided url.
|
||||
func NewRequest(rawurl string) (*Request, error) {
|
||||
u, err := url.Parse(rawurl)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Ignore UserInfo if present
|
||||
u.User = nil
|
||||
|
||||
return &Request{
|
||||
Host: u.Host,
|
||||
URL: u,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// NewProxyRequest makes a new request using the provided host.
|
||||
func NewProxyRequest(host, rawurl string) (*Request, error) {
|
||||
u, err := url.Parse(rawurl)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Ignore UserInfo if present
|
||||
u.User = nil
|
||||
|
||||
return &Request{
|
||||
Host: host,
|
||||
URL: u,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (c *Client) Do(req *Request) (*Response, error) {
|
||||
host := req.Host
|
||||
if strings.LastIndex(host, ":") == -1 {
|
||||
// The default port is 1965
|
||||
host += ":1965"
|
||||
}
|
||||
|
||||
config := &tls.Config{
|
||||
// Allow self-signed certificates
|
||||
// TODO: Trust on first use
|
||||
InsecureSkipVerify: true,
|
||||
}
|
||||
conn, err := tls.Dial("tcp", host, config)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer conn.Close()
|
||||
|
||||
// Write the request
|
||||
request := req.URL.String() + "\r\n"
|
||||
if _, err := conn.Write([]byte(request)); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Read the response header
|
||||
code := make([]byte, 2)
|
||||
if _, err := conn.Read(code); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
status, err := strconv.Atoi(string(code))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Read one space
|
||||
space := make([]byte, 1)
|
||||
if _, err := conn.Read(space); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if space[0] != ' ' {
|
||||
return nil, ProtocolError
|
||||
}
|
||||
|
||||
// Read the meta
|
||||
scanner := bufio.NewScanner(conn)
|
||||
scanner.Scan()
|
||||
meta := scanner.Text()
|
||||
|
||||
// Read the response body
|
||||
body, err := ioutil.ReadAll(conn)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return &Response{
|
||||
Status: status,
|
||||
Meta: meta,
|
||||
Body: body,
|
||||
}, nil
|
||||
}
|
||||
185
server.go
Normal file
185
server.go
Normal file
@ -0,0 +1,185 @@
|
||||
package gemini
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"crypto/tls"
|
||||
"io"
|
||||
"net"
|
||||
"net/url"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Status codes.
|
||||
const (
|
||||
StatusInput = 10
|
||||
StatusSensitiveInput = 11
|
||||
StatusSuccess = 20
|
||||
StatusRedirectTemporary = 30
|
||||
StatusRedirectPermanent = 31
|
||||
StatusTemporaryFailure = 40
|
||||
StatusServerUnavailable = 41
|
||||
StatusCGIError = 42
|
||||
StatusProxyError = 43
|
||||
StatusSlowDown = 44
|
||||
StatusPermanentFailure = 50
|
||||
StatusNotFound = 51
|
||||
StatusGone = 52
|
||||
StatusProxyRequestRefused = 53
|
||||
StatusBadRequest = 59
|
||||
StatusClientCertificateRequired = 60
|
||||
StatusCertificateNotAuthorised = 61
|
||||
StatusCertificateNotValid = 62
|
||||
)
|
||||
|
||||
// Status code categories.
|
||||
const (
|
||||
StatusClassInput = 1
|
||||
StatusClassSuccess = 2
|
||||
StatusClassRedirect = 3
|
||||
StatusClassTemporaryFailure = 4
|
||||
StatusClassPermanentFailure = 5
|
||||
StatusClassClientCertificateRequired = 6
|
||||
)
|
||||
|
||||
// Response is a Gemini response.
|
||||
type Response struct {
|
||||
Status int
|
||||
Meta string
|
||||
Body []byte
|
||||
}
|
||||
|
||||
// Write writes the Response to the provided io.Writer.
|
||||
func (r *Response) Write(w io.Writer) {
|
||||
header := strconv.Itoa(r.Status) + " " + r.Meta + "\r\n"
|
||||
w.Write([]byte(header))
|
||||
|
||||
// Only write response body on success
|
||||
if r.Status/10 == StatusClassSuccess {
|
||||
w.Write(r.Body)
|
||||
}
|
||||
}
|
||||
|
||||
// Server is a Gemini server.
|
||||
type Server struct {
|
||||
Addr string
|
||||
TLSConfig *tls.Config
|
||||
Handler Handler
|
||||
}
|
||||
|
||||
// ListenAndServer listens on the given address and serves.
|
||||
func (s *Server) ListenAndServe() error {
|
||||
addr := s.Addr
|
||||
if addr == "" {
|
||||
addr = ":1965"
|
||||
}
|
||||
|
||||
ln, err := net.Listen("tcp", addr)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer ln.Close()
|
||||
|
||||
tlsListener := tls.NewListener(ln, s.TLSConfig)
|
||||
return s.Serve(tlsListener)
|
||||
}
|
||||
|
||||
// Serve listens for requests on the provided listener.
|
||||
func (s *Server) Serve(ln net.Listener) error {
|
||||
for {
|
||||
rw, err := ln.Accept()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
req, err := readLine(rw)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
url, err := url.Parse(req)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
resp := s.Handler.Serve(url)
|
||||
resp.Write(rw)
|
||||
rw.Close()
|
||||
}
|
||||
}
|
||||
|
||||
// Handler handles a url with a response.
|
||||
type Handler interface {
|
||||
// Serve accepts a url, as that is the only information that the client
|
||||
// provides in a request.
|
||||
Serve(*url.URL) *Response
|
||||
}
|
||||
|
||||
// Mux is a Gemini request multiplexer.
|
||||
// It matches the URL of each incoming request against a list of registered
|
||||
// patterns and calls the handler for the pattern that most closesly matches
|
||||
// the URL.
|
||||
type Mux struct {
|
||||
entries []muxEntry
|
||||
}
|
||||
|
||||
type muxEntry struct {
|
||||
scheme string
|
||||
host string
|
||||
path string
|
||||
handler Handler
|
||||
}
|
||||
|
||||
func (m *Mux) match(url *url.URL) Handler {
|
||||
for _, e := range m.entries {
|
||||
if (e.scheme == "" || url.Scheme == e.scheme) &&
|
||||
(e.host == "" || url.Host == e.host) &&
|
||||
strings.HasPrefix(url.Path, e.path) {
|
||||
return e.handler
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *Mux) Handle(pattern string, handler Handler) {
|
||||
url, err := url.Parse(pattern)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
m.entries = append(m.entries, muxEntry{
|
||||
url.Scheme,
|
||||
url.Host,
|
||||
url.Path,
|
||||
handler,
|
||||
})
|
||||
}
|
||||
|
||||
func (m *Mux) HandleFunc(pattern string, handlerFunc func(url *url.URL) *Response) {
|
||||
handler := HandlerFunc(handlerFunc)
|
||||
m.Handle(pattern, handler)
|
||||
}
|
||||
|
||||
func (m *Mux) Serve(url *url.URL) *Response {
|
||||
h := m.match(url)
|
||||
if h == nil {
|
||||
return &Response{
|
||||
Status: StatusNotFound,
|
||||
Meta: "Not found",
|
||||
}
|
||||
}
|
||||
return h.Serve(url)
|
||||
}
|
||||
|
||||
type HandlerFunc func(url *url.URL) *Response
|
||||
|
||||
func (f HandlerFunc) Serve(url *url.URL) *Response {
|
||||
return f(url)
|
||||
}
|
||||
|
||||
// readLine reads a line.
|
||||
func readLine(r io.Reader) (string, error) {
|
||||
scanner := bufio.NewScanner(r)
|
||||
scanner.Scan()
|
||||
if err := scanner.Err(); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return scanner.Text(), nil
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user