Fetch missing auth events, implement QueryMissingAuthPrevEvents, try other servers in room for /event and /get_missing_events (#1450)

* Try to ask other servers in the room for missing events if the origin won't provide them

* Logging

* More logging

* Implement QueryMissingAuthPrevEvents

* Try to get missing auth events badly

* Use processEvent

* Logging

* Update QueryMissingAuthPrevEvents

* Try to find missing auth events

* Patchy fix for test

* Logging tweaks

* Send auth events as outliers

* Update check in QueryMissingAuthPrevEvents

* Error responses

* More return codes

* Don't return error on reject/soft-fail since it was ultimately handled

* More tweaks

* More error tweaks

roomserver/internal/helpers/auth.go

@@ -83,7 +83,7 @@ func CheckForSoftFail(
 	// Check if the event is allowed.
 	if err = gomatrixserverlib.Allowed(event.Event, &authEvents); err != nil {
 		// return true, nil
-		return true, fmt.Errorf("gomatrixserverlib.Allowed: %w", err)
+		return true, err
 	}
 	return false, nil
 }
@@ -99,7 +99,7 @@ func CheckAuthEvents(
 	// Grab the numeric IDs for the supplied auth state events from the database.
 	authStateEntries, err := db.StateEntriesForEventIDs(ctx, authEventIDs)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("db.StateEntriesForEventIDs: %w", err)
 	}
 	authStateEntries = types.DeduplicateStateEntries(authStateEntries)
 
@@ -109,7 +109,7 @@ func CheckAuthEvents(
 	// Load the actual auth events from the database.
 	authEvents, err := loadAuthEvents(ctx, db, stateNeeded, authStateEntries)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("loadAuthEvents: %w", err)
 	}
 
 	// Check if the event is allowed.

roomserver/internal/input/input_events.go

@@ -49,7 +49,7 @@ func (r *Inputer) processRoomEvent(
 	isRejected := false
 	authEventNIDs, rejectionErr := helpers.CheckAuthEvents(ctx, r.DB, headered, input.AuthEventIDs)
 	if rejectionErr != nil {
-		logrus.WithError(rejectionErr).WithField("event_id", event.EventID()).WithField("auth_event_ids", input.AuthEventIDs).Error("processRoomEvent.checkAuthEvents failed for event, rejecting event")
+		logrus.WithError(rejectionErr).WithField("event_id", event.EventID()).WithField("auth_event_ids", input.AuthEventIDs).Error("helpers.CheckAuthEvents failed for event, rejecting event")
 		isRejected = true
 	}
 

roomserver/internal/perform/perform_invite.go

@@ -136,14 +136,10 @@ func (r *Inviter) PerformInvite(
 			log.WithError(err).WithField("event_id", event.EventID()).WithField("auth_event_ids", event.AuthEventIDs()).Error(
 				"processInviteEvent.checkAuthEvents failed for event",
 			)
-			if _, ok := err.(*gomatrixserverlib.NotAllowed); ok {
-				res.Error = &api.PerformError{
-					Msg:  err.Error(),
-					Code: api.PerformErrorNotAllowed,
-				}
-				return nil, nil
+			res.Error = &api.PerformError{
+				Msg:  err.Error(),
+				Code: api.PerformErrorNotAllowed,
 			}
-			return nil, fmt.Errorf("checkAuthEvents: %w", err)
 		}
 
 		// If the invite originated from us and the target isn't local then we
@@ -160,7 +156,7 @@ func (r *Inviter) PerformInvite(
 			if err = r.FSAPI.PerformInvite(ctx, fsReq, fsRes); err != nil {
 				res.Error = &api.PerformError{
 					Msg:  err.Error(),
-					Code: api.PerformErrorNoOperation,
+					Code: api.PerformErrorNotAllowed,
 				}
 				log.WithError(err).WithField("event_id", event.EventID()).Error("r.FSAPI.PerformInvite failed")
 				return nil, nil
@@ -185,7 +181,12 @@ func (r *Inviter) PerformInvite(
 		inputRes := &api.InputRoomEventsResponse{}
 		r.Inputer.InputRoomEvents(context.Background(), inputReq, inputRes)
 		if err = inputRes.Err(); err != nil {
-			return nil, fmt.Errorf("r.InputRoomEvents: %w", err)
+			res.Error = &api.PerformError{
+				Msg:  fmt.Sprintf("r.InputRoomEvents: %s", err.Error()),
+				Code: api.PerformErrorNotAllowed,
+			}
+			log.WithError(err).WithField("event_id", event.EventID()).Error("r.InputRoomEvents failed")
+			return nil, nil
 		}
 	} else {
 		// The invite originated over federation. Process the membership

roomserver/internal/perform/perform_join.go

@@ -249,14 +249,10 @@ func (r *Joiner) performJoinRoomByID(
 			inputRes := api.InputRoomEventsResponse{}
 			r.Inputer.InputRoomEvents(ctx, &inputReq, &inputRes)
 			if err = inputRes.Err(); err != nil {
-				var notAllowed *gomatrixserverlib.NotAllowed
-				if errors.As(err, &notAllowed) {
-					return "", &api.PerformError{
-						Code: api.PerformErrorNotAllowed,
-						Msg:  fmt.Sprintf("InputRoomEvents auth failed: %s", err),
-					}
+				return "", &api.PerformError{
+					Code: api.PerformErrorNotAllowed,
+					Msg:  fmt.Sprintf("InputRoomEvents auth failed: %s", err),
 				}
-				return "", fmt.Errorf("r.InputRoomEvents: %w", err)
 			}
 		}
 

roomserver/internal/query/query.go

@@ -98,6 +98,38 @@ func (r *Queryer) QueryStateAfterEvents(
 	return nil
 }
 
+// QueryMissingAuthPrevEvents implements api.RoomserverInternalAPI
+func (r *Queryer) QueryMissingAuthPrevEvents(
+	ctx context.Context,
+	request *api.QueryMissingAuthPrevEventsRequest,
+	response *api.QueryMissingAuthPrevEventsResponse,
+) error {
+	info, err := r.DB.RoomInfo(ctx, request.RoomID)
+	if err != nil {
+		return err
+	}
+	if info == nil {
+		return errors.New("room doesn't exist")
+	}
+
+	response.RoomExists = !info.IsStub
+	response.RoomVersion = info.RoomVersion
+
+	for _, authEventID := range request.AuthEventIDs {
+		if nids, err := r.DB.EventNIDs(ctx, []string{authEventID}); err != nil || len(nids) == 0 {
+			response.MissingAuthEventIDs = append(response.MissingAuthEventIDs, authEventID)
+		}
+	}
+
+	for _, prevEventID := range request.PrevEventIDs {
+		if nids, err := r.DB.EventNIDs(ctx, []string{prevEventID}); err != nil || len(nids) == 0 {
+			response.MissingPrevEventIDs = append(response.MissingPrevEventIDs, prevEventID)
+		}
+	}
+
+	return nil
+}
+
 // QueryEventsByID implements api.RoomserverInternalAPI
 func (r *Queryer) QueryEventsByID(
 	ctx context.Context,
@@ -255,19 +287,24 @@ func (r *Queryer) QueryServerJoinedToRoom(
 		return fmt.Errorf("r.DB.Events: %w", err)
 	}
 
+	servers := map[gomatrixserverlib.ServerName]struct{}{}
 	for _, e := range events {
 		if e.Type() == gomatrixserverlib.MRoomMember && e.StateKey() != nil {
 			_, serverName, err := gomatrixserverlib.SplitID('@', *e.StateKey())
 			if err != nil {
 				continue
 			}
+			servers[serverName] = struct{}{}
 			if serverName == request.ServerName {
 				response.IsInRoom = true
-				break
 			}
 		}
 	}
 
+	for server := range servers {
+		response.ServerNames = append(response.ServerNames, server)
+	}
+
 	return nil
 }