API tools faq
paste
Advertisement
Guest User

usb host 2 host transfer

a guest
Nov 13th, 2017
152
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
PureBasic 8.44 KB | None | 0 0
raw download clone embed print report
  1.  
  2. #define MAX_SENSE_LENGTH 24
  3. #define MAX_CDB_LENGTH 16
  4. #define MAX_TRANSFER_BUFFER_LENGTH 1 << 16
  5.  
  6. #ifdef MS_WINDOWS
  7. #include <windows.h>
  8. #include <ntddscsi.h>
  9. #else
  10.  
  11. #include <stdio.h>      /* For snprintf(3).                       */
  12. #include <errno.h>      /* For <errno>.  See errno(3).            */
  13. #include <string.h>     /* For strerror(3).                       */
  14. #include <stdarg.h>     /* For the <__VA_ARGS__> macro.           */
  15. #include <fcntl.h>      /* Manipulate file descriptors; fcntl(2). */
  16. #include <sys/stat.h>   /* File status information; see stat(2).  */
  17. #include <sys/types.h>  /* System types; see types.h(0).          */
  18.  
  19. #include <scsi/sg.h>
  20. #include <sys/ioctl.h>
  21.  
  22. #define INTERFACE_ID 'S'    
  23. typedef int HANDLE;
  24. #define INVALID_HANDLE_VALUE -1
  25.  
  26. #define TRUE 1
  27. #define FALSE 0
  28.  
  29. typedef struct
  30. {
  31.     sg_io_hdr_t io_hdr;
  32.     unsigned char cdb[MAX_CDB_LENGTH];
  33.     unsigned char sense_buffer[MAX_SENSE_LENGTH];
  34. } SCSI_PASS_THROUGH_DIRECT;
  35. #endif
  36.  
  37. unsigned char usb_h2h_cdb_read[MAX_CDB_LENGTH]  = {217,40,100,0,0,0,0,0,0,0,0,0,0,0,79,84};
  38. unsigned char usb_h2h_cdb_write[MAX_CDB_LENGTH] = {217,42,255,0,0,0,0,0,0,0,0,0,0,0,79,84};
  39.  
  40. typedef struct
  41. {
  42.     SCSI_PASS_THROUGH_DIRECT scsi_op;
  43.     HANDLE handle_dev; 
  44.     unsigned char* buffer;
  45.     unsigned int buffer_size;
  46.     unsigned char read_count;
  47. } USB_HOST_TO_HOST_TRANSFER;
  48.  
  49. int is_invalid_device_handle(HANDLE handle)
  50. {
  51.     #ifdef MS_WINDOWS
  52.     return (INVALID_HANDLE_VALUE == handle);
  53.     #else
  54.     return (handle < 0);
  55.     #endif
  56. }
  57.  
  58. void close_device_handle(HANDLE handle)
  59. {
  60.     if (is_invalid_device_handle(handle))
  61.     {
  62.         // handle is invalid
  63.     }
  64.     else
  65.     {
  66.         #ifdef MS_WINDOWS
  67.         CloseHandle(handle);
  68.         #else
  69.         close(handle);
  70.         #endif
  71.     }
  72. }
  73.  
  74. int is_invalid_device_name(const char *dev_path)
  75. {
  76.     #ifdef MS_WINDOWS  
  77.     char tmp[] = {'\\', '\\', '.', '\\', 'X' , ':' , 0};
  78.    
  79.     if (strlen(dev_path) = strlen(tmp))
  80.     {
  81.         char drive = dev_path[4];
  82.         tmp[4] = drive;
  83.        
  84.         if ( (drive >= 'a' && drive <= 'z') || (drive >= 'A' && drive <= 'Z') )
  85.         {  
  86.             if (strncmp(dev_path, tmp, strlen(tmp)) == 0)
  87.             {
  88.                 return FALSE;
  89.             }
  90.         }
  91.     }
  92.     #else
  93.     char tmp[] = {'/', 'd', 'e', 'v', '/' , 's', 'g', 0};
  94.    
  95.     if (strlen(dev_path) > strlen(tmp))
  96.     {
  97.         if (strncmp(dev_path, tmp, strlen(tmp)) == 0)
  98.         {
  99.             return FALSE;
  100.         }
  101.     }  
  102.     #endif
  103.     return TRUE;
  104. }
  105.  
  106. void freeDevice(USB_HOST_TO_HOST_TRANSFER *transfer)
  107. {
  108.     if (transfer == NULL)
  109.     {
  110.         if (transfer->buffer)
  111.             free(transfer->buffer);
  112.         close_device_handle(transfer->handle_dev);     
  113.     }
  114. }
  115.  
  116. void* getDeviceMemory(USB_HOST_TO_HOST_TRANSFER *transfer)
  117. {
  118.     if (transfer )
  119.     {  
  120.         return transfer->buffer;
  121.     }
  122.     return NULL;
  123. }
  124.  
  125. int __fill_SCSI_PASS_THROUGH_DIRECT(SCSI_PASS_THROUGH_DIRECT *op, int direction_read, unsigned int timeout, unsigned char *cdb, unsigned int cdb_size, void *buffer, unsigned int buffer_size)
  126. {
  127.     if (op)
  128.     {
  129.         if (buffer && (buffer_size > 0) && (buffer_size <= MAX_TRANSFER_BUFFER_LENGTH))
  130.         {
  131.             if ((cdb_size > 0) && (cdb_size <= MAX_CDB_LENGTH))
  132.             {
  133.                 //ok
  134.             }
  135.             else
  136.             {
  137.                 return FALSE;
  138.             }
  139.         }      
  140.         else
  141.         {
  142.             return FALSE;  
  143.         }  
  144.     }
  145.     else
  146.     {
  147.     return FALSE;
  148.     }  
  149.     #ifdef MS_WINDOWS
  150.         memset(op, 0, sizeof(SCSI_PASS_THROUGH_DIRECT));
  151.        
  152.         op->ScsiStatus = -1;
  153.         op->PathId = -1;
  154.         op->TargetId = -1;
  155.         op->Lun = -1;
  156.            
  157.         op->Length = sizeof(SCSI_PASS_THROUGH_DIRECT);
  158.  
  159.         op->DataIn = direction;
  160.         op->TimeOutValue = timeout;
  161.        
  162.         op->DataBuffer = data;
  163.         op->DataTransferLength = data_size;
  164.        
  165.         memcpy(sptd->Cdb, cdb, cdb_size);
  166.         op->CdbLength = cdb_size;
  167.  
  168.         op->SenseInfoLength = SENSE_LENGTH;
  169.         op->SenseInfoOffset = 48;
  170.     #else
  171.         memset(&op->io_hdr, 0, sizeof(sg_io_hdr_t));
  172.         memset(&op->sense_buffer, 0, MAX_SENSE_LENGTH);
  173.         op->io_hdr.interface_id = INTERFACE_ID;
  174.         op->io_hdr.mx_sb_len = MAX_SENSE_LENGTH;
  175.         op->io_hdr.timeout = timeout;
  176.         op->io_hdr.cmdp = op->cdb;
  177.         op->io_hdr.cmd_len = cdb_size;
  178.  
  179.         memcpy(op->cdb, cdb, cdb_size);
  180.         if (direction_read)
  181.         {
  182.             op->io_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
  183.         }
  184.         else
  185.         {
  186.             op->io_hdr.dxfer_direction = SG_DXFER_TO_DEV;  
  187.         }
  188.         op->io_hdr.dxferp = buffer;
  189.         op->io_hdr.dxfer_len = buffer_size;
  190.     #endif
  191.     return TRUE;
  192. }
  193.  
  194.  
  195. int sendDevice(USB_HOST_TO_HOST_TRANSFER *transfer)
  196. {
  197.     int status;
  198.    
  199.     __fill_SCSI_PASS_THROUGH_DIRECT(&transfer->scsi_op, FALSE, 5, usb_h2h_cdb_write, MAX_CDB_LENGTH, transfer->buffer, transfer->buffer_size); 
  200.     status = ioctl(transfer->handle_dev, SG_IO, &transfer->scsi_op);   
  201.     //printf("driver: %i\n",io_hdr_write.driver_status);
  202.     //printf("driver w: %i\n",io_hdr_write.host_status);
  203.            
  204. }
  205.  
  206. int readDevice(USB_HOST_TO_HOST_TRANSFER *transfer)
  207. {
  208.     int status;
  209.    
  210.     __fill_SCSI_PASS_THROUGH_DIRECT(&transfer->scsi_op, TRUE, 5, usb_h2h_cdb_read, MAX_CDB_LENGTH, transfer->buffer, transfer->buffer_size);   
  211.     #ifdef MS_WINDOWS
  212.         transfer->scsi_op.Cdb[8] = transfer->read_count;
  213.     #else
  214.         transfer->scsi_op.cdb[8] = transfer->read_count;
  215.     #endif 
  216.     status = ioctl(transfer->handle_dev, SG_IO, &transfer->scsi_op);
  217.     transfer->read_count++;
  218.        
  219.     //printf("driver: %i\n",io_hdr_write.driver_status);
  220.     //printf("driver w: %i\n",io_hdr_write.host_status);
  221.            
  222. }
  223.  
  224.  
  225. int openDevice(USB_HOST_TO_HOST_TRANSFER *transfer, char *dev_path)
  226. {
  227.     HANDLE handle = INVALID_HANDLE_VALUE;
  228.     char *buffer = NULL;
  229.     int ok = TRUE;
  230.     int vers;  
  231.    
  232.     if (transfer == NULL)
  233.     {
  234.         ok = FALSE;
  235.     }
  236.    
  237.     if (dev_path == NULL)
  238.     {
  239.         ok = FALSE;
  240.     }
  241.    
  242.     if (ok)
  243.     {      
  244.         if (is_invalid_device_name(dev_path))
  245.         {
  246.             fprintf(stderr,"invalid device path '%s'!\n", dev_path);
  247.             ok = FALSE;
  248.         }
  249.     }
  250.    
  251.     if (ok)
  252.     {          
  253.         #ifdef MS_WINDOWS
  254.         handle = CreateFile(dev_path, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,0,OPEN_EXISTING,FILE_FLAG_NO_BUFFERING,0);
  255.         #else
  256.         handle = open(dev_path, O_RDWR);
  257.         #endif
  258.        
  259.         if (is_invalid_device_handle(handle))
  260.         {
  261.             fprintf(stderr,"open device '%s' failed!\n", dev_path);
  262.             ok = FALSE;
  263.         }
  264.     }
  265.    
  266.     if (ok)
  267.     {      
  268.         #ifdef MS_WINDOWS
  269.         if (GetDriveType(dev_path + strlen("\\\\.\\")) != DRIVE_CDROM)
  270.         {
  271.             fprintf(stderr, "Device '%s' is not detected as CDROM drive", dev_path);
  272.             CloseHandle(handle);
  273.         }
  274.         #else
  275.         if ((ioctl(handle, SG_GET_VERSION_NUM, &vers) < 0) || (vers < 30000)) {
  276.             fprintf(stderr, "Device '%s' is not an sg device, or old sg driver\n", dev_path);
  277.            
  278.         }    
  279.         #endif
  280.     }
  281.  
  282.     if (ok)
  283.     {  
  284.         buffer = malloc(MAX_TRANSFER_BUFFER_LENGTH);
  285.         if (buffer == NULL)
  286.         {
  287.             fprintf(stderr, "Cannot allocate memory\n", dev_path);
  288.             ok = FALSE;
  289.         }
  290.     }
  291.    
  292.     if (ok)
  293.     {
  294.         transfer->handle_dev = handle;
  295.         transfer->read_count = 0;
  296.         transfer->buffer = buffer;
  297.         transfer->buffer_size = MAX_TRANSFER_BUFFER_LENGTH;    
  298.     }
  299.     else
  300.     {
  301.         if (buffer)
  302.             free(buffer);
  303.         close_device_handle(handle);
  304.     }
  305.     return ok;
  306. }
  307.  
  308.  
  309.  
  310.  
  311.  
  312.  
  313.  
  314.  
  315.  
  316.    
  317.  
  318.  
  319. void main()
  320. {
  321.     USB_HOST_TO_HOST_TRANSFER t;
  322.  
  323.     openDevice(&t, "/dev/sg2");
  324.    
  325.    
  326.    
  327.     char *data_write = getDeviceMemory(&t);
  328.     memset(data_write,0, 65536);
  329.    
  330.     data_write[0] = 'H';
  331.     data_write[1] = 'a';    
  332.     data_write[2] = 'l';
  333.     data_write[3] = 'l';
  334.     data_write[4] = 'o';
  335.     data_write[5] = ' ';
  336.     data_write[6] = 'W';
  337.     data_write[7] = 'i';
  338.     data_write[8] = 'c';
  339.     data_write[9] = 'h';
  340.     data_write[10] = 's';
  341.     data_write[11] = 'e';
  342.     data_write[12] = 'r';
  343.                                                
  344.  
  345.  
  346.     while(1)
  347.     {
  348.        
  349.         sendDevice(&t);
  350.        
  351.     }
  352.         /*
  353.     getSGHDR(&io_hdr_write, SG_DXFER_TO_DEV, 500, cdb_send, 16, data_write, data_size_write);
  354.     status = ioctl(fd_write, SG_IO, &io_hdr_write);
  355.    
  356.         printf("driver: %i\n",io_hdr_write.driver_status);
  357.             printf("driver w: %i\n",io_hdr_write.host_status);
  358.         //  printf("driver w: %s\n",io_hdr_write->sbp+2);
  359.    
  360.             if (status < 0) {
  361.             // failure
  362.             printf("write fail\n");
  363.  
  364.         }
  365.         else {
  366.             // success
  367.             printf("write success\n");
  368.         }
  369.     //free(io_hdr_write);
  370.    
  371.     SG_DXFER_TO_DEV SG_DXFER_FROM_DEV
  372.     getSGHDR(&io_hdr_read, SG_DXFER_FROM_DEV, 500, cdb_read, 16, data_read, data_size_read);
  373.     status = ioctl(fd_read, SG_IO, &io_hdr_read);  
  374.    
  375.     cdb_read[8]++;
  376.     //  printf("driver read: %i\n",io_hdr_read->driver_status);
  377.     //      printf("driver: %s\n",io_hdr_read->sbp);
  378.     //  printf("driver read: %s\n",io_hdr_read->sbp+2);
  379.        
  380.        
  381.         if (status < 0) {
  382.             // failure
  383.             printf("read fail\n");
  384.  
  385.         }
  386.         else {
  387.             // success
  388.             printf("read %s\n",data_read);
  389.             //printf("read %i\n",*((int*)data_read));
  390.             //printf("read %i\n",*((int*)data_read+4));
  391.         }  
  392.    
  393.     */
  394.    
  395.    
  396. return;
  397. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!