package store import ( "bytes" "database/sql" "errors" "fmt" "io" "strings" "golang.org/x/net/html" ) var ErrEmbeddedAssetUnavailable = errors.New("embedded asset is unavailable") // freezeEmbeddedAssets resolves mutable asset: HEADs only in HTML embedding // attributes. Plain text and code examples containing asset: remain unchanged. func (s *Store) freezeEmbeddedAssets(objectUUID string, payload []byte, contentType string) ([]byte, []string, error) { return freezeEmbeddedAssetsFrom(s.DB, objectUUID, payload, contentType) } func freezeEmbeddedAssetsFrom(q interface{ QueryRow(string, ...any) *sql.Row }, objectUUID string, payload []byte, contentType string) ([]byte, []string, error) { if !strings.HasPrefix(strings.ToLower(strings.TrimSpace(contentType)), "text/html") { return payload, nil, nil } z := html.NewTokenizer(bytes.NewReader(payload)) var output bytes.Buffer seen := map[string]bool{} resolved := map[string]string{} var hashes []string resolve := func(address string) (string, error) { if hash := resolved[address]; hash != "" { return hash, nil } var hash string err := q.QueryRow(`SELECT COALESCE(a.head_document_hash,'') FROM assets a JOIN paths p ON p.domain_uuid=a.domain_uuid WHERE p.object_uuid=? AND a.address=? ORDER BY COALESCE(p.is_primary,0) DESC LIMIT 1`, objectUUID, address).Scan(&hash) if err != nil || !validDocumentHash(hash) { if errors.Is(err, sql.ErrNoRows) || err == nil { return "", fmt.Errorf("%w: %s", ErrEmbeddedAssetUnavailable, address) } return "", err } resolved[address] = hash if !seen[hash] { seen[hash] = true hashes = append(hashes, hash) } return hash, nil } for { typeOfToken := z.Next() if typeOfToken == html.ErrorToken { if errors.Is(z.Err(), io.EOF) { return output.Bytes(), hashes, nil } return nil, nil, z.Err() } if typeOfToken != html.StartTagToken && typeOfToken != html.SelfClosingTagToken { output.Write(z.Raw()) continue } token := z.Token() changed := false assetRef := tokenAttribute(token.Attr, "asset-ref") legacyImmutableRef := tokenAttribute(token.Attr, "immutable-ref") if assetRef == "" && strings.HasPrefix(legacyImmutableRef, "asset:") { assetRef = legacyImmutableRef } if strings.HasPrefix(assetRef, "asset:") { hash, err := resolve(assetRef) if err != nil { return nil, nil, err } setTokenAttribute(&token, "asset-ref", assetRef) setTokenAttribute(&token, "immutable-ref", "sha256:"+hash) changed = true } for _, name := range []string{"src", "href", "poster", "data"} { provenanceName := "data-pageswiki-asset-" + name address := tokenAttribute(token.Attr, provenanceName) if address == "" { candidate := tokenAttribute(token.Attr, name) if strings.HasPrefix(candidate, "asset:") { address = candidate } } if !strings.HasPrefix(address, "asset:") { continue } hash, err := resolve(address) if err != nil { return nil, nil, err } setTokenAttribute(&token, provenanceName, address) setTokenAttribute(&token, name, "/_/obj/sha256:"+hash) changed = true } if changed { output.WriteString(token.String()) } else { output.Write(z.Raw()) } } } func tokenAttribute(attributes []html.Attribute, name string) string { for _, attribute := range attributes { if strings.EqualFold(attribute.Key, name) { return strings.TrimSpace(attribute.Val) } } return "" } func setTokenAttribute(token *html.Token, name, value string) { for index := range token.Attr { if strings.EqualFold(token.Attr[index].Key, name) { token.Attr[index].Key = name token.Attr[index].Val = value return } } token.Attr = append(token.Attr, html.Attribute{Key: name, Val: value}) }