cmd_usbreq.c

USB monitor

/* cmd_usbreq.c - Nereid USB Monitor / USB request command
 * Copyright (C) 2003 Tachibana Eriko
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */

#include <stdio.h>
#include <stdlib.h>

#include "include/usbdef.h"
#include "cmd_usb.h"
#include "cmd_usbreq.h"
#include "usbmon.h"
#include "usbinfo.h"
#include "usbio.h"
#include "usbdesc.h"
#include "util.h"


/* Defines */
#define BUFFER_SIZE (64 * 1024)

/* Variables */
unsigned char Buffer[BUFFER_SIZE];

/* 堷悢夝庍 */
static int req_get_status (int argc, char* argv[], setupType type);
static int req_clr_feature (int argc, char* argv[], setupType type);
static int req_get_state (int argc, char* argv[], setupType type);
static int req_set_feature (int argc, char* argv[], setupType type);
static int req_set_address (int argc, char* argv[], setupType type);
static int req_get_desc (int argc, char* argv[], setupType type);
static int req_set_desc (int argc, char* argv[], setupType type);
static int req_get_conf (int argc, char* argv[], setupType type);
static int req_set_conf (int argc, char* argv[], setupType type);
static int req_get_intf (int argc, char* argv[], setupType type);
static int req_set_intf (int argc, char* argv[], setupType type);
static int req_synch_frame (int argc, char* argv[], setupType type);

/* 壓惪偗 */
static void get_status (setupType type, int devadr, setupRecipient rec, int index);
static void clr_feature (setupType type, int devadr, setupRecipient rec, int index, int func);
static void get_state (setupType type, int devadr, int port);
static void set_feature (setupType type, int devadr, setupRecipient rec, int index, int func);
static void set_address (setupType type, int devadr);
static void get_descriptor (setupType type, int devadr, int descno, int index, int len);
static void set_descriptor (setupType type, int devadr, int descno, int index, unsigned char* buf, int len);
static void get_configuration (setupType type, int devadr);
static void set_configuration (setupType type, int devadr, int confno);
static void get_interface (setupType type, int devadr, int intf);
static void set_interface (setupType type, int devadr, int intf, int no);
static void synch_frame (setupType type, int devadr, int ep);


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

/* Command: 僗僥乕僞僗庢摼 */
int req_std_get_status (int argc, char* argv[]) { return req_get_status (argc, argv, TYPE_STANDARD); }
int req_cls_get_status (int argc, char* argv[]) { return req_get_status (argc, argv, TYPE_CLASS); }
int req_vdr_get_status (int argc, char* argv[]) { return req_get_status (argc, argv, TYPE_VENDOR); }

/* Command: 婡擻傪柍岠偵偡傞 */
int req_std_clr_feature (int argc, char* argv[]) { return req_clr_feature (argc, argv, TYPE_STANDARD); }
int req_cls_clr_feature (int argc, char* argv[]) { return req_clr_feature (argc, argv, TYPE_CLASS); }
int req_vdr_clr_feature (int argc, char* argv[]) { return req_clr_feature (argc, argv, TYPE_VENDOR); }

/* Command: 僶僗忬懺庢摼 */
int req_std_get_state (int argc, char* argv[]) { return req_get_state (argc, argv, TYPE_STANDARD); }
int req_cls_get_state (int argc, char* argv[]) { return req_get_state (argc, argv, TYPE_CLASS); }
int req_vdr_get_state (int argc, char* argv[]) { return req_get_state (argc, argv, TYPE_VENDOR); }

/* Command: 婡擻傪桳岠偵偡傞 */
int req_std_set_feature (int argc, char* argv[]) { return req_set_feature (argc, argv, TYPE_STANDARD); }
int req_cls_set_feature (int argc, char* argv[]) { return req_set_feature (argc, argv, TYPE_CLASS); }
int req_vdr_set_feature (int argc, char* argv[]) { return req_set_feature (argc, argv, TYPE_VENDOR); }

/* Command: 傾僪儗僗愝掕 */
int req_std_set_address (int argc, char* argv[]) { return req_set_address (argc, argv, TYPE_STANDARD); }
int req_cls_set_address (int argc, char* argv[]) { return req_set_address (argc, argv, TYPE_CLASS); }
int req_vdr_set_address (int argc, char* argv[]) { return req_set_address (argc, argv, TYPE_VENDOR); }

/* Command: 僨僗僋儕僾僞庢摼丒昞帵 */
int req_std_get_desc (int argc, char* argv[]) { return req_get_desc (argc, argv, TYPE_STANDARD); }
int req_cls_get_desc (int argc, char* argv[]) { return req_get_desc (argc, argv, TYPE_CLASS); }
int req_vdr_get_desc (int argc, char* argv[]) { return req_get_desc (argc, argv, TYPE_VENDOR); }

/* Command: 僨僗僋儕僾僞愝掕 */
int req_std_set_desc (int argc, char* argv[]) { return req_set_desc (argc, argv, TYPE_STANDARD); }
int req_cls_set_desc (int argc, char* argv[]) { return req_set_desc (argc, argv, TYPE_CLASS); }
int req_vdr_set_desc (int argc, char* argv[]) { return req_set_desc (argc, argv, TYPE_VENDOR); }

/* Command: 僐儞僼傿僊儏儗乕僔儑儞斣崋庢摼 */
int req_std_get_conf (int argc, char* argv[]) { return req_get_conf (argc, argv, TYPE_STANDARD); }
int req_cls_get_conf (int argc, char* argv[]) { return req_get_conf (argc, argv, TYPE_CLASS); }
int req_vdr_get_conf (int argc, char* argv[]) { return req_get_conf (argc, argv, TYPE_VENDOR); }

/* Command: 僐儞僼傿僊儏儗乕僔儑儞慖戰 */
int req_std_set_conf (int argc, char* argv[]) { return req_set_conf (argc, argv, TYPE_STANDARD); }
int req_cls_set_conf (int argc, char* argv[]) { return req_set_conf (argc, argv, TYPE_CLASS); }
int req_vdr_set_conf (int argc, char* argv[]) { return req_set_conf (argc, argv, TYPE_VENDOR); }

/* Command: 僀儞僞乕僼僃乕僗斣崋庢摼 */
int req_std_get_intf (int argc, char* argv[]) { return req_get_intf (argc, argv, TYPE_STANDARD); }
int req_cls_get_intf (int argc, char* argv[]) { return req_get_intf (argc, argv, TYPE_CLASS); }
int req_vdr_get_intf (int argc, char* argv[]) { return req_get_intf (argc, argv, TYPE_VENDOR); }

/* Command: 僀儞僞乕僼僃乕僗慖戰 */
int req_std_set_intf (int argc, char* argv[]) { return req_set_intf (argc, argv, TYPE_STANDARD); }
int req_cls_set_intf (int argc, char* argv[]) { return req_set_intf (argc, argv, TYPE_CLASS); }
int req_vdr_set_intf (int argc, char* argv[]) { return req_set_intf (argc, argv, TYPE_VENDOR); }

/* Command: 僼儗乕儉摨婜 */
int req_std_synch_frame (int argc, char* argv[]) { return req_synch_frame (argc, argv, TYPE_STANDARD); }
int req_cls_synch_frame (int argc, char* argv[]) { return req_synch_frame (argc, argv, TYPE_CLASS); }
int req_vdr_synch_frame (int argc, char* argv[]) { return req_synch_frame (argc, argv, TYPE_VENDOR); }

/* Hub Class: 傑偩嶌偭偰傑偣傫 */
int req_cls_clr_tt_buf (int argc, char* argv[]) { return RET_FAILURE; }
int req_cls_reset_tt (int argc, char* argv[]) { return RET_FAILURE; }
int req_cls_get_tt_stat (int argc, char* argv[]) { return RET_FAILURE; }
int req_cls_stop_tt (int argc, char* argv[]) { return RET_FAILURE; }


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

/* 僗僥乕僞僗庢摼 堷悢夝庍 */
int
req_get_status (int argc, char* argv[], setupType type)
{
  int i;

  if (argc == 0)
    {
      printf ("<devadr> = 1乣127\tUSB 婡婍偺僨僶僀僗傾僪儗僗傪巜掕偟傑偡.\n"
	      "<rec> = d/i/e\t\t憖嶌懳徾傪巜掕偟傑偡(device, interface, endpoint).\n"
	      "<index> = 0乣255\t0丄僀儞僞乕僼僃乕僗斣崋丄僄儞僪億僀儞僩斣崋傪巜掕偟傑偡.\n");

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

  for (i = 0; i < argc; i += 3)
    {
      int devadr, rec, index;

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

      get_status (type, devadr, rec, index);
    }

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

/* 僗僥乕僞僗昞帵 壓惪偗 */
static void
get_status (setupType type, int devadr, setupRecipient rec, int index)
{
  UsbInfo* usb = get_usbinfo (devadr);
  int stat;

  if (usb == NULL)
    return;

  stat = GetStatus (type, usb->devadr, rec, index, usb->bMaxPacketSize0, usb->speed);
  if (stat < 0)
    return;

  printf ("僨僶僀僗傾僪儗僗 = %d, 僗僥乕僞僗 = 0x%04x", usb->devadr, stat);
  switch (rec)
    {
    case REC_DEVICE:
      printf (" (RemoteWakeUp=%s, %s-powered)", (stat & 0x0002) ? "Enable" : "Disable",
						(stat & 0x0001) ? "Self" : "Bus");
      break;

    case REC_ENDPOINT:
      printf (" (%sHalt)", (stat & 0x0001) ? "" : "Not ");
      break;

    case REC_INTERFACE:
    case REC_OTHER:
      break;
    }
  printf ("\n");
}

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

/* 婡擻傪柍岠偵偡傞 堷悢夝庍 */
int
req_clr_feature (int argc, char* argv[], setupType type)
{
  int i;

  if (argc == 0)
    {
      printf ("<devadr> = 1乣127\tUSB 婡婍偺僨僶僀僗傾僪儗僗傪巜掕偟傑偡.\n"
	      "<rec> = d/i/e\t\t憖嶌懳徾傪巜掕偟傑偡(device, interface, endpoint).\n"
	      "<index> = 0乣255\t0丄僀儞僞乕僼僃乕僗斣崋丄僄儞僪億僀儞僩斣崋傪巜掕偟傑偡.\n"
	      "<func> = 0乣65535\t柍岠偵偡傞婡擻傪巜掕偟傑偡.\n");

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

  for (i = 0; i < argc; i += 4)
    {
      int devadr, rec, index, func;

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

      clr_feature (type, devadr, rec, index, func);
    }

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

/* 婡擻傪柍岠偵偡傞 壓惪偗 */
static void
clr_feature (setupType type, int devadr, setupRecipient rec, int index, int func)
{
  UsbInfo* usb = get_usbinfo (devadr);

  if (usb == NULL)
    return;

  ClearFeature (type, usb->devadr, rec, func, index, usb->bMaxPacketSize0, usb->speed);
}

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

/* 僶僗忬懺庢摼 堷悢夝庍 */
int
req_get_state (int argc, char* argv[], setupType type)
{
  int i;

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

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

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

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

      get_state (type, devadr, port);
    }

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

/* 僶僗忬懺庢摼 堷悢夝庍 */
static void
get_state (setupType type, int devadr, int port)
{
  UsbInfo* usb = get_usbinfo (devadr);
  int rc;

  if (usb == NULL)
    return;

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

  printf ("僨僶僀僗傾僪儗僗 = %d, 億乕僩斣崋 = %d, 僶僗忬懺 = 0x%02x (D+:%s, D-:%s)\n",
			usb->devadr, port, rc, (rc & 0x02) ? "High" : "Low",
					       (rc & 0x01) ? "High" : "Low");
}

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

/* 婡擻傪桳岠偵偡傞 堷悢夝庍 */
int
req_set_feature (int argc, char* argv[], setupType type)
{
  int i;

  if (argc == 0)
    {
      printf ("<devadr> = 1乣127\tUSB 婡婍偺僨僶僀僗傾僪儗僗傪巜掕偟傑偡.\n"
	      "<rec> = d/i/e\t\t憖嶌懳徾傪巜掕偟傑偡(device, interface, endpoint).\n"
	      "<index> = 0乣255\t0丄僀儞僞乕僼僃乕僗斣崋丄僄儞僪億僀儞僩斣崋傪巜掕偟傑偡.\n"
	      "<func> = 0乣65535\t桳岠偵偡傞婡擻傪巜掕偟傑偡.\n");

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

  for (i = 0; i < argc; i += 4)
    {
      int devadr, rec, index, func;

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

      set_feature (type, devadr, rec, index, func);
    }

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

/* 婡擻傪桳岠偵偡傞 壓惪偗 */
static void
set_feature (setupType type, int devadr, setupRecipient rec, int index, int func)
{
  UsbInfo* usb = get_usbinfo (devadr);

  if (usb == NULL)
    return;

  SetFeature (type, usb->devadr, rec, func, index, usb->bMaxPacketSize0, usb->speed);
}

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

/* 傾僪儗僗愝掕 堷悢夝庍 */
int
req_set_address (int argc, char* argv[], setupType type)
{
  int i;

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

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

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

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

      set_address (type, devadr);
    }

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

/* 傾僪儗僗愝掕 壓惪偗 */
/* 崱偺偲偙傠惓忢摦嶌偟側偄 */
static void
set_address (setupType type, int devadr)
{
  UsbInfo* usb0 = get_usbinfo (0);
  UsbInfo* usb;

  if (usb0 == NULL)
    return;

  if (SetAddress (type, devadr, usb0->bMaxPacketSize0, usb0->speed) < 0)
    return;

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

  /* 妱傝摉偰偨僨僶僀僗傾僪儗僗偺忣曬傪愝掕偡傞 */
  *usb = *usb0;
  usb->devadr = devadr;
  usb->confdescp = usb0->confdescp;
  usb->total_confdesc = usb0->total_confdesc;

  /* 僨僶僀僗傾僪儗僗 0 傪弶婜忬懺偵栠偡 */
  usb0->confdescp = NULL;
  free_usbinfo (usb0);
}

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

/* 僨僗僋儕僾僞庢摼丒昞帵 堷悢夝庍 */
int
req_get_desc (int argc, char* argv[], setupType type)
{
  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"
	      "<len> = 0乣65535\t撉傒崬傓挿偝傪巜掕偟傑偡.\n");

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

  for (i = 0; i < argc; i += 5)
    {
      int devadr, desc, no, index, len;
      int argerr = 0;

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

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