No OneTemporary
Actions

Size

25 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/.gitignore b/.gitignore
	index 6356d56..81037b9 100644
	--- a/.gitignore
	+++ b/.gitignore
	@@ -1,12 +1,12 @@
	/_build
	/cover
	/deps
	/doc
	/.fetch
	erl_crash.dump
	*.ez
	*.beam
	/config/*.secret.exs
	-/priv/libmagic_port
	-/test/*.mgc
	+/priv/
	+*.mgc
	core.*
	diff --git a/src/libmagic_port.c b/src/libmagic_port.c
	index 84199e3..04d9e84 100644
	--- a/src/libmagic_port.c
	+++ b/src/libmagic_port.c
	@@ -1,449 +1,446 @@
	//
	// libmagic_port: The Sorcerer’s Apprentice
	//
	// To use this program, compile it with dynamically linked libmagic, as mirrored
	// at https://github.com/file/file. You may install it with apt-get,
	// yum or brew. Refer to the Makefile for further reference.
	//
	// This program is designed to run interactively as a backend daemon to the
	// GenMagic library.
	//
	// Communication is done over STDIN/STDOUT as binary packets of 2 bytes length
	// plus X bytes payload, where the payload is an erlang term encoded with
	// :erlang.term_to_binary/1 and decoded with :erlang.binary_to_term/1.
	//
	// Once the program is ready, it sends the `:ready` atom.
	//
	// It is then up to the Erlang side to load databases, by sending messages:
	// - `{:add_database, :default \| path}`
	//
	// If the requested database have been loaded, an `{:ok, :loaded}` message will
	// follow. Otherwise, the process will exit (exit code 1).
	//
	// Commands are sent to the program STDIN as an erlang term of `{Operation,
	// Argument}`, and response of `{:ok \| :error, Response}`.
	//
	// The program may exit with the following exit codes:
	// - 1 if libmagic handles could not be opened,
	// - 2 if something went wrong with ei_*,
	// - 3 if you sent invalid term format,
	// - 255 if the loop exited unexpectedly.
	//
	// Invalid packets will cause the program to exit (exit code 3). This will
	// happen if your Erlang Term format doesn't match the version the program has
	// been compiled with.
	//
	// Commands:
	// {:reload, _} :: :ready
	// {:add_database, :default \| String.t()} :: {:ok, _} \| {:error, _}
	// {:file, path :: String.t()} :: {:ok, {type, encoding, name}} \| {:error,
	// :badarg} \| {:error, {errno :: integer(), String.t()}}
	// {:bytes, binary()} :: same as :file
	// {:stop, reason :: atom()} :: exit 0

	#include <arpa/inet.h>
	#include <ei.h>
	#ifdef EI_INCOMPLETE
	#include <erl_interface.h>
	#endif
	#include <errno.h>
	#include <getopt.h>
	#include <libgen.h>
	#include <magic.h>
	#include <stdarg.h>
	#include <stdbool.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <unistd.h>

	#define ERROR_OK 0
	#define ERROR_MAGIC 1
	#define ERROR_EI 2
	#define ERROR_BAD_TERM 3

	// We use a bigger than possible valid command length (around 4111 bytes) to
	// allow more precise errors when using too long paths.
	#define COMMAND_LEN 8000
	#define COMMAND_BUFFER_SIZE COMMAND_LEN + 1

	#define MAGIC_FLAGS_COMMON (MAGIC_CHECK \| MAGIC_ERROR)
	magic_t magic_setup(int flags);

	#define EI_ENSURE(result) \
	do { \
	if (result != 0) { \
	fprintf(stderr, "EI ERROR, line: %d", __LINE__); \
	exit(ERROR_EI); \
	} \
	} while (0);

	typedef char byte;

	void setup_environment();
	void magic_close_all();
	void magic_open_all();
	int magic_load_all(char *path);
	void process_command(uint16_t len, byte *buf);
	void process_command_file(byte buf, int index, ei_x_buff result);
	void process_command_bytes(byte buf, int index, ei_x_buff result);
	void process_command_load(byte buf, int index, ei_x_buff result);
	void process_file(char path, ei_x_buff result);
	void process_bytes(char bytes, int size, ei_x_buff result);
	void process_load(ei_x_buff result, char path);
	void send_and_free(ei_x_buff *result);
	size_t read_cmd(byte *buf);
	size_t write_cmd(byte *buf, size_t len);
	void error(ei_x_buff result, const char error);
	void handle_magic_error(magic_t handle, int errn, ei_x_buff *result);
	void fdseek(uint16_t count);

	static magic_t magic_mime_type; // MAGIC_MIME_TYPE
	static magic_t magic_mime_encoding; // MAGIC_MIME_ENCODING
	static magic_t magic_type_name; // MAGIC_NONE

	bool magic_loaded = false;

	int main(int argc, char **argv) {
	-#ifdef EI_INCOMPLETE
	- erl_init(NULL, -1);
	-#else
	- EI_ENSURE(ei_init());
	-#endif
	+ if (!getenv("MAJIC_DEBUG"))
	+ freopen("/dev/null", "w", stderr);
	setup_environment();
	magic_open_all();

	byte buf[COMMAND_BUFFER_SIZE];
	uint16_t len;
	while ((len = read_cmd(buf)) > 0) {
	process_command(len, buf);
	}

	return 255;
	}

	void process_command(uint16_t len, byte *buf) {
	ei_x_buff result;
	char atom[128];
	int index, version, arity;
	index = 0;

	// Initialize result
	EI_ENSURE(ei_x_new_with_version(&result));
	EI_ENSURE(ei_x_encode_tuple_header(&result, 2));

	if (len >= COMMAND_LEN)
	return error(&result, "badarg");

	if (ei_decode_version(buf, &index, &version) != 0)
	exit(ERROR_BAD_TERM);

	if (ei_decode_tuple_header(buf, &index, &arity) != 0)
	return error(&result, "badarg");

	if (arity != 2)
	return error(&result, "badarg");

	if (ei_decode_atom(buf, &index, atom) != 0)
	return error(&result, "badarg");

	// {:file, path}
	if (strlen(atom) == 4 && strcmp(atom, "file") == 0)
	return process_command_file(buf, index, &result);

	// {:bytes, bytes}
	if (strlen(atom) == 5 && strcmp(atom, "bytes") == 0)
	return process_command_bytes(buf, index, &result);

	// {:add_database, path}
	if (strlen(atom) == 12 && strcmp(atom, "add_database") == 0)
	return process_command_load(buf, index, &result);

	// {:reload, _}
	if (strlen(atom) == 6 && strcmp(atom, "reload") == 0)
	return magic_open_all();

	// {:stop, _}
	if (strlen(atom) == 4 && strcmp(atom, "stop") == 0)
	exit(ERROR_OK);

	error(&result, "badarg");
	}

	void process_command_file(byte buf, int index, ei_x_buff result) {
	int termtype, termsize;
	char path[4097];
	long bin_length;

	if (!magic_loaded)
	return error(result, "magic_database_not_loaded");

	ei_get_type(buf, &index, &termtype, &termsize);

	if (termtype != ERL_BINARY_EXT)
	return error(result, "badarg");

	if (termsize > 4096)
	return error(result, "enametoolong");

	EI_ENSURE(ei_decode_binary(buf, &index, path, &bin_length));
	path[termsize] = '\0';
	process_file(path, result);
	}

	void process_command_bytes(byte buf, int index, ei_x_buff result) {
	if (!magic_loaded)
	return error(result, "magic_database_not_loaded");

	int termtype, termsize;
	long bin_length;
	char bytes[51];
	EI_ENSURE(ei_get_type(buf, &index, &termtype, &termsize));

	if (termtype != ERL_BINARY_EXT)
	return error(result, "badarg");

	if (termsize > 50)
	return error(result, "toolong");

	EI_ENSURE(ei_decode_binary(buf, &index, bytes, &bin_length));
	bytes[termsize] = '\0';
	process_bytes(bytes, termsize, result);
	}

	void process_command_load(byte buf, int index, ei_x_buff result) {
	char path[4097];
	int termtype, termsize;
	ei_get_type(buf, &index, &termtype, &termsize);

	if (termtype == ERL_BINARY_EXT) {
	if (termsize > 4096)
	return error(result, "enametoolong");

	long bin_length;
	EI_ENSURE(ei_decode_binary(buf, &index, path, &bin_length));
	path[termsize] = '\0';
	return process_load(result, path);
	}

	if (termtype == ERL_ATOM_EXT) {
	EI_ENSURE(ei_decode_atom(buf, &index, path));
	if (strlen(path) == 7 && strcmp(path, "default") == 0)
	return process_load(result, NULL);
	}

	error(result, "badarg");
	}

	void process_load(ei_x_buff result, char path) {
	if (magic_load_all(path) == 0) {
	EI_ENSURE(ei_x_encode_atom(result, "ok"));
	EI_ENSURE(ei_x_encode_atom(result, "loaded"));
	} else {
	EI_ENSURE(ei_x_encode_atom(result, "error"));
	EI_ENSURE(ei_x_encode_atom(result, "not_loaded"));
	}
	send_and_free(result);
	}

	void setup_environment() { opterr = 0; }

	void magic_close_all() {
	magic_loaded = false;
	if (magic_mime_encoding) {
	magic_close(magic_mime_encoding);
	magic_mime_encoding = NULL;
	}
	if (magic_mime_type) {
	magic_close(magic_mime_type);
	magic_mime_type = NULL;
	}
	if (magic_type_name) {
	magic_close(magic_type_name);
	magic_type_name = NULL;
	}
	}

	void magic_open_all() {
	magic_close_all();
	magic_mime_encoding = magic_open(MAGIC_FLAGS_COMMON \| MAGIC_MIME_ENCODING);
	magic_mime_type = magic_open(MAGIC_FLAGS_COMMON \| MAGIC_MIME_TYPE);
	magic_type_name = magic_open(MAGIC_FLAGS_COMMON \| MAGIC_NONE);

	if (magic_mime_encoding && magic_mime_type && magic_type_name) {
	ei_x_buff ok_buf;
	EI_ENSURE(ei_x_new_with_version(&ok_buf));
	EI_ENSURE(ei_x_encode_atom(&ok_buf, "ready"));
	return send_and_free(&ok_buf);
	}

	exit(ERROR_MAGIC);
	}

	int magic_load_all(char *path) {
	int res;

	if ((res = magic_load(magic_mime_encoding, path)) != 0)
	return res;
	if ((res = magic_load(magic_mime_type, path)) != 0)
	return res;
	if ((res = magic_load(magic_type_name, path)) != 0)
	return res;

	magic_loaded = true;
	return 0;
	}

	void process_bytes(char path, int size, ei_x_buff result) {
	const char *mime_type_result = magic_buffer(magic_mime_type, path, size);
	const int mime_type_errno = magic_errno(magic_mime_type);

	if (mime_type_errno > 0)
	return handle_magic_error(magic_mime_type, mime_type_errno, result);

	const char *mime_encoding_result =
	magic_buffer(magic_mime_encoding, path, size);
	int mime_encoding_errno = magic_errno(magic_mime_encoding);

	if (mime_encoding_errno > 0)
	return handle_magic_error(magic_mime_encoding, mime_encoding_errno, result);

	const char *type_name_result = magic_buffer(magic_type_name, path, size);
	int type_name_errno = magic_errno(magic_type_name);

	if (type_name_errno > 0)
	return handle_magic_error(magic_type_name, type_name_errno, result);

	EI_ENSURE(ei_x_encode_atom(result, "ok"));
	EI_ENSURE(ei_x_encode_tuple_header(result, 3));
	EI_ENSURE(
	ei_x_encode_binary(result, mime_type_result, strlen(mime_type_result)));
	EI_ENSURE(ei_x_encode_binary(result, mime_encoding_result,
	strlen(mime_encoding_result)));
	EI_ENSURE(
	ei_x_encode_binary(result, type_name_result, strlen(type_name_result)));
	send_and_free(result);
	}

	void handle_magic_error(magic_t handle, int errn, ei_x_buff *result) {
	const char *error = magic_error(handle);
	EI_ENSURE(ei_x_encode_atom(result, "error"));
	EI_ENSURE(ei_x_encode_tuple_header(result, 2));
	long errlon = (long)errn;
	EI_ENSURE(ei_x_encode_long(result, errlon));
	EI_ENSURE(ei_x_encode_binary(result, error, strlen(error)));
	send_and_free(result);
	}

	void process_file(char path, ei_x_buff result) {
	const char *mime_type_result = magic_file(magic_mime_type, path);
	const int mime_type_errno = magic_errno(magic_mime_type);

	if (mime_type_errno > 0)
	return handle_magic_error(magic_mime_type, mime_type_errno, result);

	const char *mime_encoding_result = magic_file(magic_mime_encoding, path);
	int mime_encoding_errno = magic_errno(magic_mime_encoding);

	if (mime_encoding_errno > 0)
	return handle_magic_error(magic_mime_encoding, mime_encoding_errno, result);

	const char *type_name_result = magic_file(magic_type_name, path);
	int type_name_errno = magic_errno(magic_type_name);

	if (type_name_errno > 0)
	return handle_magic_error(magic_type_name, type_name_errno, result);

	EI_ENSURE(ei_x_encode_atom(result, "ok"));
	EI_ENSURE(ei_x_encode_tuple_header(result, 3));
	EI_ENSURE(
	ei_x_encode_binary(result, mime_type_result, strlen(mime_type_result)));
	EI_ENSURE(ei_x_encode_binary(result, mime_encoding_result,
	strlen(mime_encoding_result)));
	EI_ENSURE(
	ei_x_encode_binary(result, type_name_result, strlen(type_name_result)));
	send_and_free(result);
	}

	// Adapted from https://erlang.org/doc/tutorial/erl_interface.html
	// Changed `read_cmd`, the original one was buggy given some length (due to
	// endinaness).
	// TODO: Check if `write_cmd` exhibits the same issue.
	size_t read_exact(byte *buf, size_t len) {
	int i;
	size_t got = 0;

	do {
	if ((i = read(0, buf + got, len - got)) <= 0) {
	return (i);
	}
	got += i;
	} while (got < len);

	return (len);
	}

	size_t write_exact(byte *buf, size_t len) {
	int i;
	size_t wrote = 0;

	do {
	if ((i = write(1, buf + wrote, len - wrote)) <= 0)
	return (i);
	wrote += i;
	} while (wrote < len);

	return (len);
	}

	size_t read_cmd(byte *buf) {
	int i;
	if ((i = read(0, buf, sizeof(uint16_t))) <= 0) {
	return (i);
	}
	uint16_t len16 = (uint16_t )buf;
	len16 = ntohs(len16);

	// Buffer isn't large enough: just return possible len, without reading.
	// Up to the caller of verifying the size again and return an error.
	// buf left unchanged, stdin emptied of X bytes.
	if (len16 > COMMAND_LEN) {
	fdseek(len16);
	return len16;
	}

	return read_exact(buf, len16);
	}

	size_t write_cmd(byte *buf, size_t len) {
	byte li;

	li = (len >> 8) & 0xff;
	write_exact(&li, 1);

	li = len & 0xff;
	write_exact(&li, 1);

	return write_exact(buf, len);
	}

	void send_and_free(ei_x_buff *result) {
	write_cmd(result->buff, result->index);
	EI_ENSURE(ei_x_free(result));
	}

	void error(ei_x_buff result, const char error) {
	EI_ENSURE(ei_x_encode_atom(result, "error"));
	EI_ENSURE(ei_x_encode_atom(result, error));
	send_and_free(result);
	}

	void fdseek(uint16_t count) {
	int i = 0;
	while (i < count) {
	getchar();
	i += 1;
	}
	}
	diff --git a/test/majic/majic_test.exs b/test/majic/majic_test.exs
	index 9beadcb..ba6a9f2 100644
	--- a/test/majic/majic_test.exs
	+++ b/test/majic/majic_test.exs
	@@ -1,81 +1,97 @@
	defmodule MajicTest do
	use Majic.MagicCase
	alias Majic.Result

	doctest Majic
	@iterations 100

	test "Makefile is text file" do
	{:ok, pid} = Majic.Server.start_link([])
	path = absolute_path("Makefile")
	assert {:ok, %{mime_type: "text/x-makefile"}} = Majic.Server.perform(pid, path)
	end

	test "With Majic.perform" do
	{:ok, pid} = Majic.Server.start_link([])
	path = absolute_path("Makefile")
	assert {:ok, %{mime_type: "text/x-makefile"}} = Majic.perform(path, server: pid)
	end

	@tag external: true
	test "Load test local files" do
	{:ok, pid} = Majic.Server.start_link([])

	files_stream()
	\|> Stream.cycle()
	\|> Stream.take(@iterations)
	\|> Stream.map(&assert {:ok, %Result{}} = Majic.Server.perform(pid, &1))
	\|> Enum.all?()
	\|> assert
	end

	test "Non-existent file" do
	{:ok, pid} = Majic.Server.start_link([])
	path = missing_filename()
	assert_no_file(Majic.Server.perform(pid, path))
	end

	test "Bytes" do
	{:ok, pid} = Majic.Server.start_link([])
	bytes = File.read!("test/fixtures/cat.webp")
	assert {:ok, _} = Majic.Server.perform(pid, {:bytes, bytes})
	end

	test "Named process" do
	{:ok, pid} = Majic.Server.start_link(name: :gen_magic)
	path = absolute_path("Makefile")
	assert {:ok, %{cycles: 0}} = Majic.Server.status(:gen_magic)
	assert {:ok, %{cycles: 0}} = Majic.Server.status(pid)
	assert {:ok, %Result{} = result} = Majic.Server.perform(:gen_magic, path)
	assert {:ok, %{cycles: 1}} = Majic.Server.status(:gen_magic)
	assert {:ok, %{cycles: 1}} = Majic.Server.status(pid)
	assert "text/x-makefile" = result.mime_type
	end

	describe "custom database" do
	setup do
	- database = absolute_path("elixir.mgc")
	+ database = compile_magic_db(absolute_path("test/elixir"))
	on_exit(fn -> File.rm(database) end)
	- {_, 0} = System.cmd("file", ["-C", "-m", absolute_path("test/elixir")])
	[database: database]
	end

	+ defp compile_magic_db(source) do
	+ target = Path.join(Path.dirname(source), Path.basename(source, Path.extname(source)) <> ".mgc")
	+ file_cmd = find_file_cmd()
	+
	+ case System.cmd(file_cmd, ["-C", "-m", source], cd: Path.dirname(source), stderr_to_stdout: true) do
	+ {_, 0} -> :ok
	+ {output, _} -> raise "file -C failed: #{output}"
	+ end
	+
	+ target
	+ end
	+
	+ defp find_file_cmd do
	+ candidates = ["/opt/homebrew/opt/file-formula/bin/file", "/usr/local/opt/file-formula/bin/file", "file"]
	+ Enum.find(candidates, &File.exists?/1) \|\| "file"
	+ end
	+
	test "recognises Elixir files", %{database: database} do
	{:ok, pid} = Majic.Server.start_link(database_patterns: [database])
	path = absolute_path("mix.exs")
	assert {:ok, %Result{} = result} = Majic.Server.perform(pid, path)
	assert "text/x-elixir" = result.mime_type
	assert "us-ascii" = result.encoding
	assert "Elixir module source text" = result.content
	end

	test "recognises Elixir files after a reload", %{database: database} do
	{:ok, pid} = Majic.Server.start_link([])
	path = absolute_path("mix.exs")
	{:ok, %Result{mime_type: mime}} = Majic.Server.perform(pid, path)
	refute mime == "text/x-elixir"
	:ok = Majic.Server.reload(pid, [database])
	assert {:ok, %Result{mime_type: "text/x-elixir"}} = Majic.Server.perform(pid, path)
	end
	end
	end
	diff --git a/test/majic/port_test.exs b/test/majic/port_test.exs
	index 8f95c6e..eb9e018 100644
	--- a/test/majic/port_test.exs
	+++ b/test/majic/port_test.exs
	@@ -1,204 +1,204 @@
	defmodule Majic.PortTest do
	use Majic.MagicCase

	@tmp_path "/tmp/testgenmagicx"
	require Logger

	test "sends ready" do
	port = Port.open(Majic.Config.get_port_name(), Majic.Config.get_port_options([]))
	on_exit(fn -> send(port, {self(), :close}) end)
	assert_ready(port)
	end

	test "errors with non existent database with an error" do
	opts = [:use_stdio, :binary, :exit_status, {:packet, 2}, {:args, []}]
	port = Port.open(Majic.Config.get_port_name(), opts)
	on_exit(fn -> send(port, {self(), :close}) end)
	assert_ready(port)

	send(
	port,
	{self(), {:command, :erlang.term_to_binary({:add_database, "/somewhere/nowhere"})}}
	)

	assert_receive {^port, {:data, data}}
	assert {:error, :not_loaded} == :erlang.binary_to_term(data)
	end

	test "loads default database" do
	opts = [:use_stdio, :binary, :exit_status, {:packet, 2}, {:args, []}]
	port = Port.open(Majic.Config.get_port_name(), opts)
	on_exit(fn -> send(port, {self(), :close}) end)
	assert_ready(port)

	send(
	port,
	{self(), {:command, :erlang.term_to_binary({:add_database, :default})}}
	)

	assert_receive {^port, {:data, data}}
	assert {:ok, :loaded} == :erlang.binary_to_term(data)
	end

	test "reloads" do
	opts = [:use_stdio, :binary, :exit_status, {:packet, 2}, {:args, []}]
	port = Port.open(Majic.Config.get_port_name(), opts)
	on_exit(fn -> send(port, {self(), :close}) end)
	assert_ready_and_init_default(port)

	send(port, {self(), {:command, :erlang.term_to_binary({:reload, :reload})}})

	assert_ready(port)
	end

	test "errors when no database loaded" do
	opts = [:use_stdio, :binary, :exit_status, {:packet, 2}, {:args, []}]
	port = Port.open(Majic.Config.get_port_name(), opts)
	on_exit(fn -> send(port, {self(), :close}) end)
	assert_ready(port)

	send(port, {self(), {:command, :erlang.term_to_binary({:bytes, "hello world"})}})
	assert_receive {^port, {:data, data}}
	assert {:error, :magic_database_not_loaded} = :erlang.binary_to_term(data)
	refute_receive _
	end

	test "stops" do
	port = Port.open(Majic.Config.get_port_name(), Majic.Config.get_port_options([]))
	on_exit(fn -> send(port, {self(), :close}) end)
	assert_ready_and_init_default(port)
	send(port, {self(), {:command, :erlang.term_to_binary({:stop, :stop})}})
	assert_receive {^port, {:exit_status, 0}}
	end

	describe "port" do
	setup do
	port = Port.open(Majic.Config.get_port_name(), Majic.Config.get_port_options([]))
	on_exit(fn -> send(port, {self(), :close}) end)
	assert_ready_and_init_default(port)
	%{port: port}
	end

	test "exits with badly formatted erlang terms", %{port: port} do
	send(port, {self(), {:command, "i forgot to term_to_binary!!"}})
	assert_receive {^port, {:exit_status, 3}}
	end

	test "errors with wrong command", %{port: port} do
	send(port, {self(), {:command, :erlang.term_to_binary(:wrong)}})
	assert_receive {^port, {:data, data}}
	assert {:error, :badarg} = :erlang.binary_to_term(data)
	refute_receive _

	send(port, {self(), {:command, :erlang.term_to_binary({:file, 42})}})
	assert_receive {^port, {:data, data}}
	assert {:error, :badarg} = :erlang.binary_to_term(data)
	refute_receive _

	send(port, {self(), {:command, :erlang.term_to_binary("more wrong")}})
	assert_receive {^port, {:data, data}}
	assert {:error, :badarg} = :erlang.binary_to_term(data)
	refute_receive _

	send(port, {self(), {:command, :erlang.term_to_binary({"no", "no"})}})
	assert_receive {^port, {:data, data}}
	assert {:error, :badarg} = :erlang.binary_to_term(data)
	refute_receive _
	end

	test "file works", %{port: port} do
	send(port, {self(), {:command, :erlang.term_to_binary({:file, Path.expand("Makefile")})}})
	assert_receive {^port, {:data, data}}
	assert {:ok, _} = :erlang.binary_to_term(data)
	end

	test "bytes works", %{port: port} do
	send(port, {self(), {:command, :erlang.term_to_binary({:bytes, "some bytes!"})}})
	assert_receive {^port, {:data, data}}
	assert {:ok, _} = :erlang.binary_to_term(data)
	end

	test "fails with non existent file", %{port: port} do
	send(port, {self(), {:command, :erlang.term_to_binary({:file, "/path/to/nowhere"})}})
	assert_receive {^port, {:data, data}}
	assert {:error, _} = :erlang.binary_to_term(data)
	end

	test "works with big file path", %{port: port} do
	# Test with longest valid path.
	{dir, bigfile} = too_big(@tmp_path, "/a")

	case File.mkdir_p(dir) do
	:ok ->
	File.touch!(bigfile)
	on_exit(fn -> File.rm_rf!(@tmp_path) end)
	send(port, {self(), {:command, :erlang.term_to_binary({:file, bigfile})}})
	assert_receive {^port, {:data, data}}
	assert {:ok, _} = :erlang.binary_to_term(data)
	refute_receive _

	# This path should be long enough for buffers, but larger than a valid path name.
	# Magic will return an errno 36.
	file = @tmp_path <> String.duplicate("a", 256)
	send(port, {self(), {:command, :erlang.term_to_binary({:file, file})}})
	assert_receive {^port, {:data, data}}
	assert {:error, {36, _}} = :erlang.binary_to_term(data)
	refute_receive _
	# Theses filename should be too big for the path buffer.
	file = bigfile <> "aaaaaaaaaa"
	send(port, {self(), {:command, :erlang.term_to_binary({:file, file})}})
	assert_receive {^port, {:data, data}}
	assert {:error, :enametoolong} = :erlang.binary_to_term(data)
	refute_receive _
	# This call should be larger than the COMMAND_BUFFER_SIZE. Ensure nothing bad happens!
	file = String.duplicate(bigfile, 4)
	send(port, {self(), {:command, :erlang.term_to_binary({:file, file})}})
	assert_receive {^port, {:data, data}}
	assert {:error, :badarg} = :erlang.binary_to_term(data)
	refute_receive _
	# We re-run a valid call to ensure the buffer/... haven't been corrupted in port land.
	send(port, {self(), {:command, :erlang.term_to_binary({:file, bigfile})}})
	assert_receive {^port, {:data, data}}
	assert {:ok, _} = :erlang.binary_to_term(data)
	refute_receive _

	{:error, :enametoolong} ->
	Logger.info(
	"Skipping test, operating system does not support max POSIX length for directories"
	)

	:ignore
	end
	end
	end

	def assert_ready(port) do
	- assert_receive {^port, {:data, data}}
	+ assert_receive {^port, {:data, data}}, 5000
	assert :ready == :erlang.binary_to_term(data)
	end

	def assert_ready_and_init_default(port) do
	- assert_receive {^port, {:data, data}}
	+ assert_receive {^port, {:data, data}}, 5000
	assert :ready == :erlang.binary_to_term(data)
	send(port, {self(), {:command, :erlang.term_to_binary({:add_database, :default})}})
	- assert_receive {^port, {:data, data}}
	+ assert_receive {^port, {:data, data}}, 5000
	assert {:ok, _} = :erlang.binary_to_term(data)
	end

	def too_big(path, filename, limit \\ 4095) do
	last_len = byte_size(filename)
	path_len = byte_size(path)
	needed = limit - (last_len + path_len)
	extra = make_too_big(needed, "")
	{path <> extra, path <> extra <> filename}
	end

	def make_too_big(needed, acc) when needed <= 255 do
	acc <> "/" <> String.duplicate("a", needed - 1)
	end

	def make_too_big(needed, acc) do
	acc = acc <> "/" <> String.duplicate("a", 254)
	make_too_big(needed - 255, acc)
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Aug 9, 9:55 AM (1 d, 17 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1722885
Default Alt Text: (25 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions