1 /* 2 * Copyright (C) 2003-2008 Takahiro Hirofuchi 3 * Copyright (C) 2015-2016 Samsung Electronics 4 * Krzysztof Opasiak <k.opasiak@samsung.com> 5 * 6 * This is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 19 * USA. 20 */ 21 22 #include <asm/byteorder.h> 23 #include <linux/file.h> 24 #include <linux/fs.h> 25 #include <linux/kernel.h> 26 #include <linux/slab.h> 27 #include <linux/stat.h> 28 #include <linux/module.h> 29 #include <linux/moduleparam.h> 30 #include <net/sock.h> 31 32 #include "usbip_common.h" 33 34 #define DRIVER_AUTHOR "Takahiro Hirofuchi <hirofuchi@users.sourceforge.net>" 35 #define DRIVER_DESC "USB/IP Core" 36 37 #ifdef CONFIG_USBIP_DEBUG 38 unsigned long usbip_debug_flag = 0xffffffff; 39 #else 40 unsigned long usbip_debug_flag; 41 #endif 42 EXPORT_SYMBOL_GPL(usbip_debug_flag); 43 module_param(usbip_debug_flag, ulong, S_IRUGO|S_IWUSR); 44 MODULE_PARM_DESC(usbip_debug_flag, "debug flags (defined in usbip_common.h)"); 45 46 /* FIXME */ 47 struct device_attribute dev_attr_usbip_debug; 48 EXPORT_SYMBOL_GPL(dev_attr_usbip_debug); 49 50 static ssize_t usbip_debug_show(struct device *dev, 51 struct device_attribute *attr, char *buf) 52 { 53 return sprintf(buf, "%lx\n", usbip_debug_flag); 54 } 55 56 static ssize_t usbip_debug_store(struct device *dev, 57 struct device_attribute *attr, const char *buf, 58 size_t count) 59 { 60 if (sscanf(buf, "%lx", &usbip_debug_flag) != 1) 61 return -EINVAL; 62 return count; 63 } 64 DEVICE_ATTR_RW(usbip_debug); 65 66 static void usbip_dump_buffer(char *buff, int bufflen) 67 { 68 print_hex_dump(KERN_DEBUG, "usbip-core", DUMP_PREFIX_OFFSET, 16, 4, 69 buff, bufflen, false); 70 } 71 72 static void usbip_dump_pipe(unsigned int p) 73 { 74 unsigned char type = usb_pipetype(p); 75 unsigned char ep = usb_pipeendpoint(p); 76 unsigned char dev = usb_pipedevice(p); 77 unsigned char dir = usb_pipein(p); 78 79 pr_debug("dev(%d) ep(%d) [%s] ", dev, ep, dir ? "IN" : "OUT"); 80 81 switch (type) { 82 case PIPE_ISOCHRONOUS: 83 pr_debug("ISO\n"); 84 break; 85 case PIPE_INTERRUPT: 86 pr_debug("INT\n"); 87 break; 88 case PIPE_CONTROL: 89 pr_debug("CTRL\n"); 90 break; 91 case PIPE_BULK: 92 pr_debug("BULK\n"); 93 break; 94 default: 95 pr_debug("ERR\n"); 96 break; 97 } 98 } 99 100 static void usbip_dump_usb_device(struct usb_device *udev) 101 { 102 struct device *dev = &udev->dev; 103 int i; 104 105 dev_dbg(dev, " devnum(%d) devpath(%s) usb speed(%s)", 106 udev->devnum, udev->devpath, usb_speed_string(udev->speed)); 107 108 pr_debug("tt %p, ttport %d\n", udev->tt, udev->ttport); 109 110 dev_dbg(dev, " "); 111 for (i = 0; i < 16; i++) 112 pr_debug(" %2u", i); 113 pr_debug("\n"); 114 115 dev_dbg(dev, " toggle0(IN) :"); 116 for (i = 0; i < 16; i++) 117 pr_debug(" %2u", (udev->toggle[0] & (1 << i)) ? 1 : 0); 118 pr_debug("\n"); 119 120 dev_dbg(dev, " toggle1(OUT):"); 121 for (i = 0; i < 16; i++) 122 pr_debug(" %2u", (udev->toggle[1] & (1 << i)) ? 1 : 0); 123 pr_debug("\n"); 124 125 dev_dbg(dev, " epmaxp_in :"); 126 for (i = 0; i < 16; i++) { 127 if (udev->ep_in[i]) 128 pr_debug(" %2u", 129 le16_to_cpu(udev->ep_in[i]->desc.wMaxPacketSize)); 130 } 131 pr_debug("\n"); 132 133 dev_dbg(dev, " epmaxp_out :"); 134 for (i = 0; i < 16; i++) { 135 if (udev->ep_out[i]) 136 pr_debug(" %2u", 137 le16_to_cpu(udev->ep_out[i]->desc.wMaxPacketSize)); 138 } 139 pr_debug("\n"); 140 141 dev_dbg(dev, "parent %p, bus %p\n", udev->parent, udev->bus); 142 143 dev_dbg(dev, 144 "descriptor %p, config %p, actconfig %p, rawdescriptors %p\n", 145 &udev->descriptor, udev->config, 146 udev->actconfig, udev->rawdescriptors); 147 148 dev_dbg(dev, "have_langid %d, string_langid %d\n", 149 udev->have_langid, udev->string_langid); 150 151 dev_dbg(dev, "maxchild %d\n", udev->maxchild); 152 } 153 154 static void usbip_dump_request_type(__u8 rt) 155 { 156 switch (rt & USB_RECIP_MASK) { 157 case USB_RECIP_DEVICE: 158 pr_debug("DEVICE"); 159 break; 160 case USB_RECIP_INTERFACE: 161 pr_debug("INTERF"); 162 break; 163 case USB_RECIP_ENDPOINT: 164 pr_debug("ENDPOI"); 165 break; 166 case USB_RECIP_OTHER: 167 pr_debug("OTHER "); 168 break; 169 default: 170 pr_debug("------"); 171 break; 172 } 173 } 174 175 static void usbip_dump_usb_ctrlrequest(struct usb_ctrlrequest *cmd) 176 { 177 if (!cmd) { 178 pr_debug(" : null pointer\n"); 179 return; 180 } 181 182 pr_debug(" "); 183 pr_debug("bRequestType(%02X) bRequest(%02X) wValue(%04X) wIndex(%04X) wLength(%04X) ", 184 cmd->bRequestType, cmd->bRequest, 185 cmd->wValue, cmd->wIndex, cmd->wLength); 186 pr_debug("\n "); 187 188 if ((cmd->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) { 189 pr_debug("STANDARD "); 190 switch (cmd->bRequest) { 191 case USB_REQ_GET_STATUS: 192 pr_debug("GET_STATUS\n"); 193 break; 194 case USB_REQ_CLEAR_FEATURE: 195 pr_debug("CLEAR_FEAT\n"); 196 break; 197 case USB_REQ_SET_FEATURE: 198 pr_debug("SET_FEAT\n"); 199 break; 200 case USB_REQ_SET_ADDRESS: 201 pr_debug("SET_ADDRRS\n"); 202 break; 203 case USB_REQ_GET_DESCRIPTOR: 204 pr_debug("GET_DESCRI\n"); 205 break; 206 case USB_REQ_SET_DESCRIPTOR: 207 pr_debug("SET_DESCRI\n"); 208 break; 209 case USB_REQ_GET_CONFIGURATION: 210 pr_debug("GET_CONFIG\n"); 211 break; 212 case USB_REQ_SET_CONFIGURATION: 213 pr_debug("SET_CONFIG\n"); 214 break; 215 case USB_REQ_GET_INTERFACE: 216 pr_debug("GET_INTERF\n"); 217 break; 218 case USB_REQ_SET_INTERFACE: 219 pr_debug("SET_INTERF\n"); 220 break; 221 case USB_REQ_SYNCH_FRAME: 222 pr_debug("SYNC_FRAME\n"); 223 break; 224 default: 225 pr_debug("REQ(%02X)\n", cmd->bRequest); 226 break; 227 } 228 usbip_dump_request_type(cmd->bRequestType); 229 } else if ((cmd->bRequestType & USB_TYPE_MASK) == USB_TYPE_CLASS) { 230 pr_debug("CLASS\n"); 231 } else if ((cmd->bRequestType & USB_TYPE_MASK) == USB_TYPE_VENDOR) { 232 pr_debug("VENDOR\n"); 233 } else if ((cmd->bRequestType & USB_TYPE_MASK) == USB_TYPE_RESERVED) { 234 pr_debug("RESERVED\n"); 235 } 236 } 237 238 void usbip_dump_urb(struct urb *urb) 239 { 240 struct device *dev; 241 242 if (!urb) { 243 pr_debug("urb: null pointer!!\n"); 244 return; 245 } 246 247 if (!urb->dev) { 248 pr_debug("urb->dev: null pointer!!\n"); 249 return; 250 } 251 252 dev = &urb->dev->dev; 253 254 dev_dbg(dev, " urb :%p\n", urb); 255 dev_dbg(dev, " dev :%p\n", urb->dev); 256 257 usbip_dump_usb_device(urb->dev); 258 259 dev_dbg(dev, " pipe :%08x ", urb->pipe); 260 261 usbip_dump_pipe(urb->pipe); 262 263 dev_dbg(dev, " status :%d\n", urb->status); 264 dev_dbg(dev, " transfer_flags :%08X\n", urb->transfer_flags); 265 dev_dbg(dev, " transfer_buffer :%p\n", urb->transfer_buffer); 266 dev_dbg(dev, " transfer_buffer_length:%d\n", 267 urb->transfer_buffer_length); 268 dev_dbg(dev, " actual_length :%d\n", urb->actual_length); 269 dev_dbg(dev, " setup_packet :%p\n", urb->setup_packet); 270 271 if (urb->setup_packet && usb_pipetype(urb->pipe) == PIPE_CONTROL) 272 usbip_dump_usb_ctrlrequest( 273 (struct usb_ctrlrequest *)urb->setup_packet); 274 275 dev_dbg(dev, " start_frame :%d\n", urb->start_frame); 276 dev_dbg(dev, " number_of_packets :%d\n", urb->number_of_packets); 277 dev_dbg(dev, " interval :%d\n", urb->interval); 278 dev_dbg(dev, " error_count :%d\n", urb->error_count); 279 dev_dbg(dev, " context :%p\n", urb->context); 280 dev_dbg(dev, " complete :%p\n", urb->complete); 281 } 282 EXPORT_SYMBOL_GPL(usbip_dump_urb); 283 284 void usbip_dump_header(struct usbip_header *pdu) 285 { 286 pr_debug("BASE: cmd %u seq %u devid %u dir %u ep %u\n", 287 pdu->base.command, 288 pdu->base.seqnum, 289 pdu->base.devid, 290 pdu->base.direction, 291 pdu->base.ep); 292 293 switch (pdu->base.command) { 294 case USBIP_CMD_SUBMIT: 295 pr_debug("USBIP_CMD_SUBMIT: x_flags %u x_len %u sf %u #p %d iv %d\n", 296 pdu->u.cmd_submit.transfer_flags, 297 pdu->u.cmd_submit.transfer_buffer_length, 298 pdu->u.cmd_submit.start_frame, 299 pdu->u.cmd_submit.number_of_packets, 300 pdu->u.cmd_submit.interval); 301 break; 302 case USBIP_CMD_UNLINK: 303 pr_debug("USBIP_CMD_UNLINK: seq %u\n", 304 pdu->u.cmd_unlink.seqnum); 305 break; 306 case USBIP_RET_SUBMIT: 307 pr_debug("USBIP_RET_SUBMIT: st %d al %u sf %d #p %d ec %d\n", 308 pdu->u.ret_submit.status, 309 pdu->u.ret_submit.actual_length, 310 pdu->u.ret_submit.start_frame, 311 pdu->u.ret_submit.number_of_packets, 312 pdu->u.ret_submit.error_count); 313 break; 314 case USBIP_RET_UNLINK: 315 pr_debug("USBIP_RET_UNLINK: status %d\n", 316 pdu->u.ret_unlink.status); 317 break; 318 default: 319 /* NOT REACHED */ 320 pr_err("unknown command\n"); 321 break; 322 } 323 } 324 EXPORT_SYMBOL_GPL(usbip_dump_header); 325 326 /* Receive data over TCP/IP. */ 327 int usbip_recv(struct socket *sock, void *buf, int size) 328 { 329 int result; 330 struct msghdr msg; 331 struct kvec iov; 332 int total = 0; 333 334 /* for blocks of if (usbip_dbg_flag_xmit) */ 335 char *bp = buf; 336 int osize = size; 337 338 usbip_dbg_xmit("enter\n"); 339 340 if (!sock || !buf || !size) { 341 pr_err("invalid arg, sock %p buff %p size %d\n", sock, buf, 342 size); 343 return -EINVAL; 344 } 345 346 do { 347 sock->sk->sk_allocation = GFP_NOIO; 348 iov.iov_base = buf; 349 iov.iov_len = size; 350 msg.msg_name = NULL; 351 msg.msg_namelen = 0; 352 msg.msg_control = NULL; 353 msg.msg_controllen = 0; 354 msg.msg_flags = MSG_NOSIGNAL; 355 356 result = kernel_recvmsg(sock, &msg, &iov, 1, size, MSG_WAITALL); 357 if (result <= 0) { 358 pr_debug("receive sock %p buf %p size %u ret %d total %d\n", 359 sock, buf, size, result, total); 360 goto err; 361 } 362 363 size -= result; 364 buf += result; 365 total += result; 366 } while (size > 0); 367 368 if (usbip_dbg_flag_xmit) { 369 if (!in_interrupt()) 370 pr_debug("%-10s:", current->comm); 371 else 372 pr_debug("interrupt :"); 373 374 pr_debug("receiving....\n"); 375 usbip_dump_buffer(bp, osize); 376 pr_debug("received, osize %d ret %d size %d total %d\n", 377 osize, result, size, total); 378 } 379 380 return total; 381 382 err: 383 return result; 384 } 385 EXPORT_SYMBOL_GPL(usbip_recv); 386 387 /* there may be more cases to tweak the flags. */ 388 static unsigned int tweak_transfer_flags(unsigned int flags) 389 { 390 flags &= ~URB_NO_TRANSFER_DMA_MAP; 391 return flags; 392 } 393 394 static void usbip_pack_cmd_submit(struct usbip_header *pdu, struct urb *urb, 395 int pack) 396 { 397 struct usbip_header_cmd_submit *spdu = &pdu->u.cmd_submit; 398 399 /* 400 * Some members are not still implemented in usbip. I hope this issue 401 * will be discussed when usbip is ported to other operating systems. 402 */ 403 if (pack) { 404 spdu->transfer_flags = 405 tweak_transfer_flags(urb->transfer_flags); 406 spdu->transfer_buffer_length = urb->transfer_buffer_length; 407 spdu->start_frame = urb->start_frame; 408 spdu->number_of_packets = urb->number_of_packets; 409 spdu->interval = urb->interval; 410 } else { 411 urb->transfer_flags = spdu->transfer_flags; 412 urb->transfer_buffer_length = spdu->transfer_buffer_length; 413 urb->start_frame = spdu->start_frame; 414 urb->number_of_packets = spdu->number_of_packets; 415 urb->interval = spdu->interval; 416 } 417 } 418 419 static void usbip_pack_ret_submit(struct usbip_header *pdu, struct urb *urb, 420 int pack) 421 { 422 struct usbip_header_ret_submit *rpdu = &pdu->u.ret_submit; 423 424 if (pack) { 425 rpdu->status = urb->status; 426 rpdu->actual_length = urb->actual_length; 427 rpdu->start_frame = urb->start_frame; 428 rpdu->number_of_packets = urb->number_of_packets; 429 rpdu->error_count = urb->error_count; 430 } else { 431 urb->status = rpdu->status; 432 urb->actual_length = rpdu->actual_length; 433 urb->start_frame = rpdu->start_frame; 434 urb->number_of_packets = rpdu->number_of_packets; 435 urb->error_count = rpdu->error_count; 436 } 437 } 438 439 void usbip_pack_pdu(struct usbip_header *pdu, struct urb *urb, int cmd, 440 int pack) 441 { 442 switch (cmd) { 443 case USBIP_CMD_SUBMIT: 444 usbip_pack_cmd_submit(pdu, urb, pack); 445 break; 446 case USBIP_RET_SUBMIT: 447 usbip_pack_ret_submit(pdu, urb, pack); 448 break; 449 default: 450 /* NOT REACHED */ 451 pr_err("unknown command\n"); 452 break; 453 } 454 } 455 EXPORT_SYMBOL_GPL(usbip_pack_pdu); 456 457 static void correct_endian_basic(struct usbip_header_basic *base, int send) 458 { 459 if (send) { 460 base->command = cpu_to_be32(base->command); 461 base->seqnum = cpu_to_be32(base->seqnum); 462 base->devid = cpu_to_be32(base->devid); 463 base->direction = cpu_to_be32(base->direction); 464 base->ep = cpu_to_be32(base->ep); 465 } else { 466 base->command = be32_to_cpu(base->command); 467 base->seqnum = be32_to_cpu(base->seqnum); 468 base->devid = be32_to_cpu(base->devid); 469 base->direction = be32_to_cpu(base->direction); 470 base->ep = be32_to_cpu(base->ep); 471 } 472 } 473 474 static void correct_endian_cmd_submit(struct usbip_header_cmd_submit *pdu, 475 int send) 476 { 477 if (send) { 478 pdu->transfer_flags = cpu_to_be32(pdu->transfer_flags); 479 480 cpu_to_be32s(&pdu->transfer_buffer_length); 481 cpu_to_be32s(&pdu->start_frame); 482 cpu_to_be32s(&pdu->number_of_packets); 483 cpu_to_be32s(&pdu->interval); 484 } else { 485 pdu->transfer_flags = be32_to_cpu(pdu->transfer_flags); 486 487 be32_to_cpus(&pdu->transfer_buffer_length); 488 be32_to_cpus(&pdu->start_frame); 489 be32_to_cpus(&pdu->number_of_packets); 490 be32_to_cpus(&pdu->interval); 491 } 492 } 493 494 static void correct_endian_ret_submit(struct usbip_header_ret_submit *pdu, 495 int send) 496 { 497 if (send) { 498 cpu_to_be32s(&pdu->status); 499 cpu_to_be32s(&pdu->actual_length); 500 cpu_to_be32s(&pdu->start_frame); 501 cpu_to_be32s(&pdu->number_of_packets); 502 cpu_to_be32s(&pdu->error_count); 503 } else { 504 be32_to_cpus(&pdu->status); 505 be32_to_cpus(&pdu->actual_length); 506 be32_to_cpus(&pdu->start_frame); 507 be32_to_cpus(&pdu->number_of_packets); 508 be32_to_cpus(&pdu->error_count); 509 } 510 } 511 512 static void correct_endian_cmd_unlink(struct usbip_header_cmd_unlink *pdu, 513 int send) 514 { 515 if (send) 516 pdu->seqnum = cpu_to_be32(pdu->seqnum); 517 else 518 pdu->seqnum = be32_to_cpu(pdu->seqnum); 519 } 520 521 static void correct_endian_ret_unlink(struct usbip_header_ret_unlink *pdu, 522 int send) 523 { 524 if (send) 525 cpu_to_be32s(&pdu->status); 526 else 527 be32_to_cpus(&pdu->status); 528 } 529 530 void usbip_header_correct_endian(struct usbip_header *pdu, int send) 531 { 532 __u32 cmd = 0; 533 534 if (send) 535 cmd = pdu->base.command; 536 537 correct_endian_basic(&pdu->base, send); 538 539 if (!send) 540 cmd = pdu->base.command; 541 542 switch (cmd) { 543 case USBIP_CMD_SUBMIT: 544 correct_endian_cmd_submit(&pdu->u.cmd_submit, send); 545 break; 546 case USBIP_RET_SUBMIT: 547 correct_endian_ret_submit(&pdu->u.ret_submit, send); 548 break; 549 case USBIP_CMD_UNLINK: 550 correct_endian_cmd_unlink(&pdu->u.cmd_unlink, send); 551 break; 552 case USBIP_RET_UNLINK: 553 correct_endian_ret_unlink(&pdu->u.ret_unlink, send); 554 break; 555 default: 556 /* NOT REACHED */ 557 pr_err("unknown command\n"); 558 break; 559 } 560 } 561 EXPORT_SYMBOL_GPL(usbip_header_correct_endian); 562 563 static void usbip_iso_packet_correct_endian( 564 struct usbip_iso_packet_descriptor *iso, int send) 565 { 566 /* does not need all members. but copy all simply. */ 567 if (send) { 568 iso->offset = cpu_to_be32(iso->offset); 569 iso->length = cpu_to_be32(iso->length); 570 iso->status = cpu_to_be32(iso->status); 571 iso->actual_length = cpu_to_be32(iso->actual_length); 572 } else { 573 iso->offset = be32_to_cpu(iso->offset); 574 iso->length = be32_to_cpu(iso->length); 575 iso->status = be32_to_cpu(iso->status); 576 iso->actual_length = be32_to_cpu(iso->actual_length); 577 } 578 } 579 580 static void usbip_pack_iso(struct usbip_iso_packet_descriptor *iso, 581 struct usb_iso_packet_descriptor *uiso, int pack) 582 { 583 if (pack) { 584 iso->offset = uiso->offset; 585 iso->length = uiso->length; 586 iso->status = uiso->status; 587 iso->actual_length = uiso->actual_length; 588 } else { 589 uiso->offset = iso->offset; 590 uiso->length = iso->length; 591 uiso->status = iso->status; 592 uiso->actual_length = iso->actual_length; 593 } 594 } 595 596 /* must free buffer */ 597 struct usbip_iso_packet_descriptor* 598 usbip_alloc_iso_desc_pdu(struct urb *urb, ssize_t *bufflen) 599 { 600 struct usbip_iso_packet_descriptor *iso; 601 int np = urb->number_of_packets; 602 ssize_t size = np * sizeof(*iso); 603 int i; 604 605 iso = kzalloc(size, GFP_KERNEL); 606 if (!iso) 607 return NULL; 608 609 for (i = 0; i < np; i++) { 610 usbip_pack_iso(&iso[i], &urb->iso_frame_desc[i], 1); 611 usbip_iso_packet_correct_endian(&iso[i], 1); 612 } 613 614 *bufflen = size; 615 616 return iso; 617 } 618 EXPORT_SYMBOL_GPL(usbip_alloc_iso_desc_pdu); 619 620 /* some members of urb must be substituted before. */ 621 int usbip_recv_iso(struct usbip_device *ud, struct urb *urb) 622 { 623 void *buff; 624 struct usbip_iso_packet_descriptor *iso; 625 int np = urb->number_of_packets; 626 int size = np * sizeof(*iso); 627 int i; 628 int ret; 629 int total_length = 0; 630 631 if (!usb_pipeisoc(urb->pipe)) 632 return 0; 633 634 /* my Bluetooth dongle gets ISO URBs which are np = 0 */ 635 if (np == 0) 636 return 0; 637 638 buff = kzalloc(size, GFP_KERNEL); 639 if (!buff) 640 return -ENOMEM; 641 642 ret = usbip_recv(ud->tcp_socket, buff, size); 643 if (ret != size) { 644 dev_err(&urb->dev->dev, "recv iso_frame_descriptor, %d\n", 645 ret); 646 kfree(buff); 647 648 if (ud->side == USBIP_STUB || ud->side == USBIP_VUDC) 649 usbip_event_add(ud, SDEV_EVENT_ERROR_TCP); 650 else 651 usbip_event_add(ud, VDEV_EVENT_ERROR_TCP); 652 653 return -EPIPE; 654 } 655 656 iso = (struct usbip_iso_packet_descriptor *) buff; 657 for (i = 0; i < np; i++) { 658 usbip_iso_packet_correct_endian(&iso[i], 0); 659 usbip_pack_iso(&iso[i], &urb->iso_frame_desc[i], 0); 660 total_length += urb->iso_frame_desc[i].actual_length; 661 } 662 663 kfree(buff); 664 665 if (total_length != urb->actual_length) { 666 dev_err(&urb->dev->dev, 667 "total length of iso packets %d not equal to actual length of buffer %d\n", 668 total_length, urb->actual_length); 669 670 if (ud->side == USBIP_STUB || ud->side == USBIP_VUDC) 671 usbip_event_add(ud, SDEV_EVENT_ERROR_TCP); 672 else 673 usbip_event_add(ud, VDEV_EVENT_ERROR_TCP); 674 675 return -EPIPE; 676 } 677 678 return ret; 679 } 680 EXPORT_SYMBOL_GPL(usbip_recv_iso); 681 682 /* 683 * This functions restores the padding which was removed for optimizing 684 * the bandwidth during transfer over tcp/ip 685 * 686 * buffer and iso packets need to be stored and be in propeper endian in urb 687 * before calling this function 688 */ 689 void usbip_pad_iso(struct usbip_device *ud, struct urb *urb) 690 { 691 int np = urb->number_of_packets; 692 int i; 693 int actualoffset = urb->actual_length; 694 695 if (!usb_pipeisoc(urb->pipe)) 696 return; 697 698 /* if no packets or length of data is 0, then nothing to unpack */ 699 if (np == 0 || urb->actual_length == 0) 700 return; 701 702 /* 703 * if actual_length is transfer_buffer_length then no padding is 704 * present. 705 */ 706 if (urb->actual_length == urb->transfer_buffer_length) 707 return; 708 709 /* 710 * loop over all packets from last to first (to prevent overwritting 711 * memory when padding) and move them into the proper place 712 */ 713 for (i = np-1; i > 0; i--) { 714 actualoffset -= urb->iso_frame_desc[i].actual_length; 715 memmove(urb->transfer_buffer + urb->iso_frame_desc[i].offset, 716 urb->transfer_buffer + actualoffset, 717 urb->iso_frame_desc[i].actual_length); 718 } 719 } 720 EXPORT_SYMBOL_GPL(usbip_pad_iso); 721 722 /* some members of urb must be substituted before. */ 723 int usbip_recv_xbuff(struct usbip_device *ud, struct urb *urb) 724 { 725 int ret; 726 int size; 727 728 if (ud->side == USBIP_STUB || ud->side == USBIP_VUDC) { 729 /* the direction of urb must be OUT. */ 730 if (usb_pipein(urb->pipe)) 731 return 0; 732 733 size = urb->transfer_buffer_length; 734 } else { 735 /* the direction of urb must be IN. */ 736 if (usb_pipeout(urb->pipe)) 737 return 0; 738 739 size = urb->actual_length; 740 } 741 742 /* no need to recv xbuff */ 743 if (!(size > 0)) 744 return 0; 745 746 if (size > urb->transfer_buffer_length) { 747 /* should not happen, probably malicious packet */ 748 if (ud->side == USBIP_STUB) { 749 usbip_event_add(ud, SDEV_EVENT_ERROR_TCP); 750 return 0; 751 } else { 752 usbip_event_add(ud, VDEV_EVENT_ERROR_TCP); 753 return -EPIPE; 754 } 755 } 756 757 ret = usbip_recv(ud->tcp_socket, urb->transfer_buffer, size); 758 if (ret != size) { 759 dev_err(&urb->dev->dev, "recv xbuf, %d\n", ret); 760 if (ud->side == USBIP_STUB || ud->side == USBIP_VUDC) { 761 usbip_event_add(ud, SDEV_EVENT_ERROR_TCP); 762 } else { 763 usbip_event_add(ud, VDEV_EVENT_ERROR_TCP); 764 return -EPIPE; 765 } 766 } 767 768 return ret; 769 } 770 EXPORT_SYMBOL_GPL(usbip_recv_xbuff); 771 772 static int __init usbip_core_init(void) 773 { 774 int ret; 775 776 pr_info(DRIVER_DESC " v" USBIP_VERSION "\n"); 777 ret = usbip_init_eh(); 778 if (ret) 779 return ret; 780 781 return 0; 782 } 783 784 static void __exit usbip_core_exit(void) 785 { 786 usbip_finish_eh(); 787 return; 788 } 789 790 module_init(usbip_core_init); 791 module_exit(usbip_core_exit); 792 793 MODULE_AUTHOR(DRIVER_AUTHOR); 794 MODULE_DESCRIPTION(DRIVER_DESC); 795 MODULE_LICENSE("GPL"); 796 MODULE_VERSION(USBIP_VERSION); 797