tools/testing/selftests/kdbus/kdbus-util.h

   1 /*
   2  * Copyright (C) 2013-2015 Kay Sievers
   3  * Copyright (C) 2013-2015 Daniel Mack
   4  *
   5  * kdbus is free software; you can redistribute it and/or modify it under
   6  * the terms of the GNU Lesser General Public License as published by the
   7  * Free Software Foundation; either version 2.1 of the License, or (at
   8  * your option) any later version.
   9  */
  10
  11 #pragma once
  12
  13 #define BIT(X) (1 << (X))
  14
  15 #include <time.h>
  16 #include <stdbool.h>
  17 #include <linux/kdbus.h>
  18 #include <sys/wait.h>
  19
  20 /* backwards-incompatible tizen customizations */
  21 #define TIZEN
  22 #ifdef TIZEN
  23         #define ONTIZEN(TIZEN,NONTIZEN) TIZEN
  24 #else
  25         #define ONTIZEN(TIZEN,NONTIZEN) NONTIZEN
  26 #endif
  27
  28 /* c99 compat */
  29 #define typeof __typeof__
  30
  31 #define wur __attribute__((warn_unused_result))
  32
  33 #define print(...) fprintf(stderr, ##__VA_ARGS__)
  34
  35 #define UNUSED(VAL) do { __auto_type _UNUSED_val_ = (VAL); (void)_UNUSED_val_; } while (0)
  36
  37 #define TABSIZE(T) (sizeof(T)/sizeof(T[0]))
  38
  39 static inline wur void *alloc(size_t size) {
  40         void *p;
  41         int ret = posix_memalign(&p, 8, size);
  42         return ret ? NULL : p;
  43 }
  44
  45 #define MAX(A,B) ({\
  46         typeof(A) __MAX__A__ = (A);\
  47         typeof(B) __MAX__B__ = (B);\
  48         __MAX__A__<__MAX__B__ ? __MAX__B__ : __MAX__A__;\
  49 })
  50 #define MIN(A,B) ({\
  51         typeof(A) __MIN__A__ = (A);\
  52         typeof(B) __MIN__B__ = (B);\
  53         __MIN__A__>__MIN__B__ ? __MIN__B__ : __MIN__A__;\
  54 })
  55
  56 #define KDBUS_TIMEOUT_INFINITE 0x3fffffffffffffffULL
  57
  58 #define _STRINGIFY(x) #x
  59 #define STRINGIFY(x) _STRINGIFY(x)
  60 #define ELEMENTSOF(x) (sizeof(x)/sizeof((x)[0]))
  61
  62 #define fail(FMT,...) do { print("[" __FILE__ ":" STRINGIFY(__LINE__) "] fail " FMT "\n", ##__VA_ARGS__); exit(2); } while (0)
  63
  64 #define KDBUS_PTR(addr) ((void *)(uintptr_t)(addr))
  65
  66 #define KDBUS_ALIGN8(l) (((l) + 7) & ~7)
  67 #define KDBUS_ITEM_HEADER_SIZE offsetof(struct kdbus_item, data)
  68 #define KDBUS_ITEM_SIZE(s) KDBUS_ALIGN8((s) + KDBUS_ITEM_HEADER_SIZE)
  69
  70 #define KDBUS_ITEM_NEXT(item) \
  71         (typeof(item))((uint8_t *)(item) + KDBUS_ALIGN8((item)->size))
  72 #define KDBUS_ITEM_FOREACH(item, head, first)                           \
  73         for ((item) = (head)->first;                                    \
  74              ((uint8_t *)(item) < (uint8_t *)(head) + (head)->size) &&  \
  75                ((uint8_t *)(item) >= (uint8_t *)(head));                \
  76              (item) = KDBUS_ITEM_NEXT(item))
  77 #define KDBUS_FOREACH(iter, first, _size)                               \
  78         for ((iter) = (first);                                          \
  79              ((uint8_t *)(iter) < (uint8_t *)(first) + (_size)) &&      \
  80                ((uint8_t *)(iter) >= (uint8_t *)(first));               \
  81              (iter) = (void *)((uint8_t *)(iter) + KDBUS_ALIGN8((iter)->size)))
  82
  83 #define _KDBUS_ATTACH_BITS_SET_NR (__builtin_popcountll(_KDBUS_ATTACH_ALL))
  84
  85 /* Sum of KDBUS_ITEM_* that reflects _KDBUS_ATTACH_ALL */
  86 #define KDBUS_ATTACH_ITEMS_TYPE_SUM                                     \
  87         ((((_KDBUS_ATTACH_BITS_SET_NR - 1) *                            \
  88         ((_KDBUS_ATTACH_BITS_SET_NR - 1) + 1)) / 2) +                   \
  89         (_KDBUS_ITEM_ATTACH_BASE * _KDBUS_ATTACH_BITS_SET_NR))
  90
  91 #define POOL_SIZE (16 * 1024LU * 1024LU)
  92
  93 #define UNPRIV_UID 65534
  94 #define UNPRIV_GID 65534
  95
  96 /* Dump as user of process, useful for user namespace testing */
  97 #define SUID_DUMP_USER  1
  98
  99 extern int kdbus_util_verbose;
 100
 101 #define kdbus_printf(X...) \
 102         if (kdbus_util_verbose) \
 103                 print(X)
 104
 105 #define RUN_FORKED(_child_, _parent_) ASSERT_ZERO(({\
 106                 pid_t pid, rpid;\
 107                 int ret;\
 108                 \
 109                 pid = fork();\
 110                 if (pid == 0) {\
 111                         _child_;\
 112                         exit(0);\
 113                 } else if (pid > 0) {\
 114                         _parent_;\
 115                         rpid = waitpid(pid, &ret, 0);\
 116                         ASSERT_RETURN(rpid,==,pid);\
 117                         ASSERT_NONZERO(WIFEXITED(ret));\
 118                         ASSERT_ZERO(WEXITSTATUS(ret));\
 119                         ret = TEST_OK;\
 120                 } else {\
 121                         ret = pid;\
 122                 }\
 123                 \
 124                 ret;\
 125         }))
 126
 127 #define RUN_UNPRIVILEGED(child_uid, child_gid, _child_, _parent_) RUN_FORKED(({\
 128                 ret = drop_privileges(child_uid, child_gid);\
 129                 ASSERT_EXIT_VAL(ret,==,0, ret);\
 130                 _child_;\
 131         }), _parent_)
 132
 133 #define RUN_UNPRIVILEGED_CONN(_var_, _bus_, _code_)                     \
 134         RUN_UNPRIVILEGED(UNPRIV_UID, UNPRIV_GID, ({                     \
 135                 struct kdbus_conn *_var_;                               \
 136                 ASSERT_EXIT_NONZERO(_var_ = kdbus_hello(_bus_, 0, NULL, 0));                    \
 137                 _code_;                                                 \
 138                 kdbus_conn_free(_var_);                                 \
 139         }), ({}))
 140
 141 #define RUN_CLONE_CHILD(clone_ret, flags, _setup_, _child_body_,        \
 142                         _parent_setup_, _parent_body_) ({               \
 143         pid_t pid, rpid;                                                \
 144         int ret;                                                        \
 145         int efd = -1;                                                   \
 146                                                                         \
 147         _setup_;                                                        \
 148         efd = eventfd(0, EFD_CLOEXEC);                                  \
 149         ASSERT_RETURN(efd,>=,0);                                        \
 150         *(clone_ret) = 0;                                               \
 151         pid = syscall(__NR_clone, flags, NULL);                         \
 152         if (pid == 0) {                                                 \
 153                 eventfd_t event_status = 0;                             \
 154                 ASSERT_EXIT_ZERO(prctl(PR_SET_PDEATHSIG, SIGKILL));                     \
 155                 ret = eventfd_read(efd, &event_status);                 \
 156                 if (ret < 0 || event_status != 1) {                     \
 157                         kdbus_printf("error eventfd_read()\n");         \
 158                         exit(EXIT_FAILURE);                             \
 159                 }                                                       \
 160                 _child_body_;                                           \
 161                 exit(0);                                                \
 162         } else if (pid > 0) {                                           \
 163                 _parent_setup_;                                         \
 164                 ASSERT_RETURN(eventfd_write(efd, 1),>=,0);                              \
 165                 _parent_body_;                                          \
 166                 rpid = waitpid(pid, &ret, 0);                           \
 167                 ASSERT_RETURN(rpid,==,pid);                             \
 168                 ASSERT_NONZERO(WIFEXITED(ret));                         \
 169                 ASSERT_ZERO(WEXITSTATUS(ret));                  \
 170                 ret = TEST_OK;                                          \
 171         } else {                                                        \
 172                 ret = -errno;                                           \
 173                 *(clone_ret) = -errno;                                  \
 174         }                                                               \
 175         CLOSE(efd);                                                     \
 176         ret;                                                            \
 177 })
 178
 179 #define ASSERT_NO_PENDING(CONN) do {\
 180         struct kdbus_cmd_recv _ASSERT_NO_PENDING_recv_ = { .size = sizeof(_ASSERT_NO_PENDING_recv_) };\
 181         int _ASSERT_NO_PENDING_fd_ = (CONN)->fd;\
 182         int _ASSERT_NO_PENDING_ret_ = kdbus_cmd_recv(_ASSERT_NO_PENDING_fd_, &_ASSERT_NO_PENDING_recv_);\
 183         ASSERT_RETURN(-EAGAIN,==,_ASSERT_NO_PENDING_ret_);\
 184 } while (0)
 185
 186 #define CLOSE(...) do { __auto_type _CLOSE_fd_ = (__VA_ARGS__); if (close(_CLOSE_fd_)) fail("close(%d) err(%d)", _CLOSE_fd_, errno); } while (0)
 187
 188 /* Enums for parent if it should drop privs or not */
 189 enum kdbus_drop_parent {
 190         DO_NOT_DROP,
 191         DROP_SAME_UNPRIV,
 192         DROP_OTHER_UNPRIV,
 193 };
 194
 195 struct kdbus_conn {
 196         int fd;
 197         uint64_t id;
 198         unsigned attach_flags_recv;
 199         unsigned char *buf;
 200 };
 201
 202 wur int kdbus_sysfs_get_parameter_mask(const char *path, uint64_t *mask);
 203 wur int kdbus_sysfs_set_parameter_mask(const char *path, uint64_t mask);
 204
 205 wur int sys_memfd_create(const char *name, __u64 size);
 206 wur int sys_memfd_seal_set(int fd);
 207 wur off_t sys_memfd_get_size(int fd, off_t *size);
 208
 209 wur int kdbus_list(struct kdbus_conn *conn, uint64_t flags);
 210 wur int kdbus_name_release(struct kdbus_conn *conn, const char *name);
 211 wur int kdbus_name_acquire(struct kdbus_conn *conn, const char *name,
 212                        uint64_t *flags);
 213 void kdbus_msg_free(struct kdbus_msg *msg);
 214 wur int kdbus_msg_recv(struct kdbus_conn *conn,
 215                    struct kdbus_msg **msg, uint64_t *offset);
 216 wur int kdbus_msg_recv_poll(struct kdbus_conn *conn, int timeout_ms,
 217                         struct kdbus_msg **msg_out, uint64_t *offset);
 218 wur int kdbus_free(const struct kdbus_conn *conn, uint64_t offset);
 219 wur int kdbus_free_msg(struct kdbus_conn const *conn, struct kdbus_msg *msg);
 220 wur int kdbus_msg_dump(const struct kdbus_msg *msg);
 221 wur int kdbus_create_bus(int control_fd, const char *name,
 222                      uint64_t owner_meta, char **path);
 223 wur int kdbus_msg_send(const struct kdbus_conn *conn, const char *name,
 224                    uint64_t cookie, uint64_t flags, uint64_t timeout,
 225                    int64_t priority, uint64_t dst_id);
 226 wur int kdbus_msg_send_sync(const struct kdbus_conn *conn, const char *name,
 227                         uint64_t cookie, uint64_t flags, uint64_t timeout,
 228                         int64_t priority, uint64_t dst_id, int cancel_fd);
 229 wur int kdbus_msg_send_reply(const struct kdbus_conn *conn,
 230                          uint64_t reply_cookie,
 231                          uint64_t dst_id);
 232 wur struct kdbus_conn *kdbus_hello(const char *path, uint64_t hello_flags,
 233                                const struct kdbus_item *item,
 234                                size_t item_size);
 235 wur int timeout_msg_recv(struct kdbus_conn *conn, uint64_t type, uint64_t *cookie_reply, uint64_t *seqnum, uint64_t *monotonic_ns, uint64_t *realtime_ns);
 236 wur struct kdbus_conn *kdbus_hello_registrar(const char *path, const char *name,
 237                                          const struct kdbus_policy_access *access,
 238                                          size_t num_access, uint64_t flags);
 239 wur struct kdbus_conn *kdbus_hello_activator(const char *path, const char *name,
 240                                          const struct kdbus_policy_access *access,
 241                                          size_t num_access);
 242 wur bool kdbus_item_in_message(struct kdbus_msg *msg, uint64_t type);
 243 wur int kdbus_bus_creator_info(struct kdbus_conn *conn,
 244                            uint64_t flags,
 245                            uint64_t *offset);
 246 wur int kdbus_conn_info(struct kdbus_conn *conn, uint64_t id,
 247                     const char *name, uint64_t flags, uint64_t *offset);
 248 void kdbus_conn_free(struct kdbus_conn *conn);
 249 wur int kdbus_conn_update_attach_flags(struct kdbus_conn *conn,
 250                                    uint64_t attach_flags_send,
 251                                    uint64_t attach_flags_recv);
 252 wur int kdbus_conn_update_policy(struct kdbus_conn *conn, const char *name,
 253                              const struct kdbus_policy_access *access,
 254                              size_t num_access);
 255
 256 wur int kdbus_add_match_id(struct kdbus_conn *conn, uint64_t cookie,
 257                        uint64_t type, uint64_t id);
 258 wur int kdbus_add_match_empty(struct kdbus_conn *conn);
 259
 260 wur int all_uids_gids_are_mapped(void);
 261 wur int drop_privileges(uid_t uid, gid_t gid);
 262 wur uint64_t now(clockid_t clock);
 263 wur char *unique_name(const char *prefix);
 264
 265 wur int userns_map_uid_gid(pid_t pid, const char *map_uid, const char *map_gid);
 266 wur int test_is_capable(int cap, ...);
 267 wur int config_user_ns_is_enabled(void);
 268 wur int config_auditsyscall_is_enabled(void);
 269 wur int config_cgroups_is_enabled(void);
 270 wur int config_security_is_enabled(void);