diff -u -r sane-1.0.2/backend/canon-scsi.c scsi_modified/backend/canon-scsi.c
--- sane-1.0.2/backend/canon-scsi.c	Sun Mar  5 14:40:52 2000
+++ scsi_modified/backend/canon-scsi.c	Sat May  6 22:55:35 2000
@@ -320,7 +320,7 @@
   cmd[0] = 0xd4;
   cmd[4] = 0x01;
 
-  status = sanei_scsi_cmd (fd, cmd, 6, 0, 0);
+  status = sanei_scsi_cmd2 (fd, cmd, 6, 0, 0, 0, 0);
   if (status == SANE_STATUS_GOOD)
   {
     status = sanei_scsi_cmd (fd, &priority, 1, 0, 0);
@@ -356,7 +356,7 @@
   }
 
   DBG (31, "get scan mode: cmd[4]='0x%0X'\n", cmd[4]);
-  status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), buf, buf_size);
+  status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), 0, 0, buf, buf_size);
 
   DBG (31, "<< get scan mode\n");
   return (status);
@@ -386,7 +386,7 @@
   cmdlen = (page == TRANSPARENCY_UNIT) ? 18 :
     (page == SCAN_CONTROL_CONDITIONS)  ? 26 : 34;
 
-  status = sanei_scsi_cmd (fd, cmd, cmdlen, 0, 0);
+  status = sanei_scsi_cmd2 (fd, cmd, 6, &cmd[10], cmdlen-6, 0, 0);
   DBG (31, "<< define scan mode\n");
   return (status);
 }
diff -u -r sane-1.0.2/backend/sharp.c scsi_modified/backend/sharp.c
--- sane-1.0.2/backend/sharp.c	Sun Mar  5 14:42:34 2000
+++ scsi_modified/backend/sharp.c	Sat May  6 22:55:29 2000
@@ -46,7 +46,11 @@
    This file implements a SANE backend for Sharp flatbed scanners.  */
 
 /*
-   Version 0.30
+   Version 0.31
+   changes to version 0.30:
+   - support for JX350 added (Thanks to Shuhei Tomita for providind the
+     patch)
+    
    changes to version 0.20
    - support for the proposed extended open function in sanei_scsi.c added
    - support for ADF and FSU (transparency adapter) added
@@ -377,7 +381,8 @@
             }
           
         }
-      else if (sdat->model == JX250 || sdat->model == JX330)
+      else if (sdat->model == JX250 || sdat->model == JX330 ||
+	       sdat->model == JX350)
         {
           switch (sense_key)
             {
@@ -502,7 +507,7 @@
   SANE_Status status;
   DBG (11, "<< test_unit_ready ");
 
-  status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
+  status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), 0, 0, 0, 0);
 
   DBG (11, ">>\n");
   return (status);
@@ -516,7 +521,7 @@
   SANE_Status status;
   DBG (11, "<< request_sense ");
 
-  status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), sense_buf, sense_size);
+  status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), 0, 0, sense_buf, sense_size);
 
   DBG (11, ">>\n");
   return (status);
@@ -530,7 +535,7 @@
   SANE_Status status;
   DBG (11, "<< inquiry ");
 
-  status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), inq_buf, inq_size);
+  status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), 0, 0, inq_buf, inq_size);
 
   DBG (11, ">>\n");
   return (status);
@@ -539,20 +544,20 @@
 static SANE_Status
 mode_select_mud (int fd, int mud)
 {
-  static u_char cmd[6 + MODEPARAM_LEN] = 
+  static u_char cmd[6] = 
                         {MODE_SELECT6, 0x10, 0, 0, MODEPARAM_LEN, 0};
-  mode_select_param *mp;
+
+  static mode_select_param mp;
   SANE_Status status;
   DBG (11, "<< mode_select_mud ");
 
-  mp = (mode_select_param *)(cmd + 6);
-  memset (mp, 0, MODEPARAM_LEN);
-  mp->page_code = 3;
-  mp->page_length = 6;
-  mp->mud[0] = mud >> 8;
-  mp->mud[1] = mud & 0xFF;
+  memset (&mp, 0, MODEPARAM_LEN);
+  mp.page_code = 3;
+  mp.page_length = 6;
+  mp.mud[0] = mud >> 8;
+  mp.mud[1] = mud & 0xFF;
 
-  status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
+  status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), &mp, sizeof(mp), 0, 0);
 
   DBG (11, ">>\n");
   return (status);
@@ -1198,7 +1203,8 @@
   dev->info.br_x_ranges[mode].quant = 0;
 
   dev->info.tl_y_ranges[mode].min = 0;
-  if (dev->sensedat.model != JX250 || mode != SCAN_WITH_FSU)
+  if ((dev->sensedat.model != JX250 && dev->sensedat.model != JX350) ||
+      mode != SCAN_WITH_FSU)
     dev->info.tl_y_ranges[mode].max = SANE_FIX(PIX_TO_MM(
       (m_subdev.max_y[0] << 24) + (m_subdev.max_y[1] << 16) +
       (m_subdev.max_y[2] << 8) + m_subdev.max_y[3] - 1, dev->info.mud));
@@ -1291,6 +1297,8 @@
         sensedat.model = JX610;
       else if (strncmp (inquiry_data + 16, "JX250", 5) == 0)
         sensedat.model = JX250;
+      else if (strncmp (inquiry_data + 16, "JX350", 5) == 0)
+        sensedat.model = JX350;
       else if (   strncmp (inquiry_data + 16, "JX320", 5) == 0
                || strncmp (inquiry_data + 16, "JX325", 5) == 0
                || strncmp (inquiry_data + 16, "JX330", 5) == 0)
@@ -1437,7 +1445,7 @@
           get_max_scan_size(fd, dev, SCAN_WITH_FSU);
         }
 
-      if (dev->sensedat.model == JX330)
+      if (dev->sensedat.model == JX330 || dev->sensedat.model == JX350)
         {
           dev->info.xres_range.max = 600;
           dev->info.xres_range.min = 30;
@@ -1768,7 +1776,8 @@
   init_string_option(s, SANE_NAME_HALFTONE_PATTERN, SANE_TITLE_HALFTONE_PATTERN,
     SANE_DESC_HALFTONE " (JX-330 only)", halftone_list, OPT_HALFTONE, 0);
 
-  if (s->dev->sensedat.model == JX250 || s->dev->sensedat.model == JX610)
+  if (s->dev->sensedat.model == JX250 || s->dev->sensedat.model == JX350 ||
+      s->dev->sensedat.model == JX610)
     s->opt[OPT_HALFTONE].cap |= SANE_CAP_INACTIVE;
 
   i = 0;
@@ -1874,7 +1883,8 @@
 
   /* select resolution */
 #ifdef USE_RESOLUTION_LIST
-  if (s->dev->sensedat.model == JX610 || s->dev->sensedat.model == JX330)
+  if (s->dev->sensedat.model == JX610 || s->dev->sensedat.model == JX330 ||
+      s->dev->sensedat.model == JX350)
     init_string_option(s, "ResolutionList", "ResolutionList", "ResolutionList", 
       resolution_list_jx610, OPT_RESOLUTION_LIST, RESOLUTION_MAX_JX610);
   else
@@ -1979,7 +1989,7 @@
     "Edge emphasis", edge_emphasis_list,
     OPT_EDGE_EMPHASIS, 0);
 
-  if (s->dev->sensedat.model == JX250)
+  if (s->dev->sensedat.model == JX250 || s->dev->sensedat.model == JX350)
     s->opt[OPT_EDGE_EMPHASIS].cap |= SANE_CAP_INACTIVE;
 
   /* threshold */
@@ -3099,7 +3109,7 @@
 static SANE_Status
 send_gamma_tables (SHARP_Scanner *s)
 {
-  if (s->dev->sensedat.model != JX250)
+  if (s->dev->sensedat.model != JX250 && s->dev->sensedat.model != JX350)
     {
       return send_ascii_gamma_tables(s);
     }
@@ -3178,8 +3188,8 @@
      
      NOTE: If you need to decrease this value, remember that s->buffer
      is used in send_ascii_gamma_tables (JX330/JX610) and in 
-     send_binary_g_table (JX250). send_ascii_gamma_tables needs 4106 bytes,
-     and send_binary_g_table needs 522 bytes.
+     send_binary_g_table (JX250/JX350). send_ascii_gamma_tables needs 4106
+     bytes, and send_binary_g_table needs 522 bytes.
   */
   if (s->dev->info.bufsize < 32 * 1024)
     {
@@ -3454,7 +3464,7 @@
   if (s->val[OPT_CUSTOM_GAMMA].w == SANE_FALSE)
     {
 #endif
-      if (s->dev->sensedat.model != JX250)
+      if (s->dev->sensedat.model != JX250 && s->dev->sensedat.model != JX350)
         {
           ss.dtc = 0x03;
           if (strcmp (gamma, GAMMA10) == 0)
@@ -3507,7 +3517,7 @@
         }
 #endif
 
-  if (s->dev->sensedat.model != JX250)
+  if (s->dev->sensedat.model != JX250 && s->dev->sensedat.model != JX350)
     {
       ss.dtc = 0x86;
       ss.dtq = 0x05;
@@ -3590,7 +3600,7 @@
   wp.wdb.rif_padding = (s->reverse * 128) + 0;
   wp.wdb.eletu = (!s->speed << 2) + (s->edge << 6) + (s->lightcolor << 4);
 
-  if (s->dev->sensedat.model == JX250)
+  if (s->dev->sensedat.model == JX250 || s->dev->sensedat.model == JX350)
     {
       wp.wdbx250.threshold_red   = s->val[OPT_THRESHOLD_R].w;
       wp.wdbx250.threshold_green = s->val[OPT_THRESHOLD_G].w;
@@ -4001,7 +4011,7 @@
     status = sane_read_direct(handle, dst_buf, max_len, len);
   else if (s->image_composition <= 4)
     status = sane_read_shuffled(handle, dst_buf, max_len, len, 0);
-  else if (s->dev->sensedat.model != JX250)
+  else if (s->dev->sensedat.model != JX250 && s->dev->sensedat.model != JX350 )
     status = sane_read_direct(handle, dst_buf, max_len, len);
   else
     status = sane_read_shuffled(handle, dst_buf, max_len, len, 1);
diff -u -r sane-1.0.2/include/sane/sanei_scsi.h scsi_modified/include/sane/sanei_scsi.h
--- sane-1.0.2/include/sane/sanei_scsi.h	Sun Mar  5 14:44:57 2000
+++ scsi_modified/include/sane/sanei_scsi.h	Sat May  6 22:57:12 2000
@@ -86,18 +86,51 @@
 
    NOTE: Some systems may not support multiple outstanding commands.
    On such systems, enter() may block.  In other words, it is not
-   proper to assume that enter() is a non-blocking routine.  */
+   proper to assume that enter() is a non-blocking routine.  
+
+   src points to a buffer which contains the SCSI command followed
+   by data to be written to the device (if any)
+*/
 extern SANE_Status sanei_scsi_req_enter (int fd,
 					 const void * src, size_t src_size,
 					 void * dst, size_t * dst_size,
 					 void **idp);
 
+/* Same as above, but with separate buffers for the SCSI command and
+   for the data to be sent to the device.
+
+   With sanei_scsi_req_enter, the length of te SCSI command block must be
+   guessed. While that works in most cases, Canon scanners for example
+   use the vendor specific commands 0xd4, 0xd5 and 0xd6. The Canon 
+   scanners want to get 6 byte command blocks for these commands, 
+   but sanei_scsi_req_enter and sanei_scsi_cmd send 12 bytes. 
+
+   cmd:      pointer to SCSI command
+   cmd_size: size of the command
+   src:      pointer to the buffer with data to be sent rto the scanner
+   src_size: size of that buffer
+   dst, dst_size, idp: see above
+   
+   If dst_size and *dst_size are non-zero, a "read command" (ie,
+   data transfer from the device to the host) is assumed.
+*/
+extern SANE_Status sanei_scsi_req_enter2 (int fd,
+					 const void * cmd, size_t cmd_size,
+					 const void * src, size_t src_size,
+					 void * dst, size_t * dst_size,
+					 void **idp);
+
 /* Wait for the completion of the SCSI command with id ID.  */
 extern SANE_Status sanei_scsi_req_wait (void *id);
 
 /* This is a convenience function that is equivalent to a pair of
    enter()/wait() calls.  */
 extern SANE_Status sanei_scsi_cmd (int fd,
+				   const void * src, size_t src_size,
+				   void * dst, size_t * dst_size);
+
+extern SANE_Status sanei_scsi_cmd2 (int fd,
+				   const void * cmd, size_t cmd_size,
 				   const void * src, size_t src_size,
 				   void * dst, size_t * dst_size);
 
diff -u -r sane-1.0.2/sanei/sanei_scsi.c scsi_modified/sanei/sanei_scsi.c
--- sane-1.0.2/sanei/sanei_scsi.c	Sun Mar  5 14:45:19 2000
+++ scsi_modified/sanei/sanei_scsi.c	Sun May  7 12:35:02 2000
@@ -244,6 +244,9 @@
 #ifndef SG_GET_VERSION_NUM
 #define SG_GET_VERSION_NUM 0x2282
 #endif
+#ifndef SG_NEXT_CMD_LEN
+#define SG_NEXT_CMD_LEN 0x2283
+#endif
 
 #ifndef SCSIBUFFERSIZE
 #define SCSIBUFFERSIZE (128 * 1024)
@@ -733,7 +736,7 @@
   char *real_dev = 0;
   void *pdata = 0;
   int fd;
-#ifdef __linux__
+#if USE == LINUX_INTERFACE
   static int first_time = 1;
 #endif
 
@@ -1185,12 +1188,12 @@
         DBG(1, "sanei_scsi_open: SG driver can change buffer size at run time\n");
         if (fdpa->sg_queue_max > 1)
           DBG(1, "sanei_scsi_open: low level command queueing enabled\n");
-        #ifdef SG_IO
+#ifdef SG_IO
         if (sg_version >= 30000)
           {
             DBG(1, "sanei_scsi_open: using new SG header structure\n");
           }
-        #endif
+#endif
       }
   }
 #endif /* LINUX_INTERFACE */
@@ -1424,7 +1427,9 @@
 
 
 SANE_Status
-sanei_scsi_req_enter (int fd, const void *src, size_t src_size,
+sanei_scsi_req_enter2 (int fd, 
+                      const void *cmd, size_t cmd_size,
+                      const void *src, size_t src_size,
 		      void *dst, size_t * dst_size, void **idp)
 {
   SANEI_SCSI_Sense_Handler handler;
@@ -1435,12 +1440,13 @@
   static void *buf_ptr;
 
   if (dst_size)
-    DBG (1, "sanei_scsi_req_enter: (fd=%x, src=%p, src_size=%x, "
-	 "dst=%p, dst_size=%x, *idp=%p)\n",
-	 fd, src, src_size, dst, *dst_size, idp);
+    DBG (1, "sanei_scsi_req_enter2: (fd=%x, cmd=%p, cmd_size=%x, "
+	 "src=%p, src_size=%x, dst=%p, dst_size=%x, *idp=%p)\n",
+	 fd, cmd, cmd_size, src, src_size, dst, *dst_size, idp);
   else
-    DBG (1, "sanei_scsi_req_enter: (fd=%x, src=%p, src_size=%x, "
-	 "dst=%p, dst_size=NULL, *idp=%p)\n", fd, src, src_size, dst, idp);
+    DBG (1, "sanei_scsi_req_enter2: (fd=%x, cmd=%p, cmd_size=%x, "
+	 "src=%p, src_size=%x, dst=%p, dst_size=NULL, *idp=%p)\n", 
+	 fd, src, src_size, dst, idp);
 
   /* Lock the command structure */
   if (!mutex_$lock (&com->CommandLock, mutex_$wait_forever))
@@ -1452,16 +1458,16 @@
   /* Fill in the command structure */
   com->opcode = Enter;
   com->fd = fd;
-  com->cdb_size = CDB_SIZE (*(u_char *) src);
+  com->cdb_size = cmd_size;
   if (dst_size)
     com->dst_size = *dst_size;
-  memcpy (&com->cdb, src, com->cdb_size);
+  memcpy (&com->cdb, cmd, com->cdb_size);
 
   /* figure out if this is a read or a write */
   if (dst_size && *dst_size)
     {
       /* dest buffer specified, must be a read */
-      assert (com->cdb_size == src_size);
+      /* assert (com->cdb_size == src_size); */
       com->direction = scsi_read;
       buf_ptr = dst;
       com->buf_size = *dst_size;
@@ -1469,10 +1475,10 @@
   else
     {
       /* no dest buffer, must be a write */
-      assert (com->cdb_size <= src_size);
+      /* assert (com->cdb_size <= src_size); */
       com->direction = scsi_write;
-      buf_ptr = (char *) src + com->cdb_size;
-      com->buf_size = src_size - com->cdb_size;
+      buf_ptr = (char *) src;
+      com->buf_size = src_size;
       if (com->buf_size)
 	memcpy (fd_info[fd].pdata, buf_ptr, com->buf_size);
     }
@@ -1567,14 +1573,16 @@
 
 
 SANE_Status
-sanei_scsi_cmd (int fd, const void *src, size_t src_size,
+sanei_scsi_cmd2 (int fd, 
+                const void *cmd, size_t cmd_size,
+                const void *src, size_t src_size,
 		void *dst, size_t * dst_size)
 {
   SANE_Status status;
   void *id;
 
-  DBG (1, "sanei_scsi_cmd: (fd=%d)\n", fd);
-  status = sanei_scsi_req_enter (fd, src, src_size, dst, dst_size, &id);
+  DBG (1, "sanei_scsi_cmd2: (fd=%d)\n", fd);
+  status = sanei_scsi_req_enter2 (fd, cmd, cmd_size, src, src_size, dst, dst_size, &id);
   if (status != SANE_STATUS_GOOD)
     return status;
   return sanei_scsi_req_wait (id);
@@ -1791,7 +1799,9 @@
 }
 
 SANE_Status
-sanei_scsi_req_enter (int fd, const void *src, size_t src_size,
+sanei_scsi_req_enter2 (int fd, 
+                      const void *cmd, size_t cmd_size,
+                      const void *src, size_t src_size,
 		      void *dst, size_t * dst_size, void **idp)
 {
   struct req *req;
@@ -1837,39 +1847,46 @@
 #endif
       memset (&req->sgdata.cdb.hdr, 0, sizeof (req->sgdata.cdb.hdr));
       req->sgdata.cdb.hdr.pack_id = pack_id++;
-      req->sgdata.cdb.hdr.pack_len = src_size + sizeof (req->sgdata.cdb.hdr);
+      req->sgdata.cdb.hdr.pack_len = cmd_size + src_size 
+                                     + sizeof (req->sgdata.cdb.hdr);
       req->sgdata.cdb.hdr.reply_len = (dst_size ? *dst_size : 0)
                                       + sizeof (req->sgdata.cdb.hdr);
-      memcpy (&req->sgdata.cdb.data, src, src_size);
+      memcpy (&req->sgdata.cdb.data, cmd, cmd_size);
+      memcpy (&req->sgdata.cdb.data[cmd_size], src, src_size);
+      if (CDB_SIZE (*(u_char *) cmd) != cmd_size)
+        {
+          if (ioctl(fd, SG_NEXT_CMD_LEN, &cmd_size))
+            {
+              DBG(1, "sanei_scsi_req_enter2: ioctl to set command length failed\n");
+            }
+        }
 #ifdef SG_IO
     }
   else
     {
       memset (&req->sgdata.sg3.hdr, 0, sizeof (req->sgdata.sg3.hdr));
       req->sgdata.sg3.hdr.interface_id = 'S';
-      req->sgdata.sg3.hdr.cmd_len = CDB_SIZE (*(u_char *) src);
+      req->sgdata.sg3.hdr.cmd_len = cmd_size;
       req->sgdata.sg3.hdr.iovec_count = 0;
       req->sgdata.sg3.hdr.mx_sb_len = SENSE_MAX;
       /* read or write? */
       if (dst_size && *dst_size)
         {
-          assert (req->sgdata.sg3.hdr.cmd_len == src_size);
           req->sgdata.sg3.hdr.dxfer_direction = SG_DXFER_FROM_DEV;
           req->sgdata.sg3.hdr.dxfer_len = *dst_size;
           req->sgdata.sg3.hdr.dxferp = dst;
         }
-      else if (req->sgdata.sg3.hdr.cmd_len < src_size)
+      else if (src_size)
         {
           req->sgdata.sg3.hdr.dxfer_direction = SG_DXFER_TO_DEV;
-          req->sgdata.sg3.hdr.dxfer_len = src_size - req->sgdata.sg3.hdr.cmd_len;
-          req->sgdata.sg3.hdr.dxferp = ((char*) src) + req->sgdata.sg3.hdr.cmd_len;
+          req->sgdata.sg3.hdr.dxfer_len = src_size;
+          (const void*) req->sgdata.sg3.hdr.dxferp = src;
         }
       else
         {
-          assert (req->sgdata.sg3.hdr.cmd_len == src_size);
           req->sgdata.sg3.hdr.dxfer_direction = SG_DXFER_NONE;
         }
-      (const void*) req->sgdata.sg3.hdr.cmdp = src;
+      (const void*) req->sgdata.sg3.hdr.cmdp = cmd;
       req->sgdata.sg3.hdr.sbp = &(req->sgdata.sg3.sense_buffer[0]);
       /* 10 seconds should be ok even for slow scanners */
       req->sgdata.sg3.hdr.timeout = 10000;
@@ -2053,13 +2070,15 @@
 }
 
 SANE_Status
-sanei_scsi_cmd (int fd, const void *src, size_t src_size,
+sanei_scsi_cmd2 (int fd, 
+                const void *cmd, size_t cmd_size,
+                const void *src, size_t src_size,
 		void *dst, size_t * dst_size)
 {
   SANE_Status status;
   void *id;
 
-  status = sanei_scsi_req_enter (fd, src, src_size, dst, dst_size, &id);
+  status = sanei_scsi_req_enter2 (fd, cmd, cmd_size, src, src_size, dst, dst_size, &id);
   if (status != SANE_STATUS_GOOD)
     return status;
   return sanei_scsi_req_wait (id);
@@ -2237,33 +2256,45 @@
 #endif /* !HAVE_SCSIREQ_ENTER */
 
 SANE_Status
-sanei_scsi_cmd (int fd, const void *src, size_t src_size,
+sanei_scsi_cmd2 (int fd, 
+                const void *cmd, size_t cmd_size,
+                const void *src, size_t src_size,
 		void *dst, size_t * dst_size)
 {
-  size_t cdb_size;
+  /* xxx obsolete: size_t cdb_size;
+  */
   scsireq_t hdr;
   int result;
 
+/* xxx obsolete: 
   cdb_size = CDB_SIZE (*(u_char *) src);
+*/
 
   memset (&hdr, 0, sizeof (hdr));
-  memcpy (hdr.cmd, src, cdb_size);
+  memcpy (hdr.cmd, cmd, cmd_size);
   if (dst_size && *dst_size)
     {
-      assert (cdb_size == src_size);
+      /* xxx obsolete: assert (cdb_size == src_size);
+      */
       hdr.flags = SCCMD_READ;
       hdr.databuf = dst;
       hdr.datalen = *dst_size;
     }
   else
     {
-      assert (cdb_size <= src_size);
+      /* xxx obsolete: assert (cdb_size <= src_size);
+      */
       hdr.flags = SCCMD_WRITE;
-      hdr.databuf = (char *) src + cdb_size;
+      /* The old variant:
+        hdr.databuf = (char *) src + cdb_size;
+        hdr.datalen = src_size;
+        xxxxxx huh? Shouldn´t the above line have been src_size - cdb_size)
+      */
+      hdr.databuf = (char *) src;
       hdr.datalen = src_size;
     }
   hdr.timeout = 60000;		/* 1 minute timeout */
-  hdr.cmdlen = cdb_size;
+  hdr.cmdlen = cmd_size;
   hdr.senselen = sizeof (hdr.sense);
 
   result = scsireq_enter (fd, &hdr);
@@ -2303,10 +2334,13 @@
 #endif /* USE == BSD_INTERFACE */
 
 #if USE == FREEBSD_CAM_INTERFACE
-SANE_Status sanei_scsi_cmd(int fd, const void *src, size_t src_size,
+SANE_Status sanei_scsi_cmd2(int fd, 
+                           const void *cmd, size_t cmd_size,
+                           const void *src, size_t src_size,
 			   void *dst, size_t * dst_size) {
 
-   size_t 		cdb_size; 
+   /* xxx obsolete size_t 		cdb_size; 
+   */
    struct cam_device	*dev;
    union ccb		*ccb;
    int			rv;
@@ -2319,27 +2353,29 @@
       return SANE_STATUS_INVAL;
    }
 
-   cdb_size = CDB_SIZE (*(u_char *) src);
+   /* xxx obsolete: cdb_size = CDB_SIZE (*(u_char *) src);
+   */
    dev = cam_devices[fd];
    ccb = cam_getccb(dev);
     
    /* Build the CCB */
    bzero(&(&ccb->ccb_h)[1], sizeof(struct ccb_scsiio));
-   bcopy(src, &ccb->csio.cdb_io.cdb_bytes, cdb_size);
+   bcopy(cmd, &ccb->csio.cdb_io.cdb_bytes, cmd_size);
 
    /*
     * Set the data direction flags.
     */
    if(dst_size && *dst_size) {
-      assert (cdb_size == src_size);
+      /* xxx obsolete: assert (cdb_size == src_size);
+      */
       ccb_flags = CAM_DIR_IN;
       data_buf = ((char*)(dst));
       data_len = *dst_size;
    }
-   else if(src_size > cdb_size) {
+   else if(src_size > 0) {
       ccb_flags = CAM_DIR_OUT;
-      data_buf = ((char*)(src + cdb_size));
-      data_len = src_size - cdb_size;
+      data_buf = ((char*)(src));
+      data_len = src_size;
    }
    else {
       ccb_flags = CAM_DIR_NONE;
@@ -2355,7 +2391,7 @@
 		 /* data_ptr */ (u_int8_t *)data_buf,
 		 /* dxfer_len */ data_len,
 		 /* sense_len */ SSD_FULL_SIZE,
-		 /* cdb_len */ cdb_size,
+		 /* cdb_len */ cmd_size,
 		 /* timeout */ 60 * 1000);
 
    /* Run the command */
@@ -2395,30 +2431,35 @@
 #if USE == HPUX_INTERFACE
 /* XXX untested code! */
 SANE_Status
-sanei_scsi_cmd (int fd, const void *src, size_t src_size,
+sanei_scsi_cmd2 (int fd, 
+                const void *cmd, size_t cmd_size,
+                const void *src, size_t src_size,
 		void *dst, size_t * dst_size)
 {
   struct sctl_io hdr;
-  size_t cdb_size;
+  /* xxx obsolete size_t cdb_size;
 
-  cdb_size = CDB_SIZE (*(u_char *) src);
+     cdb_size = CDB_SIZE (*(u_char *) src);
+  */
 
   memset (&hdr, 0, sizeof (hdr));
-  memcpy (hdr.cdb, src, src_size);
+  memcpy (hdr.cdb, cmd, cmd_size);
   if (dst_size && *dst_size)
     {
-      assert (cdb_size == src_size);
+      /* xxx obsolete assert (cdb_size == src_size);
+      */
       hdr.flags = SCTL_READ;
       hdr.data = dst;
       hdr.data_length = *dst_size;
     }
   else
     {
-      assert (cdb_size <= src_size);
-      hdr.data = (char *) src + cdb_size;
-      hdr.data_length = src_size - cdb_size;
+      /* xxx obsolete assert (cdb_size <= src_size);
+      */
+      hdr.data = (char *) src;
+      hdr.data_length = src_size;
     }
-  hdr.cdb_length = cdb_size;
+  hdr.cdb_length = cmd_size;
   hdr.max_msecs = 60000;	/* 1 minute timeout */
   if (ioctl (fd, SIOC_IO, &hdr) < 0)
     {
@@ -2442,29 +2483,34 @@
 
 #if USE == OPENSTEP_INTERFACE
 SANE_Status
-sanei_scsi_cmd (int fd, const void *src, size_t src_size,
+sanei_scsi_cmd2 (int fd, 
+                const void *cmd, size_t cmd_size,
+                const void *src, size_t src_size,
 		void *dst, size_t * dst_size)
 {
   struct scsi_req hdr;
-  size_t cdb_size;
+  /* xxx obsolete size_t cdb_size;
 
-  cdb_size = CDB_SIZE (*(u_char *) src);
+     cdb_size = CDB_SIZE (*(u_char *) src);
+  */
 
   memset (&hdr, 0, sizeof (hdr));
-  memcpy (&hdr.sr_cdb, src, cdb_size);
+  memcpy (&hdr.sr_cdb, cmd, cmd_size);
   if (dst_size && *dst_size)
     {
-      assert (cdb_size == src_size);
+      /* xxx obsolete assert (cdb_size == src_size);
+      */
       hdr.sr_dma_dir = SR_DMA_RD;
       hdr.sr_addr = dst;
       hdr.sr_dma_max = *dst_size;
     }
   else
     {
-      assert (cdb_size <= src_size);
+      /* xxx obsolete assert (cdb_size <= src_size);
+      */
       hdr.sr_dma_dir = SR_DMA_WR;
-      hdr.sr_addr = (char *) src + cdb_size;
-      hdr.sr_dma_max = src_size - cdb_size;
+      hdr.sr_addr = (char *) src;
+      hdr.sr_dma_max = src_size;
     }
   hdr.sr_ioto = 60;		/* I/O timeout in seconds */
 
@@ -2489,15 +2535,18 @@
 
 #if USE == DECUNIX_INTERFACE
 SANE_Status
-sanei_scsi_cmd (int fd, const void *src, size_t src_size,
+sanei_scsi_cmd2 (int fd, 
+                const void *cmd, size_t cmd_size,
+                const void *src, size_t src_size,
 		void *dst, size_t * dst_size)
 {
   u_char sense[64];
   UAGT_CAM_CCB hdr;
   CCB_SCSIIO ccb;
-  size_t cdb_size;
+  /* xxx obsolete size_t cdb_size;
 
-  cdb_size = CDB_SIZE (*(u_char *) src);
+     cdb_size = CDB_SIZE (*(u_char *) src);
+  */
 
   memset (&ccb, 0, sizeof (ccb));
   ccb.cam_ch.my_addr = (CCB_HEADER *) & ccb;
@@ -2510,24 +2559,26 @@
 
   if (dst_size && *dst_size)
     {
-      assert (cdb_size == src_size);
+      /* xxx obsolete assert (cdb_size == src_size);
+      */
       ccb.cam_ch.cam_flags |= CAM_DIR_IN;
       ccb.cam_data_ptr = (u_char *) dst;
       ccb.cam_dxfer_len = *dst_size;
     }
   else
     {
-      assert (cdb_size <= src_size);
-      if (cdb_size == src_size)
+      /* xxx obsolete assert (cdb_size <= src_size);
+      */
+      if (0 == src_size)
 	ccb.cam_ch.cam_flags |= CAM_DIR_NONE;
       else
 	ccb.cam_ch.cam_flags |= CAM_DIR_OUT;
-      ccb.cam_data_ptr = (u_char *) src + cdb_size;
-      ccb.cam_dxfer_len = src_size - cdb_size;
+      ccb.cam_data_ptr = (u_char *) src;
+      ccb.cam_dxfer_len = src_size;
     }
   ccb.cam_timeout = 60;		/* set timeout in seconds */
-  ccb.cam_cdb_len = cdb_size;
-  memcpy (&ccb.cam_cdb_io.cam_cdb_bytes[0], src, cdb_size);
+  ccb.cam_cdb_len = cmd_size;
+  memcpy (&ccb.cam_cdb_io.cam_cdb_bytes[0], cmd, cmd_size);
 
   memset (&hdr, 0, sizeof (hdr));
   hdr.uagt_ccb = (CCB_HEADER *) & ccb;
@@ -2566,13 +2617,16 @@
 
 #if USE == SCO_OS5_INTERFACE
 SANE_Status
-sanei_scsi_cmd (int fd, const void *src, size_t src_size,
+sanei_scsi_cmd2 (int fd, 
+                const void *cmd, size_t cmd_size,
+                const void *src, size_t src_size,
 		void *dst, size_t * dst_size)
 {
   static u_char sense_buffer[256];
   struct scsicmd2 sc2;
   struct scsicmd *sc;
-  int cdb_size;
+  /* xxx obsolete int cdb_size;
+  */
   int opcode;
   int i;
 
@@ -2584,7 +2638,8 @@
   sc2.sense_len = sizeof (sense_buffer);
   sc2.sense_ptr = sense_buffer;
 
-  cdb_size = CDB_SIZE (*(u_char *) src);
+  /* xxx obsolete cdb_size = CDB_SIZE (*(u_char *) src);
+  */
   if (dst_size && *dst_size)
     {
       sc->is_write = 0;
@@ -2593,12 +2648,12 @@
     }
   else
     {
-      sc->data_len = src_size - cdb_size;
-      sc->data_ptr = (char *) src + cdb_size;
+      sc->data_len = src_size;
+      sc->data_ptr = (char *) src;
       sc->is_write = 1;
     }
-  memcpy (sc->cdb, src, cdb_size);
-  sc->cdb_len = cdb_size;
+  memcpy (sc->cdb, cmd, cmd_size);
+  sc->cdb_len = cmd_size;
 
   /* Send the command down via the "pass-through" interface */
   if (ioctl (fd, SCSIUSERCMD2, &sc2) < 0)
@@ -2635,7 +2690,9 @@
  *
  */
 SANE_Status
-sanei_scsi_cmd (int fd, const void * src, size_t src_size,
+sanei_scsi_cmd2 (int fd, 
+                const void * cmd, size_t cmd_size,
+                const void * src, size_t src_size,
 		void * dst, size_t * dst_size)
 {
   struct sb sb, *sb_ptr; /* Command block and pointer */
@@ -2645,36 +2702,38 @@
   char sense[32]; /* for call of sens req */
   char cmd[16]; /* global for right alignment */
   char * cp;
-  size_t cdb_size;
+
+  /* xxx obsolete size_t cdb_size;
 
   cdb_size = CDB_SIZE (*(u_char *) src);
+  */
   memset (&cmd, 0, 16);
   sb_ptr = &sb;
   sb_ptr->sb_type = ISCB_TYPE;
-  cp = (char *) src;
-  DBG(1, "cdb_size = %d src = {0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x ...}\n", cdb_size,
+  cp = (char *) cmd;
+  DBG(1, "cdb_size = %d src = {0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x ...}\n", cmd_size,
       cp[0],cp[1],cp[2],cp[3],cp[4],cp[5],cp[6],cp[7],cp[8],cp[9]);
-  switch (cdb_size)
+  switch (cmd_size)
     {
     default:
       return SANE_STATUS_IO_ERROR;
     case 6:
       scs = (struct scs *) cmd;
-      memcpy(SCS_AD(scs),src,SCS_SZ);
+      memcpy(SCS_AD(scs),cmd,SCS_SZ);
       scs->ss_lun = 0;
       sb_ptr->SCB.sc_cmdpt = SCS_AD(scs);
       sb_ptr->SCB.sc_cmdsz = SCS_SZ;
       break;
     case 10:
       scm = (struct scm *) cmd;
-      memcpy(SCM_AD(scm),src,SCM_SZ);
+      memcpy(SCM_AD(scm),cmd,SCM_SZ);
       scm->sm_lun = 0;
       sb_ptr->SCB.sc_cmdpt = SCM_AD(scm);
       sb_ptr->SCB.sc_cmdsz = SCM_SZ;
       break;
     case 12:
       scv = (struct scv *) cmd;
-      memcpy(SCV_AD(scv),src,SCV_SZ);
+      memcpy(SCV_AD(scv),cmd,SCV_SZ);
       scv->sv_lun = 0;
       sb_ptr->SCB.sc_cmdpt = SCV_AD(scv);
       sb_ptr->SCB.sc_cmdsz = SCV_SZ;
@@ -2682,17 +2741,17 @@
     }
   if (dst_size && *dst_size)
     {
-      assert (cdb_size == src_size);
+      assert (0 == src_size);
       sb_ptr->SCB.sc_mode = SCB_READ;
       sb_ptr->SCB.sc_datapt = dst;
       sb_ptr->SCB.sc_datasz = *dst_size;
     }
   else
     {
-      assert (cdb_size <= src_size);
+      assert (0 <= src_size);
       sb_ptr->SCB.sc_mode = SCB_WRITE;
-      sb_ptr->SCB.sc_datapt = (char *) src + cdb_size;
-      if ( (sb_ptr->SCB.sc_datasz = src_size - cdb_size) > 0 ) {
+      sb_ptr->SCB.sc_datapt = (char *) src;
+      if ( (sb_ptr->SCB.sc_datasz = src_size) > 0 ) {
 	sb_ptr->SCB.sc_mode = SCB_WRITE;
       } else {
 	/* also use READ mode if the backends have write with length 0 */
@@ -2705,7 +2764,7 @@
   {
     /* do read write by normal read or write system calls */
     /* the driver will lock process in momory and do optimized transfer */
-    cp = (char *) src;
+    cp = (char *) cmd;
     switch (*cp)
       {
       case 0x0: /* test unit ready */
@@ -2768,36 +2827,43 @@
 #endif /* USE == SYSVR4_INTERFACE */
 #if USE == SCO_UW71_INTERFACE
 SANE_Status
-sanei_scsi_cmd (int fd, const void *src, size_t src_size,
+sanei_scsi_cmd2 (int fd, 
+                const void *cmd, size_t cmd_size,
+                const void *src, size_t src_size,
 		void *dst, size_t * dst_size)
 {
   static u_char sense_buffer[24];
   struct scb cmdblk;
   time_t elapsed;
   uint_t compcode, status;
-  int cdb_size, mode;
+  /* xxx obsolete int cdb_size, mode;
+  */
+  int mode;
   int i;
 
   if (fd < 0)
     return SANE_STATUS_IO_ERROR;
 
-  cmdblk.sc_cmdpt = (caddr_t) src;
-  cdb_size = CDB_SIZE (*(u_char *) src);
-  cmdblk.sc_cmdsz = cdb_size;
+  cmdblk.sc_cmdpt = (caddr_t) cmd;
+  /* xxx obsolete cdb_size = CDB_SIZE (*(u_char *) src);
+  */
+  cmdblk.sc_cmdsz = cmd_size;
   cmdblk.sc_time = 60000; /* 60 secs */
 
   if (dst_size && *dst_size)
     {
-      assert (cdb_size == src_size);
+      /* xxx obsolete assert (cdb_size == src_size);
+      */
       cmdblk.sc_datapt = (caddr_t) dst;
       cmdblk.sc_datasz = *dst_size;
       mode = SCB_READ;
     }
   else
     {
-      assert (cdb_size <= src_size);
-      cmdblk.sc_datapt = (char *) src + cdb_size;
-      cmdblk.sc_datasz = src_size - cdb_size;
+      /* xxx obsolete assert (cdb_size <= src_size);
+      */
+      cmdblk.sc_datapt = (char *) src;
+      cmdblk.sc_datasz = src_size;
       mode = SCB_WRITE;
     }
 
@@ -2972,7 +3038,9 @@
 
 /* XXX untested code! */
 SANE_Status
-sanei_scsi_cmd (int fd, const void *src, size_t src_size,
+sanei_scsi_cmd2 (int fd, 
+                const void *cmd, size_t cmd_size,
+                const void *src, size_t src_size,
 		void *dst, size_t * dst_size)
 {
   ULONG rc;			/* Returns. */
@@ -2980,10 +3048,11 @@
   unsigned long cbParam;
   SRB srb;			/* SCSI Request Block */
   ULONG count = 0;		/* For semaphore. */
-  size_t cdb_size;
+  /* xxx obsolete size_t cdb_size;
+  */
 
   memset ((char *) &srb, 0, sizeof (srb));	/* Okay, I'm paranoid. */
-  cdb_size = CDB_SIZE (*(u_char *) src);	/* Size of command block. */
+  /* xxx obsolete cdb_size = CDB_SIZE (*(u_char *) src);*/ /* Size of command block. */
   srb.cmd = SRB_Command;	/* execute SCSI cmd */
   srb.ha_num = fd_info[fd].bus;	/* host adapter number */
   srb.u.cmd.target = fd_info[fd].target;	/* Target SCSI ID */
@@ -2993,27 +3062,29 @@
     {
       /* Reading. */
       assert (*dst_size <= sanei_scsi_max_request_size);
-      assert (cdb_size == src_size);
+      /* xxx obsolete assert (cdb_size == src_size);
+      */
       srb.u.cmd.data_len = *dst_size;
       srb.flags |= SRB_Read;
     }
   else
     {
       /* Writing. */
-      srb.u.cmd.data_len = src_size - cdb_size;
-      assert (cdb_size <= src_size);
+      srb.u.cmd.data_len = src_size;
+      /* xxx obsolete assert (cdb_size <= src_size);
+      */
       assert (srb.u.cmd.data_len <= sanei_scsi_max_request_size);
       if (srb.u.cmd.data_len)
 	srb.flags |= SRB_Write;
       else
 	srb.flags |= SRB_NoTransfer;
-      memcpy (aspi_buf, (char *) src + cdb_size, srb.u.cmd.data_len);
+      memcpy (aspi_buf, (char *) src, srb.u.cmd.data_len);
     }
   srb.u.cmd.sense_len = 16;	/* length of sense buffer */
   srb.u.cmd.data_ptr = NULL;	/* pointer to data buffer already registered */
   srb.u.cmd.link_ptr = NULL;	/* pointer to next SRB */
-  srb.u.cmd.cdb_len = cdb_size;	/* SCSI command length */
-  memcpy (&srb.u.cmd.cdb_st[0], (char *) src, cdb_size);
+  srb.u.cmd.cdb_len = cmd_size;	/* SCSI command length */
+  memcpy (&srb.u.cmd.cdb_st[0], (char *) cmd, cmd_size);
 
   /* Do the command. */
   rc = DosDevIOCtl (driver_handle, 0x92, 0x02, (void *) &srb,
@@ -3038,7 +3109,7 @@
       && fd_info[fd].sense_handler != 0)
     {
       SANEI_SCSI_Sense_Handler s_handler = fd_info[fd].sense_handler;
-      return (*s_handler) (fd, &srb.u.cmd.cdb_st[cdb_size],
+      return (*s_handler) (fd, &srb.u.cmd.cdb_st[cmd_size],
 			   fd_info[fd].sense_handler_arg);
     }
   if (srb.status != SRB_Done ||
@@ -3055,7 +3126,9 @@
 
 #if USE == STUBBED_INTERFACE
 SANE_Status
-sanei_scsi_cmd (int fd, const void *src, size_t src_size,
+sanei_scsi_cmd2 (int fd, 
+                const void *cmd, size_t cmd_size,
+                const void *src, size_t src_size,
 		void *dst, size_t * dst_size)
 {
   return SANE_STATUS_UNSUPPORTED;
@@ -3067,11 +3140,13 @@
 #define WE_HAVE_FIND_DEVICES
 
 SANE_Status
-sanei_scsi_cmd (int fd, const void *src, size_t src_size,
+sanei_scsi_cmd2 (int fd, 
+                const void *cmd, size_t cmd_size,
+                const void *src, size_t src_size,
 		void *dst, size_t * dst_size)
 {
   dsreq_t scsi_req;			/* SCSI request */
-  size_t  cdb_size;			/* Size of SCSI command */
+  /* xxx obsolete size_t  cdb_size; */	/* Size of SCSI command */
   static u_char	*cmdbuf = NULL,		/* Command buffer */
 		*sensebuf = NULL,	/* Request sense buffer */
 		*databuf  = NULL;	/* Data buffer */
@@ -3094,9 +3169,10 @@
   /*
    * Build the SCSI request...
    */
-  cdb_size = CDB_SIZE (*(u_char *) src);
+  /* xxx obsolete cdb_size = CDB_SIZE (*(u_char *) src);
+  */
 
-  DBG(1, "sanei_scsi_cmd: cdb_size = %d\n", cdb_size);
+  DBG(1, "sanei_scsi_cmd: cmd_size = %d\n", cmd_size);
 
   if (dst != NULL)
     {
@@ -3106,7 +3182,7 @@
       scsi_req.ds_flags    = DSRQ_READ | DSRQ_SENSE;
       scsi_req.ds_time     = 120 * 1000;
       scsi_req.ds_cmdbuf   = (caddr_t) cmdbuf;
-      scsi_req.ds_cmdlen   = cdb_size;
+      scsi_req.ds_cmdlen   = cmd_size;
       scsi_req.ds_databuf  = (caddr_t) databuf;
       scsi_req.ds_datalen  = *dst_size;
       scsi_req.ds_sensebuf = (caddr_t) sensebuf;
@@ -3115,7 +3191,7 @@
       /*
        * Copy command to cmdbuf to assure 32-bit alignment.
        */
-      memcpy(cmdbuf, src, cdb_size);
+      memcpy(cmdbuf, cmd, cmd_size);
     }
   else
     {
@@ -3125,17 +3201,17 @@
       scsi_req.ds_flags    = DSRQ_WRITE | DSRQ_SENSE;
       scsi_req.ds_time     = 120 * 1000;
       scsi_req.ds_cmdbuf   = (caddr_t) cmdbuf;
-      scsi_req.ds_cmdlen   = cdb_size;
+      scsi_req.ds_cmdlen   = cmd_size;
       scsi_req.ds_databuf  = (caddr_t) databuf;
-      scsi_req.ds_datalen  = src_size - cdb_size;
+      scsi_req.ds_datalen  = src_size;
       scsi_req.ds_sensebuf = (caddr_t) sensebuf;
       scsi_req.ds_senselen = sizeof (sensebuf);
 
       /*
        * Copy command and data to local buffers to ensure 32-bit alignment...
        */
-      memcpy (cmdbuf, (u_char *) src, cdb_size);
-      memcpy (databuf, (u_char *) src + cdb_size, src_size - cdb_size);
+      memcpy (cmdbuf, (u_char *) cmd, cmd_size);
+      memcpy (databuf, (u_char *) src, src_size);
     }
 
   /*
@@ -3306,32 +3382,38 @@
 
 #if USE == AIX_GSC_INTERFACE
 SANE_Status
-sanei_scsi_cmd (int fd, const void *src, size_t src_size,
+sanei_scsi_cmd2 (int fd, 
+                const void *cmd, size_t cmd_size,
+                const void *src, size_t src_size,
 		void *dst, size_t * dst_size)
 {
   scmd_t scmd;
-  size_t cdb_size;
+  /* xxx obsolete size_t cdb_size;
+  */
   char sense_buf[32];
   char status;
 
-  cdb_size = CDB_SIZE (*(u_char *) src);
+  /* xxx obsolete cdb_size = CDB_SIZE (*(u_char *) src);
+  */
 
   memset (&scmd, 0, sizeof (scmd));
   if (dst_size && *dst_size)
     {
-      assert (cdb_size == src_size);
+      /* xxx obsolete assert (cdb_size == src_size);
+      */
       scmd.rw = 1;
       scmd.data_buf = dst;
       scmd.datalen = *dst_size;
     }
   else
     {
-      assert (cdb_size <= src_size);
-      scmd.data_buf = (char *) src + cdb_size;
-      scmd.datalen = src_size - cdb_size;
+      /* assert (cdb_size <= src_size);
+      */
+      scmd.data_buf = (char *) src;
+      scmd.datalen = src_size;
     }
-  scmd.cdb = (char *) src;
-  scmd.cdblen = cdb_size;
+  scmd.cdb = (char *) cmd;
+  scmd.cdblen = cmd_size;
   scmd.timeval = 60;		/* 1 minute timeout */
   scmd.sense_buf = sense_buf;
   scmd.senselen = sizeof (sense_buf);
@@ -3372,19 +3454,23 @@
 #endif
 
 SANE_Status
-sanei_scsi_cmd (int fd, const void *src, size_t src_size,
+sanei_scsi_cmd2 (int fd, 
+                const void *cmd, size_t cmd_size,
+                const void *src, size_t src_size,
 		void *dst, size_t * dst_size)
 {
   struct user_scsi us;
-  size_t cdb_size;
+  /* xxx obsolete size_t cdb_size;
+  */
   char sensebf[CCS_SENSE_LEN];
 
-  cdb_size = CDB_SIZE (*(u_char *) src);
+  /* xxx obsolete cdb_size = CDB_SIZE (*(u_char *) src);
+  */
 
   /* first put the user scsi structure together.  */
   memset (&us, 0, sizeof (us));
-  us.us_cdbp = (caddr_t) src;
-  us.us_cdblen = cdb_size;
+  us.us_cdbp = (caddr_t) cmd;
+  us.us_cdblen = cmd_size;
   us.us_sensep = sensebf;
   us.us_senselen = CCS_SENSE_LEN;
   if (dst && dst_size && *dst_size)
@@ -3395,8 +3481,8 @@
     }
   else
     {
-      us.us_bufp = (caddr_t) src + cdb_size;
-      us.us_buflen = src_size - cdb_size;
+      us.us_bufp = (caddr_t) src;
+      us.us_buflen = src_size;
       us.us_flags = USER_SCSI_WRITE;
     }
   /* now run it */
@@ -3440,36 +3526,42 @@
 static int d_errs = 100;
 
 static SANE_Status
-scsi_cmd (int fd, const void *src, size_t src_size,
+scsi_cmd (int fd, 
+          const void *cmd, size_t cmd_size,
+          const void *src, size_t src_size,
 	  void *dst, size_t * dst_size, int probing)
 {
   struct scg_cmd scmd;
-  size_t cdb_size;
+  /* xxx obsolete size_t cdb_size;
+  */
   SANEI_SCSI_Sense_Handler handler;
 
-  cdb_size = CDB_SIZE (*(u_char *) src);
+  /* xxx obsolete cdb_size = CDB_SIZE (*(u_char *) src);
+  */
 
   memset (&scmd, 0, sizeof (scmd));
   scmd.flags = DEF_SCG_FLG | (probing ? SCG_SILENT : 0);
   if (dst && dst_size && *dst_size)
     {
-      assert (cdb_size == src_size);
+      /* xxx obsolete assert (cdb_size == src_size);
+      */
       scmd.flags |= SCG_RECV_DATA;
       scmd.addr = dst;
       scmd.size = *dst_size;
     }
   else
     {
-      assert (cdb_size <= src_size);
-      scmd.addr = (caddr_t) src + cdb_size;
-      scmd.size = src_size - cdb_size;
+      /* xxx obsolete assert (cdb_size <= src_size);
+      */
+      scmd.addr = (caddr_t) src;
+      scmd.size = src_size;
     }
-  scmd.cdb_len = cdb_size;
+  scmd.cdb_len = cmd_size;
   scmd.sense_len = CCS_SENSE_LEN;
   scmd.target = fd_info[fd].target;
   /* use 2 second timeout when probing, 60 seconds otherwise: */
   scmd.timeout = probing ? 2 : DEF_TIMEOUT;
-  memcpy (&scmd.cdb.g0_cdb.cmd, src, cdb_size);
+  memcpy (&scmd.cdb.g0_cdb.cmd, cmd, cmd_size);
   scmd.cdb.cmd_cdb[1] |= fd_info[fd].lun << 5;
   if (ioctl (fd, SCGIO_CMD, &scmd) < 0)
     return SANE_STATUS_IO_ERROR;
@@ -3537,10 +3629,12 @@
 }
 
 SANE_Status
-sanei_scsi_cmd (int fd, const void *src, size_t src_size,
+sanei_scsi_cmd2 (int fd, 
+                const void *cmd, size_t cmd_size,
+                const void *src, size_t src_size,
 		void *dst, size_t * dst_size)
 {
-  return scsi_cmd (fd, src, src_size, dst, dst_size, 0);
+  return scsi_cmd (fd, cmd, cmd_size, src, src_size, dst, dst_size, 0);
 }
 
 static int
@@ -3559,10 +3653,11 @@
 #ifndef WE_HAVE_ASYNC_SCSI
 
 SANE_Status
-sanei_scsi_req_enter (int fd, const void *src, size_t src_size,
+
+sanei_scsi_req_enter2 (int fd, const void *src, size_t src_size,
 		      void *dst, size_t * dst_size, void **idp)
 {
-  return sanei_scsi_cmd (fd, src, src_size, dst, dst_size);
+  return sanei_scsi_cmd2 (fd, cmd, cmd_size, src, src_size, dst, dst_size);
 }
 
 SANE_Status
@@ -3577,6 +3672,40 @@
 }
 
 #endif /* WE_HAVE_ASYNC_SCSI */
+
+SANE_Status sanei_scsi_req_enter (int fd,
+                      const void *src, size_t src_size,
+		      void *dst, size_t * dst_size, void **idp)
+{
+  size_t cmd_size = CDB_SIZE (*(char *) src);
+  
+  if (dst_size && *dst_size)
+    assert(src_size == cmd_size);
+  else
+    assert(src_size >= cmd_size);
+
+  return sanei_scsi_req_enter2(fd,  src, cmd_size, 
+                               (char*) src + cmd_size, src_size - cmd_size, 
+                               dst, dst_size, idp);
+}
+
+SANE_Status
+sanei_scsi_cmd (int fd, const void *src, size_t src_size,
+		void *dst, size_t * dst_size)
+{
+  size_t cmd_size = CDB_SIZE (*(char *) src);
+  
+  if (dst_size && *dst_size)
+    assert(src_size == cmd_size);
+  else
+    assert(src_size >= cmd_size);
+
+  return sanei_scsi_cmd2(fd,  src, cmd_size, 
+                             (char*) src + cmd_size, src_size - cmd_size, 
+                             dst, dst_size);
+}
+
+
 
 #ifndef WE_HAVE_FIND_DEVICES
 
Only in scsi_modified/sanei: sanei_scsi.c~