git.squeep.com Git - akkoma/blob - lib/pleroma/web/nodeinfo/nodeinfo_controller.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.Nodeinfo.NodeinfoController do
   6   use Pleroma.Web, :controller
   7
   8   alias Pleroma.Config
   9   alias Pleroma.Stats
  10   alias Pleroma.User
  11   alias Pleroma.Web
  12   alias Pleroma.Web.ActivityPub.MRF
  13   alias Pleroma.Web.Federator.Publisher
  14
  15   def schemas(conn, _params) do
  16     response = %{
  17       links: [
  18         %{
  19           rel: "http://nodeinfo.diaspora.software/ns/schema/2.0",
  20           href: Web.base_url() <> "/nodeinfo/2.0.json"
  21         },
  22         %{
  23           rel: "http://nodeinfo.diaspora.software/ns/schema/2.1",
  24           href: Web.base_url() <> "/nodeinfo/2.1.json"
  25         }
  26       ]
  27     }
  28
  29     json(conn, response)
  30   end
  31
  32   # returns a nodeinfo 2.0 map, since 2.1 just adds a repository field
  33   # under software.
  34   def raw_nodeinfo do
  35     stats = Stats.get_stats()
  36
  37     exclusions = Config.get([:instance, :mrf_transparency_exclusions])
  38
  39     mrf_simple =
  40       Config.get(:mrf_simple)
  41       |> Enum.map(fn {k, v} -> {k, Enum.reject(v, fn v -> v in exclusions end)} end)
  42       |> Enum.into(%{})
  43
  44     # This horror is needed to convert regex sigils to strings
  45     mrf_keyword =
  46       Config.get(:mrf_keyword, [])
  47       |> Enum.map(fn {key, value} ->
  48         {key,
  49          Enum.map(value, fn
  50            {pattern, replacement} ->
  51              %{
  52                "pattern" =>
  53                  if not is_binary(pattern) do
  54                    inspect(pattern)
  55                  else
  56                    pattern
  57                  end,
  58                "replacement" => replacement
  59              }
  60
  61            pattern ->
  62              if not is_binary(pattern) do
  63                inspect(pattern)
  64              else
  65                pattern
  66              end
  67          end)}
  68       end)
  69       |> Enum.into(%{})
  70
  71     mrf_policies =
  72       MRF.get_policies()
  73       |> Enum.map(fn policy -> to_string(policy) |> String.split(".") |> List.last() end)
  74
  75     quarantined = Config.get([:instance, :quarantined_instances], [])
  76
  77     staff_accounts =
  78       User.all_superusers()
  79       |> Enum.map(fn u -> u.ap_id end)
  80
  81     mrf_user_allowlist =
  82       Config.get([:mrf_user_allowlist], [])
  83       |> Enum.into(%{}, fn {k, v} -> {k, length(v)} end)
  84
  85     federation_response =
  86       if Config.get([:instance, :mrf_transparency]) do
  87         %{
  88           mrf_policies: mrf_policies,
  89           mrf_simple: mrf_simple,
  90           mrf_keyword: mrf_keyword,
  91           mrf_user_allowlist: mrf_user_allowlist,
  92           quarantined_instances: quarantined,
  93           exclusions: length(exclusions) > 0
  94         }
  95       else
  96         %{}
  97       end
  98
  99     features =
 100       [
 101         "pleroma_api",
 102         "mastodon_api",
 103         "mastodon_api_streaming",
 104         "polls",
 105         "pleroma_explicit_addressing",
 106         if Config.get([:media_proxy, :enabled]) do
 107           "media_proxy"
 108         end,
 109         if Config.get([:gopher, :enabled]) do
 110           "gopher"
 111         end,
 112         if Config.get([:chat, :enabled]) do
 113           "chat"
 114         end,
 115         if Config.get([:suggestions, :enabled]) do
 116           "suggestions"
 117         end,
 118         if Config.get([:instance, :allow_relay]) do
 119           "relay"
 120         end,
 121         if Config.get([:instance, :safe_dm_mentions]) do
 122           "safe_dm_mentions"
 123         end
 124       ]
 125       |> Enum.filter(& &1)
 126
 127     %{
 128       version: "2.0",
 129       software: %{
 130         name: Pleroma.Application.name() |> String.downcase(),
 131         version: Pleroma.Application.version()
 132       },
 133       protocols: Publisher.gather_nodeinfo_protocol_names(),
 134       services: %{
 135         inbound: [],
 136         outbound: []
 137       },
 138       openRegistrations: Config.get([:instance, :registrations_open]),
 139       usage: %{
 140         users: %{
 141           total: stats.user_count || 0
 142         },
 143         localPosts: stats.status_count || 0
 144       },
 145       metadata: %{
 146         nodeName: Config.get([:instance, :name]),
 147         nodeDescription: Config.get([:instance, :description]),
 148         private: !Config.get([:instance, :public], true),
 149         suggestions: %{
 150           enabled: Config.get([:suggestions, :enabled], false),
 151           thirdPartyEngine: Config.get([:suggestions, :third_party_engine], ""),
 152           timeout: Config.get([:suggestions, :timeout], 5000),
 153           limit: Config.get([:suggestions, :limit], 23),
 154           web: Config.get([:suggestions, :web], "")
 155         },
 156         staffAccounts: staff_accounts,
 157         federation: federation_response,
 158         pollLimits: Config.get([:instance, :poll_limits]),
 159         postFormats: Config.get([:instance, :allowed_post_formats]),
 160         uploadLimits: %{
 161           general: Config.get([:instance, :upload_limit]),
 162           avatar: Config.get([:instance, :avatar_upload_limit]),
 163           banner: Config.get([:instance, :banner_upload_limit]),
 164           background: Config.get([:instance, :background_upload_limit])
 165         },
 166         accountActivationRequired: Config.get([:instance, :account_activation_required], false),
 167         invitesEnabled: Config.get([:instance, :invites_enabled], false),
 168         features: features,
 169         restrictedNicknames: Config.get([Pleroma.User, :restricted_nicknames]),
 170         skipThreadContainment: Config.get([:instance, :skip_thread_containment], false)
 171       }
 172     }
 173   end
 174
 175   # Schema definition: https://github.com/jhass/nodeinfo/blob/master/schemas/2.0/schema.json
 176   # and https://github.com/jhass/nodeinfo/blob/master/schemas/2.1/schema.json
 177   def nodeinfo(conn, %{"version" => "2.0"}) do
 178     conn
 179     |> put_resp_header(
 180       "content-type",
 181       "application/json; profile=http://nodeinfo.diaspora.software/ns/schema/2.0#; charset=utf-8"
 182     )
 183     |> json(raw_nodeinfo())
 184   end
 185
 186   def nodeinfo(conn, %{"version" => "2.1"}) do
 187     raw_response = raw_nodeinfo()
 188
 189     updated_software =
 190       raw_response
 191       |> Map.get(:software)
 192       |> Map.put(:repository, Pleroma.Application.repository())
 193
 194     response =
 195       raw_response
 196       |> Map.put(:software, updated_software)
 197       |> Map.put(:version, "2.1")
 198
 199     conn
 200     |> put_resp_header(
 201       "content-type",
 202       "application/json; profile=http://nodeinfo.diaspora.software/ns/schema/2.1#; charset=utf-8"
 203     )
 204     |> json(response)
 205   end
 206
 207   def nodeinfo(conn, _) do
 208     render_error(conn, :not_found, "Nodeinfo schema version not handled")
 209   end
 210 end