No OneTemporary
Actions

Authored By

Unknown

Size

23 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/application.ex b/lib/pleroma/application.ex
	index cb15dc1e9..3f199c002 100644
	--- a/lib/pleroma/application.ex
	+++ b/lib/pleroma/application.ex
	@@ -1,305 +1,306 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Application do
	use Application

	import Cachex.Spec

	alias Pleroma.Config

	require Logger

	@name Mix.Project.config()[:name]
	@version Mix.Project.config()[:version]
	@repository Mix.Project.config()[:source_url]

	def name, do: @name
	def version, do: @version
	def named_version, do: @name <> " " <> @version
	def repository, do: @repository

	def user_agent do
	if Process.whereis(Pleroma.Web.Endpoint) do
	case Config.get([:http, :user_agent], :default) do
	:default ->
	info = "#{Pleroma.Web.Endpoint.url()} <#{Config.get([:instance, :email], "")}>"
	named_version() <> "; " <> info

	custom ->
	custom
	end
	else
	# fallback, if endpoint is not started yet
	"Pleroma Data Loader"
	end
	end

	# See http://elixir-lang.org/docs/stable/elixir/Application.html
	# for more information on OTP Applications
	def start(_type, _args) do
	# Scrubbers are compiled at runtime and therefore will cause a conflict
	# every time the application is restarted, so we disable module
	# conflicts at runtime
	Code.compiler_options(ignore_module_conflict: true)
	# Disable warnings_as_errors at runtime, it breaks Phoenix live reload
	# due to protocol consolidation warnings
	Code.compiler_options(warnings_as_errors: false)
	Pleroma.Telemetry.Logger.attach()
	Config.Holder.save_default()
	Pleroma.HTML.compile_scrubbers()
	Pleroma.Config.Oban.warn()
	Config.DeprecationWarnings.warn()

	if Config.get([Pleroma.Web.Plugs.HTTPSecurityPlug, :enable], true) do
	Pleroma.Web.Plugs.HTTPSecurityPlug.warn_if_disabled()
	end

	Pleroma.ApplicationRequirements.verify!()
	load_custom_modules()
	Pleroma.Docs.JSON.compile()
	limiters_setup()

	adapter = Application.get_env(:tesla, :adapter)

	if match?({Tesla.Adapter.Finch, _}, adapter) do
	Logger.info("Starting Finch")
	Finch.start_link(name: MyFinch)
	end

	if adapter == Tesla.Adapter.Gun do
	if version = Pleroma.OTPVersion.version() do
	[major, minor] =
	version
	\|> String.split(".")
	\|> Enum.map(&String.to_integer/1)
	\|> Enum.take(2)

	if (major == 22 and minor < 2) or major < 22 do
	raise "
	!!!OTP VERSION WARNING!!!
	You are using gun adapter with OTP version #{version}, which doesn't support correct handling of unordered certificates chains. Please update your Erlang/OTP to at least 22.2.
	"
	end
	else
	raise "
	!!!OTP VERSION WARNING!!!
	To support correct handling of unordered certificates chains - OTP version must be > 22.2.
	"
	end
	end

	# Define workers and child supervisors to be supervised
	children =
	[
	Pleroma.PromEx,
	+ Pleroma.LDAP,
	Pleroma.Repo,
	Config.TransferTask,
	Pleroma.Emoji,
	Pleroma.Web.Plugs.RateLimiter.Supervisor,
	{Task.Supervisor, name: Pleroma.TaskSupervisor}
	] ++
	cachex_children() ++
	http_children(adapter) ++
	[
	Pleroma.Stats,
	Pleroma.JobQueueMonitor,
	{Majic.Pool, [name: Pleroma.MajicPool, pool_size: Config.get([:majic_pool, :size], 2)]},
	{Oban, Config.get(Oban)},
	Pleroma.Web.Endpoint
	] ++
	task_children() ++
	streamer_registry() ++
	background_migrators() ++
	shout_child(shout_enabled?()) ++
	[Pleroma.Gopher.Server] ++
	[Pleroma.Search.Healthcheck]

	# See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
	# for other strategies and supported options
	# If we have a lot of caches, default max_restarts can cause test
	# resets to fail.
	# Go for the default 3 unless we're in test
	max_restarts = Application.get_env(:pleroma, __MODULE__)[:max_restarts]

	opts = [strategy: :one_for_one, name: Pleroma.Supervisor, max_restarts: max_restarts]
	Supervisor.start_link(children, opts)
	end

	def load_custom_modules do
	dir = Config.get([:modules, :runtime_dir])

	if dir && File.exists?(dir) do
	dir
	\|> Pleroma.Utils.compile_dir()
	\|> case do
	{:error, _errors, _warnings} ->
	raise "Invalid custom modules"

	{:ok, modules, _warnings} ->
	if Application.get_env(:pleroma, __MODULE__)[:load_custom_modules] do
	Enum.each(modules, fn mod ->
	Logger.info("Custom module loaded: #{inspect(mod)}")
	end)
	end

	:ok
	end
	end
	end

	defp cachex_children do
	[
	build_cachex("used_captcha", ttl_interval: seconds_valid_interval()),
	build_cachex("user", default_ttl: 25_000, ttl_interval: 1000, limit: 2500),
	build_cachex("object", default_ttl: 25_000, ttl_interval: 1000, limit: 2500),
	build_cachex("rich_media", default_ttl: :timer.minutes(120), limit: 5000),
	build_cachex("scrubber", limit: 2500),
	build_cachex("scrubber_management", limit: 2500),
	build_cachex("idempotency", expiration: idempotency_expiration(), limit: 2500),
	build_cachex("web_resp", limit: 2500),
	build_cachex("emoji_packs", expiration: emoji_packs_expiration(), limit: 10),
	build_cachex("failed_proxy_url", limit: 2500),
	build_cachex("failed_media_helper_url", default_ttl: :timer.minutes(15), limit: 2_500),
	build_cachex("banned_urls", default_ttl: :timer.hours(24 * 30), limit: 5_000),
	build_cachex("chat_message_id_idempotency_key",
	expiration: chat_message_id_idempotency_key_expiration(),
	limit: 500_000
	),
	build_cachex("rel_me", limit: 2500),
	build_cachex("host_meta", default_ttl: :timer.minutes(120), limit: 5000)
	]
	end

	defp emoji_packs_expiration,
	do: expiration(default: :timer.seconds(5 * 60), interval: :timer.seconds(60))

	defp idempotency_expiration,
	do: expiration(default: :timer.seconds(6 * 60 * 60), interval: :timer.seconds(60))

	defp chat_message_id_idempotency_key_expiration,
	do: expiration(default: :timer.minutes(2), interval: :timer.seconds(60))

	defp seconds_valid_interval,
	do: :timer.seconds(Config.get!([Pleroma.Captcha, :seconds_valid]))

	@spec build_cachex(String.t(), keyword()) :: map()
	def build_cachex(type, opts),
	do: %{
	id: String.to_atom("cachex_" <> type),
	start: {Cachex, :start_link, [String.to_atom(type <> "_cache"), opts]},
	type: :worker
	}

	defp shout_enabled?, do: Config.get([:shout, :enabled])

	defp streamer_registry do
	if Application.get_env(:pleroma, __MODULE__)[:streamer_registry] do
	[
	{Registry,
	[
	name: Pleroma.Web.Streamer.registry(),
	keys: :duplicate,
	partitions: System.schedulers_online()
	]}
	]
	else
	[]
	end
	end

	defp background_migrators do
	if Application.get_env(:pleroma, __MODULE__)[:background_migrators] do
	[
	Pleroma.Migrators.HashtagsTableMigrator,
	Pleroma.Migrators.ContextObjectsDeletionMigrator
	]
	else
	[]
	end
	end

	defp shout_child(true) do
	[
	Pleroma.Web.ShoutChannel.ShoutChannelState,
	{Phoenix.PubSub, [name: Pleroma.PubSub, adapter: Phoenix.PubSub.PG2]}
	]
	end

	defp shout_child(_), do: []

	defp task_children do
	children = [
	%{
	id: :web_push_init,
	start: {Task, :start_link, [&Pleroma.Web.Push.init/0]},
	restart: :temporary
	}
	]

	if Application.get_env(:pleroma, __MODULE__)[:internal_fetch] do
	children ++
	[
	%{
	id: :internal_fetch_init,
	start: {Task, :start_link, [&Pleroma.Web.ActivityPub.InternalFetchActor.init/0]},
	restart: :temporary
	}
	]
	else
	children
	end
	end

	# start hackney and gun pools in tests
	defp http_children(adapter) do
	if Application.get_env(:pleroma, __MODULE__)[:test_http_pools] do
	http_children_hackney() ++ http_children_gun()
	else
	cond do
	match?(Tesla.Adapter.Hackney, adapter) -> http_children_hackney()
	match?(Tesla.Adapter.Gun, adapter) -> http_children_gun()
	true -> []
	end
	end
	end

	defp http_children_hackney do
	pools = [:federation, :media]

	pools =
	if Config.get([Pleroma.Upload, :proxy_remote]) do
	[:upload \| pools]
	else
	pools
	end

	for pool <- pools do
	options = Config.get([:hackney_pools, pool])
	:hackney_pool.child_spec(pool, options)
	end
	end

	defp http_children_gun do
	Pleroma.Gun.ConnectionPool.children() ++
	[{Task, &Pleroma.HTTP.AdapterHelper.Gun.limiter_setup/0}]
	end

	@spec limiters_setup() :: :ok
	def limiters_setup do
	config = Config.get(ConcurrentLimiter, [])

	[
	Pleroma.Search
	]
	\|> Enum.each(fn module ->
	mod_config = Keyword.get(config, module, [])

	max_running = Keyword.get(mod_config, :max_running, 5)
	max_waiting = Keyword.get(mod_config, :max_waiting, 5)

	ConcurrentLimiter.new(module, max_running, max_waiting)
	end)
	end
	end
	diff --git a/lib/pleroma/web/auth/ldap_authenticator.ex b/lib/pleroma/ldap.ex
	similarity index 58%
	copy from lib/pleroma/web/auth/ldap_authenticator.ex
	copy to lib/pleroma/ldap.ex
	index ad5bc9863..868932501 100644
	--- a/lib/pleroma/web/auth/ldap_authenticator.ex
	+++ b/lib/pleroma/ldap.ex
	@@ -1,175 +1,233 @@
	-# Pleroma: A lightweight social networking server
	-# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	-# SPDX-License-Identifier: AGPL-3.0-only
	-
	-defmodule Pleroma.Web.Auth.LDAPAuthenticator do
	- alias Pleroma.User
	+defmodule Pleroma.LDAP do
	+ use GenServer

	require Logger

	- import Pleroma.Web.Auth.Helpers, only: [fetch_credentials: 1, fetch_user: 1]
	+ alias Pleroma.Config
	+ alias Pleroma.User

	- @behaviour Pleroma.Web.Auth.Authenticator
	- @base Pleroma.Web.Auth.PleromaAuthenticator
	+ import Pleroma.Web.Auth.Helpers, only: [fetch_user: 1]

	@connection_timeout 10_000
	@search_timeout 10_000

	- defdelegate get_registration(conn), to: @base
	- defdelegate create_from_registration(conn, registration), to: @base
	- defdelegate handle_error(conn, error), to: @base
	- defdelegate auth_template, to: @base
	- defdelegate oauth_consumer_template, to: @base
	-
	- def get_user(%Plug.Conn{} = conn) do
	- with {:ldap, true} <- {:ldap, Pleroma.Config.get([:ldap, :enabled])},
	- {:ok, {name, password}} <- fetch_credentials(conn),
	- %User{} = user <- ldap_user(name, password) do
	- {:ok, user}
	- else
	- {:ldap, _} ->
	- @base.get_user(conn)
	+ def start_link(_) do
	+ GenServer.start_link(__MODULE__, [], name: __MODULE__)
	+ end

	- error ->
	- error
	+ @impl true
	+ def init(state) do
	+ case {Config.get(Pleroma.Web.Auth.Authenticator), Config.get([:ldap, :enabled])} do
	+ {Pleroma.Web.Auth.LDAPAuthenticator, true} ->
	+ {:ok, state, {:continue, :connect}}
	+
	+ {Pleroma.Web.Auth.LDAPAuthenticator, false} ->
	+ Logger.error(
	+ "LDAP Authenticator enabled but :pleroma, :ldap is not enabled. Auth will not work."
	+ )
	+
	+ {:ok, state}
	+
	+ {_, true} ->
	+ Logger.warning(
	+ ":pleroma, :ldap is enabled but Pleroma.Web.Authenticator is not set to the LDAPAuthenticator. LDAP will not be used."
	+ )
	+
	+ {:ok, state}
	+ end
	+ end
	+
	+ @impl true
	+ def handle_continue(:connect, _state), do: do_handle_connect()
	+
	+ @impl true
	+ def handle_info(:connect, _state), do: do_handle_connect()
	+
	+ def handle_info({:bind_after_reconnect, name, password, from}, state) do
	+ result = bind_user(state[:connection], name, password)
	+
	+ GenServer.reply(from, result)
	+
	+ {:noreply, state}
	+ end
	+
	+ defp do_handle_connect() do
	+ state =
	+ case connect() do
	+ {:ok, connection} ->
	+ :eldap.controlling_process(connection, self())
	+ [connection: connection]
	+
	+ _ ->
	+ Logger.error("Failed to connect to LDAP. Retrying in 5000ms")
	+ Process.send_after(self(), :connect, 5_000)
	+ []
	+ end
	+
	+ {:noreply, state}
	+ end
	+
	+ @impl true
	+ def handle_call({:bind_user, name, password}, from, state) do
	+ case bind_user(state[:connection], name, password) do
	+ :needs_reconnect ->
	+ Process.send(self(), {:bind_after_reconnect, name, password, from}, [])
	+ {:noreply, state, {:continue, :connect}}
	+
	+ result ->
	+ {:reply, result, state, :hibernate}
	end
	end

	- defp ldap_user(name, password) do
	- ldap = Pleroma.Config.get(:ldap, [])
	+ @impl true
	+ def terminate(_, state) do
	+ :eldap.close(state[:connection])
	+
	+ :ok
	+ end
	+
	+ defp connect() do
	+ ldap = Config.get(:ldap, [])
	host = Keyword.get(ldap, :host, "localhost")
	port = Keyword.get(ldap, :port, 389)
	ssl = Keyword.get(ldap, :ssl, false)
	tls = Keyword.get(ldap, :tls, false)
	cacertfile = Keyword.get(ldap, :cacertfile) \|\| CAStore.file_path()

	default_secure_opts = [
	verify: :verify_peer,
	cacerts: decode_certfile(cacertfile),
	customize_hostname_check: [
	fqdn_fun: fn _ -> to_charlist(host) end
	]
	]

	sslopts = Keyword.merge(default_secure_opts, Keyword.get(ldap, :sslopts, []))
	tlsopts = Keyword.merge(default_secure_opts, Keyword.get(ldap, :tlsopts, []))

	+ default_options = [{:port, port}, {:ssl, ssl}, {:timeout, @connection_timeout}]
	+
	# :sslopts can only be included in :eldap.open/2 when {ssl: true}
	# or the connection will fail
	options =
	if ssl do
	- [{:port, port}, {:ssl, ssl}, {:sslopts, sslopts}, {:timeout, @connection_timeout}]
	+ default_options ++ [{:sslopts, sslopts}]
	else
	- [{:port, port}, {:ssl, ssl}, {:timeout, @connection_timeout}]
	+ default_options
	end

	case :eldap.open([to_charlist(host)], options) do
	{:ok, connection} ->
	try do
	cond do
	ssl ->
	:application.ensure_all_started(:ssl)
	+ {:ok, connection}

	tls ->
	case :eldap.start_tls(
	connection,
	tlsopts,
	@connection_timeout
	) do
	:ok ->
	- :ok
	+ {:ok, connection}

	error ->
	Logger.error("Could not start TLS: #{inspect(error)}")
	:eldap.close(connection)
	end

	true ->
	- :ok
	+ {:ok, :connection}
	end
	-
	- bind_user(connection, ldap, name, password)
	after
	- :eldap.close(connection)
	+ :ok
	end

	{:error, error} ->
	Logger.error("Could not open LDAP connection: #{inspect(error)}")
	{:error, {:ldap_connection_error, error}}
	end
	end

	- defp bind_user(connection, ldap, name, password) do
	- uid = Keyword.get(ldap, :uid, "cn")
	- base = Keyword.get(ldap, :base)
	+ defp bind_user(connection, name, password) do
	+ uid = Config.get([:ldap, :uid], "cn")
	+ base = Config.get([:ldap, :base])

	case :eldap.simple_bind(connection, "#{uid}=#{name},#{base}", password) do
	:ok ->
	case fetch_user(name) do
	%User{} = user ->
	user

	_ ->
	register_user(connection, base, uid, name)
	end

	+ # eldap does not inform us of socket closure
	+ # until it is used
	+ {:error, {:gen_tcp_error, :closed}} ->
	+ :eldap.close(connection)
	+ :needs_reconnect
	+
	error ->
	Logger.error("Could not bind LDAP user #{name}: #{inspect(error)}")
	{:error, {:ldap_bind_error, error}}
	end
	end

	defp register_user(connection, base, uid, name) do
	case :eldap.search(connection, [
	{:base, to_charlist(base)},
	{:filter, :eldap.equalityMatch(to_charlist(uid), to_charlist(name))},
	{:scope, :eldap.wholeSubtree()},
	{:timeout, @search_timeout}
	]) do
	# The :eldap_search_result record structure changed in OTP 24.3 and added a controls field
	# https://github.com/erlang/otp/pull/5538
	{:ok, {:eldap_search_result, [{:eldap_entry, _object, attributes}], _referrals}} ->
	try_register(name, attributes)

	{:ok, {:eldap_search_result, [{:eldap_entry, _object, attributes}], _referrals, _controls}} ->
	try_register(name, attributes)

	error ->
	Logger.error("Couldn't register user because LDAP search failed: #{inspect(error)}")
	{:error, {:ldap_search_error, error}}
	end
	end

	defp try_register(name, attributes) do
	params = %{
	name: name,
	nickname: name,
	password: nil
	}

	params =
	case List.keyfind(attributes, ~c"mail", 0) do
	{_, [mail]} -> Map.put_new(params, :email, :erlang.list_to_binary(mail))
	_ -> params
	end

	changeset = User.register_changeset_ldap(%User{}, params)

	case User.register(changeset) do
	{:ok, user} -> user
	error -> error
	end
	end

	defp decode_certfile(file) do
	with {:ok, data} <- File.read(file) do
	data
	\|> :public_key.pem_decode()
	\|> Enum.map(fn {_, b, _} -> b end)
	else
	_ ->
	Logger.error("Unable to read certfile: #{file}")
	[]
	end
	end
	end
	diff --git a/lib/pleroma/web/auth/ldap_authenticator.ex b/lib/pleroma/web/auth/ldap_authenticator.ex
	index ad5bc9863..c420c8bc3 100644
	--- a/lib/pleroma/web/auth/ldap_authenticator.ex
	+++ b/lib/pleroma/web/auth/ldap_authenticator.ex
	@@ -1,175 +1,32 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Auth.LDAPAuthenticator do
	alias Pleroma.User

	- require Logger
	-
	- import Pleroma.Web.Auth.Helpers, only: [fetch_credentials: 1, fetch_user: 1]
	+ import Pleroma.Web.Auth.Helpers, only: [fetch_credentials: 1]

	@behaviour Pleroma.Web.Auth.Authenticator
	@base Pleroma.Web.Auth.PleromaAuthenticator

	- @connection_timeout 10_000
	- @search_timeout 10_000
	-
	defdelegate get_registration(conn), to: @base
	defdelegate create_from_registration(conn, registration), to: @base
	defdelegate handle_error(conn, error), to: @base
	defdelegate auth_template, to: @base
	defdelegate oauth_consumer_template, to: @base

	def get_user(%Plug.Conn{} = conn) do
	with {:ldap, true} <- {:ldap, Pleroma.Config.get([:ldap, :enabled])},
	{:ok, {name, password}} <- fetch_credentials(conn),
	- %User{} = user <- ldap_user(name, password) do
	+ %User{} = user <- GenServer.call(Pleroma.LDAP, {:bind_user, name, password}) do
	{:ok, user}
	else
	{:ldap, _} ->
	@base.get_user(conn)

	error ->
	error
	end
	end
	-
	- defp ldap_user(name, password) do
	- ldap = Pleroma.Config.get(:ldap, [])
	- host = Keyword.get(ldap, :host, "localhost")
	- port = Keyword.get(ldap, :port, 389)
	- ssl = Keyword.get(ldap, :ssl, false)
	- tls = Keyword.get(ldap, :tls, false)
	- cacertfile = Keyword.get(ldap, :cacertfile) \|\| CAStore.file_path()
	-
	- default_secure_opts = [
	- verify: :verify_peer,
	- cacerts: decode_certfile(cacertfile),
	- customize_hostname_check: [
	- fqdn_fun: fn _ -> to_charlist(host) end
	- ]
	- ]
	-
	- sslopts = Keyword.merge(default_secure_opts, Keyword.get(ldap, :sslopts, []))
	- tlsopts = Keyword.merge(default_secure_opts, Keyword.get(ldap, :tlsopts, []))
	-
	- # :sslopts can only be included in :eldap.open/2 when {ssl: true}
	- # or the connection will fail
	- options =
	- if ssl do
	- [{:port, port}, {:ssl, ssl}, {:sslopts, sslopts}, {:timeout, @connection_timeout}]
	- else
	- [{:port, port}, {:ssl, ssl}, {:timeout, @connection_timeout}]
	- end
	-
	- case :eldap.open([to_charlist(host)], options) do
	- {:ok, connection} ->
	- try do
	- cond do
	- ssl ->
	- :application.ensure_all_started(:ssl)
	-
	- tls ->
	- case :eldap.start_tls(
	- connection,
	- tlsopts,
	- @connection_timeout
	- ) do
	- :ok ->
	- :ok
	-
	- error ->
	- Logger.error("Could not start TLS: #{inspect(error)}")
	- :eldap.close(connection)
	- end
	-
	- true ->
	- :ok
	- end
	-
	- bind_user(connection, ldap, name, password)
	- after
	- :eldap.close(connection)
	- end
	-
	- {:error, error} ->
	- Logger.error("Could not open LDAP connection: #{inspect(error)}")
	- {:error, {:ldap_connection_error, error}}
	- end
	- end
	-
	- defp bind_user(connection, ldap, name, password) do
	- uid = Keyword.get(ldap, :uid, "cn")
	- base = Keyword.get(ldap, :base)
	-
	- case :eldap.simple_bind(connection, "#{uid}=#{name},#{base}", password) do
	- :ok ->
	- case fetch_user(name) do
	- %User{} = user ->
	- user
	-
	- _ ->
	- register_user(connection, base, uid, name)
	- end
	-
	- error ->
	- Logger.error("Could not bind LDAP user #{name}: #{inspect(error)}")
	- {:error, {:ldap_bind_error, error}}
	- end
	- end
	-
	- defp register_user(connection, base, uid, name) do
	- case :eldap.search(connection, [
	- {:base, to_charlist(base)},
	- {:filter, :eldap.equalityMatch(to_charlist(uid), to_charlist(name))},
	- {:scope, :eldap.wholeSubtree()},
	- {:timeout, @search_timeout}
	- ]) do
	- # The :eldap_search_result record structure changed in OTP 24.3 and added a controls field
	- # https://github.com/erlang/otp/pull/5538
	- {:ok, {:eldap_search_result, [{:eldap_entry, _object, attributes}], _referrals}} ->
	- try_register(name, attributes)
	-
	- {:ok, {:eldap_search_result, [{:eldap_entry, _object, attributes}], _referrals, _controls}} ->
	- try_register(name, attributes)
	-
	- error ->
	- Logger.error("Couldn't register user because LDAP search failed: #{inspect(error)}")
	- {:error, {:ldap_search_error, error}}
	- end
	- end
	-
	- defp try_register(name, attributes) do
	- params = %{
	- name: name,
	- nickname: name,
	- password: nil
	- }
	-
	- params =
	- case List.keyfind(attributes, ~c"mail", 0) do
	- {_, [mail]} -> Map.put_new(params, :email, :erlang.list_to_binary(mail))
	- _ -> params
	- end
	-
	- changeset = User.register_changeset_ldap(%User{}, params)
	-
	- case User.register(changeset) do
	- {:ok, user} -> user
	- error -> error
	- end
	- end
	-
	- defp decode_certfile(file) do
	- with {:ok, data} <- File.read(file) do
	- data
	- \|> :public_key.pem_decode()
	- \|> Enum.map(fn {_, b, _} -> b end)
	- else
	- _ ->
	- Logger.error("Unable to read certfile: #{file}")
	- []
	- end
	- end
	end

File Metadata

Mime Type: text/x-diff
Expires: Thu, Oct 29, 3:03 PM (1 d, 9 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1798246
Default Alt Text: (23 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions