2017-09-08 16:17:12 +02:00
|
|
|
// Copyright 2017 Vector Creations 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.
|
|
|
|
|
2017-10-11 19:16:53 +02:00
|
|
|
package routing
|
2017-06-07 15:32:53 +02:00
|
|
|
|
|
|
|
import (
|
2017-09-13 12:03:41 +02:00
|
|
|
"context"
|
2017-06-07 15:32:53 +02:00
|
|
|
"encoding/json"
|
|
|
|
"fmt"
|
2017-08-23 16:13:47 +02:00
|
|
|
"net/http"
|
|
|
|
|
2017-06-07 15:32:53 +02:00
|
|
|
"github.com/matrix-org/dendrite/clientapi/jsonerror"
|
|
|
|
"github.com/matrix-org/dendrite/clientapi/producers"
|
2017-06-19 16:21:04 +02:00
|
|
|
"github.com/matrix-org/dendrite/common/config"
|
2017-06-07 15:32:53 +02:00
|
|
|
"github.com/matrix-org/dendrite/roomserver/api"
|
|
|
|
"github.com/matrix-org/gomatrixserverlib"
|
|
|
|
"github.com/matrix-org/util"
|
2020-05-05 16:48:37 +02:00
|
|
|
"github.com/sirupsen/logrus"
|
2017-06-07 15:32:53 +02:00
|
|
|
)
|
|
|
|
|
|
|
|
// Send implements /_matrix/federation/v1/send/{txnID}
|
|
|
|
func Send(
|
2017-09-04 14:14:01 +02:00
|
|
|
httpReq *http.Request,
|
|
|
|
request *gomatrixserverlib.FederationRequest,
|
2017-06-07 15:32:53 +02:00
|
|
|
txnID gomatrixserverlib.TransactionID,
|
2020-02-11 12:18:12 +01:00
|
|
|
cfg *config.Dendrite,
|
2020-05-01 11:48:17 +02:00
|
|
|
rsAPI api.RoomserverInternalAPI,
|
2017-06-07 15:32:53 +02:00
|
|
|
producer *producers.RoomserverProducer,
|
2020-03-30 17:40:28 +02:00
|
|
|
eduProducer *producers.EDUServerProducer,
|
2017-06-07 15:32:53 +02:00
|
|
|
keys gomatrixserverlib.KeyRing,
|
|
|
|
federation *gomatrixserverlib.FederationClient,
|
|
|
|
) util.JSONResponse {
|
|
|
|
t := txnReq{
|
2020-03-30 17:40:28 +02:00
|
|
|
context: httpReq.Context(),
|
2020-05-01 11:48:17 +02:00
|
|
|
rsAPI: rsAPI,
|
2020-03-30 17:40:28 +02:00
|
|
|
producer: producer,
|
|
|
|
eduProducer: eduProducer,
|
|
|
|
keys: keys,
|
|
|
|
federation: federation,
|
2017-06-07 15:32:53 +02:00
|
|
|
}
|
2020-03-27 17:28:22 +01:00
|
|
|
|
|
|
|
var txnEvents struct {
|
2020-03-30 17:40:28 +02:00
|
|
|
PDUs []json.RawMessage `json:"pdus"`
|
|
|
|
EDUs []gomatrixserverlib.EDU `json:"edus"`
|
2020-03-27 17:28:22 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if err := json.Unmarshal(request.Content(), &txnEvents); err != nil {
|
2017-06-07 15:32:53 +02:00
|
|
|
return util.JSONResponse{
|
2018-03-13 16:55:45 +01:00
|
|
|
Code: http.StatusBadRequest,
|
2017-08-23 16:13:47 +02:00
|
|
|
JSON: jsonerror.NotJSON("The request body could not be decoded into valid JSON. " + err.Error()),
|
2017-06-07 15:32:53 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-30 17:40:28 +02:00
|
|
|
// TODO: Really we should have a function to convert FederationRequest to txnReq
|
2020-03-27 17:28:22 +01:00
|
|
|
t.PDUs = txnEvents.PDUs
|
2020-03-30 17:40:28 +02:00
|
|
|
t.EDUs = txnEvents.EDUs
|
2017-06-07 15:32:53 +02:00
|
|
|
t.Origin = request.Origin()
|
|
|
|
t.TransactionID = txnID
|
2017-06-19 16:21:04 +02:00
|
|
|
t.Destination = cfg.Matrix.ServerName
|
2017-06-07 15:32:53 +02:00
|
|
|
|
2020-03-27 17:28:22 +01:00
|
|
|
util.GetLogger(httpReq.Context()).Infof("Received transaction %q containing %d PDUs, %d EDUs", txnID, len(t.PDUs), len(t.EDUs))
|
|
|
|
|
2017-06-07 15:32:53 +02:00
|
|
|
resp, err := t.processTransaction()
|
2020-04-16 18:59:55 +02:00
|
|
|
switch err.(type) {
|
|
|
|
// No error? Great! Send back a 200.
|
|
|
|
case nil:
|
|
|
|
return util.JSONResponse{
|
|
|
|
Code: http.StatusOK,
|
|
|
|
JSON: resp,
|
|
|
|
}
|
|
|
|
// Handle known error cases as we will return a 400 error for these.
|
|
|
|
case roomNotFoundError:
|
|
|
|
case unmarshalError:
|
|
|
|
case verifySigError:
|
|
|
|
// Handle unknown error cases. Sending 500 errors back should be a last
|
|
|
|
// resort as this can make other homeservers back off sending federation
|
|
|
|
// events.
|
|
|
|
default:
|
2020-03-02 17:20:44 +01:00
|
|
|
util.GetLogger(httpReq.Context()).WithError(err).Error("t.processTransaction failed")
|
|
|
|
return jsonerror.InternalServerError()
|
2017-06-07 15:32:53 +02:00
|
|
|
}
|
2020-04-16 18:59:55 +02:00
|
|
|
// Return a 400 error for bad requests as fallen through from above.
|
2017-06-07 15:32:53 +02:00
|
|
|
return util.JSONResponse{
|
2020-04-16 18:59:55 +02:00
|
|
|
Code: http.StatusBadRequest,
|
|
|
|
JSON: jsonerror.BadJSON(err.Error()),
|
2017-06-07 15:32:53 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type txnReq struct {
|
|
|
|
gomatrixserverlib.Transaction
|
2020-03-30 17:40:28 +02:00
|
|
|
context context.Context
|
2020-05-01 11:48:17 +02:00
|
|
|
rsAPI api.RoomserverInternalAPI
|
2020-03-30 17:40:28 +02:00
|
|
|
producer *producers.RoomserverProducer
|
|
|
|
eduProducer *producers.EDUServerProducer
|
2020-05-06 15:27:02 +02:00
|
|
|
keys gomatrixserverlib.JSONVerifier
|
|
|
|
federation txnFederationClient
|
|
|
|
}
|
|
|
|
|
|
|
|
// A subset of FederationClient functionality that txn requires. Useful for testing.
|
|
|
|
type txnFederationClient interface {
|
|
|
|
LookupState(ctx context.Context, s gomatrixserverlib.ServerName, roomID string, eventID string, roomVersion gomatrixserverlib.RoomVersion) (
|
|
|
|
res gomatrixserverlib.RespState, err error,
|
|
|
|
)
|
|
|
|
LookupStateIDs(ctx context.Context, s gomatrixserverlib.ServerName, roomID string, eventID string) (res gomatrixserverlib.RespStateIDs, err error)
|
|
|
|
GetEvent(ctx context.Context, s gomatrixserverlib.ServerName, eventID string) (res gomatrixserverlib.Transaction, err error)
|
2017-06-07 15:32:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func (t *txnReq) processTransaction() (*gomatrixserverlib.RespSend, error) {
|
2020-04-16 18:59:55 +02:00
|
|
|
results := make(map[string]gomatrixserverlib.PDUResult)
|
|
|
|
|
2020-03-27 17:28:22 +01:00
|
|
|
var pdus []gomatrixserverlib.HeaderedEvent
|
|
|
|
for _, pdu := range t.PDUs {
|
|
|
|
var header struct {
|
|
|
|
RoomID string `json:"room_id"`
|
|
|
|
}
|
|
|
|
if err := json.Unmarshal(pdu, &header); err != nil {
|
|
|
|
util.GetLogger(t.context).WithError(err).Warn("Transaction: Failed to extract room ID from event")
|
2020-04-16 18:59:55 +02:00
|
|
|
return nil, unmarshalError{err}
|
2020-03-27 17:28:22 +01:00
|
|
|
}
|
|
|
|
verReq := api.QueryRoomVersionForRoomRequest{RoomID: header.RoomID}
|
|
|
|
verRes := api.QueryRoomVersionForRoomResponse{}
|
2020-05-01 11:48:17 +02:00
|
|
|
if err := t.rsAPI.QueryRoomVersionForRoom(t.context, &verReq, &verRes); err != nil {
|
2020-03-27 17:28:22 +01:00
|
|
|
util.GetLogger(t.context).WithError(err).Warn("Transaction: Failed to query room version for room", verReq.RoomID)
|
2020-04-16 18:59:55 +02:00
|
|
|
return nil, roomNotFoundError{verReq.RoomID}
|
2020-03-27 17:28:22 +01:00
|
|
|
}
|
|
|
|
event, err := gomatrixserverlib.NewEventFromUntrustedJSON(pdu, verRes.RoomVersion)
|
|
|
|
if err != nil {
|
|
|
|
util.GetLogger(t.context).WithError(err).Warnf("Transaction: Failed to parse event JSON of event %q", event.EventID())
|
2020-04-16 18:59:55 +02:00
|
|
|
return nil, unmarshalError{err}
|
2020-03-27 17:28:22 +01:00
|
|
|
}
|
|
|
|
if err := gomatrixserverlib.VerifyAllEventSignatures(t.context, []gomatrixserverlib.Event{event}, t.keys); err != nil {
|
|
|
|
util.GetLogger(t.context).WithError(err).Warnf("Transaction: Couldn't validate signature of event %q", event.EventID())
|
2020-04-16 18:59:55 +02:00
|
|
|
return nil, verifySigError{event.EventID(), err}
|
2020-03-27 17:28:22 +01:00
|
|
|
}
|
|
|
|
pdus = append(pdus, event.Headered(verRes.RoomVersion))
|
2017-06-07 15:32:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Process the events.
|
2020-03-27 17:28:22 +01:00
|
|
|
for _, e := range pdus {
|
|
|
|
err := t.processEvent(e.Unwrap())
|
2017-06-07 15:32:53 +02:00
|
|
|
if err != nil {
|
|
|
|
// If the error is due to the event itself being bad then we skip
|
|
|
|
// it and move onto the next event. We report an error so that the
|
|
|
|
// sender knows that we have skipped processing it.
|
|
|
|
//
|
|
|
|
// However if the event is due to a temporary failure in our server
|
|
|
|
// such as a database being unavailable then we should bail, and
|
|
|
|
// hope that the sender will retry when we are feeling better.
|
|
|
|
//
|
|
|
|
// It is uncertain what we should do if an event fails because
|
|
|
|
// we failed to fetch more information from the sending server.
|
|
|
|
// For example if a request to /state fails.
|
|
|
|
// If we skip the event then we risk missing the event until we
|
|
|
|
// receive another event referencing it.
|
|
|
|
// If we bail and stop processing then we risk wedging incoming
|
|
|
|
// transactions from that server forever.
|
|
|
|
switch err.(type) {
|
2020-04-16 18:59:55 +02:00
|
|
|
case roomNotFoundError:
|
2017-06-07 15:32:53 +02:00
|
|
|
case *gomatrixserverlib.NotAllowed:
|
|
|
|
default:
|
|
|
|
// Any other error should be the result of a temporary error in
|
|
|
|
// our server so we should bail processing the transaction entirely.
|
|
|
|
return nil, err
|
|
|
|
}
|
2017-09-13 12:03:41 +02:00
|
|
|
results[e.EventID()] = gomatrixserverlib.PDUResult{
|
|
|
|
Error: err.Error(),
|
|
|
|
}
|
2020-03-16 18:51:58 +01:00
|
|
|
util.GetLogger(t.context).WithError(err).WithField("event_id", e.EventID()).Warn("Failed to process incoming federation event, skipping it.")
|
2017-06-07 15:32:53 +02:00
|
|
|
} else {
|
|
|
|
results[e.EventID()] = gomatrixserverlib.PDUResult{}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-30 17:40:28 +02:00
|
|
|
t.processEDUs(t.EDUs)
|
2020-03-27 17:28:22 +01:00
|
|
|
util.GetLogger(t.context).Infof("Processed %d PDUs from transaction %q", len(results), t.TransactionID)
|
2017-06-07 15:32:53 +02:00
|
|
|
return &gomatrixserverlib.RespSend{PDUs: results}, nil
|
|
|
|
}
|
|
|
|
|
2020-04-16 18:59:55 +02:00
|
|
|
type roomNotFoundError struct {
|
2017-06-07 15:32:53 +02:00
|
|
|
roomID string
|
|
|
|
}
|
2020-04-16 18:59:55 +02:00
|
|
|
type unmarshalError struct {
|
|
|
|
err error
|
|
|
|
}
|
|
|
|
type verifySigError struct {
|
|
|
|
eventID string
|
|
|
|
err error
|
|
|
|
}
|
2017-06-07 15:32:53 +02:00
|
|
|
|
2020-04-16 18:59:55 +02:00
|
|
|
func (e roomNotFoundError) Error() string { return fmt.Sprintf("room %q not found", e.roomID) }
|
|
|
|
func (e unmarshalError) Error() string { return fmt.Sprintf("unable to parse event: %s", e.err) }
|
|
|
|
func (e verifySigError) Error() string {
|
|
|
|
return fmt.Sprintf("unable to verify signature of event %q: %s", e.eventID, e.err)
|
|
|
|
}
|
2017-06-07 15:32:53 +02:00
|
|
|
|
2020-03-30 17:40:28 +02:00
|
|
|
func (t *txnReq) processEDUs(edus []gomatrixserverlib.EDU) {
|
|
|
|
for _, e := range edus {
|
|
|
|
switch e.Type {
|
|
|
|
case gomatrixserverlib.MTyping:
|
|
|
|
// https://matrix.org/docs/spec/server_server/latest#typing-notifications
|
|
|
|
var typingPayload struct {
|
|
|
|
RoomID string `json:"room_id"`
|
|
|
|
UserID string `json:"user_id"`
|
|
|
|
Typing bool `json:"typing"`
|
|
|
|
}
|
|
|
|
if err := json.Unmarshal(e.Content, &typingPayload); err != nil {
|
|
|
|
util.GetLogger(t.context).WithError(err).Error("Failed to unmarshal typing event")
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if err := t.eduProducer.SendTyping(t.context, typingPayload.UserID, typingPayload.RoomID, typingPayload.Typing, 30*1000); err != nil {
|
|
|
|
util.GetLogger(t.context).WithError(err).Error("Failed to send typing event to edu server")
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
util.GetLogger(t.context).WithField("type", e.Type).Warn("unhandled edu")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-07 15:32:53 +02:00
|
|
|
func (t *txnReq) processEvent(e gomatrixserverlib.Event) error {
|
2017-07-07 15:11:32 +02:00
|
|
|
prevEventIDs := e.PrevEventIDs()
|
2017-06-07 15:32:53 +02:00
|
|
|
|
|
|
|
// Fetch the state needed to authenticate the event.
|
|
|
|
needed := gomatrixserverlib.StateNeededForAuth([]gomatrixserverlib.Event{e})
|
|
|
|
stateReq := api.QueryStateAfterEventsRequest{
|
|
|
|
RoomID: e.RoomID(),
|
|
|
|
PrevEventIDs: prevEventIDs,
|
|
|
|
StateToFetch: needed.Tuples(),
|
|
|
|
}
|
|
|
|
var stateResp api.QueryStateAfterEventsResponse
|
2020-05-01 11:48:17 +02:00
|
|
|
if err := t.rsAPI.QueryStateAfterEvents(t.context, &stateReq, &stateResp); err != nil {
|
2017-06-07 15:32:53 +02:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if !stateResp.RoomExists {
|
|
|
|
// TODO: When synapse receives a message for a room it is not in it
|
|
|
|
// asks the remote server for the state of the room so that it can
|
|
|
|
// check if the remote server knows of a join "m.room.member" event
|
|
|
|
// that this server is unaware of.
|
|
|
|
// However generally speaking we should reject events for rooms we
|
|
|
|
// aren't a member of.
|
2020-04-16 18:59:55 +02:00
|
|
|
return roomNotFoundError{e.RoomID()}
|
2017-06-07 15:32:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if !stateResp.PrevEventsExist {
|
2020-03-27 17:28:22 +01:00
|
|
|
return t.processEventWithMissingState(e, stateResp.RoomVersion)
|
2017-06-07 15:32:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Check that the event is allowed by the state at the event.
|
2020-03-16 18:29:52 +01:00
|
|
|
var events []gomatrixserverlib.Event
|
|
|
|
for _, headeredEvent := range stateResp.StateEvents {
|
2020-03-27 17:28:22 +01:00
|
|
|
events = append(events, headeredEvent.Unwrap())
|
2020-03-16 18:29:52 +01:00
|
|
|
}
|
|
|
|
if err := checkAllowedByState(e, events); err != nil {
|
2017-06-07 15:32:53 +02:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: Check that the roomserver has a copy of all of the auth_events.
|
|
|
|
// TODO: Check that the event is allowed by its auth_events.
|
|
|
|
|
|
|
|
// pass the event to the roomserver
|
2020-03-27 17:28:22 +01:00
|
|
|
_, err := t.producer.SendEvents(
|
|
|
|
t.context,
|
|
|
|
[]gomatrixserverlib.HeaderedEvent{
|
|
|
|
e.Headered(stateResp.RoomVersion),
|
|
|
|
},
|
|
|
|
api.DoNotSendToOtherServers,
|
|
|
|
nil,
|
|
|
|
)
|
2018-05-26 13:03:35 +02:00
|
|
|
return err
|
2017-06-07 15:32:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func checkAllowedByState(e gomatrixserverlib.Event, stateEvents []gomatrixserverlib.Event) error {
|
|
|
|
authUsingState := gomatrixserverlib.NewAuthEvents(nil)
|
|
|
|
for i := range stateEvents {
|
2017-09-20 11:59:19 +02:00
|
|
|
err := authUsingState.AddEvent(&stateEvents[i])
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2017-06-07 15:32:53 +02:00
|
|
|
}
|
|
|
|
return gomatrixserverlib.Allowed(e, &authUsingState)
|
|
|
|
}
|
|
|
|
|
2020-03-27 17:28:22 +01:00
|
|
|
func (t *txnReq) processEventWithMissingState(e gomatrixserverlib.Event, roomVersion gomatrixserverlib.RoomVersion) error {
|
2017-06-07 15:32:53 +02:00
|
|
|
// We are missing the previous events for this events.
|
|
|
|
// This means that there is a gap in our view of the history of the
|
|
|
|
// room. There two ways that we can handle such a gap:
|
|
|
|
// 1) We can fill in the gap using /get_missing_events
|
|
|
|
// 2) We can leave the gap and request the state of the room at
|
|
|
|
// this event from the remote server using either /state_ids
|
|
|
|
// or /state.
|
|
|
|
// Synapse will attempt to do 1 and if that fails or if the gap is
|
|
|
|
// too large then it will attempt 2.
|
2017-06-12 19:30:47 +02:00
|
|
|
// Synapse will use /state_ids if possible since usually the state
|
2017-06-07 15:32:53 +02:00
|
|
|
// is largely unchanged and it is more efficient to fetch a list of
|
|
|
|
// event ids and then use /event to fetch the individual events.
|
|
|
|
// However not all version of synapse support /state_ids so you may
|
|
|
|
// need to fallback to /state.
|
|
|
|
// TODO: Attempt to fill in the gap using /get_missing_events
|
2020-05-05 16:48:37 +02:00
|
|
|
|
|
|
|
// Attempt to fetch the missing state using /state_ids and /events
|
2020-05-06 19:03:25 +02:00
|
|
|
respState, haveEventIDs, err := t.lookupMissingStateViaStateIDs(e, roomVersion)
|
2017-06-07 15:32:53 +02:00
|
|
|
if err != nil {
|
2020-05-05 16:48:37 +02:00
|
|
|
// Fallback to /state
|
|
|
|
util.GetLogger(t.context).WithError(err).Warn("processEventWithMissingState failed to /state_ids, falling back to /state")
|
|
|
|
respState, err = t.lookupMissingStateViaState(e, roomVersion)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2017-06-07 15:32:53 +02:00
|
|
|
}
|
2020-05-05 16:48:37 +02:00
|
|
|
|
2017-06-07 15:32:53 +02:00
|
|
|
// Check that the event is allowed by the state.
|
2020-03-06 17:58:10 +01:00
|
|
|
retryAllowedState:
|
2020-05-05 16:48:37 +02:00
|
|
|
if err := checkAllowedByState(e, respState.StateEvents); err != nil {
|
2020-03-06 17:58:10 +01:00
|
|
|
switch missing := err.(type) {
|
|
|
|
case gomatrixserverlib.MissingAuthEventError:
|
|
|
|
// An auth event was missing so let's look up that event over federation
|
2020-05-05 16:48:37 +02:00
|
|
|
for _, s := range respState.StateEvents {
|
2020-03-06 17:58:10 +01:00
|
|
|
if s.EventID() != missing.AuthEventID {
|
|
|
|
continue
|
|
|
|
}
|
2020-03-27 17:28:22 +01:00
|
|
|
err = t.processEventWithMissingState(s, roomVersion)
|
2020-03-06 17:58:10 +01:00
|
|
|
// If there was no error retrieving the event from federation then
|
|
|
|
// we assume that it succeeded, so retry the original state check
|
|
|
|
if err == nil {
|
|
|
|
goto retryAllowedState
|
|
|
|
}
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
}
|
2017-06-07 15:32:53 +02:00
|
|
|
return err
|
|
|
|
}
|
2020-03-27 17:28:22 +01:00
|
|
|
|
2020-05-06 19:03:25 +02:00
|
|
|
// pass the event along with the state to the roomserver using a background context so we don't
|
|
|
|
// needlessly expire
|
|
|
|
return t.producer.SendEventWithState(context.Background(), respState, e.Headered(roomVersion), haveEventIDs)
|
2020-05-05 16:48:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func (t *txnReq) lookupMissingStateViaState(e gomatrixserverlib.Event, roomVersion gomatrixserverlib.RoomVersion) (
|
|
|
|
respState *gomatrixserverlib.RespState, err error) {
|
|
|
|
state, err := t.federation.LookupState(t.context, t.Origin, e.RoomID(), e.EventID(), roomVersion)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
// Check that the returned state is valid.
|
|
|
|
if err := state.Check(t.context, t.keys); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return &state, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *txnReq) lookupMissingStateViaStateIDs(e gomatrixserverlib.Event, roomVersion gomatrixserverlib.RoomVersion) (
|
2020-05-06 19:03:25 +02:00
|
|
|
*gomatrixserverlib.RespState, map[string]bool, error) {
|
2020-05-05 16:48:37 +02:00
|
|
|
|
|
|
|
// fetch the state event IDs at the time of the event
|
|
|
|
stateIDs, err := t.federation.LookupStateIDs(t.context, t.Origin, e.RoomID(), e.EventID())
|
|
|
|
if err != nil {
|
2020-05-06 19:03:25 +02:00
|
|
|
return nil, nil, err
|
2020-05-05 16:48:37 +02:00
|
|
|
}
|
2020-05-05 17:46:22 +02:00
|
|
|
|
|
|
|
// fetch as many as we can from the roomserver, do them as 2 calls rather than
|
|
|
|
// 1 to try to reduce the number of parameters in the bulk query this will use
|
|
|
|
haveEventMap := make(map[string]*gomatrixserverlib.HeaderedEvent, len(stateIDs.StateEventIDs))
|
2020-05-06 19:03:25 +02:00
|
|
|
haveEventIDs := make(map[string]bool)
|
2020-05-05 17:46:22 +02:00
|
|
|
for _, eventList := range [][]string{stateIDs.StateEventIDs, stateIDs.AuthEventIDs} {
|
|
|
|
queryReq := api.QueryEventsByIDRequest{
|
|
|
|
EventIDs: eventList,
|
|
|
|
}
|
|
|
|
var queryRes api.QueryEventsByIDResponse
|
2020-05-06 19:03:25 +02:00
|
|
|
if err = t.rsAPI.QueryEventsByID(t.context, &queryReq, &queryRes); err != nil {
|
|
|
|
return nil, nil, err
|
2020-05-05 17:46:22 +02:00
|
|
|
}
|
|
|
|
// allow indexing of current state by event ID
|
|
|
|
for i := range queryRes.Events {
|
|
|
|
haveEventMap[queryRes.Events[i].EventID()] = &queryRes.Events[i]
|
2020-05-06 19:03:25 +02:00
|
|
|
haveEventIDs[queryRes.Events[i].EventID()] = true
|
2020-05-05 17:46:22 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-05 16:48:37 +02:00
|
|
|
// work out which auth/state IDs are missing
|
|
|
|
wantIDs := append(stateIDs.StateEventIDs, stateIDs.AuthEventIDs...)
|
|
|
|
missing := make(map[string]bool)
|
|
|
|
for _, sid := range wantIDs {
|
|
|
|
if _, ok := haveEventMap[sid]; !ok {
|
|
|
|
missing[sid] = true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
util.GetLogger(t.context).WithFields(logrus.Fields{
|
|
|
|
"missing": len(missing),
|
|
|
|
"event_id": e.EventID(),
|
|
|
|
"room_id": e.RoomID(),
|
2020-05-05 17:46:22 +02:00
|
|
|
"already_have": len(haveEventMap),
|
2020-05-05 16:48:37 +02:00
|
|
|
"total_state": len(stateIDs.StateEventIDs),
|
|
|
|
"total_auth_events": len(stateIDs.AuthEventIDs),
|
|
|
|
}).Info("Fetching missing state at event")
|
|
|
|
|
|
|
|
for missingEventID := range missing {
|
2020-05-06 19:03:25 +02:00
|
|
|
var txn gomatrixserverlib.Transaction
|
|
|
|
txn, err = t.federation.GetEvent(t.context, t.Origin, missingEventID)
|
2020-05-05 16:48:37 +02:00
|
|
|
if err != nil {
|
|
|
|
util.GetLogger(t.context).WithError(err).WithField("event_id", missingEventID).Warn("failed to get missing /event for event ID")
|
2020-05-06 19:03:25 +02:00
|
|
|
return nil, nil, err
|
2020-05-05 16:48:37 +02:00
|
|
|
}
|
|
|
|
for _, pdu := range txn.PDUs {
|
2020-05-06 19:03:25 +02:00
|
|
|
var event gomatrixserverlib.Event
|
|
|
|
event, err = gomatrixserverlib.NewEventFromUntrustedJSON(pdu, roomVersion)
|
2020-05-05 16:48:37 +02:00
|
|
|
if err != nil {
|
|
|
|
util.GetLogger(t.context).WithError(err).Warnf("Transaction: Failed to parse event JSON of event %q", event.EventID())
|
2020-05-06 19:03:25 +02:00
|
|
|
return nil, nil, unmarshalError{err}
|
2020-05-05 16:48:37 +02:00
|
|
|
}
|
2020-05-06 19:03:25 +02:00
|
|
|
if err = gomatrixserverlib.VerifyAllEventSignatures(t.context, []gomatrixserverlib.Event{event}, t.keys); err != nil {
|
2020-05-05 16:48:37 +02:00
|
|
|
util.GetLogger(t.context).WithError(err).Warnf("Transaction: Couldn't validate signature of event %q", event.EventID())
|
2020-05-06 19:03:25 +02:00
|
|
|
return nil, nil, verifySigError{event.EventID(), err}
|
2020-05-05 16:48:37 +02:00
|
|
|
}
|
|
|
|
h := event.Headered(roomVersion)
|
|
|
|
haveEventMap[event.EventID()] = &h
|
|
|
|
}
|
|
|
|
}
|
2020-05-06 19:03:25 +02:00
|
|
|
resp, err := t.createRespStateFromStateIDs(stateIDs, haveEventMap)
|
|
|
|
return resp, haveEventIDs, err
|
2020-05-05 16:48:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func (t *txnReq) createRespStateFromStateIDs(stateIDs gomatrixserverlib.RespStateIDs, haveEventMap map[string]*gomatrixserverlib.HeaderedEvent) (
|
|
|
|
*gomatrixserverlib.RespState, error) {
|
|
|
|
// create a RespState response using the response to /state_ids as a guide
|
|
|
|
respState := gomatrixserverlib.RespState{
|
|
|
|
AuthEvents: make([]gomatrixserverlib.Event, len(stateIDs.AuthEventIDs)),
|
|
|
|
StateEvents: make([]gomatrixserverlib.Event, len(stateIDs.StateEventIDs)),
|
|
|
|
}
|
|
|
|
|
|
|
|
for i := range stateIDs.StateEventIDs {
|
|
|
|
ev, ok := haveEventMap[stateIDs.StateEventIDs[i]]
|
|
|
|
if !ok {
|
|
|
|
return nil, fmt.Errorf("missing state event %s", stateIDs.StateEventIDs[i])
|
|
|
|
}
|
|
|
|
respState.StateEvents[i] = ev.Unwrap()
|
|
|
|
}
|
|
|
|
for i := range stateIDs.AuthEventIDs {
|
|
|
|
ev, ok := haveEventMap[stateIDs.AuthEventIDs[i]]
|
|
|
|
if !ok {
|
|
|
|
return nil, fmt.Errorf("missing auth event %s", stateIDs.AuthEventIDs[i])
|
|
|
|
}
|
|
|
|
respState.AuthEvents[i] = ev.Unwrap()
|
|
|
|
}
|
|
|
|
// Check that the returned state is valid.
|
|
|
|
if err := respState.Check(t.context, t.keys); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return &respState, nil
|
2017-06-07 15:32:53 +02:00
|
|
|
}
|