Beginning of kdbus support
[platform/upstream/dbus.git] / dbus / kdbus.h
1 /*
2  * Copyright (C) 2013 Kay Sievers
3  * Copyright (C) 2013 Greg Kroah-Hartman <gregkh@linuxfoundation.org>
4  * Copyright (C) 2013 Linux Foundation
5  * Copyright (C) 2013 Lennart Poettering
6  * Copyright (C) 2013 Daniel Mack <daniel@zonque.org>
7  *
8  * kdbus is free software; you can redistribute it and/or modify it under
9  * the terms of the GNU Lesser General Public License as published by the
10  * Free Software Foundation; either version 2.1 of the License, or (at
11  * your option) any later version.
12  */
13
14 #ifndef _KDBUS_H_
15 #define _KDBUS_H_
16
17 #ifndef __KERNEL__
18 #include <sys/ioctl.h>
19 #include <sys/types.h>
20 #include <linux/types.h>
21 #endif
22
23 #define KDBUS_IOC_MAGIC                 0x95
24 #define KDBUS_SRC_ID_KERNEL             (0)
25 #define KDBUS_DST_ID_WELL_KNOWN_NAME    (0)
26 #define KDBUS_MATCH_SRC_ID_ANY          (~0ULL)
27 #define KDBUS_DST_ID_BROADCAST          (~0ULL)
28
29 /* Common first elements in a structure which are used to iterate over
30  * a list of elements. */
31 #define KDBUS_PART_HEADER \
32         struct {                                                        \
33                 __u64 size;                                             \
34                 __u64 type;                                             \
35         }
36
37 /* Message sent from kernel to userspace, when the owner or starter of
38  * a well-known name changes */
39 struct kdbus_manager_msg_name_change {
40         __u64 old_id;
41         __u64 new_id;
42         __u64 flags;                    /* 0 or (possibly?) KDBUS_NAME_IN_QUEUE */
43         char name[0];
44 };
45
46 struct kdbus_manager_msg_id_change {
47         __u64 id;
48         __u64 flags;                    /* The kernel flags field from KDBUS_HELLO */
49 };
50
51 struct kdbus_creds {
52         __u64 uid;
53         __u64 gid;
54         __u64 pid;
55         __u64 tid;
56
57         /* The starttime of the process PID. This is useful to detect
58         PID overruns from the client side. i.e. if you use the PID to
59         look something up in /proc/$PID/ you can afterwards check the
60         starttime field of it to ensure you didn't run into a PID
61         ovretun. */
62         __u64 starttime;
63 };
64
65 struct kdbus_audit {
66         __u64 sessionid;
67         __u64 loginuid;
68 };
69
70 struct kdbus_timestamp {
71         __u64 monotonic_ns;
72         __u64 realtime_ns;
73 };
74
75 struct kdbus_vec {
76         __u64 size;
77         union {
78                 __u64 address;
79                 __u64 offset;
80         };
81 };
82
83 struct kdbus_memfd {
84         __u64 size;
85         int fd;
86         __u32 __pad;
87 };
88
89 /* Message Item Types */
90 enum {
91         _KDBUS_MSG_NULL,
92
93         /* Filled in by userspace */
94         KDBUS_MSG_PAYLOAD_VEC,          /* .data_vec, reference to memory area */
95         KDBUS_MSG_PAYLOAD_OFF,          /* .data_vec, reference to memory area */
96         KDBUS_MSG_PAYLOAD_MEMFD,        /* file descriptor of a special data file */
97         KDBUS_MSG_FDS,                  /* .data_fds of file descriptors */
98         KDBUS_MSG_BLOOM,                /* for broadcasts, carries bloom filter blob in .data */
99         KDBUS_MSG_DST_NAME,             /* destination's well-known name, in .str */
100         KDBUS_MSG_PRIORITY,             /* queue priority for message */
101
102         /* Filled in by kernelspace */
103         KDBUS_MSG_SRC_NAMES     = 0x400,/* NUL separated string list with well-known names of source */
104         KDBUS_MSG_TIMESTAMP,            /* .timestamp */
105         KDBUS_MSG_SRC_CREDS,            /* .creds */
106         KDBUS_MSG_SRC_PID_COMM,         /* optional, in .str */
107         KDBUS_MSG_SRC_TID_COMM,         /* optional, in .str */
108         KDBUS_MSG_SRC_EXE,              /* optional, in .str */
109         KDBUS_MSG_SRC_CMDLINE,          /* optional, in .str (a chain of NUL str) */
110         KDBUS_MSG_SRC_CGROUP,           /* optional, in .str */
111         KDBUS_MSG_SRC_CAPS,             /* caps data blob, in .data */
112         KDBUS_MSG_SRC_SECLABEL,         /* NUL terminated string, in .str */
113         KDBUS_MSG_SRC_AUDIT,            /* .audit */
114
115         /* Special messages from kernel, consisting of one and only one of these data blocks */
116         KDBUS_MSG_NAME_ADD      = 0x800,/* .name_change */
117         KDBUS_MSG_NAME_REMOVE,          /* .name_change */
118         KDBUS_MSG_NAME_CHANGE,          /* .name_change */
119         KDBUS_MSG_ID_ADD,               /* .id_change */
120         KDBUS_MSG_ID_REMOVE,            /* .id_change */
121         KDBUS_MSG_REPLY_TIMEOUT,        /* empty, but .reply_cookie in .kdbus_msg is filled in */
122         KDBUS_MSG_REPLY_DEAD,           /* dito */
123 };
124
125 /**
126  * struct  kdbus_item - chain of data blocks
127  *
128  * size: overall data record size
129  * type: kdbus_item type of data
130  */
131 struct kdbus_item {
132         KDBUS_PART_HEADER;
133         union {
134                 /* inline data */
135                 __u8 data[0];
136                 __u32 data32[0];
137                 __u64 data64[0];
138                 char str[0];
139
140                 /* connection */
141                 __u64 id;
142
143                 /* data vector */
144                 struct kdbus_vec vec;
145
146                 /* process credentials and properties*/
147                 struct kdbus_creds creds;
148                 struct kdbus_audit audit;
149                 struct kdbus_timestamp timestamp;
150
151                 /* specific fields */
152                 struct kdbus_memfd memfd;
153                 int fds[0];
154                 struct kdbus_manager_msg_name_change name_change;
155                 struct kdbus_manager_msg_id_change id_change;
156         };
157 };
158
159 enum {
160         KDBUS_MSG_FLAGS_EXPECT_REPLY    = 1 << 0,
161         KDBUS_MSG_FLAGS_NO_AUTO_START   = 1 << 1,
162 };
163
164 enum {
165         KDBUS_PAYLOAD_KERNEL,
166         KDBUS_PAYLOAD_DBUS1     = 0x4442757356657231ULL, /* 'DBusVer1' */
167         KDBUS_PAYLOAD_GVARIANT  = 0x4756617269616e74ULL, /* 'GVariant' */
168 };
169
170 /**
171  * struct kdbus_msg
172  *
173  * set by userspace:
174  * dst_id: destination id
175  * flags: KDBUS_MSG_FLAGS_*
176  * items: data records
177  *
178  * set by kernel:
179  * src_id: who sent the message
180  */
181 struct kdbus_msg {
182         __u64 size;
183         __u64 flags;
184         __u64 dst_id;                   /* connection, 0 == name in data, ~0 broadcast */
185         __u64 src_id;                   /* connection, 0 == kernel */
186         __u64 payload_type;             /* 'DBusVer1', 'GVariant', ... */
187         __u64 cookie;                   /* userspace-supplied cookie */
188         union {
189                 __u64 cookie_reply;     /* cookie we reply to */
190                 __u64 timeout_ns;       /* timespan to wait for reply */
191         };
192         struct kdbus_item items[0];
193 };
194
195 enum {
196         _KDBUS_POLICY_NULL,
197         KDBUS_POLICY_NAME,
198         KDBUS_POLICY_ACCESS,
199 };
200
201 enum {
202         _KDBUS_POLICY_ACCESS_NULL,
203         KDBUS_POLICY_ACCESS_USER,
204         KDBUS_POLICY_ACCESS_GROUP,
205         KDBUS_POLICY_ACCESS_WORLD,
206 };
207
208 enum {
209         KDBUS_POLICY_RECV               = 1 <<  2,
210         KDBUS_POLICY_SEND               = 1 <<  1,
211         KDBUS_POLICY_OWN                = 1 <<  0,
212 };
213
214 struct kdbus_policy_access {
215         __u64 type;             /* USER, GROUP, WORLD */
216         __u64 bits;             /* RECV, SEND, OWN */
217         __u64 id;               /* uid, gid, 0 */
218 };
219
220 //FIXME: convert access to access[]
221 struct kdbus_policy {
222         KDBUS_PART_HEADER;
223         union {
224                 char name[0];
225                 struct kdbus_policy_access access;
226         };
227 };
228
229 /* A series of KDBUS_POLICY_NAME, plus one or more KDBUS_POLICY_ACCESS */
230 struct kdbus_cmd_policy {
231         __u64 size;
232         struct kdbus_policy policies[0];
233 };
234
235 /* Flags for struct kdbus_cmd_hello */
236 enum {
237         KDBUS_HELLO_STARTER             =  1 <<  0,
238         KDBUS_HELLO_ACCEPT_FD           =  1 <<  1,
239
240         /* The following have an effect on directed messages only --
241          * not for broadcasts */
242         KDBUS_HELLO_ATTACH_COMM         =  1 << 10,
243         KDBUS_HELLO_ATTACH_EXE          =  1 << 11,
244         KDBUS_HELLO_ATTACH_CMDLINE      =  1 << 12,
245         KDBUS_HELLO_ATTACH_CGROUP       =  1 << 13,
246         KDBUS_HELLO_ATTACH_CAPS         =  1 << 14,
247         KDBUS_HELLO_ATTACH_SECLABEL     =  1 << 15,
248         KDBUS_HELLO_ATTACH_AUDIT        =  1 << 16,
249 };
250
251 struct kdbus_cmd_hello {
252         __u64 size;
253
254         /* userspace → kernel, kernel → userspace */
255         __u64 conn_flags;       /* userspace specifies its
256                                  * capabilities and more, kernel
257                                  * returns its capabilites and
258                                  * more. Kernel might refuse client's
259                                  * capabilities by returning an error
260                                  * from KDBUS_HELLO */
261
262         /* kernel → userspace */
263         __u64 bus_flags;        /* this is .flags copied verbatim from
264                                  * from original KDBUS_CMD_BUS_MAKE
265                                  * ioctl. It's intended to be useful
266                                  * to do negotiation of features of
267                                  * the payload that is transfreted. */
268         __u64 id;               /* id assigned to this connection */
269         __u64 bloom_size;       /* The bloom filter size chosen by the
270                                  * bus owner */
271         __u64 pool_size;        /* maximum size of pool buffer */
272         struct kdbus_item items[0];
273 };
274
275 /* Flags for kdbus_cmd_{bus,ep,ns}_make */
276 enum {
277         KDBUS_MAKE_ACCESS_GROUP         = 1 <<  0,
278         KDBUS_MAKE_ACCESS_WORLD         = 1 <<  1,
279         KDBUS_MAKE_POLICY_OPEN          = 1 <<  2,
280 };
281
282 /* Items to append to kdbus_cmd_{bus,ep,ns}_make */
283 enum {
284         _KDBUS_MAKE_NULL,
285         KDBUS_MAKE_NAME,
286         KDBUS_MAKE_CGROUP,      /* the cgroup hierarchy ID for which to attach
287                                  * cgroup membership paths to messages.
288                                  * FIXME: remove, use *the* hierarchy */
289         KDBUS_MAKE_CRED,        /* allow translator services which connect
290                                  * to the bus on behalf of somebody else,
291                                  * allow specifiying the credentials of the
292                                  * client to connect on behalf on. Needs
293                                  * privileges */
294 };
295
296 struct kdbus_cmd_bus_make {
297         __u64 size;
298         __u64 flags;            /* userspace → kernel, kernel → userspace
299                                  * When creating a bus feature
300                                  * kernel negotiation. */
301         __u64 bus_flags;        /* userspace → kernel
302                                  * When a bus is created this value is
303                                  * copied verbatim into the bus
304                                  * structure and returned from
305                                  * KDBUS_CMD_HELLO, later */
306         __u64 bloom_size;       /* size of the bloom filter for this bus */
307         struct kdbus_item items[0];
308 };
309
310 struct kdbus_cmd_ep_make {
311         __u64 size;
312         __u64 flags;            /* userspace → kernel, kernel → userspace
313                                  * When creating an entry point
314                                  * feature kernel negotiation done the
315                                  * same way as for
316                                  * KDBUS_CMD_BUS_MAKE. Unused for
317                                  * now. */
318         struct kdbus_item items[0];
319 };
320
321 struct kdbus_cmd_ns_make {
322         __u64 size;
323         __u64 flags;            /* userspace → kernel, kernel → userspace
324                                  * When creating an entry point
325                                  * feature kernel negotiation done the
326                                  * same way as for
327                                  * KDBUS_CMD_BUS_MAKE. Unused for
328                                  * now. */
329         struct kdbus_item items[0];
330 };
331
332 enum {
333         /* userspace → kernel */
334         KDBUS_NAME_REPLACE_EXISTING             = 1 <<  0,
335         KDBUS_NAME_QUEUE                        = 1 <<  1,
336         KDBUS_NAME_ALLOW_REPLACEMENT            = 1 <<  2,
337
338         /* kernel → userspace */
339         KDBUS_NAME_IN_QUEUE                     = 1 << 16,
340 };
341
342 /* We allow (de)regestration of names of other peers */
343 struct kdbus_cmd_name {
344         __u64 size;
345         __u64 flags;
346         __u64 id;
347         __u64 conn_flags;
348         char name[0];
349 };
350
351 struct kdbus_cmd_names {
352         __u64 size;
353         struct kdbus_cmd_name names[0];
354 };
355
356 enum {
357         _KDBUS_NAME_INFO_ITEM_NULL,
358         KDBUS_NAME_INFO_ITEM_NAME,      /* userspace → kernel */
359         KDBUS_NAME_INFO_ITEM_SECLABEL,  /* kernel → userspace */
360         KDBUS_NAME_INFO_ITEM_AUDIT,     /* kernel → userspace */
361 };
362
363 struct kdbus_cmd_name_info {
364         __u64 size;                     /* overall size of info */
365         __u64 flags;
366         __u64 id;                       /* either ID, or 0 and _ITEM_NAME follows */
367         struct kdbus_creds creds;
368         struct kdbus_item items[0];     /* list of item records */
369 };
370
371 enum {
372         _KDBUS_MATCH_NULL,
373         KDBUS_MATCH_BLOOM,              /* Matches a mask blob against KDBUS_MSG_BLOOM */
374         KDBUS_MATCH_SRC_NAME,           /* Matches a name string against KDBUS_MSG_SRC_NAMES */
375         KDBUS_MATCH_NAME_ADD,           /* Matches a name string against KDBUS_MSG_NAME_ADD */
376         KDBUS_MATCH_NAME_REMOVE,        /* Matches a name string against KDBUS_MSG_NAME_REMOVE */
377         KDBUS_MATCH_NAME_CHANGE,        /* Matches a name string against KDBUS_MSG_NAME_CHANGE */
378         KDBUS_MATCH_ID_ADD,             /* Matches an ID against KDBUS_MSG_ID_ADD */
379         KDBUS_MATCH_ID_REMOVE,          /* Matches an ID against KDBUS_MSG_ID_REMOVE */
380 };
381
382 struct kdbus_cmd_match {
383         __u64 size;
384         __u64 id;       /* We allow registration/deregestration of matches for other peers */
385         __u64 cookie;   /* userspace supplied cookie; when removing; kernel deletes everything with same cookie */
386         __u64 src_id;   /* ~0: any. other: exact unique match */
387         struct kdbus_item items[0];
388 };
389
390 struct kdbus_cmd_monitor {
391         __u64 id;               /* We allow setting the monitor flag of other peers */
392         unsigned int enable;    /* A boolean to enable/disable monitoring */
393         __u32 __pad;
394 };
395
396 /* FD states:
397  * control nodes: unset
398  *   bus owner  (via KDBUS_CMD_BUS_MAKE)
399  *   ns owner   (via KDBUS_CMD_NS_MAKE)
400  *
401  * ep nodes: unset
402  *   connected  (via KDBUS_CMD_HELLO)
403  *   starter    (via KDBUS_CMD_HELLO with KDBUS_CMD_HELLO_STARTER)
404  *   ep owner   (via KDBUS_CMD_EP_MAKE)
405  */
406 enum {
407         /* kdbus control node commands: require unset state */
408         KDBUS_CMD_BUS_MAKE =            _IOW(KDBUS_IOC_MAGIC, 0x00, struct kdbus_cmd_bus_make),
409         KDBUS_CMD_NS_MAKE =             _IOR(KDBUS_IOC_MAGIC, 0x10, struct kdbus_cmd_ns_make),
410
411         /* kdbus ep node commands: require unset state */
412         KDBUS_CMD_EP_MAKE =             _IOW(KDBUS_IOC_MAGIC, 0x20, struct kdbus_cmd_ep_make),
413         KDBUS_CMD_HELLO =               _IOWR(KDBUS_IOC_MAGIC, 0x30, struct kdbus_cmd_hello),
414
415         /* kdbus ep node commands: require connected state */
416         KDBUS_CMD_MSG_SEND =            _IOW(KDBUS_IOC_MAGIC, 0x40, struct kdbus_msg),
417         KDBUS_CMD_MSG_RECV =            _IOR(KDBUS_IOC_MAGIC, 0x41, __u64 *),
418         KDBUS_CMD_MSG_RELEASE =         _IOW(KDBUS_IOC_MAGIC, 0x42, __u64 *),
419
420         KDBUS_CMD_NAME_ACQUIRE =        _IOWR(KDBUS_IOC_MAGIC, 0x50, struct kdbus_cmd_name),
421         KDBUS_CMD_NAME_RELEASE =        _IOW(KDBUS_IOC_MAGIC, 0x51, struct kdbus_cmd_name),
422         KDBUS_CMD_NAME_LIST =           _IOWR(KDBUS_IOC_MAGIC, 0x52, struct kdbus_cmd_names),
423         KDBUS_CMD_NAME_QUERY =          _IOWR(KDBUS_IOC_MAGIC, 0x53, struct kdbus_cmd_name_info),
424
425         KDBUS_CMD_MATCH_ADD =           _IOW(KDBUS_IOC_MAGIC, 0x60, struct kdbus_cmd_match),
426         KDBUS_CMD_MATCH_REMOVE =        _IOW(KDBUS_IOC_MAGIC, 0x61, struct kdbus_cmd_match),
427         KDBUS_CMD_MONITOR =             _IOW(KDBUS_IOC_MAGIC, 0x62, struct kdbus_cmd_monitor),
428
429         /* kdbus ep node commands: require ep owner state */
430         KDBUS_CMD_EP_POLICY_SET =       _IOW(KDBUS_IOC_MAGIC, 0x70, struct kdbus_cmd_policy),
431
432         /* kdbus memfd commands: */
433         KDBUS_CMD_MEMFD_NEW =           _IOR(KDBUS_IOC_MAGIC, 0x80, int *),
434         KDBUS_CMD_MEMFD_SIZE_GET =      _IOR(KDBUS_IOC_MAGIC, 0x81, __u64 *),
435         KDBUS_CMD_MEMFD_SIZE_SET =      _IOW(KDBUS_IOC_MAGIC, 0x82, __u64 *),
436         KDBUS_CMD_MEMFD_SEAL_GET =      _IOR(KDBUS_IOC_MAGIC, 0x83, int *),
437         KDBUS_CMD_MEMFD_SEAL_SET =      _IO(KDBUS_IOC_MAGIC, 0x84),
438 };
439 #endif