f8cef413d6
Integrate tunasync management, SQLite authentication and content settings, real monitoring and per-repository pull speeds. Add Chinese-only announcements and mirror help, editable related links, admin layout updates, deployment tools and tests.
403 lines
12 KiB
Go
403 lines
12 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"image"
|
|
_ "image/jpeg"
|
|
_ "image/png"
|
|
"io"
|
|
"net/http"
|
|
"net/mail"
|
|
"net/url"
|
|
"os"
|
|
"path/filepath"
|
|
"regexp"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
var identifier = regexp.MustCompile(`^[a-zA-Z0-9][a-zA-Z0-9_.+-]{0,127}$`)
|
|
|
|
func validName(value string) bool {
|
|
return identifier.MatchString(value) && value != "." && value != ".."
|
|
}
|
|
func validText(value Localized, required bool, limit int) bool {
|
|
has := false
|
|
if len(value) > 20 {
|
|
return false
|
|
}
|
|
for locale, text := range value {
|
|
if len(locale) > 48 || !localeIdentifier.MatchString(locale) {
|
|
return false
|
|
}
|
|
if len(text) > limit {
|
|
return false
|
|
}
|
|
if strings.TrimSpace(text) != "" {
|
|
has = true
|
|
}
|
|
}
|
|
return !required || has
|
|
}
|
|
|
|
var localeIdentifier = regexp.MustCompile(`^[a-zA-Z]{2,3}(?:-[a-zA-Z0-9]{2,8})*$`)
|
|
|
|
func webURL(value string, empty bool) bool {
|
|
if empty && value == "" {
|
|
return true
|
|
}
|
|
u, e := url.Parse(value)
|
|
return e == nil && (u.Scheme == "http" || u.Scheme == "https") && u.Host != "" && u.User == nil && len(value) < 2048
|
|
}
|
|
func navigationURL(value string) bool {
|
|
if webURL(value, false) {
|
|
return true
|
|
}
|
|
if !strings.HasPrefix(value, "/") || strings.HasPrefix(value, "//") || len(value) >= 2048 || strings.ContainsAny(value, "\\\r\n\t") {
|
|
return false
|
|
}
|
|
u, err := url.Parse(value)
|
|
return err == nil && u.Scheme == "" && u.Host == "" && u.User == nil
|
|
}
|
|
func imageURL(value string) bool {
|
|
if strings.HasPrefix(value, "/assets/") || strings.HasPrefix(value, "/uploads/") {
|
|
return !strings.Contains(value, "..") && !strings.ContainsAny(value, "\\?#")
|
|
}
|
|
u, e := url.Parse(value)
|
|
return e == nil && u.Scheme == "https" && u.Host != "" && u.User == nil
|
|
}
|
|
func strict(raw []byte, value any) bool {
|
|
d := json.NewDecoder(bytes.NewReader(raw))
|
|
d.DisallowUnknownFields()
|
|
return d.Decode(value) == nil
|
|
}
|
|
func (a *App) listRecords(w http.ResponseWriter, r *http.Request) {
|
|
kind := r.PathValue("kind")
|
|
if kind != "announcements" && kind != "mirrors" && kind != "settings" {
|
|
fail(w, 404, "NOT_FOUND")
|
|
return
|
|
}
|
|
if _, ok := a.require(w, r, kind != "announcements"); !ok {
|
|
return
|
|
}
|
|
records, err := a.records(kind)
|
|
if err != nil {
|
|
a.internal(w, err)
|
|
return
|
|
}
|
|
respond(w, 200, records)
|
|
}
|
|
func (a *App) putRecord(w http.ResponseWriter, r *http.Request) {
|
|
kind, id := r.PathValue("kind"), r.PathValue("id")
|
|
if !validName(id) || (kind != "announcements" && kind != "mirrors" && kind != "settings") {
|
|
fail(w, 400, "INVALID_INPUT")
|
|
return
|
|
}
|
|
s, ok := a.require(w, r, kind != "announcements")
|
|
if !ok {
|
|
return
|
|
}
|
|
var body struct {
|
|
Data json.RawMessage `json:"data"`
|
|
Revision int `json:"revision"`
|
|
}
|
|
if !readJSON(w, r, &body) {
|
|
return
|
|
}
|
|
var value any
|
|
switch kind {
|
|
case "announcements":
|
|
var d Announcement
|
|
if !strict(body.Data, &d) || strings.TrimSpace(d.Title) == "" || len(d.Title) > 300 || len(d.Body) > 250000 || (d.Published && strings.TrimSpace(d.Body) == "") {
|
|
fail(w, 400, "INVALID_INPUT")
|
|
return
|
|
}
|
|
if d.Date == "" {
|
|
d.Date = time.Now().UTC().Format(time.RFC3339)
|
|
}
|
|
if _, err := time.Parse(time.RFC3339, d.Date); err != nil {
|
|
fail(w, 400, "INVALID_INPUT")
|
|
return
|
|
}
|
|
value = d
|
|
case "mirrors":
|
|
var d MirrorMetadata
|
|
if !strict(body.Data, &d) || d.Name != id || !validText(d.Description, false, 1000) || len(d.Help) > 250000 || !webURL(d.Website, true) || (d.Category != "os" && d.Category != "language" && d.Category != "other") {
|
|
fail(w, 400, "INVALID_INPUT")
|
|
return
|
|
}
|
|
value = d
|
|
case "settings":
|
|
var d Settings
|
|
if id != "site" || !strict(body.Data, &d) || !validText(d.Name, true, 200) || !validText(d.Description, false, 2000) || !validText(d.Address, false, 2000) || !imageURL(d.LogoLight) || !imageURL(d.LogoDark) || !imageURL(d.Favicon) || !imageURL(d.Avatar) || len(d.Links) > 50 || len(d.RelatedLinks) > 50 || len(d.Downloads) > 100 {
|
|
fail(w, 400, "INVALID_INPUT")
|
|
return
|
|
}
|
|
var fields map[string]json.RawMessage
|
|
json.Unmarshal(body.Data, &fields)
|
|
if _, provided := fields["relatedLinks"]; !provided {
|
|
// Preserve saved sidebar changes when an older open form submits without this field.
|
|
current, err := a.record("settings", "site")
|
|
var existing Settings
|
|
if err != nil || decodeData(current.Data, &existing) != nil {
|
|
fail(w, 409, "CONFLICT")
|
|
return
|
|
}
|
|
d.RelatedLinks = existing.RelatedLinks
|
|
}
|
|
if d.RelatedLinks == nil {
|
|
d.RelatedLinks = []RelatedLink{}
|
|
}
|
|
for _, link := range d.RelatedLinks {
|
|
if !validText(link.Title, true, 200) || (link.Kind != "help" && link.Kind != "url") || (link.Kind == "help" && link.URL != "") || (link.Kind == "url" && !navigationURL(link.URL)) {
|
|
fail(w, 400, "INVALID_INPUT")
|
|
return
|
|
}
|
|
}
|
|
if d.Email != "" {
|
|
if parsed, err := mail.ParseAddress(d.Email); err != nil || parsed.Address != d.Email {
|
|
fail(w, 400, "INVALID_INPUT")
|
|
return
|
|
}
|
|
}
|
|
for _, link := range d.Links {
|
|
if !validText(link.Title, true, 200) || !webURL(link.URL, false) {
|
|
fail(w, 400, "INVALID_INPUT")
|
|
return
|
|
}
|
|
}
|
|
for _, download := range d.Downloads {
|
|
if strings.TrimSpace(download.Name) == "" || len(download.Name) > 100 || len(download.Version) > 100 || !webURL(download.URL, false) {
|
|
fail(w, 400, "INVALID_INPUT")
|
|
return
|
|
}
|
|
}
|
|
value = d
|
|
}
|
|
result, err := a.saveRecord(kind, id, value, body.Revision)
|
|
if errors.Is(err, errConflict) {
|
|
fail(w, 409, "CONFLICT")
|
|
return
|
|
}
|
|
if err != nil {
|
|
a.internal(w, err)
|
|
return
|
|
}
|
|
a.audit(s, "record_save", kind+"/"+id, "success")
|
|
respond(w, 200, result)
|
|
}
|
|
func (a *App) deleteRecord(w http.ResponseWriter, r *http.Request) {
|
|
kind, id := r.PathValue("kind"), r.PathValue("id")
|
|
if kind != "announcements" && kind != "mirrors" {
|
|
fail(w, 400, "INVALID_INPUT")
|
|
return
|
|
}
|
|
s, ok := a.require(w, r, kind != "announcements")
|
|
if !ok {
|
|
return
|
|
}
|
|
var body struct {
|
|
Revision int `json:"revision"`
|
|
}
|
|
if !readJSON(w, r, &body) {
|
|
return
|
|
}
|
|
result, err := a.db.Exec("UPDATE records SET deleted=1,revision=revision+1,updated=? WHERE kind=? AND id=? AND revision=? AND deleted=0", time.Now().UnixMilli(), kind, id, body.Revision)
|
|
if err != nil {
|
|
a.internal(w, err)
|
|
return
|
|
}
|
|
count, _ := result.RowsAffected()
|
|
if count != 1 {
|
|
fail(w, 409, "CONFLICT")
|
|
return
|
|
}
|
|
a.audit(s, "record_delete", kind+"/"+id, "success")
|
|
respond(w, 200, map[string]bool{"ok": true})
|
|
}
|
|
func (a *App) upload(w http.ResponseWriter, r *http.Request) {
|
|
s, ok := a.require(w, r, true)
|
|
if !ok {
|
|
return
|
|
}
|
|
r.Body = http.MaxBytesReader(w, r.Body, 5<<20)
|
|
if err := r.ParseMultipartForm(4 << 20); err != nil {
|
|
fail(w, 400, "INVALID_IMAGE")
|
|
return
|
|
}
|
|
if r.MultipartForm != nil {
|
|
defer r.MultipartForm.RemoveAll()
|
|
}
|
|
file, _, err := r.FormFile("file")
|
|
if err != nil {
|
|
fail(w, 400, "INVALID_IMAGE")
|
|
return
|
|
}
|
|
defer file.Close()
|
|
content, err := io.ReadAll(io.LimitReader(file, 4<<20+1))
|
|
if err != nil || len(content) > 4<<20 {
|
|
fail(w, 400, "INVALID_IMAGE")
|
|
return
|
|
}
|
|
conf, format, err := image.DecodeConfig(bytes.NewReader(content))
|
|
if err != nil || (format != "png" && format != "jpeg") || conf.Width < 1 || conf.Height < 1 || conf.Width > 8192 || conf.Height > 8192 || int64(conf.Width)*int64(conf.Height) > 32000000 {
|
|
fail(w, 400, "INVALID_IMAGE")
|
|
return
|
|
}
|
|
ext := ".png"
|
|
if format == "jpeg" {
|
|
ext = ".jpg"
|
|
}
|
|
name := tokenHash(randomToken())[:24] + ext
|
|
if err = os.WriteFile(filepath.Join(a.cfg.Data, "uploads", name), content, 0644); err != nil {
|
|
a.internal(w, err)
|
|
return
|
|
}
|
|
a.audit(s, "upload", name, "success")
|
|
respond(w, 201, map[string]string{"url": "/uploads/" + name})
|
|
}
|
|
func (a *App) public(w http.ResponseWriter, r *http.Request) {
|
|
site, err := a.record("settings", "site")
|
|
if err != nil {
|
|
a.internal(w, err)
|
|
return
|
|
}
|
|
metadata, err := a.records("mirrors")
|
|
if err != nil {
|
|
a.internal(w, err)
|
|
return
|
|
}
|
|
metas := map[string]MirrorMetadata{}
|
|
for _, record := range metadata {
|
|
var m MirrorMetadata
|
|
if decodeData(record.Data, &m) == nil {
|
|
metas[record.ID] = m
|
|
}
|
|
}
|
|
jobs, updated, upstreamError := a.cachedJobs()
|
|
mirrors := []PublicMirror{}
|
|
for _, job := range jobs {
|
|
meta, exists := metas[job.Name]
|
|
if exists && !meta.Visible {
|
|
continue
|
|
}
|
|
if !exists {
|
|
meta = MirrorMetadata{Name: job.Name, Category: "other", Visible: true, Description: Localized{}}
|
|
}
|
|
mirrors = append(mirrors, publicMirror(job, meta))
|
|
}
|
|
sort.Slice(mirrors, func(i, j int) bool { return mirrors[i].Name < mirrors[j].Name })
|
|
announcements, err := a.records("announcements")
|
|
if err != nil {
|
|
a.internal(w, err)
|
|
return
|
|
}
|
|
published := []Record{}
|
|
for _, record := range announcements {
|
|
var d Announcement
|
|
if decodeData(record.Data, &d) == nil && d.Published {
|
|
record.Data = d
|
|
published = append(published, record)
|
|
}
|
|
}
|
|
sort.SliceStable(published, func(i, j int) bool {
|
|
a, b := published[i].Data.(Announcement), published[j].Data.(Announcement)
|
|
if a.Pinned != b.Pinned {
|
|
return a.Pinned
|
|
}
|
|
return a.Date > b.Date
|
|
})
|
|
if len(published) > 100 {
|
|
published = published[:100]
|
|
}
|
|
respond(w, 200, map[string]any{"site": site.Data, "mirrors": mirrors, "announcements": published, "source": map[string]any{"updatedAt": updated, "stale": upstreamError != "" || updated == 0 || time.Now().UnixMilli()-updated > 60000, "code": upstreamError}})
|
|
}
|
|
func (a *App) overview(w http.ResponseWriter, r *http.Request) {
|
|
if _, ok := a.require(w, r, false); !ok {
|
|
return
|
|
}
|
|
jobs, updated, code := a.cachedJobs()
|
|
workers := []Worker{}
|
|
err := a.managerGet(r.Context(), "/workers", &workers)
|
|
if err != nil && code == "" {
|
|
code = "TUNASYNC_UNAVAILABLE"
|
|
}
|
|
respond(w, 200, map[string]any{"jobs": jobs, "workers": workers, "worker": a.cfg.Worker, "updatedAt": updated, "code": code, "configAvailable": a.cfg.WorkerConfig != "", "logsAvailable": a.cfg.Logs != ""})
|
|
}
|
|
func (a *App) auditList(w http.ResponseWriter, r *http.Request) {
|
|
if _, ok := a.require(w, r, true); !ok {
|
|
return
|
|
}
|
|
rows, err := a.db.Query("SELECT id,username,action,target,result,created FROM audit ORDER BY id DESC LIMIT 200")
|
|
if err != nil {
|
|
a.internal(w, err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
out := []map[string]any{}
|
|
for rows.Next() {
|
|
var id, created int64
|
|
var username, action, target, result string
|
|
if err = rows.Scan(&id, &username, &action, &target, &result, &created); err != nil {
|
|
a.internal(w, err)
|
|
return
|
|
}
|
|
out = append(out, map[string]any{"id": id, "username": username, "action": action, "target": target, "result": result, "created": created})
|
|
}
|
|
respond(w, 200, out)
|
|
}
|
|
func (a *App) users(w http.ResponseWriter, r *http.Request) {
|
|
if _, ok := a.require(w, r, true); !ok {
|
|
return
|
|
}
|
|
rows, err := a.db.Query("SELECT id,username,role,created FROM users ORDER BY id")
|
|
if err != nil {
|
|
a.internal(w, err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
out := []map[string]any{}
|
|
for rows.Next() {
|
|
var id, created int64
|
|
var username, role string
|
|
if err = rows.Scan(&id, &username, &role, &created); err != nil {
|
|
a.internal(w, err)
|
|
return
|
|
}
|
|
out = append(out, map[string]any{"id": id, "username": username, "role": role, "created": created})
|
|
}
|
|
respond(w, 200, out)
|
|
}
|
|
func (a *App) createUser(w http.ResponseWriter, r *http.Request) {
|
|
s, ok := a.require(w, r, true)
|
|
if !ok {
|
|
return
|
|
}
|
|
var body struct {
|
|
Username string `json:"username"`
|
|
Password string `json:"password"`
|
|
Role string `json:"role"`
|
|
}
|
|
if !readJSON(w, r, &body) {
|
|
return
|
|
}
|
|
if !validName(body.Username) || (body.Role != "admin" && body.Role != "editor") {
|
|
fail(w, 400, "INVALID_INPUT")
|
|
return
|
|
}
|
|
hash, err := hashPassword(body.Password)
|
|
if err != nil {
|
|
fail(w, 400, "INVALID_PASSWORD")
|
|
return
|
|
}
|
|
if _, err = a.db.Exec("INSERT INTO users(username,password,role,created) VALUES(?,?,?,?)", body.Username, hash, body.Role, time.Now().UnixMilli()); err != nil {
|
|
fail(w, 409, "CONFLICT")
|
|
return
|
|
}
|
|
a.audit(s, "user_create", body.Username, "success")
|
|
respond(w, 201, map[string]bool{"ok": true})
|
|
}
|