xref: /freebsd/contrib/libfido2/src/hid_linux.c (revision 81b22a98) 
1 /*
2  * Copyright (c) 2019 Yubico AB. All rights reserved.
3  * Use of this source code is governed by a BSD-style
4  * license that can be found in the LICENSE file.
5  */
6 
7 #include <sys/types.h>
8 #include <sys/file.h>
9 #include <sys/ioctl.h>
10 
11 #include <linux/hidraw.h>
12 #include <linux/input.h>
13 
14 #include <errno.h>
15 #include <libudev.h>
16 #include <time.h>
17 #include <unistd.h>
18 
19 #include "fido.h"
20 
21 struct hid_linux {
22 	int             fd;
23 	size_t          report_in_len;
24 	size_t          report_out_len;
25 	sigset_t        sigmask;
26 	const sigset_t *sigmaskp;
27 };
28 
29 static int
30 get_report_descriptor(int fd, struct hidraw_report_descriptor *hrd)
31 {
32 	int s = -1;
33 
34 	if (ioctl(fd, IOCTL_REQ(HIDIOCGRDESCSIZE), &s) == -1) {
35 		fido_log_error(errno, "%s: ioctl HIDIOCGRDESCSIZE", __func__);
36 		return (-1);
37 	}
38 
39 	if (s < 0 || (unsigned)s > HID_MAX_DESCRIPTOR_SIZE) {
40 		fido_log_debug("%s: HIDIOCGRDESCSIZE %d", __func__, s);
41 		return (-1);
42 	}
43 
44 	hrd->size = (unsigned)s;
45 
46 	if (ioctl(fd, IOCTL_REQ(HIDIOCGRDESC), hrd) == -1) {
47 		fido_log_error(errno, "%s: ioctl HIDIOCGRDESC", __func__);
48 		return (-1);
49 	}
50 
51 	return (0);
52 }
53 
54 static bool
55 is_fido(const char *path)
56 {
57 	int				fd;
58 	uint32_t			usage_page = 0;
59 	struct hidraw_report_descriptor	hrd;
60 
61 	memset(&hrd, 0, sizeof(hrd));
62 
63 	if ((fd = fido_hid_unix_open(path)) == -1)
64 		return (false);
65 
66 	if (get_report_descriptor(fd, &hrd) < 0 ||
67 	    fido_hid_get_usage(hrd.value, hrd.size, &usage_page) < 0)
68 		usage_page = 0;
69 
70 	if (close(fd) == -1)
71 		fido_log_error(errno, "%s: close", __func__);
72 
73 	return (usage_page == 0xf1d0);
74 }
75 
76 static int
77 parse_uevent(const char *uevent, int *bus, int16_t *vendor_id,
78     int16_t *product_id)
79 {
80 	char			*cp;
81 	char			*p;
82 	char			*s;
83 	int			 ok = -1;
84 	short unsigned int	 x;
85 	short unsigned int	 y;
86 	short unsigned int	 z;
87 
88 	if ((s = cp = strdup(uevent)) == NULL)
89 		return (-1);
90 
91 	while ((p = strsep(&cp, "\n")) != NULL && *p != '\0') {
92 		if (strncmp(p, "HID_ID=", 7) == 0) {
93 			if (sscanf(p + 7, "%hx:%hx:%hx", &x, &y, &z) == 3) {
94 				*bus = (int)x;
95 				*vendor_id = (int16_t)y;
96 				*product_id = (int16_t)z;
97 				ok = 0;
98 				break;
99 			}
100 		}
101 	}
102 
103 	free(s);
104 
105 	return (ok);
106 }
107 
108 static char *
109 get_parent_attr(struct udev_device *dev, const char *subsystem,
110     const char *devtype, const char *attr)
111 {
112 	struct udev_device	*parent;
113 	const char		*value;
114 
115 	if ((parent = udev_device_get_parent_with_subsystem_devtype(dev,
116 	    subsystem, devtype)) == NULL || (value =
117 	    udev_device_get_sysattr_value(parent, attr)) == NULL)
118 		return (NULL);
119 
120 	return (strdup(value));
121 }
122 
123 static char *
124 get_usb_attr(struct udev_device *dev, const char *attr)
125 {
126 	return (get_parent_attr(dev, "usb", "usb_device", attr));
127 }
128 
129 static int
130 copy_info(fido_dev_info_t *di, struct udev *udev,
131     struct udev_list_entry *udev_entry)
132 {
133 	const char		*name;
134 	const char		*path;
135 	char			*uevent = NULL;
136 	struct udev_device	*dev = NULL;
137 	int			 bus = 0;
138 	int			 ok = -1;
139 
140 	memset(di, 0, sizeof(*di));
141 
142 	if ((name = udev_list_entry_get_name(udev_entry)) == NULL ||
143 	    (dev = udev_device_new_from_syspath(udev, name)) == NULL ||
144 	    (path = udev_device_get_devnode(dev)) == NULL ||
145 	    is_fido(path) == 0)
146 		goto fail;
147 
148 	if ((uevent = get_parent_attr(dev, "hid", NULL, "uevent")) == NULL ||
149 	    parse_uevent(uevent, &bus, &di->vendor_id, &di->product_id) < 0) {
150 		fido_log_debug("%s: uevent", __func__);
151 		goto fail;
152 	}
153 
154 #ifndef FIDO_HID_ANY
155 	if (bus != BUS_USB) {
156 		fido_log_debug("%s: bus", __func__);
157 		goto fail;
158 	}
159 #endif
160 
161 	di->path = strdup(path);
162 	if ((di->manufacturer = get_usb_attr(dev, "manufacturer")) == NULL)
163 		di->manufacturer = strdup("unknown");
164 	if ((di->product = get_usb_attr(dev, "product")) == NULL)
165 		di->product = strdup("unknown");
166 	if (di->path == NULL || di->manufacturer == NULL || di->product == NULL)
167 		goto fail;
168 
169 	ok = 0;
170 fail:
171 	if (dev != NULL)
172 		udev_device_unref(dev);
173 
174 	free(uevent);
175 
176 	if (ok < 0) {
177 		free(di->path);
178 		free(di->manufacturer);
179 		free(di->product);
180 		explicit_bzero(di, sizeof(*di));
181 	}
182 
183 	return (ok);
184 }
185 
186 int
187 fido_hid_manifest(fido_dev_info_t *devlist, size_t ilen, size_t *olen)
188 {
189 	struct udev		*udev = NULL;
190 	struct udev_enumerate	*udev_enum = NULL;
191 	struct udev_list_entry	*udev_list;
192 	struct udev_list_entry	*udev_entry;
193 	int			 r = FIDO_ERR_INTERNAL;
194 
195 	*olen = 0;
196 
197 	if (ilen == 0)
198 		return (FIDO_OK); /* nothing to do */
199 
200 	if (devlist == NULL)
201 		return (FIDO_ERR_INVALID_ARGUMENT);
202 
203 	if ((udev = udev_new()) == NULL ||
204 	    (udev_enum = udev_enumerate_new(udev)) == NULL)
205 		goto fail;
206 
207 	if (udev_enumerate_add_match_subsystem(udev_enum, "hidraw") < 0 ||
208 	    udev_enumerate_scan_devices(udev_enum) < 0)
209 		goto fail;
210 
211 	if ((udev_list = udev_enumerate_get_list_entry(udev_enum)) == NULL) {
212 		r = FIDO_OK; /* zero hidraw devices */
213 		goto fail;
214 	}
215 
216 	udev_list_entry_foreach(udev_entry, udev_list) {
217 		if (copy_info(&devlist[*olen], udev, udev_entry) == 0) {
218 			devlist[*olen].io = (fido_dev_io_t) {
219 				fido_hid_open,
220 				fido_hid_close,
221 				fido_hid_read,
222 				fido_hid_write,
223 			};
224 			if (++(*olen) == ilen)
225 				break;
226 		}
227 	}
228 
229 	r = FIDO_OK;
230 fail:
231 	if (udev_enum != NULL)
232 		udev_enumerate_unref(udev_enum);
233 	if (udev != NULL)
234 		udev_unref(udev);
235 
236 	return (r);
237 }
238 
239 void *
240 fido_hid_open(const char *path)
241 {
242 	struct hid_linux *ctx;
243 	struct hidraw_report_descriptor hrd;
244 	struct timespec tv_pause;
245 	long interval_ms, retries = 0;
246 
247 	if ((ctx = calloc(1, sizeof(*ctx))) == NULL ||
248 	    (ctx->fd = fido_hid_unix_open(path)) == -1) {
249 		free(ctx);
250 		return (NULL);
251 	}
252 
253 	while (flock(ctx->fd, LOCK_EX|LOCK_NB) == -1) {
254 		if (errno != EWOULDBLOCK) {
255 			fido_log_error(errno, "%s: flock", __func__);
256 			fido_hid_close(ctx);
257 			return (NULL);
258 		}
259 		if (retries++ >= 15) {
260 			fido_log_debug("%s: flock timeout", __func__);
261 			fido_hid_close(ctx);
262 			return (NULL);
263 		}
264 		interval_ms = retries * 100000000L;
265 		tv_pause.tv_sec = interval_ms / 1000000000L;
266 		tv_pause.tv_nsec = interval_ms % 1000000000L;
267 		if (nanosleep(&tv_pause, NULL) == -1) {
268 			fido_log_error(errno, "%s: nanosleep", __func__);
269 			fido_hid_close(ctx);
270 			return (NULL);
271 		}
272 	}
273 
274 	if (get_report_descriptor(ctx->fd, &hrd) < 0 ||
275 	    fido_hid_get_report_len(hrd.value, hrd.size, &ctx->report_in_len,
276 	    &ctx->report_out_len) < 0 || ctx->report_in_len == 0 ||
277 	    ctx->report_out_len == 0) {
278 		fido_log_debug("%s: using default report sizes", __func__);
279 		ctx->report_in_len = CTAP_MAX_REPORT_LEN;
280 		ctx->report_out_len = CTAP_MAX_REPORT_LEN;
281 	}
282 
283 	return (ctx);
284 }
285 
286 void
287 fido_hid_close(void *handle)
288 {
289 	struct hid_linux *ctx = handle;
290 
291 	if (close(ctx->fd) == -1)
292 		fido_log_error(errno, "%s: close", __func__);
293 
294 	free(ctx);
295 }
296 
297 int
298 fido_hid_set_sigmask(void *handle, const fido_sigset_t *sigmask)
299 {
300 	struct hid_linux *ctx = handle;
301 
302 	ctx->sigmask = *sigmask;
303 	ctx->sigmaskp = &ctx->sigmask;
304 
305 	return (FIDO_OK);
306 }
307 
308 int
309 fido_hid_read(void *handle, unsigned char *buf, size_t len, int ms)
310 {
311 	struct hid_linux	*ctx = handle;
312 	ssize_t			 r;
313 
314 	if (len != ctx->report_in_len) {
315 		fido_log_debug("%s: len %zu", __func__, len);
316 		return (-1);
317 	}
318 
319 	if (fido_hid_unix_wait(ctx->fd, ms, ctx->sigmaskp) < 0) {
320 		fido_log_debug("%s: fd not ready", __func__);
321 		return (-1);
322 	}
323 
324 	if ((r = read(ctx->fd, buf, len)) == -1) {
325 		fido_log_error(errno, "%s: read", __func__);
326 		return (-1);
327 	}
328 
329 	if (r < 0 || (size_t)r != len) {
330 		fido_log_debug("%s: %zd != %zu", __func__, r, len);
331 		return (-1);
332 	}
333 
334 	return ((int)r);
335 }
336 
337 int
338 fido_hid_write(void *handle, const unsigned char *buf, size_t len)
339 {
340 	struct hid_linux	*ctx = handle;
341 	ssize_t			 r;
342 
343 	if (len != ctx->report_out_len + 1) {
344 		fido_log_debug("%s: len %zu", __func__, len);
345 		return (-1);
346 	}
347 
348 	if ((r = write(ctx->fd, buf, len)) == -1) {
349 		fido_log_error(errno, "%s: write", __func__);
350 		return (-1);
351 	}
352 
353 	if (r < 0 || (size_t)r != len) {
354 		fido_log_debug("%s: %zd != %zu", __func__, r, len);
355 		return (-1);
356 	}
357 
358 	return ((int)r);
359 }
360 
361 size_t
362 fido_hid_report_in_len(void *handle)
363 {
364 	struct hid_linux *ctx = handle;
365 
366 	return (ctx->report_in_len);
367 }
368 
369 size_t
370 fido_hid_report_out_len(void *handle)
371 {
372 	struct hid_linux *ctx = handle;
373 
374 	return (ctx->report_out_len);
375 }
376