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

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

Version: ~ [ linux-5.14-rc3 ] ~ [ linux-5.13.5 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.53 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.135 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.198 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.240 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.276 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.276 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ 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.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

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

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | 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.

osdn.jp