psapi.c

winNT技术操作系统,国外开放的原代码和LIUX一样

                                     SourceString->Buffer,
                                     pwcUnicodeBuf,
                                     l,
                                     NULL);

        if(!NT_SUCCESS(Status))
        {
          goto exitWithStatus;
        }

        /* initialize Unicode string buffer */
        UnicodeString.Length = UnicodeString.MaximumLength = l;
        UnicodeString.Buffer = pwcUnicodeBuf;

        /* convert and copy */
        if(AreFileApisANSI())
          RtlUnicodeStringToAnsiString(&AnsiString, &UnicodeString, FALSE);
        else
          RtlUnicodeStringToOemString(&AnsiString, &UnicodeString, FALSE);

        /* return the string size */
        Context->nBufSize = AnsiString.Length;
#if 0
        }
        __finally
        {
          /* free the buffer */
          PsaiFree(pwcUnicodeBuf);
        }
#else
        Status = STATUS_NO_MORE_FILES;

exitWithStatus:
        /* free the buffer */
        PsaiFree(pwcUnicodeBuf);
        return Status;
#endif
      }
    }
    else
    {
      /* we want other module information */
      ULONG nSize = Context->nBufSize;

      /* base address */
      if(nSize >= sizeof(CurrentModule->DllBase))
      {
        Context->lpmodinfo->lpBaseOfDll = CurrentModule->DllBase;
        nSize -= sizeof(CurrentModule->DllBase);
      }

      /* image size */
      if(nSize >= sizeof(CurrentModule->SizeOfImage))
      {
        Context->lpmodinfo->SizeOfImage = CurrentModule->SizeOfImage;
        nSize -= sizeof(CurrentModule->SizeOfImage);
      }

      /* entry point */
      if(nSize >= sizeof(CurrentModule->EntryPoint))
      {
        /* ??? FIXME? is "EntryPoint" just the offset, or the real address? */
        Context->lpmodinfo->EntryPoint = (PVOID)CurrentModule->EntryPoint;
      }

      Context->nBufSize = TRUE;
    }

    return STATUS_NO_MORE_FILES;
  }

  return STATUS_SUCCESS;
}


static DWORD
InternalGetModuleInformation(HANDLE hProcess,
                             HMODULE hModule,
                             GET_MODULE_INFORMATION_FLAGS Flags,
                             LPVOID lpBuffer,
                             DWORD nBufSize)
{
  GET_MODULE_INFORMATION_CONTEXT Context;
  NTSTATUS Status;

  Context.hModule = hModule;
  Context.Flags = Flags;
  Context.nBufSize = nBufSize;
  Context.lpBuffer = lpBuffer;

  Status = PsaEnumerateProcessModules(hProcess, GetModuleInformationCallback, &Context);

  if(Status == STATUS_NO_MORE_FILES)
  {
    /* module was found, return string size */
    return Context.nBufSize;
  }
  else if(NT_SUCCESS(Status))
  {
    /* module was not found */
    SetLastError(ERROR_INVALID_HANDLE);
  }
  else
  {
    /* an error occurred */
    SetLastErrorByStatus(Status);
  }
  return 0;
}


typedef struct _INTERNAL_ENUM_PAGE_FILES_CONTEXT
{
  PENUM_PAGE_FILE_CALLBACKA pCallbackRoutine;
  LPVOID lpContext;
} INTERNAL_ENUM_PAGE_FILES_CONTEXT, *PINTERNAL_ENUM_PAGE_FILES_CONTEXT;


static BOOL
InternalAnsiPageFileCallback(LPVOID pContext,
                             PENUM_PAGE_FILE_INFORMATION pPageFileInfo,
                             LPCWSTR lpFilename)
{
  size_t slen;
  LPSTR AnsiFileName;
  PINTERNAL_ENUM_PAGE_FILES_CONTEXT Context = (PINTERNAL_ENUM_PAGE_FILES_CONTEXT)pContext;

  slen = wcslen(lpFilename);

  AnsiFileName = (LPSTR)LocalAlloc(LMEM_FIXED, (slen + 1) * sizeof(CHAR));
  if(AnsiFileName != NULL)
  {
    BOOL Ret;

    WideCharToMultiByte(CP_ACP,
                        0,
                        lpFilename,
                        -1, /* only works if the string is NULL-terminated!!! */
                        AnsiFileName,
                        (slen + 1) * sizeof(CHAR),
                        NULL,
                        NULL);

    Ret = Context->pCallbackRoutine(Context->lpContext, pPageFileInfo, AnsiFileName);

    LocalFree((HLOCAL)AnsiFileName);

    return Ret;
  }

  return FALSE;
}

/* PUBLIC *********************************************************************/

/*
 * @implemented
 */
BOOL
STDCALL
EmptyWorkingSet(HANDLE hProcess)
{
  QUOTA_LIMITS QuotaLimits;
  NTSTATUS Status;

  /* query the working set */
  Status = NtQueryInformationProcess(hProcess,
                                     ProcessQuotaLimits,
                                     &QuotaLimits,
                                     sizeof(QuotaLimits),
                                     NULL);

  if(!NT_SUCCESS(Status))
  {
    SetLastErrorByStatus(Status);
    return FALSE;
  }

  /* empty the working set */
  QuotaLimits.MinimumWorkingSetSize = -1;
  QuotaLimits.MaximumWorkingSetSize = -1;

  /* set the working set */
  Status = NtSetInformationProcess(hProcess,
                                   ProcessQuotaLimits,
                                   &QuotaLimits,
                                   sizeof(QuotaLimits));
  if(!NT_SUCCESS(Status))
  {
    SetLastErrorByStatus(Status);
    return FALSE;
  }
  
  return TRUE;
}


/*
 * @implemented
 */
BOOL
STDCALL
EnumDeviceDrivers(LPVOID *lpImageBase,
                  DWORD cb,
                  LPDWORD lpcbNeeded)
{
  ENUM_DEVICE_DRIVERS_CONTEXT Context;
  NTSTATUS Status;
 
  if(cb == 0 || lpImageBase == NULL)
  {
    *lpcbNeeded = 0;
    return TRUE;
  }
 
  cb /= sizeof(PVOID);

  Context.lpImageBase = lpImageBase;
  Context.nCount = cb;

  Status = PsaEnumerateSystemModules(EnumDeviceDriversCallback, &Context);

  /* return the count of bytes returned */
  *lpcbNeeded = (cb - Context.nCount) * sizeof(PVOID);

  if(!NT_SUCCESS(Status) && (Status != STATUS_INFO_LENGTH_MISMATCH))
  {
    SetLastErrorByStatus(Status);
    return FALSE;
  }

  return TRUE;
}


/*
 * @implemented
 */
BOOL
STDCALL
EnumProcesses(DWORD *lpidProcess,
              DWORD cb,
              LPDWORD lpcbNeeded)
{
  ENUM_PROCESSES_CONTEXT Context;
  NTSTATUS Status;
  
  cb /= sizeof(DWORD);
  
  if(cb == 0 || lpidProcess == NULL)
  {
    *lpcbNeeded = 0;
    return TRUE;
  }
  
  Context.lpidProcess = lpidProcess;
  Context.nCount = cb;

  /* enumerate the process ids */
  Status = PsaEnumerateProcesses(EnumProcessesCallback, &Context);

  *lpcbNeeded = (cb - Context.nCount) * sizeof(DWORD);

  if(!NT_SUCCESS(Status) && (Status != STATUS_INFO_LENGTH_MISMATCH))
  {
    SetLastErrorByStatus(Status);
    return FALSE;
  }

  return TRUE;
}


/*
 * @implemented
 */
BOOL
STDCALL
EnumProcessModules(HANDLE hProcess,
                   HMODULE *lphModule,
                   DWORD cb,
                   LPDWORD lpcbNeeded)
{
  ENUM_PROCESS_MODULES_CONTEXT Context;
  NTSTATUS Status;
  
  cb /= sizeof(HMODULE);
  
  if(cb == 0 || lphModule == NULL)
  {
    *lpcbNeeded = 0;
    return TRUE;
  }

  Context.lphModule = lphModule;
  Context.nCount = cb;

  /* enumerate the process modules */
  Status = PsaEnumerateProcessModules(hProcess, EnumProcessModulesCallback, &Context);

  *lpcbNeeded = (cb - Context.nCount) * sizeof(DWORD);

  if(!NT_SUCCESS(Status) && (Status != STATUS_INFO_LENGTH_MISMATCH))
  {
    SetLastErrorByStatus(Status);
    return FALSE;
  }
  
  return TRUE;
}


/*
 * @implemented
 */
DWORD
STDCALL
GetDeviceDriverBaseNameA(LPVOID ImageBase,
                         LPSTR lpBaseName,
                         DWORD nSize)
{
  return InternalGetDeviceDriverName(FALSE, FALSE, ImageBase, lpBaseName, nSize);
}


/*
 * @implemented
 */
DWORD
STDCALL
GetDeviceDriverFileNameA(LPVOID ImageBase,
                         LPSTR lpFilename,
                         DWORD nSize)
{
  return InternalGetDeviceDriverName(FALSE, TRUE, ImageBase, lpFilename, nSize);
}


/*
 * @implemented
 */
DWORD
STDCALL
GetDeviceDriverBaseNameW(LPVOID ImageBase,
                         LPWSTR lpBaseName,
                         DWORD nSize)
{
  return InternalGetDeviceDriverName(TRUE, FALSE, ImageBase, lpBaseName, nSize);
}


/*
 * @implemented
 */
DWORD
STDCALL
GetDeviceDriverFileNameW(LPVOID ImageBase,
                         LPWSTR lpFilename,
                         DWORD nSize)
{
  return InternalGetDeviceDriverName(TRUE, TRUE, ImageBase, lpFilename, nSize);
}


/*
 * @implemented
 */
DWORD
STDCALL
GetMappedFileNameA(HANDLE hProcess,
                   LPVOID lpv,
                   LPSTR lpFilename,
                   DWORD nSize)
{
  return InternalGetMappedFileName(FALSE, hProcess, lpv, lpFilename, nSize);
}


/*
 * @implemented
 */
DWORD
STDCALL
GetMappedFileNameW(HANDLE hProcess,
                   LPVOID lpv,
                   LPWSTR lpFilename,
                   DWORD nSize)
{
  return InternalGetMappedFileName(TRUE, hProcess, lpv, lpFilename, nSize);
}


/*
 * @implemented
 */
DWORD
STDCALL
GetModuleBaseNameA(HANDLE hProcess,
                   HMODULE hModule,
                   LPSTR lpBaseName,
                   DWORD nSize)
{
  GET_MODULE_INFORMATION_FLAGS Flags = {TRUE, FALSE, FALSE};
  return InternalGetModuleInformation(hProcess, hModule, Flags, lpBaseName, nSize);
}


/*
 * @implemented
 */
DWORD
STDCALL
GetModuleBaseNameW(HANDLE hProcess,
                   HMODULE hModule,
                   LPWSTR lpBaseName,
                   DWORD nSize)
{
  GET_MODULE_INFORMATION_FLAGS Flags = {TRUE, TRUE, FALSE};
  return InternalGetModuleInformation(hProcess, hModule, Flags, lpBaseName, nSize);
}


/*
 * @implemented
 */
DWORD
STDCALL
GetModuleFileNameExA(HANDLE hProcess,
                     HMODULE hModule,
                     LPSTR lpFilename,
                     DWORD nSize)
{
  GET_MODULE_INFORMATION_FLAGS Flags = {TRUE, FALSE, TRUE};
  return InternalGetModuleInformation(hProcess, hModule, Flags, lpFilename, nSize);
}


/*
 * @implemented
 */
DWORD
STDCALL
GetModuleFileNameExW(HANDLE hProcess,
                     HMODULE hModule,
                     LPWSTR lpFilename,
                     DWORD nSize)
{
  GET_MODULE_INFORMATION_FLAGS Flags = {TRUE, TRUE, TRUE};
  return InternalGetModuleInformation(hProcess, hModule, Flags, lpFilename, nSize);
}


/*
 * @implemented
 */
BOOL
STDCALL
GetModuleInformation(HANDLE hProcess,
                     HMODULE hModule,
                     LPMODULEINFO lpmodinfo,
                     DWORD cb)
{
  GET_MODULE_INFORMATION_FLAGS Flags = {FALSE, FALSE, FALSE};
  return (BOOL)InternalGetModuleInformation(hProcess, hModule, Flags, lpmodinfo, cb);
}


/*
 * @implemented
 */
BOOL