mirror of
https://github.com/koodo-reader/koodo-reader.git
synced 2026-06-11 09:24:48 -04:00
607 lines
17 KiB
Go
607 lines
17 KiB
Go
package main
|
|
|
|
import (
|
|
"database/sql"
|
|
"encoding/xml"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
_ "modernc.org/sqlite"
|
|
)
|
|
|
|
// ── OPDS configuration ────────────────────────────────────────────────────────
|
|
|
|
var opdsEnabled bool
|
|
|
|
func init() {
|
|
opdsEnabled = os.Getenv("ENABLE_OPDS") == "true"
|
|
}
|
|
|
|
// ── Atom / OPDS XML types ─────────────────────────────────────────────────────
|
|
|
|
const (
|
|
atomNS = "http://www.w3.org/2005/Atom"
|
|
opdsNS = "http://opds-spec.org/2010/catalog"
|
|
dcNS = "http://purl.org/dc/terms/"
|
|
opensearchNS = "http://a9.com/-/spec/opensearch/1.1/"
|
|
opdsMimeAcq = "application/atom+xml;profile=opds-catalog;kind=acquisition"
|
|
opdsMimeNav = "application/atom+xml;profile=opds-catalog;kind=navigation"
|
|
opdsMimeFeed = "application/atom+xml;profile=opds-catalog"
|
|
opdsMimeSearch = "application/opensearchdescription+xml"
|
|
)
|
|
|
|
type atomLink struct {
|
|
Rel string `xml:"rel,attr,omitempty"`
|
|
Href string `xml:"href,attr"`
|
|
Type string `xml:"type,attr,omitempty"`
|
|
Title string `xml:"title,attr,omitempty"`
|
|
Count string `xml:"thr:count,attr,omitempty"`
|
|
}
|
|
|
|
type atomPerson struct {
|
|
Name string `xml:"name"`
|
|
}
|
|
|
|
type atomContent struct {
|
|
Type string `xml:"type,attr,omitempty"`
|
|
Content string `xml:",chardata"`
|
|
}
|
|
|
|
type dcLanguage struct {
|
|
Lang string `xml:",chardata"`
|
|
}
|
|
|
|
type atomEntry struct {
|
|
XMLName xml.Name `xml:"entry"`
|
|
Title string `xml:"title"`
|
|
ID string `xml:"id"`
|
|
Updated string `xml:"updated"`
|
|
Authors []atomPerson `xml:"author,omitempty"`
|
|
Links []atomLink `xml:"link,omitempty"`
|
|
Summary atomContent `xml:"summary,omitempty"`
|
|
Content *atomContent `xml:"content,omitempty"`
|
|
Publisher string `xml:"dc:publisher,omitempty"`
|
|
Language string `xml:"dc:language,omitempty"`
|
|
}
|
|
|
|
type opensearchDesc struct {
|
|
TotalResults int `xml:"opensearch:totalResults"`
|
|
ItemsPerPage int `xml:"opensearch:itemsPerPage"`
|
|
StartIndex int `xml:"opensearch:startIndex"`
|
|
}
|
|
|
|
type atomFeed struct {
|
|
XMLName xml.Name `xml:"feed"`
|
|
Xmlns string `xml:"xmlns,attr"`
|
|
XmlnsDC string `xml:"xmlns:dc,attr"`
|
|
XmlnsOS string `xml:"xmlns:opensearch,attr"`
|
|
XmlnsOPDS string `xml:"xmlns:opds,attr"`
|
|
ID string `xml:"id"`
|
|
Title string `xml:"title"`
|
|
Updated string `xml:"updated"`
|
|
Author atomPerson `xml:"author"`
|
|
Links []atomLink `xml:"link"`
|
|
TotalResults int `xml:"opensearch:totalResults,omitempty"`
|
|
ItemsPerPage int `xml:"opensearch:itemsPerPage,omitempty"`
|
|
StartIndex int `xml:"opensearch:startIndex,omitempty"`
|
|
Entries []atomEntry `xml:"entry,omitempty"`
|
|
}
|
|
|
|
// ── Book model from SQLite ────────────────────────────────────────────────────
|
|
|
|
type opdsBook struct {
|
|
Key string
|
|
Name string
|
|
Author string
|
|
Description string
|
|
Cover string
|
|
Format string
|
|
Publisher string
|
|
Size int64
|
|
Page int
|
|
}
|
|
|
|
func openBooksDB() (*sql.DB, error) {
|
|
dbPath := filepath.Join(uploadDir, "config", "books.db")
|
|
return sql.Open("sqlite", dbPath+"?_journal=WAL&mode=ro")
|
|
}
|
|
|
|
func queryBooks(db *sql.DB, search string) ([]opdsBook, error) {
|
|
var (
|
|
rows *sql.Rows
|
|
err error
|
|
)
|
|
base := `SELECT key, COALESCE(name,''), COALESCE(author,''), COALESCE(description,''),
|
|
COALESCE(cover,''), COALESCE(format,''), COALESCE(publisher,''),
|
|
COALESCE(size,0), COALESCE(page,0)
|
|
FROM books`
|
|
if search != "" {
|
|
like := "%" + search + "%"
|
|
rows, err = db.Query(base+` WHERE name LIKE ? OR author LIKE ? OR description LIKE ?
|
|
ORDER BY name`, like, like, like)
|
|
} else {
|
|
rows, err = db.Query(base + ` ORDER BY name`)
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
var books []opdsBook
|
|
for rows.Next() {
|
|
var b opdsBook
|
|
if err := rows.Scan(&b.Key, &b.Name, &b.Author, &b.Description,
|
|
&b.Cover, &b.Format, &b.Publisher, &b.Size, &b.Page); err != nil {
|
|
continue
|
|
}
|
|
books = append(books, b)
|
|
}
|
|
return books, rows.Err()
|
|
}
|
|
|
|
func queryBook(db *sql.DB, key string) (*opdsBook, error) {
|
|
row := db.QueryRow(`SELECT key, COALESCE(name,''), COALESCE(author,''), COALESCE(description,''),
|
|
COALESCE(cover,''), COALESCE(format,''), COALESCE(publisher,''),
|
|
COALESCE(size,0), COALESCE(page,0)
|
|
FROM books WHERE key = ?`, key)
|
|
var b opdsBook
|
|
if err := row.Scan(&b.Key, &b.Name, &b.Author, &b.Description,
|
|
&b.Cover, &b.Format, &b.Publisher, &b.Size, &b.Page); err != nil {
|
|
return nil, err
|
|
}
|
|
return &b, nil
|
|
}
|
|
|
|
// ── Cover file detection ──────────────────────────────────────────────────────
|
|
|
|
var imageExts = []string{".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp"}
|
|
|
|
// findCoverFile finds the cover image for a given book key.
|
|
// It first checks the cover field (e.g. "1767196800000.jpg"), then falls back
|
|
// to scanning the cover directory for any image with the matching stem.
|
|
func findCoverFile(key, coverField string) (string, string) {
|
|
coverDir := filepath.Join(uploadDir, "cover")
|
|
|
|
// Try the explicit cover field first
|
|
if coverField != "" {
|
|
candidate := filepath.Join(coverDir, coverField)
|
|
if _, err := os.Stat(candidate); err == nil {
|
|
ext := strings.ToLower(filepath.Ext(coverField))
|
|
return candidate, ext
|
|
}
|
|
// Maybe cover field is just the key, try composing
|
|
for _, ext := range imageExts {
|
|
candidate = filepath.Join(coverDir, key+ext)
|
|
if _, err := os.Stat(candidate); err == nil {
|
|
return candidate, ext
|
|
}
|
|
}
|
|
}
|
|
|
|
// Scan for key.* in cover directory
|
|
for _, ext := range imageExts {
|
|
candidate := filepath.Join(coverDir, key+ext)
|
|
if _, err := os.Stat(candidate); err == nil {
|
|
return candidate, ext
|
|
}
|
|
}
|
|
return "", ""
|
|
}
|
|
|
|
func coverMime(ext string) string {
|
|
switch ext {
|
|
case ".jpg", ".jpeg":
|
|
return "image/jpeg"
|
|
case ".png":
|
|
return "image/png"
|
|
case ".gif":
|
|
return "image/gif"
|
|
case ".webp":
|
|
return "image/webp"
|
|
case ".bmp":
|
|
return "image/bmp"
|
|
default:
|
|
return "image/jpeg"
|
|
}
|
|
}
|
|
|
|
func bookMime(format string) string {
|
|
switch strings.ToLower(format) {
|
|
case "epub":
|
|
return "application/epub+zip"
|
|
case "pdf":
|
|
return "application/pdf"
|
|
case "mobi":
|
|
return "application/x-mobipocket-ebook"
|
|
case "azw", "azw3":
|
|
return "application/x-mobi8-ebook"
|
|
case "cbz":
|
|
return "application/x-cbz"
|
|
case "cbr":
|
|
return "application/x-cbr"
|
|
case "txt":
|
|
return "text/plain"
|
|
case "fb2":
|
|
return "application/x-fictionbook+xml"
|
|
default:
|
|
return "application/octet-stream"
|
|
}
|
|
}
|
|
|
|
// ── XML helpers ───────────────────────────────────────────────────────────────
|
|
|
|
func now() string { return time.Now().UTC().Format(time.RFC3339) }
|
|
|
|
func writeXML(w http.ResponseWriter, status int, v any) {
|
|
w.Header().Set("Content-Type", "application/atom+xml; charset=utf-8")
|
|
w.WriteHeader(status)
|
|
_, _ = w.Write([]byte(xml.Header))
|
|
enc := xml.NewEncoder(w)
|
|
enc.Indent("", " ")
|
|
_ = enc.Encode(v)
|
|
}
|
|
|
|
func opdsRequireAuth(w http.ResponseWriter) {
|
|
w.Header().Set("WWW-Authenticate", `Basic realm="OPDS Catalog"`)
|
|
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
|
|
w.WriteHeader(http.StatusUnauthorized)
|
|
_, _ = w.Write([]byte("Unauthorized"))
|
|
}
|
|
|
|
// ── OPDS handlers ─────────────────────────────────────────────────────────────
|
|
|
|
// handleOPDSRoot serves the OPDS root navigation feed.
|
|
func handleOPDSRoot(w http.ResponseWriter, r *http.Request, base string) {
|
|
feed := atomFeed{
|
|
Xmlns: atomNS,
|
|
XmlnsDC: dcNS,
|
|
XmlnsOS: opensearchNS,
|
|
XmlnsOPDS: opdsNS,
|
|
ID: base + "/opds",
|
|
Title: "Koodo Reader OPDS Catalog",
|
|
Updated: now(),
|
|
Author: atomPerson{Name: "Koodo Reader"},
|
|
Links: []atomLink{
|
|
{Rel: "self", Href: base + "/opds", Type: opdsMimeNav},
|
|
{Rel: "start", Href: base + "/opds", Type: opdsMimeNav},
|
|
{Rel: "search", Href: base + "/opds/search?q={searchTerms}", Type: opdsMimeSearch},
|
|
},
|
|
Entries: []atomEntry{
|
|
{
|
|
Title: "All Books",
|
|
ID: base + "/opds/books",
|
|
Updated: now(),
|
|
Links: []atomLink{
|
|
{Rel: "subsection", Href: base + "/opds/books", Type: opdsMimeAcq},
|
|
},
|
|
Summary: atomContent{Content: "Browse all books in the library"},
|
|
},
|
|
{
|
|
Title: "Search",
|
|
ID: base + "/opds/search",
|
|
Updated: now(),
|
|
Links: []atomLink{
|
|
{Rel: "search", Href: base + "/opds/search?q={searchTerms}", Type: opdsMimeAcq, Title: "Search books"},
|
|
},
|
|
Summary: atomContent{Content: "Search the library by title, author or description"},
|
|
},
|
|
},
|
|
}
|
|
writeXML(w, http.StatusOK, feed)
|
|
}
|
|
|
|
// handleOPDSBooks serves the full acquisition feed of all books (or search results).
|
|
func handleOPDSBooks(w http.ResponseWriter, r *http.Request, base, search string) {
|
|
db, err := openBooksDB()
|
|
if err != nil {
|
|
log.Printf("OPDS: failed to open books.db: %v", err)
|
|
http.Error(w, "Database unavailable", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
defer db.Close()
|
|
|
|
books, err := queryBooks(db, search)
|
|
if err != nil {
|
|
log.Printf("OPDS: query error: %v", err)
|
|
http.Error(w, "Query error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
title := "All Books"
|
|
selfHref := base + "/opds/books"
|
|
if search != "" {
|
|
title = fmt.Sprintf("Search results for \"%s\"", search)
|
|
selfHref = base + "/opds/search?q=" + search
|
|
}
|
|
|
|
feed := atomFeed{
|
|
Xmlns: atomNS,
|
|
XmlnsDC: dcNS,
|
|
XmlnsOS: opensearchNS,
|
|
XmlnsOPDS: opdsNS,
|
|
ID: selfHref,
|
|
Title: title,
|
|
Updated: now(),
|
|
Author: atomPerson{Name: "Koodo Reader"},
|
|
TotalResults: len(books),
|
|
ItemsPerPage: len(books),
|
|
StartIndex: 1,
|
|
Links: []atomLink{
|
|
{Rel: "self", Href: selfHref, Type: opdsMimeAcq},
|
|
{Rel: "start", Href: base + "/opds", Type: opdsMimeNav},
|
|
{Rel: "search", Href: base + "/opds/search?q={searchTerms}", Type: opdsMimeSearch},
|
|
},
|
|
}
|
|
|
|
for _, b := range books {
|
|
entry := buildEntry(b, base)
|
|
feed.Entries = append(feed.Entries, entry)
|
|
}
|
|
|
|
writeXML(w, http.StatusOK, feed)
|
|
}
|
|
|
|
// handleOPDSBook serves the acquisition feed for a single book.
|
|
func handleOPDSBook(w http.ResponseWriter, r *http.Request, base, key string) {
|
|
db, err := openBooksDB()
|
|
if err != nil {
|
|
log.Printf("OPDS: failed to open books.db: %v", err)
|
|
http.Error(w, "Database unavailable", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
defer db.Close()
|
|
|
|
b, err := queryBook(db, key)
|
|
if err != nil {
|
|
http.Error(w, "Book not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
feed := atomFeed{
|
|
Xmlns: atomNS,
|
|
XmlnsDC: dcNS,
|
|
XmlnsOS: opensearchNS,
|
|
XmlnsOPDS: opdsNS,
|
|
ID: base + "/opds/book/" + key,
|
|
Title: b.Name,
|
|
Updated: now(),
|
|
Author: atomPerson{Name: "Koodo Reader"},
|
|
Links: []atomLink{
|
|
{Rel: "self", Href: base + "/opds/book/" + key, Type: opdsMimeAcq},
|
|
{Rel: "start", Href: base + "/opds", Type: opdsMimeNav},
|
|
},
|
|
Entries: []atomEntry{buildEntry(*b, base)},
|
|
}
|
|
writeXML(w, http.StatusOK, feed)
|
|
}
|
|
|
|
// handleOPDSCover serves the cover image for a book.
|
|
func handleOPDSCover(w http.ResponseWriter, r *http.Request, key string) {
|
|
db, err := openBooksDB()
|
|
if err != nil {
|
|
http.Error(w, "Database unavailable", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
defer db.Close()
|
|
|
|
b, err := queryBook(db, key)
|
|
if err != nil {
|
|
http.Error(w, "Book not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
coverPath, ext := findCoverFile(b.Key, b.Cover)
|
|
if coverPath == "" {
|
|
http.Error(w, "Cover not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
f, err := os.Open(coverPath)
|
|
if err != nil {
|
|
http.Error(w, "Cannot open cover", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
defer f.Close()
|
|
|
|
w.Header().Set("Content-Type", coverMime(ext))
|
|
http.ServeContent(w, r, filepath.Base(coverPath), time.Time{}, f)
|
|
}
|
|
|
|
// handleOPDSDownload serves the book file for download.
|
|
func handleOPDSDownload(w http.ResponseWriter, r *http.Request, key string) {
|
|
db, err := openBooksDB()
|
|
if err != nil {
|
|
http.Error(w, "Database unavailable", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
defer db.Close()
|
|
|
|
b, err := queryBook(db, key)
|
|
if err != nil {
|
|
http.Error(w, "Book not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
format := strings.ToLower(b.Format)
|
|
bookPath := filepath.Join(uploadDir, "book", b.Key+"."+format)
|
|
if _, err := os.Stat(bookPath); os.IsNotExist(err) {
|
|
http.Error(w, "Book file not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
f, err := os.Open(bookPath)
|
|
if err != nil {
|
|
http.Error(w, "Cannot open book file", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
defer f.Close()
|
|
|
|
filename := b.Name
|
|
if filename == "" {
|
|
filename = b.Key
|
|
}
|
|
filename += "." + format
|
|
|
|
w.Header().Set("Content-Type", bookMime(format))
|
|
w.Header().Set("Content-Disposition",
|
|
fmt.Sprintf(`attachment; filename="%s"`, strings.ReplaceAll(filename, `"`, `'`)))
|
|
http.ServeContent(w, r, filename, time.Time{}, f)
|
|
}
|
|
|
|
// handleOPDSSearch serves the OpenSearch description document.
|
|
func handleOPDSSearchDesc(w http.ResponseWriter, r *http.Request, base string) {
|
|
type osParam struct {
|
|
Name string `xml:"name,attr"`
|
|
Value string `xml:"value,attr"`
|
|
}
|
|
type osURL struct {
|
|
Type string `xml:"type,attr"`
|
|
Template string `xml:"template,attr"`
|
|
}
|
|
type osDesc struct {
|
|
XMLName xml.Name `xml:"OpenSearchDescription"`
|
|
Xmlns string `xml:"xmlns,attr"`
|
|
ShortName string `xml:"ShortName"`
|
|
Description string `xml:"Description"`
|
|
InputEnc string `xml:"InputEncoding"`
|
|
URL osURL `xml:"Url"`
|
|
}
|
|
|
|
desc := osDesc{
|
|
Xmlns: "http://a9.com/-/spec/opensearch/1.1/",
|
|
ShortName: "Koodo Reader",
|
|
Description: "Search books by title, author or description",
|
|
InputEnc: "UTF-8",
|
|
URL: osURL{
|
|
Type: opdsMimeAcq,
|
|
Template: base + "/opds/search?q={searchTerms}",
|
|
},
|
|
}
|
|
w.Header().Set("Content-Type", "application/opensearchdescription+xml; charset=utf-8")
|
|
w.WriteHeader(http.StatusOK)
|
|
_, _ = w.Write([]byte(xml.Header))
|
|
enc := xml.NewEncoder(w)
|
|
enc.Indent("", " ")
|
|
_ = enc.Encode(desc)
|
|
}
|
|
|
|
// ── Entry builder ─────────────────────────────────────────────────────────────
|
|
|
|
func buildEntry(b opdsBook, base string) atomEntry {
|
|
format := strings.ToLower(b.Format)
|
|
entry := atomEntry{
|
|
Title: b.Name,
|
|
ID: base + "/opds/book/" + b.Key,
|
|
Updated: now(),
|
|
Links: []atomLink{
|
|
// Acquisition link (download)
|
|
{
|
|
Rel: "http://opds-spec.org/acquisition",
|
|
Href: base + "/opds/download/" + b.Key + "." + format,
|
|
Type: bookMime(format),
|
|
},
|
|
},
|
|
Summary: atomContent{Type: "text", Content: b.Description},
|
|
Publisher: b.Publisher,
|
|
}
|
|
|
|
if b.Author != "" {
|
|
entry.Authors = []atomPerson{{Name: b.Author}}
|
|
}
|
|
|
|
// Cover image links
|
|
coverPath, ext := findCoverFile(b.Key, b.Cover)
|
|
if coverPath != "" {
|
|
mime := coverMime(ext)
|
|
entry.Links = append(entry.Links,
|
|
atomLink{
|
|
Rel: "http://opds-spec.org/image",
|
|
Href: base + "/opds/cover/" + b.Key,
|
|
Type: mime,
|
|
},
|
|
atomLink{
|
|
Rel: "http://opds-spec.org/image/thumbnail",
|
|
Href: base + "/opds/cover/" + b.Key,
|
|
Type: mime,
|
|
},
|
|
)
|
|
}
|
|
|
|
return entry
|
|
}
|
|
|
|
// ── OPDS router ───────────────────────────────────────────────────────────────
|
|
|
|
func opdsHandler(w http.ResponseWriter, r *http.Request) {
|
|
// Auth check
|
|
if !authenticate(r) {
|
|
opdsRequireAuth(w)
|
|
return
|
|
}
|
|
|
|
base := getServerOrigin(r)
|
|
path := r.URL.Path
|
|
|
|
switch {
|
|
// Root catalog
|
|
case path == "/opds" || path == "/opds/":
|
|
handleOPDSRoot(w, r, base)
|
|
|
|
// All books acquisition feed
|
|
case path == "/opds/books":
|
|
handleOPDSBooks(w, r, base, "")
|
|
|
|
// Search feed
|
|
case path == "/opds/search":
|
|
q := r.URL.Query().Get("q")
|
|
handleOPDSBooks(w, r, base, q)
|
|
|
|
// OpenSearch description
|
|
case path == "/opds/search.xml":
|
|
handleOPDSSearchDesc(w, r, base)
|
|
|
|
// Single book feed: /opds/book/{key}
|
|
case strings.HasPrefix(path, "/opds/book/"):
|
|
key := strings.TrimPrefix(path, "/opds/book/")
|
|
key = strings.Trim(key, "/")
|
|
if key == "" {
|
|
http.Error(w, "Missing book key", http.StatusBadRequest)
|
|
return
|
|
}
|
|
handleOPDSBook(w, r, base, key)
|
|
|
|
// Cover image: /opds/cover/{key}
|
|
case strings.HasPrefix(path, "/opds/cover/"):
|
|
key := strings.TrimPrefix(path, "/opds/cover/")
|
|
key = strings.Trim(key, "/")
|
|
if key == "" {
|
|
http.Error(w, "Missing book key", http.StatusBadRequest)
|
|
return
|
|
}
|
|
handleOPDSCover(w, r, key)
|
|
|
|
// Book file download: /opds/download/{key}.{format}
|
|
case strings.HasPrefix(path, "/opds/download/"):
|
|
filename := strings.TrimPrefix(path, "/opds/download/")
|
|
filename = strings.Trim(filename, "/")
|
|
// Strip extension to get key
|
|
key := filename
|
|
if idx := strings.LastIndex(filename, "."); idx > 0 {
|
|
key = filename[:idx]
|
|
}
|
|
if key == "" {
|
|
http.Error(w, "Missing book key", http.StatusBadRequest)
|
|
return
|
|
}
|
|
handleOPDSDownload(w, r, key)
|
|
|
|
default:
|
|
http.Error(w, "Not Found", http.StatusNotFound)
|
|
}
|
|
}
|