status-im/status-go

package server

import (
    "database/sql"
    "encoding/json"
    "fmt"
    "net/http"

    "github.com/golang/protobuf/proto"
    "go.uber.org/zap"

    "github.com/status-im/status-go/images"
    "github.com/status-im/status-go/protocol/common"
    "github.com/status-im/status-go/protocol/protobuf"
)

func getUnfurledLinksFromDB(db *sql.DB, msgID string) ([]*protobuf.UnfurledLink, error) {
    var result []byte
    err := db.QueryRow(`SELECT unfurled_links FROM user_messages WHERE id = ?`, msgID).Scan(&result)
    if err != nil {
        return nil, 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 nil, fmt.Errorf("failed to unmarshal protobuf.UrlPreview: %w", err)
    }
    return links, nil
}

func getThumbnailPayload(db *sql.DB, msgID string, thumbnailURL string) ([]byte, error) {
    var payload []byte

    var links, err = getUnfurledLinksFromDB(db, msgID)
    if err != nil {
        return nil, err
    }

    for _, p := range links {
        if p.Url == thumbnailURL {
            payload = p.ThumbnailPayload
            break
        }
    }

    return payload, nil
}

func getFaviconPayload(db *sql.DB, msgID string, faviconURL string) ([]byte, error) {
    var payload []byte

    var links, err = getUnfurledLinksFromDB(db, msgID)
    if err != nil {
        return nil, err
    }

    for _, p := range links {
        if p.Url == faviconURL {
            payload = p.FaviconPayload
            break
        }
    }

    return payload, nil
}

func validateAndReturnImageParams(r *http.Request, w http.ResponseWriter, logger *zap.Logger) ImageParams {
    params := r.URL.Query()
    parsed := ParseImageParams(logger, params)

    if parsed.MessageID == "" {
        http.Error(w, "missing query parameter 'message-id'", http.StatusBadRequest)
        return ImageParams{}
    }

    if parsed.URL == "" {
        http.Error(w, "missing query parameter 'url'", http.StatusBadRequest)
        return ImageParams{}
    }
    return parsed
}

func getMimeTypeAndWriteImage(w http.ResponseWriter, logger *zap.Logger, imagePayload []byte) {
    mimeType, err := images.GetMimeType(imagePayload)
    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(imagePayload)
    if err != nil {
        logger.Error("failed to write response", zap.Error(err))
    }
}

func checkForFetchImageError(err error, logger *zap.Logger, parsedImageParams ImageParams, w http.ResponseWriter, imageType string) {
    if err != nil {
        logger.Error("failed to get "+imageType, zap.String("msgID", parsedImageParams.MessageID))
        http.Error(w, "failed to get "+imageType, http.StatusInternalServerError)
        return
    }
}

func handleLinkPreviewThumbnail(db *sql.DB, logger *zap.Logger) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        parsed := validateAndReturnImageParams(r, w, logger)
        if parsed.URL != "" {
            thumbnail, err := getThumbnailPayload(db, parsed.MessageID, parsed.URL)
            checkForFetchImageError(err, logger, parsed, w, "thumbnail")
            getMimeTypeAndWriteImage(w, logger, thumbnail)
        }
    }
}

func handleLinkPreviewFavicon(db *sql.DB, logger *zap.Logger) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        parsed := validateAndReturnImageParams(r, w, logger)
        if parsed.URL != "" {
            favicon, err := getFaviconPayload(db, parsed.MessageID, parsed.URL)
            checkForFetchImageError(err, logger, parsed, w, "favicon")
            getMimeTypeAndWriteImage(w, logger, favicon)
        }
    }
}

func getStatusLinkPreviewImage(p *protobuf.UnfurledStatusLink, imageID common.MediaServerImageID) ([]byte, error) {

    switch imageID {
    case common.MediaServerContactIcon:
        contact := p.GetContact()
        if contact == nil {
            return nil, fmt.Errorf("this is not a contact link")
        }
        if contact.Icon == nil {
            return nil, fmt.Errorf("contact icon is empty")
        }
        return contact.Icon.Payload, nil

    case common.MediaServerCommunityIcon:
        community := p.GetCommunity()
        if community == nil {
            return nil, fmt.Errorf("this is not a community link")
        }
        if community.Icon == nil {
            return nil, fmt.Errorf("community icon is empty")
        }
        return community.Icon.Payload, nil

    case common.MediaServerCommunityBanner:
        community := p.GetCommunity()
        if community == nil {
            return nil, fmt.Errorf("this is not a community link")
        }
        if community.Banner == nil {
            return nil, fmt.Errorf("community banner is empty")
        }
        return community.Banner.Payload, nil

    case common.MediaServerChannelCommunityIcon:
        channel := p.GetChannel()
        if channel == nil {
            return nil, fmt.Errorf("this is not a community channel link")
        }
        if channel.Community == nil {
            return nil, fmt.Errorf("channel community is empty")
        }
        if channel.Community.Icon == nil {
            return nil, fmt.Errorf("channel community icon is empty")
        }
        return channel.Community.Icon.Payload, nil

    case common.MediaServerChannelCommunityBanner:
        channel := p.GetChannel()
        if channel == nil {
            return nil, fmt.Errorf("this is not a community channel link")
        }
        if channel.Community == nil {
            return nil, fmt.Errorf("channel community is empty")
        }
        if channel.Community.Banner == nil {
            return nil, fmt.Errorf("channel community banner is empty")
        }
        return channel.Community.Banner.Payload, nil
    }

    return nil, fmt.Errorf("value not supported")
}

func getStatusLinkPreviewThumbnail(db *sql.DB, messageID string, URL string, imageID common.MediaServerImageID) ([]byte, int, error) {
    var messageLinks []byte
    err := db.QueryRow(`SELECT unfurled_status_links FROM user_messages WHERE id = ?`, messageID).Scan(&messageLinks)
    if err != nil {
        return nil, http.StatusBadRequest, fmt.Errorf("could not find message with message-id '%s': %w", messageID, err)
    }

    var links protobuf.UnfurledStatusLinks
    err = proto.Unmarshal(messageLinks, &links)
    if err != nil {
        return nil, http.StatusInternalServerError, fmt.Errorf("failed to unmarshal protobuf.UrlPreview: %w", err)
    }

    for _, p := range links.UnfurledStatusLinks {
        if p.Url == URL {
            thumbnailPayload, err := getStatusLinkPreviewImage(p, imageID)
            if err != nil {
                return nil, http.StatusBadRequest, fmt.Errorf("invalid query parameter 'image-id' value: %w", err)
            }
            return thumbnailPayload, http.StatusOK, nil
        }
    }

    return nil, http.StatusBadRequest, fmt.Errorf("no link preview found for given url")
}

func handleStatusLinkPreviewThumbnail(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
        }

        if parsed.ImageID == "" {
            http.Error(w, "missing query parameter 'image-id'", http.StatusBadRequest)
            return
        }

        thumbnail, httpsStatusCode, err := getStatusLinkPreviewThumbnail(db, parsed.MessageID, parsed.URL, common.MediaServerImageID(parsed.ImageID))
        if err != nil {
            http.Error(w, err.Error(), httpsStatusCode)
            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))
        }
    }
}