| 1 |
/* SPDX-License-Identifier: LGPL-2.1-or-later */ |
| 2 |
|
| 3 |
#include <fcntl.h> |
| 4 |
#include <linux/rfkill.h> |
| 5 |
#include <poll.h> |
| 6 |
#include <sys/stat.h> |
| 7 |
#include <unistd.h> |
| 8 |
|
| 9 |
#include "sd-daemon.h" |
| 10 |
#include "sd-device.h" |
| 11 |
|
| 12 |
#include "alloc-util.h" |
| 13 |
#include "device-private.h" |
| 14 |
#include "device-util.h" |
| 15 |
#include "errno-util.h" |
| 16 |
#include "escape.h" |
| 17 |
#include "fd-util.h" |
| 18 |
#include "fileio.h" |
| 19 |
#include "io-util.h" |
| 20 |
#include "list.h" |
| 21 |
#include "main-func.h" |
| 22 |
#include "parse-util.h" |
| 23 |
#include "reboot-util.h" |
| 24 |
#include "string-table.h" |
| 25 |
#include "string-util.h" |
| 26 |
#include "time-util.h" |
| 27 |
#include "udev-util.h" |
| 28 |
|
| 29 |
/* Note that any write is delayed until exit and the rfkill state will not be |
| 30 |
* stored for rfkill indices that disappear after a change. */ |
| 31 |
#define EXIT_USEC (5 * USEC_PER_SEC) |
| 32 |
|
| 33 |
typedef struct write_queue_item { |
| 34 |
LIST_FIELDS(struct write_queue_item, queue); |
| 35 |
int rfkill_idx; |
| 36 |
char *file; |
| 37 |
int state; |
| 38 |
} write_queue_item; |
| 39 |
|
| 40 |
typedef struct Context { |
| 41 |
LIST_HEAD(write_queue_item, write_queue); |
| 42 |
int rfkill_fd; |
| 43 |
} Context; |
| 44 |
|
| 45 |
static struct write_queue_item* write_queue_item_free(struct write_queue_item *item) { |
| 46 |
if (!item) |
| 47 |
return NULL; |
| 48 |
|
| 49 |
free(item->file); |
| 50 |
return mfree(item); |
| 51 |
} |
| 52 |
|
| 53 |
static const char* const rfkill_type_table[NUM_RFKILL_TYPES] = { |
| 54 |
[RFKILL_TYPE_ALL] = "all", |
| 55 |
[RFKILL_TYPE_WLAN] = "wlan", |
| 56 |
[RFKILL_TYPE_BLUETOOTH] = "bluetooth", |
| 57 |
[RFKILL_TYPE_UWB] = "uwb", |
| 58 |
[RFKILL_TYPE_WIMAX] = "wimax", |
| 59 |
[RFKILL_TYPE_WWAN] = "wwan", |
| 60 |
[RFKILL_TYPE_GPS] = "gps", |
| 61 |
[RFKILL_TYPE_FM] = "fm", |
| 62 |
[RFKILL_TYPE_NFC] = "nfc", |
| 63 |
}; |
| 64 |
|
| 65 |
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(rfkill_type, int); |
| 66 |
|
| 67 |
static int find_device( |
| 68 |
const struct rfkill_event *event, |
| 69 |
sd_device **ret) { |
| 70 |
_cleanup_(sd_device_unrefp) sd_device *device = NULL; |
| 71 |
_cleanup_free_ char *sysname = NULL; |
| 72 |
const char *name; |
| 73 |
int r; |
| 74 |
|
| 75 |
assert(event); |
| 76 |
assert(ret); |
| 77 |
|
| 78 |
if (asprintf(&sysname, "rfkill%u", event->idx) < 0) |
| 79 |
return log_oom(); |
| 80 |
|
| 81 |
r = sd_device_new_from_subsystem_sysname(&device, "rfkill", sysname); |
| 82 |
if (r < 0) |
| 83 |
return log_full_errno(ERRNO_IS_DEVICE_ABSENT(r) ? LOG_DEBUG : LOG_ERR, r, |
| 84 |
"Failed to open device '%s': %m", sysname); |
| 85 |
|
| 86 |
r = device_get_sysattr_safe_string(device, "name", &name); |
| 87 |
if (r < 0) |
| 88 |
return log_device_debug_errno(device, r, "Device has no name, ignoring: %m"); |
| 89 |
|
| 90 |
log_device_debug(device, "Operating on rfkill device '%s'.", name); |
| 91 |
|
| 92 |
*ret = TAKE_PTR(device); |
| 93 |
return 0; |
| 94 |
} |
| 95 |
|
| 96 |
static int determine_state_file( |
| 97 |
const struct rfkill_event *event, |
| 98 |
char **ret) { |
| 99 |
|
| 100 |
_cleanup_(sd_device_unrefp) sd_device *d = NULL, *device = NULL; |
| 101 |
const char *path_id, *type; |
| 102 |
char *state_file; |
| 103 |
int r; |
| 104 |
|
| 105 |
assert(event); |
| 106 |
assert(ret); |
| 107 |
|
| 108 |
r = find_device(event, &d); |
| 109 |
if (r < 0) |
| 110 |
return r; |
| 111 |
|
| 112 |
r = device_wait_for_initialization(d, "rfkill", USEC_INFINITY, &device); |
| 113 |
if (r < 0) |
| 114 |
return r; |
| 115 |
|
| 116 |
assert_se(type = rfkill_type_to_string(event->type)); |
| 117 |
|
| 118 |
if (sd_device_get_property_value(device, "ID_PATH", &path_id) >= 0) { |
| 119 |
_cleanup_free_ char *escaped_path_id = NULL; |
| 120 |
|
| 121 |
escaped_path_id = cescape(path_id); |
| 122 |
if (!escaped_path_id) |
| 123 |
return log_oom(); |
| 124 |
|
| 125 |
state_file = strjoin("/var/lib/systemd/rfkill/", escaped_path_id, ":", type); |
| 126 |
} else |
| 127 |
state_file = strjoin("/var/lib/systemd/rfkill/", type); |
| 128 |
|
| 129 |
if (!state_file) |
| 130 |
return log_oom(); |
| 131 |
|
| 132 |
*ret = state_file; |
| 133 |
return 0; |
| 134 |
} |
| 135 |
|
| 136 |
static int load_state(Context *c, const struct rfkill_event *event) { |
| 137 |
_cleanup_free_ char *state_file = NULL, *value = NULL; |
| 138 |
int b, r; |
| 139 |
|
| 140 |
assert(c); |
| 141 |
assert(c->rfkill_fd >= 0); |
| 142 |
assert(event); |
| 143 |
|
| 144 |
if (!shall_restore_state()) |
| 145 |
return 0; |
| 146 |
|
| 147 |
r = determine_state_file(event, &state_file); |
| 148 |
if (r < 0) |
| 149 |
return r; |
| 150 |
|
| 151 |
r = read_one_line_file(state_file, &value); |
| 152 |
if (IN_SET(r, -ENOENT, 0)) { |
| 153 |
/* No state file or it's truncated? Then save the current state */ |
| 154 |
|
| 155 |
r = write_string_file(state_file, one_zero(event->soft), WRITE_STRING_FILE_CREATE|WRITE_STRING_FILE_ATOMIC|WRITE_STRING_FILE_MKDIR_0755); |
| 156 |
if (r < 0) |
| 157 |
return log_error_errno(r, "Failed to write state file %s: %m", state_file); |
| 158 |
|
| 159 |
log_debug("Saved state '%s' to %s.", one_zero(event->soft), state_file); |
| 160 |
return 0; |
| 161 |
} |
| 162 |
if (r < 0) |
| 163 |
return log_error_errno(r, "Failed to read state file %s: %m", state_file); |
| 164 |
|
| 165 |
b = parse_boolean(value); |
| 166 |
if (b < 0) |
| 167 |
return log_error_errno(b, "Failed to parse state file %s: %m", state_file); |
| 168 |
|
| 169 |
struct rfkill_event we = { |
| 170 |
.idx = event->idx, |
| 171 |
.op = RFKILL_OP_CHANGE, |
| 172 |
.soft = b, |
| 173 |
}; |
| 174 |
assert_cc(offsetof(struct rfkill_event, op) < RFKILL_EVENT_SIZE_V1); |
| 175 |
assert_cc(offsetof(struct rfkill_event, soft) < RFKILL_EVENT_SIZE_V1); |
| 176 |
|
| 177 |
ssize_t l = write(c->rfkill_fd, &we, sizeof we); |
| 178 |
if (l < 0) |
| 179 |
return log_error_errno(errno, "Failed to restore rfkill state for %u: %m", event->idx); |
| 180 |
if ((size_t)l < RFKILL_EVENT_SIZE_V1) /* l cannot be < 0 here. Cast to fix -Werror=sign-compare */ |
| 181 |
return log_error_errno(SYNTHETIC_ERRNO(EIO), |
| 182 |
"Couldn't write rfkill event structure, too short (wrote %zd of %zu bytes).", |
| 183 |
l, sizeof we); |
| 184 |
log_debug("Writing struct rfkill_event successful (%zd of %zu bytes).", l, sizeof we); |
| 185 |
|
| 186 |
log_debug("Loaded state '%s' from %s.", one_zero(b), state_file); |
| 187 |
return 0; |
| 188 |
} |
| 189 |
|
| 190 |
static void save_state_queue_remove(Context *c, int idx, const char *state_file) { |
| 191 |
assert(c); |
| 192 |
|
| 193 |
LIST_FOREACH(queue, item, c->write_queue) |
| 194 |
if ((state_file && streq(item->file, state_file)) || idx == item->rfkill_idx) { |
| 195 |
log_debug("Canceled previous save state of '%s' to %s.", one_zero(item->state), item->file); |
| 196 |
LIST_REMOVE(queue, c->write_queue, item); |
| 197 |
write_queue_item_free(item); |
| 198 |
} |
| 199 |
} |
| 200 |
|
| 201 |
static int save_state_queue(Context *c, const struct rfkill_event *event) { |
| 202 |
_cleanup_free_ char *state_file = NULL; |
| 203 |
struct write_queue_item *item; |
| 204 |
int r; |
| 205 |
|
| 206 |
assert(c); |
| 207 |
assert(c->rfkill_fd >= 0); |
| 208 |
assert(event); |
| 209 |
|
| 210 |
r = determine_state_file(event, &state_file); |
| 211 |
if (r < 0) |
| 212 |
return r; |
| 213 |
|
| 214 |
save_state_queue_remove(c, event->idx, state_file); |
| 215 |
|
| 216 |
item = new0(struct write_queue_item, 1); |
| 217 |
if (!item) |
| 218 |
return -ENOMEM; |
| 219 |
|
| 220 |
item->file = TAKE_PTR(state_file); |
| 221 |
item->rfkill_idx = event->idx; |
| 222 |
item->state = event->soft; |
| 223 |
|
| 224 |
LIST_APPEND(queue, c->write_queue, item); |
| 225 |
|
| 226 |
return 0; |
| 227 |
} |
| 228 |
|
| 229 |
static int save_state_cancel(Context *c, const struct rfkill_event *event) { |
| 230 |
_cleanup_free_ char *state_file = NULL; |
| 231 |
int r; |
| 232 |
|
| 233 |
assert(c); |
| 234 |
assert(c->rfkill_fd >= 0); |
| 235 |
assert(event); |
| 236 |
|
| 237 |
r = determine_state_file(event, &state_file); |
| 238 |
save_state_queue_remove(c, event->idx, state_file); |
| 239 |
if (r < 0) |
| 240 |
return r; |
| 241 |
|
| 242 |
return 0; |
| 243 |
} |
| 244 |
|
| 245 |
static int save_state_write_one(struct write_queue_item *item) { |
| 246 |
int r; |
| 247 |
|
| 248 |
r = write_string_file(item->file, one_zero(item->state), WRITE_STRING_FILE_CREATE|WRITE_STRING_FILE_ATOMIC|WRITE_STRING_FILE_MKDIR_0755); |
| 249 |
if (r < 0) |
| 250 |
return log_error_errno(r, "Failed to write state file %s: %m", item->file); |
| 251 |
|
| 252 |
log_debug("Saved state '%s' to %s.", one_zero(item->state), item->file); |
| 253 |
return 0; |
| 254 |
} |
| 255 |
|
| 256 |
static void context_save_and_clear(Context *c) { |
| 257 |
struct write_queue_item *i; |
| 258 |
|
| 259 |
assert(c); |
| 260 |
|
| 261 |
while ((i = LIST_POP(queue, c->write_queue))) { |
| 262 |
(void) save_state_write_one(i); |
| 263 |
write_queue_item_free(i); |
| 264 |
} |
| 265 |
|
| 266 |
safe_close(c->rfkill_fd); |
| 267 |
} |
| 268 |
|
| 269 |
static int run(int argc, char *argv[]) { |
| 270 |
_cleanup_(context_save_and_clear) Context c = { .rfkill_fd = -EBADF }; |
| 271 |
bool ready = false; |
| 272 |
int r, n; |
| 273 |
|
| 274 |
if (argc > 1) |
| 275 |
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "This program requires no arguments."); |
| 276 |
|
| 277 |
log_setup(); |
| 278 |
|
| 279 |
umask(0022); |
| 280 |
|
| 281 |
n = sd_listen_fds(false); |
| 282 |
if (n < 0) |
| 283 |
return log_error_errno(n, "Failed to determine whether we got any file descriptors passed: %m"); |
| 284 |
if (n > 1) |
| 285 |
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Got too many file descriptors."); |
| 286 |
|
| 287 |
if (n == 0) { |
| 288 |
c.rfkill_fd = open("/dev/rfkill", O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK); |
| 289 |
if (c.rfkill_fd < 0) { |
| 290 |
if (errno == ENOENT) { |
| 291 |
log_debug_errno(errno, "Missing rfkill subsystem, or no device present, exiting."); |
| 292 |
return 0; |
| 293 |
} |
| 294 |
|
| 295 |
return log_error_errno(errno, "Failed to open %s: %m", "/dev/rfkill"); |
| 296 |
} |
| 297 |
} else { |
| 298 |
c.rfkill_fd = SD_LISTEN_FDS_START; |
| 299 |
|
| 300 |
r = fd_nonblock(c.rfkill_fd, 1); |
| 301 |
if (r < 0) |
| 302 |
return log_error_errno(r, "Failed to make /dev/rfkill socket non-blocking: %m"); |
| 303 |
} |
| 304 |
|
| 305 |
for (;;) { |
| 306 |
struct rfkill_event event = {}; |
| 307 |
|
| 308 |
ssize_t l = read(c.rfkill_fd, &event, sizeof event); |
| 309 |
if (l < 0) { |
| 310 |
if (errno != EAGAIN) |
| 311 |
return log_error_errno(errno, "Failed to read from /dev/rfkill: %m"); |
| 312 |
|
| 313 |
if (!ready) { |
| 314 |
/* Notify manager that we are now finished with processing whatever was |
| 315 |
* queued */ |
| 316 |
r = sd_notify(false, "READY=1"); |
| 317 |
if (r < 0) |
| 318 |
log_warning_errno(r, "Failed to send readiness notification, ignoring: %m"); |
| 319 |
|
| 320 |
ready = true; |
| 321 |
} |
| 322 |
|
| 323 |
/* Hang around for a bit, maybe there's more coming */ |
| 324 |
|
| 325 |
r = fd_wait_for_event(c.rfkill_fd, POLLIN, EXIT_USEC); |
| 326 |
if (r == -EINTR) |
| 327 |
continue; |
| 328 |
if (r < 0) |
| 329 |
return log_error_errno(r, "Failed to poll() on device: %m"); |
| 330 |
if (r > 0) |
| 331 |
continue; |
| 332 |
|
| 333 |
log_debug("All events read and idle, exiting."); |
| 334 |
break; |
| 335 |
} |
| 336 |
|
| 337 |
if ((size_t)l < RFKILL_EVENT_SIZE_V1) /* l cannot be < 0 here. Cast to fix -Werror=sign-compare */ |
| 338 |
return log_error_errno(SYNTHETIC_ERRNO(EIO), "Short read of struct rfkill_event: (%zd < %zu)", |
| 339 |
l, (size_t) RFKILL_EVENT_SIZE_V1); /* Casting necessary to make compiling with different kernel versions happy */ |
| 340 |
log_debug("Reading struct rfkill_event: got %zd bytes.", l); |
| 341 |
|
| 342 |
/* The event structure has more fields. We only care about the first few, so it's OK if we |
| 343 |
* don't read the full structure. */ |
| 344 |
assert_cc(offsetof(struct rfkill_event, op) < RFKILL_EVENT_SIZE_V1); |
| 345 |
assert_cc(offsetof(struct rfkill_event, type) < RFKILL_EVENT_SIZE_V1); |
| 346 |
|
| 347 |
const char *type = rfkill_type_to_string(event.type); |
| 348 |
if (!type) { |
| 349 |
log_debug("An rfkill device of unknown type %u discovered, ignoring.", event.type); |
| 350 |
continue; |
| 351 |
} |
| 352 |
|
| 353 |
switch (event.op) { |
| 354 |
|
| 355 |
case RFKILL_OP_ADD: |
| 356 |
log_debug("A new rfkill device has been added with index %u and type %s.", event.idx, type); |
| 357 |
(void) load_state(&c, &event); |
| 358 |
break; |
| 359 |
|
| 360 |
case RFKILL_OP_DEL: |
| 361 |
log_debug("An rfkill device has been removed with index %u and type %s", event.idx, type); |
| 362 |
(void) save_state_cancel(&c, &event); |
| 363 |
break; |
| 364 |
|
| 365 |
case RFKILL_OP_CHANGE: |
| 366 |
log_debug("An rfkill device has changed state with index %u and type %s", event.idx, type); |
| 367 |
(void) save_state_queue(&c, &event); |
| 368 |
break; |
| 369 |
|
| 370 |
default: |
| 371 |
log_debug("Unknown event %u from /dev/rfkill for index %u and type %s, ignoring.", event.op, event.idx, type); |
| 372 |
} |
| 373 |
} |
| 374 |
|
| 375 |
return 0; |
| 376 |
} |
| 377 |
|
| 378 |
DEFINE_MAIN_FUNCTION(run); |