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