PnpDispatchDeviceInterface

NTSTATUS __fastcall PnpDispatchDeviceInterface(
        HPNPCTX *hPnpCtx,
        WCHAR *DeviceInterfaceName,
        __int64 a3,
        int a4,
        __int64 a5){
  NTSTATUS(__fastcall *v6)(INT64, INT64, INT64); 
  HPNPCTX *v7; 
  int v8; 
  UINT64 v9; 
  int v10; 
  UINT64 v11; 
  int v12; 
  int v13; 
  int v14; 
  int v15; 
  unsigned int DeviceInterfaceMappedProperty; 
  _DEVPROPKEY *PropertyKey; 
  UINT64 *PropertyType; 
  UINT8 *PropertyBuffer; 
  WCHAR *BufferSize; 
  UINT64 *PropertySize; 
  UINT64 *v23; 
  UINT64 Flags[2]; 

  v6 = 0i64;
  v7 = 0i64;
  *(_OWORD *)Flags = 0i64;
  v8 = a4 - 1;
  if( v8 )
  {
    v9 = (unsigned int)(v8 - 1);
    if( (_DWORD)v9 )
    {
      v10 = v9 - 1;
      if( v10 )
      {
        v11 = (unsigned int)(v10 - 1);
        if( (_DWORD)v11 )
        {
          v12 = v11 - 1;
          if( v12 )
          {
            v13 = v12 - 1;
            if( v13 )
            {
              v14 = v13 - 1;
              if( v14 )
              {
                v15 = v14 - 1;
                if( v15 )
                {
                  if( v15 == 1 )
                  {
                    LODWORD(BufferSize) = *(_DWORD *)(a5 + 40);
                    LODWORD(PropertyType) = *(_DWORD *)(a5 + 24);
                    DeviceInterfaceMappedProperty = CmSetDeviceInterfaceMappedProperty(
                                                      hPnpCtx,
                                                      DeviceInterfaceName,
                                                      *(VOID **)a5,
                                                      *(WCHAR **)(a5 + 8),
                                                      *(_DEVPROPKEY **)(a5 + 16),
                                                      (UINT64)PropertyType,
                                                      *(UINT8 **)(a5 + 32),
                                                      (UINT64)BufferSize);
                  }
                  else
                  {
                    DeviceInterfaceMappedProperty = -1073741811;
                  }
                }
                else
                {
                  LODWORD(BufferSize) = *(_DWORD *)(a5 + 40);
                  DeviceInterfaceMappedProperty = CmGetDeviceInterfaceMappedProperty(
                                                    hPnpCtx,
                                                    DeviceInterfaceName,
                                                    *(VOID **)a5,
                                                    *(const WCHAR **)(a5 + 8),
                                                    *(const _DEVPROPKEY **)(a5 + 16),
                                                    *(UINT64 **)(a5 + 24),
                                                    *(UINT8 **)(a5 + 32),
                                                    (UINT64)BufferSize,
                                                    *(UINT64 **)(a5 + 48));
                }
              }
              else
              {
                DeviceInterfaceMappedProperty = CmGetDeviceInterfaceMappedPropertyLocales(
                                                  (_DEVPROPKEY *)hPnpCtx,
                                                  0i64,
                                                  0i64,
                                                  *(UINT64 **)(a5 + 8));
              }
            }
            else
            {
              LODWORD(PropertyType) = *(_DWORD *)(a5 + 32);
              DeviceInterfaceMappedProperty = CmGetDeviceInterfaceMappedPropertyKeys(
                                                hPnpCtx,
                                                DeviceInterfaceName,
                                                *(VOID **)a5,
                                                0,
                                                *(_DEVPROPKEY **)(a5 + 24),
                                                (UINT64)PropertyType,
                                                *(UINT64 **)(a5 + 40));
            }
          }
          else
          {
            if( *(_QWORD *)a5 )
            {
              Flags[0] = *(_QWORD *)a5;
              v6 = PnpCmMatchCallbackRoutine;
              v7 = (HPNPCTX *)Flags;
              Flags[1] = *(_QWORD *)(a5 + 8);
            }
            LODWORD(PropertyBuffer) = *(_DWORD *)(a5 + 40) & 0xFFFF0000;
            DeviceInterfaceMappedProperty = CmGetMatchingDeviceInterfaceList(
                                              hPnpCtx,
                                              (UINT8 *)v6,
                                              v7,
                                              *(const WCHAR **)(a5 + 16),
                                              *(_CM_OBJECT_TYPE *)(a5 + 24),
                                              *(VOID **)(a5 + 32),
                                              PropertyBuffer,
                                              BufferSize,
                                              (UINT64)PropertySize,
                                              v23,
                                              Flags[0]);
          }
        }
        else
        {
          DeviceInterfaceMappedProperty = CmDeleteDeviceInterface(
                                            hPnpCtx,
                                            DeviceInterfaceName,
                                            (WCHAR *)(*(_DWORD *)a5 & 0xFFFF0000),
                                            v11,
                                            (UINT64)PropertyKey,
                                            (INT64)PropertyType,
                                            (INT64)PropertyBuffer,
                                            (INT64)BufferSize,
                                            (INT64)PropertySize);
        }
      }
      else
      {
        LODWORD(PropertyType) = *(_DWORD *)(a5 + 20) & 0xFFFF0000;
        DeviceInterfaceMappedProperty = CmCreateDeviceInterface(
                                          hPnpCtx,
                                          DeviceInterfaceName,
                                          (WCHAR *)*(unsigned int *)a5,
                                          a5 + 8,
                                          (VOID **)(a5 + 16),
                                          (UINT8 *)PropertyType,
                                          (INT64)PropertyBuffer,
                                          (UINT64 *)BufferSize,
                                          (INT64)PropertySize);
      }
    }
    else
    {
      LOBYTE(PropertyType) = *(_BYTE *)(a5 + 4);
      LODWORD(PropertyKey) = *(_DWORD *)a5;
      DeviceInterfaceMappedProperty = CmOpenDeviceInterfaceRegKey(
                                        hPnpCtx,
                                        DeviceInterfaceName,
                                        48i64,
                                        v9,
                                        (INT64)PropertyKey,
                                        (INT64)PropertyType,
                                        *(VOID ***)(a5 + 8),
                                        (UINT64 *)(a5 + 16));
    }
  }
  else
  {
    DeviceInterfaceMappedProperty = CmValidateDeviceInterfaceName((WCHAR *)hPnpCtx);
  }
  return PnpMapCmStatusToDispatchStatus(DeviceInterfaceMappedProperty);
}

Referenced by:

No references.