1 files changed, 679 insertions, 0 deletions

diff --git a/tools/usb/usbip/src/usbipd.c b/tools/usb/usbip/src/usbipd.c
new file mode 100644
index 000000000000..2f87f2d348ba
--- /dev/null
+++ b/tools/usb/usbip/src/usbipd.c
@@ -0,0 +1,679 @@
+/*
+ * Copyright (C) 2011 matt mooney <mfm@muteddisk.com>
+ *               2005-2007 Takahiro Hirofuchi
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
+#define _GNU_SOURCE
+#include <errno.h>
+#include <unistd.h>
+#include <netdb.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <arpa/inet.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+#ifdef HAVE_LIBWRAP
+#include <tcpd.h>
+#endif
+
+#include <getopt.h>
+#include <signal.h>
+#include <poll.h>
+
+#include "usbip_host_driver.h"
+#include "usbip_common.h"
+#include "usbip_network.h"
+#include "list.h"
+
+#undef  PROGNAME
+#define PROGNAME "usbipd"
+#define MAXSOCKFD 20
+
+#define MAIN_LOOP_TIMEOUT 10
+
+#define DEFAULT_PID_FILE "/var/run/" PROGNAME ".pid"
+
+static const char usbip_version_string[] = PACKAGE_STRING;
+
+static const char usbipd_help_string[] =
+        "usage: usbipd [options]\n"
+        "\n"
+        "       -4, --ipv4\n"
+        "               Bind to IPv4. Default is both.\n"
+        "\n"
+        "       -6, --ipv6\n"
+        "               Bind to IPv6. Default is both.\n"
+        "\n"
+        "       -D, --daemon\n"
+        "               Run as a daemon process.\n"
+        "\n"
+        "       -d, --debug\n"
+        "               Print debugging information.\n"
+        "\n"
+        "       -PFILE, --pid FILE\n"
+        "               Write process id to FILE.\n"
+        "               If no FILE specified, use " DEFAULT_PID_FILE "\n"
+        "\n"
+        "       -tPORT, --tcp-port PORT\n"
+        "               Listen on TCP/IP port PORT.\n"
+        "\n"
+        "       -h, --help\n"
+        "               Print this help.\n"
+        "\n"
+        "       -v, --version\n"
+        "               Show version.\n";
+
+static void usbipd_help(void)
+{
+        printf("%s\n", usbipd_help_string);
+}
+
+static int recv_request_import(int sockfd)
+{
+        struct op_import_request req;
+        struct op_common reply;
+        struct usbip_exported_device *edev;
+        struct usbip_usb_device pdu_udev;
+        struct list_head *i;
+        int found = 0;
+        int error = 0;
+        int rc;
+
+        memset(&req, 0, sizeof(req));
+        memset(&reply, 0, sizeof(reply));
+
+        rc = usbip_net_recv(sockfd, &req, sizeof(req));
+        if (rc < 0) {
+                dbg("usbip_net_recv failed: import request");
+                return -1;
+        }
+        PACK_OP_IMPORT_REQUEST(0, &req);
+
+        list_for_each(i, &host_driver->edev_list) {
+                edev = list_entry(i, struct usbip_exported_device, node);
+                if (!strncmp(req.busid, edev->udev.busid, SYSFS_BUS_ID_SIZE)) {
+                        info("found requested device: %s", req.busid);
+                        found = 1;
+                        break;
+                }
+        }
+
+        if (found) {
+                /* should set TCP_NODELAY for usbip */
+                usbip_net_set_nodelay(sockfd);
+
+                /* export device needs a TCP/IP socket descriptor */
+                rc = usbip_host_export_device(edev, sockfd);
+                if (rc < 0)
+                        error = 1;
+        } else {
+                info("requested device not found: %s", req.busid);
+                error = 1;
+        }
+
+        rc = usbip_net_send_op_common(sockfd, OP_REP_IMPORT,
+                                      (!error ? ST_OK : ST_NA));
+        if (rc < 0) {
+                dbg("usbip_net_send_op_common failed: %#0x", OP_REP_IMPORT);
+                return -1;
+        }
+
+        if (error) {
+                dbg("import request busid %s: failed", req.busid);
+                return -1;
+        }
+
+        memcpy(&pdu_udev, &edev->udev, sizeof(pdu_udev));
+        usbip_net_pack_usb_device(1, &pdu_udev);
+
+        rc = usbip_net_send(sockfd, &pdu_udev, sizeof(pdu_udev));
+        if (rc < 0) {
+                dbg("usbip_net_send failed: devinfo");
+                return -1;
+        }
+
+        dbg("import request busid %s: complete", req.busid);
+
+        return 0;
+}
+
+static int send_reply_devlist(int connfd)
+{
+        struct usbip_exported_device *edev;
+        struct usbip_usb_device pdu_udev;
+        struct usbip_usb_interface pdu_uinf;
+        struct op_devlist_reply reply;
+        struct list_head *j;
+        int rc, i;
+
+        reply.ndev = 0;
+        /* number of exported devices */
+        list_for_each(j, &host_driver->edev_list) {
+                reply.ndev += 1;
+        }
+        info("exportable devices: %d", reply.ndev);
+
+        rc = usbip_net_send_op_common(connfd, OP_REP_DEVLIST, ST_OK);
+        if (rc < 0) {
+                dbg("usbip_net_send_op_common failed: %#0x", OP_REP_DEVLIST);
+                return -1;
+        }
+        PACK_OP_DEVLIST_REPLY(1, &reply);
+
+        rc = usbip_net_send(connfd, &reply, sizeof(reply));
+        if (rc < 0) {
+                dbg("usbip_net_send failed: %#0x", OP_REP_DEVLIST);
+                return -1;
+        }
+
+        list_for_each(j, &host_driver->edev_list) {
+                edev = list_entry(j, struct usbip_exported_device, node);
+                dump_usb_device(&edev->udev);
+                memcpy(&pdu_udev, &edev->udev, sizeof(pdu_udev));
+                usbip_net_pack_usb_device(1, &pdu_udev);
+
+                rc = usbip_net_send(connfd, &pdu_udev, sizeof(pdu_udev));
+                if (rc < 0) {
+                        dbg("usbip_net_send failed: pdu_udev");
+                        return -1;
+                }
+
+                for (i = 0; i < edev->udev.bNumInterfaces; i++) {
+                        dump_usb_interface(&edev->uinf[i]);
+                        memcpy(&pdu_uinf, &edev->uinf[i], sizeof(pdu_uinf));
+                        usbip_net_pack_usb_interface(1, &pdu_uinf);
+
+                        rc = usbip_net_send(connfd, &pdu_uinf,
+                                        sizeof(pdu_uinf));
+                        if (rc < 0) {
+                                err("usbip_net_send failed: pdu_uinf");
+                                return -1;
+                        }
+                }
+        }
+
+        return 0;
+}
+
+static int recv_request_devlist(int connfd)
+{
+        struct op_devlist_request req;
+        int rc;
+
+        memset(&req, 0, sizeof(req));
+
+        rc = usbip_net_recv(connfd, &req, sizeof(req));
+        if (rc < 0) {
+                dbg("usbip_net_recv failed: devlist request");
+                return -1;
+        }
+
+        rc = send_reply_devlist(connfd);
+        if (rc < 0) {
+                dbg("send_reply_devlist failed");
+                return -1;
+        }
+
+        return 0;
+}
+
+static int recv_pdu(int connfd)
+{
+        uint16_t code = OP_UNSPEC;
+        int ret;
+
+        ret = usbip_net_recv_op_common(connfd, &code);
+        if (ret < 0) {
+                dbg("could not receive opcode: %#0x", code);
+                return -1;
+        }
+
+        ret = usbip_host_refresh_device_list();
+        if (ret < 0) {
+                dbg("could not refresh device list: %d", ret);
+                return -1;
+        }
+
+        info("received request: %#0x(%d)", code, connfd);
+        switch (code) {
+        case OP_REQ_DEVLIST:
+                ret = recv_request_devlist(connfd);
+                break;
+        case OP_REQ_IMPORT:
+                ret = recv_request_import(connfd);
+                break;
+        case OP_REQ_DEVINFO:
+        case OP_REQ_CRYPKEY:
+        default:
+                err("received an unknown opcode: %#0x", code);
+                ret = -1;
+        }
+
+        if (ret == 0)
+                info("request %#0x(%d): complete", code, connfd);
+        else
+                info("request %#0x(%d): failed", code, connfd);
+
+        return ret;
+}
+
+#ifdef HAVE_LIBWRAP
+static int tcpd_auth(int connfd)
+{
+        struct request_info request;
+        int rc;
+
+        request_init(&request, RQ_DAEMON, PROGNAME, RQ_FILE, connfd, 0);
+        fromhost(&request);
+        rc = hosts_access(&request);
+        if (rc == 0)
+                return -1;
+
+        return 0;
+}
+#endif
+
+static int do_accept(int listenfd)
+{
+        int connfd;
+        struct sockaddr_storage ss;
+        socklen_t len = sizeof(ss);
+        char host[NI_MAXHOST], port[NI_MAXSERV];
+        int rc;
+
+        memset(&ss, 0, sizeof(ss));
+
+        connfd = accept(listenfd, (struct sockaddr *)&ss, &len);
+        if (connfd < 0) {
+                err("failed to accept connection");
+                return -1;
+        }
+
+        rc = getnameinfo((struct sockaddr *)&ss, len, host, sizeof(host),
+                         port, sizeof(port), NI_NUMERICHOST | NI_NUMERICSERV);
+        if (rc)
+                err("getnameinfo: %s", gai_strerror(rc));
+
+#ifdef HAVE_LIBWRAP
+        rc = tcpd_auth(connfd);
+        if (rc < 0) {
+                info("denied access from %s", host);
+                close(connfd);
+                return -1;
+        }
+#endif
+        info("connection from %s:%s", host, port);
+
+        return connfd;
+}
+
+int process_request(int listenfd)
+{
+        pid_t childpid;
+        int connfd;
+
+        connfd = do_accept(listenfd);
+        if (connfd < 0)
+                return -1;
+        childpid = fork();
+        if (childpid == 0) {
+                close(listenfd);
+                recv_pdu(connfd);
+                exit(0);
+        }
+        close(connfd);
+        return 0;
+}
+
+static void addrinfo_to_text(struct addrinfo *ai, char buf[],
+                             const size_t buf_size)
+{
+        char hbuf[NI_MAXHOST];
+        char sbuf[NI_MAXSERV];
+        int rc;
+
+        buf[0] = '\0';
+
+        rc = getnameinfo(ai->ai_addr, ai->ai_addrlen, hbuf, sizeof(hbuf),
+                         sbuf, sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV);
+        if (rc)
+                err("getnameinfo: %s", gai_strerror(rc));
+
+        snprintf(buf, buf_size, "%s:%s", hbuf, sbuf);
+}
+
+static int listen_all_addrinfo(struct addrinfo *ai_head, int sockfdlist[],
+                             int maxsockfd)
+{
+        struct addrinfo *ai;
+        int ret, nsockfd = 0;
+        const size_t ai_buf_size = NI_MAXHOST + NI_MAXSERV + 2;
+        char ai_buf[ai_buf_size];
+
+        for (ai = ai_head; ai && nsockfd < maxsockfd; ai = ai->ai_next) {
+                int sock;
+
+                addrinfo_to_text(ai, ai_buf, ai_buf_size);
+                dbg("opening %s", ai_buf);
+                sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
+                if (sock < 0) {
+                        err("socket: %s: %d (%s)",
+                            ai_buf, errno, strerror(errno));
+                        continue;
+                }
+
+                usbip_net_set_reuseaddr(sock);
+                usbip_net_set_nodelay(sock);
+                /* We use seperate sockets for IPv4 and IPv6
+                 * (see do_standalone_mode()) */
+                usbip_net_set_v6only(sock);
+
+                if (sock >= FD_SETSIZE) {
+                        err("FD_SETSIZE: %s: sock=%d, max=%d",
+                            ai_buf, sock, FD_SETSIZE);
+                        close(sock);
+                        continue;
+                }
+
+                ret = bind(sock, ai->ai_addr, ai->ai_addrlen);
+                if (ret < 0) {
+                        err("bind: %s: %d (%s)",
+                            ai_buf, errno, strerror(errno));
+                        close(sock);
+                        continue;
+                }
+
+                ret = listen(sock, SOMAXCONN);
+                if (ret < 0) {
+                        err("listen: %s: %d (%s)",
+                            ai_buf, errno, strerror(errno));
+                        close(sock);
+                        continue;
+                }
+
+                info("listening on %s", ai_buf);
+                sockfdlist[nsockfd++] = sock;
+        }
+
+        return nsockfd;
+}
+
+static struct addrinfo *do_getaddrinfo(char *host, int ai_family)
+{
+        struct addrinfo hints, *ai_head;
+        int rc;
+
+        memset(&hints, 0, sizeof(hints));
+        hints.ai_family   = ai_family;
+        hints.ai_socktype = SOCK_STREAM;
+        hints.ai_flags    = AI_PASSIVE;
+
+        rc = getaddrinfo(host, usbip_port_string, &hints, &ai_head);
+        if (rc) {
+                err("failed to get a network address %s: %s", usbip_port_string,
+                    gai_strerror(rc));
+                return NULL;
+        }
+
+        return ai_head;
+}
+
+static void signal_handler(int i)
+{
+        dbg("received '%s' signal", strsignal(i));
+}
+
+static void set_signal(void)
+{
+        struct sigaction act;
+
+        memset(&act, 0, sizeof(act));
+        act.sa_handler = signal_handler;
+        sigemptyset(&act.sa_mask);
+        sigaction(SIGTERM, &act, NULL);
+        sigaction(SIGINT, &act, NULL);
+        act.sa_handler = SIG_IGN;
+        sigaction(SIGCLD, &act, NULL);
+}
+
+static const char *pid_file;
+
+static void write_pid_file(void)
+{
+        if (pid_file) {
+                dbg("creating pid file %s", pid_file);
+                FILE *fp;
+
+                fp = fopen(pid_file, "w");
+                if (!fp) {
+                        err("pid_file: %s: %d (%s)",
+                            pid_file, errno, strerror(errno));
+                        return;
+                }
+                fprintf(fp, "%d\n", getpid());
+                fclose(fp);
+        }
+}
+
+static void remove_pid_file(void)
+{
+        if (pid_file) {
+                dbg("removing pid file %s", pid_file);
+                unlink(pid_file);
+        }
+}
+
+static int do_standalone_mode(int daemonize, int ipv4, int ipv6)
+{
+        struct addrinfo *ai_head;
+        int sockfdlist[MAXSOCKFD];
+        int nsockfd, family;
+        int i, terminate;
+        struct pollfd *fds;
+        struct timespec timeout;
+        sigset_t sigmask;
+
+        if (usbip_host_driver_open()) {
+                err("please load " USBIP_CORE_MOD_NAME ".ko and "
+                    USBIP_HOST_DRV_NAME ".ko!");
+                return -1;
+        }
+
+        if (daemonize) {
+                if (daemon(0, 0) < 0) {
+                        err("daemonizing failed: %s", strerror(errno));
+                        usbip_host_driver_close();
+                        return -1;
+                }
+                umask(0);
+                usbip_use_syslog = 1;
+        }
+        set_signal();
+        write_pid_file();
+
+        info("starting " PROGNAME " (%s)", usbip_version_string);
+
+        /*
+         * To suppress warnings on systems with bindv6only disabled
+         * (default), we use seperate sockets for IPv6 and IPv4 and set
+         * IPV6_V6ONLY on the IPv6 sockets.
+         */
+        if (ipv4 && ipv6)
+                family = AF_UNSPEC;
+        else if (ipv4)
+                family = AF_INET;
+        else
+                family = AF_INET6;
+
+        ai_head = do_getaddrinfo(NULL, family);
+        if (!ai_head) {
+                usbip_host_driver_close();
+                return -1;
+        }
+        nsockfd = listen_all_addrinfo(ai_head, sockfdlist,
+                sizeof(sockfdlist) / sizeof(*sockfdlist));
+        freeaddrinfo(ai_head);
+        if (nsockfd <= 0) {
+                err("failed to open a listening socket");
+                usbip_host_driver_close();
+                return -1;
+        }
+
+        dbg("listening on %d address%s", nsockfd, (nsockfd == 1) ? "" : "es");
+
+        fds = calloc(nsockfd, sizeof(struct pollfd));
+        for (i = 0; i < nsockfd; i++) {
+                fds[i].fd = sockfdlist[i];
+                fds[i].events = POLLIN;
+        }
+        timeout.tv_sec = MAIN_LOOP_TIMEOUT;
+        timeout.tv_nsec = 0;
+
+        sigfillset(&sigmask);
+        sigdelset(&sigmask, SIGTERM);
+        sigdelset(&sigmask, SIGINT);
+
+        terminate = 0;
+        while (!terminate) {
+                int r;
+
+                r = ppoll(fds, nsockfd, &timeout, &sigmask);
+                if (r < 0) {
+                        dbg("%s", strerror(errno));
+                        terminate = 1;
+                } else if (r) {
+                        for (i = 0; i < nsockfd; i++) {
+                                if (fds[i].revents & POLLIN) {
+                                        dbg("read event on fd[%d]=%d",
+                                            i, sockfdlist[i]);
+                                        process_request(sockfdlist[i]);
+                                }
+                        }
+                } else {
+                        dbg("heartbeat timeout on ppoll()");
+                }
+        }
+
+        info("shutting down " PROGNAME);
+        free(fds);
+        usbip_host_driver_close();
+
+        return 0;
+}
+
+int main(int argc, char *argv[])
+{
+        static const struct option longopts[] = {
+                { "ipv4",     no_argument,       NULL, '4' },
+                { "ipv6",     no_argument,       NULL, '6' },
+                { "daemon",   no_argument,       NULL, 'D' },
+                { "daemon",   no_argument,       NULL, 'D' },
+                { "debug",    no_argument,       NULL, 'd' },
+                { "pid",      optional_argument, NULL, 'P' },
+                { "tcp-port", required_argument, NULL, 't' },
+                { "help",     no_argument,       NULL, 'h' },
+                { "version",  no_argument,       NULL, 'v' },
+                { NULL,       0,                 NULL,  0  }
+        };
+
+        enum {
+                cmd_standalone_mode = 1,
+                cmd_help,
+                cmd_version
+        } cmd;
+
+        int daemonize = 0;
+        int ipv4 = 0, ipv6 = 0;
+        int opt, rc = -1;
+
+        pid_file = NULL;
+
+        usbip_use_stderr = 1;
+        usbip_use_syslog = 0;
+
+        if (geteuid() != 0)
+                err("not running as root?");
+
+        cmd = cmd_standalone_mode;
+        for (;;) {
+                opt = getopt_long(argc, argv, "46DdP::t:hv", longopts, NULL);
+
+                if (opt == -1)
+                        break;
+
+                switch (opt) {
+                case '4':
+                        ipv4 = 1;
+                        break;
+                case '6':
+                        ipv6 = 1;
+                        break;
+                case 'D':
+                        daemonize = 1;
+                        break;
+                case 'd':
+                        usbip_use_debug = 1;
+                        break;
+                case 'h':
+                        cmd = cmd_help;
+                        break;
+                case 'P':
+                        pid_file = optarg ? optarg : DEFAULT_PID_FILE;
+                        break;
+                case 't':
+                        usbip_setup_port_number(optarg);
+                        break;
+                case 'v':
+                        cmd = cmd_version;
+                        break;
+                case '?':
+                        usbipd_help();
+                default:
+                        goto err_out;
+                }
+        }
+
+        if (!ipv4 && !ipv6)
+                ipv4 = ipv6 = 1;
+
+        switch (cmd) {
+        case cmd_standalone_mode:
+                rc = do_standalone_mode(daemonize, ipv4, ipv6);
+                remove_pid_file();
+                break;
+        case cmd_version:
+                printf(PROGNAME " (%s)\n", usbip_version_string);
+                rc = 0;
+                break;
+        case cmd_help:
+                usbipd_help();
+                rc = 0;
+                break;
+        default:
+                usbipd_help();
+                goto err_out;
+        }
+
+err_out:
+        return (rc > -1 ? EXIT_SUCCESS : EXIT_FAILURE);
+}