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