install.c

这是USB驱动程序库

      open_service = (open_service_t)
        GetProcAddress(advapi32_dll, "OpenServiceA");
      
      change_service_config = (change_service_config_t)
        GetProcAddress(advapi32_dll, "ChangeServiceConfigA");
      
      close_service_handle = (close_service_handle_t)
        GetProcAddress(advapi32_dll, "CloseServiceHandle");
      
      create_service = (create_service_t)
        GetProcAddress(advapi32_dll, "CreateServiceA");
      
      delete_service = (delete_service_t)
        GetProcAddress(advapi32_dll, "DeleteService");
      
      start_service = (start_service_t)
        GetProcAddress(advapi32_dll, "StartServiceA");
      
      query_service_status = (query_service_status_t)
        GetProcAddress(advapi32_dll, "QueryServiceStatus");
      
      control_service = (control_service_t)
        GetProcAddress(advapi32_dll, "ControlService");
      
      if(!open_sc_manager || !open_service || !change_service_config
         || !close_service_handle || !create_service || !delete_service
         || !start_service || !query_service_status || !control_service)
        {
          FreeLibrary(advapi32_dll);
          usb_error("usb_service_load_dll(): loading exported "
                    "functions of advapi32.dll failed");

          return FALSE;
        }
    }
  return TRUE;
}

bool_t usb_service_free_dll()
{
  if(advapi32_dll)
    {
      FreeLibrary(advapi32_dll);
    }
  return TRUE;
}

bool_t usb_service_create(const char *name, const char *display_name,
                          const char *binary_path, unsigned long type,
                          unsigned long start_type)
{
  SC_HANDLE scm = NULL;
  SC_HANDLE service = NULL;
  bool_t ret = FALSE;

  if(!usb_service_load_dll())
    {
      return FALSE;
    }

  do 
    {
      scm = open_sc_manager(NULL, SERVICES_ACTIVE_DATABASE, 
                            SC_MANAGER_ALL_ACCESS);

      if(!scm)
        {
          usb_error("usb_service_create(): opening service control "
                    "manager failed: %s", usb_win_error_to_string());
          break;
        }
      
      service = open_service(scm, name, SERVICE_ALL_ACCESS);

      if(service)
        {
          if(!change_service_config(service,
                                    type,
                                    start_type,
                                    SERVICE_ERROR_NORMAL,
                                    binary_path,
                                    NULL,
                                    NULL,
                                    NULL,
                                    NULL,
                                    NULL,
                                    display_name))
            {
              usb_error("usb_service_create(): changing config of "
                        "service '%s' failed: %s", 
                        name, usb_win_error_to_string());
              break;
            }
          ret = TRUE;
          break;
        }
  
      if(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST)
        {
          service = create_service(scm,
                                   name,
                                   display_name,
                                   GENERIC_EXECUTE,
                                   type,
                                   start_type,
                                   SERVICE_ERROR_NORMAL, 
                                   binary_path,
                                   NULL, NULL, NULL, NULL, NULL);
	  
          if(!service)
            {
              usb_error("usb_service_create(): creating "
                        "service '%s' failed: %s",
                        name, usb_win_error_to_string());
            }
          ret = TRUE;	
        }
    } while(0);

  if(service)
    {
      close_service_handle(service);
    }
  
  if(scm)
    {
      close_service_handle(scm);
    }
  
  usb_service_free_dll();

  return ret;
}

bool_t usb_service_stop(const char *name)
{
  bool_t ret = FALSE;
  SC_HANDLE scm = NULL;
  SC_HANDLE service = NULL;
  SERVICE_STATUS status;

  if(!usb_service_load_dll())
    {
      return FALSE;
    }

  do
    {
      scm = open_sc_manager(NULL, SERVICES_ACTIVE_DATABASE, 
                            SC_MANAGER_ALL_ACCESS);
      
      if(!scm)
        {
          usb_error("usb_stop_service(): opening service control "
                    "manager failed: %s", usb_win_error_to_string());
          break;
        }
      
      service = open_service(scm, name, SERVICE_ALL_ACCESS);
      
      if(!service)
        {
          ret = TRUE;
          break;
        }

      if(!query_service_status(service, &status))
        {
          usb_error("usb_stop_service(): getting status of "
                    "service '%s' failed: %s", 
                    name, usb_win_error_to_string());
          break;
        }

      if(status.dwCurrentState == SERVICE_STOPPED)
        {
          ret = TRUE;
          break;
        }

      if(!control_service(service, SERVICE_CONTROL_STOP, &status))
        {
          usb_error("usb_stop_service(): stopping service '%s' failed: %s",
                    name, usb_win_error_to_string());
          break;
        }
      
      do 
        {
          int wait = 0;
	  
          if(!query_service_status(service, &status))
            {
              usb_error("usb_stop_service(): getting status of "
                        "service '%s' failed: %s", 
                        name, usb_win_error_to_string());
              break;
            }
          Sleep(500);
          wait += 500;
	  
          if(wait > 20000)
            {
              usb_error("usb_stop_service(): stopping "
                        "service '%s' failed, timeout", name);
              ret = FALSE;
              break;
            }
          ret = TRUE;
        } while(status.dwCurrentState != SERVICE_STOPPED);
    } while(0);

  if(service)
    {
      close_service_handle(service);
    }
  
  if(scm)
    {
      close_service_handle(scm);
    }
  
  usb_service_free_dll();

  return ret;
}

bool_t usb_service_delete(const char *name)
{
  bool_t ret = FALSE;
  SC_HANDLE scm = NULL;
  SC_HANDLE service = NULL;

  if(!usb_service_load_dll())
    {
      return FALSE;
    }

  do 
    {
      scm = open_sc_manager(NULL, SERVICES_ACTIVE_DATABASE, 
                            SC_MANAGER_ALL_ACCESS);
      
      if(!scm)
        {
          usb_error("usb_delete_service(): opening service control "
                    "manager failed: %s", usb_win_error_to_string());
          break;
        }
      
      service = open_service(scm, name, SERVICE_ALL_ACCESS);
  
      if(!service)
        {
          ret = TRUE;
          break;
        }
      

      if(!delete_service(service))
        {
          usb_error("usb_service_delete(): deleting "
                    "service '%s' failed: %s", 
                    name, usb_win_error_to_string());
          break;
        }
      ret = TRUE;
    } while(0);

  if(service)
    {
      close_service_handle(service);
    }
  
  if(scm)
    {
      close_service_handle(scm);
    }
  
  usb_service_free_dll();

  return ret;
}

void CALLBACK usb_touch_inf_file_np_rundll(HWND wnd, HINSTANCE instance,
                                           LPSTR cmd_line, int cmd_show)
{
  usb_touch_inf_file_np(cmd_line);
}

int usb_touch_inf_file_np(const char *inf_file)
{
  const char inf_comment[] = ";added by libusb to break this file's digital "
    "signature";
  const wchar_t inf_comment_uni[] = L";added by libusb to break this file's "
    L"digital signature";

  char buf[1024];
  wchar_t wbuf[1024];
  int found = 0;
  OSVERSIONINFO version;
  FILE *f;

  version.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

  if(!GetVersionEx(&version))
    return -1;


  /* XP system */
  if((version.dwMajorVersion == 5) && (version.dwMinorVersion >= 1))
    {
      f = fopen(inf_file, "rb");
      
      if(!f)
        return -1;

      while(fgetws(wbuf, sizeof(wbuf)/2, f))
        {
          if(wcsstr(wbuf, inf_comment_uni))
            {
              found = 1;
              break;
            }
        }

      fclose(f);

      if(!found)
        {
          f = fopen(inf_file, "ab");
          /*           fputwc(0x000d, f); */
          /*           fputwc(0x000d, f); */
          fputws(inf_comment_uni, f);
          fclose(f);
        }
    }
  else
    {
      f = fopen(inf_file, "r");
      
      if(!f)
        return -1;

      while(fgets(buf, sizeof(buf), f))
        {
          if(strstr(buf, inf_comment))
            {
              found = 1;
              break;
            }
        }

      fclose(f);

      if(!found)
        {
          f = fopen(inf_file, "a");
          fputs("\n", f);
          fputs(inf_comment, f);
          fputs("\n", f);
          fclose(f);
        }
    }

  return 0;
}

int usb_install_needs_restart_np(void)
{
  HDEVINFO dev_info;
  SP_DEVINFO_DATA dev_info_data;
  int dev_index = 0;
  SP_DEVINSTALL_PARAMS install_params;
  int ret = FALSE;

  dev_info_data.cbSize = sizeof(SP_DEVINFO_DATA);
  dev_info = SetupDiGetClassDevs(NULL, NULL, NULL,
                                 DIGCF_ALLCLASSES | DIGCF_PRESENT);
  
  SetEnvironmentVariable("LIBUSB_NEEDS_REBOOT", "1");

  if(dev_info == INVALID_HANDLE_VALUE)
    {
      usb_error("usb_install_needs_restart_np(): getting "
                "device info set failed");
      return ret;
    }
  
  while(SetupDiEnumDeviceInfo(dev_info, dev_index, &dev_info_data))
    {
      memset(&install_params, 0, sizeof(SP_PROPCHANGE_PARAMS));
      install_params.cbSize = sizeof(SP_DEVINSTALL_PARAMS);

      if(SetupDiGetDeviceInstallParams(dev_info, &dev_info_data, 
                                       &install_params))
        {
          if(install_params.Flags & (DI_NEEDRESTART | DI_NEEDREBOOT))
            {
              usb_message("usb_install_needs_restart_np(): restart needed");
              ret = TRUE;
            }
        }
      
      dev_index++;
    }
  
  SetupDiDestroyDeviceInfoList(dev_info);

  return ret;
}