cmd_usbreq.c

USB monitor

	++argerr;

      if (argerr != 0)
	{
	  printf ("get descriptor: 堷悢偑惓偟偔偁傝傑偣傫.\n");
	  return RET_FAILURE;
	}

      get_descriptor (type, devadr, (desc << 8) + no, index, len);
    }

  /* 惓忢廔椆 */
  return RET_SUCCESS;
}

/* 僨僗僋儕僾僞庢摼丒昞帵 壓惪偗 */
static void
get_descriptor (setupType type, int devadr, int descno, int index, int len)
{
  UsbInfo* usb;
  unsigned char* buf;
  int rc;

  if ((usb = get_usbinfo (devadr)) == NULL)
    return;
  if ((buf = malloc (len)) == NULL)
    {
      perror ("get descriptor");
      return;
    }

  rc = GetDescriptor (type, devadr, descno, index, len, buf,
					usb->bMaxPacketSize0, usb->speed);

  /* 撉傒崬傫偩僨僗僋儕僾僞傪弴偵夝庍偟偰偄偔 */
  if (rc > 0)
    {
      unsigned char* p = buf;
      unsigned char* tail = buf + rc;

      while (p < tail)
	{
	  DevDesc devdesc;
	  const int minsize = ((char*) &devdesc.bDescriptorType) - ((char*) &devdesc)
			      + sizeof (devdesc.bDescriptorType);
	  int desc_len, desc_type;

	  /* 壖 */
	  desc_len = tail - p;
	  desc_type = descno >> 8;

	  switch (desc_type)
	    {
	    case DES_HID_REPORT:
	      print_hid_reportdesc ((HidRepDesc*) p, desc_len);
	      break;

	    case DES_HID_PHYSICAL:
	      print_hid_physicaldesc ((HidPhyDesc*) p, desc_len);
	      break;

	    default:
	      /* 昗弨宍幃僨僗僋儕僾僞 */
	      if (desc_len < minsize)
		{
		  printf ("Descriptor 偺僒僀僘偑晄惓偱偡.\n");
		  desc_type = -1;
		  break;
		}
	      desc_len = ((DevDesc*) p)->bLength;
	      desc_type = ((DevDesc*) p)->bDescriptorType;

	      if (tail < &p[desc_len])
		{
		  printf ("Descriptor 偺僒僀僘偑晄惓偱偡.\n");
		  desc_type = -1;
		  break;
		}
	      if (desc_type < 0)
		break;

	      /* 僨僗僋儕僾僞偺撪梕傪昞帵 */
	      print_descriptor (p);
	    }

	  switch (desc_type)
	    {
	    case DES_DEVICE:
	      /* 僨僶僀僗忣曬傪峏怴偡傞 */
	      usb->devdesc = *(DevDesc*) p;
	      usb->bMaxPacketSize0 = usb->devdesc.bMaxPacketSize0;
	      break;

	    case DES_CONFIGURATION:
	      /* 僨僶僀僗忣曬傪峏怴偡傞 */
	      usb->confno = ((ConfDesc*) p)->bConfigurationValue;
	      free (usb->confdescp);

	      usb->total_confdesc = tail - p;
	      usb->confdescp = malloc (usb->total_confdesc);
	      if (usb->confdescp == NULL)
		printf ("僶僢僼傽傪妋曐偱偒傑偣傫.\n");
	      else
		memcpy (usb->confdescp, p, usb->total_confdesc);
	      break;

	    default:
	      break;
	    }

	  p += desc_len;
	}
    }

  free (buf);
}

/* ---------------------------------------------------------------------- */

/* 僨僗僋儕僾僞愝掕 堷悢夝庍 */
int
req_set_desc (int argc, char* argv[], setupType type)
{
  unsigned char* p;
  int devadr, desc, no, index;
  int argerr = 0;
  int i;

  if (argc == 0)
    {
      printf ("<devadr> = 0乣127\t僨僶僀僗傾僪儗僗傪巜掕偟傑偡.\n"
	      "<desc> = 0乣255/name\t僨僗僋儕僾僞偺庬椶傪巜掕偟傑偡.\n"
	      "<no> = 0乣255\t\t僨僗僋儕僾僞斣崋傪巜掕偟傑偡.\n"
              "<index> = 0乣65535\t僀儞僨僢僋僗斣崋傪巜掕偟傑偡.\n"
	      "[data] = 0乣255\t彂偒崬傓僨乕僞傪巜掕偟傑偡.\n");

      /* 惓忢廔椆 */
      return RET_SUCCESS;
    }

  if (argc < 4)
    {
      printf ("set descriptor: 堷悢偑懌傝傑偣傫.\n");
      return RET_FAILURE;
    }

  if ((sscanf (argv[0], "%i", &devadr) != 1)
   || (devadr < 0 || DEVADR_MAX < devadr))
    ++argerr;
  if ((desc = descriptor_type_num (argv[1])) < 0)
    if ((sscanf (argv[1], "%i", &desc) != 1) || (desc < 0 || 255 < desc))
      ++argerr;
  if ((sscanf (argv[2], "%i", &no) != 1) || (no < 0 || 255 < no))
    ++argerr;
  if ((sscanf (argv[3], "%i", &index) != 1) || (index < 0 || 255 < index))
    ++argerr;

  if (argerr != 0)
    {
      printf ("set descriptor: 堷悢偑惓偟偔偁傝傑偣傫.\n");
      return RET_FAILURE;
    }

  /* 彂偒崬傓僨乕僞傪僶僀僫儕壔偡傞 */
  p = Buffer;
  for (i = 4; i < argc; ++i)
    {
      int d;

      if ((sscanf (argv[i], "%i", &d) != 1) || (d < 0 || 255 < d))
	{
	  printf ("set descriptor: 僨乕僞偺巜掕偑惓偟偔偁傝傑偣傫.\n");
	  return RET_FAILURE;
	}

      *p++ = d;

      if ((p - Buffer) >= BUFFER_SIZE)
	{
	  printf ("set descriptor: 僨乕僞偑挿偡偓傑偡.\n");
	  return RET_FAILURE;
	}
    }

  set_descriptor (type, devadr, (desc << 8) + no, index, Buffer, p - Buffer);

  /* 惓忢廔椆 */
  return RET_SUCCESS;
}

/* 僨僗僋儕僾僞愝掕 壓惪偗 */
static void
set_descriptor (setupType type, int devadr, int descno, int index,
						unsigned char* buf, int len)
{
  UsbInfo* usb;

  if ((usb = get_usbinfo (devadr)) == NULL)
    return;

  SetDescriptor (type, devadr, descno, index, len, buf,
				usb->bMaxPacketSize0, usb->speed);
}

/* ---------------------------------------------------------------------- */

/* 僐儞僼傿僊儏儗乕僔儑儞斣崋庢摼 堷悢夝庍 */
int
req_get_conf (int argc, char* argv[], setupType type)
{
  int i;

  if (argc == 0)
    {
      printf ("<devadr> = 1乣127\tUSB 婡婍偺僨僶僀僗傾僪儗僗傪巜掕偟傑偡.\n");

      /* 惓忢廔椆 */
      return RET_SUCCESS;
    }

  for (i = 0; i < argc; ++i)
    {
      int devadr;

      if ((sscanf (argv[i], "%i", &devadr) != 1)
       || (devadr < 0 || DEVADR_MAX < devadr))
	{
	  printf ("get configuration: 堷悢偑惓偟偔偁傝傑偣傫.\n");
	  return RET_FAILURE;
	}

      get_configuration (type, devadr);
    }

  /* 惓忢廔椆 */
  return RET_SUCCESS;
}

/* 僐儞僼傿僊儏儗乕僔儑儞斣崋庢摼 壓惪偗 */
static void
get_configuration (setupType type, int devadr)
{
  UsbInfo* usb = get_usbinfo (devadr);
  int rc;

  if (usb == NULL)
    return;

  rc = GetConfiguration (type, usb->devadr, usb->bMaxPacketSize0, usb->speed);
  if (rc < 0)
    return;

  usb->confno = rc;
  printf ("僨僶僀僗傾僪儗僗 = %d, 僐儞僼傿僊儏儗乕僔儑儞斣崋 = %d\n",
							usb->devadr, rc);
}

/* ---------------------------------------------------------------------- */

/* 僐儞僼傿僊儏儗乕僔儑儞慖戰 堷悢夝庍 */
int
req_set_conf (int argc, char* argv[], setupType type)
{
  int i;

  if (argc == 0)
    {
      printf ("<devadr> = 1乣127\tUSB 婡婍偺僨僶僀僗傾僪儗僗傪巜掕偟傑偡.\n"
	      "<no> = 0乣255\t\t僐儞僼傿僊儏儗乕僔儑儞斣崋傪巜掕偟傑偡.\n");

      /* 惓忢廔椆 */
      return RET_SUCCESS;
    }

  for (i = 0; i < argc; i += 2)
    {
      int devadr, confno;

      if (argc < i + 2)
	{
	  printf ("set configuration: 堷悢偑懌傝傑偣傫.\n");
	  return RET_FAILURE;
	}
      if ((sscanf (argv[i + 0], "%i", &devadr) != 1)
       || (sscanf (argv[i + 1], "%i", &confno) != 1)
       || (devadr < 0 || DEVADR_MAX < devadr)
       || (confno < 0 || 255 < confno))
	{
	  printf ("set configuration: 堷悢偑惓偟偔偁傝傑偣傫.\n");
	  return RET_FAILURE;
	}

      set_configuration (type, devadr, confno);
    }

  /* 惓忢廔椆 */
  return RET_SUCCESS;
}

/* 僐儞僼傿僊儏儗乕僔儑儞慖戰 壓惪偗 */
static void
set_configuration (setupType type, int devadr, int confno)
{
  UsbInfo* usb = get_usbinfo (devadr);
  int rc;

  if (usb == NULL)
    return;

  rc = SetConfiguration (type, usb->devadr, confno, usb->bMaxPacketSize0, usb->speed);
  if (rc < 0)
    return;

  usb->confno = confno;
}

/* ---------------------------------------------------------------------- */

/* 僀儞僞乕僼僃乕僗斣崋庢摼 堷悢夝庍 */
int
req_get_intf (int argc, char* argv[], setupType type)
{
  int i;

  if (argc == 0)
    {
      printf ("<devadr> = 1乣127\tUSB 婡婍偺僨僶僀僗傾僪儗僗傪巜掕偟傑偡.\n"
	      "<intf> = 0乣255\t\t僀儞僞乕僼僃乕僗斣崋傪巜掕偟傑偡.\n");

      /* 惓忢廔椆 */
      return RET_SUCCESS;
    }

  for (i = 0; i < argc; i += 2)
    {
      int devadr, intf;

      if (argc < i + 2)
	{
	  printf ("get interface: 堷悢偑懌傝傑偣傫.\n");
	  return RET_FAILURE;
	}
      if ((sscanf (argv[i + 0], "%i", &devadr) != 1)
       || (sscanf (argv[i + 1], "%i", &intf) != 1)
       || (devadr < 0 || DEVADR_MAX < devadr)
       || (intf < 0 || WORD_MAX < intf))
	{
	  printf ("get interface: 堷悢偑惓偟偔偁傝傑偣傫.\n");
	  return RET_FAILURE;
	}

      get_interface (type, devadr, intf);
    }

  /* 惓忢廔椆 */
  return RET_SUCCESS;
}

/* 僀儞僞乕僼僃乕僗斣崋庢摼 壓惪偗 */
static void
get_interface (setupType type, int devadr, int intf)
{
  UsbInfo* usb = get_usbinfo (devadr);
  int rc;

  if (usb == NULL)
    return;

  rc = GetInterface (type, usb->devadr, intf, usb->bMaxPacketSize0, usb->speed);
  if (rc < 0)
    return;

  printf ("僨僶僀僗傾僪儗僗 = %d, 僀儞僞乕僼僃乕僗愝掕 = %d\n", usb->devadr, rc);
}

/* ---------------------------------------------------------------------- */

/* 僀儞僞乕僼僃乕僗慖戰 堷悢夝庍 */
int
req_set_intf (int argc, char* argv[], setupType type)
{
  int i;

  if (argc == 0)
    {
      printf ("<devadr> = 1乣127\tUSB 婡婍偺僨僶僀僗傾僪儗僗傪巜掕偟傑偡.\n"
	      "<intf> = 0乣255\t\t僀儞僞乕僼僃乕僗斣崋傪巜掕偟傑偡.\n"
	      "<no> = 0乣255\t\t愝掕偡傞抣傪巜掕偟傑偡.\n");

      /* 惓忢廔椆 */
      return RET_SUCCESS;
    }

  for (i = 0; i < argc; i += 3)
    {
      int devadr, intf, no;

      if (argc < i + 3)
	{
	  printf ("set interface: 堷悢偑懌傝傑偣傫.\n");
	  return RET_FAILURE;
	}
      if ((sscanf (argv[i + 0], "%i", &devadr) != 1)
       || (sscanf (argv[i + 1], "%i", &intf) != 1)
       || (sscanf (argv[i + 2], "%i", &no) != 1)
       || (devadr < 0 || DEVADR_MAX < devadr)
       || (intf < 0 || WORD_MAX < intf)
       || (no < 0 || WORD_MAX < no))
	{
	  printf ("set interface: 堷悢偑惓偟偔偁傝傑偣傫.\n");
	  return RET_FAILURE;
	}

      set_interface (type, devadr, intf, no);
    }

  /* 惓忢廔椆 */
  return RET_SUCCESS;
}

/* 僀儞僞乕僼僃乕僗慖戰 壓惪偗 */
static void
set_interface (setupType type, int devadr, int intf, int no)
{
  UsbInfo* usb = get_usbinfo (devadr);

  if (usb == NULL)
    return;

  SetInterface (type, usb->devadr, intf, no, usb->bMaxPacketSize0, usb->speed);
}

/* ---------------------------------------------------------------------- */

/* 摨婜僼儗乕儉庢摼 堷悢夝庍 */
int
req_synch_frame (int argc, char* argv[], setupType type)
{
  int i;

  if (argc == 0)
    {
      printf ("<devadr> = 1乣127\tUSB 婡婍偺僨僶僀僗傾僪儗僗傪巜掕偟傑偡.\n"
	      "<ep> = 0乣15\t\t僄儞僪億僀儞僩斣崋傪巜掕偟傑偡.\n");

      /* 惓忢廔椆 */
      return RET_SUCCESS;
    }

  for (i = 0; i < argc; i += 2)
    {
      int devadr, ep;

      if (argc < i + 2)
	{
	  printf ("synch frame: 堷悢偑懌傝傑偣傫.\n");
	  return RET_FAILURE;
	}
      if ((sscanf (argv[i + 0], "%i", &devadr) != 1)
       || (sscanf (argv[i + 1], "%i", &ep) != 1)
       || (devadr < 0 || DEVADR_MAX < devadr)
       || (ep < 0 || ENDPOINT_MAX < ep))
	{
	  printf ("synch frame: 堷悢偑惓偟偔偁傝傑偣傫.\n");
	  return RET_FAILURE;
	}

      synch_frame (type, devadr, ep);
    }

  /* 惓忢廔椆 */
  return RET_SUCCESS;
}

/* 摨婜僼儗乕儉庢摼 壓惪偗 */
static void
synch_frame (setupType type, int devadr, int ep)
{
  UsbInfo* usb = get_usbinfo (devadr);
  int frame;

  if (usb == NULL)
    return;

  if ((frame = SynchFrame (type, usb->devadr, ep, usb->bMaxPacketSize0, usb->speed)) < 0)
    return;

  printf ("僨僶僀僗傾僪儗僗 = %d, 僄儞僪億僀儞僩 = %d, 摨婜僼儗乕儉 = 0x%04x\n",
		usb->devadr, ep, frame);
}

/* ---------------------------------------------------------------------- */

/* EOF */