rounds/gemini.go

   1 /*
   2 tofuproxy -- flexible HTTP/HTTPS proxy, TLS terminator, X.509 TOFU
   3              manager, WARC/geminispace browser
   4 Copyright (C) 2021 Sergey Matveev <stargrave@stargrave.org>
   5
   6 This program is free software: you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation, version 3 of the License.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 package rounds
  20
  21 import (
  22         "bufio"
  23         "bytes"
  24         "context"
  25         "fmt"
  26         "html"
  27         "io"
  28         "log"
  29         "net/http"
  30         "strconv"
  31         "strings"
  32
  33         "go.stargrave.org/tofuproxy/fifos"
  34         ttls "go.stargrave.org/tofuproxy/tls"
  35 )
  36
  37 const (
  38         ContentTypeGemini = "text/gemini"
  39         SchemeGemini      = "gemini://"
  40         GeminiEntrypoint  = "https://gemini"
  41         GeminiPort        = ":1965"
  42 )
  43
  44 var GemCodeName = map[int]string{
  45         10: "INPUT",
  46         11: "SENSITIVE INPUT",
  47         20: "SUCCESS",
  48         30: "REDIRECT - TEMPORARY",
  49         31: "REDIRECT - PERMANENT",
  50         40: "TEMPORARY FAILURE",
  51         41: "SERVER UNAVAILABLE",
  52         42: "CGI ERROR",
  53         43: "PROXY ERROR",
  54         44: "SLOW DOWN",
  55         50: "PERMANENT FAILURE",
  56         51: "NOT FOUND",
  57         52: "GONE",
  58         53: "PROXY REQUEST REFUSED",
  59         59: "BAD REQUEST",
  60         60: "CLIENT CERTIFICATE REQUIRED",
  61         61: "CERTIFICATE NOT AUTHORISED",
  62         62: "CERTIFICATE NOT VALID",
  63 }
  64
  65 func absolutizeURL(host, u string, paths ...string) string {
  66         host = strings.TrimSuffix(host, GeminiPort)
  67         if strings.Contains(u, "://") {
  68                 return u
  69         }
  70         if strings.HasPrefix(u, "/") {
  71                 return GeminiEntrypoint + "/" + host + u
  72         }
  73         paths = append([]string{GeminiEntrypoint, host}, paths...)
  74         paths = append(paths, u)
  75         return strings.Join(paths, "/")
  76 }
  77
  78 func geminifyURL(host, u string, paths ...string) string {
  79         u = absolutizeURL(host, u, paths...)
  80         if !strings.HasPrefix(u, SchemeGemini) {
  81                 return u
  82         }
  83         return GeminiEntrypoint + "/" + strings.TrimPrefix(u, SchemeGemini)
  84 }
  85
  86 func RoundGemini(
  87         host string,
  88         resp *http.Response,
  89         w http.ResponseWriter,
  90         req *http.Request,
  91 ) (bool, error) {
  92         if host != "gemini" {
  93                 return true, nil
  94         }
  95         paths := strings.Split(strings.TrimPrefix(req.URL.Path, "/"), "/")
  96         host, paths = paths[0], paths[1:]
  97         if host == "gemini:" {
  98                 http.Redirect(w, req, strings.Join(
  99                         append([]string{GeminiEntrypoint}, paths[1:]...), "/",
 100                 ), http.StatusTemporaryRedirect)
 101                 return false, nil
 102         }
 103         hostWithPort := host
 104         if !strings.Contains(hostWithPort, ":") {
 105                 hostWithPort += GeminiPort
 106         }
 107         conn, err := ttls.DialTLS(context.TODO(), "tcp", hostWithPort)
 108         if err != nil {
 109                 log.Printf("%s: can not dial: %+v\n", req.URL, err)
 110                 return false, err
 111         }
 112         query := fmt.Sprintf("%s%s/%s", SchemeGemini, host, strings.Join(paths, "/"))
 113         if req.URL.RawQuery != "" {
 114                 query += "?" + req.URL.RawQuery
 115         }
 116         if _, err = conn.Write([]byte(query + "\r\n")); err != nil {
 117                 log.Printf("%s: can not send request: %+v\n", req.URL, err)
 118                 return false, err
 119         }
 120         if len(paths) > 0 && paths[len(paths)-1] == "" {
 121                 paths = paths[:len(paths)-1]
 122         }
 123         br := bufio.NewReader(conn)
 124         rawResp, err := br.ReadString('\n')
 125         if err != nil {
 126                 log.Printf("%s: can not read response: %+v\n", req.URL, err)
 127                 return false, err
 128         }
 129         cols := strings.SplitN(rawResp, " ", 2)
 130         if len(cols) < 2 {
 131                 err = fmt.Errorf("invalid response format: %s", rawResp)
 132                 log.Printf("%s: %s\n", req.URL, err)
 133                 return false, err
 134         }
 135         code, err := strconv.Atoi(cols[0])
 136         if err != nil {
 137                 log.Printf("%s: can not parse response code: %+v\n", req.URL, err)
 138                 return false, err
 139         }
 140         codeName := GemCodeName[code]
 141         if codeName == "" {
 142                 codeName = "UNKNOWN"
 143         }
 144         if 10 <= code && code <= 19 {
 145                 w.Header().Add("Content-Type", "text/plain")
 146                 w.WriteHeader(http.StatusBadRequest)
 147                 fmt.Fprintf(w, "%s\n%d (%s): INPUT is not supported\n", cols[1], code, codeName)
 148                 return false, nil
 149         }
 150         if 30 <= code && code <= 39 {
 151                 w.Header().Add("Content-Type", "text/html")
 152                 w.WriteHeader(http.StatusOK)
 153                 u := geminifyURL(host, cols[1], paths...)
 154                 w.Write([]byte(
 155                         fmt.Sprintf(
 156                                 `<!DOCTYPE html>
 157 <html><head><title>%d (%s) redirection</title></head>
 158 <body>Redirection to <a href="%s">%s</a></body></html>`,
 159                                 code, codeName, u, u,
 160                         )))
 161                 fifos.LogRedir <- fmt.Sprintf(
 162                         "%s %s\t%d\t%s", req.Method, req.URL, code, cols[1],
 163                 )
 164                 return false, nil
 165         }
 166         if 40 <= code && code <= 49 {
 167                 w.Header().Add("Content-Type", "text/plain")
 168                 w.WriteHeader(http.StatusBadGateway)
 169                 fmt.Fprintf(w, "%s\n%d (%s)\n", cols[1], code, codeName)
 170                 return false, nil
 171         }
 172         if 50 <= code && code <= 59 {
 173                 w.Header().Add("Content-Type", "text/plain")
 174                 w.WriteHeader(http.StatusBadGateway)
 175                 fmt.Fprintf(w, "%s\n%d (%s)\n", cols[1], code, codeName)
 176                 return false, nil
 177         }
 178         if 60 <= code && code <= 69 {
 179                 w.Header().Add("Content-Type", "text/plain")
 180                 w.WriteHeader(http.StatusUnauthorized)
 181                 fmt.Fprintf(w, "%s\n%d (%s)\n", cols[1], code, codeName)
 182                 return false, nil
 183         }
 184         if !(20 <= code && code <= 29) {
 185                 err = fmt.Errorf("unknown response code: %d", code)
 186                 log.Printf("%s: %s\n", req.URL, err)
 187                 return false, err
 188         }
 189         contentType := strings.Split(strings.TrimRight(cols[1], "\r\n"), ";")[0]
 190         if contentType == ContentTypeGemini &&
 191                 !strings.Contains(req.Header.Get("Accept"), ContentTypeGemini) {
 192                 w.Header().Add("Content-Type", "text/html")
 193                 w.WriteHeader(http.StatusOK)
 194                 raw, err := io.ReadAll(br)
 195                 if err != nil {
 196                         log.Printf("%s: can not read response body: %+v\n", req.URL, err)
 197                         return false, err
 198                 }
 199                 var buf bytes.Buffer
 200                 fmt.Fprintf(&buf, `<!DOCTYPE html>
 201 <html><head><title>%d (%s)</title></head><body>
 202 `, code, codeName)
 203                 pre := false
 204                 for _, line := range strings.Split(string(raw), "\n") {
 205                         if strings.HasPrefix(line, "```") {
 206                                 if pre {
 207                                         buf.WriteString("</pre>\n")
 208                                 } else {
 209                                         buf.WriteString("<pre>" + line[3:] + "\n")
 210                                 }
 211                                 pre = !pre
 212                                 continue
 213                         }
 214                         if pre {
 215                                 fmt.Fprintf(&buf, "%s\n", line)
 216                                 continue
 217                         }
 218                         if strings.HasPrefix(line, "=> ") {
 219                                 cols = strings.Fields(line)
 220                                 u := geminifyURL(host, cols[1], paths...)
 221                                 switch len(cols) {
 222                                 case 2:
 223                                         fmt.Fprintf(
 224                                                 &buf, "<a href=\"%s\">%s</a><br/>\n",
 225                                                 u, html.EscapeString(cols[1]),
 226                                         )
 227                                 default:
 228                                         fmt.Fprintf(
 229                                                 &buf, "<a href=\"%s\">%s</a> (<tt>%s</tt>)<br/>\n",
 230                                                 u, html.EscapeString(strings.Join(cols[2:], " ")), cols[1],
 231                                         )
 232                                 }
 233                                 continue
 234                         }
 235                         if strings.HasPrefix(line, "# ") {
 236                                 fmt.Fprintf(&buf, "<h1>%s</h1>\n", html.EscapeString(line[2:]))
 237                                 continue
 238                         }
 239                         if strings.HasPrefix(line, "## ") {
 240                                 fmt.Fprintf(&buf, "<h2>%s</h2>\n", html.EscapeString(line[3:]))
 241                                 continue
 242                         }
 243                         if strings.HasPrefix(line, "### ") {
 244                                 fmt.Fprintf(&buf, "<h3>%s</h3>\n", html.EscapeString(line[4:]))
 245                                 continue
 246                         }
 247                         if strings.HasPrefix(line, "* ") {
 248                                 fmt.Fprintf(&buf, "&bullet; %s\n", html.EscapeString(line[2:]))
 249                                 continue
 250                         }
 251                         if strings.HasPrefix(line, "> ") {
 252                                 fmt.Fprintf(
 253                                         &buf, "<blockquote><tt>%s</tt></blockquote>\n",
 254                                         html.EscapeString(line[2:]),
 255                                 )
 256                                 continue
 257                         }
 258                         fmt.Fprintf(&buf, "%s<br/>\n", html.EscapeString(line))
 259                 }
 260                 buf.WriteString("</body></html>\n")
 261                 _, err = w.Write(buf.Bytes())
 262                 return false, err
 263         }
 264         w.Header().Add("Content-Type", contentType)
 265         w.WriteHeader(http.StatusOK)
 266         _, err = io.Copy(w, br)
 267         if err != nil {
 268                 log.Printf("%s: can not read response body: %+v\n", req.URL, err)
 269         }
 270         return false, err
 271 }