check domain blocks way earlier on

internal/visibility/statusvisible.go

@@ -2,7 +2,6 @@ package visibility
 
 import (
 	"errors"
-	"net/url"
 
 	"fmt"
 
@@ -17,21 +16,23 @@ func (f *filter) StatusVisible(targetStatus *gtsmodel.Status, requestingAccount
 		"statusID": targetStatus.ID,
 	})
 
-	uri, err := url.Parse(targetStatus.URI)
-	if err != nil {
-		return false, fmt.Errorf("StatusVisible: error parsing uri: %s", targetStatus.URI)
-	}
-	if blocked, err := f.blockedDomain(uri.Host); blocked || err != nil {
-		l.Debugf("domain %s is blocked", uri.Host)
-		return blocked, err
-	}
-aaaaaaaaaa
 	relevantAccounts, err := f.pullRelevantAccountsFromStatus(targetStatus)
 	if err != nil {
 		l.Debugf("error pulling relevant accounts for status %s: %s", targetStatus.ID, err)
+		return false, fmt.Errorf("error pulling relevant accounts for status %s: %s", targetStatus.ID, err)
 	}
-	targetAccount := relevantAccounts.StatusAuthor
 
+	domainBlocked, err := f.blockedRelevant(relevantAccounts)
+	if err != nil {
+		l.Debugf("error checking domain block: %s", err)
+		return false, fmt.Errorf("error checking domain block: %s", err)
+	}
+
+	if domainBlocked {
+		return false, nil
+	}
+
+	targetAccount := relevantAccounts.StatusAuthor
 	// if target account is suspended then don't show the status
 	if !targetAccount.SuspendedAt.IsZero() {
 		l.Trace("target account suspended at is not zero")

internal/visibility/util.go

@@ -81,6 +81,7 @@ type relevantAccounts struct {
 	MentionedAccounts     []*gtsmodel.Account
 }
 
+// blockedDomain checks whether the given domain is blocked by us or not
 func (f *filter) blockedDomain(host string) (bool, error) {
 	b := &gtsmodel.DomainBlock{}
 	err := f.db.GetWhere([]db.Where{{Key: "domain", Value: host, CaseInsensitive: true}}, b)
@@ -97,3 +98,59 @@ func (f *filter) blockedDomain(host string) (bool, error) {
 	// there's an actual error
 	return false, err
 }
+
+// blockedRelevant checks through all relevant accounts attached to a status
+// to make sure none of them are domain blocked by this instance.
+func (f *filter) blockedRelevant(r *relevantAccounts) (bool, error) {
+	if r.StatusAuthor != nil {
+		b, err := f.blockedDomain(r.StatusAuthor.Domain)
+		if err != nil {
+			return false, err
+		}
+		if b {
+			return true, nil
+		}
+	}
+
+	if r.ReplyToAccount != nil {
+		b, err := f.blockedDomain(r.ReplyToAccount.Domain)
+		if err != nil {
+			return false, err
+		}
+		if b {
+			return true, nil
+		}
+	}
+
+	if r.BoostedAccount != nil {
+		b, err := f.blockedDomain(r.BoostedAccount.Domain)
+		if err != nil {
+			return false, err
+		}
+		if b {
+			return true, nil
+		}
+	}
+
+	if r.BoostedReplyToAccount != nil {
+		b, err := f.blockedDomain(r.BoostedReplyToAccount.Domain)
+		if err != nil {
+			return false, err
+		}
+		if b {
+			return true, nil
+		}
+	}
+
+	for _, a := range r.MentionedAccounts {
+		b, err := f.blockedDomain(a.Domain)
+		if err != nil {
+			return false, err
+		}
+		if b {
+			return true, nil
+		}
+	}
+
+	return false, nil
+}