Move outbound fed invite into gmsl function

federationapi/api/api.go

@@ -62,7 +62,7 @@ type RoomserverFederationAPI interface {
 	// Handle an instruction to make_leave & send_leave with a remote server.
 	PerformLeave(ctx context.Context, request *PerformLeaveRequest, response *PerformLeaveResponse) error
 	// Handle sending an invite to a remote server.
-	PerformInvite(ctx context.Context, request *PerformInviteRequest, response *PerformInviteResponse) error
+	SendInvite(ctx context.Context, event gomatrixserverlib.PDU, strippedState []gomatrixserverlib.InviteStrippedState) (gomatrixserverlib.PDU, error)
 	// Handle an instruction to peek a room on a remote server.
 	PerformOutboundPeek(ctx context.Context, request *PerformOutboundPeekRequest, response *PerformOutboundPeekResponse) error
 	// Query the server names of the joined hosts in a room.

federationapi/internal/perform.go

@@ -503,60 +503,59 @@ func (r *FederationInternalAPI) PerformLeave(
 	)
 }
 
-// PerformInvite implements api.FederationInternalAPI
+// SendInvite implements api.FederationInternalAPI
-func (r *FederationInternalAPI) PerformInvite(
+func (r *FederationInternalAPI) SendInvite(
 	ctx context.Context,
-	request *api.PerformInviteRequest,
+	event gomatrixserverlib.PDU,
-	response *api.PerformInviteResponse,
+	strippedState []gomatrixserverlib.InviteStrippedState,
-) (err error) {
+) (gomatrixserverlib.PDU, error) {
-	_, origin, err := r.cfg.Matrix.SplitLocalID('@', request.Event.Sender())
+	_, origin, err := r.cfg.Matrix.SplitLocalID('@', event.Sender())
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	if request.Event.StateKey() == nil {
+	if event.StateKey() == nil {
-		return errors.New("invite must be a state event")
+		return nil, errors.New("invite must be a state event")
 	}
 
-	_, destination, err := gomatrixserverlib.SplitID('@', *request.Event.StateKey())
+	_, destination, err := gomatrixserverlib.SplitID('@', *event.StateKey())
 	if err != nil {
-		return fmt.Errorf("gomatrixserverlib.SplitID: %w", err)
+		return nil, fmt.Errorf("gomatrixserverlib.SplitID: %w", err)
 	}
 
 	// TODO (devon): This should be allowed via a relay. Currently only transactions
 	// can be sent to relays. Would need to extend relays to handle invites.
 	if !r.shouldAttemptDirectFederation(destination) {
-		return fmt.Errorf("relay servers have no meaningful response for invite.")
+		return nil, fmt.Errorf("relay servers have no meaningful response for invite.")
 	}
 
 	logrus.WithFields(logrus.Fields{
-		"event_id":     request.Event.EventID(),
+		"event_id":     event.EventID(),
-		"user_id":      *request.Event.StateKey(),
+		"user_id":      *event.StateKey(),
-		"room_id":      request.Event.RoomID(),
+		"room_id":      event.RoomID(),
-		"room_version": request.RoomVersion,
+		"room_version": event.Version(),
 		"destination":  destination,
 	}).Info("Sending invite")
 
-	inviteReq, err := fclient.NewInviteV2Request(request.Event.PDU, request.InviteRoomState)
+	inviteReq, err := fclient.NewInviteV2Request(event, strippedState)
 	if err != nil {
-		return fmt.Errorf("gomatrixserverlib.NewInviteV2Request: %w", err)
+		return nil, fmt.Errorf("gomatrixserverlib.NewInviteV2Request: %w", err)
 	}
 
 	inviteRes, err := r.federation.SendInviteV2(ctx, origin, destination, inviteReq)
 	if err != nil {
-		return fmt.Errorf("r.federation.SendInviteV2: failed to send invite: %w", err)
+		return nil, fmt.Errorf("r.federation.SendInviteV2: failed to send invite: %w", err)
 	}
-	verImpl, err := gomatrixserverlib.GetRoomVersion(request.RoomVersion)
+	verImpl, err := gomatrixserverlib.GetRoomVersion(event.Version())
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	inviteEvent, err := verImpl.NewEventFromUntrustedJSON(inviteRes.Event)
 	if err != nil {
-		return fmt.Errorf("r.federation.SendInviteV2 failed to decode event response: %w", err)
+		return nil, fmt.Errorf("r.federation.SendInviteV2 failed to decode event response: %w", err)
 	}
-	response.Event = &types.HeaderedEvent{PDU: inviteEvent}
+	return inviteEvent, nil
-	return nil
 }
 
 // PerformServersAlive implements api.FederationInternalAPI

federationapi/routing/invite.go

@@ -85,7 +85,7 @@ func InviteV2(
 			PrivateKey:            cfg.Matrix.PrivateKey,
 			Verifier:              keys,
 			InviteQuerier:         rsAPI,
-			MembershipQuerier:     &MembershipQuerier{roomserver: rsAPI},
+			MembershipQuerier:     &api.MembershipQuerier{Roomserver: rsAPI},
 			GenerateStrippedState: rsAPI.GenerateInviteStrippedState,
 			InviteEvent:           inviteReq.Event(),
 			StrippedState:         inviteReq.InviteRoomState(),
@@ -170,7 +170,7 @@ func InviteV1(
 		PrivateKey:            cfg.Matrix.PrivateKey,
 		Verifier:              keys,
 		InviteQuerier:         rsAPI,
-		MembershipQuerier:     &MembershipQuerier{roomserver: rsAPI},
+		MembershipQuerier:     &api.MembershipQuerier{Roomserver: rsAPI},
 		GenerateStrippedState: rsAPI.GenerateInviteStrippedState,
 		InviteEvent:           event,
 		StrippedState:         strippedState,

federationapi/routing/join.go

@@ -216,25 +216,6 @@ func MakeJoin(
 	}
 }
 
-type MembershipQuerier struct {
-	roomserver api.FederationRoomserverAPI
-}
-
-func (mq *MembershipQuerier) CurrentMembership(ctx context.Context, roomID spec.RoomID, userID spec.UserID) (string, error) {
-	req := api.QueryMembershipForUserRequest{
-		RoomID: roomID.String(),
-		UserID: userID.String(),
-	}
-	res := api.QueryMembershipForUserResponse{}
-	err := mq.roomserver.QueryMembershipForUser(ctx, &req, &res)
-
-	membership := ""
-	if err == nil {
-		membership = res.Membership
-	}
-	return membership, err
-}
-
 // SendJoin implements the /send_join API
 // The make-join send-join dance makes much more sense as a single
 // flow so the cyclomatic complexity is high:
@@ -268,7 +249,7 @@ func SendJoin(
 		KeyID:             cfg.Matrix.KeyID,
 		PrivateKey:        cfg.Matrix.PrivateKey,
 		Verifier:          keys,
-		MembershipQuerier: &MembershipQuerier{roomserver: rsAPI},
+		MembershipQuerier: &api.MembershipQuerier{Roomserver: rsAPI},
 	}
 	response, joinErr := gomatrixserverlib.HandleSendJoin(input)
 	switch e := joinErr.(type) {

roomserver/api/query.go

@@ -17,6 +17,7 @@
 package api
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"strings"
@@ -457,3 +458,22 @@ type QueryLeftUsersRequest struct {
 type QueryLeftUsersResponse struct {
 	LeftUsers []string `json:"user_ids"`
 }
+
+type MembershipQuerier struct {
+	Roomserver FederationRoomserverAPI
+}
+
+func (mq *MembershipQuerier) CurrentMembership(ctx context.Context, roomID spec.RoomID, userID spec.UserID) (string, error) {
+	req := QueryMembershipForUserRequest{
+		RoomID: roomID.String(),
+		UserID: userID.String(),
+	}
+	res := QueryMembershipForUserResponse{}
+	err := mq.Roomserver.QueryMembershipForUser(ctx, &req, &res)
+
+	membership := ""
+	if err == nil {
+		membership = res.Membership
+	}
+	return membership, err
+}

roomserver/internal/api.go

@@ -232,11 +232,7 @@ func (r *RoomserverInternalAPI) PerformInvite(
 	ctx context.Context,
 	req *api.PerformInviteRequest,
 ) error {
-	outputEvents, err := r.Inviter.PerformInvite(ctx, req)
+	return r.Inviter.PerformInvite(ctx, req)
-	if err != nil {
-		return err
-	}
-	return r.OutputProducer.ProduceRoomEvents(req.Event.RoomID(), outputEvents)
 }
 
 func (r *RoomserverInternalAPI) PerformLeave(

roomserver/internal/helpers/auth.go

@@ -83,15 +83,14 @@ func CheckForSoftFail(
 	return false, nil
 }
 
-// CheckAuthEvents checks that the event passes authentication checks
+// GetAuthEvents returns the numeric IDs for the auth events.
-// Returns the numeric IDs for the auth events.
+func GetAuthEvents(
-func CheckAuthEvents(
 	ctx context.Context,
 	db storage.RoomDatabase,
 	roomVersion gomatrixserverlib.RoomVersion,
-	event *types.HeaderedEvent,
+	event gomatrixserverlib.PDU,
 	authEventIDs []string,
-) ([]types.EventNID, error) {
+) (gomatrixserverlib.AuthEventProvider, error) {
 	// Grab the numeric IDs for the supplied auth state events from the database.
 	authStateEntries, err := db.StateEntriesForEventIDs(ctx, authEventIDs, true)
 	if err != nil {
@@ -100,25 +99,14 @@ func CheckAuthEvents(
 	authStateEntries = types.DeduplicateStateEntries(authStateEntries)
 
 	// Work out which of the state events we actually need.
-	stateNeeded := gomatrixserverlib.StateNeededForAuth([]gomatrixserverlib.PDU{event.PDU})
+	stateNeeded := gomatrixserverlib.StateNeededForAuth([]gomatrixserverlib.PDU{event})
 
 	// Load the actual auth events from the database.
 	authEvents, err := loadAuthEvents(ctx, db, roomVersion, stateNeeded, authStateEntries)
 	if err != nil {
 		return nil, fmt.Errorf("loadAuthEvents: %w", err)
 	}
-
+	return &authEvents, nil
-	// Check if the event is allowed.
-	if err = gomatrixserverlib.Allowed(event.PDU, &authEvents); err != nil {
-		return nil, err
-	}
-
-	// Return the numeric IDs for the auth events.
-	result := make([]types.EventNID, len(authStateEntries))
-	for i := range authStateEntries {
-		result[i] = authStateEntries[i].EventNID
-	}
-	return result, nil
 }
 
 type authEvents struct {

roomserver/internal/perform/perform_invite.go

@@ -110,40 +110,114 @@ func (r *Inviter) ProcessInviteMembership(
 	return outputUpdates, nil
 }
 
+type QueryState struct {
+	storage.Database
+}
+
+func (q *QueryState) GetAuthEvents(ctx context.Context, event gomatrixserverlib.PDU) (gomatrixserverlib.AuthEventProvider, error) {
+	return helpers.GetAuthEvents(ctx, q.Database, event.Version(), event, event.AuthEventIDs())
+}
+
 // nolint:gocyclo
 func (r *Inviter) PerformInvite(
 	ctx context.Context,
 	req *api.PerformInviteRequest,
-) ([]api.OutputEvent, error) {
+) error {
-	var outputUpdates []api.OutputEvent
 	event := req.Event
+
+	sender, err := spec.NewUserID(event.Sender(), true)
+	if err != nil {
+		return spec.InvalidParam("The user ID is invalid")
+	}
+	if !r.Cfg.Matrix.IsLocalServerName(sender.Domain()) {
+		return api.ErrInvalidID{Err: fmt.Errorf("the invite must be from a local user")}
+	}
+
 	if event.StateKey() == nil {
-		return nil, fmt.Errorf("invite must be a state event")
+		return fmt.Errorf("invite must be a state event")
 	}
-	_, senderDomain, err := gomatrixserverlib.SplitID('@', event.Sender())
+	invitedUser, err := spec.NewUserID(*event.StateKey(), true)
 	if err != nil {
-		return nil, fmt.Errorf("sender %q is invalid", event.Sender())
+		return spec.InvalidParam("The user ID is invalid")
 	}
+	isTargetLocal := r.Cfg.Matrix.IsLocalServerName(invitedUser.Domain())
 
-	roomID := event.RoomID()
+	validRoomID, err := spec.NewRoomID(event.RoomID())
-	targetUserID := *event.StateKey()
-
-	_, domain, err := gomatrixserverlib.SplitID('@', targetUserID)
 	if err != nil {
-		return nil, api.ErrInvalidID{Err: fmt.Errorf("the user ID %s is invalid", targetUserID)}
+		return err
-	}
-	isTargetLocal := r.Cfg.Matrix.IsLocalServerName(domain)
-	isOriginLocal := r.Cfg.Matrix.IsLocalServerName(senderDomain)
-	if !isOriginLocal {
-		return nil, api.ErrInvalidID{Err: fmt.Errorf("the invite must be from a local user")}
 	}
 
-	validRoomID, err := spec.NewRoomID(roomID)
+	input := PerformInviteInput{
+		Context:               ctx,
+		RoomID:                *validRoomID,
+		Event:                 event.PDU,
+		InvitedUser:           *invitedUser,
+		IsTargetLocal:         isTargetLocal,
+		StrippedState:         req.InviteRoomState,
+		MembershipQuerier:     &api.MembershipQuerier{Roomserver: r.RSAPI},
+		StateQuerier:          &QueryState{r.DB},
+		GenerateStrippedState: r.GenerateInviteStrippedState,
+	}
+	inviteEvent, err := PerformInvite(input, r.FSAPI)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	inviteState := req.InviteRoomState
+	// Use the returned event if there was one (due to federation), otherwise
+	// send the original invite event to the roomserver.
+	if inviteEvent == nil {
+		inviteEvent = event
+	}
+
+	// Send the invite event to the roomserver input stream. This will
+	// notify existing users in the room about the invite, update the
+	// membership table and ensure that the event is ready and available
+	// to use as an auth event when accepting the invite.
+	// It will NOT notify the invitee of this invite.
+	inputReq := &api.InputRoomEventsRequest{
+		InputRoomEvents: []api.InputRoomEvent{
+			{
+				Kind:         api.KindNew,
+				Event:        &types.HeaderedEvent{PDU: inviteEvent},
+				Origin:       sender.Domain(),
+				SendAsServer: req.SendAsServer,
+			},
+		},
+	}
+	inputRes := &api.InputRoomEventsResponse{}
+	r.Inputer.InputRoomEvents(context.Background(), inputReq, inputRes)
+	if err := inputRes.Err(); err != nil {
+		util.GetLogger(ctx).WithField("event_id", event.EventID()).Error("r.InputRoomEvents failed")
+		return api.ErrNotAllowed{Err: err}
+	}
+
+	return nil
+}
+
+// TODO: Move to gmsl
+
+type StateQuerier interface {
+	GetAuthEvents(ctx context.Context, event gomatrixserverlib.PDU) (gomatrixserverlib.AuthEventProvider, error)
+}
+
+type PerformInviteInput struct {
+	Context               context.Context
+	RoomID                spec.RoomID
+	Event                 gomatrixserverlib.PDU
+	InvitedUser           spec.UserID
+	IsTargetLocal         bool
+	StrippedState         []gomatrixserverlib.InviteStrippedState
+	MembershipQuerier     gomatrixserverlib.MembershipQuerier
+	StateQuerier          StateQuerier
+	GenerateStrippedState func(ctx context.Context, roomID spec.RoomID, stateWanted []gomatrixserverlib.StateKeyTuple, inviteEvent gomatrixserverlib.PDU) ([]gomatrixserverlib.InviteStrippedState, error)
+}
+
+type FederatedInviteClient interface {
+	SendInvite(ctx context.Context, event gomatrixserverlib.PDU, strippedState []gomatrixserverlib.InviteStrippedState) (gomatrixserverlib.PDU, error)
+}
+
+func PerformInvite(input PerformInviteInput, fedClient FederatedInviteClient) (gomatrixserverlib.PDU, error) {
+	inviteState := input.StrippedState
 	if len(inviteState) == 0 {
 		// "If they are set on the room, at least the state for m.room.avatar, m.room.canonical_alias, m.room.join_rules, and m.room.name SHOULD be included."
 		// https://matrix.org/docs/spec/client_server/r0.6.0#m-room-member
@@ -158,47 +232,45 @@ func (r *Inviter) PerformInvite(
 				StateKey:  "",
 			})
 		}
-		if is, generateErr := r.GenerateInviteStrippedState(ctx, *validRoomID, stateWanted, req.Event); generateErr == nil {
+		if is, generateErr := input.GenerateStrippedState(input.Context, input.RoomID, stateWanted, input.Event); generateErr == nil {
 			inviteState = is
 		} else {
-			util.GetLogger(ctx).WithError(generateErr).Error("failed querying known room")
+			util.GetLogger(input.Context).WithError(generateErr).Error("failed querying known room")
 			return nil, spec.InternalServerError{}
 		}
 	}
 
-	logger := util.GetLogger(ctx).WithFields(map[string]interface{}{
+	logger := util.GetLogger(input.Context).WithFields(map[string]interface{}{
-		"inviter":  event.Sender(),
+		"inviter":  input.Event.Sender(),
-		"invitee":  *event.StateKey(),
+		"invitee":  *input.Event.StateKey(),
-		"room_id":  roomID,
+		"room_id":  input.RoomID.String(),
-		"event_id": event.EventID(),
+		"event_id": input.Event.EventID(),
 	})
 	logger.WithFields(log.Fields{
-		"room_version": req.RoomVersion,
+		"room_version": input.Event.Version(),
-		"target_local": isTargetLocal,
+		"target_local": input.IsTargetLocal,
 		"origin_local": true,
 	}).Debug("processing invite event")
 
 	if len(inviteState) == 0 {
-		if err = event.SetUnsignedField("invite_room_state", struct{}{}); err != nil {
+		if err := input.Event.SetUnsignedField("invite_room_state", struct{}{}); err != nil {
 			return nil, fmt.Errorf("event.SetUnsignedField: %w", err)
 		}
 	} else {
-		if err = event.SetUnsignedField("invite_room_state", inviteState); err != nil {
+		if err := input.Event.SetUnsignedField("invite_room_state", inviteState); err != nil {
 			return nil, fmt.Errorf("event.SetUnsignedField: %w", err)
 		}
 	}
 
-	membershipReq := api.QueryMembershipForUserRequest{
+	membership, err := input.MembershipQuerier.CurrentMembership(input.Context, input.RoomID, input.InvitedUser)
-		RoomID: validRoomID.String(),
-		UserID: *event.StateKey(),
-	}
-	res := api.QueryMembershipForUserResponse{}
-	err = r.RSAPI.QueryMembershipForUser(ctx, &membershipReq, &res)
-
 	if err != nil {
-		return nil, fmt.Errorf("r.RSAPI.QueryMembershipForUser: %w", err)
+		util.GetLogger(input.Context).WithError(err).Error("failed getting user membership")
+		return nil, spec.InternalServerError{}
+
 	}
-	if res.Membership == spec.Join {
+	isAlreadyJoined := (membership == spec.Join)
+
+	if isAlreadyJoined {
 		// If the user is joined to the room then that takes precedence over this
 		// invite event. It makes little sense to move a user that is already
 		// joined to the room into the invite state.
@@ -234,57 +306,34 @@ func (r *Inviter) PerformInvite(
 	// try and see if the user is allowed to make this invite. We can't do
 	// this for invites coming in over federation - we have to take those on
 	// trust.
-	_, err = helpers.CheckAuthEvents(ctx, r.DB, req.RoomVersion, event, event.AuthEventIDs())
+	authEventProvider, err := input.StateQuerier.GetAuthEvents(input.Context, input.Event)
 	if err != nil {
-		logger.WithError(err).WithField("event_id", event.EventID()).WithField("auth_event_ids", event.AuthEventIDs()).Error(
+		logger.WithError(err).WithField("event_id", input.Event.EventID()).WithField("auth_event_ids", input.Event.AuthEventIDs()).Error(
-			"ProcessInviteEvent.checkAuthEvents failed for event",
+			"ProcessInvite.getAuthEvents failed for event",
 		)
 		return nil, api.ErrNotAllowed{Err: err}
 	}
-	// TODO: Move everything above here to gmsl (including fed call?)
 
-	// If the invite originated from us and the target isn't local then we
+	// Check if the event is allowed.
-	// should try and send the invite over federation first. It might be
+	if err = gomatrixserverlib.Allowed(input.Event, authEventProvider); err != nil {
-	// that the remote user doesn't exist, in which case we can give up
+		logger.WithError(err).WithField("event_id", input.Event.EventID()).WithField("auth_event_ids", input.Event.AuthEventIDs()).Error(
-	// processing here.
+			"ProcessInvite: event not allowed",
-	if req.SendAsServer != api.DoNotSendToOtherServers && !isTargetLocal {
+		)
-		fsReq := &federationAPI.PerformInviteRequest{
-			RoomVersion:     req.RoomVersion,
-			Event:           event,
-			InviteRoomState: inviteState,
-		}
-		fsRes := &federationAPI.PerformInviteResponse{}
-		if err = r.FSAPI.PerformInvite(ctx, fsReq, fsRes); err != nil {
-			logger.WithError(err).WithField("event_id", event.EventID()).Error("r.FSAPI.PerformInvite failed")
-			return nil, api.ErrNotAllowed{Err: err}
-		}
-		event = fsRes.Event
-		logger.Debugf("Federated PerformInvite success with event ID %s", event.EventID())
-	}
-
-	// Send the invite event to the roomserver input stream. This will
-	// notify existing users in the room about the invite, update the
-	// membership table and ensure that the event is ready and available
-	// to use as an auth event when accepting the invite.
-	// It will NOT notify the invitee of this invite.
-	inputReq := &api.InputRoomEventsRequest{
-		InputRoomEvents: []api.InputRoomEvent{
-			{
-				Kind:         api.KindNew,
-				Event:        event,
-				Origin:       senderDomain,
-				SendAsServer: req.SendAsServer,
-			},
-		},
-	}
-	inputRes := &api.InputRoomEventsResponse{}
-	r.Inputer.InputRoomEvents(context.Background(), inputReq, inputRes)
-	if err = inputRes.Err(); err != nil {
-		logger.WithError(err).WithField("event_id", event.EventID()).Error("r.InputRoomEvents failed")
 		return nil, api.ErrNotAllowed{Err: err}
 	}
 
-	// Don't notify the sync api of this event in the same way as a federated invite so the invitee
+	// If the target isn't local then we should try and send the invite
-	// gets the invite, as the roomserver will do this when it processes the m.room.member invite.
+	// over federation first. It might be that the remote user doesn't exist,
-	return outputUpdates, nil
+	// in which case we can give up processing here.
+	var inviteEvent gomatrixserverlib.PDU
+	if !input.IsTargetLocal {
+		inviteEvent, err = fedClient.SendInvite(input.Context, input.Event, inviteState)
+		if err != nil {
+			logger.WithError(err).WithField("event_id", input.Event.EventID()).Error("fedClient.SendInvite failed")
+			return nil, api.ErrNotAllowed{Err: err}
+		}
+		logger.Debugf("Federated SendInvite success with event ID %s", input.Event.EventID())
+	}
+
+	return inviteEvent, nil
 }