1#include <errno.h>
  2#include <stdio.h>
  3#include <stdint.h>
  4#include <stdlib.h>
  5#include <unistd.h>
  6#include <sys/ioctl.h>
  7#include <sys/types.h>
  8#include <sys/stat.h>
  9#include <fcntl.h>
 10#include <linux/fs.h>
 11
 12static int set_immutable(const char *path, int immutable)
 13{
 14	unsigned int flags;
 15	int fd;
 16	int rc;
 17	int error;
 18
 19	fd = open(path, O_RDONLY);
 20	if (fd < 0)
 21		return fd;
 22
 23	rc = ioctl(fd, FS_IOC_GETFLAGS, &flags);
 24	if (rc < 0) {
 25		error = errno;
 26		close(fd);
 27		errno = error;
 28		return rc;
 29	}
 30
 31	if (immutable)
 32		flags |= FS_IMMUTABLE_FL;
 33	else
 34		flags &= ~FS_IMMUTABLE_FL;
 35
 36	rc = ioctl(fd, FS_IOC_SETFLAGS, &flags);
 37	error = errno;
 38	close(fd);
 39	errno = error;
 40	return rc;
 41}
 42
 43static int get_immutable(const char *path)
 44{
 45	unsigned int flags;
 46	int fd;
 47	int rc;
 48	int error;
 49
 50	fd = open(path, O_RDONLY);
 51	if (fd < 0)
 52		return fd;
 53
 54	rc = ioctl(fd, FS_IOC_GETFLAGS, &flags);
 55	if (rc < 0) {
 56		error = errno;
 57		close(fd);
 58		errno = error;
 59		return rc;
 60	}
 61	close(fd);
 62	if (flags & FS_IMMUTABLE_FL)
 63		return 1;
 64	return 0;
 65}
 66
 67int main(int argc, char **argv)
 68{
 69	const char *path;
 70	char buf[5];
 71	int fd, rc;
 72
 73	if (argc < 2) {
 74		fprintf(stderr, "usage: %s <path>\n", argv[0]);
 75		return EXIT_FAILURE;
 76	}
 77
 78	path = argv[1];
 79
 80	/* attributes: EFI_VARIABLE_NON_VOLATILE |
 81	 *		EFI_VARIABLE_BOOTSERVICE_ACCESS |
 82	 *		EFI_VARIABLE_RUNTIME_ACCESS
 83	 */
 84	*(uint32_t *)buf = 0x7;
 85	buf[4] = 0;
 86
 87	/* create a test variable */
 88	fd = open(path, O_WRONLY | O_CREAT, 0600);
 89	if (fd < 0) {
 90		perror("open(O_WRONLY)");
 91		return EXIT_FAILURE;
 92	}
 93
 94	rc = write(fd, buf, sizeof(buf));
 95	if (rc != sizeof(buf)) {
 96		perror("write");
 97		return EXIT_FAILURE;
 98	}
 99
100	close(fd);
101
102	rc = get_immutable(path);
103	if (rc < 0) {
104		perror("ioctl(FS_IOC_GETFLAGS)");
105		return EXIT_FAILURE;
106	} else if (rc) {
107		rc = set_immutable(path, 0);
108		if (rc < 0) {
109			perror("ioctl(FS_IOC_SETFLAGS)");
110			return EXIT_FAILURE;
111		}
112	}
113
114	fd = open(path, O_RDONLY);
115	if (fd < 0) {
116		perror("open");
117		return EXIT_FAILURE;
118	}
119
120	if (unlink(path) < 0) {
121		perror("unlink");
122		return EXIT_FAILURE;
123	}
124
125	rc = read(fd, buf, sizeof(buf));
126	if (rc > 0) {
127		fprintf(stderr, "reading from an unlinked variable "
128				"shouldn't be possible\n");
129		return EXIT_FAILURE;
130	}
131
132	return EXIT_SUCCESS;
133}

  1// SPDX-License-Identifier: GPL-2.0
  2#include <errno.h>
  3#include <stdio.h>
  4#include <stdint.h>
  5#include <stdlib.h>
  6#include <unistd.h>
  7#include <sys/ioctl.h>
  8#include <sys/types.h>
  9#include <sys/stat.h>
 10#include <fcntl.h>
 11#include <linux/fs.h>
 12
 13static int set_immutable(const char *path, int immutable)
 14{
 15	unsigned int flags;
 16	int fd;
 17	int rc;
 18	int error;
 19
 20	fd = open(path, O_RDONLY);
 21	if (fd < 0)
 22		return fd;
 23
 24	rc = ioctl(fd, FS_IOC_GETFLAGS, &flags);
 25	if (rc < 0) {
 26		error = errno;
 27		close(fd);
 28		errno = error;
 29		return rc;
 30	}
 31
 32	if (immutable)
 33		flags |= FS_IMMUTABLE_FL;
 34	else
 35		flags &= ~FS_IMMUTABLE_FL;
 36
 37	rc = ioctl(fd, FS_IOC_SETFLAGS, &flags);
 38	error = errno;
 39	close(fd);
 40	errno = error;
 41	return rc;
 42}
 43
 44static int get_immutable(const char *path)
 45{
 46	unsigned int flags;
 47	int fd;
 48	int rc;
 49	int error;
 50
 51	fd = open(path, O_RDONLY);
 52	if (fd < 0)
 53		return fd;
 54
 55	rc = ioctl(fd, FS_IOC_GETFLAGS, &flags);
 56	if (rc < 0) {
 57		error = errno;
 58		close(fd);
 59		errno = error;
 60		return rc;
 61	}
 62	close(fd);
 63	if (flags & FS_IMMUTABLE_FL)
 64		return 1;
 65	return 0;
 66}
 67
 68int main(int argc, char **argv)
 69{
 70	const char *path;
 71	char buf[5];
 72	int fd, rc;
 73
 74	if (argc < 2) {
 75		fprintf(stderr, "usage: %s <path>\n", argv[0]);
 76		return EXIT_FAILURE;
 77	}
 78
 79	path = argv[1];
 80
 81	/* attributes: EFI_VARIABLE_NON_VOLATILE |
 82	 *		EFI_VARIABLE_BOOTSERVICE_ACCESS |
 83	 *		EFI_VARIABLE_RUNTIME_ACCESS
 84	 */
 85	*(uint32_t *)buf = 0x7;
 86	buf[4] = 0;
 87
 88	/* create a test variable */
 89	fd = open(path, O_WRONLY | O_CREAT, 0600);
 90	if (fd < 0) {
 91		perror("open(O_WRONLY)");
 92		return EXIT_FAILURE;
 93	}
 94
 95	rc = write(fd, buf, sizeof(buf));
 96	if (rc != sizeof(buf)) {
 97		perror("write");
 98		return EXIT_FAILURE;
 99	}
100
101	close(fd);
102
103	rc = get_immutable(path);
104	if (rc < 0) {
105		perror("ioctl(FS_IOC_GETFLAGS)");
106		return EXIT_FAILURE;
107	} else if (rc) {
108		rc = set_immutable(path, 0);
109		if (rc < 0) {
110			perror("ioctl(FS_IOC_SETFLAGS)");
111			return EXIT_FAILURE;
112		}
113	}
114
115	fd = open(path, O_RDONLY);
116	if (fd < 0) {
117		perror("open");
118		return EXIT_FAILURE;
119	}
120
121	if (unlink(path) < 0) {
122		perror("unlink");
123		return EXIT_FAILURE;
124	}
125
126	rc = read(fd, buf, sizeof(buf));
127	if (rc > 0) {
128		fprintf(stderr, "reading from an unlinked variable "
129				"shouldn't be possible\n");
130		return EXIT_FAILURE;
131	}
132
133	return EXIT_SUCCESS;
134}