package server import ( "bytes" "database/sql" "encoding/json" "errors" "fmt" "image" "image/color" "net/http" "net/url" "os" "path/filepath" "strconv" "time" "go.uber.org/zap" "github.com/status-im/status-go/images" "github.com/status-im/status-go/ipfs" "github.com/status-im/status-go/multiaccounts" "github.com/status-im/status-go/protocol/identity/colorhash" "github.com/status-im/status-go/protocol/identity/identicon" "github.com/status-im/status-go/protocol/identity/ring" "github.com/status-im/status-go/protocol/protobuf" ) const ( basePath = "/messages" identiconsPath = basePath + "/identicons" imagesPath = basePath + "/images" audioPath = basePath + "/audio" ipfsPath = "/ipfs" discordAuthorsPath = "/discord/authors" discordAttachmentsPath = basePath + "/discord/attachments" LinkPreviewThumbnailPath = "/link-preview/thumbnail" // Handler routes for pairing accountImagesPath = "/accountImages" accountInitialsPath = "/accountInitials" contactImagesPath = "/contactImages" generateQRCode = "/GenerateQRCode" ) type HandlerPatternMap map[string]http.HandlerFunc func handleRequestDBMissing(logger *zap.Logger) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { logger.Error("can't handle media request without appdb") } } func handleRequestDownloaderMissing(logger *zap.Logger) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { logger.Error("can't handle media request without ipfs downloader") } } type ImageParams struct { KeyUID string PublicKey string ImageName string ImagePath string FullName string InitialsLength int FontFile string FontSize float64 Color color.Color BgSize int BgColor color.Color UppercaseRatio float64 Theme ring.Theme Ring bool IndicatorSize float64 IndicatorBorder float64 IndicatorColor color.Color AuthorID string URL string MessageID string AttachmentID string Hash string Download bool } func ParseImageParams(logger *zap.Logger, params url.Values) ImageParams { parsed := ImageParams{} parsed.Color = color.Transparent parsed.BgColor = color.Transparent parsed.IndicatorColor = color.Transparent parsed.UppercaseRatio = 1.0 keyUids := params["keyUid"] if len(keyUids) != 0 { parsed.KeyUID = keyUids[0] } pks := params["publicKey"] if len(pks) != 0 { parsed.PublicKey = pks[0] } imageNames := params["imageName"] if len(imageNames) != 0 { if filepath.IsAbs(imageNames[0]) { if _, err := os.Stat(imageNames[0]); err == nil { parsed.ImagePath = imageNames[0] } else if errors.Is(err, os.ErrNotExist) { logger.Error("ParseParams: image not exit", zap.String("imageName", imageNames[0])) return parsed } else { logger.Error("ParseParams: failed to read image", zap.String("imageName", imageNames[0]), zap.Error(err)) return parsed } } else { parsed.ImageName = imageNames[0] } } names := params["name"] if len(names) != 0 { parsed.FullName = names[0] } parsed.InitialsLength = 2 amountInitialsStr := params["length"] if len(amountInitialsStr) != 0 { amountInitials, err := strconv.Atoi(amountInitialsStr[0]) if err != nil { logger.Error("ParseParams: invalid initials length") return parsed } parsed.InitialsLength = amountInitials } fontFiles := params["fontFile"] if len(fontFiles) != 0 { if _, err := os.Stat(fontFiles[0]); err == nil { parsed.FontFile = fontFiles[0] } else if errors.Is(err, os.ErrNotExist) { logger.Error("ParseParams: font file not exit", zap.String("FontFile", fontFiles[0])) return parsed } else { logger.Error("ParseParams: font file not exit", zap.String("FontFile", fontFiles[0]), zap.Error(err)) return parsed } } fontSizeStr := params["fontSize"] if len(fontSizeStr) != 0 { fontSize, err := strconv.ParseFloat(fontSizeStr[0], 64) if err != nil { logger.Error("ParseParams: invalid fontSize", zap.String("FontSize", fontSizeStr[0])) return parsed } parsed.FontSize = fontSize } colors := params["color"] if len(colors) != 0 { textColor, err := images.ParseColor(colors[0]) if err != nil { logger.Error("ParseParams: invalid color", zap.String("Color", colors[0])) return parsed } parsed.Color = textColor } sizeStrs := params["size"] if len(sizeStrs) != 0 { size, err := strconv.Atoi(sizeStrs[0]) if err != nil { logger.Error("ParseParams: invalid size", zap.String("size", sizeStrs[0])) return parsed } parsed.BgSize = size } bgColors := params["bgColor"] if len(bgColors) != 0 { bgColor, err := images.ParseColor(bgColors[0]) if err != nil { logger.Error("ParseParams: invalid bgColor", zap.String("BgColor", bgColors[0])) return parsed } parsed.BgColor = bgColor } uppercaseRatioStr := params["uppercaseRatio"] if len(uppercaseRatioStr) != 0 { uppercaseRatio, err := strconv.ParseFloat(uppercaseRatioStr[0], 64) if err != nil { logger.Error("ParseParams: invalid uppercaseRatio", zap.String("uppercaseRatio", uppercaseRatioStr[0])) return parsed } parsed.UppercaseRatio = uppercaseRatio } indicatorColors := params["indicatorColor"] if len(indicatorColors) != 0 { indicatorColor, err := images.ParseColor(indicatorColors[0]) if err != nil { logger.Error("ParseParams: invalid indicatorColor", zap.String("IndicatorColor", indicatorColors[0])) return parsed } parsed.IndicatorColor = indicatorColor } indicatorSizeStrs := params["indicatorSize"] if len(indicatorSizeStrs) != 0 { indicatorSize, err := strconv.ParseFloat(indicatorSizeStrs[0], 64) if err != nil { logger.Error("ParseParams: invalid indicatorSize", zap.String("indicatorSize", indicatorSizeStrs[0])) indicatorSize = 0 } parsed.IndicatorSize = indicatorSize } indicatorBorderStrs := params["indicatorBorder"] if len(indicatorBorderStrs) != 0 { indicatorBorder, err := strconv.ParseFloat(indicatorBorderStrs[0], 64) if err != nil { logger.Error("ParseParams: invalid indicatorBorder", zap.String("indicatorBorder", indicatorBorderStrs[0])) indicatorBorder = 0 } parsed.IndicatorBorder = indicatorBorder } parsed.Theme = getTheme(params, logger) parsed.Ring = ringEnabled(params) messageIDs := params["message-id"] if len(messageIDs) != 0 { parsed.MessageID = messageIDs[0] } messageIDs = params["messageId"] if len(messageIDs) != 0 { parsed.MessageID = messageIDs[0] } authorIds := params["authorId"] if len(authorIds) != 0 { parsed.AuthorID = authorIds[0] } urls := params["url"] if len(urls) != 0 { parsed.URL = urls[0] } hash := params["hash"] if len(hash) != 0 { parsed.Hash = hash[0] } _, download := params["download"] parsed.Download = download return parsed } func handleAccountImagesImpl(multiaccountsDB *multiaccounts.Database, logger *zap.Logger, w http.ResponseWriter, parsed ImageParams) { if parsed.KeyUID == "" { logger.Error("handleAccountImagesImpl: no keyUid") return } if parsed.ImageName == "" { logger.Error("handleAccountImagesImpl: no imageName") return } identityImage, err := multiaccountsDB.GetIdentityImage(parsed.KeyUID, parsed.ImageName) if err != nil { logger.Error("handleAccountImagesImpl: failed to load image.", zap.String("keyUid", parsed.KeyUID), zap.String("imageName", parsed.ImageName), zap.Error(err)) return } if parsed.BgSize == 0 { parsed.BgSize = identityImage.Width } payload, err := images.RoundCrop(identityImage.Payload) if err != nil { logger.Error("handleAccountImagesImpl: failed to crop image.", zap.String("keyUid", parsed.KeyUID), zap.String("imageName", parsed.ImageName), zap.Error(err)) return } if parsed.Ring { account, err := multiaccountsDB.GetAccount(parsed.KeyUID) if err != nil { logger.Error("handleAccountImagesImpl: failed to GetAccount .", zap.String("keyUid", parsed.KeyUID), zap.Error(err)) return } accColorHash := account.ColorHash if accColorHash == nil { if parsed.PublicKey == "" { logger.Error("handleAccountImagesImpl: no public key for color hash", zap.String("keyUid", parsed.KeyUID)) return } accColorHash, err = colorhash.GenerateFor(parsed.PublicKey) if err != nil { logger.Error("handleAccountImagesImpl: could not generate color hash", zap.String("keyUid", parsed.KeyUID), zap.Error(err)) return } } payload, err = ring.DrawRing(&ring.DrawRingParam{ Theme: parsed.Theme, ColorHash: accColorHash, ImageBytes: payload, Height: identityImage.Height, Width: identityImage.Width, }) if err != nil { logger.Error("handleAccountImagesImpl: failed to draw ring for account identity", zap.Error(err)) return } } if parsed.IndicatorSize != 0 { // enlarge indicator size based on identity image size / desired size // or we get a bad quality identity image enlargeIndicatorRatio := float64(identityImage.Width / parsed.BgSize) payload, err = images.AddStatusIndicatorToImage(payload, parsed.IndicatorColor, parsed.IndicatorSize*enlargeIndicatorRatio, parsed.IndicatorBorder*enlargeIndicatorRatio) if err != nil { logger.Error("handleAccountImagesImpl: failed to draw status-indicator for initials", zap.Error(err)) return } } if len(payload) == 0 { logger.Error("handleAccountImagesImpl: empty image") return } mime, err := images.GetProtobufImageMime(payload) if err != nil { logger.Error("failed to get mime", zap.Error(err)) } w.Header().Set("Content-Type", mime) w.Header().Set("Cache-Control", "no-store") _, err = w.Write(payload) if err != nil { logger.Error("handleAccountImagesImpl: failed to write image", zap.Error(err)) } } func handleAccountImagesPlaceholder(logger *zap.Logger, w http.ResponseWriter, parsed ImageParams) { if parsed.ImagePath == "" { logger.Error("handleAccountImagesPlaceholder: no imagePath") return } payload, im, err := images.ImageToBytesAndImage(parsed.ImagePath) if err != nil { logger.Error("handleAccountImagesPlaceholder: failed to load image from disk", zap.String("imageName", parsed.ImagePath)) return } width := im.Bounds().Dx() if parsed.BgSize == 0 { parsed.BgSize = width } payload, err = images.RoundCrop(payload) if err != nil { logger.Error("handleAccountImagesPlaceholder: failed to crop image.", zap.String("imageName", parsed.ImagePath), zap.Error(err)) return } if parsed.IndicatorSize != 0 { enlargeIndicatorRatio := float64(width / parsed.BgSize) payload, err = images.AddStatusIndicatorToImage(payload, parsed.IndicatorColor, parsed.IndicatorSize*enlargeIndicatorRatio, parsed.IndicatorBorder*enlargeIndicatorRatio) if err != nil { logger.Error("handleAccountImagesPlaceholder: failed to draw status-indicator for initials", zap.Error(err)) return } } if len(payload) == 0 { logger.Error("handleAccountImagesPlaceholder: empty image") return } mime, err := images.GetProtobufImageMime(payload) if err != nil { logger.Error("failed to get mime", zap.Error(err)) } w.Header().Set("Content-Type", mime) w.Header().Set("Cache-Control", "no-store") _, err = w.Write(payload) if err != nil { logger.Error("handleAccountImagesPlaceholder: failed to write image", zap.Error(err)) } } // handleAccountImages render multiaccounts custom profile image func handleAccountImages(multiaccountsDB *multiaccounts.Database, logger *zap.Logger) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { params := r.URL.Query() parsed := ParseImageParams(logger, params) if parsed.KeyUID == "" { handleAccountImagesPlaceholder(logger, w, parsed) } else { handleAccountImagesImpl(multiaccountsDB, logger, w, parsed) } } } func handleAccountInitialsImpl(multiaccountsDB *multiaccounts.Database, logger *zap.Logger, w http.ResponseWriter, parsed ImageParams) { var name = parsed.FullName var accColorHash multiaccounts.ColorHash var account *multiaccounts.Account if parsed.KeyUID != "" { account, err := multiaccountsDB.GetAccount(parsed.KeyUID) if err != nil { logger.Error("handleAccountInitialsImpl: failed to get account.", zap.String("keyUid", parsed.KeyUID), zap.Error(err)) return } name = account.Name accColorHash = account.ColorHash } initials := images.ExtractInitials(name, parsed.InitialsLength) payload, err := images.GenerateInitialsImage(initials, parsed.BgColor, parsed.Color, parsed.FontFile, parsed.BgSize, parsed.FontSize, parsed.UppercaseRatio) if err != nil { logger.Error("handleAccountInitialsImpl: failed to generate initials image.", zap.String("keyUid", parsed.KeyUID), zap.String("name", account.Name), zap.Error(err)) return } if parsed.Ring { if accColorHash == nil { if parsed.PublicKey == "" { logger.Error("handleAccountInitialsImpl: no public key, can't draw ring", zap.String("keyUid", parsed.KeyUID), zap.Error(err)) return } accColorHash, err = colorhash.GenerateFor(parsed.PublicKey) if err != nil { logger.Error("handleAccountInitialsImpl: failed to generate color hash from pubkey", zap.String("keyUid", parsed.KeyUID), zap.Error(err)) return } } payload, err = ring.DrawRing(&ring.DrawRingParam{ Theme: parsed.Theme, ColorHash: accColorHash, ImageBytes: payload, Height: parsed.BgSize, Width: parsed.BgSize, }) if err != nil { logger.Error("failed to draw ring for account identity", zap.Error(err)) return } } if parsed.IndicatorSize != 0 { payload, err = images.AddStatusIndicatorToImage(payload, parsed.IndicatorColor, parsed.IndicatorSize, parsed.IndicatorBorder) if err != nil { logger.Error("failed to draw status-indicator for initials", zap.Error(err)) return } } if len(payload) == 0 { logger.Error("handleAccountInitialsImpl: empty image", zap.String("keyUid", parsed.KeyUID), zap.Error(err)) return } mime, err := images.GetProtobufImageMime(payload) if err != nil { logger.Error("failed to get mime", zap.Error(err)) } w.Header().Set("Content-Type", mime) w.Header().Set("Cache-Control", "no-store") _, err = w.Write(payload) if err != nil { logger.Error("failed to write image", zap.Error(err)) } } func handleAccountInitialsPlaceholder(logger *zap.Logger, w http.ResponseWriter, parsed ImageParams) { if parsed.FullName == "" { logger.Error("handleAccountInitialsPlaceholder: no full name") return } initials := images.ExtractInitials(parsed.FullName, parsed.InitialsLength) payload, err := images.GenerateInitialsImage(initials, parsed.BgColor, parsed.Color, parsed.FontFile, parsed.BgSize, parsed.FontSize, parsed.UppercaseRatio) if err != nil { logger.Error("handleAccountInitialsPlaceholder: failed to generate initials image.", zap.String("keyUid", parsed.KeyUID), zap.String("name", parsed.FullName), zap.Error(err)) return } if parsed.IndicatorSize != 0 { payload, err = images.AddStatusIndicatorToImage(payload, parsed.IndicatorColor, parsed.IndicatorSize, parsed.IndicatorBorder) if err != nil { logger.Error("failed to draw status-indicator for initials", zap.Error(err)) return } } if len(payload) == 0 { logger.Error("handleAccountInitialsPlaceholder: empty image", zap.String("keyUid", parsed.KeyUID), zap.Error(err)) return } mime, err := images.GetProtobufImageMime(payload) if err != nil { logger.Error("failed to get mime", zap.Error(err)) } w.Header().Set("Content-Type", mime) w.Header().Set("Cache-Control", "no-store") _, err = w.Write(payload) if err != nil { logger.Error("failed to write image", zap.Error(err)) } } // handleAccountInitials render multiaccounts/contacts initials avatar image func handleAccountInitials(multiaccountsDB *multiaccounts.Database, logger *zap.Logger) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { params := r.URL.Query() parsed := ParseImageParams(logger, params) if parsed.FontFile == "" { logger.Error("handleAccountInitials: no fontFile") return } if parsed.FontSize == 0 { logger.Error("handleAccountInitials: no fontSize") return } if parsed.Color == color.Transparent { logger.Error("handleAccountInitials: no color") return } if parsed.BgSize == 0 { logger.Error("handleAccountInitials: no size") return } if parsed.BgColor == color.Transparent { logger.Error("handleAccountInitials: no bgColor") return } if parsed.KeyUID == "" && parsed.PublicKey == "" { handleAccountInitialsPlaceholder(logger, w, parsed) } else { handleAccountInitialsImpl(multiaccountsDB, logger, w, parsed) } } } // handleContactImages render contacts custom profile image func handleContactImages(db *sql.DB, logger *zap.Logger) http.HandlerFunc { if db == nil { return handleRequestDBMissing(logger) } return func(w http.ResponseWriter, r *http.Request) { params := r.URL.Query() parsed := ParseImageParams(logger, params) if parsed.PublicKey == "" { logger.Error("no publicKey") return } if parsed.ImageName == "" { logger.Error("no imageName") return } var payload []byte err := db.QueryRow(`SELECT payload FROM chat_identity_contacts WHERE contact_id = ? and image_type = ?`, parsed.PublicKey, parsed.ImageName).Scan(&payload) if err != nil { logger.Error("failed to load image.", zap.String("contact id", parsed.PublicKey), zap.String("image type", parsed.ImageName), zap.Error(err)) return } img, _, err := image.Decode(bytes.NewReader(payload)) if err != nil { logger.Error("failed to decode config.", zap.String("contact id", parsed.PublicKey), zap.String("image type", parsed.ImageName), zap.Error(err)) return } width := img.Bounds().Dx() if parsed.BgSize == 0 { parsed.BgSize = width } payload, err = images.RoundCrop(payload) if err != nil { logger.Error("handleContactImages: failed to crop image.", zap.Error(err)) return } if parsed.Ring { colorHash, err := colorhash.GenerateFor(parsed.PublicKey) if err != nil { logger.Error("could not generate color hash") return } payload, err = ring.DrawRing(&ring.DrawRingParam{ Theme: parsed.Theme, ColorHash: colorHash, ImageBytes: payload, Height: width, Width: width, }) if err != nil { logger.Error("failed to draw ring for contact image.", zap.Error(err)) return } } if parsed.IndicatorSize != 0 { enlargeIndicatorRatio := float64(width / parsed.BgSize) payload, err = images.AddStatusIndicatorToImage(payload, parsed.IndicatorColor, parsed.IndicatorSize*enlargeIndicatorRatio, parsed.IndicatorBorder*enlargeIndicatorRatio) if err != nil { logger.Error("handleAccountImagesImpl: failed to draw status-indicator for initials", zap.Error(err)) return } } if len(payload) == 0 { logger.Error("empty image") return } mime, err := images.GetProtobufImageMime(payload) if err != nil { logger.Error("failed to get mime", zap.Error(err)) } w.Header().Set("Content-Type", mime) w.Header().Set("Cache-Control", "no-store") _, err = w.Write(payload) if err != nil { logger.Error("failed to write image", zap.Error(err)) } } } func ringEnabled(params url.Values) bool { addRings, ok := params["addRing"] return ok && len(addRings) == 1 && addRings[0] == "1" } func getTheme(params url.Values, logger *zap.Logger) ring.Theme { theme := ring.LightTheme // default themes, ok := params["theme"] if ok && len(themes) > 0 { t, err := strconv.Atoi(themes[0]) if err != nil { logger.Error("invalid param[theme], value: " + themes[0]) } else { theme = ring.Theme(t) } } return theme } func handleIdenticon(logger *zap.Logger) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { params := r.URL.Query() parsed := ParseImageParams(logger, params) if parsed.PublicKey == "" { logger.Error("no publicKey") return } identiconImage, err := identicon.Generate(parsed.PublicKey) if err != nil { logger.Error("could not generate identicon") } if identiconImage != nil && parsed.Ring { colorHash, err := colorhash.GenerateFor(parsed.PublicKey) if err != nil { logger.Error("could not generate color hash") return } identiconImage, err = ring.DrawRing(&ring.DrawRingParam{ Theme: parsed.Theme, ColorHash: colorHash, ImageBytes: identiconImage, Height: identicon.Height, Width: identicon.Width, }) if err != nil { logger.Error("failed to draw ring", zap.Error(err)) } } w.Header().Set("Content-Type", "image/png") w.Header().Set("Cache-Control", "max-age:290304000, public") w.Header().Set("Expires", time.Now().AddDate(60, 0, 0).Format(http.TimeFormat)) _, err = w.Write(identiconImage) if err != nil { logger.Error("failed to write image", zap.Error(err)) } } } func handleDiscordAuthorAvatar(db *sql.DB, logger *zap.Logger) http.HandlerFunc { if db == nil { return handleRequestDBMissing(logger) } return func(w http.ResponseWriter, r *http.Request) { params := r.URL.Query() parsed := ParseImageParams(logger, params) if parsed.AuthorID == "" { logger.Error("no authorIDs") return } var image []byte err := db.QueryRow(`SELECT avatar_image_payload FROM discord_message_authors WHERE id = ?`, parsed.AuthorID).Scan(&image) if err != nil { logger.Error("failed to find image", zap.Error(err)) return } if len(image) == 0 { logger.Error("empty image") return } mime, err := images.GetProtobufImageMime(image) if err != nil { logger.Error("failed to get mime", zap.Error(err)) } w.Header().Set("Content-Type", mime) w.Header().Set("Cache-Control", "no-store") _, err = w.Write(image) if err != nil { logger.Error("failed to write image", zap.Error(err)) } } } func handleDiscordAttachment(db *sql.DB, logger *zap.Logger) http.HandlerFunc { if db == nil { return handleRequestDBMissing(logger) } return func(w http.ResponseWriter, r *http.Request) { params := r.URL.Query() parsed := ParseImageParams(logger, params) if parsed.MessageID == "" { logger.Error("no messageID") return } if parsed.AttachmentID == "" { logger.Error("no attachmentID") return } var image []byte err := db.QueryRow(`SELECT payload FROM discord_message_attachments WHERE discord_message_id = ? AND id = ?`, parsed.MessageID, parsed.AttachmentID).Scan(&image) if err != nil { logger.Error("failed to find image", zap.Error(err)) return } if len(image) == 0 { logger.Error("empty image") return } mime, err := images.GetProtobufImageMime(image) if err != nil { logger.Error("failed to get mime", zap.Error(err)) } w.Header().Set("Content-Type", mime) w.Header().Set("Cache-Control", "no-store") _, err = w.Write(image) if err != nil { logger.Error("failed to write image", zap.Error(err)) } } } func handleImage(db *sql.DB, logger *zap.Logger) http.HandlerFunc { if db == nil { return handleRequestDBMissing(logger) } return func(w http.ResponseWriter, r *http.Request) { params := r.URL.Query() parsed := ParseImageParams(logger, params) if parsed.MessageID == "" { logger.Error("no messageID") return } var image []byte err := db.QueryRow(`SELECT image_payload FROM user_messages WHERE id = ?`, parsed.MessageID).Scan(&image) if err != nil { logger.Error("failed to find image", zap.Error(err)) return } if len(image) == 0 { logger.Error("empty image") return } mime, err := images.GetProtobufImageMime(image) if err != nil { logger.Error("failed to get mime", zap.Error(err)) } w.Header().Set("Content-Type", mime) w.Header().Set("Cache-Control", "no-store") _, err = w.Write(image) if err != nil { logger.Error("failed to write image", zap.Error(err)) } } } func handleAudio(db *sql.DB, logger *zap.Logger) http.HandlerFunc { if db == nil { return handleRequestDBMissing(logger) } return func(w http.ResponseWriter, r *http.Request) { params := r.URL.Query() parsed := ParseImageParams(logger, params) if parsed.MessageID == "" { logger.Error("no messageID") return } var audio []byte err := db.QueryRow(`SELECT audio_payload FROM user_messages WHERE id = ?`, parsed.MessageID).Scan(&audio) if err != nil { logger.Error("failed to find image", zap.Error(err)) return } if len(audio) == 0 { logger.Error("empty audio") return } w.Header().Set("Content-Type", "audio/aac") w.Header().Set("Cache-Control", "no-store") _, err = w.Write(audio) if err != nil { logger.Error("failed to write audio", zap.Error(err)) } } } func handleIPFS(downloader *ipfs.Downloader, logger *zap.Logger) http.HandlerFunc { if downloader == nil { return handleRequestDownloaderMissing(logger) } return func(w http.ResponseWriter, r *http.Request) { params := r.URL.Query() parsed := ParseImageParams(logger, params) if parsed.Hash == "" { logger.Error("no hash") return } content, err := downloader.Get(parsed.Hash, parsed.Download) if err != nil { logger.Error("could not download hash", zap.Error(err)) return } w.Header().Set("Cache-Control", "max-age:290304000, public") w.Header().Set("Expires", time.Now().AddDate(60, 0, 0).Format(http.TimeFormat)) _, err = w.Write(content) if err != nil { logger.Error("failed to write ipfs resource", zap.Error(err)) } } } func handleQRCodeGeneration(multiaccountsDB *multiaccounts.Database, logger *zap.Logger) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { params := r.URL.Query() payload := generateQRBytes(params, logger, multiaccountsDB) mime, err := images.GetProtobufImageMime(payload) if err != nil { logger.Error("could not generate image from payload", zap.Error(err)) } w.Header().Set("Content-Type", mime) w.Header().Set("Cache-Control", "no-store") _, err = w.Write(payload) if err != nil { logger.Error("failed to write image", zap.Error(err)) } } } func getThumbnailPayload(db *sql.DB, logger *zap.Logger, msgID string, thumbnailURL string) ([]byte, error) { var payload []byte var result []byte err := db.QueryRow(`SELECT unfurled_links FROM user_messages WHERE id = ?`, msgID).Scan(&result) if err != nil { return payload, fmt.Errorf("could not find message with message-id '%s': %w", msgID, err) } var links []*protobuf.UnfurledLink err = json.Unmarshal(result, &links) if err != nil { return payload, fmt.Errorf("failed to unmarshal protobuf.UrlPreview: %w", err) } for _, p := range links { if p.Url == thumbnailURL { payload = p.ThumbnailPayload break } } return payload, nil } func handleLinkPreviewThumbnail(db *sql.DB, logger *zap.Logger) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { params := r.URL.Query() parsed := ParseImageParams(logger, params) if parsed.MessageID == "" { http.Error(w, "missing query parameter 'message-id'", http.StatusBadRequest) return } if parsed.URL == "" { http.Error(w, "missing query parameter 'url'", http.StatusBadRequest) return } thumbnail, err := getThumbnailPayload(db, logger, parsed.MessageID, parsed.URL) if err != nil { logger.Error("failed to get thumbnail", zap.String("msgID", parsed.MessageID)) http.Error(w, "failed to get thumbnail", http.StatusInternalServerError) return } mimeType, err := images.GetMimeType(thumbnail) if err != nil { http.Error(w, "mime type not supported", http.StatusNotImplemented) return } w.Header().Set("Content-Type", "image/"+mimeType) w.Header().Set("Cache-Control", "no-store") _, err = w.Write(thumbnail) if err != nil { logger.Error("failed to write response", zap.Error(err)) } } }