2017-11-29 09:38:56 +00:00
|
|
|
// Copyright 2017 New Vector Ltd
|
|
|
|
//
|
|
|
|
// 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 routing
|
|
|
|
|
|
|
|
import (
|
2022-05-25 10:05:30 +01:00
|
|
|
"encoding/json"
|
Federation for v3/v4 rooms (#954)
* Update gomatrixserverlib
* Default to room version 4
* Update gomatrixserverlib
* Limit prev_events and auth_events
* Fix auth_events, prev_events
* Fix linter issues
* Update gomatrixserverlib
* Fix getState
* Update sytest-whitelist
* Squashed commit of the following:
commit 067b87506357c996fd6ddb11271db9469ad4ce80
Author: Neil Alexander <neilalexander@users.noreply.github.com>
Date: Fri Apr 3 14:29:06 2020 +0100
Invites v2 endpoint (#952)
* Start converting v1 invite endpoint to v2
* Update gomatrixserverlib
* Early federationsender code for sending invites
* Sending invites sorta happens now
* Populate invite request with stripped state
* Remodel a bit, don't reflect received invites
* Handle invite_room_state
* Handle room versions a bit better
* Update gomatrixserverlib
* Tweak order in destinationQueue.next
* Revert check in processMessage
* Tweak federation sender destination queue code a bit
* Add comments
commit 955244c09298d0e6c870377dad3af2ffa1f5e578
Author: Ben B <benne@klimlive.de>
Date: Fri Apr 3 12:40:50 2020 +0200
use custom http client instead of the http DefaultClient (#823)
This commit replaces the default client from the http lib with a custom one.
The previously used default client doesn't come with a timeout. This could cause
unwanted locks.
That solution chosen here creates a http client in the base component dendrite
with a constant timeout of 30 seconds. If it should be necessary to overwrite
this, we could include the timeout in the dendrite configuration.
Here it would be a good idea to extend the type "Address" by a timeout and
create an http client for each service.
Closes #820
Signed-off-by: Benedikt Bongartz <benne@klimlive.de>
Co-authored-by: Kegsay <kegan@matrix.org>
* Update sytest-whitelist, sytest-blacklist
* Update go.mod/go.sum
* Add some error wrapping for debug
* Add a NOTSPEC to common/events.go
* Perform state resolution at send_join
* Set default room version to v2 again
* Tweak GetCapabilities
* Add comments to ResolveConflictsAdhoc
* Update sytest-blacklist
* go mod tidy
* Update sytest-whitelist, sytest-blacklist
* Update versions
* Updates from review comments
* Update sytest-blacklist, sytest-whitelist
* Check room versions compatible at make_join, add some comments, update gomatrixserverlib, other tweaks
* Set default room version back to v2
* Update gomatrixserverlib, sytest-whitelist
2020-04-09 15:46:06 +01:00
|
|
|
"fmt"
|
2017-11-29 09:38:56 +00:00
|
|
|
"net/http"
|
2020-05-12 16:24:28 +01:00
|
|
|
"sort"
|
2018-08-06 14:09:25 +01:00
|
|
|
"time"
|
2017-11-29 09:38:56 +00:00
|
|
|
|
2022-08-05 10:12:41 +01:00
|
|
|
"github.com/matrix-org/gomatrixserverlib"
|
2023-04-06 09:55:01 +01:00
|
|
|
"github.com/matrix-org/gomatrixserverlib/fclient"
|
2023-04-19 15:50:33 +01:00
|
|
|
"github.com/matrix-org/gomatrixserverlib/spec"
|
2022-08-05 10:12:41 +01:00
|
|
|
"github.com/matrix-org/util"
|
|
|
|
"github.com/sirupsen/logrus"
|
|
|
|
|
2017-11-29 09:38:56 +00:00
|
|
|
"github.com/matrix-org/dendrite/clientapi/jsonerror"
|
2020-06-12 14:55:57 +01:00
|
|
|
"github.com/matrix-org/dendrite/internal/eventutil"
|
2017-11-29 09:38:56 +00:00
|
|
|
"github.com/matrix-org/dendrite/roomserver/api"
|
2023-04-27 12:54:20 +01:00
|
|
|
"github.com/matrix-org/dendrite/roomserver/types"
|
2020-12-02 17:41:00 +00:00
|
|
|
"github.com/matrix-org/dendrite/setup/config"
|
2017-11-29 09:38:56 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
// MakeJoin implements the /make_join API
|
|
|
|
func MakeJoin(
|
|
|
|
httpReq *http.Request,
|
2023-04-19 15:50:33 +01:00
|
|
|
request *fclient.FederationRequest,
|
2020-08-10 14:18:04 +01:00
|
|
|
cfg *config.FederationAPI,
|
2022-05-05 19:30:38 +01:00
|
|
|
rsAPI api.FederationRoomserverAPI,
|
2017-11-29 09:38:56 +00:00
|
|
|
roomID, userID string,
|
Federation for v3/v4 rooms (#954)
* Update gomatrixserverlib
* Default to room version 4
* Update gomatrixserverlib
* Limit prev_events and auth_events
* Fix auth_events, prev_events
* Fix linter issues
* Update gomatrixserverlib
* Fix getState
* Update sytest-whitelist
* Squashed commit of the following:
commit 067b87506357c996fd6ddb11271db9469ad4ce80
Author: Neil Alexander <neilalexander@users.noreply.github.com>
Date: Fri Apr 3 14:29:06 2020 +0100
Invites v2 endpoint (#952)
* Start converting v1 invite endpoint to v2
* Update gomatrixserverlib
* Early federationsender code for sending invites
* Sending invites sorta happens now
* Populate invite request with stripped state
* Remodel a bit, don't reflect received invites
* Handle invite_room_state
* Handle room versions a bit better
* Update gomatrixserverlib
* Tweak order in destinationQueue.next
* Revert check in processMessage
* Tweak federation sender destination queue code a bit
* Add comments
commit 955244c09298d0e6c870377dad3af2ffa1f5e578
Author: Ben B <benne@klimlive.de>
Date: Fri Apr 3 12:40:50 2020 +0200
use custom http client instead of the http DefaultClient (#823)
This commit replaces the default client from the http lib with a custom one.
The previously used default client doesn't come with a timeout. This could cause
unwanted locks.
That solution chosen here creates a http client in the base component dendrite
with a constant timeout of 30 seconds. If it should be necessary to overwrite
this, we could include the timeout in the dendrite configuration.
Here it would be a good idea to extend the type "Address" by a timeout and
create an http client for each service.
Closes #820
Signed-off-by: Benedikt Bongartz <benne@klimlive.de>
Co-authored-by: Kegsay <kegan@matrix.org>
* Update sytest-whitelist, sytest-blacklist
* Update go.mod/go.sum
* Add some error wrapping for debug
* Add a NOTSPEC to common/events.go
* Perform state resolution at send_join
* Set default room version to v2 again
* Tweak GetCapabilities
* Add comments to ResolveConflictsAdhoc
* Update sytest-blacklist
* go mod tidy
* Update sytest-whitelist, sytest-blacklist
* Update versions
* Updates from review comments
* Update sytest-blacklist, sytest-whitelist
* Check room versions compatible at make_join, add some comments, update gomatrixserverlib, other tweaks
* Set default room version back to v2
* Update gomatrixserverlib, sytest-whitelist
2020-04-09 15:46:06 +01:00
|
|
|
remoteVersions []gomatrixserverlib.RoomVersion,
|
2017-11-29 09:38:56 +00:00
|
|
|
) util.JSONResponse {
|
2023-04-27 07:07:13 +01:00
|
|
|
roomVersion, err := rsAPI.QueryRoomVersionForRoom(httpReq.Context(), roomID)
|
|
|
|
if err != nil {
|
2020-03-27 16:28:22 +00:00
|
|
|
return util.JSONResponse{
|
|
|
|
Code: http.StatusInternalServerError,
|
|
|
|
JSON: jsonerror.InternalServerError(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Federation for v3/v4 rooms (#954)
* Update gomatrixserverlib
* Default to room version 4
* Update gomatrixserverlib
* Limit prev_events and auth_events
* Fix auth_events, prev_events
* Fix linter issues
* Update gomatrixserverlib
* Fix getState
* Update sytest-whitelist
* Squashed commit of the following:
commit 067b87506357c996fd6ddb11271db9469ad4ce80
Author: Neil Alexander <neilalexander@users.noreply.github.com>
Date: Fri Apr 3 14:29:06 2020 +0100
Invites v2 endpoint (#952)
* Start converting v1 invite endpoint to v2
* Update gomatrixserverlib
* Early federationsender code for sending invites
* Sending invites sorta happens now
* Populate invite request with stripped state
* Remodel a bit, don't reflect received invites
* Handle invite_room_state
* Handle room versions a bit better
* Update gomatrixserverlib
* Tweak order in destinationQueue.next
* Revert check in processMessage
* Tweak federation sender destination queue code a bit
* Add comments
commit 955244c09298d0e6c870377dad3af2ffa1f5e578
Author: Ben B <benne@klimlive.de>
Date: Fri Apr 3 12:40:50 2020 +0200
use custom http client instead of the http DefaultClient (#823)
This commit replaces the default client from the http lib with a custom one.
The previously used default client doesn't come with a timeout. This could cause
unwanted locks.
That solution chosen here creates a http client in the base component dendrite
with a constant timeout of 30 seconds. If it should be necessary to overwrite
this, we could include the timeout in the dendrite configuration.
Here it would be a good idea to extend the type "Address" by a timeout and
create an http client for each service.
Closes #820
Signed-off-by: Benedikt Bongartz <benne@klimlive.de>
Co-authored-by: Kegsay <kegan@matrix.org>
* Update sytest-whitelist, sytest-blacklist
* Update go.mod/go.sum
* Add some error wrapping for debug
* Add a NOTSPEC to common/events.go
* Perform state resolution at send_join
* Set default room version to v2 again
* Tweak GetCapabilities
* Add comments to ResolveConflictsAdhoc
* Update sytest-blacklist
* go mod tidy
* Update sytest-whitelist, sytest-blacklist
* Update versions
* Updates from review comments
* Update sytest-blacklist, sytest-whitelist
* Check room versions compatible at make_join, add some comments, update gomatrixserverlib, other tweaks
* Set default room version back to v2
* Update gomatrixserverlib, sytest-whitelist
2020-04-09 15:46:06 +01:00
|
|
|
// Check that the room that the remote side is trying to join is actually
|
|
|
|
// one of the room versions that they listed in their supported ?ver= in
|
|
|
|
// the make_join URL.
|
|
|
|
// https://matrix.org/docs/spec/server_server/r0.1.3#get-matrix-federation-v1-make-join-roomid-userid
|
|
|
|
remoteSupportsVersion := false
|
|
|
|
for _, v := range remoteVersions {
|
2023-04-27 07:07:13 +01:00
|
|
|
if v == roomVersion {
|
Federation for v3/v4 rooms (#954)
* Update gomatrixserverlib
* Default to room version 4
* Update gomatrixserverlib
* Limit prev_events and auth_events
* Fix auth_events, prev_events
* Fix linter issues
* Update gomatrixserverlib
* Fix getState
* Update sytest-whitelist
* Squashed commit of the following:
commit 067b87506357c996fd6ddb11271db9469ad4ce80
Author: Neil Alexander <neilalexander@users.noreply.github.com>
Date: Fri Apr 3 14:29:06 2020 +0100
Invites v2 endpoint (#952)
* Start converting v1 invite endpoint to v2
* Update gomatrixserverlib
* Early federationsender code for sending invites
* Sending invites sorta happens now
* Populate invite request with stripped state
* Remodel a bit, don't reflect received invites
* Handle invite_room_state
* Handle room versions a bit better
* Update gomatrixserverlib
* Tweak order in destinationQueue.next
* Revert check in processMessage
* Tweak federation sender destination queue code a bit
* Add comments
commit 955244c09298d0e6c870377dad3af2ffa1f5e578
Author: Ben B <benne@klimlive.de>
Date: Fri Apr 3 12:40:50 2020 +0200
use custom http client instead of the http DefaultClient (#823)
This commit replaces the default client from the http lib with a custom one.
The previously used default client doesn't come with a timeout. This could cause
unwanted locks.
That solution chosen here creates a http client in the base component dendrite
with a constant timeout of 30 seconds. If it should be necessary to overwrite
this, we could include the timeout in the dendrite configuration.
Here it would be a good idea to extend the type "Address" by a timeout and
create an http client for each service.
Closes #820
Signed-off-by: Benedikt Bongartz <benne@klimlive.de>
Co-authored-by: Kegsay <kegan@matrix.org>
* Update sytest-whitelist, sytest-blacklist
* Update go.mod/go.sum
* Add some error wrapping for debug
* Add a NOTSPEC to common/events.go
* Perform state resolution at send_join
* Set default room version to v2 again
* Tweak GetCapabilities
* Add comments to ResolveConflictsAdhoc
* Update sytest-blacklist
* go mod tidy
* Update sytest-whitelist, sytest-blacklist
* Update versions
* Updates from review comments
* Update sytest-blacklist, sytest-whitelist
* Check room versions compatible at make_join, add some comments, update gomatrixserverlib, other tweaks
* Set default room version back to v2
* Update gomatrixserverlib, sytest-whitelist
2020-04-09 15:46:06 +01:00
|
|
|
remoteSupportsVersion = true
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// If it isn't, stop trying to join the room.
|
|
|
|
if !remoteSupportsVersion {
|
|
|
|
return util.JSONResponse{
|
|
|
|
Code: http.StatusBadRequest,
|
2023-04-27 07:07:13 +01:00
|
|
|
JSON: jsonerror.IncompatibleRoomVersion(roomVersion),
|
Federation for v3/v4 rooms (#954)
* Update gomatrixserverlib
* Default to room version 4
* Update gomatrixserverlib
* Limit prev_events and auth_events
* Fix auth_events, prev_events
* Fix linter issues
* Update gomatrixserverlib
* Fix getState
* Update sytest-whitelist
* Squashed commit of the following:
commit 067b87506357c996fd6ddb11271db9469ad4ce80
Author: Neil Alexander <neilalexander@users.noreply.github.com>
Date: Fri Apr 3 14:29:06 2020 +0100
Invites v2 endpoint (#952)
* Start converting v1 invite endpoint to v2
* Update gomatrixserverlib
* Early federationsender code for sending invites
* Sending invites sorta happens now
* Populate invite request with stripped state
* Remodel a bit, don't reflect received invites
* Handle invite_room_state
* Handle room versions a bit better
* Update gomatrixserverlib
* Tweak order in destinationQueue.next
* Revert check in processMessage
* Tweak federation sender destination queue code a bit
* Add comments
commit 955244c09298d0e6c870377dad3af2ffa1f5e578
Author: Ben B <benne@klimlive.de>
Date: Fri Apr 3 12:40:50 2020 +0200
use custom http client instead of the http DefaultClient (#823)
This commit replaces the default client from the http lib with a custom one.
The previously used default client doesn't come with a timeout. This could cause
unwanted locks.
That solution chosen here creates a http client in the base component dendrite
with a constant timeout of 30 seconds. If it should be necessary to overwrite
this, we could include the timeout in the dendrite configuration.
Here it would be a good idea to extend the type "Address" by a timeout and
create an http client for each service.
Closes #820
Signed-off-by: Benedikt Bongartz <benne@klimlive.de>
Co-authored-by: Kegsay <kegan@matrix.org>
* Update sytest-whitelist, sytest-blacklist
* Update go.mod/go.sum
* Add some error wrapping for debug
* Add a NOTSPEC to common/events.go
* Perform state resolution at send_join
* Set default room version to v2 again
* Tweak GetCapabilities
* Add comments to ResolveConflictsAdhoc
* Update sytest-blacklist
* go mod tidy
* Update sytest-whitelist, sytest-blacklist
* Update versions
* Updates from review comments
* Update sytest-blacklist, sytest-whitelist
* Check room versions compatible at make_join, add some comments, update gomatrixserverlib, other tweaks
* Set default room version back to v2
* Update gomatrixserverlib, sytest-whitelist
2020-04-09 15:46:06 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-29 09:38:56 +00:00
|
|
|
_, domain, err := gomatrixserverlib.SplitID('@', userID)
|
|
|
|
if err != nil {
|
|
|
|
return util.JSONResponse{
|
2018-03-13 15:55:45 +00:00
|
|
|
Code: http.StatusBadRequest,
|
2017-11-29 09:38:56 +00:00
|
|
|
JSON: jsonerror.BadJSON("Invalid UserID"),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if domain != request.Origin() {
|
|
|
|
return util.JSONResponse{
|
2018-03-13 15:55:45 +00:00
|
|
|
Code: http.StatusForbidden,
|
2017-11-29 09:38:56 +00:00
|
|
|
JSON: jsonerror.Forbidden("The join must be sent by the server of the user"),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-24 16:18:13 +01:00
|
|
|
// Check if we think we are still joined to the room
|
|
|
|
inRoomReq := &api.QueryServerJoinedToRoomRequest{
|
|
|
|
ServerName: cfg.Matrix.ServerName,
|
|
|
|
RoomID: roomID,
|
|
|
|
}
|
|
|
|
inRoomRes := &api.QueryServerJoinedToRoomResponse{}
|
|
|
|
if err = rsAPI.QueryServerJoinedToRoom(httpReq.Context(), inRoomReq, inRoomRes); err != nil {
|
|
|
|
util.GetLogger(httpReq.Context()).WithError(err).Error("rsAPI.QueryServerJoinedToRoom failed")
|
|
|
|
return jsonerror.InternalServerError()
|
|
|
|
}
|
|
|
|
if !inRoomRes.RoomExists {
|
|
|
|
return util.JSONResponse{
|
|
|
|
Code: http.StatusNotFound,
|
|
|
|
JSON: jsonerror.NotFound(fmt.Sprintf("Room ID %q was not found on this server", roomID)),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if !inRoomRes.IsInRoom {
|
|
|
|
return util.JSONResponse{
|
|
|
|
Code: http.StatusNotFound,
|
|
|
|
JSON: jsonerror.NotFound(fmt.Sprintf("Room ID %q has no remaining users on this server", roomID)),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-25 10:05:30 +01:00
|
|
|
// Check if the restricted join is allowed. If the room doesn't
|
|
|
|
// support restricted joins then this is effectively a no-op.
|
2023-04-27 07:07:13 +01:00
|
|
|
res, authorisedVia, err := checkRestrictedJoin(httpReq, rsAPI, roomVersion, roomID, userID)
|
2022-05-25 10:05:30 +01:00
|
|
|
if err != nil {
|
|
|
|
util.GetLogger(httpReq.Context()).WithError(err).Error("checkRestrictedJoin failed")
|
|
|
|
return jsonerror.InternalServerError()
|
|
|
|
} else if res != nil {
|
|
|
|
return *res
|
|
|
|
}
|
|
|
|
|
2017-11-29 09:38:56 +00:00
|
|
|
// Try building an event for the server
|
2023-05-04 11:17:42 +01:00
|
|
|
proto := gomatrixserverlib.ProtoEvent{
|
2017-11-29 09:38:56 +00:00
|
|
|
Sender: userID,
|
|
|
|
RoomID: roomID,
|
|
|
|
Type: "m.room.member",
|
|
|
|
StateKey: &userID,
|
|
|
|
}
|
2022-05-25 10:05:30 +01:00
|
|
|
content := gomatrixserverlib.MemberContent{
|
2023-04-19 15:50:33 +01:00
|
|
|
Membership: spec.Join,
|
2022-05-25 10:05:30 +01:00
|
|
|
AuthorisedVia: authorisedVia,
|
|
|
|
}
|
2023-05-04 11:17:42 +01:00
|
|
|
if err = proto.SetContent(content); err != nil {
|
2020-03-02 16:20:44 +00:00
|
|
|
util.GetLogger(httpReq.Context()).WithError(err).Error("builder.SetContent failed")
|
|
|
|
return jsonerror.InternalServerError()
|
2017-11-29 09:38:56 +00:00
|
|
|
}
|
|
|
|
|
2022-11-15 15:05:23 +00:00
|
|
|
identity, err := cfg.Matrix.SigningIdentityFor(request.Destination())
|
|
|
|
if err != nil {
|
|
|
|
return util.JSONResponse{
|
|
|
|
Code: http.StatusNotFound,
|
|
|
|
JSON: jsonerror.NotFound(
|
|
|
|
fmt.Sprintf("Server name %q does not exist", request.Destination()),
|
|
|
|
),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-27 16:28:22 +00:00
|
|
|
queryRes := api.QueryLatestEventsAndStateResponse{
|
2023-04-27 07:07:13 +01:00
|
|
|
RoomVersion: roomVersion,
|
2020-03-27 16:28:22 +00:00
|
|
|
}
|
2023-05-04 11:17:42 +01:00
|
|
|
event, err := eventutil.QueryAndBuildEvent(httpReq.Context(), &proto, cfg.Matrix, identity, time.Now(), rsAPI, &queryRes)
|
2020-06-12 14:55:57 +01:00
|
|
|
if err == eventutil.ErrRoomNoExists {
|
2017-11-29 09:38:56 +00:00
|
|
|
return util.JSONResponse{
|
2018-03-13 15:55:45 +00:00
|
|
|
Code: http.StatusNotFound,
|
2017-11-29 09:38:56 +00:00
|
|
|
JSON: jsonerror.NotFound("Room does not exist"),
|
|
|
|
}
|
2020-06-04 10:53:39 +01:00
|
|
|
} else if e, ok := err.(gomatrixserverlib.BadJSONError); ok {
|
|
|
|
return util.JSONResponse{
|
|
|
|
Code: http.StatusBadRequest,
|
|
|
|
JSON: jsonerror.BadJSON(e.Error()),
|
|
|
|
}
|
2017-11-29 09:38:56 +00:00
|
|
|
} else if err != nil {
|
2020-06-12 14:55:57 +01:00
|
|
|
util.GetLogger(httpReq.Context()).WithError(err).Error("eventutil.BuildEvent failed")
|
2020-03-02 16:20:44 +00:00
|
|
|
return jsonerror.InternalServerError()
|
2017-11-29 09:38:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Check that the join is allowed or not
|
2023-05-02 15:03:16 +01:00
|
|
|
stateEvents := make([]gomatrixserverlib.PDU, len(queryRes.StateEvents))
|
2017-11-29 09:38:56 +00:00
|
|
|
for i := range queryRes.StateEvents {
|
2023-05-02 15:03:16 +01:00
|
|
|
stateEvents[i] = queryRes.StateEvents[i].PDU
|
2017-11-29 09:38:56 +00:00
|
|
|
}
|
2020-03-27 16:28:22 +00:00
|
|
|
|
2023-05-02 15:03:16 +01:00
|
|
|
provider := gomatrixserverlib.NewAuthEvents(stateEvents)
|
|
|
|
if err = gomatrixserverlib.Allowed(event.PDU, &provider); err != nil {
|
2017-11-29 09:38:56 +00:00
|
|
|
return util.JSONResponse{
|
2018-03-13 15:55:45 +00:00
|
|
|
Code: http.StatusForbidden,
|
2017-11-29 09:38:56 +00:00
|
|
|
JSON: jsonerror.Forbidden(err.Error()),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return util.JSONResponse{
|
2018-03-13 15:55:45 +00:00
|
|
|
Code: http.StatusOK,
|
2020-03-27 16:28:22 +00:00
|
|
|
JSON: map[string]interface{}{
|
2023-05-04 11:17:42 +01:00
|
|
|
"event": proto,
|
2023-04-27 07:07:13 +01:00
|
|
|
"room_version": roomVersion,
|
2020-03-27 16:28:22 +00:00
|
|
|
},
|
2017-11-29 09:38:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// SendJoin implements the /send_join API
|
2020-05-04 13:53:47 +01:00
|
|
|
// The make-join send-join dance makes much more sense as a single
|
|
|
|
// flow so the cyclomatic complexity is high:
|
2022-05-25 10:05:30 +01:00
|
|
|
// nolint:gocyclo
|
2017-11-29 09:38:56 +00:00
|
|
|
func SendJoin(
|
|
|
|
httpReq *http.Request,
|
2023-04-19 15:50:33 +01:00
|
|
|
request *fclient.FederationRequest,
|
2020-08-10 14:18:04 +01:00
|
|
|
cfg *config.FederationAPI,
|
2022-05-05 19:30:38 +01:00
|
|
|
rsAPI api.FederationRoomserverAPI,
|
2020-06-15 16:57:59 +01:00
|
|
|
keys gomatrixserverlib.JSONVerifier,
|
2017-11-29 09:38:56 +00:00
|
|
|
roomID, eventID string,
|
|
|
|
) util.JSONResponse {
|
2023-04-27 07:07:13 +01:00
|
|
|
roomVersion, err := rsAPI.QueryRoomVersionForRoom(httpReq.Context(), roomID)
|
|
|
|
if err != nil {
|
2020-05-01 10:48:17 +01:00
|
|
|
util.GetLogger(httpReq.Context()).WithError(err).Error("rsAPI.QueryRoomVersionForRoom failed")
|
2020-03-27 16:28:22 +00:00
|
|
|
return util.JSONResponse{
|
|
|
|
Code: http.StatusInternalServerError,
|
|
|
|
JSON: jsonerror.InternalServerError(),
|
|
|
|
}
|
|
|
|
}
|
2023-04-27 07:07:13 +01:00
|
|
|
verImpl, err := gomatrixserverlib.GetRoomVersion(roomVersion)
|
2023-04-21 17:06:29 +01:00
|
|
|
if err != nil {
|
|
|
|
return util.JSONResponse{
|
|
|
|
Code: http.StatusInternalServerError,
|
|
|
|
JSON: jsonerror.UnsupportedRoomVersion(
|
2023-04-27 07:07:13 +01:00
|
|
|
fmt.Sprintf("QueryRoomVersionForRoom returned unknown room version: %s", roomVersion),
|
2023-04-21 17:06:29 +01:00
|
|
|
),
|
|
|
|
}
|
|
|
|
}
|
2020-03-27 16:28:22 +00:00
|
|
|
|
2023-04-21 17:06:29 +01:00
|
|
|
event, err := verImpl.NewEventFromUntrustedJSON(request.Content())
|
2020-03-27 16:28:22 +00:00
|
|
|
if err != nil {
|
2017-11-29 09:38:56 +00:00
|
|
|
return util.JSONResponse{
|
2018-03-13 15:55:45 +00:00
|
|
|
Code: http.StatusBadRequest,
|
2020-06-04 10:53:39 +01:00
|
|
|
JSON: jsonerror.BadJSON("The request body could not be decoded into valid JSON: " + err.Error()),
|
2017-11-29 09:38:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-04 13:53:47 +01:00
|
|
|
// Check that a state key is provided.
|
2020-08-25 21:04:35 +01:00
|
|
|
if event.StateKey() == nil || event.StateKeyEquals("") {
|
2020-05-04 13:53:47 +01:00
|
|
|
return util.JSONResponse{
|
|
|
|
Code: http.StatusBadRequest,
|
2020-10-01 20:00:56 +01:00
|
|
|
JSON: jsonerror.BadJSON("No state key was provided in the join event."),
|
2020-05-04 13:53:47 +01:00
|
|
|
}
|
|
|
|
}
|
2022-01-05 17:44:49 +00:00
|
|
|
if !event.StateKeyEquals(event.Sender()) {
|
|
|
|
return util.JSONResponse{
|
|
|
|
Code: http.StatusBadRequest,
|
|
|
|
JSON: jsonerror.BadJSON("Event state key must match the event sender."),
|
|
|
|
}
|
|
|
|
}
|
2020-05-04 13:53:47 +01:00
|
|
|
|
2022-08-02 10:22:17 +01:00
|
|
|
// Check that the sender belongs to the server that is sending us
|
|
|
|
// the request. By this point we've already asserted that the sender
|
|
|
|
// and the state key are equal so we don't need to check both.
|
2023-04-19 15:50:33 +01:00
|
|
|
var serverName spec.ServerName
|
2022-09-26 17:35:35 +01:00
|
|
|
if _, serverName, err = gomatrixserverlib.SplitID('@', event.Sender()); err != nil {
|
2022-08-02 10:22:17 +01:00
|
|
|
return util.JSONResponse{
|
|
|
|
Code: http.StatusForbidden,
|
|
|
|
JSON: jsonerror.Forbidden("The sender of the join is invalid"),
|
|
|
|
}
|
2022-09-26 17:35:35 +01:00
|
|
|
} else if serverName != request.Origin() {
|
2022-08-02 10:22:17 +01:00
|
|
|
return util.JSONResponse{
|
|
|
|
Code: http.StatusForbidden,
|
2022-09-26 17:35:35 +01:00
|
|
|
JSON: jsonerror.Forbidden("The sender does not match the server that originated the request"),
|
2022-08-02 10:22:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-29 09:38:56 +00:00
|
|
|
// Check that the room ID is correct.
|
|
|
|
if event.RoomID() != roomID {
|
|
|
|
return util.JSONResponse{
|
2018-03-13 15:55:45 +00:00
|
|
|
Code: http.StatusBadRequest,
|
Federation for v3/v4 rooms (#954)
* Update gomatrixserverlib
* Default to room version 4
* Update gomatrixserverlib
* Limit prev_events and auth_events
* Fix auth_events, prev_events
* Fix linter issues
* Update gomatrixserverlib
* Fix getState
* Update sytest-whitelist
* Squashed commit of the following:
commit 067b87506357c996fd6ddb11271db9469ad4ce80
Author: Neil Alexander <neilalexander@users.noreply.github.com>
Date: Fri Apr 3 14:29:06 2020 +0100
Invites v2 endpoint (#952)
* Start converting v1 invite endpoint to v2
* Update gomatrixserverlib
* Early federationsender code for sending invites
* Sending invites sorta happens now
* Populate invite request with stripped state
* Remodel a bit, don't reflect received invites
* Handle invite_room_state
* Handle room versions a bit better
* Update gomatrixserverlib
* Tweak order in destinationQueue.next
* Revert check in processMessage
* Tweak federation sender destination queue code a bit
* Add comments
commit 955244c09298d0e6c870377dad3af2ffa1f5e578
Author: Ben B <benne@klimlive.de>
Date: Fri Apr 3 12:40:50 2020 +0200
use custom http client instead of the http DefaultClient (#823)
This commit replaces the default client from the http lib with a custom one.
The previously used default client doesn't come with a timeout. This could cause
unwanted locks.
That solution chosen here creates a http client in the base component dendrite
with a constant timeout of 30 seconds. If it should be necessary to overwrite
this, we could include the timeout in the dendrite configuration.
Here it would be a good idea to extend the type "Address" by a timeout and
create an http client for each service.
Closes #820
Signed-off-by: Benedikt Bongartz <benne@klimlive.de>
Co-authored-by: Kegsay <kegan@matrix.org>
* Update sytest-whitelist, sytest-blacklist
* Update go.mod/go.sum
* Add some error wrapping for debug
* Add a NOTSPEC to common/events.go
* Perform state resolution at send_join
* Set default room version to v2 again
* Tweak GetCapabilities
* Add comments to ResolveConflictsAdhoc
* Update sytest-blacklist
* go mod tidy
* Update sytest-whitelist, sytest-blacklist
* Update versions
* Updates from review comments
* Update sytest-blacklist, sytest-whitelist
* Check room versions compatible at make_join, add some comments, update gomatrixserverlib, other tweaks
* Set default room version back to v2
* Update gomatrixserverlib, sytest-whitelist
2020-04-09 15:46:06 +01:00
|
|
|
JSON: jsonerror.BadJSON(
|
|
|
|
fmt.Sprintf(
|
|
|
|
"The room ID in the request path (%q) must match the room ID in the join event JSON (%q)",
|
|
|
|
roomID, event.RoomID(),
|
|
|
|
),
|
|
|
|
),
|
2017-11-29 09:38:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check that the event ID is correct.
|
|
|
|
if event.EventID() != eventID {
|
|
|
|
return util.JSONResponse{
|
2018-03-13 15:55:45 +00:00
|
|
|
Code: http.StatusBadRequest,
|
Federation for v3/v4 rooms (#954)
* Update gomatrixserverlib
* Default to room version 4
* Update gomatrixserverlib
* Limit prev_events and auth_events
* Fix auth_events, prev_events
* Fix linter issues
* Update gomatrixserverlib
* Fix getState
* Update sytest-whitelist
* Squashed commit of the following:
commit 067b87506357c996fd6ddb11271db9469ad4ce80
Author: Neil Alexander <neilalexander@users.noreply.github.com>
Date: Fri Apr 3 14:29:06 2020 +0100
Invites v2 endpoint (#952)
* Start converting v1 invite endpoint to v2
* Update gomatrixserverlib
* Early federationsender code for sending invites
* Sending invites sorta happens now
* Populate invite request with stripped state
* Remodel a bit, don't reflect received invites
* Handle invite_room_state
* Handle room versions a bit better
* Update gomatrixserverlib
* Tweak order in destinationQueue.next
* Revert check in processMessage
* Tweak federation sender destination queue code a bit
* Add comments
commit 955244c09298d0e6c870377dad3af2ffa1f5e578
Author: Ben B <benne@klimlive.de>
Date: Fri Apr 3 12:40:50 2020 +0200
use custom http client instead of the http DefaultClient (#823)
This commit replaces the default client from the http lib with a custom one.
The previously used default client doesn't come with a timeout. This could cause
unwanted locks.
That solution chosen here creates a http client in the base component dendrite
with a constant timeout of 30 seconds. If it should be necessary to overwrite
this, we could include the timeout in the dendrite configuration.
Here it would be a good idea to extend the type "Address" by a timeout and
create an http client for each service.
Closes #820
Signed-off-by: Benedikt Bongartz <benne@klimlive.de>
Co-authored-by: Kegsay <kegan@matrix.org>
* Update sytest-whitelist, sytest-blacklist
* Update go.mod/go.sum
* Add some error wrapping for debug
* Add a NOTSPEC to common/events.go
* Perform state resolution at send_join
* Set default room version to v2 again
* Tweak GetCapabilities
* Add comments to ResolveConflictsAdhoc
* Update sytest-blacklist
* go mod tidy
* Update sytest-whitelist, sytest-blacklist
* Update versions
* Updates from review comments
* Update sytest-blacklist, sytest-whitelist
* Check room versions compatible at make_join, add some comments, update gomatrixserverlib, other tweaks
* Set default room version back to v2
* Update gomatrixserverlib, sytest-whitelist
2020-04-09 15:46:06 +01:00
|
|
|
JSON: jsonerror.BadJSON(
|
|
|
|
fmt.Sprintf(
|
|
|
|
"The event ID in the request path (%q) must match the event ID in the join event JSON (%q)",
|
|
|
|
eventID, event.EventID(),
|
|
|
|
),
|
|
|
|
),
|
2017-11-29 09:38:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-19 13:15:19 +01:00
|
|
|
// Check that this is in fact a join event
|
|
|
|
membership, err := event.Membership()
|
|
|
|
if err != nil {
|
|
|
|
return util.JSONResponse{
|
|
|
|
Code: http.StatusBadRequest,
|
|
|
|
JSON: jsonerror.BadJSON("missing content.membership key"),
|
|
|
|
}
|
|
|
|
}
|
2023-04-19 15:50:33 +01:00
|
|
|
if membership != spec.Join {
|
2021-07-19 13:15:19 +01:00
|
|
|
return util.JSONResponse{
|
|
|
|
Code: http.StatusBadRequest,
|
|
|
|
JSON: jsonerror.BadJSON("membership must be 'join'"),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-29 09:38:56 +00:00
|
|
|
// Check that the event is signed by the server sending the request.
|
2023-04-21 17:06:29 +01:00
|
|
|
redacted, err := verImpl.RedactEventJSON(event.JSON())
|
2022-07-11 14:31:31 +01:00
|
|
|
if err != nil {
|
|
|
|
logrus.WithError(err).Errorf("XXX: join.go")
|
|
|
|
return util.JSONResponse{
|
|
|
|
Code: http.StatusBadRequest,
|
|
|
|
JSON: jsonerror.BadJSON("The event JSON could not be redacted"),
|
|
|
|
}
|
|
|
|
}
|
2017-11-29 09:38:56 +00:00
|
|
|
verifyRequests := []gomatrixserverlib.VerifyJSONRequest{{
|
2022-09-26 17:35:35 +01:00
|
|
|
ServerName: serverName,
|
2022-07-11 14:31:31 +01:00
|
|
|
Message: redacted,
|
2020-04-20 17:42:34 +01:00
|
|
|
AtTS: event.OriginServerTS(),
|
|
|
|
StrictValidityChecking: true,
|
2017-11-29 09:38:56 +00:00
|
|
|
}}
|
2018-08-06 14:07:29 +01:00
|
|
|
verifyResults, err := keys.VerifyJSONs(httpReq.Context(), verifyRequests)
|
2017-11-29 09:38:56 +00:00
|
|
|
if err != nil {
|
2020-03-02 16:20:44 +00:00
|
|
|
util.GetLogger(httpReq.Context()).WithError(err).Error("keys.VerifyJSONs failed")
|
|
|
|
return jsonerror.InternalServerError()
|
2017-11-29 09:38:56 +00:00
|
|
|
}
|
|
|
|
if verifyResults[0].Error != nil {
|
|
|
|
return util.JSONResponse{
|
2018-03-13 15:55:45 +00:00
|
|
|
Code: http.StatusForbidden,
|
2020-03-27 16:28:22 +00:00
|
|
|
JSON: jsonerror.Forbidden("Signature check failed: " + verifyResults[0].Error.Error()),
|
2017-11-29 09:38:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Fetch the state and auth chain. We do this before we send the events
|
|
|
|
// on, in case this fails.
|
2019-12-20 14:42:57 +00:00
|
|
|
var stateAndAuthChainResponse api.QueryStateAndAuthChainResponse
|
2020-05-01 10:48:17 +01:00
|
|
|
err = rsAPI.QueryStateAndAuthChain(httpReq.Context(), &api.QueryStateAndAuthChainRequest{
|
2017-11-29 09:38:56 +00:00
|
|
|
PrevEventIDs: event.PrevEventIDs(),
|
|
|
|
AuthEventIDs: event.AuthEventIDs(),
|
|
|
|
RoomID: roomID,
|
Federation for v3/v4 rooms (#954)
* Update gomatrixserverlib
* Default to room version 4
* Update gomatrixserverlib
* Limit prev_events and auth_events
* Fix auth_events, prev_events
* Fix linter issues
* Update gomatrixserverlib
* Fix getState
* Update sytest-whitelist
* Squashed commit of the following:
commit 067b87506357c996fd6ddb11271db9469ad4ce80
Author: Neil Alexander <neilalexander@users.noreply.github.com>
Date: Fri Apr 3 14:29:06 2020 +0100
Invites v2 endpoint (#952)
* Start converting v1 invite endpoint to v2
* Update gomatrixserverlib
* Early federationsender code for sending invites
* Sending invites sorta happens now
* Populate invite request with stripped state
* Remodel a bit, don't reflect received invites
* Handle invite_room_state
* Handle room versions a bit better
* Update gomatrixserverlib
* Tweak order in destinationQueue.next
* Revert check in processMessage
* Tweak federation sender destination queue code a bit
* Add comments
commit 955244c09298d0e6c870377dad3af2ffa1f5e578
Author: Ben B <benne@klimlive.de>
Date: Fri Apr 3 12:40:50 2020 +0200
use custom http client instead of the http DefaultClient (#823)
This commit replaces the default client from the http lib with a custom one.
The previously used default client doesn't come with a timeout. This could cause
unwanted locks.
That solution chosen here creates a http client in the base component dendrite
with a constant timeout of 30 seconds. If it should be necessary to overwrite
this, we could include the timeout in the dendrite configuration.
Here it would be a good idea to extend the type "Address" by a timeout and
create an http client for each service.
Closes #820
Signed-off-by: Benedikt Bongartz <benne@klimlive.de>
Co-authored-by: Kegsay <kegan@matrix.org>
* Update sytest-whitelist, sytest-blacklist
* Update go.mod/go.sum
* Add some error wrapping for debug
* Add a NOTSPEC to common/events.go
* Perform state resolution at send_join
* Set default room version to v2 again
* Tweak GetCapabilities
* Add comments to ResolveConflictsAdhoc
* Update sytest-blacklist
* go mod tidy
* Update sytest-whitelist, sytest-blacklist
* Update versions
* Updates from review comments
* Update sytest-blacklist, sytest-whitelist
* Check room versions compatible at make_join, add some comments, update gomatrixserverlib, other tweaks
* Set default room version back to v2
* Update gomatrixserverlib, sytest-whitelist
2020-04-09 15:46:06 +01:00
|
|
|
ResolveState: true,
|
2019-12-20 14:42:57 +00:00
|
|
|
}, &stateAndAuthChainResponse)
|
2017-11-29 09:38:56 +00:00
|
|
|
if err != nil {
|
2020-05-01 10:48:17 +01:00
|
|
|
util.GetLogger(httpReq.Context()).WithError(err).Error("rsAPI.QueryStateAndAuthChain failed")
|
2020-03-02 16:20:44 +00:00
|
|
|
return jsonerror.InternalServerError()
|
2017-11-29 09:38:56 +00:00
|
|
|
}
|
|
|
|
|
2019-12-20 14:42:57 +00:00
|
|
|
if !stateAndAuthChainResponse.RoomExists {
|
|
|
|
return util.JSONResponse{
|
|
|
|
Code: http.StatusNotFound,
|
|
|
|
JSON: jsonerror.NotFound("Room does not exist"),
|
|
|
|
}
|
|
|
|
}
|
2022-08-25 09:51:36 +01:00
|
|
|
if !stateAndAuthChainResponse.StateKnown {
|
|
|
|
return util.JSONResponse{
|
|
|
|
Code: http.StatusForbidden,
|
|
|
|
JSON: jsonerror.Forbidden("State not known"),
|
|
|
|
}
|
|
|
|
}
|
2019-12-20 14:42:57 +00:00
|
|
|
|
2020-05-04 13:53:47 +01:00
|
|
|
// Check if the user is already in the room. If they're already in then
|
|
|
|
// there isn't much point in sending another join event into the room.
|
2021-07-13 12:22:27 +01:00
|
|
|
// Also check to see if they are banned: if they are then we reject them.
|
2020-05-04 13:53:47 +01:00
|
|
|
alreadyJoined := false
|
2021-07-13 12:22:27 +01:00
|
|
|
isBanned := false
|
2020-05-04 13:53:47 +01:00
|
|
|
for _, se := range stateAndAuthChainResponse.StateEvents {
|
2020-08-25 21:04:35 +01:00
|
|
|
if !se.StateKeyEquals(*event.StateKey()) {
|
|
|
|
continue
|
|
|
|
}
|
2020-05-04 13:53:47 +01:00
|
|
|
if membership, merr := se.Membership(); merr == nil {
|
2023-04-19 15:50:33 +01:00
|
|
|
alreadyJoined = (membership == spec.Join)
|
|
|
|
isBanned = (membership == spec.Ban)
|
2020-08-25 21:04:35 +01:00
|
|
|
break
|
2020-05-04 13:53:47 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-13 12:22:27 +01:00
|
|
|
if isBanned {
|
|
|
|
return util.JSONResponse{
|
|
|
|
Code: http.StatusForbidden,
|
|
|
|
JSON: jsonerror.Forbidden("user is banned"),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-25 10:05:30 +01:00
|
|
|
// If the membership content contains a user ID for a server that is not
|
|
|
|
// ours then we should kick it back.
|
|
|
|
var memberContent gomatrixserverlib.MemberContent
|
|
|
|
if err := json.Unmarshal(event.Content(), &memberContent); err != nil {
|
|
|
|
return util.JSONResponse{
|
|
|
|
Code: http.StatusBadRequest,
|
|
|
|
JSON: jsonerror.BadJSON(err.Error()),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if memberContent.AuthorisedVia != "" {
|
|
|
|
_, domain, err := gomatrixserverlib.SplitID('@', memberContent.AuthorisedVia)
|
|
|
|
if err != nil {
|
|
|
|
return util.JSONResponse{
|
|
|
|
Code: http.StatusBadRequest,
|
|
|
|
JSON: jsonerror.BadJSON(fmt.Sprintf("The authorising username %q is invalid.", memberContent.AuthorisedVia)),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if domain != cfg.Matrix.ServerName {
|
|
|
|
return util.JSONResponse{
|
|
|
|
Code: http.StatusBadRequest,
|
|
|
|
JSON: jsonerror.BadJSON(fmt.Sprintf("The authorising username %q does not belong to this server.", memberContent.AuthorisedVia)),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Sign the membership event. This is required for restricted joins to work
|
|
|
|
// in the case that the authorised via user is one of our own users. It also
|
|
|
|
// doesn't hurt to do it even if it isn't a restricted join.
|
|
|
|
signed := event.Sign(
|
|
|
|
string(cfg.Matrix.ServerName),
|
|
|
|
cfg.Matrix.KeyID,
|
|
|
|
cfg.Matrix.PrivateKey,
|
|
|
|
)
|
|
|
|
|
2017-11-29 09:38:56 +00:00
|
|
|
// Send the events to the room server.
|
|
|
|
// We are responsible for notifying other servers that the user has joined
|
|
|
|
// the room, so set SendAsServer to cfg.Matrix.ServerName
|
2020-05-04 13:53:47 +01:00
|
|
|
if !alreadyJoined {
|
2021-07-19 13:15:19 +01:00
|
|
|
var response api.InputRoomEventsResponse
|
2022-08-11 15:29:33 +01:00
|
|
|
if err := rsAPI.InputRoomEvents(httpReq.Context(), &api.InputRoomEventsRequest{
|
2021-07-19 13:15:19 +01:00
|
|
|
InputRoomEvents: []api.InputRoomEvent{
|
|
|
|
{
|
|
|
|
Kind: api.KindNew,
|
2023-05-02 15:03:16 +01:00
|
|
|
Event: &types.HeaderedEvent{PDU: signed},
|
2021-07-19 13:15:19 +01:00
|
|
|
SendAsServer: string(cfg.Matrix.ServerName),
|
|
|
|
TransactionID: nil,
|
|
|
|
},
|
2020-05-04 13:53:47 +01:00
|
|
|
},
|
2022-08-11 15:29:33 +01:00
|
|
|
}, &response); err != nil {
|
|
|
|
return jsonerror.InternalAPIError(httpReq.Context(), err)
|
|
|
|
}
|
2021-07-19 13:15:19 +01:00
|
|
|
if response.ErrMsg != "" {
|
|
|
|
util.GetLogger(httpReq.Context()).WithField(logrus.ErrorKey, response.ErrMsg).Error("SendEvents failed")
|
|
|
|
if response.NotAllowed {
|
|
|
|
return util.JSONResponse{
|
|
|
|
Code: http.StatusBadRequest,
|
|
|
|
JSON: jsonerror.Forbidden(response.ErrMsg),
|
|
|
|
}
|
|
|
|
}
|
2020-05-04 13:53:47 +01:00
|
|
|
return jsonerror.InternalServerError()
|
|
|
|
}
|
2017-11-29 09:38:56 +00:00
|
|
|
}
|
|
|
|
|
2020-05-12 16:24:28 +01:00
|
|
|
// sort events deterministically by depth (lower is earlier)
|
|
|
|
// We also do this because sytest's basic federation server isn't good at using the correct
|
|
|
|
// state if these lists are randomised, resulting in flakey tests. :(
|
|
|
|
sort.Sort(eventsByDepth(stateAndAuthChainResponse.StateEvents))
|
|
|
|
sort.Sort(eventsByDepth(stateAndAuthChainResponse.AuthChainEvents))
|
|
|
|
|
2020-05-05 10:53:38 +01:00
|
|
|
// https://matrix.org/docs/spec/server_server/latest#put-matrix-federation-v1-send-join-roomid-eventid
|
2017-11-29 09:38:56 +00:00
|
|
|
return util.JSONResponse{
|
2018-03-13 15:55:45 +00:00
|
|
|
Code: http.StatusOK,
|
2023-04-06 09:55:01 +01:00
|
|
|
JSON: fclient.RespSendJoin{
|
2023-04-27 12:54:20 +01:00
|
|
|
StateEvents: types.NewEventJSONsFromHeaderedEvents(stateAndAuthChainResponse.StateEvents),
|
|
|
|
AuthEvents: types.NewEventJSONsFromHeaderedEvents(stateAndAuthChainResponse.AuthChainEvents),
|
2020-05-05 10:53:38 +01:00
|
|
|
Origin: cfg.Matrix.ServerName,
|
2022-05-25 14:31:07 +01:00
|
|
|
Event: signed.JSON(),
|
2017-11-29 09:38:56 +00:00
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
2020-05-12 16:24:28 +01:00
|
|
|
|
2022-05-25 10:05:30 +01:00
|
|
|
// checkRestrictedJoin finds out whether or not we can assist in processing
|
|
|
|
// a restricted room join. If the room version does not support restricted
|
|
|
|
// joins then this function returns with no side effects. This returns three
|
|
|
|
// values:
|
2022-08-05 10:12:41 +01:00
|
|
|
// - an optional JSON response body (i.e. M_UNABLE_TO_AUTHORISE_JOIN) which
|
|
|
|
// should always be sent back to the client if one is specified
|
|
|
|
// - a user ID of an authorising user, typically a user that has power to
|
|
|
|
// issue invites in the room, if one has been found
|
|
|
|
// - an error if there was a problem finding out if this was allowable,
|
|
|
|
// like if the room version isn't known or a problem happened talking to
|
|
|
|
// the roomserver
|
2022-05-25 10:05:30 +01:00
|
|
|
func checkRestrictedJoin(
|
|
|
|
httpReq *http.Request,
|
|
|
|
rsAPI api.FederationRoomserverAPI,
|
|
|
|
roomVersion gomatrixserverlib.RoomVersion,
|
|
|
|
roomID, userID string,
|
|
|
|
) (*util.JSONResponse, string, error) {
|
2023-04-21 17:06:29 +01:00
|
|
|
verImpl, err := gomatrixserverlib.GetRoomVersion(roomVersion)
|
|
|
|
if err != nil {
|
2022-05-25 10:05:30 +01:00
|
|
|
return nil, "", err
|
2023-04-21 17:06:29 +01:00
|
|
|
}
|
|
|
|
if !verImpl.MayAllowRestrictedJoinsInEventAuth() {
|
2022-05-25 10:05:30 +01:00
|
|
|
return nil, "", nil
|
|
|
|
}
|
|
|
|
req := &api.QueryRestrictedJoinAllowedRequest{
|
|
|
|
RoomID: roomID,
|
|
|
|
UserID: userID,
|
|
|
|
}
|
|
|
|
res := &api.QueryRestrictedJoinAllowedResponse{}
|
|
|
|
if err := rsAPI.QueryRestrictedJoinAllowed(httpReq.Context(), req, res); err != nil {
|
|
|
|
return nil, "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
switch {
|
|
|
|
case !res.Restricted:
|
|
|
|
// The join rules for the room don't restrict membership.
|
|
|
|
return nil, "", nil
|
|
|
|
|
|
|
|
case !res.Resident:
|
|
|
|
// The join rules restrict membership but our server isn't currently
|
|
|
|
// joined to all of the allowed rooms, so we can't actually decide
|
|
|
|
// whether or not to allow the user to join. This error code should
|
|
|
|
// tell the joining server to try joining via another resident server
|
|
|
|
// instead.
|
|
|
|
return &util.JSONResponse{
|
|
|
|
Code: http.StatusBadRequest,
|
|
|
|
JSON: jsonerror.UnableToAuthoriseJoin("This server cannot authorise the join."),
|
|
|
|
}, "", nil
|
|
|
|
|
|
|
|
case !res.Allowed:
|
|
|
|
// The join rules restrict membership, our server is in the relevant
|
|
|
|
// rooms and the user wasn't joined to join any of the allowed rooms
|
|
|
|
// and therefore can't join this room.
|
|
|
|
return &util.JSONResponse{
|
|
|
|
Code: http.StatusForbidden,
|
|
|
|
JSON: jsonerror.Forbidden("You are not joined to any matching rooms."),
|
|
|
|
}, "", nil
|
|
|
|
|
|
|
|
default:
|
|
|
|
// The join rules restrict membership, our server is in the relevant
|
|
|
|
// rooms and the user was allowed to join because they belong to one
|
|
|
|
// of the allowed rooms. We now need to pick one of our own local users
|
|
|
|
// from within the room to use as the authorising user ID, so that it
|
|
|
|
// can be referred to from within the membership content.
|
|
|
|
return nil, res.AuthorisedVia, nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-04-27 12:54:20 +01:00
|
|
|
type eventsByDepth []*types.HeaderedEvent
|
2020-05-12 16:24:28 +01:00
|
|
|
|
|
|
|
func (e eventsByDepth) Len() int {
|
|
|
|
return len(e)
|
|
|
|
}
|
|
|
|
func (e eventsByDepth) Swap(i, j int) {
|
|
|
|
e[i], e[j] = e[j], e[i]
|
|
|
|
}
|
|
|
|
func (e eventsByDepth) Less(i, j int) bool {
|
|
|
|
return e[i].Depth() < e[j].Depth()
|
|
|
|
}
|