Files
pages/internal/server/home_wallpaper.go
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming.

Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
2026-09-27 14:44:43 +09:00

171 lines
5.3 KiB
Go

package server
import (
"bytes"
"crypto/rand"
"math/big"
"mime"
"net/http"
pathpkg "path"
"strconv"
"strings"
"time"
"pageswiki/internal/store"
)
const defaultHomeWallpaperOpacity = 28
type homeWallpaperView struct {
Path string
URL string
Opacity string
}
// configuredLoginWallpaper returns only the image selected by the Domain
// administrator as the home/login wallpaper. It intentionally does not use
// the requesting principal's document permissions: choosing an image as the
// login wallpaper makes that one image public on the sign-in surface.
func (s *Server) configuredLoginWallpaper(domainUUID string) *store.Revision {
configured, _ := s.homeWallpaperConfig(domainUUID)
if configured == "" {
return nil
}
if objectUUID, err := s.store.ResolvePathInDomain(domainUUID, configured); err == nil {
revision, revisionErr := s.store.GetLatestRevisionForLanguages(objectUUID, []string{s.getLocale(domainUUID), "und"})
if revisionErr == nil && imageContentType(revision.ContentType) {
return revision
}
}
entries, err := s.store.ListBrowserEntriesInDomain(domainUUID, configured)
if err != nil {
return nil
}
candidates := make([]store.BrowserEntry, 0, len(entries))
for _, entry := range entries {
if !entry.IsDir && entry.RevisionUUID != "" && imageContentType(entry.ContentType) {
candidates = append(candidates, entry)
}
}
if len(candidates) == 0 {
return nil
}
index := 0
if value, randomErr := rand.Int(rand.Reader, big.NewInt(int64(len(candidates)))); randomErr == nil {
index = int(value.Int64())
}
revision, err := s.store.GetRevision(candidates[index].RevisionUUID)
if err != nil || !imageContentType(revision.ContentType) {
return nil
}
return revision
}
func (s *Server) handleAuthWallpaper(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet && r.Method != http.MethodHead {
w.Header().Set("Allow", "GET, HEAD")
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
return
}
revision := s.configuredLoginWallpaper(s.domainUUIDForRequest(r))
if revision == nil {
http.NotFound(w, r)
return
}
contentType := revision.ContentType
mediaType, _, err := mime.ParseMediaType(contentType)
if err != nil || !strings.HasPrefix(strings.ToLower(mediaType), "image/") {
http.NotFound(w, r)
return
}
filename := strings.TrimSpace(revision.Filename)
if filename == "" {
filename = "wallpaper"
}
w.Header().Set("Cache-Control", "private, no-store")
w.Header().Set("Content-Type", contentType)
w.Header().Set("Content-Disposition", mime.FormatMediaType("inline", map[string]string{"filename": filename}))
w.Header().Set("X-Content-Type-Options", "nosniff")
w.Header().Set("ETag", `"`+revision.DocumentHash+`"`)
if strings.EqualFold(mediaType, "image/svg+xml") {
w.Header().Set("Content-Security-Policy", "default-src 'none'; sandbox")
}
http.ServeContent(w, r, filename, time.UnixMilli(revision.CreatedAtMS), bytes.NewReader([]byte(revision.Body)))
}
func normalizePickerPath(raw string) (string, bool) {
raw = strings.TrimSpace(raw)
if raw == "" {
return "", true
}
if len(raw) > 4096 || !strings.HasPrefix(raw, "/") || strings.ContainsAny(raw, "\x00\r\n\\") {
return "", false
}
for _, part := range strings.Split(raw, "/") {
if part == "." || part == ".." {
return "", false
}
}
clean := pathpkg.Clean(raw)
if clean == "." || !strings.HasPrefix(clean, "/") {
return "", false
}
return clean, true
}
func imageContentType(raw string) bool {
mediaType, _, err := mime.ParseMediaType(raw)
return err == nil && strings.HasPrefix(strings.ToLower(mediaType), "image/")
}
func (s *Server) homeWallpaperConfig(domainUUID string) (string, int) {
path, ok := normalizePickerPath(s.getDomainConfig("home_wallpaper_path", domainUUID))
if !ok {
path = ""
}
opacity := defaultHomeWallpaperOpacity
if raw := strings.TrimSpace(s.getDomainConfig("home_wallpaper_opacity", domainUUID)); raw != "" {
if parsed, err := strconv.Atoi(raw); err == nil && parsed >= 0 && parsed <= 100 {
opacity = parsed
}
}
return path, opacity
}
func (s *Server) homeWallpaperForRequest(r *http.Request) homeWallpaperView {
domainUUID := s.domainUUIDForRequest(r)
configured, opacity := s.homeWallpaperConfig(domainUUID)
view := homeWallpaperView{Path: configured, Opacity: strconv.FormatFloat(float64(opacity)/100, 'f', 2, 64)}
if configured == "" {
return view
}
httpRequest := r
if objectUUID, err := s.store.ResolvePathInDomain(domainUUID, configured); err == nil && s.requestCanReadPath(httpRequest, configured) {
if revision, err := s.latestRevisionMetadataForRequest(httpRequest, objectUUID); err == nil && imageContentType(revision.ContentType) {
view.URL = rawProjectionURL("path:" + configured)
return view
}
}
entries, err := s.store.ListBrowserEntriesInDomain(domainUUID, configured)
if err != nil {
return view
}
candidates := make([]store.BrowserEntry, 0, len(entries))
for _, entry := range entries {
if !entry.IsDir && imageContentType(entry.ContentType) && s.requestCanReadPath(httpRequest, entry.Path) {
candidates = append(candidates, entry)
}
}
if len(candidates) == 0 {
return view
}
index := 0
if value, err := rand.Int(rand.Reader, big.NewInt(int64(len(candidates)))); err == nil {
index = int(value.Int64())
}
view.URL = rawProjectionURL("path:" + candidates[index].Path)
return view
}