💾 Archived View for source.community › ckaznocha › gemini › blob › main › server.go captured on 2024-05-26 at 14:52:38. Gemini links have been rewritten to link to archived content
⬅️ Previous capture (2024-02-05)
-=-=-=-=-=-=-
.
,-. ,-. . . ,-. ,-. ,-. ,-. ,-. ,-,-. ,-,-. . . ,-. . |- . .
`-. | | | | | | |-' | | | | | | | | | | | | | | | | |
`-' `-' `-^ ' `-' `-' :: `-' `-' ' ' ' ' ' ' `-^ ' ' ' `' `-|
/|
`-'
git clone https://source.community/ckaznocha/gemini.git
View raw contents of /server.go (main)
────╮
1│ package gemini
2│
3│ import (
4│ "bufio"
5│ "context"
6│ "crypto/tls"
7│ "errors"
8│ "fmt"
9│ "math/rand"
10│ "net"
11│ "strings"
12│ "sync"
13│ "sync/atomic"
14│ "time"
15│ )
16│
17│ type serverContextKeyType struct{}
18│
19│ //nolint:gochecknoglobals // context keys need to be global.
20│ var serverContextKey = &serverContextKeyType{}
21│
22│ // ServerFromCtx extracts a server from a context if present. If a server is not
23│ // present on the context the returned bool will be false.
24│ func ServerFromCtx(ctx context.Context) (*Server, bool) {
25│ srv, ok := ctx.Value(serverContextKey).(*Server)
26│
27│ return srv, ok
28│ }
29│
30│ // Server serves network requests using the Gemini protocol.
31│ type Server struct {
32│ // Handler is a handler that is called each time a new network requests is
33│ // received. Unlike Go's net/http panics in handlers will not be recovered
34│ // automatically.
35│ Handler Handler
36│
37│ // LogHandler is an optional function that allows a custom logger to be
38│ // hooked into the server. Erroneous logs will be passed in with `isError`
39│ // set to true.
40│ LogHandler func(message string, isError bool)
41│
42│ // BaseContext is a optional function that takes a listener and returns a
43│ // context. The context returned by BaseContext will be used to create all
44│ // other contexts in the request lifecycle.
45│ BaseContext func(net.Listener) context.Context
46│
47│ // ConnContext is an optional function that takes a context and a net.Conn
48│ // and returns a context. Like BaseContext, the context returned by
49│ // ConnContext will be used to create all contexts in the request lifecycle
50│ // after the connection has been created.
51│ ConnContext func(ctx context.Context, c net.Conn) context.Context
52│
53│ // TLSConfig is the TLS config to use for the server.
54│ TLSConfig *tls.Config
55│
56│ listeners *listeners
57│ shutdownHooks *hooks
58│ inShutdown atomicBool
59│ }
60│
61│ type hooks struct {
62│ fns []func()
63│ mu sync.RWMutex
64│ }
65│
66│ func (h *hooks) register(fn func()) {
67│ h.mu.Lock()
68│ defer h.mu.Unlock()
69│
70│ h.fns = append(h.fns, fn)
71│ }
72│
73│ func (h *hooks) call() {
74│ var wg sync.WaitGroup
75│ for _, f := range h.fns {
76│ wg.Add(1)
77│
78│ go func(f func()) {
79│ defer wg.Done()
80│ f()
81│ }(f)
82│ }
83│
84│ wg.Wait()
85│ }
86│
87│ type atomicBool int32
88│
89│ func (b *atomicBool) isSet() bool { return atomic.LoadInt32((*int32)(b)) != 0 }
90│ func (b *atomicBool) set() { atomic.StoreInt32((*int32)(b), 1) }
91│
92│ func (s *Server) closeAndLogOnError(closeFn func() error) {
93│ if err := closeFn(); err != nil && s.LogHandler != nil {
94│ s.LogHandler(err.Error(), true)
95│ }
96│ }
97│
98│ // ListenAndServeTLS creates a listener and starts the server. If certFile and
99│ // keyFile are non-empty strings the key pair will be loaded and used.
100│ func (s *Server) ListenAndServeTLS(addr, certFile, keyFile string) error {
101│ if s.shuttingDown() {
102│ return fmt.Errorf("%w", ErrServerShutdown)
103│ }
104│
105│ if addr == "" {
106│ addr = ":1965"
107│ }
108│
109│ l, err := net.Listen("tcp", addr)
110│ if err != nil {
111│ return fmt.Errorf("%w: %s", ErrStartingServer, err)
112│ }
113│
114│ return s.ServeTLS(l, certFile, keyFile)
115│ }
116│
117│ // ServeTLS starts a server with the provided listener, wrapping it in a TLS
118│ // listener. If certFile and keyFile are non-empty strings the key pair will be
119│ // loaded and used.
120│ func (s *Server) ServeTLS(l net.Listener, certFile, keyFile string) error {
121│ if s.shuttingDown() {
122│ return fmt.Errorf("%w", ErrServerShutdown)
123│ }
124│
125│ var tlsConfig *tls.Config
126│ if s.TLSConfig == nil {
127│ tlsConfig = &tls.Config{
128│ MinVersion: tls.VersionTLS13,
129│ ClientAuth: tls.RequestClientCert,
130│ }
131│ } else {
132│ tlsConfig = s.TLSConfig.Clone()
133│ }
134│
135│ if tlsConfig.MinVersion < tls.VersionTLS12 {
136│ return fmt.Errorf("%w: unsupported TLS version %q", ErrStartingServer, tlsConfig.MinVersion)
137│ }
138│
139│ if tlsConfig.Certificates == nil && tlsConfig.GetCertificate == nil {
140│ cert, err := tls.LoadX509KeyPair(certFile, keyFile)
141│ if err != nil {
142│ return fmt.Errorf("%w: %s", ErrStartingServer, err)
143│ }
144│
145│ tlsConfig.Certificates = []tls.Certificate{cert}
146│ }
147│
148│ return s.Serve(tls.NewListener(l, tlsConfig))
149│ }
150│
151│ // Serve start a server using the provided listener. The listener should support
152│ // TLS.
153│ func (s *Server) Serve(l net.Listener) error {
154│ if s.shuttingDown() {
155│ return fmt.Errorf("%w", ErrServerShutdown)
156│ }
157│
158│ ln := &listener{inner: l}
159│ defer s.closeAndLogOnError(ln.Close)
160│
161│ if s.listeners == nil {
162│ s.listeners = &listeners{}
163│ }
164│
165│ s.listeners.add(ln)
166│ defer s.listeners.remove(ln)
167│
168│ baseCtx := context.Background()
169│ if s.BaseContext != nil {
170│ baseCtx = s.BaseContext(l)
171│ if baseCtx == nil {
172│ return fmt.Errorf("%w: BaseContext is nil", ErrStartingServer)
173│ }
174│ }
175│
176│ var tempDelay time.Duration // how long to sleep on accept failure
177│
178│ ctx := context.WithValue(baseCtx, serverContextKey, s)
179│
180│ for {
181│ rw, err := ln.Accept()
182│ if err != nil {
183│ if s.inShutdown.isSet() {
184│ return fmt.Errorf("%w", ErrServerShutdown)
185│ }
186│
187│ var ne net.Error
188│ if errors.As(err, &ne) && ne.Temporary() {
189│ if tempDelay == 0 {
190│ tempDelay = 5 * time.Millisecond
191│ } else {
192│ tempDelay *= 2
193│ }
194│
195│ if max := 1 * time.Second; tempDelay > max {
196│ tempDelay = max
197│ }
198│
199│ time.Sleep(tempDelay)
200│
201│ continue
202│ }
203│
204│ return fmt.Errorf("%w: %s", ErrServing, err)
205│ }
206│
207│ connCtx := ctx
208│
209│ if s.ConnContext != nil {
210│ connCtx = s.ConnContext(connCtx, rw)
211│ if connCtx == nil {
212│ return fmt.Errorf("%w: ConnContext is nil", ErrServing)
213│ }
214│ }
215│
216│ tempDelay = 0
217│
218│ go s.handle(connCtx, rw)
219│ }
220│ }
221│
222│ func (s *Server) handle(ctx context.Context, c *tls.Conn) {
223│ if s.LogHandler != nil {
224│ s.LogHandler(fmt.Sprintf("started processing request from %s", c.RemoteAddr()), false)
225│ defer s.LogHandler(fmt.Sprintf("finished processing request from %s", c.RemoteAddr()), false)
226│ }
227│
228│ if err := c.HandshakeContext(ctx); err != nil && s.LogHandler != nil {
229│ s.LogHandler(err.Error(), true)
230│ }
231│
232│ w := &response{conn: c}
233│
234│ defer s.closeAndLogOnError(c.Close)
235│ defer w.Failure(ctx, StatusNotFound, StatusNotFound.Description())
236│
237│ r, err := ReadRequest(bufio.NewReader(c))
238│ if err != nil {
239│ if s.LogHandler != nil {
240│ s.LogHandler(err.Error(), true)
241│ }
242│
243│ w.Failure(ctx, StatusBadRequest, err.Error())
244│
245│ return
246│ }
247│
248│ if !strings.EqualFold(r.URI.Host, c.ConnectionState().ServerName) {
249│ w.Failure(ctx, StatusProxyRequestRefused, StatusProxyRequestRefused.Description())
250│
251│ return
252│ }
253│
254│ if r.URI.url.Scheme != "gemini" {
255│ w.Failure(ctx, StatusProxyRequestRefused, StatusProxyRequestRefused.Description())
256│
257│ return
258│ }
259│
260│ if r.URI.Port != "" {
261│ _, port, err := net.SplitHostPort(c.LocalAddr().String())
262│ if err != nil {
263│ if s.LogHandler != nil {
264│ s.LogHandler(err.Error(), true)
265│ }
266│
267│ w.Failure(ctx, StatusServerFailure, err.Error())
268│
269│ return
270│ }
271│
272│ if r.URI.Port != port {
273│ w.Failure(ctx, StatusProxyRequestRefused, StatusProxyRequestRefused.Description())
274│
275│ return
276│ }
277│ }
278│
279│ r.RemoteAddr = c.RemoteAddr().String()
280│
281│ if connState := c.ConnectionState(); len(connState.PeerCertificates) > 0 {
282│ r.Subject = &connState.PeerCertificates[0].Subject
283│ }
284│
285│ if s.Handler != nil {
286│ s.Handler.ServeGemini(ctx, w, r)
287│ }
288│ }
289│
290│ func (s *Server) shuttingDown() bool {
291│ return s.inShutdown.isSet()
292│ }
293│
294│ // RegisterOnShutdown adds a function which will be called when the server shuts
295│ // down. RegisterOnShutdown can be called more than once to stack functions.
296│ func (s *Server) RegisterOnShutdown(f func()) {
297│ if s.shutdownHooks == nil {
298│ s.shutdownHooks = &hooks{}
299│ }
300│
301│ s.shutdownHooks.register(f)
302│ }
303│
304│ const shutdownPollIntervalMax = 500 * time.Millisecond
305│
306│ // Shutdown shuts the server down gracefully. The shutdown will stop waiting for
307│ // requests to finish if the context cancels.
308│ func (s *Server) Shutdown(ctx context.Context) error {
309│ s.inShutdown.set()
310│
311│ if s.shutdownHooks != nil {
312│ s.shutdownHooks.call()
313│ }
314│
315│ if s.listeners == nil {
316│ return nil
317│ }
318│
319│ err := s.listeners.close()
320│
321│ interval := pollInterval(time.Millisecond)
322│
323│ timer := time.NewTimer(interval.next())
324│ defer timer.Stop()
325│
326│ for {
327│ if s.listeners.len() == 0 {
328│ return err
329│ }
330│ select {
331│ case <-ctx.Done():
332│ return fmt.Errorf("%w: context done: %s", ErrServerShutdown, ctx.Err())
333│ case <-timer.C:
334│ timer.Reset(interval.next())
335│ }
336│ }
337│ }
338│
339│ type pollInterval time.Duration
340│
341│ func (p *pollInterval) next() time.Duration {
342│ const jitterPercent = 10
343│
344│ last := time.Duration(*p)
345│ interval := last + time.Duration(rand.Intn(int(last/jitterPercent))) //nolint:gosec // this does not need to be sercure.
346│ // Double and clamp for next time.
347│ last *= 2
348│ if last > shutdownPollIntervalMax {
349│ last = shutdownPollIntervalMax
350│ }
351│
352│ *p = pollInterval(last)
353│
354│ return interval
355│ }
────╯
· · ·
© 2024 source.community