ioctl.c

Libusb-win32 is a library that allows userspace application to access USB devices on Windows opera

/* LIBUSB-WIN32, Generic Windows USB Library
 * Copyright (c) 2002-2005 Stephan Meyer <[e-mail]>
 *
 * 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 "libusb_driver.h"


NTSTATUS dispatch_ioctl(libusb_device_t *dev, IRP *irp)
{
  int ret = 0;
  NTSTATUS status = STATUS_SUCCESS;

  IO_STACK_LOCATION *stack_location = IoGetCurrentIrpStackLocation(irp);
  ULONG control_code =
    stack_location->Parameters.DeviceIoControl.IoControlCode;

  ULONG input_buffer_length
    = stack_location->Parameters.DeviceIoControl.InputBufferLength;
  ULONG output_buffer_length
    = stack_location->Parameters.DeviceIoControl.OutputBufferLength;
  ULONG transfer_buffer_length
    = stack_location->Parameters.DeviceIoControl.OutputBufferLength;

  libusb_request *request = (libusb_request *)irp->AssociatedIrp.SystemBuffer;
  char *output_buffer = (char *)irp->AssociatedIrp.SystemBuffer;
  char *input_buffer = (char *)irp->AssociatedIrp.SystemBuffer;
  MDL *transfer_buffer_mdl = irp->MdlAddress;

  status = remove_lock_acquire(dev);

  if(!NT_SUCCESS(status))
    { 
      status = complete_irp(irp, status, 0);
      remove_lock_release(dev);
      return status;
    }

  if(!request || input_buffer_length < sizeof(libusb_request)
     || input_buffer_length > LIBUSB_MAX_READ_WRITE
     || output_buffer_length > LIBUSB_MAX_READ_WRITE
     || transfer_buffer_length > LIBUSB_MAX_READ_WRITE)
    { 
      DEBUG_ERROR("dispatch_ioctl(): invalid input or output buffer\n");

      status = complete_irp(irp, STATUS_INVALID_PARAMETER, 0);
      remove_lock_release(dev);
      return status;
    }

  DEBUG_PRINT_NL();

  switch(control_code) 
    {     
    case LIBUSB_IOCTL_SET_CONFIGURATION:

      status = set_configuration(dev, request->configuration.configuration,
                                 request->timeout);
      break;
      
    case LIBUSB_IOCTL_GET_CONFIGURATION:
      
      if(!output_buffer || output_buffer_length < 1)
        {
          DEBUG_ERROR("dispatch_ioctl(), get_configuration: invalid output "
                      "buffer");
          status = STATUS_INVALID_PARAMETER;
          break;
        }

      status = get_configuration(dev, output_buffer, &ret, request->timeout);
      break;

    case LIBUSB_IOCTL_SET_INTERFACE:

      status = set_interface(dev, request->interface.interface,
                             request->interface.altsetting, request->timeout);
      break;

    case LIBUSB_IOCTL_GET_INTERFACE:

      if(!output_buffer || output_buffer_length < 1)
        {
          DEBUG_ERROR("dispatch_ioctl(), get_interface: invalid output "
                      "buffer");
          status =  STATUS_INVALID_PARAMETER;
          break;
        }

      status = get_interface(dev, request->interface.interface,
                             output_buffer, &ret, request->timeout);
      break;

    case LIBUSB_IOCTL_SET_FEATURE:

      status = set_feature(dev, request->feature.recipient,
                           request->feature.index, request->feature.feature,
                           request->timeout);
      
      break;

    case LIBUSB_IOCTL_CLEAR_FEATURE:

      status = clear_feature(dev, request->feature.recipient,
                             request->feature.index, request->feature.feature,
                             request->timeout);
      
      break;

    case LIBUSB_IOCTL_GET_STATUS:

      if(!output_buffer || output_buffer_length < 2)
        {
          DEBUG_ERROR("dispatch_ioctl(), get_status: invalid output buffer");
          status = STATUS_INVALID_PARAMETER;
          break;
        }

      status = get_status(dev, request->status.recipient,
                          request->status.index, output_buffer,
                          &ret, request->timeout);

      break;

    case LIBUSB_IOCTL_SET_DESCRIPTOR:

      if(input_buffer_length <= sizeof(libusb_request))
        {
          DEBUG_ERROR("dispatch_ioctl(), set_descriptor: invalid input "
                      "buffer");
          status = STATUS_INVALID_PARAMETER;
          break;
        }
      
      status = set_descriptor(dev, 
                              input_buffer + sizeof(libusb_request), 
                              input_buffer_length - sizeof(libusb_request), 
                              request->descriptor.type,
                              request->descriptor.recipient,
                              request->descriptor.index,
                              request->descriptor.language_id, 
                              &ret, request->timeout);
      
      break;

    case LIBUSB_IOCTL_GET_DESCRIPTOR:

      if(!output_buffer || !output_buffer_length)
        {
          DEBUG_ERROR("dispatch_ioctl(), get_descriptor: invalid output "
                      "buffer");
          status = STATUS_INVALID_PARAMETER;
          break;
        }

      status = get_descriptor(dev, output_buffer, 
                              output_buffer_length,
                              request->descriptor.type,
                              request->descriptor.recipient,
                              request->descriptor.index,
                              request->descriptor.language_id, 
                              &ret, request->timeout);
      
      break;
      
    case LIBUSB_IOCTL_INTERRUPT_OR_BULK_READ:

      if(!transfer_buffer_mdl)
        {
          DEBUG_ERROR("dispatch_ioctl(), bulk_int_read: invalid transfer "
                      "buffer");
          status = STATUS_INVALID_PARAMETER;
          break;
        }

      return transfer(dev, irp,
                      USBD_TRANSFER_DIRECTION_IN,
                      URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER,
                      request->endpoint.endpoint,
                      request->endpoint.packet_size,
                      transfer_buffer_mdl, 
                      transfer_buffer_length);

    case LIBUSB_IOCTL_INTERRUPT_OR_BULK_WRITE:

      /* we don't check 'transfer_buffer_mdl' here because it might be NULL */
      /* if the DLL requests to send a zero-length packet */
      return transfer(dev, irp,
                      USBD_TRANSFER_DIRECTION_OUT,
                      URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER,
                      request->endpoint.endpoint,
                      request->endpoint.packet_size,
                      transfer_buffer_mdl, 
                      transfer_buffer_length);

    case LIBUSB_IOCTL_VENDOR_READ:

      if(output_buffer_length && !output_buffer)
        {
          DEBUG_ERROR("dispatch_ioctl(), vendor_read: invalid output buffer");
          status = STATUS_INVALID_PARAMETER;
          break;
        }

      status = vendor_class_request(dev,
                                    request->vendor.type, 
                                    request->vendor.recipient,
                                    request->vendor.request,
                                    request->vendor.value,
                                    request->vendor.index,
                                    output_buffer,
                                    output_buffer_length,
                                    USBD_TRANSFER_DIRECTION_IN,
                                    &ret, request->timeout);
      break;

    case LIBUSB_IOCTL_VENDOR_WRITE:
      
      status = 
        vendor_class_request(dev,
                             request->vendor.type, 
                             request->vendor.recipient,
                             request->vendor.request,
                             request->vendor.value,
                             request->vendor.index,
                             input_buffer_length == sizeof(libusb_request) ?
                             NULL : input_buffer + sizeof(libusb_request),
                             input_buffer_length - sizeof(libusb_request),
                             USBD_TRANSFER_DIRECTION_OUT, 
                             &ret, request->timeout);
      break;

    case LIBUSB_IOCTL_RESET_ENDPOINT:

      status = reset_endpoint(dev, request->endpoint.endpoint,
                              request->timeout);
      break;
      
    case LIBUSB_IOCTL_ABORT_ENDPOINT:
	 
      status = abort_endpoint(dev, request->endpoint.endpoint,
                              request->timeout);
      break;

    case LIBUSB_IOCTL_RESET_DEVICE: 
      
      status = reset_device(dev, request->timeout);
      break;

    case LIBUSB_IOCTL_SET_DEBUG_LEVEL:

      DEBUG_SET_LEVEL(request->debug.level);
      break;

    case LIBUSB_IOCTL_GET_VERSION:

      if(!request || output_buffer_length < sizeof(libusb_request))
        {
          DEBUG_ERROR("dispatch_ioctl(), get_version: invalid output buffer");
          status = STATUS_INVALID_PARAMETER;
          break;
        }

      request->version.major = VERSION_MAJOR;
      request->version.minor = VERSION_MINOR;
      request->version.micro = VERSION_MICRO;
      request->version.nano  = VERSION_NANO;

      ret = sizeof(libusb_request);
      break;

    case LIBUSB_IOCTL_CLAIM_INTERFACE:
      status = claim_interface(dev, request->interface.interface);
      break;

    case LIBUSB_IOCTL_RELEASE_INTERFACE:
      status = release_interface(dev, request->interface.interface);
      break;

    case LIBUSB_IOCTL_ISOCHRONOUS_READ:
      if(!transfer_buffer_mdl)
        {
          DEBUG_ERROR("dispatch_ioctl(), isochronous_read: invalid transfer "
                      "buffer");
          status = STATUS_INVALID_PARAMETER;
          break;
        }

      return transfer(dev, irp, USBD_TRANSFER_DIRECTION_IN,
                      URB_FUNCTION_ISOCH_TRANSFER, request->endpoint.endpoint,
                      request->endpoint.packet_size, transfer_buffer_mdl, 
                      transfer_buffer_length);

    case LIBUSB_IOCTL_ISOCHRONOUS_WRITE:

      if(!transfer_buffer_mdl)
        {
          DEBUG_ERROR("dispatch_ioctl(), isochronous_write: invalid transfer "
                      "buffer");
          status = STATUS_INVALID_PARAMETER;
          break;
        }

      return transfer(dev, irp, USBD_TRANSFER_DIRECTION_OUT,
                      URB_FUNCTION_ISOCH_TRANSFER, request->endpoint.endpoint,
                      request->endpoint.packet_size, transfer_buffer_mdl, 
                      transfer_buffer_length);

    default:
      
      status = STATUS_INVALID_PARAMETER;
    }

  status = complete_irp(irp, status, ret);  
  remove_lock_release(dev);

  return status;
}