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