hoernschen/dendrite
1
0
Fork 0
mirror of https://github.com/hoernschen/dendrite.git synced 2025-07-29 12:42:46 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Unmarshal events at the Dendrite level not GMSL level (#2164)

Browse source 
* Use new event json types in gmsl

* Fix EventJSON to actually unmarshal events

* Update GMSL

* Bump GMSL and improve error messages

* Send back the correct RespState

* Update GMSL
This commit is contained in:
kegsay 2022-02-09 20:31:24 +00:00 • committed by GitHub
parent cc688a9a38
commit aa5c3b88de
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
15 changed files with 158 additions and 107 deletions
Download patch file Download diff file Expand all files Collapse all files

20
federationapi/internal/perform.go
View file

@ -201,7 +201,6 @@ func (r *FederationInternalAPI) performJoinUsingServer(
context.Background(),
serverName,
event,
respMakeJoin.RoomVersion,
)
if err != nil {
r.statistics.ForServer(serverName).Failure()
@ -209,9 +208,11 @@ func (r *FederationInternalAPI) performJoinUsingServer(
}
r.statistics.ForServer(serverName).Success()
authEvents := respSendJoin.AuthEvents.UntrustedEvents(respMakeJoin.RoomVersion)
// Sanity-check the join response to ensure that it has a create
// event, that the room version is known, etc.
if err = sanityCheckAuthChain(respSendJoin.AuthEvents); err != nil {
if err = sanityCheckAuthChain(authEvents); err != nil {
return fmt.Errorf("sanityCheckAuthChain: %w", err)
}
@ -225,6 +226,7 @@ func (r *FederationInternalAPI) performJoinUsingServer(
var respState *gomatrixserverlib.RespState
respState, err = respSendJoin.Check(
context.Background(),
respMakeJoin.RoomVersion,
r.keyRing,
event,
federatedAuthProvider(ctx, r.federation, r.keyRing, serverName),
@ -392,12 +394,13 @@ func (r *FederationInternalAPI) performOutboundPeekUsingServer(
ctx = context.Background()
respState := respPeek.ToRespState()
authEvents := respState.AuthEvents.UntrustedEvents(respPeek.RoomVersion)
// authenticate the state returned (check its auth events etc)
// the equivalent of CheckSendJoinResponse()
if err = sanityCheckAuthChain(respState.AuthEvents); err != nil {
if err = sanityCheckAuthChain(authEvents); err != nil {
return fmt.Errorf("sanityCheckAuthChain: %w", err)
}
if err = respState.Check(ctx, r.keyRing, federatedAuthProvider(ctx, r.federation, r.keyRing, serverName)); err != nil {
if err = respState.Check(ctx, respPeek.RoomVersion, r.keyRing, federatedAuthProvider(ctx, r.federation, r.keyRing, serverName)); err != nil {
return fmt.Errorf("error checking state returned from peeking: %w", err)
}
@ -549,10 +552,15 @@ func (r *FederationInternalAPI) PerformInvite(
inviteRes, err := r.federation.SendInviteV2(ctx, destination, inviteReq)
if err != nil {
return fmt.Errorf("r.federation.SendInviteV2: %w", err)
return fmt.Errorf("r.federation.SendInviteV2: failed to send invite: %w", err)
}
logrus.Infof("GOT INVITE RESPONSE %s", string(inviteRes.Event))
response.Event = inviteRes.Event.Headered(request.RoomVersion)
inviteEvent, err := inviteRes.Event.UntrustedEvent(request.RoomVersion)
if err != nil {
return fmt.Errorf("r.federation.SendInviteV2 failed to decode event response: %w", err)
}
response.Event = inviteEvent.Headered(request.RoomVersion)
return nil
}

9
federationapi/inthttp/client.go
View file

@ -387,14 +387,7 @@ func (h *httpFederationInternalAPI) LookupMissingEvents(
if request.Err != nil {
return res, request.Err
}
res.Events = make([]*gomatrixserverlib.Event, 0, len(request.Res.Events))
for _, js := range request.Res.Events {
ev, err := gomatrixserverlib.NewEventFromUntrustedJSON(js, roomVersion)
if err != nil {
return res, err
}
res.Events = append(res.Events, ev)
}
res.Events = request.Res.Events
return res, nil
}

2
federationapi/routing/eventauth.go
View file

@ -65,7 +65,7 @@ func GetEventAuth(
return util.JSONResponse{
Code: http.StatusOK,
JSON: gomatrixserverlib.RespEventAuth{
AuthEvents: gomatrixserverlib.UnwrapEventHeaders(response.AuthChainEvents),
AuthEvents: gomatrixserverlib.NewEventJSONsFromHeaderedEvents(response.AuthChainEvents),
},
}
}

4
federationapi/routing/invite.go
View file

@ -178,12 +178,12 @@ func processInvite(
if isInviteV2 {
return util.JSONResponse{
Code: http.StatusOK,
JSON: gomatrixserverlib.RespInviteV2{Event: &signedEvent},
JSON: gomatrixserverlib.RespInviteV2{Event: signedEvent.JSON()},
}
} else {
return util.JSONResponse{
Code: http.StatusOK,
JSON: gomatrixserverlib.RespInvite{Event: &signedEvent},
JSON: gomatrixserverlib.RespInvite{Event: signedEvent.JSON()},
}
}
default:

4
federationapi/routing/join.go
View file

@ -351,8 +351,8 @@ func SendJoin(
return util.JSONResponse{
Code: http.StatusOK,
JSON: gomatrixserverlib.RespSendJoin{
StateEvents: gomatrixserverlib.UnwrapEventHeaders(stateAndAuthChainResponse.StateEvents),
AuthEvents: gomatrixserverlib.UnwrapEventHeaders(stateAndAuthChainResponse.AuthChainEvents),
StateEvents: gomatrixserverlib.NewEventJSONsFromHeaderedEvents(stateAndAuthChainResponse.StateEvents),
AuthEvents: gomatrixserverlib.NewEventJSONsFromHeaderedEvents(stateAndAuthChainResponse.AuthChainEvents),
Origin: cfg.Matrix.ServerName,
},
}

2
federationapi/routing/missingevents.go
View file

@ -62,7 +62,7 @@ func GetMissingEvents(
eventsResponse.Events = filterEvents(eventsResponse.Events, roomID)
resp := gomatrixserverlib.RespMissingEvents{
Events: gomatrixserverlib.UnwrapEventHeaders(eventsResponse.Events),
Events: gomatrixserverlib.NewEventJSONsFromHeaderedEvents(eventsResponse.Events),
}
return util.JSONResponse{

4
federationapi/routing/peek.go
View file

@ -88,8 +88,8 @@ func Peek(
}
respPeek := gomatrixserverlib.RespPeek{
StateEvents: gomatrixserverlib.UnwrapEventHeaders(response.StateEvents),
AuthEvents: gomatrixserverlib.UnwrapEventHeaders(response.AuthChainEvents),
StateEvents: gomatrixserverlib.NewEventJSONsFromHeaderedEvents(response.StateEvents),
AuthEvents: gomatrixserverlib.NewEventJSONsFromHeaderedEvents(response.AuthChainEvents),
RoomVersion: response.RoomVersion,
LatestEvent: response.LatestEvent.Unwrap(),
RenewalInterval: renewalInterval,

32
federationapi/routing/state.go
View file

@ -35,12 +35,15 @@ func GetState(
return *err
}
state, err := getState(ctx, request, rsAPI, roomID, eventID)
stateEvents, authChain, err := getState(ctx, request, rsAPI, roomID, eventID)
if err != nil {
return *err
}
return util.JSONResponse{Code: http.StatusOK, JSON: state}
return util.JSONResponse{Code: http.StatusOK, JSON: &gomatrixserverlib.RespState{
AuthEvents: gomatrixserverlib.NewEventJSONsFromHeaderedEvents(authChain),
StateEvents: gomatrixserverlib.NewEventJSONsFromHeaderedEvents(stateEvents),
}}
}
// GetStateIDs returns state event IDs & auth event IDs for the roomID, eventID
@ -55,13 +58,13 @@ func GetStateIDs(
return *err
}
state, err := getState(ctx, request, rsAPI, roomID, eventID)
stateEvents, authEvents, err := getState(ctx, request, rsAPI, roomID, eventID)
if err != nil {
return *err
}
stateEventIDs := getIDsFromEvent(state.StateEvents)
authEventIDs := getIDsFromEvent(state.AuthEvents)
stateEventIDs := getIDsFromEvent(stateEvents)
authEventIDs := getIDsFromEvent(authEvents)
return util.JSONResponse{Code: http.StatusOK, JSON: gomatrixserverlib.RespStateIDs{
StateEventIDs: stateEventIDs,
@ -97,18 +100,18 @@ func getState(
rsAPI api.RoomserverInternalAPI,
roomID string,
eventID string,
) (*gomatrixserverlib.RespState, *util.JSONResponse) {
) (stateEvents, authEvents []*gomatrixserverlib.HeaderedEvent, errRes *util.JSONResponse) {
event, resErr := fetchEvent(ctx, rsAPI, eventID)
if resErr != nil {
return nil, resErr
return nil, nil, resErr
}
if event.RoomID() != roomID {
return nil, &util.JSONResponse{Code: http.StatusNotFound, JSON: jsonerror.NotFound("event does not belong to this room")}
return nil, nil, &util.JSONResponse{Code: http.StatusNotFound, JSON: jsonerror.NotFound("event does not belong to this room")}
}
resErr = allowedToSeeEvent(ctx, request.Origin(), rsAPI, eventID)
if resErr != nil {
return nil, resErr
return nil, nil, resErr
}
var response api.QueryStateAndAuthChainResponse
@ -123,20 +126,17 @@ func getState(
)
if err != nil {
resErr := util.ErrorResponse(err)
return nil, &resErr
return nil, nil, &resErr
}
if !response.RoomExists {
return nil, &util.JSONResponse{Code: http.StatusNotFound, JSON: nil}
return nil, nil, &util.JSONResponse{Code: http.StatusNotFound, JSON: nil}
}
return &gomatrixserverlib.RespState{
StateEvents: gomatrixserverlib.UnwrapEventHeaders(response.StateEvents),
AuthEvents: gomatrixserverlib.UnwrapEventHeaders(response.AuthChainEvents),
}, nil
return response.StateEvents, response.AuthChainEvents, nil
}
func getIDsFromEvent(events []*gomatrixserverlib.Event) []string {
func getIDsFromEvent(events []*gomatrixserverlib.HeaderedEvent) []string {
IDs := make([]string, len(events))
for i := range events {
IDs[i] = events[i].EventID()

7
federationapi/routing/threepid.go
View file

@ -170,13 +170,18 @@ func ExchangeThirdPartyInvite(
util.GetLogger(httpReq.Context()).WithError(err).Error("federation.SendInvite failed")
return jsonerror.InternalServerError()
}
inviteEvent, err := signedEvent.Event.UntrustedEvent(verRes.RoomVersion)
if err != nil {
util.GetLogger(httpReq.Context()).WithError(err).Error("federation.SendInvite failed")
return jsonerror.InternalServerError()
}
// Send the event to the roomserver
if err = api.SendEvents(
httpReq.Context(), rsAPI,
api.KindNew,
[]*gomatrixserverlib.HeaderedEvent{
signedEvent.Event.Headered(verRes.RoomVersion),
inviteEvent.Headered(verRes.RoomVersion),
},
request.Origin(),
cfg.Matrix.ServerName,