Merge pull request #31 from lumag/tqftp-1.1.1

meson.build: prepare 1.1.1 release

Android.bp

@@ -0,0 +1,9 @@
+cc_binary {
+    name: "tqftpserv",
+    vendor: true,
+    srcs: [
+        "tqftpserv.c",
+        "translate.c",
+    ],
+    shared_libs: ["libqrtr"],
+}

LICENSE

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2018, Linaro Ltd.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ * may be used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */

Makefile

@@ -1,17 +0,0 @@
-TQFTPSERV := tqftpserv
-
-CFLAGS := -Wall -g -O2
-LDFLAGS := -lqrtr
-
-SRCS := tqftpserv.c
-
-OBJS := $(SRCS:.c=.o)
-
-$(TQFTPSERV): $(OBJS)
-	$(CC) -o $@ $^ $(LDFLAGS)
-
-install: $(TQFTPSERV)
-	install -D -m 755 $< $(DESTDIR)$(prefix)/bin/$<
-
-clean:
-	rm -f $(TQFTPSERV) $(OBJS)

README.md

@@ -0,0 +1,53 @@
+# tqftpserv
+
+The tqftpserv software is an implementation of a TFTP (Trivial File Transfer Protocol) server which runs on top of the AF_QIPCRTR (a.k.a QRTR) socket type.
+
+The main purpose of tqftpserv is to serve files from the Linux file system to other processors on the Qualcomm SoCs as requested.
+
+The protocol implemented here is (loosely) based on RFC 1350 including some extensions to the protocol.
+
+In basic terms, the protocol supports RRQ (Read Request) and WRQ (Write Request) messages which read and write files respectively. A request can have some extra options, like `blksize` ior `wsize`. The meaning of those is documented in the `parse_options` function.
+
+For reference, the proprietary implementation of this that is used on practically all Qualcomm-based Android devices is called "tftp_server".
+
+## File paths
+
+There's two different virtual paths prefixes that are supported:
+* `/readonly/firmware/image/` for read-only files such as firmware files
+* `/readwrite/` for read-write (temporary) files
+
+Requests to those paths are "translated" (see `translate.c`) to paths in the Linux filesystem. In a regular setup readonly requests go to `/lib/firmware/` and readwrite requests go to `/tmp/tqftpserv/`.
+
+Translating those readonly request paths tries to take into account custom Linux firmware paths, custom "firmware-name" paths for remoteprocs, .zstd compressed firmware and more. In case of doubt, please consult the source code.
+
+For example on a QCM6490 Fairphone 5 smartphone the path for `/readonly/firmware/image/modem_pr/so/901_0_0.mbn` will be translated to `/lib/firmware/qcom/qcm6490/fairphone5/modem_pr/so/901_0_0.mbn`, based on the devicetree property `firmware-name = "qcom/qcm6490/fairphone5/modem.mbn";` in the modem/mpss DT node.
+
+The actual paths that are used and requested are dependent on the TFTP clients, which is usually the firmware that is running on the Hexagon-based modem processor on the SoC.
+
+## Example requests
+
+The following are some example requests which are grabbed from the tqftpserv log during modem bootup.
+
+* Write content to a file called "server_check.txt":
+```
+[TQFTP] WRQ: /readwrite/server_check.txt (octet)
+```
+
+* Read a file called "ota_firewall/ruleset" which does not exist:
+```
+[TQFTP] RRQ: /readwrite/ota_firewall/ruleset (mode=octet rsize=0 seek=0)
+tqftpserv: failed to open ota_firewall/ruleset: No such file or directory
+[TQFTP] unable to open /readwrite/ota_firewall/ruleset (2), reject
+```
+
+* Stat a file with the path "modem_pr/so/901_0_0.mbn", and then read it:
+```
+[TQFTP] RRQ: /readonly/firmware/image/modem_pr/so/901_0_0.mbn (mode=octet rsize=0 seek=0)
+[TQFTP] Remote returned END OF TRANSFER: 9 - End of Transfer
+[TQFTP] RRQ: /readonly/firmware/image/modem_pr/so/901_0_0.mbn (mode=octet rsize=52 seek=0)
+```
+
+In binary such a request can look like the following:
+```
+\0\1/readonly/firmware/image/modem_pr/so/901_0_0.mbn\0octet\0blksize\0007680\0timeoutms\0001000\0tsize\0000\0wsize\00010\0
+```

list.h

@@ -1,32 +1,6 @@
+// SPDX-License-Identifier: BSD-3-Clause
 /*
  * Copyright (c) 2016, Linaro Ltd.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * 1. Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- * this list of conditions and the following disclaimer in the documentation
- * and/or other materials provided with the distribution.
- *
- * 3. Neither the name of the copyright holder nor the names of its contributors
- * may be used to endorse or promote products derived from this software without
- * specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
  */
 #ifndef __LIST_H__
 #define __LIST_H__

meson.build

@@ -0,0 +1,45 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+project('tqftpserv',
+        'c',
+        version: '1.1.1',
+        default_options: [
+            'warning_level=1',
+            'buildtype=release',
+        ])
+
+prefix = get_option('prefix')
+
+zstd_dep = dependency('libzstd')
+add_project_arguments('-DHAVE_ZSTD', language : 'c')
+
+# Not required to build the executable,
+# only to automatically retrieve the install dir for unit files
+systemd = dependency('systemd', required : false)
+if get_option('systemd-unit-prefix') != ''
+  systemd_system_unit_dir = get_option('systemd-unit-prefix')
+elif systemd.found()
+  systemd_system_unit_dir = systemd.get_variable(
+    pkgconfig : 'systemdsystemunitdir',
+    pkgconfig_define: ['prefix', prefix])
+endif
+
+qrtr_dep = dependency('qrtr')
+
+tqftpserv_srcs = ['translate.c',
+                  'tqftpserv.c',
+                  'zstd-decompress.c']
+executable('tqftpserv',
+           tqftpserv_srcs,
+           dependencies : [qrtr_dep, zstd_dep],
+           install : true)
+
+if systemd_system_unit_dir != ''
+        systemd_unit_conf = configuration_data()
+        systemd_unit_conf.set('prefix', prefix)
+        configure_file(
+                input : 'tqftpserv.service.in',
+                output : 'tqftpserv.service',
+                configuration : systemd_unit_conf,
+                install_dir : systemd_system_unit_dir)
+endif

meson_options.txt

@@ -0,0 +1,4 @@
+option('systemd-unit-prefix',
+  type: 'string',
+  description: 'Directory for systemd system unit files'
+)

tqftpserv.service.in

@@ -0,0 +1,10 @@
+[Unit]
+Description=QRTR TFTP service
+
+[Service]
+ExecStart=@prefix@/bin/tqftpserv
+Restart=always
+
+[Install]
+WantedBy=multi-user.target
+

translate.c

@@ -0,0 +1,243 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/*
+ * Copyright (c) 2019, Linaro Ltd.
+ */
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <err.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <libgen.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "translate.h"
+#include "zstd-decompress.h"
+
+#define READONLY_PATH	"/readonly/firmware/image/"
+#define READWRITE_PATH	"/readwrite/"
+
+#ifndef ANDROID
+#define FIRMWARE_BASE	"/lib/firmware/"
+#define TQFTPSERV_TMP	"/tmp/tqftpserv"
+#define UPDATES_DIR	"updates/"
+#else
+#define FIRMWARE_BASE	"/vendor/firmware/"
+#define TQFTPSERV_TMP	"/data/vendor/tmp/tqftpserv"
+#endif
+
+static int open_maybe_compressed(const char *path);
+
+static void read_fw_path_from_sysfs(char *outbuffer, size_t bufsize)
+{
+	size_t pathsize;
+	FILE *f = fopen("/sys/module/firmware_class/parameters/path", "rt");
+	if (!f)
+		return;
+	pathsize = fread(outbuffer, sizeof(char), bufsize, f);
+	fclose(f);
+	if (pathsize == 0)
+		return;
+	/* truncate newline */
+	outbuffer[pathsize - 1] = '\0';
+}
+
+/**
+ * translate_readonly() - open "file" residing with remoteproc firmware
+ * @file:	file requested, stripped of "/readonly/image/" prefix
+ *
+ * It is assumed that the readonly files requested by the client resides under
+ * /lib/firmware in the same place as its associated remoteproc firmware.  This
+ * function scans through all entries under /sys/class/remoteproc and read the
+ * dirname of each "firmware" file in an attempt to find, and open(2), the
+ * requested file.
+ *
+ * As these files are readonly, it's not possible to pass flags to open(2).
+ *
+ * Return: opened fd on success, -1 otherwise
+ */
+static int translate_readonly(const char *file)
+{
+	char firmware_value[PATH_MAX];
+	char *firmware_value_copy = NULL;
+	char *firmware_path;
+	char firmware_attr[32];
+	char path[PATH_MAX];
+	char fw_sysfs_path[PATH_MAX];
+	struct dirent *de;
+	int firmware_fd;
+	DIR *class_dir;
+	int class_fd;
+	ssize_t n;
+	int fd = -1;
+
+	read_fw_path_from_sysfs(fw_sysfs_path, sizeof(fw_sysfs_path));
+
+	class_fd = open("/sys/class/remoteproc", O_RDONLY | O_DIRECTORY);
+	if (class_fd < 0) {
+		warn("failed to open remoteproc class");
+		return -1;
+	}
+
+	class_dir = fdopendir(class_fd);
+	if (!class_dir) {
+		warn("failed to opendir");
+		close(class_fd);
+		return -1;
+	}
+
+	while ((de = readdir(class_dir)) != NULL) {
+		if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, ".."))
+			continue;
+
+		if (strlen(de->d_name) + sizeof("/firmware") > sizeof(firmware_attr))
+			continue;
+		strcpy(firmware_attr, de->d_name);
+		strcat(firmware_attr, "/firmware");
+
+		firmware_fd = openat(class_fd, firmware_attr, O_RDONLY);
+		if (firmware_fd < 0)
+			continue;
+
+		n = read(firmware_fd, firmware_value, sizeof(firmware_value));
+		close(firmware_fd);
+		if (n < 0) {
+			continue;
+		}
+		firmware_value[n] = '\0';
+
+		firmware_value_copy = strdup(firmware_value);
+		firmware_path = dirname(firmware_value_copy);
+
+		/* first try path from sysfs */
+		if ((strlen(fw_sysfs_path) > 0) &&
+		    (strlen(fw_sysfs_path) + 1 + strlen(firmware_value) + 1 + strlen(file) + 1 < sizeof(path))) {
+			strcpy(path, fw_sysfs_path);
+			strcat(path, "/");
+			strcat(path, firmware_path);
+			strcat(path, "/");
+			strcat(path, file);
+
+			fd = open_maybe_compressed(path);
+			if (fd >= 0)
+				break;
+			if (errno != ENOENT)
+				warn("failed to open %s", path);
+		}
+
+		/* now try with base path */
+		if (strlen(FIRMWARE_BASE) + strlen(UPDATES_DIR) + strlen(firmware_value) + 1 +
+		    strlen(file) + 1 > sizeof(path))
+			continue;
+
+		strcpy(path, FIRMWARE_BASE);
+		strcat(path, UPDATES_DIR);
+		strcat(path, firmware_path);
+		strcat(path, "/");
+		strcat(path, file);
+
+		fd = open_maybe_compressed(path);
+		if (fd < 0) {
+			strcpy(path, FIRMWARE_BASE);
+			strcat(path, firmware_path);
+			strcat(path, "/");
+			strcat(path, file);
+
+			fd = open_maybe_compressed(path);
+		}
+		if (fd >= 0)
+			break;
+
+		if (errno != ENOENT)
+			warn("failed to open %s", path);
+	}
+
+	free(firmware_value_copy);
+	closedir(class_dir);
+
+	return fd;
+}
+
+/**
+ * translate_readwrite() - open "file" from a temporary directory
+ * @file:	relative path of the requested file, with /readwrite/ stripped
+ * @flags:	flags to be passed to open(2)
+ *
+ * Return: opened fd on success, -1 otherwise
+ */
+static int translate_readwrite(const char *file, int flags)
+{
+	int base;
+	int ret;
+	int fd;
+
+	ret = mkdir(TQFTPSERV_TMP, 0700);
+	if (ret < 0 && errno != EEXIST) {
+		warn("failed to create temporary tqftpserv directory");
+		return -1;
+	}
+
+	base = open(TQFTPSERV_TMP, O_RDONLY | O_DIRECTORY);
+	if (base < 0) {
+		warn("failed top open temporary tqftpserv directory");
+		return -1;
+	}
+
+	fd = openat(base, file, flags, 0600);
+	close(base);
+	if (fd < 0)
+		warn("failed to open %s", file);
+
+	return fd;
+}
+
+/**
+ * translate_open() - open file after translating path
+ *
+
+ * Strips /readonly/firmware/image and search among remoteproc firmware.
+ * Replaces /readwrite with a temporary directory.
+
+ */
+int translate_open(const char *path, int flags)
+{
+	if (!strncmp(path, READONLY_PATH, strlen(READONLY_PATH)))
+		return translate_readonly(path + strlen(READONLY_PATH));
+	else if (!strncmp(path, READWRITE_PATH, strlen(READWRITE_PATH)))
+		return translate_readwrite(path + strlen(READWRITE_PATH), flags);
+
+	fprintf(stderr, "invalid path %s, rejecting\n", path);
+	errno = ENOENT;
+	return -1;
+}
+
+/* linux-firmware uses .zst as file extension */
+#define ZSTD_EXTENSION ".zst"
+
+/**
+ * open_maybe_compressed() - open a file and maybe decompress it if necessary
+ * @filename:	path to a file that may be compressed (should not include compression format extension)
+ *
+ * Return: opened fd on success, -1 on error
+ */
+static int open_maybe_compressed(const char *path)
+{
+	char *path_with_zstd_extension = NULL;
+	int fd = -1;
+
+	if (access(path, F_OK) == 0)
+		return open(path, O_RDONLY);
+
+	asprintf(&path_with_zstd_extension, "%s%s", path, ZSTD_EXTENSION);
+
+	if (access(path_with_zstd_extension, F_OK) == 0)
+		fd = zstd_decompress_file(path_with_zstd_extension);
+
+	free(path_with_zstd_extension);
+
+	return fd;
+}

translate.h

@@ -0,0 +1,6 @@
+#ifndef __TRANSLATE_H__
+#define __TRANSLATE_H__
+
+int translate_open(const char *path, int flags);
+
+#endif

zstd-decompress.c

@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/*
+ * Copyright (c) 2024, Stefan Hansson
+ * Copyright (c) 2024, Emil Velikov
+ */
+
+/* For memfd_create */
+#define _GNU_SOURCE
+
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <zstd.h>
+
+#include "zstd-decompress.h"
+
+/**
+ * zstd_decompress_file() - decompress a zstd-compressed file
+ * @filename:	path to a file to decompress
+ *
+ * Return: opened fd on success, -1 on error
+ */
+int zstd_decompress_file(const char *filename)
+{
+	/* Figure out the size of the file. */
+	struct stat file_stat;
+	if (stat(filename, &file_stat) == -1) {
+		fprintf(stderr, "stat %s failed (%s)\n", filename, strerror(errno));
+		return -1;
+	}
+
+	const size_t file_size = file_stat.st_size;
+
+	const int input_file_fd = open(filename, O_RDONLY);
+	if (input_file_fd == -1) {
+		perror("open failed");
+		return -1;
+	}
+
+	void* const compressed_buffer = mmap(NULL, file_size, PROT_READ, MAP_POPULATE | MAP_PRIVATE, input_file_fd, 0);
+	if (compressed_buffer == MAP_FAILED) {
+		perror("mmap failed");
+		close(input_file_fd);
+		return -1;
+	}
+	close(input_file_fd);
+
+	const unsigned long long decompressed_size = ZSTD_getFrameContentSize(compressed_buffer, file_size);
+	if (decompressed_size == ZSTD_CONTENTSIZE_UNKNOWN) {
+		fprintf(stderr, "Content size could not be determined for %s\n", filename);
+		munmap(compressed_buffer, file_size);
+		return -1;
+	}
+	if (decompressed_size == ZSTD_CONTENTSIZE_ERROR) {
+		fprintf(stderr, "Error getting content size for %s\n", filename);
+		munmap(compressed_buffer, file_size);
+		return -1;
+	}
+
+	void* const decompressed_buffer = malloc((size_t)decompressed_size);
+	if (decompressed_buffer == NULL) {
+		perror("malloc failed");
+		munmap(compressed_buffer, file_size);
+		return -1;
+	}
+
+	const size_t return_size = ZSTD_decompress(decompressed_buffer, decompressed_size, compressed_buffer, file_size);
+	if (ZSTD_isError(return_size)) {
+		fprintf(stderr, "ZSTD_decompress failed: %s\n", ZSTD_getErrorName(return_size));
+		free(decompressed_buffer);
+		munmap(compressed_buffer, file_size);
+		return -1;
+	}
+
+	const int output_file_fd = memfd_create(filename, 0);
+	if (output_file_fd == -1) {
+		perror("memfd_create failed");
+		free(decompressed_buffer);
+		munmap(compressed_buffer, file_size);
+		return -1;
+	}
+
+	if (write(output_file_fd, decompressed_buffer, decompressed_size) != decompressed_size) {
+		perror("write failed");
+		close(output_file_fd);
+		free(decompressed_buffer);
+		munmap(compressed_buffer, file_size);
+		return -1;
+	}
+
+	return output_file_fd;
+}

zstd-decompress.h

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/*
+ * Copyright (c) 2024, Stefan Hansson
+ */
+
+#ifndef __ZSTD_DECOMPRESS_H__
+#define __ZSTD_DECOMPRESS_H__
+
+#include <stdbool.h>
+
+#ifdef HAVE_ZSTD
+int zstd_decompress_file(const char *filename);
+#else
+static int zstd_decompress_file(const char *filename)
+{
+	fprintf(stderr, "Built without ZSTD support\n");
+	return -1;
+}
+#endif
+
+#endif