kdbus: test suite changed to common format
[platform/kernel/linux-exynos.git] / tools / testing / selftests / kdbus / test-endpoint.c
1 #include <stdio.h>
2 #include <string.h>
3 #include <fcntl.h>
4 #include <stdlib.h>
5 #include <stddef.h>
6 #include <unistd.h>
7 #include <stdint.h>
8 #include <errno.h>
9 #include <assert.h>
10 #include <libgen.h>
11 #include <sys/capability.h>
12 #include <sys/wait.h>
13 #include <stdbool.h>
14
15 #include "kdbus-api.h"
16 #include "kdbus-util.h"
17 #include "kdbus-enum.h"
18 #include "kdbus-test.h"
19
20 #define KDBUS_SYSNAME_MAX_LEN                   63
21
22 static wur int install_name_add_match(struct kdbus_conn *conn, const char *name)
23 {
24         struct {
25                 struct kdbus_cmd_match cmd;
26                 struct {
27                         uint64_t size;
28                         uint64_t type;
29                         struct kdbus_notify_name_change chg;
30                 } item;
31                 char name[64];
32         } buf;
33         int ret;
34
35         /* install the match rule */
36         memset(&buf, 0, sizeof(buf));
37         buf.item.type = KDBUS_ITEM_NAME_ADD;
38         buf.item.chg.old_id.id = KDBUS_MATCH_ID_ANY;
39         buf.item.chg.new_id.id = KDBUS_MATCH_ID_ANY;
40         strncpy(buf.name, name, sizeof(buf.name) - 1);
41         buf.item.size = sizeof(buf.item) + strlen(buf.name) + 1;
42         buf.cmd.size = sizeof(buf.cmd) + buf.item.size;
43
44         ret = kdbus_cmd_match_add(conn->fd, &buf.cmd);
45         if (ret < 0)
46                 return ret;
47
48         return 0;
49 }
50
51 static wur int create_endpoint(const char *buspath, uid_t uid, const char *name,
52                            uint64_t flags)
53 {
54         struct {
55                 struct kdbus_cmd cmd;
56
57                 /* name item */
58                 struct {
59                         uint64_t size;
60                         uint64_t type;
61                         /* max should be KDBUS_SYSNAME_MAX_LEN */
62                         char str[128];
63                 } name;
64         } ep_make;
65         int fd, ret;
66
67         fd = open(buspath, O_RDWR);
68         if (fd < 0)
69                 return fd;
70
71         memset(&ep_make, 0, sizeof(ep_make));
72
73         snprintf(ep_make.name.str,
74                  /* Use the KDBUS_SYSNAME_MAX_LEN or sizeof(str) */
75                  KDBUS_SYSNAME_MAX_LEN > strlen(name) ?
76                  KDBUS_SYSNAME_MAX_LEN : sizeof(ep_make.name.str),
77                  "%u-%s", uid, name);
78
79         ep_make.name.type = KDBUS_ITEM_MAKE_NAME;
80         ep_make.name.size = KDBUS_ITEM_HEADER_SIZE +
81                             strlen(ep_make.name.str) + 1;
82
83         ep_make.cmd.flags = flags;
84         ep_make.cmd.size = sizeof(ep_make.cmd) + ep_make.name.size;
85
86         ret = kdbus_cmd_endpoint_make(fd, &ep_make.cmd);
87         if (ret < 0) {
88                 kdbus_printf("error creating endpoint: %d (%m)\n", ret);
89                 return ret;
90         }
91
92         return fd;
93 }
94
95 static wur int unpriv_test_custom_ep(const char *buspath)
96 {
97         int ret, ep_fd1, ep_fd2;
98         char *ep1, *ep2, *tmp1, *tmp2;
99
100         ASSERT_NONZERO(tmp1 = strdup(buspath));
101         ASSERT_NONZERO(tmp2 = strdup(buspath));
102
103         ret = asprintf(&ep1, "%s/%u-%s", dirname(tmp1), getuid(), "apps1");
104         ASSERT_RETURN(ret,>,0);
105
106         ret = asprintf(&ep2, "%s/%u-%s", dirname(tmp2), getuid(), "apps2");
107         ASSERT_RETURN(ret,>,0);
108
109         free(tmp1);
110         free(tmp2);
111
112         /* endpoint only accessible to current uid */
113         ep_fd1 = create_endpoint(buspath, getuid(), "apps1", 0);
114         ASSERT_RETURN(ep_fd1,>=,0);
115
116         /* endpoint world accessible */
117         ep_fd2 = create_endpoint(buspath, getuid(), "apps2",
118                                   KDBUS_MAKE_ACCESS_WORLD);
119         ASSERT_RETURN(ep_fd2,>=,0);
120
121         RUN_UNPRIVILEGED(UNPRIV_UID, UNPRIV_UID, ({
122                 int ep_fd;
123                 struct kdbus_conn *ep_conn;
124
125                 /*
126                  * Make sure that we are not able to create custom
127                  * endpoints
128                  */
129                 ep_fd = create_endpoint(buspath, getuid(),
130                                         "unpriv_costum_ep", 0);
131                 ASSERT_EXIT(ep_fd,==,-EPERM);
132
133                 /*
134                  * Endpoint "apps1" only accessible to same users,
135                  * that own the endpoint. Access denied by VFS
136                  */
137                 ep_conn = kdbus_hello(ep1, 0, NULL, 0);
138                 ASSERT_EXIT(errno,==,EACCES);
139                 ASSERT_EXIT_ZERO(ep_conn);
140
141                 /* Endpoint "apps2" world accessible */
142                 ASSERT_EXIT_NONZERO(ep_conn = kdbus_hello(ep2, 0, NULL, 0));
143
144                 kdbus_conn_free(ep_conn);
145
146                 exit(EXIT_SUCCESS);
147         }),
148         ({}));
149
150         CLOSE(ep_fd1);
151         CLOSE(ep_fd2);
152         free(ep1);
153         free(ep2);
154
155         return 0;
156 }
157
158 static wur int update_endpoint(int fd, const char *name)
159 {
160         int len = strlen(name) + 1;
161         struct {
162                 struct kdbus_cmd cmd;
163
164                 /* name item */
165                 struct {
166                         uint64_t size;
167                         uint64_t type;
168                         char str[KDBUS_ALIGN8(len)];
169                 } name;
170
171                 struct {
172                         uint64_t size;
173                         uint64_t type;
174                         struct kdbus_policy_access access;
175                 } access;
176         } ep_update;
177         int ret;
178
179         memset(&ep_update, 0, sizeof(ep_update));
180
181         ep_update.name.size = KDBUS_ITEM_HEADER_SIZE + len;
182         ep_update.name.type = KDBUS_ITEM_NAME;
183         strncpy(ep_update.name.str, name, sizeof(ep_update.name.str) - 1);
184
185         ep_update.access.size = sizeof(ep_update.access);
186         ep_update.access.type = KDBUS_ITEM_POLICY_ACCESS;
187         ep_update.access.access.type = KDBUS_POLICY_ACCESS_WORLD;
188         ep_update.access.access.access = KDBUS_POLICY_SEE;
189
190         ep_update.cmd.size = sizeof(ep_update);
191
192         ret = kdbus_cmd_endpoint_update(fd, &ep_update.cmd);
193         if (ret < 0) {
194                 kdbus_printf("error updating endpoint: %d (%m)\n", ret);
195                 return ret;
196         }
197
198         return 0;
199 }
200
201 wur int kdbus_test_custom_endpoint(struct kdbus_test_env *env)
202 {
203         char *ep, *tmp;
204         int ret, ep_fd;
205         struct kdbus_msg *msg;
206         struct kdbus_conn *ep_conn;
207         struct kdbus_conn *reader;
208         const char *name = "foo.bar.baz";
209         const char *epname = "foo";
210         char fake_ep[KDBUS_SYSNAME_MAX_LEN + 1] = {'\0'};
211
212         memset(fake_ep, 'X', sizeof(fake_ep) - 1);
213
214         /* Try to create a custom endpoint with a long name */
215         ASSERT_RETURN(-ENAMETOOLONG,==,create_endpoint(env->buspath, getuid(), fake_ep, 0));
216
217         /* Try to create a custom endpoint with a different uid */
218         ASSERT_RETURN(-EINVAL,==,create_endpoint(env->buspath, getuid() + 1, "foobar", 0));
219
220         /* create a custom endpoint, and open a connection on it */
221         ASSERT_RETURN(0,<=,ep_fd = create_endpoint(env->buspath, getuid(), "foo", 0));
222
223         ASSERT_NONZERO(tmp = strdup(env->buspath));
224         ASSERT_RETURN(0,<=,asprintf(&ep, "%s/%u-%s", dirname(tmp), getuid(), epname));
225         free(tmp);
226
227         /* Register a connection that listen to broadcasts */
228         ASSERT_NONZERO(reader = kdbus_hello(ep, 0, NULL, 0));
229
230         /* Register to kernel signals */
231         ASSERT_ZERO(kdbus_add_match_id(reader, 0x1, KDBUS_ITEM_ID_ADD, KDBUS_MATCH_ID_ANY));
232         ASSERT_ZERO(kdbus_add_match_id(reader, 0x2, KDBUS_ITEM_ID_REMOVE, KDBUS_MATCH_ID_ANY));
233         ASSERT_ZERO(install_name_add_match(reader, name));
234
235         /* Monitor connections are not supported on custom endpoints */
236         ep_conn = kdbus_hello(ep, KDBUS_HELLO_MONITOR, NULL, 0);
237         ASSERT_RETURN(errno,==,EOPNOTSUPP);
238         ASSERT_ZERO(ep_conn);
239
240         ASSERT_NONZERO(ep_conn = kdbus_hello(ep, 0, NULL, 0));
241
242         /* Check that the reader got the IdAdd notification */
243         ASSERT_ZERO(kdbus_msg_recv(reader, &msg, NULL));
244         ASSERT_RETURN(msg->items[0].type,==,(typeof(msg->items[0].type))KDBUS_ITEM_ID_ADD);
245         ASSERT_RETURN(msg->items[0].id_change.id,==,ep_conn->id);
246         kdbus_msg_free(msg);
247
248         /*
249          * Add a name add match on the endpoint connection, acquire name from
250          * the unfiltered connection, and make sure the filtered connection
251          * did not get the notification on the name owner change. Also, the
252          * endpoint connection may not be able to call conn_info, neither on
253          * the name nor on the ID.
254          */
255         ASSERT_ZERO(install_name_add_match(ep_conn, name));
256
257         ASSERT_ZERO(kdbus_name_acquire(env->conn, name, NULL));
258
259         ASSERT_RETURN(ONTIZEN(0,-EAGAIN),==,kdbus_msg_recv(ep_conn, NULL, NULL));
260         ASSERT_RETURN(ONTIZEN(0,-ESRCH),==,kdbus_conn_info(ep_conn, 0, name, 0, NULL));
261         ASSERT_RETURN(-ESRCH,==,kdbus_conn_info(ep_conn, 0, "random.crappy.name", 0, NULL));
262         ASSERT_RETURN(ONTIZEN(0,-ENXIO),==,kdbus_conn_info(ep_conn, env->conn->id, NULL, 0, NULL));
263         ASSERT_RETURN(-ENXIO,==,kdbus_conn_info(ep_conn, 0x0fffffffffffffffULL, NULL, 0, NULL));
264
265         /* Check that the reader did not receive the name notification */
266         ASSERT_RETURN(ONTIZEN(0,-EAGAIN),==,kdbus_msg_recv(reader, NULL, NULL));
267
268         /*
269          * Release the name again, update the custom endpoint policy,
270          * and try again. This time, the connection on the custom endpoint
271          * should have gotten it.
272          */
273         ASSERT_ZERO(kdbus_name_release(env->conn, name));
274
275         /* Check that the reader did not receive the name notification */
276         ASSERT_RETURN(-EAGAIN,==,kdbus_msg_recv(reader, NULL, NULL));
277
278         ASSERT_ZERO(update_endpoint(ep_fd, name));
279
280         ASSERT_ZERO(kdbus_name_acquire(env->conn, name, NULL));
281
282         ASSERT_ZERO(kdbus_msg_recv(ep_conn, &msg, NULL));
283         ASSERT_RETURN(msg->items[0].type,==,(typeof(msg->items[0].type))KDBUS_ITEM_NAME_ADD);
284         ASSERT_ZERO(msg->items[0].name_change.old_id.id);
285         ASSERT_RETURN(msg->items[0].name_change.new_id.id,==,env->conn->id);
286         ASSERT_ZERO(strcmp(msg->items[0].name_change.name, name));
287         kdbus_msg_free(msg);
288
289         ASSERT_ZERO(kdbus_msg_recv(reader, &msg, NULL));
290         ASSERT_ZERO(strcmp(msg->items[0].name_change.name, name));
291
292         kdbus_msg_free(msg);
293
294         ASSERT_ZERO(kdbus_conn_info(ep_conn, 0, name, 0, NULL));
295
296         ASSERT_ZERO(kdbus_conn_info(ep_conn, env->conn->id, NULL, 0, NULL));
297
298         /* If we have privileges test custom endpoints */
299         ret = test_is_capable(CAP_SETUID, CAP_SETGID, -1);
300         ASSERT_RETURN(ret,>=,0);
301
302         /*
303          * All uids/gids are mapped and we have the necessary caps
304          */
305         if (ret && all_uids_gids_are_mapped())
306                 ASSERT_ZERO(unpriv_test_custom_ep(env->buspath));
307
308         kdbus_conn_free(reader);
309         kdbus_conn_free(ep_conn);
310         CLOSE(ep_fd);
311
312         return TEST_OK;
313 }