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 #include <sys/stat.h> 23 24 #include <limits.h> 25 #include <stdint.h> 26 #include <stdio.h> 27 #include <string.h> 28 29 #include <fcntl.h> 30 #include <getopt.h> 31 #include <unistd.h> 32 #include <errno.h> 33 34 #include "vhci_driver.h" 35 #include "usbip_common.h" 36 #include "usbip_network.h" 37 #include "usbip.h" 38 39 static const char usbip_attach_usage_string[] = 40 "usbip attach <args>\n" 41 " -r, --remote=<host> The machine with exported USB devices\n" 42 " -b, --busid=<busid> Busid of the device on <host>\n" 43 " -d, --device=<devid> Id of the virtual UDC on <host>\n"; 44 45 void usbip_attach_usage(void) 46 { 47 printf("usage: %s", usbip_attach_usage_string); 48 } 49 50 #define MAX_BUFF 100 51 static int record_connection(char *host, char *port, char *busid, int rhport) 52 { 53 int fd; 54 char path[PATH_MAX+1]; 55 char buff[MAX_BUFF+1]; 56 int ret; 57 58 ret = mkdir(VHCI_STATE_PATH, 0700); 59 if (ret < 0) { 60 /* if VHCI_STATE_PATH exists, then it better be a directory */ 61 if (errno == EEXIST) { 62 struct stat s; 63 64 ret = stat(VHCI_STATE_PATH, &s); 65 if (ret < 0) 66 return -1; 67 if (!(s.st_mode & S_IFDIR)) 68 return -1; 69 } else 70 return -1; 71 } 72 73 snprintf(path, PATH_MAX, VHCI_STATE_PATH"/port%d", rhport); 74 75 fd = open(path, O_WRONLY|O_CREAT|O_TRUNC, S_IRWXU); 76 if (fd < 0) 77 return -1; 78 79 snprintf(buff, MAX_BUFF, "%s %s %s\n", 80 host, port, busid); 81 82 ret = write(fd, buff, strlen(buff)); 83 if (ret != (ssize_t) strlen(buff)) { 84 close(fd); 85 return -1; 86 } 87 88 close(fd); 89 90 return 0; 91 } 92 93 static int import_device(int sockfd, struct usbip_usb_device *udev) 94 { 95 int rc; 96 int port; 97 uint32_t speed = udev->speed; 98 99 rc = usbip_vhci_driver_open(); 100 if (rc < 0) { 101 err("open vhci_driver"); 102 goto err_out; 103 } 104 105 do { 106 port = usbip_vhci_get_free_port(speed); 107 if (port < 0) { 108 err("no free port"); 109 goto err_driver_close; 110 } 111 112 dbg("got free port %d", port); 113 114 rc = usbip_vhci_attach_device(port, sockfd, udev->busnum, 115 udev->devnum, udev->speed); 116 if (rc < 0 && errno != EBUSY) { 117 err("import device"); 118 goto err_driver_close; 119 } 120 } while (rc < 0); 121 122 usbip_vhci_driver_close(); 123 124 return port; 125 126 err_driver_close: 127 usbip_vhci_driver_close(); 128 err_out: 129 return -1; 130 } 131 132 static int query_import_device(int sockfd, char *busid) 133 { 134 int rc; 135 struct op_import_request request; 136 struct op_import_reply reply; 137 uint16_t code = OP_REP_IMPORT; 138 139 memset(&request, 0, sizeof(request)); 140 memset(&reply, 0, sizeof(reply)); 141 142 /* send a request */ 143 rc = usbip_net_send_op_common(sockfd, OP_REQ_IMPORT, 0); 144 if (rc < 0) { 145 err("send op_common"); 146 return -1; 147 } 148 149 strncpy(request.busid, busid, SYSFS_BUS_ID_SIZE-1); 150 151 PACK_OP_IMPORT_REQUEST(0, &request); 152 153 rc = usbip_net_send(sockfd, (void *) &request, sizeof(request)); 154 if (rc < 0) { 155 err("send op_import_request"); 156 return -1; 157 } 158 159 /* receive a reply */ 160 rc = usbip_net_recv_op_common(sockfd, &code); 161 if (rc < 0) { 162 err("recv op_common"); 163 return -1; 164 } 165 166 rc = usbip_net_recv(sockfd, (void *) &reply, sizeof(reply)); 167 if (rc < 0) { 168 err("recv op_import_reply"); 169 return -1; 170 } 171 172 PACK_OP_IMPORT_REPLY(0, &reply); 173 174 /* check the reply */ 175 if (strncmp(reply.udev.busid, busid, SYSFS_BUS_ID_SIZE)) { 176 err("recv different busid %s", reply.udev.busid); 177 return -1; 178 } 179 180 /* import a device */ 181 return import_device(sockfd, &reply.udev); 182 } 183 184 static int attach_device(char *host, char *busid) 185 { 186 int sockfd; 187 int rc; 188 int rhport; 189 190 sockfd = usbip_net_tcp_connect(host, usbip_port_string); 191 if (sockfd < 0) { 192 err("tcp connect"); 193 return -1; 194 } 195 196 rhport = query_import_device(sockfd, busid); 197 if (rhport < 0) { 198 err("Attach request for Device %s. Is this device exported?", 199 busid); 200 return -1; 201 } 202 203 close(sockfd); 204 205 rc = record_connection(host, usbip_port_string, busid, rhport); 206 if (rc < 0) { 207 err("record connection"); 208 return -1; 209 } 210 211 return 0; 212 } 213 214 int usbip_attach(int argc, char *argv[]) 215 { 216 static const struct option opts[] = { 217 { "remote", required_argument, NULL, 'r' }, 218 { "busid", required_argument, NULL, 'b' }, 219 { "device", required_argument, NULL, 'd' }, 220 { NULL, 0, NULL, 0 } 221 }; 222 char *host = NULL; 223 char *busid = NULL; 224 int opt; 225 int ret = -1; 226 227 for (;;) { 228 opt = getopt_long(argc, argv, "d:r:b:", opts, NULL); 229 230 if (opt == -1) 231 break; 232 233 switch (opt) { 234 case 'r': 235 host = optarg; 236 break; 237 case 'd': 238 case 'b': 239 busid = optarg; 240 break; 241 default: 242 goto err_out; 243 } 244 } 245 246 if (!host || !busid) 247 goto err_out; 248 249 ret = attach_device(host, busid); 250 goto out; 251 252 err_out: 253 usbip_attach_usage(); 254 out: 255 return ret; 256 } 257