1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) 2011 matt mooney <mfm@muteddisk.com> 4 * 2005-2007 Takahiro Hirofuchi 5 */ 6 7 #include <sys/socket.h> 8 9 #include <string.h> 10 11 #include <arpa/inet.h> 12 #include <netdb.h> 13 #include <netinet/tcp.h> 14 #include <unistd.h> 15 16 #ifdef HAVE_LIBWRAP 17 #include <tcpd.h> 18 #endif 19 20 #include "usbip_common.h" 21 #include "usbip_network.h" 22 23 int usbip_port = 3240; 24 char *usbip_port_string = "3240"; 25 26 void usbip_setup_port_number(char *arg) 27 { 28 dbg("parsing port arg '%s'", arg); 29 char *end; 30 unsigned long int port = strtoul(arg, &end, 10); 31 32 if (end == arg) { 33 err("port: could not parse '%s' as a decimal integer", arg); 34 return; 35 } 36 37 if (*end != '\0') { 38 err("port: garbage at end of '%s'", arg); 39 return; 40 } 41 42 if (port > UINT16_MAX) { 43 err("port: %s too high (max=%d)", 44 arg, UINT16_MAX); 45 return; 46 } 47 48 usbip_port = port; 49 usbip_port_string = arg; 50 info("using port %d (\"%s\")", usbip_port, usbip_port_string); 51 } 52 53 uint32_t usbip_net_pack_uint32_t(int pack, uint32_t num) 54 { 55 uint32_t i; 56 57 if (pack) 58 i = htonl(num); 59 else 60 i = ntohl(num); 61 62 return i; 63 } 64 65 uint16_t usbip_net_pack_uint16_t(int pack, uint16_t num) 66 { 67 uint16_t i; 68 69 if (pack) 70 i = htons(num); 71 else 72 i = ntohs(num); 73 74 return i; 75 } 76 77 void usbip_net_pack_usb_device(int pack, struct usbip_usb_device *udev) 78 { 79 udev->busnum = usbip_net_pack_uint32_t(pack, udev->busnum); 80 udev->devnum = usbip_net_pack_uint32_t(pack, udev->devnum); 81 udev->speed = usbip_net_pack_uint32_t(pack, udev->speed); 82 83 udev->idVendor = usbip_net_pack_uint16_t(pack, udev->idVendor); 84 udev->idProduct = usbip_net_pack_uint16_t(pack, udev->idProduct); 85 udev->bcdDevice = usbip_net_pack_uint16_t(pack, udev->bcdDevice); 86 } 87 88 void usbip_net_pack_usb_interface(int pack __attribute__((unused)), 89 struct usbip_usb_interface *udev 90 __attribute__((unused))) 91 { 92 /* uint8_t members need nothing */ 93 } 94 95 static ssize_t usbip_net_xmit(int sockfd, void *buff, size_t bufflen, 96 int sending) 97 { 98 ssize_t nbytes; 99 ssize_t total = 0; 100 101 if (!bufflen) 102 return 0; 103 104 do { 105 if (sending) 106 nbytes = send(sockfd, buff, bufflen, 0); 107 else 108 nbytes = recv(sockfd, buff, bufflen, MSG_WAITALL); 109 110 if (nbytes <= 0) 111 return -1; 112 113 buff = (void *)((intptr_t) buff + nbytes); 114 bufflen -= nbytes; 115 total += nbytes; 116 117 } while (bufflen > 0); 118 119 return total; 120 } 121 122 ssize_t usbip_net_recv(int sockfd, void *buff, size_t bufflen) 123 { 124 return usbip_net_xmit(sockfd, buff, bufflen, 0); 125 } 126 127 ssize_t usbip_net_send(int sockfd, void *buff, size_t bufflen) 128 { 129 return usbip_net_xmit(sockfd, buff, bufflen, 1); 130 } 131 132 static inline void usbip_net_pack_op_common(int pack, 133 struct op_common *op_common) 134 { 135 op_common->version = usbip_net_pack_uint16_t(pack, op_common->version); 136 op_common->code = usbip_net_pack_uint16_t(pack, op_common->code); 137 op_common->status = usbip_net_pack_uint32_t(pack, op_common->status); 138 } 139 140 int usbip_net_send_op_common(int sockfd, uint32_t code, uint32_t status) 141 { 142 struct op_common op_common; 143 int rc; 144 145 memset(&op_common, 0, sizeof(op_common)); 146 147 op_common.version = USBIP_VERSION; 148 op_common.code = code; 149 op_common.status = status; 150 151 usbip_net_pack_op_common(1, &op_common); 152 153 rc = usbip_net_send(sockfd, &op_common, sizeof(op_common)); 154 if (rc < 0) { 155 dbg("usbip_net_send failed: %d", rc); 156 return -1; 157 } 158 159 return 0; 160 } 161 162 int usbip_net_recv_op_common(int sockfd, uint16_t *code, int *status) 163 { 164 struct op_common op_common; 165 int rc; 166 167 memset(&op_common, 0, sizeof(op_common)); 168 169 rc = usbip_net_recv(sockfd, &op_common, sizeof(op_common)); 170 if (rc < 0) { 171 dbg("usbip_net_recv failed: %d", rc); 172 goto err; 173 } 174 175 usbip_net_pack_op_common(0, &op_common); 176 177 if (op_common.version != USBIP_VERSION) { 178 err("USBIP Kernel and tool version mismatch: %d %d:", 179 op_common.version, USBIP_VERSION); 180 goto err; 181 } 182 183 switch (*code) { 184 case OP_UNSPEC: 185 break; 186 default: 187 if (op_common.code != *code) { 188 dbg("unexpected pdu %#0x for %#0x", op_common.code, 189 *code); 190 /* return error status */ 191 *status = ST_ERROR; 192 goto err; 193 } 194 } 195 196 *status = op_common.status; 197 198 if (op_common.status != ST_OK) { 199 dbg("request failed at peer: %d", op_common.status); 200 goto err; 201 } 202 203 *code = op_common.code; 204 205 return 0; 206 err: 207 return -1; 208 } 209 210 int usbip_net_set_reuseaddr(int sockfd) 211 { 212 const int val = 1; 213 int ret; 214 215 ret = setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val)); 216 if (ret < 0) 217 dbg("setsockopt: SO_REUSEADDR"); 218 219 return ret; 220 } 221 222 int usbip_net_set_nodelay(int sockfd) 223 { 224 const int val = 1; 225 int ret; 226 227 ret = setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val)); 228 if (ret < 0) 229 dbg("setsockopt: TCP_NODELAY"); 230 231 return ret; 232 } 233 234 int usbip_net_set_keepalive(int sockfd) 235 { 236 const int val = 1; 237 int ret; 238 239 ret = setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &val, sizeof(val)); 240 if (ret < 0) 241 dbg("setsockopt: SO_KEEPALIVE"); 242 243 return ret; 244 } 245 246 int usbip_net_set_v6only(int sockfd) 247 { 248 const int val = 1; 249 int ret; 250 251 ret = setsockopt(sockfd, IPPROTO_IPV6, IPV6_V6ONLY, &val, sizeof(val)); 252 if (ret < 0) 253 dbg("setsockopt: IPV6_V6ONLY"); 254 255 return ret; 256 } 257 258 /* 259 * IPv6 Ready 260 */ 261 int usbip_net_tcp_connect(char *hostname, char *service) 262 { 263 struct addrinfo hints, *res, *rp; 264 int sockfd; 265 int ret; 266 267 memset(&hints, 0, sizeof(hints)); 268 hints.ai_family = AF_UNSPEC; 269 hints.ai_socktype = SOCK_STREAM; 270 271 /* get all possible addresses */ 272 ret = getaddrinfo(hostname, service, &hints, &res); 273 if (ret < 0) { 274 dbg("getaddrinfo: %s service %s: %s", hostname, service, 275 gai_strerror(ret)); 276 return ret; 277 } 278 279 /* try the addresses */ 280 for (rp = res; rp; rp = rp->ai_next) { 281 sockfd = socket(rp->ai_family, rp->ai_socktype, 282 rp->ai_protocol); 283 if (sockfd < 0) 284 continue; 285 286 /* should set TCP_NODELAY for usbip */ 287 usbip_net_set_nodelay(sockfd); 288 /* TODO: write code for heartbeat */ 289 usbip_net_set_keepalive(sockfd); 290 291 if (connect(sockfd, rp->ai_addr, rp->ai_addrlen) == 0) 292 break; 293 294 close(sockfd); 295 } 296 297 freeaddrinfo(res); 298 299 if (!rp) 300 return EAI_SYSTEM; 301 302 return sockfd; 303 } 304