2 assert_activity_not_local,
3 community_inbox::{community_receive_message, CommunityAcceptedActivities},
5 inbox_verify_http_signature,
6 is_activity_already_known,
7 is_addressed_to_community_followers,
8 is_addressed_to_local_person,
9 person_inbox::{person_receive_message, PersonAcceptedActivities},
11 use activitystreams::{activity::ActorAndObject, prelude::*};
12 use actix_web::{web, HttpRequest, HttpResponse};
14 use lemmy_api_common::blocking;
15 use lemmy_apub::{get_activity_to_and_cc, insert_activity};
16 use lemmy_db_queries::{ApubObject, DbPool};
17 use lemmy_db_schema::source::community::Community;
18 use lemmy_utils::{location_info, LemmyError};
19 use lemmy_websocket::LemmyContext;
20 use serde::{Deserialize, Serialize};
24 /// Allowed activity types for shared inbox.
25 #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd, Deserialize, Serialize)]
26 #[serde(rename_all = "PascalCase")]
40 // TODO: this isnt entirely correct, cause some of these receive are not ActorAndObject,
41 // but it still works due to the anybase conversion
42 pub type AcceptedActivities = ActorAndObject<ValidTypes>;
44 /// Handler for all incoming requests to shared inbox.
45 pub async fn shared_inbox(
47 input: web::Json<AcceptedActivities>,
48 context: web::Data<LemmyContext>,
49 ) -> Result<HttpResponse, LemmyError> {
50 let activity = input.into_inner();
51 // First of all check the http signature
52 let request_counter = &mut 0;
53 let actor = inbox_verify_http_signature(&activity, &context, request, request_counter).await?;
55 // Do nothing if we received the same activity before
56 let actor_id = actor.actor_id();
57 let activity_id = get_activity_id(&activity, &actor_id)?;
58 if is_activity_already_known(context.pool(), &activity_id).await? {
59 return Ok(HttpResponse::Ok().finish());
62 assert_activity_not_local(&activity)?;
63 // Log the activity, so we avoid receiving and parsing it twice. Note that this could still happen
64 // if we receive the same activity twice in very quick succession.
65 insert_activity(&activity_id, activity.clone(), false, true, context.pool()).await?;
67 let activity_any_base = activity.clone().into_any_base()?;
68 let mut res: Option<HttpResponse> = None;
69 let to_and_cc = get_activity_to_and_cc(&activity);
70 // Handle community first, so in case the sender is banned by the community, it will error out.
71 // If we handled the person receive first, the activity would be inserted to the database before the
72 // community could check for bans.
73 // Note that an activity can be addressed to a community and to a person (or multiple persons) at the
74 // same time. In this case we still only handle it once, to avoid duplicate websocket
76 let community = extract_local_community_from_destinations(&to_and_cc, context.pool()).await?;
77 if let Some(community) = community {
78 let community_activity = CommunityAcceptedActivities::from_any_base(activity_any_base.clone())?
79 .context(location_info!())?;
81 Box::pin(community_receive_message(
90 } else if is_addressed_to_local_person(&to_and_cc, context.pool()).await? {
91 let person_activity = PersonAcceptedActivities::from_any_base(activity_any_base.clone())?
92 .context(location_info!())?;
93 // `to_person` is only used for follow activities (which we dont receive here), so no need to pass
95 Box::pin(person_receive_message(
103 } else if is_addressed_to_community_followers(&to_and_cc, context.pool())
107 let person_activity = PersonAcceptedActivities::from_any_base(activity_any_base.clone())?
108 .context(location_info!())?;
110 Box::pin(person_receive_message(
121 // If none of those, throw an error
122 if let Some(r) = res {
125 Ok(HttpResponse::NotImplemented().finish())
129 /// If `to_and_cc` contains the ID of a local community, return that community, otherwise return
132 /// This doesnt handle the case where an activity is addressed to multiple communities (because
133 /// Lemmy doesnt generate such activities).
134 async fn extract_local_community_from_destinations(
137 ) -> Result<Option<Community>, LemmyError> {
138 for url in to_and_cc {
139 let url = url.to_owned();
140 let community = blocking(pool, move |conn| {
141 Community::read_from_apub_id(conn, &url.into())
144 if let Ok(c) = community {