// SPDX-License-Identifier: LGPL-2.0-only
// SPDX-FileCopyrightText: 2023 Oleksij Rempel <linux@rempel-privat.de>

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <time.h>
#include <unistd.h>

#include "isobusfs_srv.h"
#include "isobusfs_cmn_fa.h"

static struct isobusfs_srv_handles *
isobusfs_srv_walk_handles(struct isobusfs_srv_priv *priv, const char *path)
{
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(priv->handles); i++) {
		if (priv->handles[i].path == NULL)
			continue;

		if (!strcmp(priv->handles[i].path, path))
			return &priv->handles[i];
	}

	return NULL;
}

static int isobusfs_srv_add_file(struct isobusfs_srv_priv *priv,
				 const char *path, int fd, DIR *dir)
{
	unsigned int j;

	if (priv->handles_count >= (int)ARRAY_SIZE(priv->handles)) {
		pr_err("too many handles");
		return -ENOSPC;
	}

	for (j = 0; j < ARRAY_SIZE(priv->handles); j++) {
		if (priv->handles[j].path == NULL)
			break;
	}

	priv->handles[j].path = strdup(path);
	priv->handles[j].fd = fd;
	priv->handles[j].dir = dir;

	priv->handles_count++;
	return j;
}

static int isobusfs_srv_add_client_to_file(struct isobusfs_srv_handles *file,
					   struct isobusfs_srv_client *client)
{
	unsigned int j;

	for (j = 0; j < ARRAY_SIZE(file->clients); j++) {
		if (file->clients[j] == client)
			return 0;
	}

	for (j = 0; j < ARRAY_SIZE(file->clients); j++) {
		if (file->clients[j] == NULL) {
			file->clients[j] = client;
			file->refcount++;
			return 0;
		}
	}

	pr_err("%s: can't add client to file", __func__);
	return -ENOENT;
}

static int isobusfs_srv_request_file(struct isobusfs_srv_priv *priv,
				     struct isobusfs_srv_client *client,
				     const char *path, int fd, DIR *dir)
{
	struct isobusfs_srv_handles *file;
	int handle, ret;

	file = isobusfs_srv_walk_handles(priv, path);
	if (!file) {
		handle = isobusfs_srv_add_file(priv, path, fd, dir);
		if (handle < 0)
			return handle;

		file = &priv->handles[handle];
	} else {
		handle = file - priv->handles;
	}

	ret = isobusfs_srv_add_client_to_file(file, client);
	if (ret < 0)
		return ret;

	return handle;
}

static struct isobusfs_srv_handles *
isobusfs_srv_get_handle(struct isobusfs_srv_priv *priv, int handle)
{
	if (handle < 0 || handle >= (int)ARRAY_SIZE(priv->handles))
		return NULL;

	return &priv->handles[handle];
}

static int isobusfs_srv_release_handle(struct isobusfs_srv_priv *priv,
				       struct isobusfs_srv_client *client,
				       int handle)
{
	struct isobusfs_srv_handles *hdl = isobusfs_srv_get_handle(priv, handle);
	unsigned int client_index;

	if (!hdl) {
		pr_warn("%s: invalid handle %d", __func__, handle);
		return -ENOENT;
	}

	/* Find the client in the hdl's client list and remove it */
	for (client_index = 0; client_index < ARRAY_SIZE(hdl->clients); client_index++) {
		if (hdl->clients[client_index] == client) {
			hdl->clients[client_index] = NULL;
			hdl->refcount--;

			pr_debug("%s: client %p removed from handle %d", __func__, client, handle);
			/* If refcount is 0, close the hdl and remove it from the list */
			if (hdl->refcount == 0) {
				pr_debug("%s: closing handle %d", __func__, handle);
				/* fd will be automatically closed when
				 * closedir(3) is called.
				 */
				if (hdl->dir)
					closedir(hdl->dir);
				else
					close(hdl->fd);
				memset(hdl, 0, sizeof(*hdl));
				priv->handles_count--;
			}

			return 0;
		}
	}

	pr_err("%s: client %p not found in handle %d", __func__, client, handle);
	return -ENOENT;
}

void isobusfs_srv_remove_client_from_handles(struct isobusfs_srv_priv *priv,
					   struct isobusfs_srv_client *client)
{
	unsigned int handle;
	unsigned int client_index;

	for (handle = 0; handle < ARRAY_SIZE(priv->handles); handle++) {
		struct isobusfs_srv_handles *hdl = &priv->handles[handle];

		if (hdl->path == NULL)
			continue;

		for (client_index = 0; client_index < ARRAY_SIZE(hdl->clients); client_index++) {
			if (hdl->clients[client_index] == client) {
				hdl->clients[client_index] = NULL;
				hdl->refcount--;

				if (hdl->refcount == 0) {
					close(hdl->fd);
					memset(hdl, 0, sizeof(*hdl));
					priv->handles_count--;
				}

				break;
			}
		}
	}
}

static int isobusfs_srv_fa_open_directory(struct isobusfs_srv_priv *priv,
					  struct isobusfs_srv_client *client,
					  const char *path, size_t path_len,
					  uint8_t *handle)
{
	char linux_path[ISOBUSFS_SRV_MAX_PATH_LEN];
	struct isobusfs_srv_handles *hdl;
	struct stat file_stat;
	int file_index, fd;
	DIR *dir;
	int ret;

	ret = isobusfs_path_to_linux_path(priv, path, path_len, linux_path, sizeof(linux_path));
	if (ret < 0)
		return ret;

	hdl = isobusfs_srv_walk_handles(priv, linux_path);
	if (hdl) {
		pr_err("%s: Path %s is already opened\n", __func__, linux_path);
		return ISOBUSFS_ERR_OTHER;
	}

	dir = opendir(linux_path);
	if (!dir) {
		pr_err("%s: Error opening directory %s. Error %d (%s)\n",
		       __func__, linux_path, errno, strerror(errno));
		switch (errno) {
		case EACCES:
			return ISOBUSFS_ERR_ACCESS_DENIED;
		case ENOENT:
			return ISOBUSFS_ERR_FILE_ORPATH_NOT_FOUND;
		case ENOMEM:
			return ISOBUSFS_ERR_OUT_OF_MEM;
		default:
			return ISOBUSFS_ERR_OTHER;
		}
	}

	fd = dirfd(dir);
	if (fd < 0) {
		pr_err("%s: Error getting file descriptor for directory %s. Error %d (%s)\n",
		       __func__, linux_path, errno, strerror(errno));
		closedir(dir);
		return ISOBUSFS_ERR_OTHER;
	}

	if (fstat(fd, &file_stat) < 0 || !S_ISDIR(file_stat.st_mode)) {
		pr_err("%s: Path %s is not a directory\n", __func__,
		       linux_path);
		closedir(dir);
		return ISOBUSFS_ERR_INVALID_ACCESS;
	}

	file_index = isobusfs_srv_request_file(priv, client, linux_path, fd,
					       dir);
	if (file_index < 0) {
		closedir(dir);
		return file_index;
	}

	*handle = (uint8_t)file_index;

	return 0;
}

static int isobusfs_srv_fa_open_file(struct isobusfs_srv_priv *priv,
				     struct isobusfs_srv_client *client,
				     const char *path, size_t path_len,
				     uint8_t flags, uint8_t *handle)
{
	char linux_path[ISOBUSFS_SRV_MAX_PATH_LEN];
	struct isobusfs_srv_handles *hdl;
	struct stat file_stat;
	int open_flags = 0;
	int file_index;
	int ret, fd;

	ret = isobusfs_path_to_linux_path(priv, path, path_len,
					  linux_path, sizeof(linux_path));
	if (ret < 0)
		return ret;

	pr_debug("convert ISOBUS FS path to linux path: %.*s -> %s",
		 path_len, path, linux_path);

	/* Determine open flags based on the requested access type */
	switch (flags & ISOBUSFS_FA_OPEN_MASK) {
	case ISOBUSFS_FA_OPEN_FILE_RO:
		open_flags |= O_RDONLY;
		break;
	case ISOBUSFS_FA_OPEN_FILE_WO:
		open_flags |= O_WRONLY;
		break;
	case ISOBUSFS_FA_OPEN_FILE_WR:
		open_flags |= O_RDWR;
		if (!(flags & ISOBUSFS_FA_OPEN_APPEND))
			open_flags |= O_TRUNC;
		break;
	default:
		return ISOBUSFS_ERR_INVALID_ACCESS;
	}

	if (flags & ISOBUSFS_FA_OPEN_APPEND)
		open_flags |= O_APPEND;

	/* Check if the file is already opened */
	hdl = isobusfs_srv_walk_handles(priv, linux_path);
	if (hdl) {
		pr_warn("Handle: %s is already opened by client: %x\n",
			linux_path, client->addr);
		fd = hdl->fd;
	} else {
		/* Open the file if not already opened */
		fd = open(linux_path, open_flags);
		if (fd < 0) {
			switch (errno) {
			case EACCES:
				return ISOBUSFS_ERR_ACCESS_DENIED;
			case EINVAL:
				return ISOBUSFS_ERR_INVALID_ACCESS;
			case EMFILE:
			case ENFILE:
				return ISOBUSFS_ERR_TOO_MANY_FILES_OPEN;
			case ENOENT:
				return ISOBUSFS_ERR_FILE_ORPATH_NOT_FOUND;
			case ENOMEM:
				return ISOBUSFS_ERR_OUT_OF_MEM;
			default:
				return ISOBUSFS_ERR_OTHER;
			}
		}
		/* Check if the opened path is a regular file */
		if (fstat(fd, &file_stat) < 0) {
			close(fd);
			return ISOBUSFS_ERR_OTHER;
		}

		if (!S_ISREG(file_stat.st_mode)) {
			close(fd);
			/* Invalid access (not a regular file) */
			return ISOBUSFS_ERR_INVALID_ACCESS;
		}
	}

	/* Request the file, which also handles refcount and client list 
	 * updates
	 */
	file_index = isobusfs_srv_request_file(priv, client, linux_path, fd,
					       NULL);
	if (file_index < 0) {
		close(fd);
		return file_index;
	}

	*handle = (uint8_t)file_index;

	return 0;
}

static int isobusfs_srv_fa_open_file_req(struct isobusfs_srv_priv *priv,
					 struct isobusfs_msg *msg)
{
	struct isobusfs_fa_openf_req *req =
		(struct isobusfs_fa_openf_req *)msg->buf;
	uint16_t name_len = le16toh(req->name_len);
	struct isobusfs_srv_client *client;
	struct isobusfs_fa_openf_res res;
	uint8_t error_code = 0;
	uint8_t access_type;
	size_t abs_path_len;
	uint8_t handle = 0;
	char *abs_path;
	int ret = 0;

	client = isobusfs_srv_get_client_by_msg(priv, msg);
	if (!client) {
		pr_warn("client not found");
		error_code = ISOBUSFS_ERR_OTHER;
		goto send_response;
	}

	if (name_len > msg->len - sizeof(*req)) {
		error_code = ISOBUSFS_ERR_INVALID_ACCESS;
		goto send_response;
	}

	/* Perform checks on the received request, e.g., validate path length */
	if (name_len > ISOBUSFS_MAX_PATH_NAME_LENGTH) {
		error_code = ISOBUSFS_ERR_INVALID_ACCESS;
		goto send_response;
	}

	abs_path_len = ISOBUSFS_SRV_MAX_PATH_LEN;
	abs_path = malloc(abs_path_len);
	if (!abs_path) {
		pr_warn("failed to allocate memory");
		return -ENOMEM;
	}

	if (client->current_dir[0] == '\0')
		isobusfs_srv_set_default_current_dir(priv, client);

	/* Normalize provided string and convert it to absolute ISOBUS FS path */
	ret = isobusfs_convert_relative_to_absolute(priv, client->current_dir,
						    (char *)req->name, req->name_len,
						    abs_path, abs_path_len);
	if (ret < 0) {
		error_code = ISOBUSFS_ERR_FILE_ORPATH_NOT_FOUND;
		goto send_response;
	}

	pr_debug("< rx: Open File Request. from client 0x%2x: %.*s. Current directory: %s",
		 client->addr, req->name_len, req->name, client->current_dir);

	access_type = FIELD_GET(ISOBUSFS_FA_OPEN_MASK, req->flags);
	if (access_type == ISOBUSFS_FA_OPEN_DIR) {
		error_code = isobusfs_srv_fa_open_directory(priv, client, abs_path,
							    abs_path_len, &handle);
	} else {
		error_code = isobusfs_srv_fa_open_file(priv, client, abs_path,
						       abs_path_len, req->flags,
						       &handle);
	}

send_response:
	res.fs_function =
		isobusfs_cg_function_to_buf(ISOBUSFS_CG_FILE_ACCESS,
					    ISOBUSFS_FA_F_OPEN_FILE_RES);
	res.tan = req->tan;
	res.error_code = error_code;
	res.handle = handle;
	memset(&res.reserved[0], 0xff, sizeof(res.reserved));

	/* send to socket */
	ret = isobusfs_srv_sendto(priv, msg, &res, sizeof(res));
	if (ret < 0) {
		pr_warn("can't send current directory response");
		goto err;
	}

	pr_debug("> tx: Open File Response. Error code: %d (%s).", error_code,
		 isobusfs_error_to_str(error_code));
err:

	return ret;
}

static int isobusfs_srv_read_file(struct isobusfs_srv_handles *handle,
				  uint8_t *buffer, size_t count,
				  ssize_t *readed_size)
{
	*readed_size = read(handle->fd, buffer, count);
	if (*readed_size < 0) {
		switch (errno) {
		case EBADF:
			return ISOBUSFS_ERR_INVALID_HANDLE;
		case EFAULT:
			return ISOBUSFS_ERR_OUT_OF_MEM;
		case EIO:
			return ISOBUSFS_ERR_ON_READ;
		default:
			return ISOBUSFS_ERR_OTHER;
		}
	}

	return 0;
}

static uint16_t convert_to_file_date(time_t time_val)
{
	struct tm *timeinfo = localtime(&time_val);
	int year, month, day;

	if (!timeinfo)
		return 0;

	year = timeinfo->tm_year + 1900 - 1980;
	month = timeinfo->tm_mon + 1;
	day = timeinfo->tm_mday;

	if (year < 0 || year > 127)
		return 0;

	return (year << 9) | (month << 5) | day;
}

static uint16_t convert_to_file_time(time_t time_val)
{
	struct tm *timeinfo = localtime(&time_val);
	int hours, minutes, seconds;
	uint16_t time;

	if (!timeinfo)
		return 0;

	hours = timeinfo->tm_hour;
	minutes = timeinfo->tm_min;
	seconds = timeinfo->tm_sec / 2;

	time = (hours << 11) | (minutes << 5) | seconds;

	return time;
}

static int check_access_with_base(const char *base_dir,
				  const char *relative_path, int mode)
{
	char full_path[ISOBUSFS_SRV_MAX_PATH_LEN];

	if (snprintf(full_path, sizeof(full_path), "%s/%s", base_dir,
		     relative_path) >= (int)sizeof(full_path)) {
		return -ENAMETOOLONG;
	}

	return access(full_path, mode);
}

static int isobusfs_srv_read_directory(struct isobusfs_srv_handles *handle,
				       uint8_t *buffer, size_t count,
				       ssize_t *readed_size)
{
	DIR *dir = handle->dir;
	struct dirent *entry;
	size_t pos = 0;

	/*
	 * Position the directory stream to the previously stored offset (handle->dir_pos).
	 *
	 * Handling Changes in Directory Contents:
	 * - If the directory contents change between reads (e.g., files/directories added or deleted),
	 *   handle->dir_pos may not point to the expected entry.
	 * - To ensure consistency, implement checks (e.g., compare inode numbers) to verify the correct
	 *   entry position.
	 *
	 * Detecting End of Directory:
	 * - If readdir() returns NULL before reaching handle->dir_pos, it indicates the end of the
	 *   directory with no more entries to read.
	 * - This situation should be handled appropriately, such as by resetting handle->dir_pos and
	 *   either returning an error or restarting from the beginning of the directory, depending
	 *   on the application's requirements.
	 */
	for (int i = 0; i < handle->dir_pos &&
	     (entry = readdir(dir)) != NULL; i++) {
		/* Iterating to the desired position */
	}

	/*
	 * Directory Entry Layout:
	 * This loop reads directory entries and encodes them into a buffer.
	 * Each entry in the buffer follows the format specified in ISO 11783-13:2021.
	 *
	 * The layout of each directory entry in the buffer is as follows:
	 * - Byte 1: Filename Length (as per ISO 11783-13:2021 B.22).
	 *   Represents the length of the filename that follows.
	 *
	 * - Byte 2–n: Filename (as per ISO 11783-13:2021 B.23).
	 *   The actual name of the file or directory.
	 *
	 * - Byte n + 1: Attributes (as per ISO 11783-13:2021 B.15).
	 *
	 * - Bytes n + 2, n + 3: File Date (as per ISO 11783-13:2021 B.24).
	 *   Encoded file date, using a 16-bit format derived from file_stat.st_mtime.
	 *
	 * - Bytes n + 4, n + 5: File Time (as per ISO 11783-13:2021 B.25).
	 *   Encoded file time, using a 16-bit format derived from file_stat.st_mtime.
	 *
	 * - Bytes n + 6 … n + 9: Size (as per ISO 11783-13:2021 B.26).
	 *   The size of the file in bytes, encoded in a 32-bit little-endian format.
	 *
	 * The handle->dir_pos is incremented after processing each entry, marking
	 * the current position in the directory stream for subsequent reads.
	 */
	while ((entry = readdir(dir)) != NULL) {
		size_t entry_name_len, entry_total_len;
		__le16 file_date, file_time;
		uint8_t attributes = 0;
		struct stat file_stat;
		__le32 size;

		if (check_access_with_base(handle->path, entry->d_name, R_OK) != 0)
			continue; /* Skip this entry if it's not readable */

		if (fstatat(handle->fd, entry->d_name, &file_stat, 0) < 0)
			continue; /* Skip this entry on error */

		entry_name_len = strlen(entry->d_name);
		if (entry_name_len > ISOBUSFS_MAX_DIR_ENTRY_NAME_LENGTH)
			continue;

		entry_total_len = 1 + entry_name_len + 1 + 2 + 2 + 4;

		if (pos + entry_total_len > count)
			break;

		buffer[pos++] = (uint8_t)entry_name_len;

		memcpy(buffer + pos, entry->d_name, entry_name_len);
		pos += entry_name_len;

		if (S_ISDIR(file_stat.st_mode))
			attributes |= ISOBUSFS_ATTR_DIRECTORY;
		if (check_access_with_base(handle->path, entry->d_name, W_OK) != 0)
			attributes |= ISOBUSFS_ATTR_READ_ONLY;
		buffer[pos++] = attributes;

		file_date = htole16(convert_to_file_date(file_stat.st_mtime));
		memcpy(buffer + pos, &file_date, sizeof(file_date));
		pos += sizeof(file_date);

		file_time = htole16(convert_to_file_time(file_stat.st_mtime));
		memcpy(buffer + pos, &file_time, sizeof(file_time));
		pos += sizeof(file_time);

		size = htole32(file_stat.st_size);
		memcpy(buffer + pos, &size, sizeof(size));
		pos += sizeof(size);
	}

	*readed_size = pos;
	return 0;
}

static int isobusfs_srv_fa_rf_req(struct isobusfs_srv_priv *priv,
				  struct isobusfs_msg *msg)
{
	uint8_t res_fail[8] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
	struct isobusfs_read_file_response *res;
	struct isobusfs_srv_handles *handle;
	struct isobusfs_srv_client *client;
	struct isobusfs_fa_readf_req *req;
	ssize_t readed_size = 0;
	uint8_t error_code = 0;
	ssize_t send_size;
	int ret = 0;
	int count;

	req = (struct isobusfs_fa_readf_req *)msg->buf;
	count = le16toh(req->count);

	pr_debug("< rx: Read File Request. tan: %d, handle: %d, count: %d",
		 req->tan, req->handle, count);
	/* C.3.5.1 Read File, General:
	 * The requested data (excluding the other parameters) is sent in
	 * the response (up to 1 780 bytes when TP is used, up to 65 530 bytes
	 * when ETP is used). The number of data bytes read can be less than
	 * requested if the end of the file is reached.
	 * TODO: currently we are not able to detect support transport mode,
	 * so ETP is assumed.
	 */
	if (count > ISOBUSFS_MAX_DATA_LENGH)
		count = ISOBUSFS_MAX_DATA_LENGH;

	res = malloc(sizeof(*res) + count);
	if (!res) {
		pr_warn("failed to allocate memory");
		res = (struct isobusfs_read_file_response *)&res_fail[0];
		error_code = ISOBUSFS_ERR_OUT_OF_MEM;
		goto send_response;
	}

	client = isobusfs_srv_get_client_by_msg(priv, msg);
	if (!client) {
		pr_warn("client not found");
		error_code = ISOBUSFS_ERR_OTHER;
		goto send_response;
	}

	handle = isobusfs_srv_get_handle(priv, req->handle);
	if (!handle) {
		pr_warn("failed to find file with handle: %x", req->handle);
		error_code = ISOBUSFS_ERR_FILE_ORPATH_NOT_FOUND;
	}

	/* Determine whether to read a file or a directory */
	if (handle->dir) {
		ret = isobusfs_srv_read_directory(handle, res->data, count,
						  &readed_size);
	} else {
		ret = isobusfs_srv_read_file(handle, res->data, count,
					     &readed_size);
	}

	if (ret < 0) {
		error_code = ret;
		readed_size = 0;
	} else if (count != 0 && readed_size == 0) {
		error_code = ISOBUSFS_ERR_END_OF_FILE;
	}

send_response:
	res->fs_function =
		isobusfs_cg_function_to_buf(ISOBUSFS_CG_FILE_ACCESS,
					    ISOBUSFS_FA_F_READ_FILE_RES);
	res->tan = req->tan;
	res->error_code = error_code;
	res->count = htole16(readed_size);

	send_size = sizeof(*res) + readed_size;
	if (send_size < ISOBUSFS_MIN_TRANSFER_LENGH)
		send_size = ISOBUSFS_MIN_TRANSFER_LENGH;

	/* send to socket */
	ret = isobusfs_srv_sendto(priv, msg, res, send_size);
	if (ret < 0) {
		pr_warn("can't send Read File Response");
		goto free_res;
	}

	pr_debug("> tx: Read File Response. Error code: %d (%s), readed size: %d",
		 error_code, isobusfs_error_to_str(error_code), readed_size);

free_res:
	free(res);
	return ret;
}

static int isobusfs_srv_seek(struct isobusfs_srv_priv *priv,
			     struct isobusfs_srv_handles *handle, int32_t offset,
			     uint8_t position_mode)
{
	int whence;
	off_t offs;

	switch (position_mode) {
	case ISOBUSFS_FA_SEEK_SET:
		whence = SEEK_SET;
		if (offset < 0) {
			pr_warn("Invalid offset. Offset must be positive.");
			return ISOBUSFS_ERR_INVALID_REQUESTED_LENGHT;
		}
		break;
	case ISOBUSFS_FA_SEEK_CUR:
		whence = SEEK_CUR;
		if (offset < 0 && handle->offset < -offset) {
			pr_warn("Invalid offset. Negative offset is too big.");
			return ISOBUSFS_ERR_INVALID_REQUESTED_LENGHT;
		}
		break;
	case ISOBUSFS_FA_SEEK_END:
		whence = SEEK_END;
		if (offset > 0) {
			pr_warn("Invalid offset. Offset must be negative");
			return ISOBUSFS_ERR_INVALID_REQUESTED_LENGHT;
		}
		break;
	default:
		pr_warn("invalid position mode");
		return ISOBUSFS_ERR_OTHER;
	}

	/* seek file */
	offs = lseek(handle->fd, offset, whence);
	if (offs < 0) {
		pr_warn("Failed to seek file");

		switch (offs) {
		case EBADF:
			return ISOBUSFS_ERR_INVALID_HANDLE;
		case EINVAL:
			return ISOBUSFS_ERR_INVALID_REQUESTED_LENGHT;
		case ENXIO:
			return ISOBUSFS_ERR_END_OF_FILE;
		case EOVERFLOW:
			return ISOBUSFS_ERR_OUT_OF_MEM;
		case ESPIPE:
			return ISOBUSFS_ERR_ACCESS_DENIED;
		default:
			return ISOBUSFS_ERR_OTHER;
		}
	}

	handle->offset = offs;

	return ISOBUSFS_ERR_SUCCESS;
}

static int isobusfs_srv_seek_directory(struct isobusfs_srv_handles *handle,
				       int32_t offset)
{
	DIR *dir = fdopendir(handle->fd);

	if (!dir)
		return ISOBUSFS_ERR_OTHER;

	rewinddir(dir);

	for (int32_t i = 0; i < offset; i++) {
		if (readdir(dir) == NULL)
			return ISOBUSFS_ERR_END_OF_FILE;
	}

	handle->dir_pos = offset;

	return ISOBUSFS_ERR_SUCCESS;
}

static int isobusfs_srv_fa_sf_req(struct isobusfs_srv_priv *priv,
				  struct isobusfs_msg *msg)
{
	struct isobusfs_fa_seekf_res res = {0};
	struct isobusfs_srv_client *client;
	struct isobusfs_fa_seekf_req *req;
	struct isobusfs_srv_handles *handle;
	int32_t offset_out = 0;
	uint8_t error_code = 0;
	int ret;

	req = (struct isobusfs_fa_seekf_req *)msg->buf;
	pr_debug("< rx: Seek File Request. Handle: %x, offset: %d, position mode: %d",
		 req->handle, le32toh(req->offset), req->position_mode);

	client = isobusfs_srv_get_client_by_msg(priv, msg);
	if (!client) {
		pr_warn("client not found");
		error_code = ISOBUSFS_ERR_OTHER;
		goto send_response;
	}

	handle = isobusfs_srv_get_handle(priv, req->handle);
	if (!handle) {
		pr_warn("failed to find handle: %x", req->handle);
		error_code = ISOBUSFS_ERR_INVALID_HANDLE;
		goto send_response;
	}

	if (handle->dir) {
		error_code = isobusfs_srv_seek_directory(handle,
							 le32toh(req->offset));
		res.position = htole32(handle->dir_pos);
	} else {
		error_code = isobusfs_srv_seek(priv, handle, le32toh(req->offset),
					       req->position_mode);
		res.position = htole32(handle->offset);
	}

send_response:
	res.fs_function =
		isobusfs_cg_function_to_buf(ISOBUSFS_CG_FILE_ACCESS,
					    ISOBUSFS_FA_F_SEEK_FILE_RES);
	res.tan = req->tan;
	res.error_code = error_code;

	/* send to socket */
	ret = isobusfs_srv_sendto(priv, msg, &res, sizeof(res));
	if (ret < 0) {
		pr_warn("can't send seek file response");
		return ret;
	}

	pr_debug("> tx: Seek File Response. Error code: %d, offset: %d",
		 error_code, offset_out);

	return 0;
}

static int isobusfs_srv_fa_cf_req(struct isobusfs_srv_priv *priv,
				  struct isobusfs_msg *msg)
{
	struct isobusfs_close_file_request *req;
	struct isobusfs_close_file_res res;
	struct isobusfs_srv_client *client;
	uint8_t error_code = 0;
	int ret;

	req = (struct isobusfs_close_file_request *)msg->buf;

	client = isobusfs_srv_get_client_by_msg(priv, msg);
	if (!client) {
		pr_warn("client not found");
		error_code = ISOBUSFS_ERR_OTHER;
		goto send_response;
	}

	ret = isobusfs_srv_release_handle(priv, client, req->handle);
	if (ret < 0) {
		pr_warn("failed to release handle: %x", req->handle);
		switch (ret) {
		case -ENOENT:
			error_code = ISOBUSFS_ERR_FILE_ORPATH_NOT_FOUND;
			break;
		default:
			error_code = ISOBUSFS_ERR_OTHER;
		}
	}

send_response:
	res.fs_function =
		isobusfs_cg_function_to_buf(ISOBUSFS_CG_FILE_ACCESS,
					    ISOBUSFS_FA_F_CLOSE_FILE_RES);
	res.tan = req->tan;
	res.error_code = error_code;
	memset(&res.reserved[0], 0xff, sizeof(res.reserved));

	/* send to socket */
	ret = isobusfs_srv_sendto(priv, msg, &res, sizeof(res));
	if (ret < 0) {
		pr_warn("can't send current directory response");
		goto err;
	}

	pr_debug("> tx: Close File Response. Error code: %d", error_code);

err:
	return ret;
}

/* Command group: file access */
int isobusfs_srv_rx_cg_fa(struct isobusfs_srv_priv *priv,
			  struct isobusfs_msg *msg)
{
	int func = isobusfs_buf_to_function(msg->buf);
	int ret = 0;

	switch (func) {
	case ISOBUSFS_FA_F_OPEN_FILE_REQ:
		ret = isobusfs_srv_fa_open_file_req(priv, msg);
		break;
	case ISOBUSFS_FA_F_CLOSE_FILE_REQ:
		ret = isobusfs_srv_fa_cf_req(priv, msg);
		break;
	case ISOBUSFS_FA_F_READ_FILE_REQ:
		ret = isobusfs_srv_fa_rf_req(priv, msg);
		break;
	case ISOBUSFS_FA_F_SEEK_FILE_REQ:
		ret = isobusfs_srv_fa_sf_req(priv, msg);
		break;
	case ISOBUSFS_FA_F_WRITE_FILE_REQ: /* fall through */
	default:
		pr_warn("%s: unsupported function: %i", __func__, func);
		isobusfs_srv_send_error(priv, msg,
					ISOBUSFS_ERR_FUNC_NOT_SUPPORTED);
	}

	return ret;
}