2014-08-27 12:59:36 -04:00
|
|
|
# -*- coding: utf-8 -*-
|
2019-06-12 05:31:37 -04:00
|
|
|
# Copyright 2014-2016 OpenMarket Ltd
|
|
|
|
# Copyright 2017-2018 New Vector Ltd
|
|
|
|
# Copyright 2019 The Matrix.org Foundation C.I.C.
|
2014-08-27 12:59:36 -04:00
|
|
|
#
|
|
|
|
# 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.
|
2018-04-27 06:40:06 -04:00
|
|
|
import logging
|
2020-08-24 13:58:56 -04:00
|
|
|
import random
|
2020-08-12 10:05:50 -04:00
|
|
|
from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
|
2018-04-27 06:40:06 -04:00
|
|
|
|
2020-08-19 07:26:03 -04:00
|
|
|
from canonicaljson import encode_canonical_json
|
2018-07-09 02:09:20 -04:00
|
|
|
|
2019-12-03 14:19:45 -05:00
|
|
|
from twisted.internet.interfaces import IDelayedCall
|
2014-08-27 12:59:36 -04:00
|
|
|
|
2019-07-17 14:08:02 -04:00
|
|
|
from synapse import event_auth
|
2019-12-03 14:19:45 -05:00
|
|
|
from synapse.api.constants import (
|
|
|
|
EventContentFields,
|
|
|
|
EventTypes,
|
|
|
|
Membership,
|
|
|
|
RelationTypes,
|
|
|
|
UserTypes,
|
|
|
|
)
|
2018-08-15 11:35:22 -04:00
|
|
|
from synapse.api.errors import (
|
|
|
|
AuthError,
|
|
|
|
Codes,
|
|
|
|
ConsentNotGivenError,
|
|
|
|
NotFoundError,
|
2020-08-24 13:58:56 -04:00
|
|
|
ShadowBanError,
|
2018-08-15 11:35:22 -04:00
|
|
|
SynapseError,
|
|
|
|
)
|
2020-01-28 09:18:29 -05:00
|
|
|
from synapse.api.room_versions import KNOWN_ROOM_VERSIONS, RoomVersions
|
2018-05-22 03:56:52 -04:00
|
|
|
from synapse.api.urls import ConsentURIBuilder
|
2020-05-22 09:21:54 -04:00
|
|
|
from synapse.events import EventBase
|
2020-07-22 12:29:15 -04:00
|
|
|
from synapse.events.builder import EventBuilder
|
|
|
|
from synapse.events.snapshot import EventContext
|
2014-12-10 12:59:47 -05:00
|
|
|
from synapse.events.validator import EventValidator
|
2019-07-03 10:07:04 -04:00
|
|
|
from synapse.logging.context import run_in_background
|
2019-06-19 06:33:03 -04:00
|
|
|
from synapse.metrics.background_process_metrics import run_as_background_process
|
2018-07-31 08:53:54 -04:00
|
|
|
from synapse.replication.http.send_event import ReplicationSendEventRestServlet
|
2020-08-05 16:38:57 -04:00
|
|
|
from synapse.storage.databases.main.events_worker import EventRedactBehaviour
|
2018-10-25 12:49:55 -04:00
|
|
|
from synapse.storage.state import StateFilter
|
2020-09-01 08:39:04 -04:00
|
|
|
from synapse.types import Requester, RoomAlias, StreamToken, UserID, create_requester
|
2020-10-28 11:51:15 -04:00
|
|
|
from synapse.util import json_decoder, json_encoder
|
2018-08-10 09:50:21 -04:00
|
|
|
from synapse.util.async_helpers import Linearizer
|
2016-08-23 10:23:39 -04:00
|
|
|
from synapse.util.metrics import measure_func
|
2018-08-15 11:35:22 -04:00
|
|
|
from synapse.visibility import filter_events_for_client
|
2014-12-10 12:59:47 -05:00
|
|
|
|
2014-09-05 16:35:56 -04:00
|
|
|
from ._base import BaseHandler
|
2014-08-27 12:59:36 -04:00
|
|
|
|
2020-07-09 05:40:19 -04:00
|
|
|
if TYPE_CHECKING:
|
2020-10-09 08:46:36 -04:00
|
|
|
from synapse.events.third_party_rules import ThirdPartyEventRules
|
2020-07-09 05:40:19 -04:00
|
|
|
from synapse.server import HomeServer
|
|
|
|
|
2014-08-27 12:59:36 -04:00
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
|
|
|
2020-09-04 06:54:56 -04:00
|
|
|
class MessageHandler:
|
2021-02-16 17:32:34 -05:00
|
|
|
"""Contains some read only APIs to get state about a room"""
|
2014-08-27 12:59:36 -04:00
|
|
|
|
|
|
|
def __init__(self, hs):
|
2018-07-18 10:22:02 -04:00
|
|
|
self.auth = hs.get_auth()
|
|
|
|
self.clock = hs.get_clock()
|
2015-02-09 12:41:29 -05:00
|
|
|
self.state = hs.get_state_handler()
|
2018-07-18 10:22:02 -04:00
|
|
|
self.store = hs.get_datastore()
|
2019-10-23 12:25:54 -04:00
|
|
|
self.storage = hs.get_storage()
|
|
|
|
self.state_store = self.storage.state
|
2019-05-09 08:21:57 -04:00
|
|
|
self._event_serializer = hs.get_event_client_serializer()
|
2019-12-03 14:19:45 -05:00
|
|
|
self._ephemeral_events_enabled = hs.config.enable_ephemeral_messages
|
|
|
|
|
|
|
|
# The scheduled call to self._expire_event. None if no call is currently
|
|
|
|
# scheduled.
|
|
|
|
self._scheduled_expiry = None # type: Optional[IDelayedCall]
|
|
|
|
|
|
|
|
if not hs.config.worker_app:
|
|
|
|
run_as_background_process(
|
|
|
|
"_schedule_next_expiry", self._schedule_next_expiry
|
|
|
|
)
|
2018-07-18 10:22:02 -04:00
|
|
|
|
2020-07-22 12:29:15 -04:00
|
|
|
async def get_room_data(
|
2021-02-16 17:32:34 -05:00
|
|
|
self,
|
|
|
|
user_id: str,
|
|
|
|
room_id: str,
|
|
|
|
event_type: str,
|
|
|
|
state_key: str,
|
2020-07-22 12:29:15 -04:00
|
|
|
) -> dict:
|
2021-02-16 17:32:34 -05:00
|
|
|
"""Get data from a room.
|
2018-07-18 10:22:02 -04:00
|
|
|
|
|
|
|
Args:
|
2020-07-22 12:29:15 -04:00
|
|
|
user_id
|
|
|
|
room_id
|
|
|
|
event_type
|
|
|
|
state_key
|
2018-07-18 10:22:02 -04:00
|
|
|
Returns:
|
|
|
|
The path data content.
|
|
|
|
Raises:
|
2020-08-26 10:07:35 -04:00
|
|
|
SynapseError or AuthError if the user is not in the room
|
2018-07-18 10:22:02 -04:00
|
|
|
"""
|
2019-10-31 11:43:24 -04:00
|
|
|
(
|
|
|
|
membership,
|
|
|
|
membership_event_id,
|
2020-07-22 12:29:15 -04:00
|
|
|
) = await self.auth.check_user_in_room_or_world_readable(
|
2020-02-18 18:14:57 -05:00
|
|
|
room_id, user_id, allow_departed_users=True
|
|
|
|
)
|
2018-07-18 10:22:02 -04:00
|
|
|
|
|
|
|
if membership == Membership.JOIN:
|
2020-07-22 12:29:15 -04:00
|
|
|
data = await self.state.get_current_state(room_id, event_type, state_key)
|
2018-07-18 10:22:02 -04:00
|
|
|
elif membership == Membership.LEAVE:
|
|
|
|
key = (event_type, state_key)
|
2020-07-22 12:29:15 -04:00
|
|
|
room_state = await self.state_store.get_state_for_events(
|
2018-10-25 12:49:55 -04:00
|
|
|
[membership_event_id], StateFilter.from_types([key])
|
2018-07-18 10:22:02 -04:00
|
|
|
)
|
|
|
|
data = room_state[membership_event_id].get(key)
|
2020-08-26 10:07:35 -04:00
|
|
|
else:
|
|
|
|
# check_user_in_room_or_world_readable, if it doesn't raise an AuthError, should
|
|
|
|
# only ever return a Membership.JOIN/LEAVE object
|
|
|
|
#
|
|
|
|
# Safeguard in case it returned something else
|
|
|
|
logger.error(
|
|
|
|
"Attempted to retrieve data from a room for a user that has never been in it. "
|
|
|
|
"This should not have happened."
|
|
|
|
)
|
|
|
|
raise SynapseError(403, "User not in room", errcode=Codes.FORBIDDEN)
|
2018-07-18 10:22:02 -04:00
|
|
|
|
2019-07-23 09:00:55 -04:00
|
|
|
return data
|
2018-07-18 10:22:02 -04:00
|
|
|
|
2020-07-22 12:29:15 -04:00
|
|
|
async def get_state_events(
|
2019-06-20 05:32:02 -04:00
|
|
|
self,
|
2020-07-22 12:29:15 -04:00
|
|
|
user_id: str,
|
|
|
|
room_id: str,
|
|
|
|
state_filter: StateFilter = StateFilter.all(),
|
|
|
|
at_token: Optional[StreamToken] = None,
|
|
|
|
is_guest: bool = False,
|
|
|
|
) -> List[dict]:
|
2018-07-18 10:22:02 -04:00
|
|
|
"""Retrieve all state events for a given room. If the user is
|
|
|
|
joined to the room then return the current state. If the user has
|
2018-08-15 11:35:22 -04:00
|
|
|
left the room return the state events from when they left. If an explicit
|
|
|
|
'at' parameter is passed, return the state events as of that event, if
|
|
|
|
visible.
|
2018-07-18 10:22:02 -04:00
|
|
|
|
|
|
|
Args:
|
2020-07-22 12:29:15 -04:00
|
|
|
user_id: The user requesting state events.
|
|
|
|
room_id: The room ID to get all state events from.
|
|
|
|
state_filter: The state filter used to fetch state from the database.
|
|
|
|
at_token: the stream token of the at which we are requesting
|
2018-08-15 11:35:22 -04:00
|
|
|
the stats. If the user is not allowed to view the state as of that
|
|
|
|
stream token, we raise a 403 SynapseError. If None, returns the current
|
|
|
|
state based on the current_state_events table.
|
2020-07-22 12:29:15 -04:00
|
|
|
is_guest: whether this user is a guest
|
2018-07-18 10:22:02 -04:00
|
|
|
Returns:
|
|
|
|
A list of dicts representing state events. [{}, {}, {}]
|
2018-08-15 11:35:22 -04:00
|
|
|
Raises:
|
|
|
|
NotFoundError (404) if the at token does not yield an event
|
|
|
|
|
|
|
|
AuthError (403) if the user doesn't have permission to view
|
|
|
|
members of this room.
|
2018-07-18 10:22:02 -04:00
|
|
|
"""
|
2018-08-15 11:35:22 -04:00
|
|
|
if at_token:
|
|
|
|
# FIXME this claims to get the state at a stream position, but
|
|
|
|
# get_recent_events_for_room operates by topo ordering. This therefore
|
|
|
|
# does not reliably give you the state at the given stream position.
|
|
|
|
# (https://github.com/matrix-org/synapse/issues/3305)
|
2020-07-22 12:29:15 -04:00
|
|
|
last_events, _ = await self.store.get_recent_events_for_room(
|
2019-06-20 05:32:02 -04:00
|
|
|
room_id, end_token=at_token.room_key, limit=1
|
2018-08-15 11:35:22 -04:00
|
|
|
)
|
2018-07-18 10:22:02 -04:00
|
|
|
|
2018-08-15 11:35:22 -04:00
|
|
|
if not last_events:
|
2019-06-20 05:32:02 -04:00
|
|
|
raise NotFoundError("Can't find event for token %s" % (at_token,))
|
2018-08-15 11:35:22 -04:00
|
|
|
|
2020-07-22 12:29:15 -04:00
|
|
|
visible_events = await filter_events_for_client(
|
2021-02-16 17:32:34 -05:00
|
|
|
self.storage,
|
|
|
|
user_id,
|
|
|
|
last_events,
|
|
|
|
filter_send_to_client=False,
|
2018-07-18 10:22:02 -04:00
|
|
|
)
|
2018-08-15 11:35:22 -04:00
|
|
|
|
|
|
|
event = last_events[0]
|
|
|
|
if visible_events:
|
2020-07-22 12:29:15 -04:00
|
|
|
room_state = await self.state_store.get_state_for_events(
|
2019-06-20 05:32:02 -04:00
|
|
|
[event.event_id], state_filter=state_filter
|
2018-08-15 11:35:22 -04:00
|
|
|
)
|
|
|
|
room_state = room_state[event.event_id]
|
|
|
|
else:
|
|
|
|
raise AuthError(
|
|
|
|
403,
|
2019-06-20 05:32:02 -04:00
|
|
|
"User %s not allowed to view events in room %s at token %s"
|
|
|
|
% (user_id, room_id, at_token),
|
2018-08-15 11:35:22 -04:00
|
|
|
)
|
|
|
|
else:
|
2019-10-31 11:43:24 -04:00
|
|
|
(
|
|
|
|
membership,
|
|
|
|
membership_event_id,
|
2020-07-22 12:29:15 -04:00
|
|
|
) = await self.auth.check_user_in_room_or_world_readable(
|
2020-02-18 18:14:57 -05:00
|
|
|
room_id, user_id, allow_departed_users=True
|
|
|
|
)
|
2018-08-15 11:35:22 -04:00
|
|
|
|
|
|
|
if membership == Membership.JOIN:
|
2020-07-22 12:29:15 -04:00
|
|
|
state_ids = await self.store.get_filtered_current_state_ids(
|
2019-06-20 05:32:02 -04:00
|
|
|
room_id, state_filter=state_filter
|
2018-08-15 11:35:22 -04:00
|
|
|
)
|
2020-07-22 12:29:15 -04:00
|
|
|
room_state = await self.store.get_events(state_ids.values())
|
2018-08-15 11:35:22 -04:00
|
|
|
elif membership == Membership.LEAVE:
|
2020-07-22 12:29:15 -04:00
|
|
|
room_state = await self.state_store.get_state_for_events(
|
2019-06-20 05:32:02 -04:00
|
|
|
[membership_event_id], state_filter=state_filter
|
2018-08-15 11:35:22 -04:00
|
|
|
)
|
|
|
|
room_state = room_state[membership_event_id]
|
2018-07-18 10:22:02 -04:00
|
|
|
|
|
|
|
now = self.clock.time_msec()
|
2020-07-22 12:29:15 -04:00
|
|
|
events = await self._event_serializer.serialize_events(
|
2019-06-20 05:32:02 -04:00
|
|
|
room_state.values(),
|
|
|
|
now,
|
2019-05-24 04:52:33 -04:00
|
|
|
# We don't bother bundling aggregations in when asked for state
|
|
|
|
# events, as clients won't use them.
|
|
|
|
bundle_aggregations=False,
|
2018-07-18 10:22:02 -04:00
|
|
|
)
|
2019-07-23 09:00:55 -04:00
|
|
|
return events
|
2018-07-18 10:22:02 -04:00
|
|
|
|
2020-07-22 12:29:15 -04:00
|
|
|
async def get_joined_members(self, requester: Requester, room_id: str) -> dict:
|
2018-07-18 10:22:02 -04:00
|
|
|
"""Get all the joined members in the room and their profile information.
|
|
|
|
|
|
|
|
If the user has left the room return the state events from when they left.
|
|
|
|
|
|
|
|
Args:
|
2020-07-22 12:29:15 -04:00
|
|
|
requester: The user requesting state events.
|
|
|
|
room_id: The room ID to get all state events from.
|
2018-07-18 10:22:02 -04:00
|
|
|
Returns:
|
|
|
|
A dict of user_id to profile info
|
|
|
|
"""
|
|
|
|
user_id = requester.user.to_string()
|
|
|
|
if not requester.app_service:
|
|
|
|
# We check AS auth after fetching the room membership, as it
|
|
|
|
# requires us to pull out all joined members anyway.
|
2020-07-22 12:29:15 -04:00
|
|
|
membership, _ = await self.auth.check_user_in_room_or_world_readable(
|
2020-02-18 18:14:57 -05:00
|
|
|
room_id, user_id, allow_departed_users=True
|
2018-07-18 10:22:02 -04:00
|
|
|
)
|
|
|
|
if membership != Membership.JOIN:
|
|
|
|
raise NotImplementedError(
|
|
|
|
"Getting joined members after leaving is not implemented"
|
|
|
|
)
|
|
|
|
|
2020-07-22 12:29:15 -04:00
|
|
|
users_with_profile = await self.state.get_current_users_in_room(room_id)
|
2018-07-18 10:22:02 -04:00
|
|
|
|
|
|
|
# If this is an AS, double check that they are allowed to see the members.
|
|
|
|
# This can either be because the AS user is in the room or because there
|
|
|
|
# is a user in the room that the AS is "interested in"
|
|
|
|
if requester.app_service and user_id not in users_with_profile:
|
|
|
|
for uid in users_with_profile:
|
|
|
|
if requester.app_service.is_interested_in_user(uid):
|
|
|
|
break
|
|
|
|
else:
|
|
|
|
# Loop fell through, AS has no interested users in room
|
|
|
|
raise AuthError(403, "Appservice not in room")
|
|
|
|
|
2019-07-23 09:00:55 -04:00
|
|
|
return {
|
|
|
|
user_id: {
|
|
|
|
"avatar_url": profile.avatar_url,
|
|
|
|
"display_name": profile.display_name,
|
2018-07-18 10:22:02 -04:00
|
|
|
}
|
2020-06-15 07:03:36 -04:00
|
|
|
for user_id, profile in users_with_profile.items()
|
2019-07-23 09:00:55 -04:00
|
|
|
}
|
2018-07-18 10:22:02 -04:00
|
|
|
|
2020-07-22 12:29:15 -04:00
|
|
|
def maybe_schedule_expiry(self, event: EventBase):
|
2019-12-03 14:19:45 -05:00
|
|
|
"""Schedule the expiry of an event if there's not already one scheduled,
|
|
|
|
or if the one running is for an event that will expire after the provided
|
|
|
|
timestamp.
|
|
|
|
|
|
|
|
This function needs to invalidate the event cache, which is only possible on
|
|
|
|
the master process, and therefore needs to be run on there.
|
|
|
|
|
|
|
|
Args:
|
2020-07-22 12:29:15 -04:00
|
|
|
event: The event to schedule the expiry of.
|
2019-12-03 14:19:45 -05:00
|
|
|
"""
|
|
|
|
|
|
|
|
expiry_ts = event.content.get(EventContentFields.SELF_DESTRUCT_AFTER)
|
|
|
|
if not isinstance(expiry_ts, int) or event.is_state():
|
|
|
|
return
|
|
|
|
|
|
|
|
# _schedule_expiry_for_event won't actually schedule anything if there's already
|
|
|
|
# a task scheduled for a timestamp that's sooner than the provided one.
|
|
|
|
self._schedule_expiry_for_event(event.event_id, expiry_ts)
|
|
|
|
|
2020-07-22 12:29:15 -04:00
|
|
|
async def _schedule_next_expiry(self):
|
2019-12-03 14:19:45 -05:00
|
|
|
"""Retrieve the ID and the expiry timestamp of the next event to be expired,
|
|
|
|
and schedule an expiry task for it.
|
|
|
|
|
|
|
|
If there's no event left to expire, set _expiry_scheduled to None so that a
|
|
|
|
future call to save_expiry_ts can schedule a new expiry task.
|
|
|
|
"""
|
|
|
|
# Try to get the expiry timestamp of the next event to expire.
|
2020-07-22 12:29:15 -04:00
|
|
|
res = await self.store.get_next_event_to_expire()
|
2019-12-03 14:19:45 -05:00
|
|
|
if res:
|
|
|
|
event_id, expiry_ts = res
|
|
|
|
self._schedule_expiry_for_event(event_id, expiry_ts)
|
|
|
|
|
2020-07-22 12:29:15 -04:00
|
|
|
def _schedule_expiry_for_event(self, event_id: str, expiry_ts: int):
|
2019-12-03 14:19:45 -05:00
|
|
|
"""Schedule an expiry task for the provided event if there's not already one
|
|
|
|
scheduled at a timestamp that's sooner than the provided one.
|
|
|
|
|
|
|
|
Args:
|
2020-07-22 12:29:15 -04:00
|
|
|
event_id: The ID of the event to expire.
|
|
|
|
expiry_ts: The timestamp at which to expire the event.
|
2019-12-03 14:19:45 -05:00
|
|
|
"""
|
|
|
|
if self._scheduled_expiry:
|
|
|
|
# If the provided timestamp refers to a time before the scheduled time of the
|
|
|
|
# next expiry task, cancel that task and reschedule it for this timestamp.
|
|
|
|
next_scheduled_expiry_ts = self._scheduled_expiry.getTime() * 1000
|
|
|
|
if expiry_ts < next_scheduled_expiry_ts:
|
|
|
|
self._scheduled_expiry.cancel()
|
|
|
|
else:
|
|
|
|
return
|
|
|
|
|
|
|
|
# Figure out how many seconds we need to wait before expiring the event.
|
|
|
|
now_ms = self.clock.time_msec()
|
|
|
|
delay = (expiry_ts - now_ms) / 1000
|
|
|
|
|
|
|
|
# callLater doesn't support negative delays, so trim the delay to 0 if we're
|
|
|
|
# in that case.
|
|
|
|
if delay < 0:
|
|
|
|
delay = 0
|
|
|
|
|
|
|
|
logger.info("Scheduling expiry for event %s in %.3fs", event_id, delay)
|
|
|
|
|
|
|
|
self._scheduled_expiry = self.clock.call_later(
|
|
|
|
delay,
|
|
|
|
run_as_background_process,
|
|
|
|
"_expire_event",
|
|
|
|
self._expire_event,
|
|
|
|
event_id,
|
|
|
|
)
|
|
|
|
|
2020-07-22 12:29:15 -04:00
|
|
|
async def _expire_event(self, event_id: str):
|
2019-12-03 14:19:45 -05:00
|
|
|
"""Retrieve and expire an event that needs to be expired from the database.
|
|
|
|
|
|
|
|
If the event doesn't exist in the database, log it and delete the expiry date
|
|
|
|
from the database (so that we don't try to expire it again).
|
|
|
|
"""
|
|
|
|
assert self._ephemeral_events_enabled
|
|
|
|
|
|
|
|
self._scheduled_expiry = None
|
|
|
|
|
|
|
|
logger.info("Expiring event %s", event_id)
|
|
|
|
|
|
|
|
try:
|
|
|
|
# Expire the event if we know about it. This function also deletes the expiry
|
|
|
|
# date from the database in the same database transaction.
|
2020-07-22 12:29:15 -04:00
|
|
|
await self.store.expire_event(event_id)
|
2019-12-03 14:19:45 -05:00
|
|
|
except Exception as e:
|
|
|
|
logger.error("Could not expire event %s: %r", event_id, e)
|
|
|
|
|
|
|
|
# Schedule the expiry of the next event to expire.
|
2020-07-22 12:29:15 -04:00
|
|
|
await self._schedule_next_expiry()
|
2019-12-03 14:19:45 -05:00
|
|
|
|
2018-07-18 10:22:02 -04:00
|
|
|
|
2019-09-26 06:47:53 -04:00
|
|
|
# The duration (in ms) after which rooms should be removed
|
|
|
|
# `_rooms_to_exclude_from_dummy_event_insertion` (with the effect that we will try
|
|
|
|
# to generate a dummy event for them once more)
|
|
|
|
#
|
|
|
|
_DUMMY_EVENT_ROOM_EXCLUSION_EXPIRY = 7 * 24 * 60 * 60 * 1000
|
|
|
|
|
|
|
|
|
2020-09-04 06:54:56 -04:00
|
|
|
class EventCreationHandler:
|
2020-07-09 05:40:19 -04:00
|
|
|
def __init__(self, hs: "HomeServer"):
|
2018-01-15 11:51:53 -05:00
|
|
|
self.hs = hs
|
|
|
|
self.auth = hs.get_auth()
|
|
|
|
self.store = hs.get_datastore()
|
2019-10-23 07:02:36 -04:00
|
|
|
self.storage = hs.get_storage()
|
2018-01-15 11:51:53 -05:00
|
|
|
self.state = hs.get_state_handler()
|
|
|
|
self.clock = hs.get_clock()
|
|
|
|
self.validator = EventValidator()
|
|
|
|
self.profile_handler = hs.get_profile_handler()
|
|
|
|
self.event_builder_factory = hs.get_event_builder_factory()
|
|
|
|
self.server_name = hs.hostname
|
|
|
|
self.notifier = hs.get_notifier()
|
2018-02-05 12:22:16 -05:00
|
|
|
self.config = hs.config
|
2019-05-08 12:01:30 -04:00
|
|
|
self.require_membership_for_aliases = hs.config.require_membership_for_aliases
|
2020-09-14 05:16:41 -04:00
|
|
|
self._events_shard_config = self.config.worker.events_shard_config
|
|
|
|
self._instance_name = hs.get_instance_name()
|
2018-02-05 12:22:16 -05:00
|
|
|
|
2019-12-09 06:50:34 -05:00
|
|
|
self.room_invite_state_types = self.hs.config.room_invite_state_types
|
|
|
|
|
2021-02-19 04:50:41 -05:00
|
|
|
self.membership_types_to_include_profile_data_in = (
|
|
|
|
{Membership.JOIN, Membership.INVITE}
|
|
|
|
if self.hs.config.include_profile_data_on_invite
|
|
|
|
else {Membership.JOIN}
|
|
|
|
)
|
|
|
|
|
2020-05-22 11:11:35 -04:00
|
|
|
self.send_event = ReplicationSendEventRestServlet.make_client(hs)
|
2018-01-15 11:51:53 -05:00
|
|
|
|
|
|
|
# This is only used to get at ratelimit function, and maybe_kick_guest_users
|
|
|
|
self.base_handler = BaseHandler(hs)
|
|
|
|
|
|
|
|
# We arbitrarily limit concurrent event creation for a room to 5.
|
|
|
|
# This is to stop us from diverging history *too* much.
|
2018-07-20 08:11:43 -04:00
|
|
|
self.limiter = Linearizer(max_count=5, name="room_event_creation_limit")
|
2018-01-15 11:51:53 -05:00
|
|
|
|
|
|
|
self.action_generator = hs.get_action_generator()
|
|
|
|
|
|
|
|
self.spam_checker = hs.get_spam_checker()
|
2020-10-09 08:46:36 -04:00
|
|
|
self.third_party_event_rules = (
|
|
|
|
self.hs.get_third_party_event_rules()
|
|
|
|
) # type: ThirdPartyEventRules
|
2018-01-15 11:51:53 -05:00
|
|
|
|
2019-03-19 07:38:59 -04:00
|
|
|
self._block_events_without_consent_error = (
|
|
|
|
self.config.block_events_without_consent_error
|
|
|
|
)
|
|
|
|
|
2020-10-13 08:20:32 -04:00
|
|
|
# we need to construct a ConsentURIBuilder here, as it checks that the necessary
|
|
|
|
# config options, but *only* if we have a configuration for which we are
|
|
|
|
# going to need it.
|
|
|
|
if self._block_events_without_consent_error:
|
|
|
|
self._consent_uri_builder = ConsentURIBuilder(self.config)
|
|
|
|
|
2019-09-26 06:47:53 -04:00
|
|
|
# Rooms which should be excluded from dummy insertion. (For instance,
|
|
|
|
# those without local users who can send events into the room).
|
|
|
|
#
|
|
|
|
# map from room id to time-of-last-attempt.
|
|
|
|
#
|
2020-08-12 10:05:50 -04:00
|
|
|
self._rooms_to_exclude_from_dummy_event_insertion = {} # type: Dict[str, int]
|
2020-10-13 08:20:32 -04:00
|
|
|
# The number of forward extremeities before a dummy event is sent.
|
|
|
|
self._dummy_events_threshold = hs.config.dummy_events_threshold
|
2018-05-22 03:56:52 -04:00
|
|
|
|
2019-06-17 13:04:42 -04:00
|
|
|
if (
|
2020-10-13 08:20:32 -04:00
|
|
|
self.config.run_background_tasks
|
2019-06-17 13:04:42 -04:00
|
|
|
and self.config.cleanup_extremities_with_dummy_events
|
|
|
|
):
|
|
|
|
self.clock.looping_call(
|
2019-06-19 06:33:03 -04:00
|
|
|
lambda: run_as_background_process(
|
|
|
|
"send_dummy_events_to_fill_extremities",
|
2019-06-20 05:32:02 -04:00
|
|
|
self._send_dummy_events_to_fill_extremities,
|
2019-06-19 06:33:03 -04:00
|
|
|
),
|
2019-06-17 13:04:42 -04:00
|
|
|
5 * 60 * 1000,
|
|
|
|
)
|
|
|
|
|
2019-12-03 14:19:45 -05:00
|
|
|
self._message_handler = hs.get_message_handler()
|
|
|
|
|
|
|
|
self._ephemeral_events_enabled = hs.config.enable_ephemeral_messages
|
|
|
|
|
2021-01-26 08:57:31 -05:00
|
|
|
self._external_cache = hs.get_external_cache()
|
|
|
|
|
2020-07-22 12:29:15 -04:00
|
|
|
async def create_event(
|
2019-06-20 05:32:02 -04:00
|
|
|
self,
|
2020-07-22 12:29:15 -04:00
|
|
|
requester: Requester,
|
|
|
|
event_dict: dict,
|
|
|
|
txn_id: Optional[str] = None,
|
2020-09-01 08:39:04 -04:00
|
|
|
prev_event_ids: Optional[List[str]] = None,
|
2020-10-13 18:14:35 -04:00
|
|
|
auth_event_ids: Optional[List[str]] = None,
|
2020-07-22 12:29:15 -04:00
|
|
|
require_consent: bool = True,
|
|
|
|
) -> Tuple[EventBase, EventContext]:
|
2016-01-15 11:27:26 -05:00
|
|
|
"""
|
|
|
|
Given a dict from a client, create a new event.
|
2014-12-15 12:01:12 -05:00
|
|
|
|
|
|
|
Creates an FrozenEvent object, filling out auth_events, prev_events,
|
|
|
|
etc.
|
|
|
|
|
|
|
|
Adds display names to Join membership events.
|
|
|
|
|
|
|
|
Args:
|
2017-05-02 06:36:11 -04:00
|
|
|
requester
|
2020-07-22 12:29:15 -04:00
|
|
|
event_dict: An entire event
|
|
|
|
txn_id
|
2020-01-03 11:19:55 -05:00
|
|
|
prev_event_ids:
|
2018-04-16 13:41:37 -04:00
|
|
|
the forward extremities to use as the prev_events for the
|
2020-01-03 11:19:55 -05:00
|
|
|
new event.
|
2018-04-16 13:41:37 -04:00
|
|
|
|
|
|
|
If None, they will be requested from the database.
|
2020-10-13 18:14:35 -04:00
|
|
|
|
|
|
|
auth_event_ids:
|
|
|
|
The event ids to use as the auth_events for the new event.
|
|
|
|
Should normally be left as None, which will cause them to be calculated
|
|
|
|
based on the room state at the prev_events.
|
|
|
|
|
2020-07-22 12:29:15 -04:00
|
|
|
require_consent: Whether to check if the requester has
|
|
|
|
consented to the privacy policy.
|
2018-08-16 16:25:16 -04:00
|
|
|
Raises:
|
|
|
|
ResourceLimitError if server is blocked to some resource being
|
|
|
|
exceeded
|
2016-01-15 11:27:26 -05:00
|
|
|
Returns:
|
2020-07-22 12:29:15 -04:00
|
|
|
Tuple of created event, Context
|
2014-12-15 12:01:12 -05:00
|
|
|
"""
|
2020-11-17 05:51:25 -05:00
|
|
|
await self.auth.check_auth_blocking(requester=requester)
|
2018-08-16 16:25:16 -04:00
|
|
|
|
2019-01-23 15:21:33 -05:00
|
|
|
if event_dict["type"] == EventTypes.Create and event_dict["state_key"] == "":
|
|
|
|
room_version = event_dict["content"]["room_version"]
|
|
|
|
else:
|
|
|
|
try:
|
2020-07-22 12:29:15 -04:00
|
|
|
room_version = await self.store.get_room_version_id(
|
2020-01-31 05:06:21 -05:00
|
|
|
event_dict["room_id"]
|
|
|
|
)
|
2019-01-23 15:21:33 -05:00
|
|
|
except NotFoundError:
|
|
|
|
raise AuthError(403, "Unknown room")
|
|
|
|
|
|
|
|
builder = self.event_builder_factory.new(room_version, event_dict)
|
2014-12-04 10:50:01 -05:00
|
|
|
|
2019-01-28 12:00:14 -05:00
|
|
|
self.validator.validate_builder(builder)
|
2018-04-09 07:07:39 -04:00
|
|
|
|
|
|
|
if builder.type == EventTypes.Member:
|
|
|
|
membership = builder.content.get("membership", None)
|
|
|
|
target = UserID.from_string(builder.state_key)
|
|
|
|
|
2021-02-19 04:50:41 -05:00
|
|
|
if membership in self.membership_types_to_include_profile_data_in:
|
2018-04-09 07:07:39 -04:00
|
|
|
# If event doesn't include a display name, add one.
|
|
|
|
profile = self.profile_handler
|
|
|
|
content = builder.content
|
|
|
|
|
|
|
|
try:
|
|
|
|
if "displayname" not in content:
|
2020-07-22 12:29:15 -04:00
|
|
|
displayname = await profile.get_displayname(target)
|
2020-05-19 05:31:25 -04:00
|
|
|
if displayname is not None:
|
|
|
|
content["displayname"] = displayname
|
2018-04-09 07:07:39 -04:00
|
|
|
if "avatar_url" not in content:
|
2020-07-22 12:29:15 -04:00
|
|
|
avatar_url = await profile.get_avatar_url(target)
|
2020-05-19 05:31:25 -04:00
|
|
|
if avatar_url is not None:
|
|
|
|
content["avatar_url"] = avatar_url
|
2018-04-09 07:07:39 -04:00
|
|
|
except Exception as e:
|
|
|
|
logger.info(
|
2019-06-20 05:32:02 -04:00
|
|
|
"Failed to get profile information for %r: %s", target, e
|
2018-04-09 07:07:39 -04:00
|
|
|
)
|
|
|
|
|
2020-07-22 12:29:15 -04:00
|
|
|
is_exempt = await self._is_exempt_from_privacy_policy(builder, requester)
|
2019-03-20 13:39:29 -04:00
|
|
|
if require_consent and not is_exempt:
|
2020-07-22 12:29:15 -04:00
|
|
|
await self.assert_accepted_privacy_policy(requester)
|
2018-05-22 03:56:52 -04:00
|
|
|
|
2020-10-13 18:06:36 -04:00
|
|
|
if requester.access_token_id is not None:
|
|
|
|
builder.internal_metadata.token_id = requester.access_token_id
|
2018-04-09 07:07:39 -04:00
|
|
|
|
|
|
|
if txn_id is not None:
|
|
|
|
builder.internal_metadata.txn_id = txn_id
|
|
|
|
|
2020-07-22 12:29:15 -04:00
|
|
|
event, context = await self.create_new_client_event(
|
2020-10-13 18:14:35 -04:00
|
|
|
builder=builder,
|
|
|
|
requester=requester,
|
|
|
|
prev_event_ids=prev_event_ids,
|
|
|
|
auth_event_ids=auth_event_ids,
|
2018-04-09 07:07:39 -04:00
|
|
|
)
|
2015-01-28 11:58:23 -05:00
|
|
|
|
2019-05-08 12:01:30 -04:00
|
|
|
# In an ideal world we wouldn't need the second part of this condition. However,
|
|
|
|
# this behaviour isn't spec'd yet, meaning we should be able to deactivate this
|
|
|
|
# behaviour. Another reason is that this code is also evaluated each time a new
|
|
|
|
# m.room.aliases event is created, which includes hitting a /directory route.
|
|
|
|
# Therefore not including this condition here would render the similar one in
|
|
|
|
# synapse.handlers.directory pointless.
|
|
|
|
if builder.type == EventTypes.Aliases and self.require_membership_for_aliases:
|
|
|
|
# Ideally we'd do the membership check in event_auth.check(), which
|
|
|
|
# describes a spec'd algorithm for authenticating events received over
|
|
|
|
# federation as well as those created locally. As of room v3, aliases events
|
|
|
|
# can be created by users that are not in the room, therefore we have to
|
|
|
|
# tolerate them in event_auth.check().
|
2020-07-22 12:29:15 -04:00
|
|
|
prev_state_ids = await context.get_prev_state_ids()
|
2019-05-08 12:01:30 -04:00
|
|
|
prev_event_id = prev_state_ids.get((EventTypes.Member, event.sender))
|
2019-07-24 08:16:18 -04:00
|
|
|
prev_event = (
|
2020-07-22 12:29:15 -04:00
|
|
|
await self.store.get_event(prev_event_id, allow_none=True)
|
2019-07-24 08:16:18 -04:00
|
|
|
if prev_event_id
|
|
|
|
else None
|
|
|
|
)
|
2019-05-08 12:01:30 -04:00
|
|
|
if not prev_event or prev_event.membership != Membership.JOIN:
|
|
|
|
logger.warning(
|
2019-06-20 05:32:02 -04:00
|
|
|
(
|
|
|
|
"Attempt to send `m.room.aliases` in room %s by user %s but"
|
|
|
|
" membership is %s"
|
|
|
|
),
|
2019-05-08 12:01:30 -04:00
|
|
|
event.room_id,
|
|
|
|
event.sender,
|
|
|
|
prev_event.membership if prev_event else None,
|
|
|
|
)
|
|
|
|
|
|
|
|
raise AuthError(
|
2019-06-20 05:32:02 -04:00
|
|
|
403, "You must be in the room to create an alias for it"
|
2019-05-08 12:01:30 -04:00
|
|
|
)
|
|
|
|
|
2019-11-04 12:09:22 -05:00
|
|
|
self.validator.validate_new(event, self.config)
|
2019-01-28 12:00:14 -05:00
|
|
|
|
2019-07-23 09:00:55 -04:00
|
|
|
return (event, context)
|
2016-01-15 11:27:26 -05:00
|
|
|
|
2020-07-22 12:29:15 -04:00
|
|
|
async def _is_exempt_from_privacy_policy(
|
|
|
|
self, builder: EventBuilder, requester: Requester
|
|
|
|
) -> bool:
|
2021-02-16 17:32:34 -05:00
|
|
|
""" "Determine if an event to be sent is exempt from having to consent
|
2018-05-22 03:56:52 -04:00
|
|
|
to the privacy policy
|
|
|
|
|
|
|
|
Args:
|
2020-07-22 12:29:15 -04:00
|
|
|
builder: event being created
|
|
|
|
requester: user requesting this event
|
2018-05-22 03:56:52 -04:00
|
|
|
|
|
|
|
Returns:
|
2020-07-22 12:29:15 -04:00
|
|
|
true if the event can be sent without the user consenting
|
2018-05-22 03:56:52 -04:00
|
|
|
"""
|
|
|
|
# the only thing the user can do is join the server notices room.
|
|
|
|
if builder.type == EventTypes.Member:
|
|
|
|
membership = builder.content.get("membership", None)
|
|
|
|
if membership == Membership.JOIN:
|
2020-07-22 12:29:15 -04:00
|
|
|
return await self._is_server_notices_room(builder.room_id)
|
2018-06-25 12:56:10 -04:00
|
|
|
elif membership == Membership.LEAVE:
|
|
|
|
# the user is always allowed to leave (but not kick people)
|
|
|
|
return builder.state_key == requester.user.to_string()
|
2020-07-22 12:29:15 -04:00
|
|
|
return False
|
2018-05-22 03:56:52 -04:00
|
|
|
|
2020-07-22 12:29:15 -04:00
|
|
|
async def _is_server_notices_room(self, room_id: str) -> bool:
|
2018-05-22 03:56:52 -04:00
|
|
|
if self.config.server_notices_mxid is None:
|
2019-07-23 09:00:55 -04:00
|
|
|
return False
|
2020-07-22 12:29:15 -04:00
|
|
|
user_ids = await self.store.get_users_in_room(room_id)
|
2019-07-23 09:00:55 -04:00
|
|
|
return self.config.server_notices_mxid in user_ids
|
2018-05-22 03:56:52 -04:00
|
|
|
|
2020-07-22 12:29:15 -04:00
|
|
|
async def assert_accepted_privacy_policy(self, requester: Requester) -> None:
|
2018-05-22 03:56:52 -04:00
|
|
|
"""Check if a user has accepted the privacy policy
|
|
|
|
|
|
|
|
Called when the given user is about to do something that requires
|
|
|
|
privacy consent. We see if the user is exempt and otherwise check that
|
|
|
|
they have given consent. If they have not, a ConsentNotGiven error is
|
|
|
|
raised.
|
|
|
|
|
|
|
|
Args:
|
2020-07-22 12:29:15 -04:00
|
|
|
requester: The user making the request
|
2018-05-22 03:56:52 -04:00
|
|
|
|
|
|
|
Returns:
|
2020-07-22 12:29:15 -04:00
|
|
|
Returns normally if the user has consented or is exempt
|
2018-05-22 03:56:52 -04:00
|
|
|
|
|
|
|
Raises:
|
|
|
|
ConsentNotGivenError: if the user has not given consent yet
|
|
|
|
"""
|
2019-03-19 07:38:59 -04:00
|
|
|
if self._block_events_without_consent_error is None:
|
2018-05-22 03:56:52 -04:00
|
|
|
return
|
|
|
|
|
2019-03-20 13:51:27 -04:00
|
|
|
# exempt AS users from needing consent
|
|
|
|
if requester.app_service is not None:
|
|
|
|
return
|
|
|
|
|
2020-11-17 05:51:25 -05:00
|
|
|
user_id = requester.authenticated_entity
|
|
|
|
if not user_id.startswith("@"):
|
|
|
|
# The authenticated entity might not be a user, e.g. if it's the
|
|
|
|
# server puppetting the user.
|
|
|
|
return
|
|
|
|
|
|
|
|
user = UserID.from_string(user_id)
|
2018-05-22 03:56:52 -04:00
|
|
|
|
|
|
|
# exempt the system notices user
|
|
|
|
if (
|
2019-06-20 05:32:02 -04:00
|
|
|
self.config.server_notices_mxid is not None
|
|
|
|
and user_id == self.config.server_notices_mxid
|
2018-05-22 03:56:52 -04:00
|
|
|
):
|
|
|
|
return
|
|
|
|
|
2020-07-22 12:29:15 -04:00
|
|
|
u = await self.store.get_user_by_id(user_id)
|
2018-05-22 03:56:52 -04:00
|
|
|
assert u is not None
|
2019-08-23 05:28:54 -04:00
|
|
|
if u["user_type"] in (UserTypes.SUPPORT, UserTypes.BOT):
|
|
|
|
# support and bot users are not required to consent
|
2019-08-23 04:14:52 -04:00
|
|
|
return
|
2018-05-29 14:54:32 -04:00
|
|
|
if u["appservice_id"] is not None:
|
|
|
|
# users registered by an appservice are exempt
|
|
|
|
return
|
2018-05-22 03:56:52 -04:00
|
|
|
if u["consent_version"] == self.config.user_consent_version:
|
|
|
|
return
|
|
|
|
|
2020-11-17 05:51:25 -05:00
|
|
|
consent_uri = self._consent_uri_builder.build_user_consent_uri(user.localpart)
|
2019-06-20 05:32:02 -04:00
|
|
|
msg = self._block_events_without_consent_error % {"consent_uri": consent_uri}
|
|
|
|
raise ConsentNotGivenError(msg=msg, consent_uri=consent_uri)
|
2018-05-22 03:56:52 -04:00
|
|
|
|
2020-07-22 12:29:15 -04:00
|
|
|
async def deduplicate_state_event(
|
|
|
|
self, event: EventBase, context: EventContext
|
2020-08-18 07:53:23 -04:00
|
|
|
) -> Optional[EventBase]:
|
2016-02-16 09:25:23 -05:00
|
|
|
"""
|
|
|
|
Checks whether event is in the latest resolved state in context.
|
|
|
|
|
2020-08-18 07:53:23 -04:00
|
|
|
Args:
|
|
|
|
event: The event to check for duplication.
|
|
|
|
context: The event context.
|
|
|
|
|
|
|
|
Returns:
|
2020-10-23 12:38:40 -04:00
|
|
|
The previous version of the event is returned, if it is found in the
|
2020-08-18 07:53:23 -04:00
|
|
|
event context. Otherwise, None is returned.
|
2016-02-16 09:25:23 -05:00
|
|
|
"""
|
2020-07-22 12:29:15 -04:00
|
|
|
prev_state_ids = await context.get_prev_state_ids()
|
2018-07-23 08:00:22 -04:00
|
|
|
prev_event_id = prev_state_ids.get((event.type, event.state_key))
|
2019-07-24 08:16:18 -04:00
|
|
|
if not prev_event_id:
|
2020-08-18 07:53:23 -04:00
|
|
|
return None
|
2020-07-22 12:29:15 -04:00
|
|
|
prev_event = await self.store.get_event(prev_event_id, allow_none=True)
|
2016-08-25 12:32:22 -04:00
|
|
|
if not prev_event:
|
2020-08-18 07:53:23 -04:00
|
|
|
return None
|
2016-08-25 12:32:22 -04:00
|
|
|
|
2016-02-16 09:25:23 -05:00
|
|
|
if prev_event and event.user_id == prev_event.user_id:
|
|
|
|
prev_content = encode_canonical_json(prev_event.content)
|
2016-02-15 13:21:30 -05:00
|
|
|
next_content = encode_canonical_json(event.content)
|
|
|
|
if prev_content == next_content:
|
2019-07-23 09:00:55 -04:00
|
|
|
return prev_event
|
2020-08-18 07:53:23 -04:00
|
|
|
return None
|
2016-02-15 13:21:30 -05:00
|
|
|
|
2020-05-01 10:15:36 -04:00
|
|
|
async def create_and_send_nonmember_event(
|
2020-07-22 12:29:15 -04:00
|
|
|
self,
|
|
|
|
requester: Requester,
|
2020-08-12 10:05:50 -04:00
|
|
|
event_dict: dict,
|
2020-07-22 12:29:15 -04:00
|
|
|
ratelimit: bool = True,
|
|
|
|
txn_id: Optional[str] = None,
|
2020-08-24 13:58:56 -04:00
|
|
|
ignore_shadow_ban: bool = False,
|
2020-05-22 09:21:54 -04:00
|
|
|
) -> Tuple[EventBase, int]:
|
2016-01-15 11:27:26 -05:00
|
|
|
"""
|
|
|
|
Creates an event, then sends it.
|
|
|
|
|
2020-10-02 13:10:55 -04:00
|
|
|
See self.create_event and self.handle_new_client_event.
|
2020-08-24 13:58:56 -04:00
|
|
|
|
2020-08-25 10:52:15 -04:00
|
|
|
Args:
|
|
|
|
requester: The requester sending the event.
|
|
|
|
event_dict: An entire event.
|
|
|
|
ratelimit: Whether to rate limit this send.
|
|
|
|
txn_id: The transaction ID.
|
|
|
|
ignore_shadow_ban: True if shadow-banned users should be allowed to
|
|
|
|
send this event.
|
|
|
|
|
2020-10-02 13:10:55 -04:00
|
|
|
Returns:
|
2020-10-13 07:07:56 -04:00
|
|
|
The event, and its stream ordering (if deduplication happened,
|
2020-10-02 13:10:55 -04:00
|
|
|
the previous, duplicate event).
|
|
|
|
|
2020-08-24 13:58:56 -04:00
|
|
|
Raises:
|
|
|
|
ShadowBanError if the requester has been shadow-banned.
|
2016-01-15 11:27:26 -05:00
|
|
|
"""
|
2020-10-02 13:10:55 -04:00
|
|
|
|
|
|
|
if event_dict["type"] == EventTypes.Member:
|
|
|
|
raise SynapseError(
|
|
|
|
500, "Tried to send member event through non-member codepath"
|
|
|
|
)
|
|
|
|
|
2020-08-24 13:58:56 -04:00
|
|
|
if not ignore_shadow_ban and requester.shadow_banned:
|
|
|
|
# We randomly sleep a bit just to annoy the requester.
|
|
|
|
await self.clock.sleep(random.randint(1, 10))
|
|
|
|
raise ShadowBanError()
|
2017-09-19 07:20:11 -04:00
|
|
|
|
2018-04-10 09:00:24 -04:00
|
|
|
# We limit the number of concurrent event sends in a room so that we
|
|
|
|
# don't fork the DAG too much. If we don't limit then we can end up in
|
|
|
|
# a situation where event persistence can't keep up, causing
|
|
|
|
# extremities to pile up, which in turn leads to state resolution
|
|
|
|
# taking longer.
|
2020-05-01 10:15:36 -04:00
|
|
|
with (await self.limiter.queue(event_dict["room_id"])):
|
2020-10-13 07:07:56 -04:00
|
|
|
if txn_id and requester.access_token_id:
|
|
|
|
existing_event_id = await self.store.get_event_id_from_transaction_id(
|
|
|
|
event_dict["room_id"],
|
|
|
|
requester.user.to_string(),
|
|
|
|
requester.access_token_id,
|
|
|
|
txn_id,
|
|
|
|
)
|
|
|
|
if existing_event_id:
|
|
|
|
event = await self.store.get_event(existing_event_id)
|
|
|
|
# we know it was persisted, so must have a stream ordering
|
|
|
|
assert event.internal_metadata.stream_ordering
|
|
|
|
return event, event.internal_metadata.stream_ordering
|
|
|
|
|
2020-05-01 10:15:36 -04:00
|
|
|
event, context = await self.create_event(
|
2020-10-13 18:06:36 -04:00
|
|
|
requester, event_dict, txn_id=txn_id
|
2017-09-19 07:20:11 -04:00
|
|
|
)
|
|
|
|
|
2020-10-05 14:00:50 -04:00
|
|
|
assert self.hs.is_mine_id(event.sender), "User must be our own: %s" % (
|
|
|
|
event.sender,
|
|
|
|
)
|
|
|
|
|
2020-12-11 14:05:15 -05:00
|
|
|
spam_error = await self.spam_checker.check_event_for_spam(event)
|
2018-04-09 07:07:39 -04:00
|
|
|
if spam_error:
|
2020-06-16 08:51:47 -04:00
|
|
|
if not isinstance(spam_error, str):
|
2018-04-09 07:07:39 -04:00
|
|
|
spam_error = "Spam is not permitted here"
|
2019-06-20 05:32:02 -04:00
|
|
|
raise SynapseError(403, spam_error, Codes.FORBIDDEN)
|
2018-04-09 07:07:39 -04:00
|
|
|
|
2020-10-02 13:10:55 -04:00
|
|
|
ev = await self.handle_new_client_event(
|
|
|
|
requester=requester,
|
|
|
|
event=event,
|
|
|
|
context=context,
|
2020-08-25 10:52:15 -04:00
|
|
|
ratelimit=ratelimit,
|
|
|
|
ignore_shadow_ban=ignore_shadow_ban,
|
2018-04-09 07:07:39 -04:00
|
|
|
)
|
2020-10-02 13:10:55 -04:00
|
|
|
|
|
|
|
# we know it was persisted, so must have a stream ordering
|
|
|
|
assert ev.internal_metadata.stream_ordering
|
|
|
|
return ev, ev.internal_metadata.stream_ordering
|
2014-12-04 10:50:01 -05:00
|
|
|
|
2018-02-06 11:31:50 -05:00
|
|
|
@measure_func("create_new_client_event")
|
2020-07-22 12:29:15 -04:00
|
|
|
async def create_new_client_event(
|
|
|
|
self,
|
|
|
|
builder: EventBuilder,
|
|
|
|
requester: Optional[Requester] = None,
|
2020-09-01 08:39:04 -04:00
|
|
|
prev_event_ids: Optional[List[str]] = None,
|
2020-10-13 18:14:35 -04:00
|
|
|
auth_event_ids: Optional[List[str]] = None,
|
2020-07-22 12:29:15 -04:00
|
|
|
) -> Tuple[EventBase, EventContext]:
|
2018-04-16 13:41:37 -04:00
|
|
|
"""Create a new event for a local client
|
|
|
|
|
|
|
|
Args:
|
2020-07-22 12:29:15 -04:00
|
|
|
builder:
|
|
|
|
requester:
|
2020-01-03 11:16:09 -05:00
|
|
|
prev_event_ids:
|
2018-04-16 13:41:37 -04:00
|
|
|
the forward extremities to use as the prev_events for the
|
2020-01-03 11:16:09 -05:00
|
|
|
new event.
|
2018-04-16 13:41:37 -04:00
|
|
|
|
|
|
|
If None, they will be requested from the database.
|
|
|
|
|
2020-10-13 18:14:35 -04:00
|
|
|
auth_event_ids:
|
|
|
|
The event ids to use as the auth_events for the new event.
|
|
|
|
Should normally be left as None, which will cause them to be calculated
|
|
|
|
based on the room state at the prev_events.
|
|
|
|
|
2018-04-16 13:41:37 -04:00
|
|
|
Returns:
|
2020-07-22 12:29:15 -04:00
|
|
|
Tuple of created event, context
|
2018-04-16 13:41:37 -04:00
|
|
|
"""
|
|
|
|
|
2020-01-03 11:16:09 -05:00
|
|
|
if prev_event_ids is not None:
|
2021-02-16 17:32:34 -05:00
|
|
|
assert (
|
|
|
|
len(prev_event_ids) <= 10
|
|
|
|
), "Attempting to create an event with %i prev_events" % (
|
|
|
|
len(prev_event_ids),
|
2016-05-11 04:09:20 -04:00
|
|
|
)
|
2018-04-16 13:41:37 -04:00
|
|
|
else:
|
2020-07-22 12:29:15 -04:00
|
|
|
prev_event_ids = await self.store.get_prev_events_for_room(builder.room_id)
|
2016-05-11 04:09:20 -04:00
|
|
|
|
2020-08-10 07:29:47 -04:00
|
|
|
# we now ought to have some prev_events (unless it's a create event).
|
|
|
|
#
|
|
|
|
# do a quick sanity check here, rather than waiting until we've created the
|
|
|
|
# event and then try to auth it (which fails with a somewhat confusing "No
|
|
|
|
# create event in auth events")
|
|
|
|
assert (
|
|
|
|
builder.type == EventTypes.Create or len(prev_event_ids) > 0
|
|
|
|
), "Attempting to create an event with no prev_events"
|
|
|
|
|
2020-10-13 18:14:35 -04:00
|
|
|
event = await builder.build(
|
|
|
|
prev_event_ids=prev_event_ids, auth_event_ids=auth_event_ids
|
|
|
|
)
|
2020-07-22 12:29:15 -04:00
|
|
|
context = await self.state.compute_event_context(event)
|
2017-05-02 06:36:11 -04:00
|
|
|
if requester:
|
|
|
|
context.app_service = requester.app_service
|
2016-05-11 04:09:20 -04:00
|
|
|
|
2020-10-13 13:53:56 -04:00
|
|
|
third_party_result = await self.third_party_event_rules.check_event_allowed(
|
2020-10-13 10:44:54 -04:00
|
|
|
event, context
|
|
|
|
)
|
2020-10-13 13:53:56 -04:00
|
|
|
if not third_party_result:
|
2020-10-13 10:44:54 -04:00
|
|
|
logger.info(
|
2021-02-16 17:32:34 -05:00
|
|
|
"Event %s forbidden by third-party rules",
|
|
|
|
event,
|
2020-10-13 10:44:54 -04:00
|
|
|
)
|
|
|
|
raise SynapseError(
|
|
|
|
403, "This event is not allowed in this context", Codes.FORBIDDEN
|
|
|
|
)
|
2020-10-13 13:53:56 -04:00
|
|
|
elif isinstance(third_party_result, dict):
|
|
|
|
# the third-party rules want to replace the event. We'll need to build a new
|
|
|
|
# event.
|
|
|
|
event, context = await self._rebuild_event_after_third_party_rules(
|
|
|
|
third_party_result, event
|
|
|
|
)
|
2020-10-13 10:44:54 -04:00
|
|
|
|
2019-11-04 12:09:22 -05:00
|
|
|
self.validator.validate_new(event, self.config)
|
2016-05-11 04:09:20 -04:00
|
|
|
|
2019-05-21 11:51:45 -04:00
|
|
|
# If this event is an annotation then we check that that the sender
|
|
|
|
# can't annotate the same way twice (e.g. stops users from liking an
|
|
|
|
# event multiple times).
|
2019-05-20 12:39:05 -04:00
|
|
|
relation = event.content.get("m.relates_to", {})
|
|
|
|
if relation.get("rel_type") == RelationTypes.ANNOTATION:
|
|
|
|
relates_to = relation["event_id"]
|
|
|
|
aggregation_key = relation["key"]
|
|
|
|
|
2020-07-22 12:29:15 -04:00
|
|
|
already_exists = await self.store.has_user_annotated_event(
|
2019-06-20 05:32:02 -04:00
|
|
|
relates_to, event.type, aggregation_key, event.sender
|
2019-05-20 12:39:05 -04:00
|
|
|
)
|
|
|
|
if already_exists:
|
|
|
|
raise SynapseError(400, "Can't send same reaction twice")
|
|
|
|
|
2019-06-20 05:32:02 -04:00
|
|
|
logger.debug("Created event %s", event.event_id)
|
2016-05-11 04:09:20 -04:00
|
|
|
|
2019-07-23 09:00:55 -04:00
|
|
|
return (event, context)
|
2016-05-11 04:09:20 -04:00
|
|
|
|
2016-08-23 10:23:39 -04:00
|
|
|
@measure_func("handle_new_client_event")
|
2020-05-01 10:15:36 -04:00
|
|
|
async def handle_new_client_event(
|
2020-07-22 12:29:15 -04:00
|
|
|
self,
|
|
|
|
requester: Requester,
|
|
|
|
event: EventBase,
|
|
|
|
context: EventContext,
|
|
|
|
ratelimit: bool = True,
|
|
|
|
extra_users: List[UserID] = [],
|
2020-10-02 13:03:21 -04:00
|
|
|
ignore_shadow_ban: bool = False,
|
2020-10-02 11:45:41 -04:00
|
|
|
) -> EventBase:
|
|
|
|
"""Processes a new event.
|
|
|
|
|
|
|
|
This includes deduplicating, checking auth, persisting,
|
2018-02-15 11:30:10 -05:00
|
|
|
notifying users, sending to remote servers, etc.
|
|
|
|
|
|
|
|
If called from a worker will hit out to the master process for final
|
|
|
|
processing.
|
|
|
|
|
|
|
|
Args:
|
2020-07-22 12:29:15 -04:00
|
|
|
requester
|
|
|
|
event
|
|
|
|
context
|
|
|
|
ratelimit
|
|
|
|
extra_users: Any extra users to notify about event
|
2020-05-22 09:21:54 -04:00
|
|
|
|
2020-10-02 13:03:21 -04:00
|
|
|
ignore_shadow_ban: True if shadow-banned users should be allowed to
|
|
|
|
send this event.
|
|
|
|
|
2020-05-22 09:21:54 -04:00
|
|
|
Return:
|
2020-10-02 11:45:41 -04:00
|
|
|
If the event was deduplicated, the previous, duplicate, event. Otherwise,
|
|
|
|
`event`.
|
2020-10-02 13:03:21 -04:00
|
|
|
|
|
|
|
Raises:
|
|
|
|
ShadowBanError if the requester has been shadow-banned.
|
2018-02-15 11:30:10 -05:00
|
|
|
"""
|
|
|
|
|
2020-10-07 06:28:05 -04:00
|
|
|
# we don't apply shadow-banning to membership events here. Invites are blocked
|
|
|
|
# higher up the stack, and we allow shadow-banned users to send join and leave
|
|
|
|
# events as normal.
|
2020-10-02 13:03:21 -04:00
|
|
|
if (
|
|
|
|
event.type != EventTypes.Member
|
|
|
|
and not ignore_shadow_ban
|
|
|
|
and requester.shadow_banned
|
|
|
|
):
|
|
|
|
# We randomly sleep a bit just to annoy the requester.
|
|
|
|
await self.clock.sleep(random.randint(1, 10))
|
|
|
|
raise ShadowBanError()
|
|
|
|
|
2020-10-02 11:45:41 -04:00
|
|
|
if event.is_state():
|
|
|
|
prev_event = await self.deduplicate_state_event(event, context)
|
|
|
|
if prev_event is not None:
|
|
|
|
logger.info(
|
|
|
|
"Not bothering to persist state event %s duplicated by %s",
|
|
|
|
event.event_id,
|
|
|
|
prev_event.event_id,
|
|
|
|
)
|
|
|
|
return prev_event
|
|
|
|
|
2019-06-20 05:32:02 -04:00
|
|
|
if event.is_state() and (event.type, event.state_key) == (
|
|
|
|
EventTypes.Create,
|
|
|
|
"",
|
|
|
|
):
|
|
|
|
room_version = event.content.get("room_version", RoomVersions.V1.identifier)
|
2019-01-25 13:31:41 -05:00
|
|
|
else:
|
2020-05-01 10:15:36 -04:00
|
|
|
room_version = await self.store.get_room_version_id(event.room_id)
|
2019-01-25 13:31:41 -05:00
|
|
|
|
2020-07-09 05:40:19 -04:00
|
|
|
if event.internal_metadata.is_out_of_band_membership():
|
|
|
|
# the only sort of out-of-band-membership events we expect to see here
|
|
|
|
# are invite rejections we have generated ourselves.
|
|
|
|
assert event.type == EventTypes.Member
|
|
|
|
assert event.content["membership"] == Membership.LEAVE
|
|
|
|
else:
|
|
|
|
try:
|
|
|
|
await self.auth.check_from_context(room_version, event, context)
|
|
|
|
except AuthError as err:
|
|
|
|
logger.warning("Denying new event %r because %s", event, err)
|
|
|
|
raise err
|
2018-03-01 05:18:33 -05:00
|
|
|
|
|
|
|
# Ensure that we can round trip before trying to persist in db
|
|
|
|
try:
|
2020-10-28 11:51:15 -04:00
|
|
|
dump = json_encoder.encode(event.content)
|
2020-08-19 07:26:03 -04:00
|
|
|
json_decoder.decode(dump)
|
2018-03-01 05:18:33 -05:00
|
|
|
except Exception:
|
|
|
|
logger.exception("Failed to encode content: %r", event.content)
|
|
|
|
raise
|
|
|
|
|
2020-05-01 10:15:36 -04:00
|
|
|
await self.action_generator.handle_push_actions_for_event(event, context)
|
2018-02-15 11:30:10 -05:00
|
|
|
|
2021-01-26 08:57:31 -05:00
|
|
|
await self.cache_joined_hosts_for_event(event)
|
|
|
|
|
2018-02-15 11:30:10 -05:00
|
|
|
try:
|
|
|
|
# If we're a worker we need to hit out to the master.
|
2020-09-14 05:16:41 -04:00
|
|
|
writer_instance = self._events_shard_config.get_instance(event.room_id)
|
|
|
|
if writer_instance != self._instance_name:
|
2020-05-22 11:11:35 -04:00
|
|
|
result = await self.send_event(
|
2020-09-14 05:16:41 -04:00
|
|
|
instance_name=writer_instance,
|
2018-07-31 08:53:54 -04:00
|
|
|
event_id=event.event_id,
|
2018-07-23 11:28:00 -04:00
|
|
|
store=self.store,
|
2018-02-15 11:30:10 -05:00
|
|
|
requester=requester,
|
|
|
|
event=event,
|
|
|
|
context=context,
|
2018-03-01 05:08:28 -05:00
|
|
|
ratelimit=ratelimit,
|
|
|
|
extra_users=extra_users,
|
2018-02-15 11:30:10 -05:00
|
|
|
)
|
2020-05-22 09:21:54 -04:00
|
|
|
stream_id = result["stream_id"]
|
2020-10-13 07:07:56 -04:00
|
|
|
event_id = result["event_id"]
|
|
|
|
if event_id != event.event_id:
|
|
|
|
# If we get a different event back then it means that its
|
|
|
|
# been de-duplicated, so we replace the given event with the
|
|
|
|
# one already persisted.
|
|
|
|
event = await self.store.get_event(event_id)
|
|
|
|
else:
|
|
|
|
# If we newly persisted the event then we need to update its
|
|
|
|
# stream_ordering entry manually (as it was persisted on
|
|
|
|
# another worker).
|
|
|
|
event.internal_metadata.stream_ordering = stream_id
|
2020-10-02 11:45:41 -04:00
|
|
|
return event
|
2018-02-15 11:30:10 -05:00
|
|
|
|
2020-10-13 07:07:56 -04:00
|
|
|
event = await self.persist_and_notify_client_event(
|
2019-06-20 05:32:02 -04:00
|
|
|
requester, event, context, ratelimit=ratelimit, extra_users=extra_users
|
2018-02-05 12:22:16 -05:00
|
|
|
)
|
2018-04-27 06:40:06 -04:00
|
|
|
|
2020-10-02 11:45:41 -04:00
|
|
|
return event
|
2020-07-27 08:35:56 -04:00
|
|
|
except Exception:
|
|
|
|
# Ensure that we actually remove the entries in the push actions
|
|
|
|
# staging area, if we calculated them.
|
2020-08-13 12:05:31 -04:00
|
|
|
await self.store.remove_push_actions_from_staging(event.event_id)
|
2020-07-27 08:35:56 -04:00
|
|
|
raise
|
2018-02-15 11:30:10 -05:00
|
|
|
|
2021-01-26 08:57:31 -05:00
|
|
|
async def cache_joined_hosts_for_event(self, event: EventBase) -> None:
|
|
|
|
"""Precalculate the joined hosts at the event, when using Redis, so that
|
|
|
|
external federation senders don't have to recalculate it themselves.
|
|
|
|
"""
|
|
|
|
|
|
|
|
if not self._external_cache.is_enabled():
|
|
|
|
return
|
|
|
|
|
|
|
|
# We actually store two mappings, event ID -> prev state group,
|
|
|
|
# state group -> joined hosts, which is much more space efficient
|
|
|
|
# than event ID -> joined hosts.
|
|
|
|
#
|
|
|
|
# Note: We have to cache event ID -> prev state group, as we don't
|
|
|
|
# store that in the DB.
|
|
|
|
#
|
|
|
|
# Note: We always set the state group -> joined hosts cache, even if
|
|
|
|
# we already set it, so that the expiry time is reset.
|
|
|
|
|
|
|
|
state_entry = await self.state.resolve_state_groups_for_events(
|
|
|
|
event.room_id, event_ids=event.prev_event_ids()
|
|
|
|
)
|
|
|
|
|
|
|
|
if state_entry.state_group:
|
|
|
|
joined_hosts = await self.store.get_joined_hosts(event.room_id, state_entry)
|
|
|
|
|
|
|
|
await self._external_cache.set(
|
|
|
|
"event_to_prev_state_group",
|
|
|
|
event.event_id,
|
|
|
|
state_entry.state_group,
|
|
|
|
expiry_ms=60 * 60 * 1000,
|
|
|
|
)
|
|
|
|
await self._external_cache.set(
|
|
|
|
"get_joined_hosts",
|
|
|
|
str(state_entry.state_group),
|
|
|
|
list(joined_hosts),
|
|
|
|
expiry_ms=60 * 60 * 1000,
|
|
|
|
)
|
|
|
|
|
2020-07-22 12:29:15 -04:00
|
|
|
async def _validate_canonical_alias(
|
|
|
|
self, directory_handler, room_alias_str: str, expected_room_id: str
|
|
|
|
) -> None:
|
2020-03-23 15:21:54 -04:00
|
|
|
"""
|
|
|
|
Ensure that the given room alias points to the expected room ID.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
directory_handler: The directory handler object.
|
|
|
|
room_alias_str: The room alias to check.
|
|
|
|
expected_room_id: The room ID that the alias should point to.
|
|
|
|
"""
|
|
|
|
room_alias = RoomAlias.from_string(room_alias_str)
|
|
|
|
try:
|
2020-07-22 12:29:15 -04:00
|
|
|
mapping = await directory_handler.get_association(room_alias)
|
2020-03-23 15:21:54 -04:00
|
|
|
except SynapseError as e:
|
|
|
|
# Turn M_NOT_FOUND errors into M_BAD_ALIAS errors.
|
|
|
|
if e.errcode == Codes.NOT_FOUND:
|
|
|
|
raise SynapseError(
|
|
|
|
400,
|
|
|
|
"Room alias %s does not point to the room" % (room_alias_str,),
|
|
|
|
Codes.BAD_ALIAS,
|
|
|
|
)
|
|
|
|
raise
|
|
|
|
|
|
|
|
if mapping["room_id"] != expected_room_id:
|
|
|
|
raise SynapseError(
|
|
|
|
400,
|
|
|
|
"Room alias %s does not point to the room" % (room_alias_str,),
|
|
|
|
Codes.BAD_ALIAS,
|
|
|
|
)
|
|
|
|
|
2020-05-01 10:15:36 -04:00
|
|
|
async def persist_and_notify_client_event(
|
2020-07-22 12:29:15 -04:00
|
|
|
self,
|
|
|
|
requester: Requester,
|
|
|
|
event: EventBase,
|
|
|
|
context: EventContext,
|
|
|
|
ratelimit: bool = True,
|
|
|
|
extra_users: List[UserID] = [],
|
2020-10-13 07:07:56 -04:00
|
|
|
) -> EventBase:
|
2018-03-01 05:18:33 -05:00
|
|
|
"""Called when we have fully built the event, have already
|
|
|
|
calculated the push actions for the event, and checked auth.
|
2018-03-01 05:05:27 -05:00
|
|
|
|
2020-05-22 11:11:35 -04:00
|
|
|
This should only be run on the instance in charge of persisting events.
|
2020-10-13 07:07:56 -04:00
|
|
|
|
|
|
|
Returns:
|
|
|
|
The persisted event. This may be different than the given event if
|
|
|
|
it was de-duplicated (e.g. because we had already persisted an
|
|
|
|
event with the same transaction ID.)
|
2018-02-15 11:30:10 -05:00
|
|
|
"""
|
2020-09-11 07:22:55 -04:00
|
|
|
assert self.storage.persistence is not None
|
2020-09-14 05:16:41 -04:00
|
|
|
assert self._events_shard_config.should_handle(
|
|
|
|
self._instance_name, event.room_id
|
|
|
|
)
|
2018-02-05 12:22:16 -05:00
|
|
|
|
2016-05-11 04:09:20 -04:00
|
|
|
if ratelimit:
|
2019-09-11 06:16:17 -04:00
|
|
|
# We check if this is a room admin redacting an event so that we
|
|
|
|
# can apply different ratelimiting. We do this by simply checking
|
2019-09-11 08:54:50 -04:00
|
|
|
# it's not a self-redaction (to avoid having to look up whether the
|
2019-09-11 06:16:17 -04:00
|
|
|
# user is actually admin or not).
|
|
|
|
is_admin_redaction = False
|
|
|
|
if event.type == EventTypes.Redaction:
|
2020-05-01 10:15:36 -04:00
|
|
|
original_event = await self.store.get_event(
|
2019-09-11 06:16:17 -04:00
|
|
|
event.redacts,
|
2019-12-11 08:39:47 -05:00
|
|
|
redact_behaviour=EventRedactBehaviour.AS_IS,
|
2019-09-11 06:16:17 -04:00
|
|
|
get_prev_content=False,
|
|
|
|
allow_rejected=False,
|
|
|
|
allow_none=True,
|
|
|
|
)
|
|
|
|
|
2020-08-18 16:20:49 -04:00
|
|
|
is_admin_redaction = bool(
|
2019-09-11 06:16:17 -04:00
|
|
|
original_event and event.sender != original_event.sender
|
|
|
|
)
|
|
|
|
|
2020-05-01 10:15:36 -04:00
|
|
|
await self.base_handler.ratelimit(
|
2019-09-11 05:46:38 -04:00
|
|
|
requester, is_admin_redaction=is_admin_redaction
|
|
|
|
)
|
2016-05-11 04:09:20 -04:00
|
|
|
|
2020-05-01 10:15:36 -04:00
|
|
|
await self.base_handler.maybe_kick_guest_users(event, context)
|
2016-05-11 04:09:20 -04:00
|
|
|
|
|
|
|
if event.type == EventTypes.CanonicalAlias:
|
2020-03-03 07:12:45 -05:00
|
|
|
# Validate a newly added alias or newly added alt_aliases.
|
|
|
|
|
|
|
|
original_alias = None
|
2020-08-12 10:05:50 -04:00
|
|
|
original_alt_aliases = [] # type: List[str]
|
2020-03-03 07:12:45 -05:00
|
|
|
|
|
|
|
original_event_id = event.unsigned.get("replaces_state")
|
|
|
|
if original_event_id:
|
2020-05-01 10:15:36 -04:00
|
|
|
original_event = await self.store.get_event(original_event_id)
|
2020-03-03 07:12:45 -05:00
|
|
|
|
|
|
|
if original_event:
|
|
|
|
original_alias = original_event.content.get("alias", None)
|
|
|
|
original_alt_aliases = original_event.content.get("alt_aliases", [])
|
|
|
|
|
|
|
|
# Check the alias is currently valid (if it has changed).
|
2016-05-11 04:09:20 -04:00
|
|
|
room_alias_str = event.content.get("alias", None)
|
2020-10-09 07:24:34 -04:00
|
|
|
directory_handler = self.hs.get_directory_handler()
|
2020-03-03 07:12:45 -05:00
|
|
|
if room_alias_str and room_alias_str != original_alias:
|
2020-05-01 10:15:36 -04:00
|
|
|
await self._validate_canonical_alias(
|
2020-03-23 15:21:54 -04:00
|
|
|
directory_handler, room_alias_str, event.room_id
|
|
|
|
)
|
2016-05-11 04:09:20 -04:00
|
|
|
|
2020-03-03 07:12:45 -05:00
|
|
|
# Check that alt_aliases is the proper form.
|
|
|
|
alt_aliases = event.content.get("alt_aliases", [])
|
|
|
|
if not isinstance(alt_aliases, (list, tuple)):
|
|
|
|
raise SynapseError(
|
|
|
|
400, "The alt_aliases property must be a list.", Codes.INVALID_PARAM
|
|
|
|
)
|
|
|
|
|
|
|
|
# If the old version of alt_aliases is of an unknown form,
|
|
|
|
# completely replace it.
|
|
|
|
if not isinstance(original_alt_aliases, (list, tuple)):
|
|
|
|
original_alt_aliases = []
|
|
|
|
|
|
|
|
# Check that each alias is currently valid.
|
|
|
|
new_alt_aliases = set(alt_aliases) - set(original_alt_aliases)
|
|
|
|
if new_alt_aliases:
|
|
|
|
for alias_str in new_alt_aliases:
|
2020-05-01 10:15:36 -04:00
|
|
|
await self._validate_canonical_alias(
|
2020-03-23 15:21:54 -04:00
|
|
|
directory_handler, alias_str, event.room_id
|
|
|
|
)
|
2020-03-03 07:12:45 -05:00
|
|
|
|
2020-10-09 07:24:34 -04:00
|
|
|
federation_handler = self.hs.get_federation_handler()
|
2016-05-11 04:09:20 -04:00
|
|
|
|
|
|
|
if event.type == EventTypes.Member:
|
|
|
|
if event.content["membership"] == Membership.INVITE:
|
2020-10-27 14:42:46 -04:00
|
|
|
event.unsigned[
|
|
|
|
"invite_room_state"
|
|
|
|
] = await self.store.get_stripped_room_state_from_event_context(
|
|
|
|
context,
|
|
|
|
self.room_invite_state_types,
|
|
|
|
membership_user_id=event.sender,
|
|
|
|
)
|
2016-05-11 04:09:20 -04:00
|
|
|
|
|
|
|
invitee = UserID.from_string(event.state_key)
|
|
|
|
if not self.hs.is_mine(invitee):
|
|
|
|
# TODO: Can we add signature from remote server in a nicer
|
|
|
|
# way? If we have been invited by a remote server, we need
|
|
|
|
# to get them to sign the event.
|
|
|
|
|
2020-05-01 10:15:36 -04:00
|
|
|
returned_invite = await federation_handler.send_invite(
|
|
|
|
invitee.domain, event
|
2016-05-11 04:09:20 -04:00
|
|
|
)
|
|
|
|
event.unsigned.pop("room_state", None)
|
|
|
|
|
|
|
|
# TODO: Make sure the signatures actually are correct.
|
2019-06-20 05:32:02 -04:00
|
|
|
event.signatures.update(returned_invite.signatures)
|
2016-05-11 04:09:20 -04:00
|
|
|
|
|
|
|
if event.type == EventTypes.Redaction:
|
2020-05-01 10:15:36 -04:00
|
|
|
original_event = await self.store.get_event(
|
2019-07-17 14:08:02 -04:00
|
|
|
event.redacts,
|
2019-12-11 08:39:47 -05:00
|
|
|
redact_behaviour=EventRedactBehaviour.AS_IS,
|
2019-07-17 14:08:02 -04:00
|
|
|
get_prev_content=False,
|
|
|
|
allow_rejected=False,
|
|
|
|
allow_none=True,
|
|
|
|
)
|
|
|
|
|
|
|
|
# we can make some additional checks now if we have the original event.
|
|
|
|
if original_event:
|
|
|
|
if original_event.type == EventTypes.Create:
|
|
|
|
raise AuthError(403, "Redacting create events is not permitted")
|
|
|
|
|
2019-07-31 11:03:14 -04:00
|
|
|
if original_event.room_id != event.room_id:
|
|
|
|
raise SynapseError(400, "Cannot redact event from a different room")
|
|
|
|
|
2020-11-03 07:13:48 -05:00
|
|
|
if original_event.type == EventTypes.ServerACL:
|
|
|
|
raise AuthError(403, "Redacting server ACL events is not permitted")
|
|
|
|
|
2020-05-01 10:15:36 -04:00
|
|
|
prev_state_ids = await context.get_prev_state_ids()
|
2020-08-06 08:30:06 -04:00
|
|
|
auth_events_ids = self.auth.compute_auth_events(
|
2019-06-20 05:32:02 -04:00
|
|
|
event, prev_state_ids, for_verification=True
|
2016-08-25 12:32:22 -04:00
|
|
|
)
|
2020-08-18 16:20:49 -04:00
|
|
|
auth_events_map = await self.store.get_events(auth_events_ids)
|
|
|
|
auth_events = {(e.type, e.state_key): e for e in auth_events_map.values()}
|
2020-01-28 09:18:29 -05:00
|
|
|
|
2020-05-01 10:15:36 -04:00
|
|
|
room_version = await self.store.get_room_version_id(event.room_id)
|
2020-01-28 09:18:29 -05:00
|
|
|
room_version_obj = KNOWN_ROOM_VERSIONS[room_version]
|
2019-07-17 14:08:02 -04:00
|
|
|
|
2020-01-28 09:18:29 -05:00
|
|
|
if event_auth.check_redaction(
|
|
|
|
room_version_obj, event, auth_events=auth_events
|
|
|
|
):
|
2019-07-17 14:08:02 -04:00
|
|
|
# this user doesn't have 'redact' rights, so we need to do some more
|
|
|
|
# checks on the original event. Let's start by checking the original
|
|
|
|
# event exists.
|
|
|
|
if not original_event:
|
|
|
|
raise NotFoundError("Could not find event %s" % (event.redacts,))
|
|
|
|
|
2016-05-11 04:09:20 -04:00
|
|
|
if event.user_id != original_event.user_id:
|
2019-06-20 05:32:02 -04:00
|
|
|
raise AuthError(403, "You don't have permission to redact events")
|
2016-05-11 04:09:20 -04:00
|
|
|
|
2019-07-17 14:08:02 -04:00
|
|
|
# all the checks are done.
|
2019-01-28 16:09:45 -05:00
|
|
|
event.internal_metadata.recheck_redaction = False
|
|
|
|
|
2018-07-23 08:00:22 -04:00
|
|
|
if event.type == EventTypes.Create:
|
2020-05-01 10:15:36 -04:00
|
|
|
prev_state_ids = await context.get_prev_state_ids()
|
2018-07-23 08:00:22 -04:00
|
|
|
if prev_state_ids:
|
2019-06-20 05:32:02 -04:00
|
|
|
raise AuthError(403, "Changing the room create event is forbidden")
|
2016-05-11 04:09:20 -04:00
|
|
|
|
2020-10-13 07:07:56 -04:00
|
|
|
# Note that this returns the event that was persisted, which may not be
|
|
|
|
# the same as we passed in if it was deduplicated due transaction IDs.
|
|
|
|
(
|
|
|
|
event,
|
|
|
|
event_pos,
|
|
|
|
max_stream_token,
|
|
|
|
) = await self.storage.persistence.persist_event(event, context=context)
|
2016-05-11 04:09:20 -04:00
|
|
|
|
2019-12-03 14:19:45 -05:00
|
|
|
if self._ephemeral_events_enabled:
|
|
|
|
# If there's an expiry timestamp on the event, schedule its expiry.
|
|
|
|
self._message_handler.maybe_schedule_expiry(event)
|
|
|
|
|
2016-06-02 08:02:33 -04:00
|
|
|
def _notify():
|
2018-04-27 06:07:40 -04:00
|
|
|
try:
|
|
|
|
self.notifier.on_new_room_event(
|
2020-09-24 08:24:17 -04:00
|
|
|
event, event_pos, max_stream_token, extra_users=extra_users
|
2018-04-27 06:07:40 -04:00
|
|
|
)
|
|
|
|
except Exception:
|
|
|
|
logger.exception("Error notifying about new room event")
|
2016-05-11 04:09:20 -04:00
|
|
|
|
2018-04-27 06:29:27 -04:00
|
|
|
run_in_background(_notify)
|
2018-02-06 12:27:00 -05:00
|
|
|
|
|
|
|
if event.type == EventTypes.Message:
|
|
|
|
# We don't want to block sending messages on any presence code. This
|
|
|
|
# matters as sometimes presence code can take a while.
|
2018-04-27 06:07:40 -04:00
|
|
|
run_in_background(self._bump_active_time, requester.user)
|
|
|
|
|
2020-10-13 07:07:56 -04:00
|
|
|
return event
|
2020-05-22 09:21:54 -04:00
|
|
|
|
2020-07-22 12:29:15 -04:00
|
|
|
async def _bump_active_time(self, user: UserID) -> None:
|
2018-04-27 06:07:40 -04:00
|
|
|
try:
|
|
|
|
presence = self.hs.get_presence_handler()
|
2020-02-26 10:33:26 -05:00
|
|
|
await presence.bump_presence_active_time(user)
|
2018-04-27 06:07:40 -04:00
|
|
|
except Exception:
|
|
|
|
logger.exception("Error bumping presence active time")
|
2019-06-17 13:04:42 -04:00
|
|
|
|
2020-05-01 10:15:36 -04:00
|
|
|
async def _send_dummy_events_to_fill_extremities(self):
|
2019-06-17 13:04:42 -04:00
|
|
|
"""Background task to send dummy events into rooms that have a large
|
|
|
|
number of extremities
|
|
|
|
"""
|
2019-09-26 06:47:53 -04:00
|
|
|
self._expire_rooms_to_exclude_from_dummy_event_insertion()
|
2020-05-01 10:15:36 -04:00
|
|
|
room_ids = await self.store.get_rooms_with_many_extremities(
|
2020-05-07 05:35:23 -04:00
|
|
|
min_count=self._dummy_events_threshold,
|
2019-09-26 06:47:53 -04:00
|
|
|
limit=5,
|
|
|
|
room_id_filter=self._rooms_to_exclude_from_dummy_event_insertion.keys(),
|
2019-06-17 13:04:42 -04:00
|
|
|
)
|
|
|
|
|
|
|
|
for room_id in room_ids:
|
2020-09-23 13:18:43 -04:00
|
|
|
dummy_event_sent = await self._send_dummy_event_for_room(room_id)
|
2019-06-17 13:04:42 -04:00
|
|
|
|
2019-09-26 06:47:53 -04:00
|
|
|
if not dummy_event_sent:
|
|
|
|
# Did not find a valid user in the room, so remove from future attempts
|
|
|
|
# Exclusion is time limited, so the room will be rechecked in the future
|
|
|
|
# dependent on _DUMMY_EVENT_ROOM_EXCLUSION_EXPIRY
|
|
|
|
logger.info(
|
|
|
|
"Failed to send dummy event into room %s. Will exclude it from "
|
|
|
|
"future attempts until cache expires" % (room_id,)
|
|
|
|
)
|
|
|
|
now = self.clock.time_msec()
|
|
|
|
self._rooms_to_exclude_from_dummy_event_insertion[room_id] = now
|
|
|
|
|
2020-09-23 13:18:43 -04:00
|
|
|
async def _send_dummy_event_for_room(self, room_id: str) -> bool:
|
|
|
|
"""Attempt to send a dummy event for the given room.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
room_id: room to try to send an event from
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
True if a dummy event was successfully sent. False if no user was able
|
|
|
|
to send an event.
|
|
|
|
"""
|
|
|
|
|
|
|
|
# For each room we need to find a joined member we can use to send
|
|
|
|
# the dummy event with.
|
|
|
|
latest_event_ids = await self.store.get_prev_events_for_room(room_id)
|
|
|
|
members = await self.state.get_current_users_in_room(
|
|
|
|
room_id, latest_event_ids=latest_event_ids
|
|
|
|
)
|
|
|
|
for user_id in members:
|
|
|
|
if not self.hs.is_mine_id(user_id):
|
|
|
|
continue
|
2020-11-17 05:51:25 -05:00
|
|
|
requester = create_requester(user_id, authenticated_entity=self.server_name)
|
2020-09-23 13:18:43 -04:00
|
|
|
try:
|
|
|
|
event, context = await self.create_event(
|
|
|
|
requester,
|
|
|
|
{
|
2020-12-18 04:49:18 -05:00
|
|
|
"type": EventTypes.Dummy,
|
2020-09-23 13:18:43 -04:00
|
|
|
"content": {},
|
|
|
|
"room_id": room_id,
|
|
|
|
"sender": user_id,
|
|
|
|
},
|
|
|
|
prev_event_ids=latest_event_ids,
|
|
|
|
)
|
|
|
|
|
|
|
|
event.internal_metadata.proactively_send = False
|
|
|
|
|
|
|
|
# Since this is a dummy-event it is OK if it is sent by a
|
|
|
|
# shadow-banned user.
|
2020-10-02 13:10:55 -04:00
|
|
|
await self.handle_new_client_event(
|
2021-02-16 17:32:34 -05:00
|
|
|
requester,
|
|
|
|
event,
|
|
|
|
context,
|
|
|
|
ratelimit=False,
|
|
|
|
ignore_shadow_ban=True,
|
2020-09-23 13:18:43 -04:00
|
|
|
)
|
|
|
|
return True
|
|
|
|
except AuthError:
|
|
|
|
logger.info(
|
|
|
|
"Failed to send dummy event into room %s for user %s due to "
|
|
|
|
"lack of power. Will try another user" % (room_id, user_id)
|
|
|
|
)
|
|
|
|
return False
|
|
|
|
|
2019-09-26 06:47:53 -04:00
|
|
|
def _expire_rooms_to_exclude_from_dummy_event_insertion(self):
|
|
|
|
expire_before = self.clock.time_msec() - _DUMMY_EVENT_ROOM_EXCLUSION_EXPIRY
|
|
|
|
to_expire = set()
|
|
|
|
for room_id, time in self._rooms_to_exclude_from_dummy_event_insertion.items():
|
|
|
|
if time < expire_before:
|
|
|
|
to_expire.add(room_id)
|
|
|
|
for room_id in to_expire:
|
|
|
|
logger.debug(
|
|
|
|
"Expiring room id %s from dummy event insertion exclusion cache",
|
|
|
|
room_id,
|
2019-06-17 13:04:42 -04:00
|
|
|
)
|
2019-09-26 06:47:53 -04:00
|
|
|
del self._rooms_to_exclude_from_dummy_event_insertion[room_id]
|
2020-10-13 13:53:56 -04:00
|
|
|
|
|
|
|
async def _rebuild_event_after_third_party_rules(
|
|
|
|
self, third_party_result: dict, original_event: EventBase
|
|
|
|
) -> Tuple[EventBase, EventContext]:
|
|
|
|
# the third_party_event_rules want to replace the event.
|
|
|
|
# we do some basic checks, and then return the replacement event and context.
|
|
|
|
|
|
|
|
# Construct a new EventBuilder and validate it, which helps with the
|
|
|
|
# rest of these checks.
|
|
|
|
try:
|
|
|
|
builder = self.event_builder_factory.for_room_version(
|
|
|
|
original_event.room_version, third_party_result
|
|
|
|
)
|
|
|
|
self.validator.validate_builder(builder)
|
|
|
|
except SynapseError as e:
|
|
|
|
raise Exception(
|
|
|
|
"Third party rules module created an invalid event: " + e.msg,
|
|
|
|
)
|
|
|
|
|
|
|
|
immutable_fields = [
|
|
|
|
# changing the room is going to break things: we've already checked that the
|
|
|
|
# room exists, and are holding a concurrency limiter token for that room.
|
|
|
|
# Also, we might need to use a different room version.
|
|
|
|
"room_id",
|
|
|
|
# changing the type or state key might work, but we'd need to check that the
|
|
|
|
# calling functions aren't making assumptions about them.
|
|
|
|
"type",
|
|
|
|
"state_key",
|
|
|
|
]
|
|
|
|
|
|
|
|
for k in immutable_fields:
|
|
|
|
if getattr(builder, k, None) != original_event.get(k):
|
|
|
|
raise Exception(
|
|
|
|
"Third party rules module created an invalid event: "
|
|
|
|
"cannot change field " + k
|
|
|
|
)
|
|
|
|
|
|
|
|
# check that the new sender belongs to this HS
|
|
|
|
if not self.hs.is_mine_id(builder.sender):
|
|
|
|
raise Exception(
|
|
|
|
"Third party rules module created an invalid event: "
|
|
|
|
"invalid sender " + builder.sender
|
|
|
|
)
|
|
|
|
|
|
|
|
# copy over the original internal metadata
|
|
|
|
for k, v in original_event.internal_metadata.get_dict().items():
|
|
|
|
setattr(builder.internal_metadata, k, v)
|
|
|
|
|
2020-10-16 08:39:46 -04:00
|
|
|
# the event type hasn't changed, so there's no point in re-calculating the
|
|
|
|
# auth events.
|
|
|
|
event = await builder.build(
|
|
|
|
prev_event_ids=original_event.prev_event_ids(),
|
|
|
|
auth_event_ids=original_event.auth_event_ids(),
|
|
|
|
)
|
2020-10-13 13:53:56 -04:00
|
|
|
|
|
|
|
# we rebuild the event context, to be on the safe side. If nothing else,
|
|
|
|
# delta_ids might need an update.
|
|
|
|
context = await self.state.compute_event_context(event)
|
|
|
|
return event, context
|