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.
171 lines
5.3 KiB
Go
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
|
|
}
|