Skip to contentSkip to conversation

tst API for dropping or requiring capabilities

RFC PATCH Superseded Richard Palethorpe 6 participants 16 messages Aug 8, 2019 – Aug 23, 2019

Subsystems (3)

v1 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

cover tst API for dropping or requiring capabilities

Hello,

This API allows one to drop or require particular capabilities after setup.

It can be used like this:

	.caps = (struct tst_cap []) {
		TST_CAP(TST_DROP, CAP_SYS_ADMIN),
		{0, 0, 0},
	},

or

	.caps = (struct tst_cap []) {
	        TST_CAP(TST_DROP, CAP_SYS_ADMIN)
		TST_CAP(TST_REQUIRE, CAP_SOMETHING),
		{0, 0, 0},
	},

It uses capget and capset directly so that we do not need to link to libcap.

Richard Palethorpe (1):
capability: Introduce capability API

 include/tst_capability.h | 56 +++++++++++++++++++++++++++++
 include/tst_test.h       |  6 ++++
 lib/tst_capability.c     | 78 ++++++++++++++++++++++++++++++++++++++++
 lib/tst_test.c           |  3 ++
 4 files changed, 143 insertions(+)
 create mode 100644 include/tst_capability.h
 create mode 100644 lib/tst_capability.c
Signature · 1 line
2.22.0
#1 lore raw

RFC PATCH 1/1 capability: Introduce capability API

---
 include/tst_capability.h | 56 +++++++++++++++++++++++++++++
 include/tst_test.h       |  6 ++++
 lib/tst_capability.c     | 78 ++++++++++++++++++++++++++++++++++++++++
 lib/tst_test.c           |  3 ++
 4 files changed, 143 insertions(+)
 create mode 100644 include/tst_capability.h
 create mode 100644 lib/tst_capability.c
include/tst_capability.h new file +56 -0
new file mode 100644
index 000000000..6342b667e
@@ -0,0 +1,56 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (c) 2019 Richard Palethorpe <[email protected]>
+ */
+/**
+ * @file tst_capability.h
+ *
+ * Limited capability operations without libcap.
+ */
+
+#include <stdint.h>
+
+#include "lapi/syscalls.h"
+
+#ifndef TST_CAPABILITY_H
+#define TST_CAPABILITY_H
+
+#ifndef CAP_SYS_ADMIN
+# define CAP_SYS_ADMIN        21
+#endif
+
+#ifndef CAP_TO_MASK
+# define CAP_TO_MASK(x)      (1 << ((x) & 31))
+#endif
+
+#define TST_DROP 1
+#define TST_REQUIRE 1 << 1
+
+#define TST_CAP(action, capability) {action, capability, #capability}
+
+struct tst_cap_user_header {
+	uint32_t version;
+	int pid;
+};
+
+struct tst_cap_user_data {
+	uint32_t effective;
+	uint32_t permitted;
+	uint32_t inheritable;
+};
+
+struct tst_cap {
+	uint32_t action;
+	uint32_t id;
+	char *name;
+};
+
+int tst_capget(struct tst_cap_user_header *hdr,
+	       struct tst_cap_user_data *data);
+int tst_capset(struct tst_cap_user_header *hdr,
+	       const struct tst_cap_user_data *data);
+
+void tst_cap_action(struct tst_cap *cap);
+void tst_cap_setup(struct tst_cap *cap);
+
+#endif
include/tst_test.h +6 -0
index cdeaf6ad0..84acf2c59 100644
@@ -36,6 +36,7 @@
 #include "tst_sys_conf.h"
 #include "tst_coredump.h"
 #include "tst_buffers.h"
+#include "tst_capability.h"
 
 /*
  * Reports testcase result.
@@ -206,6 +207,11 @@ struct tst_test {
 	 * NULL-terminated array to be allocated buffers.
 	 */
 	struct tst_buffers *bufs;
+
+	/*
+	 * NULL-terminated array of capability settings
+	 */
+	struct tst_cap *caps;
 };
 
 /*
lib/tst_capability.c new file +78 -0

78 lines not on this page · raw message

lib/tst_test.c +3 -0
index 8dc71dbb3..62e54d071 100644
@@ -893,6 +893,9 @@ static void do_test_setup(void)
 
 	if (main_pid != getpid())
 		tst_brk(TBROK, "Runaway child in setup()!");
+
+	if (tst_test->caps)
+		tst_cap_setup(tst_test->caps);
 }
 
 static void do_cleanup(void)
Signature · 1 line
2.22.0
#2 lore raw

RFC PATCH 1/1 capability: Introduce capability API

Hi!

Quoted 7 lines
 include/tst_capability.h | 56 +++++++++++++++++++++++++++++
 include/tst_test.h       |  6 ++++
 lib/tst_capability.c     | 78 ++++++++++++++++++++++++++++++++++++++++
 lib/tst_test.c           |  3 ++
 4 files changed, 143 insertions(+)
 create mode 100644 include/tst_capability.h
 create mode 100644 lib/tst_capability.c

This is missing a documentation in the test-writing-guidelines I do expect that you will add that later on.

Quoted 9 lines
include/tst_capability.h new file +3 -0
new file mode 100644
index 000000000..6342b667e
@@ -0,0 +1,56 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (c) 2019 Richard Palethorpe <[email protected]>

include/tst_capability.h line 13

Quoted 10 lines
include/tst_capability.h new file +10 -0
+ */
+/**
+ * @file tst_capability.h
+ *
+ * Limited capability operations without libcap.
+ */
+
+#include <stdint.h>
+
+#include "lapi/syscalls.h"

^
What is this needed for here?

include/tst_capability.h line 24

Quoted 10 lines
include/tst_capability.h new file +9 -0
+#ifndef TST_CAPABILITY_H
+#define TST_CAPABILITY_H
+
+#ifndef CAP_SYS_ADMIN
+# define CAP_SYS_ADMIN        21
+#endif
 
+#ifndef CAP_TO_MASK
+# define CAP_TO_MASK(x)      (1 << ((x) & 31))
+#endif

These bits should probably go to lapi/capability.h

include/tst_capability.h line 27

Quoted 2 lines
include/tst_capability.h new file +2 -0
+#define TST_DROP 1
+#define TST_REQUIRE 1 << 1

Maybe these should be TST_CAP_DROP and TST_CAP_REQ

include/tst_capability.h line 40

Quoted 12 lines
include/tst_capability.h new file +12 -0
+#define TST_CAP(action, capability) {action, capability, #capability}
+
+struct tst_cap_user_header {
+	uint32_t version;
+	int pid;
+};
+
+struct tst_cap_user_data {
+	uint32_t effective;
+	uint32_t permitted;
+	uint32_t inheritable;
+};

This two should probably go to lapi as well.

include/tst_capability.h line 46

Quoted 5 lines
include/tst_capability.h new file +5 -0
+struct tst_cap {
+	uint32_t action;
+	uint32_t id;
+	char *name;
+};

I wonder if we should build a table of capability names for translation just as we do errnos and signals instead of storing the name here. But I guess that unless we will need a function to translate capabilitities into strings on runtime this approach is simpler.

Quoted 106 lines
include/tst_capability.h new file +9 -0
+int tst_capget(struct tst_cap_user_header *hdr,
+	       struct tst_cap_user_data *data);
+int tst_capset(struct tst_cap_user_header *hdr,
+	       const struct tst_cap_user_data *data);
+
+void tst_cap_action(struct tst_cap *cap);
+void tst_cap_setup(struct tst_cap *cap);
+
+#endif
include/tst_test.h +6 -0
index cdeaf6ad0..84acf2c59 100644
@@ -36,6 +36,7 @@
 #include "tst_sys_conf.h"
 #include "tst_coredump.h"
 #include "tst_buffers.h"
+#include "tst_capability.h"
 
 /*
  * Reports testcase result.
@@ -206,6 +207,11 @@ struct tst_test {
 	 * NULL-terminated array to be allocated buffers.
 	 */
 	struct tst_buffers *bufs;
+
+	/*
+	 * NULL-terminated array of capability settings
+	 */
+	struct tst_cap *caps;
 };
 
 /*
lib/tst_capability.c new file +67 -0
new file mode 100644
index 000000000..d229491ae
@@ -0,0 +1,78 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (c) 2019 Richard Palethorpe <[email protected]>
+ */
+
+#define TST_NO_DEFAULT_MAIN
+#include "tst_test.h"
+#include "tst_capability.h"
+
+int tst_capget(struct tst_cap_user_header *hdr,
+	       struct tst_cap_user_data *data)
+{
+	return tst_syscall(__NR_capget, hdr, data);
+}
+
+int tst_capset(struct tst_cap_user_header *hdr,
+	       const struct tst_cap_user_data *data)
+{
+	return tst_syscall(__NR_capset, hdr, data);
+}
+
+void tst_cap_action(struct tst_cap *cap)
+{
+	struct tst_cap_user_header hdr = {
+		.version = 0x20080522,
+		.pid = tst_syscall(__NR_gettid),
+	};
+	struct tst_cap_user_data cur = { 0 };
+	struct tst_cap_user_data new = { 0 };
+	uint32_t mask = CAP_TO_MASK(cap->id);
+	uint32_t act = cap->action;
+
+	if (tst_capget(&hdr, &cur))
+		tst_brk(TBROK | TTERRNO, "tst_capget()");
+
+	new = cur;
+
+	switch (act) {
+	case TST_DROP:
+		if (cur.effective & mask) {
+			tst_res(TINFO, "Dropping %s(%d)",
+				cap->name, cap->id);
+			new.effective &= ~mask;
+			new.permitted &= ~mask;
+			new.inheritable &= ~mask;
+		}
+		break;
+	case TST_REQUIRE:
+		if (cur.permitted ^ mask) {
+			tst_brk(TCONF, "Need %s(%d)",
+				cap->name, cap->id);
+		} else if (cur.effective ^ mask) {
+			tst_res(TINFO, "Permitting %s(%d)",
+				cap->name, cap->id);
+			new.effective |= mask;
+			new.inheritable |= mask;
+		}
+		break;
+	default:
+		tst_brk(TBROK, "Unrecognised action %d", cap->action);
+	}
+
+	if (cur.effective != new.effective) {
+		if (tst_capset(&hdr, &new))
+			tst_brk(TBROK | TERRNO, "tst_capset(%s)", cap->name);
+	} else {
+		tst_res(TINFO, "No capability changes needed");

lib/tst_capability.c line 77

Quoted 10 lines
lib/tst_capability.c new file +10 -0
+	}
+}
+
+void tst_cap_setup(struct tst_cap *caps)
+{
+	struct tst_cap *cap;
+
+	for (cap = caps; cap->action; cap++) {
+		tst_cap_action(cap);
+	}

No need for the curly braces here :-).

lib/tst_test.c static void do_test_setup(void) · line 899

Quoted 13 lines
lib/tst_capability.c new file +1 -0
+}
lib/tst_test.c +3 -0
index 8dc71dbb3..62e54d071 100644
@@ -893,6 +893,9 @@ static void do_test_setup(void)
 
 	if (main_pid != getpid())
 		tst_brk(TBROK, "Runaway child in setup()!");
+
+	if (tst_test->caps)
+		tst_cap_setup(tst_test->caps);
 }

Other than the minor things and missing docs this patch looks good to me.

Signature · 2 lines
Cyril Hrubis
[email protected]
#3 lore raw

RFC PATCH 1/1 capability: Introduce capability API

----- Original Message -----

Quoted 204 lines

Hi!

Quoted 7 lines
 include/tst_capability.h | 56 +++++++++++++++++++++++++++++
 include/tst_test.h       |  6 ++++
 lib/tst_capability.c     | 78 ++++++++++++++++++++++++++++++++++++++++
 lib/tst_test.c           |  3 ++
 4 files changed, 143 insertions(+)
 create mode 100644 include/tst_capability.h
 create mode 100644 lib/tst_capability.c

This is missing a documentation in the test-writing-guidelines I do expect that you will add that later on.

Quoted 9 lines
include/tst_capability.h new file +3 -0
new file mode 100644
index 000000000..6342b667e
@@ -0,0 +1,56 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (c) 2019 Richard Palethorpe <[email protected]>

include/tst_capability.h line 13

Quoted 10 lines
include/tst_capability.h new file +10 -0
+ */
+/**
+ * @file tst_capability.h
+ *
+ * Limited capability operations without libcap.
+ */
+
+#include <stdint.h>
+
+#include "lapi/syscalls.h"

^
What is this needed for here?

include/tst_capability.h line 24

Quoted 10 lines
include/tst_capability.h new file +9 -0
+#ifndef TST_CAPABILITY_H
+#define TST_CAPABILITY_H
+
+#ifndef CAP_SYS_ADMIN
+# define CAP_SYS_ADMIN        21
+#endif
 
+#ifndef CAP_TO_MASK
+# define CAP_TO_MASK(x)      (1 << ((x) & 31))
+#endif

These bits should probably go to lapi/capability.h

include/tst_capability.h line 27

Quoted 2 lines
include/tst_capability.h new file +2 -0
+#define TST_DROP 1
+#define TST_REQUIRE 1 << 1

Maybe these should be TST_CAP_DROP and TST_CAP_REQ

include/tst_capability.h line 40

Quoted 12 lines
include/tst_capability.h new file +12 -0
+#define TST_CAP(action, capability) {action, capability, #capability}
+
+struct tst_cap_user_header {
+	uint32_t version;
+	int pid;
+};
+
+struct tst_cap_user_data {
+	uint32_t effective;
+	uint32_t permitted;
+	uint32_t inheritable;
+};

This two should probably go to lapi as well.

include/tst_capability.h line 46

Quoted 5 lines
include/tst_capability.h new file +5 -0
+struct tst_cap {
+	uint32_t action;
+	uint32_t id;
+	char *name;
+};

I wonder if we should build a table of capability names for translation just as we do errnos and signals instead of storing the name here. But I guess that unless we will need a function to translate capabilitities into strings on runtime this approach is simpler.

Quoted 106 lines
include/tst_capability.h new file +9 -0
+int tst_capget(struct tst_cap_user_header *hdr,
+	       struct tst_cap_user_data *data);
+int tst_capset(struct tst_cap_user_header *hdr,
+	       const struct tst_cap_user_data *data);
+
+void tst_cap_action(struct tst_cap *cap);
+void tst_cap_setup(struct tst_cap *cap);
+
+#endif
include/tst_test.h +6 -0
index cdeaf6ad0..84acf2c59 100644
@@ -36,6 +36,7 @@
 #include "tst_sys_conf.h"
 #include "tst_coredump.h"
 #include "tst_buffers.h"
+#include "tst_capability.h"
 
 /*
  * Reports testcase result.
@@ -206,6 +207,11 @@ struct tst_test {
 	 * NULL-terminated array to be allocated buffers.
 	 */
 	struct tst_buffers *bufs;
+
+	/*
+	 * NULL-terminated array of capability settings
+	 */
+	struct tst_cap *caps;
 };
 
 /*
lib/tst_capability.c new file +67 -0
new file mode 100644
index 000000000..d229491ae
@@ -0,0 +1,78 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (c) 2019 Richard Palethorpe <[email protected]>
+ */
+
+#define TST_NO_DEFAULT_MAIN
+#include "tst_test.h"
+#include "tst_capability.h"
+
+int tst_capget(struct tst_cap_user_header *hdr,
+	       struct tst_cap_user_data *data)
+{
+	return tst_syscall(__NR_capget, hdr, data);
+}
+
+int tst_capset(struct tst_cap_user_header *hdr,
+	       const struct tst_cap_user_data *data)
+{
+	return tst_syscall(__NR_capset, hdr, data);
+}
+
+void tst_cap_action(struct tst_cap *cap)
+{
+	struct tst_cap_user_header hdr = {
+		.version = 0x20080522,
+		.pid = tst_syscall(__NR_gettid),
+	};
+	struct tst_cap_user_data cur = { 0 };
+	struct tst_cap_user_data new = { 0 };
+	uint32_t mask = CAP_TO_MASK(cap->id);
+	uint32_t act = cap->action;
+
+	if (tst_capget(&hdr, &cur))
+		tst_brk(TBROK | TTERRNO, "tst_capget()");
+
+	new = cur;
+
+	switch (act) {
+	case TST_DROP:
+		if (cur.effective & mask) {
+			tst_res(TINFO, "Dropping %s(%d)",
+				cap->name, cap->id);
+			new.effective &= ~mask;
+			new.permitted &= ~mask;
+			new.inheritable &= ~mask;
+		}
+		break;
+	case TST_REQUIRE:
+		if (cur.permitted ^ mask) {
+			tst_brk(TCONF, "Need %s(%d)",
+				cap->name, cap->id);
+		} else if (cur.effective ^ mask) {
+			tst_res(TINFO, "Permitting %s(%d)",
+				cap->name, cap->id);
+			new.effective |= mask;
+			new.inheritable |= mask;
+		}
+		break;
+	default:
+		tst_brk(TBROK, "Unrecognised action %d", cap->action);
+	}
+
+	if (cur.effective != new.effective) {
+		if (tst_capset(&hdr, &new))
+			tst_brk(TBROK | TERRNO, "tst_capset(%s)", cap->name);
+	} else {
+		tst_res(TINFO, "No capability changes needed");

lib/tst_capability.c line 77

Quoted 10 lines
lib/tst_capability.c new file +10 -0
+	}
+}
+
+void tst_cap_setup(struct tst_cap *caps)
+{
+	struct tst_cap *cap;
+
+	for (cap = caps; cap->action; cap++) {
+		tst_cap_action(cap);
+	}

No need for the curly braces here :-).

Quoted 7 lines
lib/tst_capability.c new file +1 -0
+}
lib/tst_test.c +0 -0
index 8dc71dbb3..62e54d071 100644
@@ -893,6 +893,9 @@ static void do_test_setup(void)
 
Quoted 8 lines

lib/tst_test.c static void do_test_setup(void) · line 899

Quoted 6 lines
lib/tst_test.c +3 -0
 	if (main_pid != getpid())
 		tst_brk(TBROK, "Runaway child in setup()!");
+
+	if (tst_test->caps)
+		tst_cap_setup(tst_test->caps);
 }

Other than the minor things and missing docs this patch looks good to me.

+1, but please rebase it on latest master.

#4 lore raw

RFC PATCH 1/1 capability: Introduce capability API

In reply to Cyril Hrubis

Hello,

Quoted 5 lines · Cyril Hrubis
Quoted 5 lines
include/tst_capability.h new file +5 -0
+
+struct tst_cap_user_header {
+	uint32_t version;
+	int pid;
+};
Quoted 8 lines

include/tst_capability.h line 40

Quoted 6 lines
include/tst_capability.h new file +6 -0
+
+struct tst_cap_user_data {
+	uint32_t effective;
+	uint32_t permitted;
+	uint32_t inheritable;
+};

This two should probably go to lapi as well.

Ah, but the naming of the original structures is so bad.

typedef struct __user_cap_header_struct {
        ...
} __user *cap_user_header_t.

Well not necessarily bad, but against current naming guidelines. I would rather just use our own definitions and keep them separate from any fallback definitions for test writers.

Quoted 11 lines

include/tst_capability.h line 46

Quoted 6 lines
include/tst_capability.h new file +5 -0
+struct tst_cap {
+	uint32_t action;
+	uint32_t id;
+	char *name;
+};

I wonder if we should build a table of capability names for translation just as we do errnos and signals instead of storing the name here. But I guess that unless we will need a function to translate capabilitities into strings on runtime this approach is simpler.

I suppose if we want to print all the current capabilities then we need this. Which I can imagine would be useful, but I would rather wait until someone actually needs it.

--
Thank you,
Richard.

#5 lore raw

RFC PATCH 1/1 capability: Introduce capability API

In reply to Richard Palethorpe
Quoted 157 lines · Richard Palethorpe
---
 include/tst_capability.h | 56 +++++++++++++++++++++++++++++
 include/tst_test.h       |  6 ++++
 lib/tst_capability.c     | 78 ++++++++++++++++++++++++++++++++++++++++
 lib/tst_test.c           |  3 ++
 4 files changed, 143 insertions(+)
 create mode 100644 include/tst_capability.h
 create mode 100644 lib/tst_capability.c
include/tst_capability.h new file +56 -0
new file mode 100644
index 000000000..6342b667e
@@ -0,0 +1,56 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (c) 2019 Richard Palethorpe <[email protected]>
+ */
+/**
+ * @file tst_capability.h
+ *
+ * Limited capability operations without libcap.
+ */
+
+#include <stdint.h>
+
+#include "lapi/syscalls.h"
+
+#ifndef TST_CAPABILITY_H
+#define TST_CAPABILITY_H
+
+#ifndef CAP_SYS_ADMIN
+# define CAP_SYS_ADMIN        21
+#endif
+
+#ifndef CAP_TO_MASK
+# define CAP_TO_MASK(x)      (1 << ((x) & 31))
+#endif
+
+#define TST_DROP 1
+#define TST_REQUIRE 1 << 1
+
+#define TST_CAP(action, capability) {action, capability, #capability}
+
+struct tst_cap_user_header {
+       uint32_t version;
+       int pid;
+};
+
+struct tst_cap_user_data {
+       uint32_t effective;
+       uint32_t permitted;
+       uint32_t inheritable;
+};
+
+struct tst_cap {
+       uint32_t action;
+       uint32_t id;
+       char *name;
+};
+
+int tst_capget(struct tst_cap_user_header *hdr,
+              struct tst_cap_user_data *data);
+int tst_capset(struct tst_cap_user_header *hdr,
+              const struct tst_cap_user_data *data);
+
+void tst_cap_action(struct tst_cap *cap);
+void tst_cap_setup(struct tst_cap *cap);
+
+#endif
include/tst_test.h +6 -0
index cdeaf6ad0..84acf2c59 100644
@@ -36,6 +36,7 @@
 #include "tst_sys_conf.h"
 #include "tst_coredump.h"
 #include "tst_buffers.h"
+#include "tst_capability.h"
 
 /*
  * Reports testcase result.
@@ -206,6 +207,11 @@ struct tst_test {
         * NULL-terminated array to be allocated buffers.
         */
        struct tst_buffers *bufs;
+
+       /*
+        * NULL-terminated array of capability settings
+        */
+       struct tst_cap *caps;
 };
 
 /*
lib/tst_capability.c new file +55 -0
new file mode 100644
index 000000000..d229491ae
@@ -0,0 +1,78 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (c) 2019 Richard Palethorpe <[email protected]>
+ */
+
+#define TST_NO_DEFAULT_MAIN
+#include "tst_test.h"
+#include "tst_capability.h"
+
+int tst_capget(struct tst_cap_user_header *hdr,
+              struct tst_cap_user_data *data)
+{
+       return tst_syscall(__NR_capget, hdr, data);
+}
+
+int tst_capset(struct tst_cap_user_header *hdr,
+              const struct tst_cap_user_data *data)
+{
+       return tst_syscall(__NR_capset, hdr, data);
+}
+
+void tst_cap_action(struct tst_cap *cap)
+{
+       struct tst_cap_user_header hdr = {
+               .version = 0x20080522,
+               .pid = tst_syscall(__NR_gettid),
+       };
+       struct tst_cap_user_data cur = { 0 };
+       struct tst_cap_user_data new = { 0 };
+       uint32_t mask = CAP_TO_MASK(cap->id);
+       uint32_t act = cap->action;
+
+       if (tst_capget(&hdr, &cur))
+               tst_brk(TBROK | TTERRNO, "tst_capget()");
+
+       new = cur;
+
+       switch (act) {
+       case TST_DROP:
+               if (cur.effective & mask) {
+                       tst_res(TINFO, "Dropping %s(%d)",
+                               cap->name, cap->id);
+                       new.effective &= ~mask;
+                       new.permitted &= ~mask;
+                       new.inheritable &= ~mask;
+               }
+               break;
+       case TST_REQUIRE:
+               if (cur.permitted ^ mask) {
+                       tst_brk(TCONF, "Need %s(%d)",
+                               cap->name, cap->id);
+               } else if (cur.effective ^ mask) {
+                       tst_res(TINFO, "Permitting %s(%d)",
+                               cap->name, cap->id);
+                       new.effective |= mask;

lib/tst_capability.c line 65

Quoted 10 lines
lib/tst_capability.c new file +10 -0
+                       new.inheritable |= mask;
+               }
+               break;
+       default:
+               tst_brk(TBROK, "Unrecognised action %d", cap->action);
+       }
+
+       if (cur.effective != new.effective) {
+               if (tst_capset(&hdr, &new))
+                       tst_brk(TBROK | TERRNO, "tst_capset(%s)", cap->name);

It does not work for this simple cap_test.c, did I miss anything?

# whoami
root
# ./cap_test
tst_test.c:1111: INFO: Timeout per run is 0h 05m 00s
tst_capability.c:42: INFO: Dropping CAP_SYS_ADMIN(21)
tst_capability.c:65: BROK: tst_capset(CAP_SYS_ADMIN): EPERM
# ./cap_test
tst_test.c:1111: INFO: Timeout per run is 0h 05m 00s
tst_capability.c:51: CONF: Need CAP_SYS_ADMIN(21)
# cat cap_test.c
#include "tst_test.h"
#include "linux/capability.h"

static void do_test(void)

{
        tst_res(TPASS, "Hello");
}
static struct tst_test test = {
        .test_all = do_test,
        .needs_root = 1,
        .caps = (struct tst_cap []) {
//                TST_CAP(TST_DROP, CAP_SYS_ADMIN),
                TST_CAP(TST_REQUIRE, CAP_SYS_ADMIN),
                {},
        },
};
Signature · 2 lines
Regards,
Li Wang
#6 lore raw

RFC PATCH 1/1 capability: Introduce capability API

hi,

Quoted 9 lines

It does not work for this simple cap_test.c, did I miss anything?

# whoami
root
# ./cap_test
tst_test.c:1111: INFO: Timeout per run is 0h 05m 00s
tst_capability.c:42: INFO: Dropping CAP_SYS_ADMIN(21)
tst_capability.c:65: BROK: tst_capset(CAP_SYS_ADMIN): EPERM

Not sure why this fails for you.

Quoted 4 lines
# ./cap_test
tst_test.c:1111: INFO: Timeout per run is 0h 05m 00s
tst_capability.c:51: CONF: Need CAP_SYS_ADMIN(21)

Ah, I probably got the binary ops wrong.

Quoted 10 lines
# cat cap_test.c
#include "tst_test.h"
#include "linux/capability.h"

static void do_test(void)

{
        tst_res(TPASS, "Hello");
}
Quoted 9 lines
static struct tst_test test = {
        .test_all = do_test,
        .needs_root = 1,
        .caps = (struct tst_cap []) {
//                TST_CAP(TST_DROP, CAP_SYS_ADMIN),
                TST_CAP(TST_REQUIRE, CAP_SYS_ADMIN),
                {},
        },
};

I will add a test like this, thanks.

Signature · 2 lines
Thank you,
Richard.
#7 lore raw

RFC PATCH 1/1 capability: Introduce capability API

In reply to Li Wang

? 2019/08/15 15:10, Li Wang ??:

Quoted 169 lines · Richard Palethorpe
Quoted 156 lines
---
  include/tst_capability.h | 56 +++++++++++++++++++++++++++++
  include/tst_test.h       |  6 ++++
  lib/tst_capability.c     | 78 ++++++++++++++++++++++++++++++++++++++++
  lib/tst_test.c           |  3 ++
  4 files changed, 143 insertions(+)

create mode 100644 include/tst_capability.h
create mode 100644 lib/tst_capability.c

include/tst_capability.h new file +56 -0
new file mode 100644
index 000000000..6342b667e
@@ -0,0 +1,56 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (c) 2019 Richard Palethorpe<[email protected]>
+ */
+/**
+ * @file tst_capability.h
+ *
+ * Limited capability operations without libcap.
+ */
+
+#include<stdint.h>
+
+#include "lapi/syscalls.h"
+
+#ifndef TST_CAPABILITY_H
+#define TST_CAPABILITY_H
+
+#ifndef CAP_SYS_ADMIN
+# define CAP_SYS_ADMIN        21
+#endif
+
+#ifndef CAP_TO_MASK
+# define CAP_TO_MASK(x)      (1<<  ((x)&  31))
+#endif
+
+#define TST_DROP 1
+#define TST_REQUIRE 1<<  1
+
+#define TST_CAP(action, capability) {action, capability, #capability}
+
+struct tst_cap_user_header {
+       uint32_t version;
+       int pid;
+};
+
+struct tst_cap_user_data {
+       uint32_t effective;
+       uint32_t permitted;
+       uint32_t inheritable;
+};
+
+struct tst_cap {
+       uint32_t action;
+       uint32_t id;
+       char *name;
+};
+
+int tst_capget(struct tst_cap_user_header *hdr,
+              struct tst_cap_user_data *data);
+int tst_capset(struct tst_cap_user_header *hdr,
+              const struct tst_cap_user_data *data);
+
+void tst_cap_action(struct tst_cap *cap);
+void tst_cap_setup(struct tst_cap *cap);
+
+#endif
include/tst_test.h +6 -0
index cdeaf6ad0..84acf2c59 100644
@@ -36,6 +36,7 @@
  #include "tst_sys_conf.h"
  #include "tst_coredump.h"
  #include "tst_buffers.h"
+#include "tst_capability.h"
 
  /*
   * Reports testcase result.
@@ -206,6 +207,11 @@ struct tst_test {
          * NULL-terminated array to be allocated buffers.
          */
         struct tst_buffers *bufs;
+
+       /*
+        * NULL-terminated array of capability settings
+        */
+       struct tst_cap *caps;
  };
 
  /*
lib/tst_capability.c new file +55 -0
new file mode 100644
index 000000000..d229491ae
@@ -0,0 +1,78 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (c) 2019 Richard Palethorpe<[email protected]>
+ */
+
+#define TST_NO_DEFAULT_MAIN
+#include "tst_test.h"
+#include "tst_capability.h"
+
+int tst_capget(struct tst_cap_user_header *hdr,
+              struct tst_cap_user_data *data)
+{
+       return tst_syscall(__NR_capget, hdr, data);
+}
+
+int tst_capset(struct tst_cap_user_header *hdr,
+              const struct tst_cap_user_data *data)
+{
+       return tst_syscall(__NR_capset, hdr, data);
+}
+
+void tst_cap_action(struct tst_cap *cap)
+{
+       struct tst_cap_user_header hdr = {
+               .version = 0x20080522,
+               .pid = tst_syscall(__NR_gettid),
+       };
+       struct tst_cap_user_data cur = { 0 };
+       struct tst_cap_user_data new = { 0 };
+       uint32_t mask = CAP_TO_MASK(cap->id);
+       uint32_t act = cap->action;
+
+       if (tst_capget(&hdr,&cur))
+               tst_brk(TBROK | TTERRNO, "tst_capget()");
+
+       new = cur;
+
+       switch (act) {
+       case TST_DROP:
+               if (cur.effective&  mask) {
+                       tst_res(TINFO, "Dropping %s(%d)",
+                               cap->name, cap->id);
+                       new.effective&= ~mask;
+                       new.permitted&= ~mask;
+                       new.inheritable&= ~mask;
+               }
+               break;
+       case TST_REQUIRE:
+               if (cur.permitted ^ mask) {
+                       tst_brk(TCONF, "Need %s(%d)",
+                               cap->name, cap->id);
+               } else if (cur.effective ^ mask) {
+                       tst_res(TINFO, "Permitting %s(%d)",
+                               cap->name, cap->id);
+                       new.effective |= mask;

lib/tst_capability.c line 65

Quoted 10 lines
lib/tst_capability.c new file +10 -0
+                       new.inheritable |= mask;
+               }
+               break;
+       default:
+               tst_brk(TBROK, "Unrecognised action %d", cap->action);
+       }
+
+       if (cur.effective != new.effective) {
+               if (tst_capset(&hdr,&new))
+                       tst_brk(TBROK | TERRNO, "tst_capset(%s)", cap->name);

It does not work for this simple cap_test.c, did I miss anything?

Quoted 8 lines
# whoami
root
# ./cap_test
tst_test.c:1111: INFO: Timeout per run is 0h 05m 00s
tst_capability.c:42: INFO: Dropping CAP_SYS_ADMIN(21)
tst_capability.c:65: BROK: tst_capset(CAP_SYS_ADMIN): EPERM

Hi Li
I have tried it and have the same failure. The _LINUX_CAPABILITY_VERSION_3 seem not support on my system causes fail. If I use _LINUX_CAPABILITY_VERSION_1, cap_test will pass. I am still looking into _LINUX_CAPABILITY_VERSION_3 dependence.

Quoted 23 lines
# ./cap_test
tst_test.c:1111: INFO: Timeout per run is 0h 05m 00s
tst_capability.c:51: CONF: Need CAP_SYS_ADMIN(21)
# cat cap_test.c
#include "tst_test.h"
#include "linux/capability.h"

static void do_test(void)

{
         tst_res(TPASS, "Hello");
}
static struct tst_test test = {
         .test_all = do_test,
         .needs_root = 1,
         .caps = (struct tst_cap []) {
//                TST_CAP(TST_DROP, CAP_SYS_ADMIN),
                 TST_CAP(TST_REQUIRE, CAP_SYS_ADMIN),
                 {},
         },
};
#8 lore raw

RFC PATCH 1/1 capability: Introduce capability API

In reply to Richard Palethorpe
Quoted 118 lines · Richard Palethorpe
---
  include/tst_capability.h | 56 +++++++++++++++++++++++++++++
  include/tst_test.h       |  6 ++++
  lib/tst_capability.c     | 78 ++++++++++++++++++++++++++++++++++++++++
  lib/tst_test.c           |  3 ++
  4 files changed, 143 insertions(+)

create mode 100644 include/tst_capability.h
create mode 100644 lib/tst_capability.c

include/tst_capability.h new file +56 -0
new file mode 100644
index 000000000..6342b667e
@@ -0,0 +1,56 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (c) 2019 Richard Palethorpe<[email protected]>
+ */
+/**
+ * @file tst_capability.h
+ *
+ * Limited capability operations without libcap.
+ */
+
+#include<stdint.h>
+
+#include "lapi/syscalls.h"
+
+#ifndef TST_CAPABILITY_H
+#define TST_CAPABILITY_H
+
+#ifndef CAP_SYS_ADMIN
+# define CAP_SYS_ADMIN        21
+#endif
+
+#ifndef CAP_TO_MASK
+# define CAP_TO_MASK(x)      (1<<  ((x)&  31))
+#endif
+
+#define TST_DROP 1
+#define TST_REQUIRE 1<<  1
+
+#define TST_CAP(action, capability) {action, capability, #capability}
+
+struct tst_cap_user_header {
+	uint32_t version;
+	int pid;
+};
+
+struct tst_cap_user_data {
+	uint32_t effective;
+	uint32_t permitted;
+	uint32_t inheritable;
+};
+
+struct tst_cap {
+	uint32_t action;
+	uint32_t id;
+	char *name;
+};
+
+int tst_capget(struct tst_cap_user_header *hdr,
+	       struct tst_cap_user_data *data);
+int tst_capset(struct tst_cap_user_header *hdr,
+	       const struct tst_cap_user_data *data);
+
+void tst_cap_action(struct tst_cap *cap);
+void tst_cap_setup(struct tst_cap *cap);
+
+#endif
include/tst_test.h +6 -0
index cdeaf6ad0..84acf2c59 100644
@@ -36,6 +36,7 @@
  #include "tst_sys_conf.h"
  #include "tst_coredump.h"
  #include "tst_buffers.h"
+#include "tst_capability.h"
 
  /*
   * Reports testcase result.
@@ -206,6 +207,11 @@ struct tst_test {
  	 * NULL-terminated array to be allocated buffers.
  	 */
  	struct tst_buffers *bufs;
+
+	/*
+	 * NULL-terminated array of capability settings
+	 */
+	struct tst_cap *caps;
  };
 
  /*
lib/tst_capability.c new file +17 -0
new file mode 100644
index 000000000..d229491ae
@@ -0,0 +1,78 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (c) 2019 Richard Palethorpe<[email protected]>
+ */
+
+#define TST_NO_DEFAULT_MAIN
+#include "tst_test.h"
+#include "tst_capability.h"
+
+int tst_capget(struct tst_cap_user_header *hdr,
+	       struct tst_cap_user_data *data)
+{
+	return tst_syscall(__NR_capget, hdr, data);
+}
+
+int tst_capset(struct tst_cap_user_header *hdr,
+	       const struct tst_cap_user_data *data)

lib/tst_capability.c line 27

Quoted 10 lines
lib/tst_capability.c new file +10 -0
+{
+	return tst_syscall(__NR_capset, hdr, data);
+}
+
+void tst_cap_action(struct tst_cap *cap)
+{
+	struct tst_cap_user_header hdr = {
+		.version = 0x20080522,
+		.pid = tst_syscall(__NR_gettid),
+	};

Hi Richard

If we use _LINUX_CAPABILITY_VERSION_1, kernel will report the following warning: `cap_test' uses 32-bit capabilities (legacy support in use)

_LINUX_CAPABILITY_VERSION_2 has been deprecated since kernel 2.6.25, so we can only use _LINUX_CAPABILITY_VERSION_3.

But _LINUX_CAPABILITY_VERSION_3 uses 64-bit capabilities as man-page said, effective defined as uint32_t in tst_cap_usr_data is not enough. I guess we need to define cur[2] ,new[2] and compare. Also, it can slove the EPERM failure as Li wang's cap_test.c found.

ps: I changed kernel code to track this problem.

security/commoncap.c +12 -5
index f4ee0ae106b2..291eb4e71031 100644
@@ -247,24 +247,31 @@ int cap_capset(struct cred *new,
         if (cap_inh_is_capped()&&
             !cap_issubset(*inheritable,
                           cap_combine(old->cap_inheritable,
-                                     old->cap_permitted)))
+                                     old->cap_permitted))) {
                 /* incapable of using this inheritable set */
+               printk("xuyang 0\n");
                 return -EPERM;
+       }
 
         if (!cap_issubset(*inheritable,
                           cap_combine(old->cap_inheritable,
-                                     old->cap_bset)))
+                                     old->cap_bset))) {
                 /* no new pI capabilities outside bounding set */
+               printk("xuyang 1\n");
                 return -EPERM;
+       }
 
         /* verify restrictions on target's new Permitted set */
-       if (!cap_issubset(*permitted, old->cap_permitted))
+       if (!cap_issubset(*permitted, old->cap_permitted)) {
+               printk("xuyang  2\n");
                 return -EPERM;
+       }
 
         /* verify the _new_Effective_ is a subset of the _new_Permitted_ */
-       if (!cap_issubset(*effective, *permitted))
+       if (!cap_issubset(*effective, *permitted)) {
+               printk("xuyang 3\n");
                 return -EPERM;
-
+       }
         new->cap_effective   = *effective;
         new->cap_inheritable = *inheritable;
 

#./cap_test (dmesg will report "xuyang 3",return EPERM if use version 3)

Thanks
Yang Xu

Quoted 65 lines
lib/tst_capability.c new file +51 -0
+	struct tst_cap_user_data cur = { 0 };
+	struct tst_cap_user_data new = { 0 };
+	uint32_t mask = CAP_TO_MASK(cap->id);
+	uint32_t act = cap->action;
+
+	if (tst_capget(&hdr,&cur))
+		tst_brk(TBROK | TTERRNO, "tst_capget()");
+
+	new = cur;
+
+	switch (act) {
+	case TST_DROP:
+		if (cur.effective&  mask) {
+			tst_res(TINFO, "Dropping %s(%d)",
+				cap->name, cap->id);
+			new.effective&= ~mask;
+			new.permitted&= ~mask;
+			new.inheritable&= ~mask;
+		}
+		break;
+	case TST_REQUIRE:
+		if (cur.permitted ^ mask) {
+			tst_brk(TCONF, "Need %s(%d)",
+				cap->name, cap->id);
+		} else if (cur.effective ^ mask) {
+			tst_res(TINFO, "Permitting %s(%d)",
+				cap->name, cap->id);
+			new.effective |= mask;
+			new.inheritable |= mask;
+		}
+		break;
+	default:
+		tst_brk(TBROK, "Unrecognised action %d", cap->action);
+	}
+
+	if (cur.effective != new.effective) {
+		if (tst_capset(&hdr,&new))
+			tst_brk(TBROK | TERRNO, "tst_capset(%s)", cap->name);
+	} else {
+		tst_res(TINFO, "No capability changes needed");
+	}
+}
+
+void tst_cap_setup(struct tst_cap *caps)
+{
+	struct tst_cap *cap;
+
+	for (cap = caps; cap->action; cap++) {
+		tst_cap_action(cap);
+	}
+}
lib/tst_test.c +3 -0
index 8dc71dbb3..62e54d071 100644
@@ -893,6 +893,9 @@ static void do_test_setup(void)
 
  	if (main_pid != getpid())
  		tst_brk(TBROK, "Runaway child in setup()!");
+
+	if (tst_test->caps)
+		tst_cap_setup(tst_test->caps);
  }
 
  static void do_cleanup(void)
#9 lore raw

RFC PATCH 1/1 capability: Introduce capability API

Hello,

Quoted 52 lines

Hi Richard

If we use _LINUX_CAPABILITY_VERSION_1, kernel will report the following warning: `cap_test' uses 32-bit capabilities (legacy support in use)

_LINUX_CAPABILITY_VERSION_2 has been deprecated since kernel 2.6.25, so we can only use _LINUX_CAPABILITY_VERSION_3.

But _LINUX_CAPABILITY_VERSION_3 uses 64-bit capabilities as man-page said, effective defined as uint32_t in tst_cap_usr_data is not enough. I guess we need to define cur[2] ,new[2] and compare. Also, it can slove the EPERM failure as Li wang's cap_test.c found.
ps: I changed kernel code to track this problem.

security/commoncap.c +12 -5
index f4ee0ae106b2..291eb4e71031 100644
@@ -247,24 +247,31 @@ int cap_capset(struct cred *new,
        if (cap_inh_is_capped()&&
            !cap_issubset(*inheritable,
                          cap_combine(old->cap_inheritable,
-                                     old->cap_permitted)))
+                                     old->cap_permitted))) {
                /* incapable of using this inheritable set */
+               printk("xuyang 0\n");
                return -EPERM;
+       }
 
        if (!cap_issubset(*inheritable,
                          cap_combine(old->cap_inheritable,
-                                     old->cap_bset)))
+                                     old->cap_bset))) {
                /* no new pI capabilities outside bounding set */
+               printk("xuyang 1\n");
                return -EPERM;
+       }
 
        /* verify restrictions on target's new Permitted set */
-       if (!cap_issubset(*permitted, old->cap_permitted))
+       if (!cap_issubset(*permitted, old->cap_permitted)) {
+               printk("xuyang  2\n");
                return -EPERM;
+       }
 
        /* verify the _new_Effective_ is a subset of the _new_Permitted_ */
-       if (!cap_issubset(*effective, *permitted))
+       if (!cap_issubset(*effective, *permitted)) {
+               printk("xuyang 3\n");
                return -EPERM;
-
+       }
        new->cap_effective   = *effective;
        new->cap_inheritable = *inheritable;
 

#./cap_test (dmesg will report "xuyang 3",return EPERM if use version 3)

Quoted 2 lines

Thanks
Yang Xu

Yes, sorry I should have said earlier. I am converting it to use 64bit capabilities. Also I have created some tests for this and will try to use the upper bits.

Signature · 2 lines
Thank you,
Richard.
#10 lore raw

PATCH v2 1/2 capability: Introduce capability API

In reply to Richard Palethorpe

Allow users to easily ensure particular capabilities are either present or not present during testing without requiring libcap.

---

V2:
* Add docs
* Support 64bit capabilities
* Restructure code in various ways
* Only try to change the effective set. Inheritable has too many issues.
* Add tests

It occurred to me that if the user wants to spawn child processes then they will either need to run as root or we need to do something quite complex. On my system I am not able to set anything in the inheritable set as a normal user and I don't know about ambient capabilities. These are set through a different API, so we should consider carefully if we want to try support setting those. Especially as it may just fail on most setups.

For the most part this is just useful for dropping CAP_SYS_ADMIN or failing with a more accurate error message than "needs root".

 doc/test-writing-guidelines.txt |  78 ++++++++++++++++++++++
 include/lapi/capability.h       |  27 ++++++++
 include/tst_capability.h        |  48 ++++++++++++++
 include/tst_test.h              |   6 ++
 lib/tst_capability.c            | 110 ++++++++++++++++++++++++++++++++
 lib/tst_test.c                  |   3 +
 6 files changed, 272 insertions(+)
 create mode 100644 include/lapi/capability.h
 create mode 100644 include/tst_capability.h
 create mode 100644 lib/tst_capability.c
doc/test-writing-guidelines.txt +78 -0
index 573dd08d9..e4463a443 100644
@@ -1699,6 +1699,84 @@ struct tst_test test = {
 };
 -------------------------------------------------------------------------------
 
+2.2.31 Adding and removing capabilities
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Some tests may require the presence or absence of particular
+capabilities. Using the API provided by 'tst_capability.h' the test author can
+try to ensure that some capabilities are either present or absent during the
+test.
+
+For example; below we try to create a raw socket, which requires
+CAP_NET_ADMIN. During setup we should be able to do it, then during run it
+should be impossible. The LTP capability library should drop CAP_NET_RAW
+(assuming we have it) after setup completes.
+
+[source,c]
+--------------------------------------------------------------------------------
+#include "tst_test.h"
+#include "tst_capability.h"
+#include "tst_safe_net.h"
+
+#include "lapi/socket.h"
+
+static void run(void)
+{
+	TEST(socket(AF_INET, SOCK_RAW, 1));
+	if (TST_RET > -1) {
+		tst_res(TFAIL, "Created raw socket");
+	} else if (TST_ERR != EPERM) {
+		tst_res(TBROK | TTERRNO,
+			"Failed to create socket for wrong reason");
+	} else {
+		tst_res(TPASS | TTERRNO, "Didn't create raw socket");
+	}
+}
+
+static void setup(void)
+{
+	TEST(socket(AF_INET, SOCK_RAW, 1));
+	if (TST_RET < 0)
+		tst_brk(TCONF | TTERRNO, "We don't have CAP_NET_RAW to begin with");
+
+	SAFE_CLOSE(TST_RET);
+}
+
+static struct tst_test test = {
+	.setup = setup,
+	.test_all = run,
+	.caps = (struct tst_cap []) {
+		TST_CAP(TST_CAP_DROP, CAP_NET_RAW),
+		{}
+	},
+};
+--------------------------------------------------------------------------------
+
+Look at the test struct@the bottom. We have filled in the 'caps' field with
+a NULL terminated array containing a single 'tst_cap'. This indicates to the
+library that we should drop CAP_NET_RAW if we have it. The capability will be
+dropped in between 'setup' and 'run'.
+
+[source,c]
+--------------------------------------------------------------------------------
+static struct tst_test test = {
+	.test_all = run,
+	.caps = (struct tst_cap []) {
+		TST_CAP(TST_CAP_REQ, CAP_NET_RAW),
+		TST_CAP(TST_CAP_DROP, CAP_SYS_ADMIN),
+		{}
+	},
+};
+--------------------------------------------------------------------------------
+
+Here we request 'CAP_NET_RAW', but drop 'CAP_SYS_ADMIN'. If the capability is
+in the permitted set, but not the effective set, the library will try to
+permit it. If it is not in the permitted set, then it will fail with 'TCONF'.
+
+This API does not require 'libcap' to be installed. However it has limited
+features relative to 'libcap'. It only tries to add or remove capabilities
+from the effective set. This means that tests which need to spawn child
+processes with various capabilities will probably need 'libcap'.
 
 2.3 Writing a testcase in shell
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
include/lapi/capability.h new file +27 -0
new file mode 100644
index 000000000..02d7a9fda
@@ -0,0 +1,27 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (c) 2019 Richard Palethorpe <[email protected]>
+ */
+
+#ifndef LAPI_CAPABILITY_H
+#define LAPI_CAPABILITY_H
+
+#include "config.h"
+
+#ifdef HAVE_SYS_CAPABILITY_H
+# include <sys/capability.h>
+#endif
+
+#ifndef CAP_SYS_ADMIN
+# define CAP_SYS_ADMIN        21
+#endif
+
+#ifndef CAP_TO_INDEX
+# define CAP_TO_INDEX(x)     ((x) >> 5)
+#endif
+
+#ifndef CAP_TO_MASK
+# define CAP_TO_MASK(x)      (1 << ((x) & 31))
+#endif
+
+#endif
include/tst_capability.h new file +48 -0

48 lines not on this page · raw message

include/tst_test.h +6 -0
index 2e07ff16b..6eb558396 100644
@@ -35,6 +35,7 @@
 #include "tst_path_has_mnt_flags.h"
 #include "tst_sys_conf.h"
 #include "tst_coredump.h"
+#include "tst_capability.h"
 
 /*
  * Reports testcase result.
@@ -200,6 +201,11 @@ struct tst_test {
 	 * test.
 	 */
 	const char *const *needs_kconfigs;
+
+	/*
+	 * NULL-terminated array of capability settings
+	 */
+	struct tst_cap *caps;
 };
 
 /*
lib/tst_capability.c new file +110 -0

110 lines not on this page · raw message

lib/tst_test.c +3 -0
index 245e287fa..8d5fbd1f9 100644
@@ -888,6 +888,9 @@ static void do_test_setup(void)
 
 	if (main_pid != getpid())
 		tst_brk(TBROK, "Runaway child in setup()!");
+
+	if (tst_test->caps)
+		tst_cap_setup(tst_test->caps);
 }
 
 static void do_cleanup(void)
Signature · 1 line
2.22.0
#11 lore raw

PATCH v2 2/2 capability: library tests

---
 include/lapi/capability.h           |  8 +++++
 lib/newlib_tests/tst_capability01.c | 50 +++++++++++++++++++++++++++++
 lib/newlib_tests/tst_capability02.c | 35 ++++++++++++++++++++
 3 files changed, 93 insertions(+)
 create mode 100644 lib/newlib_tests/tst_capability01.c
 create mode 100644 lib/newlib_tests/tst_capability02.c
include/lapi/capability.h +8 -0
index 02d7a9fda..dac233d84 100644
@@ -12,10 +12,18 @@
 # include <sys/capability.h>
 #endif
 
+#ifndef CAP_NET_RAW
+# define CAP_NET_RAW          13
+#endif
+
 #ifndef CAP_SYS_ADMIN
 # define CAP_SYS_ADMIN        21
 #endif
 
+#ifndef CAP_AUDIT_READ
+# define CAP_AUDIT_READ       37
+#endif
+
 #ifndef CAP_TO_INDEX
 # define CAP_TO_INDEX(x)     ((x) >> 5)
 #endif
lib/newlib_tests/tst_capability01.c new file +50 -0

50 lines not on this page · raw message

lib/newlib_tests/tst_capability02.c new file +35 -0
new file mode 100644
index 000000000..45e3f2d22
@@ -0,0 +1,35 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (c) 2019 Richard Palethorpe <[email protected]>
+ */
+
+#include <unistd.h>
+#include <sys/types.h>
+
+#include "tst_test.h"
+#include "tst_capability.h"
+#include "tst_safe_net.h"
+
+#include "lapi/socket.h"
+
+static void run(void)
+{
+	TEST(socket(AF_INET, SOCK_RAW, 1));
+	if (TST_RET > -1) {
+		tst_res(TPASS, "Created raw socket");
+		SAFE_CLOSE(TST_RET);
+	} else {
+		tst_res(TFAIL | TTERRNO, "Didn't create raw socket");
+	}
+}
+
+static struct tst_test test = {
+	.test_all = run,
+	.needs_root = 1,
+	.caps = (struct tst_cap []) {
+		TST_CAP(TST_CAP_REQ, CAP_NET_RAW),
+		TST_CAP(TST_CAP_DROP, CAP_AUDIT_READ), /* 64bit capability */
+		TST_CAP(TST_CAP_DROP, CAP_SYS_ADMIN),
+		{}
+	},
+};
Signature · 1 line
2.22.0
#12 lore raw

PATCH v2 2/2 capability: library tests

Quoted 18 lines · Richard Palethorpe
lib/newlib_tests/tst_capability01.c new file +12 -0
new file mode 100644
index 000000000..1a9cb0568
@@ -0,0 +1,50 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (c) 2019 Richard Palethorpe<[email protected]>
+ *
+ * The user or file requires CAP_NET_RAW for this test to work.
+ * e.g use "$ setcap cap_net_raw=pei tst_capability"
+ */
+
+#include<unistd.h>
+#include<sys/types.h>
+
+#include "tst_test.h"

lib/newlib_tests/tst_capability01.c line 22

Quoted 10 lines
lib/newlib_tests/tst_capability01.c new file +10 -0
+#include "tst_capability.h"
+#include "tst_safe_net.h"
+
+#include "lapi/socket.h"
+
+static void run(void)
+{
+	TEST(socket(AF_INET, SOCK_RAW, 1));
+	if (TST_RET>  -1) {
+		tst_res(TFAIL, "Created raw socket");
                         SAFE_CLOSE(TST_RET);
Quoted 8 lines
lib/newlib_tests/tst_capability01.c new file +8 -0
+	} else if (TST_ERR != EPERM) {
+		tst_res(TBROK | TTERRNO,
+			"Failed to create socket for wrong reason");
+	} else {
+		tst_res(TPASS | TTERRNO, "Didn't create raw socket");
+	}
+}
+
#13 lore raw

PATCH v2 1/2 capability: Introduce capability API

In reply to Richard Palethorpe
Quoted 39 lines · Richard Palethorpe

Allow users to easily ensure particular capabilities are either present or not present during testing without requiring libcap.

---

V2:
* Add docs
* Support 64bit capabilities
* Restructure code in various ways
* Only try to change the effective set. Inheritable has too many issues.
* Add tests

It occurred to me that if the user wants to spawn child processes then they will either need to run as root or we need to do something quite complex. On my system I am not able to set anything in the inheritable set as a normal user and I don't know about ambient capabilities. These are set through a different API, so we should consider carefully if we want to try support setting those. Especially as it may just fail on most setups.

For the most part this is just useful for dropping CAP_SYS_ADMIN or failing with a more accurate error message than "needs root".

  doc/test-writing-guidelines.txt |  78 ++++++++++++++++++++++
  include/lapi/capability.h       |  27 ++++++++
  include/tst_capability.h        |  48 ++++++++++++++
  include/tst_test.h              |   6 ++
  lib/tst_capability.c            | 110 ++++++++++++++++++++++++++++++++
  lib/tst_test.c                  |   3 +
  6 files changed, 272 insertions(+)

create mode 100644 include/lapi/capability.h
create mode 100644 include/tst_capability.h
create mode 100644 lib/tst_capability.c

doc/test-writing-guidelines.txt +0 -0
index 573dd08d9..e4463a443 100644

doc/test-writing-guidelines.txt struct tst_test test = { · line 1703

Quoted 5 lines
doc/test-writing-guidelines.txt +2 -0
@@ -1699,6 +1699,84 @@ struct tst_test test = {
  };
  -------------------------------------------------------------------------------
 
+2.2.31 Adding and removing capabilities
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

As Jan Stancek said, it should be rebased on lastest master.

Quoted 14 lines
doc/test-writing-guidelines.txt +14 -0
+
+Some tests may require the presence or absence of particular
+capabilities. Using the API provided by 'tst_capability.h' the test author can
+try to ensure that some capabilities are either present or absent during the
+test.
+
+For example; below we try to create a raw socket, which requires
+CAP_NET_ADMIN. During setup we should be able to do it, then during run it
+should be impossible. The LTP capability library should drop CAP_NET_RAW
+(assuming we have it) after setup completes.
+
+[source,c]
+--------------------------------------------------------------------------------
+#include "tst_test.h"

doc/test-writing-guidelines.txt struct tst_test test = { · line 1727

Quoted 10 lines
doc/test-writing-guidelines.txt +10 -0
+#include "tst_capability.h"
+#include "tst_safe_net.h"
+
+#include "lapi/socket.h"
+
+static void run(void)
+{
+	TEST(socket(AF_INET, SOCK_RAW, 1));
+	if (TST_RET>  -1) {
+		tst_res(TFAIL, "Created raw socket");
                             SAFE_CLOSE(TST_RET);
Quoted 206 lines
doc/test-writing-guidelines.txt +52 -0
+	} else if (TST_ERR != EPERM) {
+		tst_res(TBROK | TTERRNO,
+			"Failed to create socket for wrong reason");
+	} else {
+		tst_res(TPASS | TTERRNO, "Didn't create raw socket");
+	}
+}
+
+static void setup(void)
+{
+	TEST(socket(AF_INET, SOCK_RAW, 1));
+	if (TST_RET<  0)
+		tst_brk(TCONF | TTERRNO, "We don't have CAP_NET_RAW to begin with");
+
+	SAFE_CLOSE(TST_RET);
+}
+
+static struct tst_test test = {
+	.setup = setup,
+	.test_all = run,
+	.caps = (struct tst_cap []) {
+		TST_CAP(TST_CAP_DROP, CAP_NET_RAW),
+		{}
+	},
+};
+--------------------------------------------------------------------------------
+
+Look at the test struct at the bottom. We have filled in the 'caps' field with
+a NULL terminated array containing a single 'tst_cap'. This indicates to the
+library that we should drop CAP_NET_RAW if we have it. The capability will be
+dropped in between 'setup' and 'run'.
+
+[source,c]
+--------------------------------------------------------------------------------
+static struct tst_test test = {
+	.test_all = run,
+	.caps = (struct tst_cap []) {
+		TST_CAP(TST_CAP_REQ, CAP_NET_RAW),
+		TST_CAP(TST_CAP_DROP, CAP_SYS_ADMIN),
+		{}
+	},
+};
+--------------------------------------------------------------------------------
+
+Here we request 'CAP_NET_RAW', but drop 'CAP_SYS_ADMIN'. If the capability is
+in the permitted set, but not the effective set, the library will try to
+permit it. If it is not in the permitted set, then it will fail with 'TCONF'.
+
+This API does not require 'libcap' to be installed. However it has limited
+features relative to 'libcap'. It only tries to add or remove capabilities
+from the effective set. This means that tests which need to spawn child
+processes with various capabilities will probably need 'libcap'.
 
  2.3 Writing a testcase in shell
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
include/lapi/capability.h new file +27 -0
new file mode 100644
index 000000000..02d7a9fda
@@ -0,0 +1,27 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (c) 2019 Richard Palethorpe<[email protected]>
+ */
+
+#ifndef LAPI_CAPABILITY_H
+#define LAPI_CAPABILITY_H
+
+#include "config.h"
+
+#ifdef HAVE_SYS_CAPABILITY_H
+# include<sys/capability.h>
+#endif
+
+#ifndef CAP_SYS_ADMIN
+# define CAP_SYS_ADMIN        21
+#endif
+
+#ifndef CAP_TO_INDEX
+# define CAP_TO_INDEX(x)     ((x)>>  5)
+#endif
+
+#ifndef CAP_TO_MASK
+# define CAP_TO_MASK(x)      (1<<  ((x)&  31))
+#endif
+
+#endif
include/tst_capability.h new file +48 -0
new file mode 100644
index 000000000..396679f2e
@@ -0,0 +1,48 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (c) 2019 Richard Palethorpe<[email protected]>
+ */
+/**
+ * @file tst_capability.h
+ *
+ * Limited capability operations without libcap.
+ */
+
+#ifndef TST_CAPABILITY_H
+#define TST_CAPABILITY_H
+
+#include<stdint.h>
+
+#include "lapi/capability.h"
+
+#define TST_CAP_DROP 1
+#define TST_CAP_REQ  1<<  1
+
+#define TST_CAP(action, capability) {action, capability, #capability}
+
+struct tst_cap_user_header {
+	uint32_t version;
+	int pid;
+};
+
+struct tst_cap_user_data {
+	uint32_t effective;
+	uint32_t permitted;
+	uint32_t inheritable;
+};
+
+struct tst_cap {
+	uint32_t action;
+	uint32_t id;
+	char *name;
+};
+
+int tst_capget(struct tst_cap_user_header *hdr,
+	       struct tst_cap_user_data *data);
+int tst_capset(struct tst_cap_user_header *hdr,
+	       const struct tst_cap_user_data *data);
+
+void tst_cap_action(struct tst_cap *cap);
+void tst_cap_setup(struct tst_cap *cap);
+
+#endif
include/tst_test.h +6 -0
index 2e07ff16b..6eb558396 100644
@@ -35,6 +35,7 @@
  #include "tst_path_has_mnt_flags.h"
  #include "tst_sys_conf.h"
  #include "tst_coredump.h"
+#include "tst_capability.h"
 
  /*
   * Reports testcase result.
@@ -200,6 +201,11 @@ struct tst_test {
  	 * test.
  	 */
  	const char *const *needs_kconfigs;
+
+	/*
+	 * NULL-terminated array of capability settings
+	 */
+	struct tst_cap *caps;
  };
 
  /*
lib/tst_capability.c new file +34 -0
new file mode 100644
index 000000000..7e6c56e1d
@@ -0,0 +1,110 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (c) 2019 Richard Palethorpe<[email protected]>
+ */
+
+#include<string.h>
+
+#define TST_NO_DEFAULT_MAIN
+#include "tst_test.h"
+#include "tst_capability.h"
+
+#include "lapi/syscalls.h"
+
+/**
+ * Get the capabilities as decided by hdr.
+ *
+ * Note that the memory pointed to by data should be large enough to store two
+ * structs.
+ */
+int tst_capget(struct tst_cap_user_header *hdr,
+	       struct tst_cap_user_data *data)
+{
+	return tst_syscall(__NR_capget, hdr, data);
+}
+
+/**
+ * Set the capabilities as decided by hdr and data
+ *
+ * Note that the memory pointed to by data should be large enough to store two
+ * structs.
+ */
+int tst_capset(struct tst_cap_user_header *hdr,
+	       const struct tst_cap_user_data *data)
+{

lib/tst_capability.c line 44

Quoted 10 lines
lib/tst_capability.c new file +10 -0
+	return tst_syscall(__NR_capset, hdr, data);
+}
+
+static void do_cap_drop(uint32_t *set, uint32_t mask, const struct tst_cap *cap)
+{
+	if (*set&  mask) {
+		tst_res(TINFO, "Dropping %s(%d)", cap->name, cap->id);
+		*set&= ~mask;
+	}
+}

If we drop a cap twice, the second drop reports nothing. I think we should print it as below:

as below:

@ -40,7 +40,10 @@ static void do_cap_drop(uint32_t *set, uint32_t mask, const struct tst_cap *cap)

	if (*set&  mask) {
		tst_res(TINFO, "Dropping %s(%d)", cap->name, cap->id);
		*set&= ~mask;

- }
+ } else
+ tst_res(TINFO,
+ "%s(%d) has not been in effective set before dropping",
+ cap->name, cap->id);

lib/tst_capability.c line 50

Quoted 6 lines
lib/tst_capability.c new file +6 -0
+
+static void do_cap_req(uint32_t *set, uint32_t mask, const struct tst_cap *cap)
+{
+	if (!(*set&  mask))
+		tst_brk(TCONF, "Need %s(%d)", cap->name, cap->id);
+

here has logic problem. :-) If set has not the cap, we should use set |mask instead of tst_brk.

code should be as below:

            if ((*set&  mask)) {
                  tst_res(TINFO,
                        "%s(%d) has been in effective set before requring",
                        cap->name, cap->id);
                return;
        } else {
                 tst_res(TINFO, "Permitting %s(%d)", cap->name, cap->id);
                 *set |= mask;

         }
Quoted 65 lines
lib/tst_capability.c new file +60 -0
+	if (!(*set&  mask)) {
+		tst_res(TINFO, "Permitting %s(%d)", cap->name, cap->id);
+		*set |= mask;
+	}
+}
+
+/**
+ * Add, check or remove capabilities
+ *
+ * Takes a NULL terminated array of structs which describe whether some
+ * capabilities are needed or not.
+ *
+ * It will attempt to drop or add capabilities to the effective set. It will
+ * try to detect if this is needed and whether it can or can't be done. If it
+ * clearly can not add a privilege to the effective set then it will return
+ * TCONF. However it may fail for some other reason and return TBROK.
+ *
+ * This only tries to change the effective set. Some tests may need to change
+ * the inheritable and ambient sets, so that child processes retain some
+ * capability.
+ */
+void tst_cap_action(struct tst_cap *cap)
+{
+	struct tst_cap_user_header hdr = {
+		.version = 0x20080522,
+		.pid = tst_syscall(__NR_gettid),
+	};
+	struct tst_cap_user_data cur[2] = { {0} };
+	struct tst_cap_user_data new[2] = { {0} };
+	uint32_t act = cap->action;
+	uint32_t *set =&new[CAP_TO_INDEX(cap->id)].effective;
+	uint32_t mask = CAP_TO_MASK(cap->id);
+
+	if (tst_capget(&hdr, cur))
+		tst_brk(TBROK | TTERRNO, "tst_capget()");
+
+	memcpy(new, cur, sizeof(new));
+
+	switch (act) {
+	case TST_CAP_DROP:
+		do_cap_drop(set, mask, cap);
+		break;
+	case TST_CAP_REQ:
+		do_cap_req(set, mask, cap);
+		break;
+	default:
+		tst_brk(TBROK, "Unrecognised action %d", cap->action);
+	}
+
+	if (memcmp(cur, new, sizeof(new))&&  tst_capset(&hdr, new))
+		tst_brk(TBROK | TERRNO, "tst_capset(%s)", cap->name);
+}
+
+void tst_cap_setup(struct tst_cap *caps)
+{
+	struct tst_cap *cap;
+
+	for (cap = caps; cap->action; cap++)
+		tst_cap_action(cap);
+}
lib/tst_test.c +0 -0
index 245e287fa..8d5fbd1f9 100644

lib/tst_test.c static void do_test_setup(void) · line 896

Quoted 9 lines
lib/tst_test.c +3 -0
@@ -888,6 +888,9 @@ static void do_test_setup(void)
 
  	if (main_pid != getpid())
  		tst_brk(TBROK, "Runaway child in setup()!");
+
+	if (tst_test->caps)
+		tst_cap_setup(tst_test->caps);
  }
 
  static void do_cleanup(void)

other than the minor things, this patch looks ok.

#14 lore raw

PATCH v2 1/2 capability: Introduce capability API

Hello,

Quoted 61 lines · Yang Xu
Quoted 40 lines · Richard Palethorpe
lib/tst_capability.c new file +34 -0
new file mode 100644
index 000000000..7e6c56e1d
@@ -0,0 +1,110 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (c) 2019 Richard Palethorpe<[email protected]>
+ */
+
+#include<string.h>
+
+#define TST_NO_DEFAULT_MAIN
+#include "tst_test.h"
+#include "tst_capability.h"
+
+#include "lapi/syscalls.h"
+
+/**
+ * Get the capabilities as decided by hdr.
+ *
+ * Note that the memory pointed to by data should be large enough to store two
+ * structs.
+ */
+int tst_capget(struct tst_cap_user_header *hdr,
+	       struct tst_cap_user_data *data)
+{
+	return tst_syscall(__NR_capget, hdr, data);
+}
+
+/**
+ * Set the capabilities as decided by hdr and data
+ *
+ * Note that the memory pointed to by data should be large enough to store two
+ * structs.
+ */
+int tst_capset(struct tst_cap_user_header *hdr,
+	       const struct tst_cap_user_data *data)
+{

lib/tst_capability.c line 44

Quoted 10 lines
lib/tst_capability.c new file +10 -0
+	return tst_syscall(__NR_capset, hdr, data);
+}
+
+static void do_cap_drop(uint32_t *set, uint32_t mask, const struct tst_cap *cap)
+{
+	if (*set&  mask) {
+		tst_res(TINFO, "Dropping %s(%d)", cap->name, cap->id);
+		*set&= ~mask;
+	}
+}

If we drop a cap twice, the second drop reports nothing. I think we should print it as below:

as below:

@ -40,7 +40,10 @@ static void do_cap_drop(uint32_t *set, uint32_t mask, const struct tst_cap *cap)

	if (*set&  mask) {
		tst_res(TINFO, "Dropping %s(%d)", cap->name, cap->id);
		*set&= ~mask;

Review

Quoted 5 lines
(quoted diff) +4 -1
-       }
+       } else
+               tst_res(TINFO,
+                       "%s(%d) has not been in effective set before dropping",
+                       cap->name, cap->id);

I think it should only print something if an action is required. Stating that we already have or don't have a capability is noise. If it prints nothing this tells the user the same thing.

Quoted 10 lines

lib/tst_capability.c line 50

Quoted 8 lines
lib/tst_capability.c new file +6 -0
+
+static void do_cap_req(uint32_t *set, uint32_t mask, const struct tst_cap *cap)
+{
+	if (!(*set&  mask))
+		tst_brk(TCONF, "Need %s(%d)", cap->name, cap->id);
+

here has logic problem. :-) If set has not the cap, we should use set |mask instead of tst_brk.

Ah, I see I broke my original logic here completely which is why this makes no sense. xD

Quoted 89 lines

code should be as below:

           if ((*set&  mask)) {
                 tst_res(TINFO,
                       "%s(%d) has been in effective set before requring",
                       cap->name, cap->id);
               return;
       } else {
                tst_res(TINFO, "Permitting %s(%d)", cap->name, cap->id);
                *set |= mask;

        }
Quoted 65 lines
lib/tst_capability.c new file +60 -0
+	if (!(*set&  mask)) {
+		tst_res(TINFO, "Permitting %s(%d)", cap->name, cap->id);
+		*set |= mask;
+	}
+}
+
+/**
+ * Add, check or remove capabilities
+ *
+ * Takes a NULL terminated array of structs which describe whether some
+ * capabilities are needed or not.
+ *
+ * It will attempt to drop or add capabilities to the effective set. It will
+ * try to detect if this is needed and whether it can or can't be done. If it
+ * clearly can not add a privilege to the effective set then it will return
+ * TCONF. However it may fail for some other reason and return TBROK.
+ *
+ * This only tries to change the effective set. Some tests may need to change
+ * the inheritable and ambient sets, so that child processes retain some
+ * capability.
+ */
+void tst_cap_action(struct tst_cap *cap)
+{
+	struct tst_cap_user_header hdr = {
+		.version = 0x20080522,
+		.pid = tst_syscall(__NR_gettid),
+	};
+	struct tst_cap_user_data cur[2] = { {0} };
+	struct tst_cap_user_data new[2] = { {0} };
+	uint32_t act = cap->action;
+	uint32_t *set =&new[CAP_TO_INDEX(cap->id)].effective;
+	uint32_t mask = CAP_TO_MASK(cap->id);
+
+	if (tst_capget(&hdr, cur))
+		tst_brk(TBROK | TTERRNO, "tst_capget()");
+
+	memcpy(new, cur, sizeof(new));
+
+	switch (act) {
+	case TST_CAP_DROP:
+		do_cap_drop(set, mask, cap);
+		break;
+	case TST_CAP_REQ:
+		do_cap_req(set, mask, cap);
+		break;
+	default:
+		tst_brk(TBROK, "Unrecognised action %d", cap->action);
+	}
+
+	if (memcmp(cur, new, sizeof(new))&&  tst_capset(&hdr, new))
+		tst_brk(TBROK | TERRNO, "tst_capset(%s)", cap->name);
+}
+
+void tst_cap_setup(struct tst_cap *caps)
+{
+	struct tst_cap *cap;
+
+	for (cap = caps; cap->action; cap++)
+		tst_cap_action(cap);
+}
lib/tst_test.c +0 -0
index 245e287fa..8d5fbd1f9 100644

lib/tst_test.c static void do_test_setup(void) · line 896

Quoted 9 lines
lib/tst_test.c +3 -0
@@ -888,6 +888,9 @@ static void do_test_setup(void)
 
  	if (main_pid != getpid())
  		tst_brk(TBROK, "Runaway child in setup()!");
+
+	if (tst_test->caps)
+		tst_cap_setup(tst_test->caps);
  }
 
  static void do_cleanup(void)

other than the minor things, this patch looks ok.

Signature · 2 lines
Thank you,
Richard.
#15 lore raw

cover tst API for dropping or requiring capabilities

In reply to Richard Palethorpe

Hi!

Quoted 5 lines

It can be used like this:

	.caps = (struct tst_cap []) {
		TST_CAP(TST_DROP, CAP_SYS_ADMIN),
		{0, 0, 0},

A minor note, the {0, 0, 0} should be equivalent to {}

Signature · 2 lines
Cyril Hrubis
[email protected]