cmd/sgblog/http.go

   1 /*
   2 SGBlog -- Git-backed CGI/UCSPI blogging/phlogging/gemlogging engine
   3 Copyright (C) 2020-2023 Sergey Matveev <stargrave@stargrave.org>
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU Affero General Public License as
   7 published by the Free Software Foundation, version 3 of the License.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU Affero General Public License
  15 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 package main
  19
  20 import (
  21         "bytes"
  22         "compress/gzip"
  23         "crypto/sha1"
  24         _ "embed"
  25         "encoding/hex"
  26         "encoding/xml"
  27         "errors"
  28         "fmt"
  29         "hash"
  30         "html"
  31         "io"
  32         "log"
  33         "net/http"
  34         "net/url"
  35         "os"
  36         "strconv"
  37         "strings"
  38         "text/template"
  39         "time"
  40
  41         "github.com/go-git/go-git/v5"
  42         "github.com/go-git/go-git/v5/plumbing"
  43         "github.com/go-git/go-git/v5/plumbing/object"
  44         "github.com/vorlif/spreak"
  45         "go.stargrave.org/sgblog"
  46         "go.stargrave.org/sgblog/cmd/sgblog/atom"
  47         "lukechampine.com/blake3"
  48 )
  49
  50 const (
  51         AtomPostsFeed    = "feed.atom"
  52         AtomCommentsFeed = "comments.atom"
  53 )
  54
  55 var (
  56         renderableSchemes = map[string]struct{}{
  57                 "finger": {},
  58                 "ftp":    {},
  59                 "gemini": {},
  60                 "gopher": {},
  61                 "http":   {},
  62                 "https":  {},
  63                 "irc":    {},
  64                 "ircs":   {},
  65                 "news":   {},
  66                 "telnet": {},
  67         }
  68
  69         //go:embed http-index.tmpl
  70         TmplHTMLIndexRaw string
  71         TmplHTMLIndex    = template.Must(template.New("http-index").Parse(TmplHTMLIndexRaw))
  72
  73         //go:embed http-entry.tmpl
  74         TmplHTMLEntryRaw string
  75         TmplHTMLEntry    = template.Must(template.New("http-entry").Funcs(
  76                 template.FuncMap{"lineURLize": lineURLizeInTemplate},
  77         ).Parse(TmplHTMLEntryRaw))
  78 )
  79
  80 type TableEntry struct {
  81         Commit      *object.Commit
  82         CommentsRaw []byte
  83         TopicsRaw   []byte
  84         Num         int
  85         Title       string
  86         LinesNum    int
  87         CommentsNum int
  88         DomainURLs  []string
  89         Topics      []string
  90 }
  91
  92 type CommentEntry struct {
  93         HeaderLines []string
  94         BodyLines   []string
  95 }
  96
  97 func makeA(href, text string) string {
  98         return `<a href="` + href + `">` + text + `</a>`
  99 }
 100
 101 func etagString(etag hash.Hash) string {
 102         return `"` + hex.EncodeToString(etag.Sum(nil)) + `"`
 103 }
 104
 105 func urlParse(what string) *url.URL {
 106         if u, err := url.ParseRequestURI(what); err == nil {
 107                 if _, exists := renderableSchemes[u.Scheme]; exists {
 108                         return u
 109                 }
 110         }
 111         return nil
 112 }
 113
 114 func lineURLize(urlPrefix, line string) string {
 115         cols := strings.Split(html.EscapeString(line), " ")
 116         for i, col := range cols {
 117                 if u := urlParse(col); u != nil {
 118                         cols[i] = makeA(col, col)
 119                         continue
 120                 }
 121                 cols[i] = sha1DigestRe.ReplaceAllString(col, makeA(urlPrefix+"/$1", "$1"))
 122         }
 123         return strings.Join(cols, " ")
 124 }
 125
 126 func lineURLizeInTemplate(urlPrefix, line interface{}) string {
 127         return lineURLize(urlPrefix.(string), line.(string))
 128 }
 129
 130 func startHeader(etag hash.Hash, gziped bool) string {
 131         lines := []string{
 132                 "Content-Type: text/html; charset=utf-8",
 133                 "ETag: " + etagString(etag),
 134         }
 135         if gziped {
 136                 lines = append(lines, "Content-Encoding: gzip")
 137         }
 138         lines = append(lines, "")
 139         lines = append(lines, "")
 140         return strings.Join(lines, "\n")
 141 }
 142
 143 func makeErr(err error, status int) {
 144         fmt.Println("Status:", status)
 145         fmt.Print("Content-Type: text/plain; charset=utf-8\n\n")
 146         fmt.Println(err)
 147         log.Fatalln(err)
 148 }
 149
 150 func checkETag(etag hash.Hash) {
 151         ifNoneMatch := os.Getenv("HTTP_IF_NONE_MATCH")
 152         if ifNoneMatch != "" && ifNoneMatch == etagString(etag) {
 153                 fmt.Printf("Status: 304\nETag: %s\n\n", ifNoneMatch)
 154                 os.Exit(0)
 155         }
 156 }
 157
 158 func bytes2uuid(b []byte) string {
 159         raw := new([16]byte)
 160         copy(raw[:], b)
 161         raw[6] = (raw[6] & 0x0F) | uint8(4<<4) // version 4
 162         return fmt.Sprintf("%x-%x-%x-%x-%x", raw[0:4], raw[4:6], raw[6:8], raw[8:10], raw[10:])
 163 }
 164
 165 type CommitIterNext interface {
 166         Next() (*object.Commit, error)
 167 }
 168
 169 func serveHTTP() {
 170         cfgPath := os.Getenv("SGBLOG_CFG")
 171         if cfgPath == "" {
 172                 log.Fatalln("SGBLOG_CFG is not set")
 173         }
 174         cfg, err := readCfg(cfgPath)
 175         if err != nil {
 176                 log.Fatalln(err)
 177         }
 178         initLocalizer(cfg.Lang)
 179
 180         pathInfo := os.Getenv("PATH_INFO")
 181         if len(pathInfo) == 0 {
 182                 pathInfo = "/"
 183         }
 184         queryValues, err := url.ParseQuery(os.Getenv("QUERY_STRING"))
 185         if err != nil {
 186                 makeErr(err, http.StatusBadRequest)
 187         }
 188
 189         etagHash := blake3.New(32, nil)
 190         for _, s := range []string{
 191                 "SGBLOG",
 192                 sgblog.Version,
 193                 cfg.GitPath,
 194                 cfg.Branch,
 195                 cfg.Title,
 196                 cfg.URLPrefix,
 197                 cfg.AtomBaseURL,
 198                 cfg.AtomId,
 199                 cfg.AtomAuthor,
 200         } {
 201                 if _, err = etagHash.Write([]byte(s)); err != nil {
 202                         panic(err)
 203                 }
 204         }
 205         etagHashForWeb := []string{
 206                 cfg.CSS,
 207                 cfg.Webmaster,
 208                 cfg.AboutURL,
 209                 cfg.CommentsNotesRef,
 210                 cfg.CommentsEmail,
 211         }
 212         etagHashForWeb = append(etagHashForWeb, cfg.GitURLs...)
 213
 214         headHash, err := initRepo(cfg)
 215         if err != nil {
 216                 makeErr(err, http.StatusInternalServerError)
 217         }
 218
 219         if notes, err := repo.Notes(); err == nil {
 220                 var notesRef *plumbing.Reference
 221                 var commentsRef *plumbing.Reference
 222                 notes.ForEach(func(ref *plumbing.Reference) error {
 223                         switch string(ref.Name()) {
 224                         case "refs/notes/commits":
 225                                 notesRef = ref
 226                         case cfg.CommentsNotesRef:
 227                                 commentsRef = ref
 228                         }
 229                         return nil
 230                 })
 231                 if notesRef != nil {
 232                         if commentsCommit, err := repo.CommitObject(notesRef.Hash()); err == nil {
 233                                 notesTree, _ = commentsCommit.Tree()
 234                         }
 235                 }
 236                 if commentsRef != nil {
 237                         if commentsCommit, err := repo.CommitObject(commentsRef.Hash()); err == nil {
 238                                 commentsTree, _ = commentsCommit.Tree()
 239                         }
 240                 }
 241         }
 242
 243         var outBuf bytes.Buffer
 244         var out io.Writer
 245         out = &outBuf
 246         var gzipWriter *gzip.Writer
 247         acceptEncoding := os.Getenv("HTTP_ACCEPT_ENCODING")
 248         for _, encoding := range strings.Split(acceptEncoding, ", ") {
 249                 if encoding == "gzip" {
 250                         gzipWriter = gzip.NewWriter(&outBuf)
 251                         out = gzipWriter
 252                 }
 253         }
 254
 255         if pathInfo == "/" {
 256                 offset := 0
 257                 if offsetRaw, exists := queryValues["offset"]; exists {
 258                         offset, err = strconv.Atoi(offsetRaw[0])
 259                         if err != nil {
 260                                 makeErr(err, http.StatusBadRequest)
 261                         }
 262                 }
 263                 repoLog, err := repo.Log(&git.LogOptions{From: *headHash})
 264                 if err != nil {
 265                         makeErr(err, http.StatusInternalServerError)
 266                 }
 267                 topicsCache, err := getTopicsCache(cfg, repoLog)
 268                 if err != nil {
 269                         makeErr(err, http.StatusInternalServerError)
 270                 }
 271                 repoLog, err = repo.Log(&git.LogOptions{From: *headHash})
 272                 if err != nil {
 273                         makeErr(err, http.StatusInternalServerError)
 274                 }
 275
 276                 commitN := 0
 277                 var commits CommitIterNext
 278                 var topic string
 279                 if t, exists := queryValues["topic"]; exists {
 280                         topic = t[0]
 281                         hashes := topicsCache[topic]
 282                         if hashes == nil {
 283                                 makeErr(errors.New("no posts with that topic"), http.StatusBadRequest)
 284                         }
 285                         if len(hashes) > offset {
 286                                 hashes = hashes[offset:]
 287                                 commitN += offset
 288                         }
 289                         commits = &HashesIter{hashes}
 290                 } else {
 291                         for i := 0; i < offset; i++ {
 292                                 if _, err = repoLog.Next(); err != nil {
 293                                         break
 294                                 }
 295                                 commitN++
 296                         }
 297                         commits = repoLog
 298                 }
 299
 300                 entries := make([]TableEntry, 0, PageEntries)
 301                 logEnded := false
 302                 for _, data := range etagHashForWeb {
 303                         etagHash.Write([]byte(data))
 304                 }
 305                 etagHash.Write([]byte("INDEX"))
 306                 etagHash.Write([]byte(topic))
 307                 for i := 0; i < PageEntries; i++ {
 308                         commit, err := commits.Next()
 309                         if err != nil {
 310                                 logEnded = true
 311                                 break
 312                         }
 313                         etagHash.Write(commit.Hash[:])
 314                         commentsRaw := sgblog.GetNote(repo, commentsTree, commit.Hash)
 315                         etagHash.Write(commentsRaw)
 316                         topicsRaw := sgblog.GetNote(repo, topicsTree, commit.Hash)
 317                         etagHash.Write(topicsRaw)
 318                         entries = append(entries, TableEntry{
 319                                 Commit:      commit,
 320                                 CommentsRaw: commentsRaw,
 321                                 TopicsRaw:   topicsRaw,
 322                         })
 323                 }
 324                 checkETag(etagHash)
 325
 326                 for i, entry := range entries {
 327                         commitN++
 328                         entry.Num = commitN
 329                         lines := msgSplit(entry.Commit.Message)
 330                         entry.Title = lines[0]
 331                         entry.LinesNum = len(lines) - 2
 332                         for _, line := range lines[2:] {
 333                                 u := urlParse(line)
 334                                 if u == nil {
 335                                         break
 336                                 }
 337                                 entry.DomainURLs = append(entry.DomainURLs, makeA(line, u.Host))
 338                         }
 339                         entry.CommentsNum = len(sgblog.ParseComments(entry.CommentsRaw))
 340                         entry.Topics = sgblog.ParseTopics(entry.TopicsRaw)
 341                         entries[i] = entry
 342                 }
 343                 offsetPrev := offset - PageEntries
 344                 if offsetPrev < 0 {
 345                         offsetPrev = 0
 346                 }
 347                 os.Stdout.Write([]byte(startHeader(etagHash, gzipWriter != nil)))
 348                 err = TmplHTMLIndex.Execute(out, struct {
 349                         T                *spreak.Localizer
 350                         Version          string
 351                         Cfg              *Cfg
 352                         Topic            string
 353                         TopicsEnabled    bool
 354                         Topics           []string
 355                         CommentsEnabled  bool
 356                         AtomPostsFeed    string
 357                         AtomCommentsFeed string
 358                         Offset           int
 359                         OffsetPrev       int
 360                         OffsetNext       int
 361                         LogEnded         bool
 362                         Entries          []TableEntry
 363                 }{
 364                         T:                localizer,
 365                         Version:          sgblog.Version,
 366                         Cfg:              cfg,
 367                         Topic:            topic,
 368                         TopicsEnabled:    topicsTree != nil,
 369                         Topics:           topicsCache.Topics(),
 370                         CommentsEnabled:  commentsTree != nil,
 371                         AtomPostsFeed:    AtomPostsFeed,
 372                         AtomCommentsFeed: AtomCommentsFeed,
 373                         Offset:           offset,
 374                         OffsetPrev:       offsetPrev,
 375                         OffsetNext:       offset + PageEntries,
 376                         LogEnded:         logEnded,
 377                         Entries:          entries,
 378                 })
 379                 if err != nil {
 380                         makeErr(err, http.StatusInternalServerError)
 381                 }
 382         } else if pathInfo == "/twtxt.txt" {
 383                 commit, err := repo.CommitObject(*headHash)
 384                 if err != nil {
 385                         makeErr(err, http.StatusInternalServerError)
 386                 }
 387                 etagHash.Write([]byte("TWTXT POSTS"))
 388                 etagHash.Write(commit.Hash[:])
 389                 checkETag(etagHash)
 390                 repoLog, err := repo.Log(&git.LogOptions{From: *headHash})
 391                 if err != nil {
 392                         makeErr(err, http.StatusInternalServerError)
 393                 }
 394                 for i := 0; i < PageEntries; i++ {
 395                         commit, err = repoLog.Next()
 396                         if err != nil {
 397                                 break
 398                         }
 399                         fmt.Fprintf(
 400                                 out, "%s\t%s\n",
 401                                 commit.Author.When.Format(time.RFC3339),
 402                                 msgSplit(commit.Message)[0],
 403                         )
 404                 }
 405                 os.Stdout.WriteString("Content-Type: text/plain; charset=utf-8\n")
 406                 os.Stdout.WriteString("ETag: " + etagString(etagHash) + "\n")
 407                 if gzipWriter != nil {
 408                         os.Stdout.WriteString("Content-Encoding: gzip\n")
 409                         gzipWriter.Close()
 410                 }
 411                 os.Stdout.WriteString("\n")
 412                 os.Stdout.Write(outBuf.Bytes())
 413                 return
 414         } else if pathInfo == "/"+AtomPostsFeed {
 415                 commit, err := repo.CommitObject(*headHash)
 416                 if err != nil {
 417                         makeErr(err, http.StatusInternalServerError)
 418                 }
 419
 420                 var topic string
 421                 if t, exists := queryValues["topic"]; exists {
 422                         topic = t[0]
 423                 }
 424
 425                 etagHash.Write([]byte("ATOM POSTS"))
 426                 etagHash.Write([]byte(topic))
 427                 etagHash.Write(commit.Hash[:])
 428                 checkETag(etagHash)
 429                 var title string
 430                 if topic == "" {
 431                         title = cfg.Title
 432                 } else {
 433                         title = fmt.Sprintf("%s (topic: %s)", cfg.Title, topic)
 434                 }
 435                 idHasher := blake3.New(32, nil)
 436                 idHasher.Write([]byte("ATOM POSTS"))
 437                 idHasher.Write([]byte(cfg.AtomId))
 438                 idHasher.Write([]byte(topic))
 439                 feed := atom.Feed{
 440                         Title:   title,
 441                         ID:      "urn:uuid:" + bytes2uuid(idHasher.Sum(nil)),
 442                         Updated: atom.Time(commit.Author.When),
 443                         Link: []atom.Link{{
 444                                 Rel:  "self",
 445                                 Href: cfg.AtomBaseURL + cfg.URLPrefix + "/" + AtomPostsFeed,
 446                         }},
 447                         Author: &atom.Person{Name: cfg.AtomAuthor},
 448                 }
 449
 450                 repoLog, err := repo.Log(&git.LogOptions{From: *headHash})
 451                 if err != nil {
 452                         makeErr(err, http.StatusInternalServerError)
 453                 }
 454                 var commits CommitIterNext
 455                 if topic == "" {
 456                         commits = repoLog
 457                 } else {
 458                         topicsCache, err := getTopicsCache(cfg, repoLog)
 459                         if err != nil {
 460                                 makeErr(err, http.StatusInternalServerError)
 461                         }
 462                         hashes := topicsCache[topic]
 463                         if hashes == nil {
 464                                 makeErr(errors.New("no posts with that topic"), http.StatusBadRequest)
 465                         }
 466                         commits = &HashesIter{hashes}
 467                 }
 468
 469                 for i := 0; i < PageEntries; i++ {
 470                         commit, err = commits.Next()
 471                         if err != nil {
 472                                 break
 473                         }
 474                         lines := msgSplit(commit.Message)
 475                         var categories []atom.Category
 476                         for _, topic := range sgblog.ParseTopics(sgblog.GetNote(
 477                                 repo, topicsTree, commit.Hash,
 478                         )) {
 479                                 categories = append(categories, atom.Category{Term: topic})
 480                         }
 481                         htmlized := make([]string, 0, len(lines))
 482                         htmlized = append(htmlized, "<pre>")
 483                         for _, l := range lines[2:] {
 484                                 htmlized = append(htmlized, lineURLize(cfg.AtomBaseURL+cfg.URLPrefix, l))
 485                         }
 486                         htmlized = append(htmlized, "</pre>")
 487                         links := []atom.Link{{
 488                                 Rel:  "alternate",
 489                                 Href: cfg.AtomBaseURL + cfg.URLPrefix + "/" + commit.Hash.String(),
 490                         }}
 491                         for _, img := range listImgs(cfg, commit.Hash) {
 492                                 links = append(links, atom.Link{
 493                                         Rel:    "enclosure",
 494                                         Href:   "http://" + cfg.ImgDomain + "/" + img.Path,
 495                                         Type:   img.Typ,
 496                                         Length: uint(img.Size),
 497                                 })
 498                         }
 499                         feed.Entry = append(feed.Entry, &atom.Entry{
 500                                 Title:     lines[0],
 501                                 ID:        "urn:uuid:" + bytes2uuid(commit.Hash[:]),
 502                                 Link:      links,
 503                                 Published: atom.Time(commit.Author.When),
 504                                 Updated:   atom.Time(commit.Author.When),
 505                                 Summary:   &atom.Text{Type: "text", Body: lines[0]},
 506                                 Content: &atom.Text{
 507                                         Type: "html",
 508                                         Body: strings.Join(htmlized, "\n"),
 509                                 },
 510                                 Category: categories,
 511                         })
 512                 }
 513                 data, err := xml.MarshalIndent(&feed, "", "  ")
 514                 if err != nil {
 515                         makeErr(err, http.StatusInternalServerError)
 516                 }
 517                 out.Write([]byte(xml.Header))
 518                 out.Write(data)
 519                 goto AtomFinish
 520         } else if pathInfo == "/"+AtomCommentsFeed {
 521                 commit, err := repo.CommitObject(commentsRef.Hash())
 522                 if err != nil {
 523                         makeErr(err, http.StatusInternalServerError)
 524                 }
 525                 etagHash.Write([]byte("ATOM COMMENTS"))
 526                 etagHash.Write(commit.Hash[:])
 527                 checkETag(etagHash)
 528                 idHasher := blake3.New(32, nil)
 529                 idHasher.Write([]byte("ATOM COMMENTS"))
 530                 idHasher.Write([]byte(cfg.AtomId))
 531                 feed := atom.Feed{
 532                         Title:   cfg.Title + " comments",
 533                         ID:      "urn:uuid:" + bytes2uuid(idHasher.Sum(nil)),
 534                         Updated: atom.Time(commit.Author.When),
 535                         Link: []atom.Link{{
 536                                 Rel:  "self",
 537                                 Href: cfg.AtomBaseURL + cfg.URLPrefix + "/" + AtomCommentsFeed,
 538                         }},
 539                         Author: &atom.Person{Name: cfg.AtomAuthor},
 540                 }
 541                 repoLog, err := repo.Log(&git.LogOptions{From: commentsRef.Hash()})
 542                 if err != nil {
 543                         makeErr(err, http.StatusInternalServerError)
 544                 }
 545                 for i := 0; i < PageEntries; i++ {
 546                         commit, err = repoLog.Next()
 547                         if err != nil {
 548                                 break
 549                         }
 550                         fileStats, err := commit.Stats()
 551                         if err != nil {
 552                                 makeErr(err, http.StatusInternalServerError)
 553                         }
 554                         t, err := commit.Tree()
 555                         if err != nil {
 556                                 makeErr(err, http.StatusInternalServerError)
 557                         }
 558                         commentedHash := plumbing.NewHash(strings.ReplaceAll(
 559                                 fileStats[0].Name, "/", "",
 560                         ))
 561                         commit, err = repo.CommitObject(commentedHash)
 562                         if err != nil {
 563                                 continue
 564                         }
 565                         comments := sgblog.ParseComments(sgblog.GetNote(repo, t, commentedHash))
 566                         if len(comments) == 0 {
 567                                 continue
 568                         }
 569                         commentN := strconv.Itoa(len(comments) - 1)
 570                         lines := strings.Split(comments[len(comments)-1], "\n")
 571                         from := strings.TrimPrefix(lines[0], "From: ")
 572                         date := strings.TrimPrefix(lines[1], "Date: ")
 573                         htmlized := make([]string, 0, len(lines))
 574                         htmlized = append(htmlized, "<pre>")
 575                         for _, l := range lines[2:] {
 576                                 htmlized = append(htmlized, lineURLize(cfg.AtomBaseURL+cfg.URLPrefix, l))
 577                         }
 578                         htmlized = append(htmlized, "</pre>")
 579                         idHasher.Reset()
 580                         idHasher.Write([]byte("COMMENT"))
 581                         idHasher.Write(commit.Hash[:])
 582                         idHasher.Write([]byte(commentN))
 583                         feed.Entry = append(feed.Entry, &atom.Entry{
 584                                 Title: fmt.Sprintf(
 585                                         "Comment %s for \"%s\" by %s",
 586                                         commentN, msgSplit(commit.Message)[0], from,
 587                                 ),
 588                                 Author: &atom.Person{Name: from},
 589                                 ID:     "urn:uuid:" + bytes2uuid(idHasher.Sum(nil)),
 590                                 Link: []atom.Link{{
 591                                         Rel: "alternate",
 592                                         Href: strings.Join([]string{
 593                                                 cfg.AtomBaseURL, cfg.URLPrefix, "/",
 594                                                 commit.Hash.String(), "#comment", commentN,
 595                                         }, ""),
 596                                 }},
 597                                 Published: atom.TimeStr(strings.Replace(date, " ", "T", -1)),
 598                                 Updated:   atom.TimeStr(strings.Replace(date, " ", "T", -1)),
 599                                 Content: &atom.Text{
 600                                         Type: "html",
 601                                         Body: strings.Join(htmlized, "\n"),
 602                                 },
 603                         })
 604                 }
 605                 data, err := xml.MarshalIndent(&feed, "", "  ")
 606                 if err != nil {
 607                         makeErr(err, http.StatusInternalServerError)
 608                 }
 609                 out.Write([]byte(xml.Header))
 610                 out.Write(data)
 611                 goto AtomFinish
 612         } else if sha1DigestRe.MatchString(pathInfo[1:]) {
 613                 commit, err := repo.CommitObject(plumbing.NewHash(pathInfo[1 : 1+sha1.Size*2]))
 614                 if err != nil {
 615                         makeErr(err, http.StatusBadRequest)
 616                 }
 617                 for _, data := range etagHashForWeb {
 618                         etagHash.Write([]byte(data))
 619                 }
 620                 etagHash.Write([]byte("ENTRY"))
 621                 etagHash.Write(commit.Hash[:])
 622                 atomCommentsURL := strings.Join([]string{
 623                         cfg.AtomBaseURL, cfg.URLPrefix, "/",
 624                         commit.Hash.String(), "/", AtomCommentsFeed,
 625                 }, "")
 626                 commentsRaw := sgblog.GetNote(repo, commentsTree, commit.Hash)
 627                 etagHash.Write(commentsRaw)
 628                 topicsRaw := sgblog.GetNote(repo, topicsTree, commit.Hash)
 629                 etagHash.Write(topicsRaw)
 630                 if strings.HasSuffix(pathInfo, AtomCommentsFeed) {
 631                         etagHash.Write([]byte("ATOM COMMENTS"))
 632                         checkETag(etagHash)
 633                         type Comment struct {
 634                                 n    string
 635                                 from string
 636                                 date string
 637                                 body []string
 638                         }
 639                         commentsRaw := sgblog.ParseComments(commentsRaw)
 640                         var toSkip int
 641                         if len(commentsRaw) > PageEntries {
 642                                 toSkip = len(commentsRaw) - PageEntries
 643                         }
 644                         comments := make([]Comment, 0, len(commentsRaw)-toSkip)
 645                         for i := len(commentsRaw) - 1; i >= toSkip; i-- {
 646                                 lines := strings.Split(commentsRaw[i], "\n")
 647                                 from := strings.TrimPrefix(lines[0], "From: ")
 648                                 date := strings.TrimPrefix(lines[1], "Date: ")
 649                                 comments = append(comments, Comment{
 650                                         n:    strconv.Itoa(i),
 651                                         from: from,
 652                                         date: strings.Replace(date, " ", "T", 1),
 653                                         body: lines[3:],
 654                                 })
 655                         }
 656                         idHasher := blake3.New(32, nil)
 657                         idHasher.Write([]byte("ATOM COMMENTS"))
 658                         idHasher.Write(commit.Hash[:])
 659                         feed := atom.Feed{
 660                                 Title:  fmt.Sprintf("\"%s\" comments", msgSplit(commit.Message)[0]),
 661                                 ID:     "urn:uuid:" + bytes2uuid(idHasher.Sum(nil)),
 662                                 Link:   []atom.Link{{Rel: "self", Href: atomCommentsURL}},
 663                                 Author: &atom.Person{Name: cfg.AtomAuthor},
 664                         }
 665                         if len(comments) > 0 {
 666                                 feed.Updated = atom.TimeStr(comments[0].date)
 667                         } else {
 668                                 feed.Updated = atom.Time(commit.Author.When)
 669                         }
 670                         for _, comment := range comments {
 671                                 idHasher.Reset()
 672                                 idHasher.Write([]byte("COMMENT"))
 673                                 idHasher.Write(commit.Hash[:])
 674                                 idHasher.Write([]byte(comment.n))
 675                                 htmlized := make([]string, 0, len(comment.body))
 676                                 htmlized = append(htmlized, "<pre>")
 677                                 for _, l := range comment.body {
 678                                         htmlized = append(
 679                                                 htmlized,
 680                                                 lineURLize(cfg.AtomBaseURL+cfg.URLPrefix, l),
 681                                         )
 682                                 }
 683                                 htmlized = append(htmlized, "</pre>")
 684                                 feed.Entry = append(feed.Entry, &atom.Entry{
 685                                         Title:  fmt.Sprintf("Comment %s by %s", comment.n, comment.from),
 686                                         Author: &atom.Person{Name: comment.from},
 687                                         ID:     "urn:uuid:" + bytes2uuid(idHasher.Sum(nil)),
 688                                         Link: []atom.Link{{
 689                                                 Rel: "alternate",
 690                                                 Href: strings.Join([]string{
 691                                                         cfg.AtomBaseURL,
 692                                                         cfg.URLPrefix, "/",
 693                                                         commit.Hash.String(),
 694                                                         "#comment", comment.n,
 695                                                 }, ""),
 696                                         }},
 697                                         Published: atom.TimeStr(
 698                                                 strings.Replace(comment.date, " ", "T", -1),
 699                                         ),
 700                                         Updated: atom.TimeStr(
 701                                                 strings.Replace(comment.date, " ", "T", -1),
 702                                         ),
 703                                         Content: &atom.Text{
 704                                                 Type: "html",
 705                                                 Body: strings.Join(htmlized, "\n"),
 706                                         },
 707                                 })
 708                         }
 709                         data, err := xml.MarshalIndent(&feed, "", "  ")
 710                         if err != nil {
 711                                 makeErr(err, http.StatusInternalServerError)
 712                         }
 713                         out.Write([]byte(xml.Header))
 714                         out.Write(data)
 715                         goto AtomFinish
 716                 }
 717                 notesRaw := sgblog.GetNote(repo, notesTree, commit.Hash)
 718                 etagHash.Write(notesRaw)
 719                 checkETag(etagHash)
 720
 721                 lines := msgSplit(commit.Message)
 722                 title := lines[0]
 723                 when := commit.Author.When.Format(sgblog.WhenFmt)
 724                 var parent string
 725                 if len(commit.ParentHashes) > 0 {
 726                         parent = commit.ParentHashes[0].String()
 727                 }
 728                 commentsParsed := sgblog.ParseComments(commentsRaw)
 729                 comments := make([]CommentEntry, 0, len(commentsParsed))
 730                 for _, comment := range commentsParsed {
 731                         lines := strings.Split(comment, "\n")
 732                         comments = append(comments, CommentEntry{lines[:3], lines[3:]})
 733                 }
 734                 var notesLines []string
 735                 if len(notesRaw) > 0 {
 736                         notesLines = strings.Split(string(notesRaw), "\n")
 737                 }
 738
 739                 os.Stdout.Write([]byte(startHeader(etagHash, gzipWriter != nil)))
 740                 err = TmplHTMLEntry.Execute(out, struct {
 741                         T               *spreak.Localizer
 742                         Version         string
 743                         Cfg             *Cfg
 744                         Title           string
 745                         TitleEscaped    string
 746                         When            string
 747                         AtomCommentsURL string
 748                         Parent          string
 749                         Commit          *object.Commit
 750                         Lines           []string
 751                         NoteLines       []string
 752                         Comments        []CommentEntry
 753                         Topics          []string
 754                         Imgs            []Img
 755                 }{
 756                         T:               localizer,
 757                         Version:         sgblog.Version,
 758                         Cfg:             cfg,
 759                         Title:           title,
 760                         TitleEscaped:    url.PathEscape(fmt.Sprintf("Re: %s (%s)", title, commit.Hash)),
 761                         When:            when,
 762                         AtomCommentsURL: atomCommentsURL,
 763                         Parent:          parent,
 764                         Commit:          commit,
 765                         Lines:           lines[2:],
 766                         NoteLines:       notesLines,
 767                         Comments:        comments,
 768                         Topics:          sgblog.ParseTopics(topicsRaw),
 769                         Imgs:            listImgs(cfg, commit.Hash),
 770                 })
 771                 if err != nil {
 772                         makeErr(err, http.StatusInternalServerError)
 773                 }
 774         } else {
 775                 makeErr(errors.New("unknown URL action"), http.StatusNotFound)
 776         }
 777         out.Write([]byte("</body></html>\n"))
 778         if gzipWriter != nil {
 779                 gzipWriter.Close()
 780         }
 781         os.Stdout.Write(outBuf.Bytes())
 782         return
 783
 784 AtomFinish:
 785         os.Stdout.WriteString("Content-Type: application/atom+xml; charset=utf-8\n")
 786         os.Stdout.WriteString("ETag: " + etagString(etagHash) + "\n")
 787         if gzipWriter != nil {
 788                 os.Stdout.WriteString("Content-Encoding: gzip\n")
 789                 gzipWriter.Close()
 790         }
 791         os.Stdout.WriteString("\n")
 792         os.Stdout.Write(outBuf.Bytes())
 793 }