mirror of
https://github.com/matrix-org/dendrite.git
synced 2026-01-15 10:03:09 -06:00
340 lines
13 KiB
Go
340 lines
13 KiB
Go
// Copyright 2020 The Matrix.org Foundation C.I.C.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package perform
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
federationAPI "github.com/matrix-org/dendrite/federationapi/api"
|
|
"github.com/matrix-org/dendrite/roomserver/api"
|
|
"github.com/matrix-org/dendrite/roomserver/internal/helpers"
|
|
"github.com/matrix-org/dendrite/roomserver/internal/input"
|
|
"github.com/matrix-org/dendrite/roomserver/state"
|
|
"github.com/matrix-org/dendrite/roomserver/storage"
|
|
"github.com/matrix-org/dendrite/roomserver/storage/shared"
|
|
"github.com/matrix-org/dendrite/roomserver/types"
|
|
"github.com/matrix-org/dendrite/setup/config"
|
|
"github.com/matrix-org/gomatrixserverlib"
|
|
"github.com/matrix-org/gomatrixserverlib/spec"
|
|
"github.com/matrix-org/util"
|
|
log "github.com/sirupsen/logrus"
|
|
)
|
|
|
|
type Inviter struct {
|
|
DB storage.Database
|
|
Cfg *config.RoomServer
|
|
FSAPI federationAPI.RoomserverFederationAPI
|
|
RSAPI api.RoomserverInternalAPI
|
|
Inputer *input.Inputer
|
|
}
|
|
|
|
func (r *Inviter) IsKnownRoom(ctx context.Context, roomID spec.RoomID) (bool, error) {
|
|
info, err := r.DB.RoomInfo(ctx, roomID.String())
|
|
if err != nil {
|
|
return false, fmt.Errorf("failed to load RoomInfo: %w", err)
|
|
}
|
|
return (info != nil && !info.IsStub()), nil
|
|
}
|
|
|
|
func (r *Inviter) GenerateInviteStrippedState(
|
|
ctx context.Context, roomID spec.RoomID, stateWanted []gomatrixserverlib.StateKeyTuple, inviteEvent gomatrixserverlib.PDU,
|
|
) ([]gomatrixserverlib.InviteStrippedState, error) {
|
|
info, err := r.DB.RoomInfo(ctx, roomID.String())
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to load RoomInfo: %w", err)
|
|
}
|
|
if info != nil {
|
|
roomState := state.NewStateResolution(r.DB, info)
|
|
stateEntries, err := roomState.LoadStateAtSnapshotForStringTuples(
|
|
ctx, info.StateSnapshotNID(), stateWanted,
|
|
)
|
|
if err != nil {
|
|
return nil, nil
|
|
}
|
|
stateNIDs := []types.EventNID{}
|
|
for _, stateNID := range stateEntries {
|
|
stateNIDs = append(stateNIDs, stateNID.EventNID)
|
|
}
|
|
stateEvents, err := r.DB.Events(ctx, info.RoomVersion, stateNIDs)
|
|
if err != nil {
|
|
return nil, nil
|
|
}
|
|
inviteState := []gomatrixserverlib.InviteStrippedState{
|
|
gomatrixserverlib.NewInviteStrippedState(inviteEvent),
|
|
}
|
|
stateEvents = append(stateEvents, types.Event{PDU: inviteEvent})
|
|
for _, event := range stateEvents {
|
|
inviteState = append(inviteState, gomatrixserverlib.NewInviteStrippedState(event.PDU))
|
|
}
|
|
return inviteState, nil
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
func (r *Inviter) ProcessInviteMembership(
|
|
ctx context.Context, inviteEvent *types.HeaderedEvent,
|
|
) ([]api.OutputEvent, error) {
|
|
var outputUpdates []api.OutputEvent
|
|
var updater *shared.MembershipUpdater
|
|
_, domain, err := gomatrixserverlib.SplitID('@', *inviteEvent.StateKey())
|
|
if err != nil {
|
|
return nil, api.ErrInvalidID{Err: fmt.Errorf("the user ID %s is invalid", *inviteEvent.StateKey())}
|
|
}
|
|
isTargetLocal := r.Cfg.Matrix.IsLocalServerName(domain)
|
|
if updater, err = r.DB.MembershipUpdater(ctx, inviteEvent.RoomID(), *inviteEvent.StateKey(), isTargetLocal, inviteEvent.Version()); err != nil {
|
|
return nil, fmt.Errorf("r.DB.MembershipUpdater: %w", err)
|
|
}
|
|
outputUpdates, err = helpers.UpdateToInviteMembership(updater, &types.Event{
|
|
EventNID: 0,
|
|
PDU: inviteEvent.PDU,
|
|
}, outputUpdates, inviteEvent.Version())
|
|
if err != nil {
|
|
return nil, fmt.Errorf("updateToInviteMembership: %w", err)
|
|
}
|
|
if err = updater.Commit(); err != nil {
|
|
return nil, fmt.Errorf("updater.Commit: %w", err)
|
|
}
|
|
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,
|
|
) error {
|
|
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 fmt.Errorf("invite must be a state event")
|
|
}
|
|
invitedUser, err := spec.NewUserID(*event.StateKey(), true)
|
|
if err != nil {
|
|
return spec.InvalidParam("The user ID is invalid")
|
|
}
|
|
isTargetLocal := r.Cfg.Matrix.IsLocalServerName(invitedUser.Domain())
|
|
|
|
validRoomID, err := spec.NewRoomID(event.RoomID())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
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 err
|
|
}
|
|
|
|
// 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
|
|
stateWanted := []gomatrixserverlib.StateKeyTuple{}
|
|
for _, t := range []string{
|
|
spec.MRoomName, spec.MRoomCanonicalAlias,
|
|
spec.MRoomJoinRules, spec.MRoomAvatar,
|
|
spec.MRoomEncryption, spec.MRoomCreate,
|
|
} {
|
|
stateWanted = append(stateWanted, gomatrixserverlib.StateKeyTuple{
|
|
EventType: t,
|
|
StateKey: "",
|
|
})
|
|
}
|
|
if is, generateErr := input.GenerateStrippedState(input.Context, input.RoomID, stateWanted, input.Event); generateErr == nil {
|
|
inviteState = is
|
|
} else {
|
|
util.GetLogger(input.Context).WithError(generateErr).Error("failed querying known room")
|
|
return nil, spec.InternalServerError{}
|
|
}
|
|
}
|
|
|
|
logger := util.GetLogger(input.Context).WithFields(map[string]interface{}{
|
|
"inviter": input.Event.Sender(),
|
|
"invitee": *input.Event.StateKey(),
|
|
"room_id": input.RoomID.String(),
|
|
"event_id": input.Event.EventID(),
|
|
})
|
|
logger.WithFields(log.Fields{
|
|
"room_version": input.Event.Version(),
|
|
"target_local": input.IsTargetLocal,
|
|
"origin_local": true,
|
|
}).Debug("processing invite event")
|
|
|
|
if len(inviteState) == 0 {
|
|
if err := input.Event.SetUnsignedField("invite_room_state", struct{}{}); err != nil {
|
|
return nil, fmt.Errorf("event.SetUnsignedField: %w", err)
|
|
}
|
|
} else {
|
|
if err := input.Event.SetUnsignedField("invite_room_state", inviteState); err != nil {
|
|
return nil, fmt.Errorf("event.SetUnsignedField: %w", err)
|
|
}
|
|
}
|
|
|
|
membership, err := input.MembershipQuerier.CurrentMembership(input.Context, input.RoomID, input.InvitedUser)
|
|
if err != nil {
|
|
util.GetLogger(input.Context).WithError(err).Error("failed getting user membership")
|
|
return nil, spec.InternalServerError{}
|
|
|
|
}
|
|
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.
|
|
// This could plausibly happen if an invite request raced with a join
|
|
// request for a user. For example if a user was invited to a public
|
|
// room and they joined the room at the same time as the invite was sent.
|
|
// The other way this could plausibly happen is if an invite raced with
|
|
// a kick. For example if a user was kicked from a room in error and in
|
|
// response someone else in the room re-invited them then it is possible
|
|
// for the invite request to race with the leave event so that the
|
|
// target receives invite before it learns that it has been kicked.
|
|
// There are a few ways this could be plausibly handled in the roomserver.
|
|
// 1) Store the invite, but mark it as retired. That will result in the
|
|
// permanent rejection of that invite event. So even if the target
|
|
// user leaves the room and the invite is retransmitted it will be
|
|
// ignored. However a new invite with a new event ID would still be
|
|
// accepted.
|
|
// 2) Silently discard the invite event. This means that if the event
|
|
// was retransmitted at a later date after the target user had left
|
|
// the room we would accept the invite. However since we hadn't told
|
|
// the sending server that the invite had been discarded it would
|
|
// have no reason to attempt to retry.
|
|
// 3) Signal the sending server that the user is already joined to the
|
|
// room.
|
|
// For now we will implement option 2. Since in the abesence of a retry
|
|
// mechanism it will be equivalent to option 1, and we don't have a
|
|
// signalling mechanism to implement option 3.
|
|
logger.Debugf("user already joined")
|
|
return nil, api.ErrNotAllowed{Err: fmt.Errorf("user is already joined to room")}
|
|
}
|
|
|
|
// The invite originated locally. Therefore we have a responsibility to
|
|
// 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.
|
|
authEventProvider, err := input.StateQuerier.GetAuthEvents(input.Context, input.Event)
|
|
if err != nil {
|
|
logger.WithError(err).WithField("event_id", input.Event.EventID()).WithField("auth_event_ids", input.Event.AuthEventIDs()).Error(
|
|
"ProcessInvite.getAuthEvents failed for event",
|
|
)
|
|
return nil, api.ErrNotAllowed{Err: err}
|
|
}
|
|
|
|
// Check if the event is allowed.
|
|
if err = gomatrixserverlib.Allowed(input.Event, authEventProvider); err != nil {
|
|
logger.WithError(err).WithField("event_id", input.Event.EventID()).WithField("auth_event_ids", input.Event.AuthEventIDs()).Error(
|
|
"ProcessInvite: event not allowed",
|
|
)
|
|
return nil, api.ErrNotAllowed{Err: err}
|
|
}
|
|
|
|
// If the target isn't local then we should try and send the invite
|
|
// over federation first. It might be that the remote user doesn't exist,
|
|
// 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
|
|
}
|