mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-24 09:50:04 +00:00
![Gabriel Krisman Bertazi](/assets/img/avatar_default.png)
The merged API doesn't use a watch_queue device, but instead relies on
pipes, so let the documentation reflect that.
Fixes: f7e47677e3
("watch_queue: Add a key/keyring notification facility")
Signed-off-by: Gabriel Krisman Bertazi <krisman@collabora.com>
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Jarkko Sakkinen <jarkko@kernel.org>
Reviewed-by: Ben Boeckel <mathstuf@gmail.com>
186 lines
3.9 KiB
C
186 lines
3.9 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/* Use watch_queue API to watch for notifications.
|
|
*
|
|
* Copyright (C) 2020 Red Hat, Inc. All Rights Reserved.
|
|
* Written by David Howells (dhowells@redhat.com)
|
|
*/
|
|
|
|
#define _GNU_SOURCE
|
|
#include <stdbool.h>
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <signal.h>
|
|
#include <unistd.h>
|
|
#include <errno.h>
|
|
#include <sys/ioctl.h>
|
|
#include <limits.h>
|
|
#include <linux/watch_queue.h>
|
|
#include <linux/unistd.h>
|
|
#include <linux/keyctl.h>
|
|
|
|
#ifndef KEYCTL_WATCH_KEY
|
|
#define KEYCTL_WATCH_KEY -1
|
|
#endif
|
|
#ifndef __NR_keyctl
|
|
#define __NR_keyctl -1
|
|
#endif
|
|
|
|
#define BUF_SIZE 256
|
|
|
|
static long keyctl_watch_key(int key, int watch_fd, int watch_id)
|
|
{
|
|
return syscall(__NR_keyctl, KEYCTL_WATCH_KEY, key, watch_fd, watch_id);
|
|
}
|
|
|
|
static const char *key_subtypes[256] = {
|
|
[NOTIFY_KEY_INSTANTIATED] = "instantiated",
|
|
[NOTIFY_KEY_UPDATED] = "updated",
|
|
[NOTIFY_KEY_LINKED] = "linked",
|
|
[NOTIFY_KEY_UNLINKED] = "unlinked",
|
|
[NOTIFY_KEY_CLEARED] = "cleared",
|
|
[NOTIFY_KEY_REVOKED] = "revoked",
|
|
[NOTIFY_KEY_INVALIDATED] = "invalidated",
|
|
[NOTIFY_KEY_SETATTR] = "setattr",
|
|
};
|
|
|
|
static void saw_key_change(struct watch_notification *n, size_t len)
|
|
{
|
|
struct key_notification *k = (struct key_notification *)n;
|
|
|
|
if (len != sizeof(struct key_notification)) {
|
|
fprintf(stderr, "Incorrect key message length\n");
|
|
return;
|
|
}
|
|
|
|
printf("KEY %08x change=%u[%s] aux=%u\n",
|
|
k->key_id, n->subtype, key_subtypes[n->subtype], k->aux);
|
|
}
|
|
|
|
/*
|
|
* Consume and display events.
|
|
*/
|
|
static void consumer(int fd)
|
|
{
|
|
unsigned char buffer[433], *p, *end;
|
|
union {
|
|
struct watch_notification n;
|
|
unsigned char buf1[128];
|
|
} n;
|
|
ssize_t buf_len;
|
|
|
|
for (;;) {
|
|
buf_len = read(fd, buffer, sizeof(buffer));
|
|
if (buf_len == -1) {
|
|
perror("read");
|
|
exit(1);
|
|
}
|
|
|
|
if (buf_len == 0) {
|
|
printf("-- END --\n");
|
|
return;
|
|
}
|
|
|
|
if (buf_len > sizeof(buffer)) {
|
|
fprintf(stderr, "Read buffer overrun: %zd\n", buf_len);
|
|
return;
|
|
}
|
|
|
|
printf("read() = %zd\n", buf_len);
|
|
|
|
p = buffer;
|
|
end = buffer + buf_len;
|
|
while (p < end) {
|
|
size_t largest, len;
|
|
|
|
largest = end - p;
|
|
if (largest > 128)
|
|
largest = 128;
|
|
if (largest < sizeof(struct watch_notification)) {
|
|
fprintf(stderr, "Short message header: %zu\n", largest);
|
|
return;
|
|
}
|
|
memcpy(&n, p, largest);
|
|
|
|
printf("NOTIFY[%03zx]: ty=%06x sy=%02x i=%08x\n",
|
|
p - buffer, n.n.type, n.n.subtype, n.n.info);
|
|
|
|
len = n.n.info & WATCH_INFO_LENGTH;
|
|
if (len < sizeof(n.n) || len > largest) {
|
|
fprintf(stderr, "Bad message length: %zu/%zu\n", len, largest);
|
|
exit(1);
|
|
}
|
|
|
|
switch (n.n.type) {
|
|
case WATCH_TYPE_META:
|
|
switch (n.n.subtype) {
|
|
case WATCH_META_REMOVAL_NOTIFICATION:
|
|
printf("REMOVAL of watchpoint %08x\n",
|
|
(n.n.info & WATCH_INFO_ID) >>
|
|
WATCH_INFO_ID__SHIFT);
|
|
break;
|
|
case WATCH_META_LOSS_NOTIFICATION:
|
|
printf("-- LOSS --\n");
|
|
break;
|
|
default:
|
|
printf("other meta record\n");
|
|
break;
|
|
}
|
|
break;
|
|
case WATCH_TYPE_KEY_NOTIFY:
|
|
saw_key_change(&n.n, len);
|
|
break;
|
|
default:
|
|
printf("other type\n");
|
|
break;
|
|
}
|
|
|
|
p += len;
|
|
}
|
|
}
|
|
}
|
|
|
|
static struct watch_notification_filter filter = {
|
|
.nr_filters = 1,
|
|
.filters = {
|
|
[0] = {
|
|
.type = WATCH_TYPE_KEY_NOTIFY,
|
|
.subtype_filter[0] = UINT_MAX,
|
|
},
|
|
},
|
|
};
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
int pipefd[2], fd;
|
|
|
|
if (pipe2(pipefd, O_NOTIFICATION_PIPE) == -1) {
|
|
perror("pipe2");
|
|
exit(1);
|
|
}
|
|
fd = pipefd[0];
|
|
|
|
if (ioctl(fd, IOC_WATCH_QUEUE_SET_SIZE, BUF_SIZE) == -1) {
|
|
perror("watch_queue(size)");
|
|
exit(1);
|
|
}
|
|
|
|
if (ioctl(fd, IOC_WATCH_QUEUE_SET_FILTER, &filter) == -1) {
|
|
perror("watch_queue(filter)");
|
|
exit(1);
|
|
}
|
|
|
|
if (keyctl_watch_key(KEY_SPEC_SESSION_KEYRING, fd, 0x01) == -1) {
|
|
perror("keyctl");
|
|
exit(1);
|
|
}
|
|
|
|
if (keyctl_watch_key(KEY_SPEC_USER_KEYRING, fd, 0x02) == -1) {
|
|
perror("keyctl");
|
|
exit(1);
|
|
}
|
|
|
|
consumer(fd);
|
|
exit(0);
|
|
}
|