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.
319 lines
9.0 KiB
Go
319 lines
9.0 KiB
Go
package server
|
|
|
|
import (
|
|
"archive/tar"
|
|
"archive/zip"
|
|
"bufio"
|
|
"bytes"
|
|
"compress/gzip"
|
|
"debug/pe"
|
|
"encoding/base64"
|
|
"encoding/csv"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"math"
|
|
"mime"
|
|
"mime/multipart"
|
|
"mime/quotedprintable"
|
|
"net/mail"
|
|
"net/url"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"unicode/utf8"
|
|
)
|
|
|
|
type archiveEntryView struct {
|
|
Name string `json:"name"`
|
|
Size uint64 `json:"size"`
|
|
IsDir bool `json:"is_dir"`
|
|
IsImage bool `json:"is_image"`
|
|
URL string `json:"url,omitempty"`
|
|
}
|
|
|
|
type metadataView struct {
|
|
Name string
|
|
Value string
|
|
}
|
|
|
|
func structuredContentView(view *contentView, body []byte, semanticPath string) {
|
|
switch view.AdapterID {
|
|
case "csv":
|
|
parseCSVView(view, body)
|
|
case "excalidraw":
|
|
parseExcalidrawView(view, body)
|
|
case "archive":
|
|
if !strings.EqualFold(filepath.Ext(view.Filename), ".zip") {
|
|
view.MetadataStatus = "pending"
|
|
view.MetadataURL = metadataProjectionURL("archive", view.RevisionUUID, semanticPath)
|
|
break
|
|
}
|
|
reader, err := zip.NewReader(bytes.NewReader(body), int64(len(body)))
|
|
if err != nil {
|
|
view.ParseError = err.Error()
|
|
return
|
|
}
|
|
for _, file := range reader.File {
|
|
if len(view.ArchiveEntries) >= maxArchiveMetadataEntries {
|
|
view.ArchiveTruncated = true
|
|
break
|
|
}
|
|
ext := strings.ToLower(filepath.Ext(file.Name))
|
|
query := url.Values{"path": {semanticPath}, "entry": {file.Name}, "rev": {view.RevisionUUID}}
|
|
view.ArchiveEntries = append(view.ArchiveEntries, archiveEntryView{
|
|
Name: file.Name, Size: file.UncompressedSize64,
|
|
IsDir: file.FileInfo().IsDir(),
|
|
IsImage: ext == ".jpg" || ext == ".jpeg" || ext == ".png" ||
|
|
ext == ".gif" || ext == ".webp" || ext == ".avif",
|
|
URL: "/v/archive?" + query.Encode(),
|
|
})
|
|
}
|
|
case "eml":
|
|
message, err := mail.ReadMessage(bytes.NewReader(body))
|
|
if err != nil {
|
|
view.ParseError = err.Error()
|
|
return
|
|
}
|
|
for _, name := range []string{"From", "To", "Cc", "Date", "Subject", "Message-ID"} {
|
|
if value := message.Header.Get(name); value != "" {
|
|
if decoded, err := new(mime.WordDecoder).DecodeHeader(value); err == nil {
|
|
value = decoded
|
|
}
|
|
view.Metadata = append(view.Metadata, metadataView{name, value})
|
|
}
|
|
}
|
|
view.Text = emailText(message.Header, message.Body)
|
|
case "pe":
|
|
file, err := pe.NewFile(bytes.NewReader(body))
|
|
if err != nil {
|
|
view.ParseError = err.Error()
|
|
return
|
|
}
|
|
defer file.Close()
|
|
view.Metadata = append(view.Metadata,
|
|
metadataView{"Machine", fmt.Sprintf("0x%04x", file.FileHeader.Machine)},
|
|
metadataView{"Sections", strconv.Itoa(int(file.FileHeader.NumberOfSections))},
|
|
metadataView{"Timestamp", strconv.FormatUint(uint64(file.FileHeader.TimeDateStamp), 10)},
|
|
metadataView{"Characteristics", fmt.Sprintf("0x%04x", file.FileHeader.Characteristics)},
|
|
)
|
|
for _, section := range file.Sections {
|
|
view.Metadata = append(view.Metadata, metadataView{
|
|
"Section " + section.Name,
|
|
fmt.Sprintf("virtual=%d raw=%d", section.VirtualSize, section.Size),
|
|
})
|
|
}
|
|
case "debian-package":
|
|
parseDebianPackage(view, body)
|
|
}
|
|
}
|
|
|
|
const (
|
|
maxExcalidrawBytes = 2 << 20
|
|
maxExcalidrawElements = 5000
|
|
maxExcalidrawPoints = 100000
|
|
maxExcalidrawText = 1 << 20
|
|
)
|
|
|
|
func parseExcalidrawView(view *contentView, body []byte) {
|
|
if len(body) > maxExcalidrawBytes {
|
|
view.ParseError = "Excalidraw scene exceeds the 2 MiB interactive limit"
|
|
return
|
|
}
|
|
var scene struct {
|
|
Type string `json:"type"`
|
|
Elements []json.RawMessage `json:"elements"`
|
|
}
|
|
if err := json.Unmarshal(body, &scene); err != nil {
|
|
view.ParseError = err.Error()
|
|
return
|
|
}
|
|
if scene.Type != "excalidraw" {
|
|
view.ParseError = "invalid Excalidraw scene type"
|
|
return
|
|
}
|
|
if len(scene.Elements) > maxExcalidrawElements {
|
|
view.ParseError = "Excalidraw scene exceeds the 5000 element limit"
|
|
return
|
|
}
|
|
pointsTotal := 0
|
|
textTotal := 0
|
|
for _, raw := range scene.Elements {
|
|
var element struct {
|
|
Type string `json:"type"`
|
|
X float64 `json:"x"`
|
|
Y float64 `json:"y"`
|
|
W float64 `json:"width"`
|
|
H float64 `json:"height"`
|
|
Points [][]float64 `json:"points"`
|
|
Text string `json:"text"`
|
|
}
|
|
if err := json.Unmarshal(raw, &element); err != nil || element.Type == "" ||
|
|
math.IsNaN(element.X) || math.IsInf(element.X, 0) ||
|
|
math.IsNaN(element.Y) || math.IsInf(element.Y, 0) ||
|
|
math.IsNaN(element.W) || math.IsInf(element.W, 0) ||
|
|
math.IsNaN(element.H) || math.IsInf(element.H, 0) {
|
|
view.ParseError = "invalid Excalidraw element"
|
|
return
|
|
}
|
|
pointsTotal += len(element.Points)
|
|
textTotal += len(element.Text)
|
|
if pointsTotal > maxExcalidrawPoints || textTotal > maxExcalidrawText {
|
|
view.ParseError = "Excalidraw scene complexity exceeds the interactive limit"
|
|
return
|
|
}
|
|
for _, point := range element.Points {
|
|
if len(point) < 2 || math.IsNaN(point[0]) || math.IsInf(point[0], 0) ||
|
|
math.IsNaN(point[1]) || math.IsInf(point[1], 0) {
|
|
view.ParseError = "invalid Excalidraw point"
|
|
return
|
|
}
|
|
}
|
|
}
|
|
view.ExcalidrawValid = true
|
|
view.ExcalidrawElements = len(scene.Elements)
|
|
}
|
|
|
|
const (
|
|
maxCSVRows = 500
|
|
maxCSVColumns = 100
|
|
maxCSVCellBytes = 16 << 10
|
|
)
|
|
|
|
func parseCSVView(view *contentView, body []byte) {
|
|
reader := csv.NewReader(bytes.NewReader(body))
|
|
reader.FieldsPerRecord = -1
|
|
for len(view.CSVRows) < maxCSVRows {
|
|
record, err := reader.Read()
|
|
if err == io.EOF {
|
|
return
|
|
}
|
|
if err != nil {
|
|
// A bounded initial window can end halfway through its final record.
|
|
view.CSVTruncated = true
|
|
if len(view.CSVRows) == 0 {
|
|
view.ParseError = err.Error()
|
|
}
|
|
return
|
|
}
|
|
if len(record) > maxCSVColumns {
|
|
record = record[:maxCSVColumns]
|
|
view.CSVTruncated = true
|
|
}
|
|
for index, cell := range record {
|
|
if len(cell) > maxCSVCellBytes {
|
|
prefix := []byte(cell[:maxCSVCellBytes])
|
|
for len(prefix) > 0 && !utf8.Valid(prefix) {
|
|
prefix = prefix[:len(prefix)-1]
|
|
}
|
|
record[index] = string(prefix) + "…"
|
|
view.CSVTruncated = true
|
|
}
|
|
}
|
|
view.CSVRows = append(view.CSVRows, record)
|
|
}
|
|
if _, err := reader.Read(); err != io.EOF {
|
|
view.CSVTruncated = true
|
|
}
|
|
}
|
|
|
|
func emailText(header mail.Header, body io.Reader) string {
|
|
mediaType, params, _ := mime.ParseMediaType(header.Get("Content-Type"))
|
|
if strings.HasPrefix(mediaType, "multipart/") && params["boundary"] != "" {
|
|
reader := multipart.NewReader(body, params["boundary"])
|
|
for {
|
|
part, err := reader.NextPart()
|
|
if err != nil {
|
|
break
|
|
}
|
|
partType, _, _ := mime.ParseMediaType(part.Header.Get("Content-Type"))
|
|
if partType == "text/plain" || partType == "text/html" || partType == "" {
|
|
return readMailBody(part.Header.Get("Content-Transfer-Encoding"), part)
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
return readMailBody(header.Get("Content-Transfer-Encoding"), body)
|
|
}
|
|
|
|
func readMailBody(encoding string, body io.Reader) string {
|
|
switch strings.ToLower(strings.TrimSpace(encoding)) {
|
|
case "quoted-printable":
|
|
body = quotedprintable.NewReader(body)
|
|
case "base64":
|
|
body = base64.NewDecoder(base64.StdEncoding, body)
|
|
}
|
|
payload, _ := io.ReadAll(io.LimitReader(body, 4<<20))
|
|
return string(payload)
|
|
}
|
|
|
|
func parseDebianPackage(view *contentView, body []byte) {
|
|
reader := bufio.NewReader(bytes.NewReader(body))
|
|
magic := make([]byte, 8)
|
|
if _, err := io.ReadFull(reader, magic); err != nil || string(magic) != "!<arch>\n" {
|
|
view.ParseError = "invalid Debian ar archive"
|
|
return
|
|
}
|
|
for {
|
|
header := make([]byte, 60)
|
|
if _, err := io.ReadFull(reader, header); err != nil {
|
|
break
|
|
}
|
|
name := strings.TrimSpace(strings.TrimSuffix(string(header[:16]), "/"))
|
|
size, err := strconv.ParseInt(strings.TrimSpace(string(header[48:58])), 10, 64)
|
|
if err != nil || size < 0 {
|
|
view.ParseError = "invalid ar member"
|
|
return
|
|
}
|
|
payload := make([]byte, size)
|
|
if _, err := io.ReadFull(reader, payload); err != nil {
|
|
view.ParseError = err.Error()
|
|
return
|
|
}
|
|
if size%2 != 0 {
|
|
_, _ = reader.ReadByte()
|
|
}
|
|
view.Metadata = append(view.Metadata, metadataView{"Member", fmt.Sprintf("%s (%d bytes)", name, size)})
|
|
if name == "debian-binary" {
|
|
view.Metadata = append(view.Metadata, metadataView{"Debian format", strings.TrimSpace(string(payload))})
|
|
}
|
|
if name == "control.tar.gz" {
|
|
parseDebControl(view, payload)
|
|
}
|
|
}
|
|
}
|
|
|
|
func parseDebControl(view *contentView, payload []byte) {
|
|
gz, err := gzip.NewReader(bytes.NewReader(payload))
|
|
if err != nil {
|
|
return
|
|
}
|
|
defer gz.Close()
|
|
tr := tar.NewReader(gz)
|
|
for {
|
|
header, err := tr.Next()
|
|
if err != nil {
|
|
return
|
|
}
|
|
if strings.TrimPrefix(header.Name, "./") != "control" {
|
|
continue
|
|
}
|
|
control, _ := io.ReadAll(io.LimitReader(tr, 1<<20))
|
|
view.Text = string(control)
|
|
message, err := mail.ReadMessage(bytes.NewReader(append(control, '\n', '\n')))
|
|
if err == nil {
|
|
for name, values := range message.Header {
|
|
view.Metadata = append(view.Metadata, metadataView{name, strings.Join(values, ", ")})
|
|
}
|
|
}
|
|
return
|
|
}
|
|
}
|
|
|
|
func archiveEntryContentType(name string, data []byte) string {
|
|
if byExtension := mime.TypeByExtension(strings.ToLower(filepath.Ext(name))); byExtension != "" {
|
|
return byExtension
|
|
}
|
|
return "application/octet-stream"
|
|
}
|