~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/usb/usbip/src/usbipd.c

Version: ~ [ linux-6.11.5 ] ~ [ linux-6.10.14 ] ~ [ linux-6.9.12 ] ~ [ linux-6.8.12 ] ~ [ linux-6.7.12 ] ~ [ linux-6.6.58 ] ~ [ linux-6.5.13 ] ~ [ linux-6.4.16 ] ~ [ linux-6.3.13 ] ~ [ linux-6.2.16 ] ~ [ linux-6.1.114 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.169 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.228 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.284 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.322 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.336 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.4.302 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0-or-later
  2 /*
  3  * Copyright (C) 2011 matt mooney <mfm@muteddisk.com>
  4  *               2005-2007 Takahiro Hirofuchi
  5  * Copyright (C) 2015-2016 Samsung Electronics
  6  *               Igor Kotrasinski <i.kotrasinsk@samsung.com>
  7  *               Krzysztof Opasiak <k.opasiak@samsung.com>
  8  */
  9 
 10 #ifdef HAVE_CONFIG_H
 11 #include "../config.h"
 12 #endif
 13 
 14 #define _GNU_SOURCE
 15 #include <errno.h>
 16 #include <unistd.h>
 17 #include <netdb.h>
 18 #include <string.h>
 19 #include <stdlib.h>
 20 #include <sys/types.h>
 21 #include <sys/stat.h>
 22 #include <arpa/inet.h>
 23 #include <sys/socket.h>
 24 #include <netinet/in.h>
 25 
 26 #ifdef HAVE_LIBWRAP
 27 #include <tcpd.h>
 28 #endif
 29 
 30 #include <getopt.h>
 31 #include <signal.h>
 32 #include <poll.h>
 33 
 34 #include "usbip_host_driver.h"
 35 #include "usbip_host_common.h"
 36 #include "usbip_device_driver.h"
 37 #include "usbip_common.h"
 38 #include "usbip_network.h"
 39 #include "list.h"
 40 
 41 #undef  PROGNAME
 42 #define PROGNAME "usbipd"
 43 #define MAXSOCKFD 20
 44 
 45 #define MAIN_LOOP_TIMEOUT 10
 46 
 47 #define DEFAULT_PID_FILE "/var/run/" PROGNAME ".pid"
 48 
 49 static const char usbip_version_string[] = PACKAGE_STRING;
 50 
 51 static const char usbipd_help_string[] =
 52         "usage: usbipd [options]\n"
 53         "\n"
 54         "       -4, --ipv4\n"
 55         "               Bind to IPv4. Default is both.\n"
 56         "\n"
 57         "       -6, --ipv6\n"
 58         "               Bind to IPv6. Default is both.\n"
 59         "\n"
 60         "       -e, --device\n"
 61         "               Run in device mode.\n"
 62         "               Rather than drive an attached device, create\n"
 63         "               a virtual UDC to bind gadgets to.\n"
 64         "\n"
 65         "       -D, --daemon\n"
 66         "               Run as a daemon process.\n"
 67         "\n"
 68         "       -d, --debug\n"
 69         "               Print debugging information.\n"
 70         "\n"
 71         "       -PFILE, --pid FILE\n"
 72         "               Write process id to FILE.\n"
 73         "               If no FILE specified, use " DEFAULT_PID_FILE "\n"
 74         "\n"
 75         "       -tPORT, --tcp-port PORT\n"
 76         "               Listen on TCP/IP port PORT.\n"
 77         "\n"
 78         "       -h, --help\n"
 79         "               Print this help.\n"
 80         "\n"
 81         "       -v, --version\n"
 82         "               Show version.\n";
 83 
 84 static struct usbip_host_driver *driver;
 85 
 86 static void usbipd_help(void)
 87 {
 88         printf("%s\n", usbipd_help_string);
 89 }
 90 
 91 static int recv_request_import(int sockfd)
 92 {
 93         struct op_import_request req;
 94         struct usbip_exported_device *edev;
 95         struct usbip_usb_device pdu_udev;
 96         struct list_head *i;
 97         int found = 0;
 98         int status = ST_OK;
 99         int rc;
100 
101         memset(&req, 0, sizeof(req));
102 
103         rc = usbip_net_recv(sockfd, &req, sizeof(req));
104         if (rc < 0) {
105                 dbg("usbip_net_recv failed: import request");
106                 return -1;
107         }
108         PACK_OP_IMPORT_REQUEST(0, &req);
109 
110         list_for_each(i, &driver->edev_list) {
111                 edev = list_entry(i, struct usbip_exported_device, node);
112                 if (!strncmp(req.busid, edev->udev.busid, SYSFS_BUS_ID_SIZE)) {
113                         info("found requested device: %s", req.busid);
114                         found = 1;
115                         break;
116                 }
117         }
118 
119         if (found) {
120                 /* should set TCP_NODELAY for usbip */
121                 usbip_net_set_nodelay(sockfd);
122 
123                 /* export device needs a TCP/IP socket descriptor */
124                 status = usbip_export_device(edev, sockfd);
125                 if (status < 0)
126                         status = ST_NA;
127         } else {
128                 info("requested device not found: %s", req.busid);
129                 status = ST_NODEV;
130         }
131 
132         rc = usbip_net_send_op_common(sockfd, OP_REP_IMPORT, status);
133         if (rc < 0) {
134                 dbg("usbip_net_send_op_common failed: %#0x", OP_REP_IMPORT);
135                 return -1;
136         }
137 
138         if (status) {
139                 dbg("import request busid %s: failed", req.busid);
140                 return -1;
141         }
142 
143         memcpy(&pdu_udev, &edev->udev, sizeof(pdu_udev));
144         usbip_net_pack_usb_device(1, &pdu_udev);
145 
146         rc = usbip_net_send(sockfd, &pdu_udev, sizeof(pdu_udev));
147         if (rc < 0) {
148                 dbg("usbip_net_send failed: devinfo");
149                 return -1;
150         }
151 
152         dbg("import request busid %s: complete", req.busid);
153 
154         return 0;
155 }
156 
157 static int send_reply_devlist(int connfd)
158 {
159         struct usbip_exported_device *edev;
160         struct usbip_usb_device pdu_udev;
161         struct usbip_usb_interface pdu_uinf;
162         struct op_devlist_reply reply;
163         struct list_head *j;
164         int rc, i;
165 
166         /*
167          * Exclude devices that are already exported to a client from
168          * the exportable device list to avoid:
169          *      - import requests for devices that are exported only to
170          *        fail the request.
171          *      - revealing devices that are imported by a client to
172          *        another client.
173          */
174 
175         reply.ndev = 0;
176         /* number of exported devices */
177         list_for_each(j, &driver->edev_list) {
178                 edev = list_entry(j, struct usbip_exported_device, node);
179                 if (edev->status != SDEV_ST_USED)
180                         reply.ndev += 1;
181         }
182         info("exportable devices: %d", reply.ndev);
183 
184         rc = usbip_net_send_op_common(connfd, OP_REP_DEVLIST, ST_OK);
185         if (rc < 0) {
186                 dbg("usbip_net_send_op_common failed: %#0x", OP_REP_DEVLIST);
187                 return -1;
188         }
189         PACK_OP_DEVLIST_REPLY(1, &reply);
190 
191         rc = usbip_net_send(connfd, &reply, sizeof(reply));
192         if (rc < 0) {
193                 dbg("usbip_net_send failed: %#0x", OP_REP_DEVLIST);
194                 return -1;
195         }
196 
197         list_for_each(j, &driver->edev_list) {
198                 edev = list_entry(j, struct usbip_exported_device, node);
199                 if (edev->status == SDEV_ST_USED)
200                         continue;
201 
202                 dump_usb_device(&edev->udev);
203                 memcpy(&pdu_udev, &edev->udev, sizeof(pdu_udev));
204                 usbip_net_pack_usb_device(1, &pdu_udev);
205 
206                 rc = usbip_net_send(connfd, &pdu_udev, sizeof(pdu_udev));
207                 if (rc < 0) {
208                         dbg("usbip_net_send failed: pdu_udev");
209                         return -1;
210                 }
211 
212                 for (i = 0; i < edev->udev.bNumInterfaces; i++) {
213                         dump_usb_interface(&edev->uinf[i]);
214                         memcpy(&pdu_uinf, &edev->uinf[i], sizeof(pdu_uinf));
215                         usbip_net_pack_usb_interface(1, &pdu_uinf);
216 
217                         rc = usbip_net_send(connfd, &pdu_uinf,
218                                         sizeof(pdu_uinf));
219                         if (rc < 0) {
220                                 err("usbip_net_send failed: pdu_uinf");
221                                 return -1;
222                         }
223                 }
224         }
225 
226         return 0;
227 }
228 
229 static int recv_request_devlist(int connfd)
230 {
231         struct op_devlist_request req;
232         int rc;
233 
234         memset(&req, 0, sizeof(req));
235 
236         rc = usbip_net_recv(connfd, &req, sizeof(req));
237         if (rc < 0) {
238                 dbg("usbip_net_recv failed: devlist request");
239                 return -1;
240         }
241 
242         rc = send_reply_devlist(connfd);
243         if (rc < 0) {
244                 dbg("send_reply_devlist failed");
245                 return -1;
246         }
247 
248         return 0;
249 }
250 
251 static int recv_pdu(int connfd)
252 {
253         uint16_t code = OP_UNSPEC;
254         int ret;
255         int status;
256 
257         ret = usbip_net_recv_op_common(connfd, &code, &status);
258         if (ret < 0) {
259                 dbg("could not receive opcode: %#0x", code);
260                 return -1;
261         }
262 
263         ret = usbip_refresh_device_list(driver);
264         if (ret < 0) {
265                 dbg("could not refresh device list: %d", ret);
266                 return -1;
267         }
268 
269         info("received request: %#0x(%d)", code, connfd);
270         switch (code) {
271         case OP_REQ_DEVLIST:
272                 ret = recv_request_devlist(connfd);
273                 break;
274         case OP_REQ_IMPORT:
275                 ret = recv_request_import(connfd);
276                 break;
277         case OP_REQ_DEVINFO:
278         case OP_REQ_CRYPKEY:
279         default:
280                 err("received an unknown opcode: %#0x", code);
281                 ret = -1;
282         }
283 
284         if (ret == 0)
285                 info("request %#0x(%d): complete", code, connfd);
286         else
287                 info("request %#0x(%d): failed", code, connfd);
288 
289         return ret;
290 }
291 
292 #ifdef HAVE_LIBWRAP
293 static int tcpd_auth(int connfd)
294 {
295         struct request_info request;
296         int rc;
297 
298         request_init(&request, RQ_DAEMON, PROGNAME, RQ_FILE, connfd, 0);
299         fromhost(&request);
300         rc = hosts_access(&request);
301         if (rc == 0)
302                 return -1;
303 
304         return 0;
305 }
306 #endif
307 
308 static int do_accept(int listenfd)
309 {
310         int connfd;
311         struct sockaddr_storage ss;
312         socklen_t len = sizeof(ss);
313         char host[NI_MAXHOST], port[NI_MAXSERV];
314         int rc;
315 
316         memset(&ss, 0, sizeof(ss));
317 
318         connfd = accept(listenfd, (struct sockaddr *)&ss, &len);
319         if (connfd < 0) {
320                 err("failed to accept connection");
321                 return -1;
322         }
323 
324         rc = getnameinfo((struct sockaddr *)&ss, len, host, sizeof(host),
325                          port, sizeof(port), NI_NUMERICHOST | NI_NUMERICSERV);
326         if (rc)
327                 err("getnameinfo: %s", gai_strerror(rc));
328 
329 #ifdef HAVE_LIBWRAP
330         rc = tcpd_auth(connfd);
331         if (rc < 0) {
332                 info("denied access from %s", host);
333                 close(connfd);
334                 return -1;
335         }
336 #endif
337         info("connection from %s:%s", host, port);
338 
339         return connfd;
340 }
341 
342 int process_request(int listenfd)
343 {
344         pid_t childpid;
345         int connfd;
346 
347         connfd = do_accept(listenfd);
348         if (connfd < 0)
349                 return -1;
350         childpid = fork();
351         if (childpid == 0) {
352                 close(listenfd);
353                 recv_pdu(connfd);
354                 exit(0);
355         }
356         close(connfd);
357         return 0;
358 }
359 
360 static void addrinfo_to_text(struct addrinfo *ai, char buf[],
361                              const size_t buf_size)
362 {
363         char hbuf[NI_MAXHOST];
364         char sbuf[NI_MAXSERV];
365         int rc;
366 
367         buf[0] = '\0';
368 
369         rc = getnameinfo(ai->ai_addr, ai->ai_addrlen, hbuf, sizeof(hbuf),
370                          sbuf, sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV);
371         if (rc)
372                 err("getnameinfo: %s", gai_strerror(rc));
373 
374         snprintf(buf, buf_size, "%s:%s", hbuf, sbuf);
375 }
376 
377 static int listen_all_addrinfo(struct addrinfo *ai_head, int sockfdlist[],
378                              int maxsockfd)
379 {
380         struct addrinfo *ai;
381         int ret, nsockfd = 0;
382         const size_t ai_buf_size = NI_MAXHOST + NI_MAXSERV + 2;
383         char ai_buf[ai_buf_size];
384 
385         for (ai = ai_head; ai && nsockfd < maxsockfd; ai = ai->ai_next) {
386                 int sock;
387 
388                 addrinfo_to_text(ai, ai_buf, ai_buf_size);
389                 dbg("opening %s", ai_buf);
390                 sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
391                 if (sock < 0) {
392                         err("socket: %s: %d (%s)",
393                             ai_buf, errno, strerror(errno));
394                         continue;
395                 }
396 
397                 usbip_net_set_reuseaddr(sock);
398                 usbip_net_set_nodelay(sock);
399                 /* We use seperate sockets for IPv4 and IPv6
400                  * (see do_standalone_mode()) */
401                 usbip_net_set_v6only(sock);
402 
403                 ret = bind(sock, ai->ai_addr, ai->ai_addrlen);
404                 if (ret < 0) {
405                         err("bind: %s: %d (%s)",
406                             ai_buf, errno, strerror(errno));
407                         close(sock);
408                         continue;
409                 }
410 
411                 ret = listen(sock, SOMAXCONN);
412                 if (ret < 0) {
413                         err("listen: %s: %d (%s)",
414                             ai_buf, errno, strerror(errno));
415                         close(sock);
416                         continue;
417                 }
418 
419                 info("listening on %s", ai_buf);
420                 sockfdlist[nsockfd++] = sock;
421         }
422 
423         return nsockfd;
424 }
425 
426 static struct addrinfo *do_getaddrinfo(char *host, int ai_family)
427 {
428         struct addrinfo hints, *ai_head;
429         int rc;
430 
431         memset(&hints, 0, sizeof(hints));
432         hints.ai_family   = ai_family;
433         hints.ai_socktype = SOCK_STREAM;
434         hints.ai_flags    = AI_PASSIVE;
435 
436         rc = getaddrinfo(host, usbip_port_string, &hints, &ai_head);
437         if (rc) {
438                 err("failed to get a network address %s: %s", usbip_port_string,
439                     gai_strerror(rc));
440                 return NULL;
441         }
442 
443         return ai_head;
444 }
445 
446 static void signal_handler(int i)
447 {
448         dbg("received '%s' signal", strsignal(i));
449 }
450 
451 static void set_signal(void)
452 {
453         struct sigaction act;
454 
455         memset(&act, 0, sizeof(act));
456         act.sa_handler = signal_handler;
457         sigemptyset(&act.sa_mask);
458         sigaction(SIGTERM, &act, NULL);
459         sigaction(SIGINT, &act, NULL);
460         act.sa_handler = SIG_IGN;
461         sigaction(SIGCHLD, &act, NULL);
462 }
463 
464 static const char *pid_file;
465 
466 static void write_pid_file(void)
467 {
468         if (pid_file) {
469                 dbg("creating pid file %s", pid_file);
470                 FILE *fp;
471 
472                 fp = fopen(pid_file, "w");
473                 if (!fp) {
474                         err("pid_file: %s: %d (%s)",
475                             pid_file, errno, strerror(errno));
476                         return;
477                 }
478                 fprintf(fp, "%d\n", getpid());
479                 fclose(fp);
480         }
481 }
482 
483 static void remove_pid_file(void)
484 {
485         if (pid_file) {
486                 dbg("removing pid file %s", pid_file);
487                 unlink(pid_file);
488         }
489 }
490 
491 static int do_standalone_mode(int daemonize, int ipv4, int ipv6)
492 {
493         struct addrinfo *ai_head;
494         int sockfdlist[MAXSOCKFD];
495         int nsockfd, family;
496         int i, terminate;
497         struct pollfd *fds;
498         struct timespec timeout;
499         sigset_t sigmask;
500 
501         if (usbip_driver_open(driver))
502                 return -1;
503 
504         if (daemonize) {
505                 if (daemon(0, 0) < 0) {
506                         err("daemonizing failed: %s", strerror(errno));
507                         usbip_driver_close(driver);
508                         return -1;
509                 }
510                 umask(0);
511                 usbip_use_syslog = 1;
512         }
513         set_signal();
514         write_pid_file();
515 
516         info("starting " PROGNAME " (%s)", usbip_version_string);
517 
518         /*
519          * To suppress warnings on systems with bindv6only disabled
520          * (default), we use seperate sockets for IPv6 and IPv4 and set
521          * IPV6_V6ONLY on the IPv6 sockets.
522          */
523         if (ipv4 && ipv6)
524                 family = AF_UNSPEC;
525         else if (ipv4)
526                 family = AF_INET;
527         else
528                 family = AF_INET6;
529 
530         ai_head = do_getaddrinfo(NULL, family);
531         if (!ai_head) {
532                 usbip_driver_close(driver);
533                 return -1;
534         }
535         nsockfd = listen_all_addrinfo(ai_head, sockfdlist,
536                 sizeof(sockfdlist) / sizeof(*sockfdlist));
537         freeaddrinfo(ai_head);
538         if (nsockfd <= 0) {
539                 err("failed to open a listening socket");
540                 usbip_driver_close(driver);
541                 return -1;
542         }
543 
544         dbg("listening on %d address%s", nsockfd, (nsockfd == 1) ? "" : "es");
545 
546         fds = calloc(nsockfd, sizeof(struct pollfd));
547         for (i = 0; i < nsockfd; i++) {
548                 fds[i].fd = sockfdlist[i];
549                 fds[i].events = POLLIN;
550         }
551         timeout.tv_sec = MAIN_LOOP_TIMEOUT;
552         timeout.tv_nsec = 0;
553 
554         sigfillset(&sigmask);
555         sigdelset(&sigmask, SIGTERM);
556         sigdelset(&sigmask, SIGINT);
557 
558         terminate = 0;
559         while (!terminate) {
560                 int r;
561 
562                 r = ppoll(fds, nsockfd, &timeout, &sigmask);
563                 if (r < 0) {
564                         dbg("%s", strerror(errno));
565                         terminate = 1;
566                 } else if (r) {
567                         for (i = 0; i < nsockfd; i++) {
568                                 if (fds[i].revents & POLLIN) {
569                                         dbg("read event on fd[%d]=%d",
570                                             i, sockfdlist[i]);
571                                         process_request(sockfdlist[i]);
572                                 }
573                         }
574                 } else {
575                         dbg("heartbeat timeout on ppoll()");
576                 }
577         }
578 
579         info("shutting down " PROGNAME);
580         free(fds);
581         usbip_driver_close(driver);
582 
583         return 0;
584 }
585 
586 int main(int argc, char *argv[])
587 {
588         static const struct option longopts[] = {
589                 { "ipv4",     no_argument,       NULL, '4' },
590                 { "ipv6",     no_argument,       NULL, '6' },
591                 { "daemon",   no_argument,       NULL, 'D' },
592                 { "daemon",   no_argument,       NULL, 'D' },
593                 { "debug",    no_argument,       NULL, 'd' },
594                 { "device",   no_argument,       NULL, 'e' },
595                 { "pid",      optional_argument, NULL, 'P' },
596                 { "tcp-port", required_argument, NULL, 't' },
597                 { "help",     no_argument,       NULL, 'h' },
598                 { "version",  no_argument,       NULL, 'v' },
599                 { NULL,       0,                 NULL,  0  }
600         };
601 
602         enum {
603                 cmd_standalone_mode = 1,
604                 cmd_help,
605                 cmd_version
606         } cmd;
607 
608         int daemonize = 0;
609         int ipv4 = 0, ipv6 = 0;
610         int opt, rc = -1;
611 
612         pid_file = NULL;
613 
614         usbip_use_stderr = 1;
615         usbip_use_syslog = 0;
616 
617         if (geteuid() != 0)
618                 err("not running as root?");
619 
620         cmd = cmd_standalone_mode;
621         driver = &host_driver;
622         for (;;) {
623                 opt = getopt_long(argc, argv, "46DdeP::t:hv", longopts, NULL);
624 
625                 if (opt == -1)
626                         break;
627 
628                 switch (opt) {
629                 case '4':
630                         ipv4 = 1;
631                         break;
632                 case '6':
633                         ipv6 = 1;
634                         break;
635                 case 'D':
636                         daemonize = 1;
637                         break;
638                 case 'd':
639                         usbip_use_debug = 1;
640                         break;
641                 case 'h':
642                         cmd = cmd_help;
643                         break;
644                 case 'P':
645                         pid_file = optarg ? optarg : DEFAULT_PID_FILE;
646                         break;
647                 case 't':
648                         usbip_setup_port_number(optarg);
649                         break;
650                 case 'v':
651                         cmd = cmd_version;
652                         break;
653                 case 'e':
654                         driver = &device_driver;
655                         break;
656                 case '?':
657                         usbipd_help();
658                 default:
659                         goto err_out;
660                 }
661         }
662 
663         if (!ipv4 && !ipv6)
664                 ipv4 = ipv6 = 1;
665 
666         switch (cmd) {
667         case cmd_standalone_mode:
668                 rc = do_standalone_mode(daemonize, ipv4, ipv6);
669                 remove_pid_file();
670                 break;
671         case cmd_version:
672                 printf(PROGNAME " (%s)\n", usbip_version_string);
673                 rc = 0;
674                 break;
675         case cmd_help:
676                 usbipd_help();
677                 rc = 0;
678                 break;
679         default:
680                 usbipd_help();
681                 goto err_out;
682         }
683 
684 err_out:
685         return (rc > -1 ? EXIT_SUCCESS : EXIT_FAILURE);
686 }
687 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

sflogo.php