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