Sprawdzanie nazwy konta na którym zalogował się użytkownik.

Do sprawdzenia nazwy konta na którym zalogował się użytkownik można posłużyć się funkcją GetUserName:

IDLE_PRIORITY_CLASS - niski
NORMAL_PRIORITY_CLASS - normalny
HIGH_PRIORITY_CLASS - wysoki
REALTIME_PRIORITY_CLASS - czasu rzeczywistego

Przykład sprawdzenia priorytetu własnej aplikacji:

Sprawdzanie zużycia pamięci przez procesy uruchomione w systemie.

W poradzie 'sprawdzanie ile pamięci zużywa nasz program' pokazałem sposób na sprawdzenie zużycia pamięci przez program, który tą funkcję wywołuje. Uchwyt do procesu został tam pobrany poprzez funkcję GetCurrentProcess(), podstawiając w to miejsce uchwyt do innego procesu, możemy sprawdzić ile pamięci taki proces zużywa, wymaga to otwarcia procesu i uzyskania do niego pełnego dostępu funkcję OpenProcess, tutaj od razu nadmienię, że do pewnych procesów systemowych, sam system dostępu nie chce udzielić i tak np. nie udało mi się uzyskać dostępu do procesów 'csrss.exe' i 'alg.exe'. W poradzie 'sprawdzanie i zmiana priorytetu aplikacji' również została użyta funkcja OpenProcess, a jako pierwszy argument została jej przekazana wartość PROCESS_ALL_ACCESS, to jest żądanie pełnego dostępu do procesu i jeżeli od procesów systemowych również zażądamy pełnego dostępu, to jak łatwo się domyślić nie uzyskamy go, dlatego jako pierwszy argument należy podać  PROCESS_QUERY_INFORMATION co jest prośbą o dostęp do informacji o procesie, a więc bez możliwości ingerencji w sam proces.
Do realizacji tego zadania trzeba stworzyć trzy odrębne funkcje, które będą ze sobą współpracowały. Funkcja GetMemory będzie odczytywała informacje o zużyci pamięci przez proces przekazany jej jako argument i będzie zwracała wynik w postaci zmienne typu AnsiString. Funkcja GetMemory pobiera jako argument numer procesu, czyli jego identyfikator, dlatego potrzebna jest kolejna funkcja wyliczająca uruchomione w systemie procesy i tutaj zaproponuję dwie różne funkcje.
    Pierwsza z nich EnumWindowProc będzie zliczała nie tyle wszystkie procesy uruchomione w systemie ile uruchomione programy, czyli zliczanie będzie odbywało się w oparciu o okna programów. Żeby ograniczyć liczbę zaindeksowanych okien wprowadziłem do niej funkcję filtrującą IsWindowVisible - ograniczająca indeksowanie tylko do okien widocznych na pasku zadań, to znaczy że programy zminimalizowane do zasobnika systemowego (systray) nie zostaną zaindeksowane. Chciałem w ten sposób uzyskać taki efekt jaki mamy w Menadżerze zadań na zakładce Aplikacje, jednak nie udało mi się znaleźć sposobu na ograniczenie indeksowania tylko dla aplikacji na pasku zadań, więc indeksowany jest zarówno pasek zdań jak i samo okno programu, dlatego będą się one powtarzać na liście.
    Druga funkcja GetProcess pobiera nazwy procesów uruchomionych w systemie, czyli dokładnie to co widać w Menadżerze zadań na zakładce Procesy i tutaj już nie ma problemu z powtarzaniem się tych samych procesów.
Zanim przystąpimy do pisania kodu, umieszczamy na formularzu komponent ListBox1 i dwa komponenty Button1 i Button2. W zdarzeniu OnClick dla przycisku Button1 zostanie wywołana funkcja EnumWindow indeksująca programy w oparciu o okna, natomiast w zdarzeniu OnClick przycisku Button2 zostanie wywołana funkcja GetProces indeksująca procesy. W obiekcie ListBox1 będzie wyświetlana lista okien wraz ze zużyciem pamięci jeśli zostanie naciśnięty przycisk Button1, lub lista procesów również ze zużyciem pamięci po wybraniu przycisku Button2. Do projektu należy włączyć dwie biblioteki: #include <psapi.h> i #include <tlhelp32.h>

//-------------------------------- #include <psapi.h> AnsiString GetMemory(DWORD ThreadID) {  typedef BOOL (_stdcall *PGetProcessMemoryInfo)(HANDLE, void*, DWORD);  String Result;  PGetProcessMemoryInfo Memproc;  HMODULE hMod;  PROCESS_MEMORY_COUNTERS ProcMem;  memset(&ProcMem, 0, sizeof(ProcMem));  ProcMem.cb = sizeof(ProcMem);  hMod = ::LoadLibrary("psapi.dll");  HANDLE ProcessHandle = OpenProcess(PROCESS_QUERY_INFORMATION , true, ThreadID);  if(!hMod) return "access denied";  Memproc = (PGetProcessMemoryInfo)::GetProcAddress(hMod, "GetProcessMemoryInfo");  if(!Memproc) return "access denied";  if((*Memproc)(ProcessHandle, &ProcMem, sizeof(ProcMem)))   Result = FloatToStrF(ProcMem.WorkingSetSize / 1024, ffNumber, 7, 0) + " KB";  else   Result = "access denied";  FreeLibrary(hMod);  return Result; } //--------------------------------------------------------------------------- bool CALLBACK EnumWindowsProc(HWND hWnd, TStrings *EnumList) {  char WindowName[255];  DWORD ID;  GetWindowText(hWnd, WindowName, 255);  GetWindowThreadProcessId(hWnd, &ID);  if(*WindowName != '\0')  {   if(IsWindowVisible(hWnd) >= 1)   {    String tmp = (String)WindowName + " - " + GetMemory(ID);    if(EnumList->IndexOf(tmp) < 0)     EnumList->Add((String)WindowName + " - " + GetMemory(ID));   }  }  return true; } //--------------------------------------------------------------------------- #include <tlhelp32.h> void __fastcall GetProcess(TStrings *ProcList) {  HWND Snap;  PROCESSENTRY32 proces;  Snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);  proces.dwSize = sizeof(PROCESSENTRY32);  if(Process32First(Snap, &proces))  {   do   {    if(proces.szExeFile[0] != '[')    {     ProcList->Add((String)(String)proces.szExeFile + " - " + GetMemory(proces.th32ProcessID));    }   }   while(Process32Next(Snap , &proces));  }  CloseHandle(Snap); } //--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) {  ListBox1->Items->Clear();  EnumWindows((WNDENUMPROC)EnumWindowsProc, (LPARAM)ListBox1->Items); } //--------------------------------------------------------------------------- void __fastcall TForm1::Button2Click(TObject *Sender) {  ListBox1->Items->Clear();  GetProcess(ListBox1->Items); } //--------------------------------

Struktura PROCESS_MEMORY_COUNTERS zwraca znacznie więcej informacji o użyciu pamięci nie tylko RAM, ale również pamięci wirtualnej (pliku wymiany):

• .PageFaultCount - liczba błędów strony

• .PageFileUsage - użycie pamięci wirtualne, pliku wymiany

• .PeakPageFileUsage - maksymalna przestrzeń zarezerwowana w pliku wymiany

• .PeakWorkingSetSize - szczytowe użycie pamięci RAM

• .QuotaNonPagedPoolUsage - niestronicowana pula pamięci

• .QuotaPagedPoolUsage - stronicowana pula pamięci

• .QuotaPeakNonPagedPoolUsage - szczytowa niestronicowana pula pamięci

• .QuotaPeakPagedPoolUsage - szczytowa stronicowana pula pamięci

• .WorkingSetSize - użycie pamięci RAM

 

...powrót do menu. 

Zamykanie procesów.

Nie trzeba chyba nikomu wyjaśniać czym jest zamykanie procesów, możemy to zrobić np. za pomocą Menadżera zadań wybierając jakiś proces na zakładce Procesy, a potem przycisk 'Zakończ proces'. Niniejsza porada opiera się na mechanizmie, który został zastosowany w poradzie 'sprawdzanie zużycia pamięci przez procesy uruchomione w systemie', z tym, że tutaj funkcja zamiast funkcji pobierającej informacje o pamięci została stworzona funkcja CloseProcess, wykorzystująca inną gotową funkcję TerminateProcess kończąca działanie dowolnego procesu. Nie jest jednak tak, że można zamknąć każdy proces, do niektórych procesów systemowych, system nie udzieli dostępu i nie pozwoli go zamknąć.
Nie będę w tej poradzie wyjaśniał mechanizmów działania, bo można o nich przeczytać w wymienionej wyżej poradzie, wspomnę jednak, że tym razem posłużymy się dodatkowym obiektem WindowList typu TStringList, który będzie przechowywał informacje o oknach i procesach uruchomionych w systemie oraz numery identyfikacyjne tych procesów niezbędne do ich zamknięcia. Procesy będą zamykane na dwa sposoby, jeden poprzez wybranie z listy ListBox1 nazwy okna, a drugi sposób poprzez wybranie z ListBox1 nazwy procesu. To czy w ListBox1 znajdą się nazwy okien czy nazwy procesów, będzie zależało od tego, którą z dwóch funkcji indeksujących wybierzemy poprzez przyciski. Po wybraniu Button1 na liście zostaną umieszczone nazwy okien, natomiast po wybraniu Button2 nazwy procesów. Z listy WindowList zostaną do ListBox1 przepisane tylko nazwy okien lub procesów bez ich numerów identyfikacyjnych, te będą przechowywane na liście WindowList, dlatego należy zadeklarować ją jako obiekt globalny w pliku nagłówkowym w sekcji private, a potem zdefiniować w konstruktorze klasy formularza.
W przedstawionym niżej kodzie da się zauważyć jeszcze jeden, być może dla niektórych niezrozumiały element, otóż jest to obiekt SelButton typu TComponent, a służy on do zapamiętania przez program, na który przycisk ostatnio kliknęliśmy, żeby po usunięciu wybranego na liście procesu odświeżyć tą listę zgodnie z wcześniejszym wyborem, czyli jeżeli wybraliśmy indeksowanie procesów na podstawie okien programów to program to zapamięta i po usunięciu z listy wybranego procesu odświeży ją zgodnie z wyborem i ponownie umieści na niej nazwy okien a nie nazwy procesów. Procesy będą zamykane po dwukrotnym kliknięciu na ListBox1.

// Plik nagłówkowy np. Unit1.h //-------------------------------- private:         TStringList *WindowList;

 

// Plik źródłowy np. Unit1.cpp //-------------------------------- _fastcall TForm1::TForm1(TComponent* Owner)         : TForm(Owner) {  WindowList = new TStringList; } //--------------------------------------------------------------------------- bool CALLBACK EnumWindowsProc(HWND hWnd, TStrings *EnumList) {  char WindowName[80];  DWORD ID;  GetWindowText(hWnd, WindowName, 80);  GetWindowThreadProcessId(hWnd, &ID);  if(!AnsiString(WindowName).IsEmpty())  {   if(IsWindowVisible(hWnd) >= 1)   {    String tmp = (String)WindowName + "=" + (String)ID;    if(EnumList->IndexOf(tmp) < 0)     EnumList->Add((String)WindowName + "=" + (String)ID);   }  }  return true; } //--------------------------------------------------------------------------- #include <tlhelp32.h> void __fastcall GetProcess(TStrings *ProcList) {  HWND Snap;  PROCESSENTRY32 proces;  Snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);  proces.dwSize = sizeof(PROCESSENTRY32);  if(Process32First(Snap, &proces))  {   do   {    if(proces.szExeFile[0] != '[')    {     ProcList->Add((String)(String)proces.szExeFile + "=" + (String)proces.th32ProcessID);    }   }   while(Process32Next(Snap , &proces));  }  CloseHandle(Snap); } //--------------------------------------------------------------------------- bool CloseProcess(DWORD ID) {  DWORD ExitCode;  HWND hWnd;  bool Result = true;  if(ID)  {   hWnd = OpenProcess(PROCESS_ALL_ACCESS, true, ID);   if(hWnd)   {    GetExitCodeProcess(hWnd, &ExitCode);    Result = TerminateProcess(hWnd, ExitCode);   }   else return false;  }  else return false;  CloseHandle(hWnd);  return Result; } //--------------------------------------------------------------------------- TComponent *SelButton; void __fastcall TForm1::Button1Click(TObject *Sender) {  SelButton = dynamic_cast<TButton *>(Sender);  ListBox1->Items->Clear();  WindowList->Clear();  EnumWindows((WNDENUMPROC)EnumWindowsProc,(LPARAM)WindowList);  for(int i = 0; i < WindowList->Count; i++)   ListBox1->Items->Add(WindowList->Names[i]); } //--------------------------------------------------------------------------- void __fastcall TForm1::Button2Click(TObject *Sender) {  SelButton = dynamic_cast<TButton *>(Sender);  ListBox1->Items->Clear();  WindowList->Clear();  GetProcess(WindowList);  for(int i = 0; i < WindowList->Count; i++)   ListBox1->Items->Add(WindowList->Names[i]); } //--------------------------------------------------------------------------- void __fastcall TForm1::ListBox1DblClick(TObject *Sender) {  if(CloseProcess((DWORD)WindowList->Values[ListBox1->Items->Strings[ListBox1->ItemIndex]].ToInt()))   Application->MessageBox("Proces został pomyślnie zamknięty!", "Procesy", MB_OK | MB_ICONINFORMATION);  else   Application->MessageBox((    "Operacja nie może być dokończona!\n\nBrak dostępu!\nKod błędu: " + (String)GetLastError()).c_str(),    "Procesy", MB_OK | MB_ICONSTOP);  dynamic_cast<TButton *>(SelButton)->Click(); } //---------------------------------------------------------------------------

...powrót do menu. 

Uruchamianie programu z poświadczeniami dla wybranego użytkownika (tylko WinXP).

W Windows XP po wywołaniu menu kontekstowego dla dowolnego programu (*.exe) znajduje się polecenie 'Uruchom jako...' pozwalające na uruchomienie tegoż programu z poświadczeniami dla dowolnego użytkownika, którego konto znajduje się w systemie, czyli jeżeli jesteśmy np. zalogowani na koncie użytkownika "Cyfrowy Baron" i powiedzmy że ten użytkownik nie posiada uprawnień administratora, to jak wiadomo nie może np. instalować programów. Możemy jednak za pomocą polecenia 'Uruchom jako...', uruchomić dany program z poświadczeniami administratora podając login i hasło. To polecenie pozwala uruchamiać programy nie tylko dla konta administratora, lecz dla wszystkich kont, koniecznym warunkiem jest znajomość hasła do danego konta.
Jeżeli nie zrozumiałeś(~łaś), to ta porada nie jest dla Ciebie i nie czytaj tego dalej, bo prawdopodobnie nie zrozumiesz.
Korzystając z funkcji CreateProcessWithLogonW możemy wymusić uruchomienie dowolnego programu z poświadczeniami dla wybranego użytkownika, wystarczy przekazać w tym celu funkcji trzy argumenty: nazwę użytkownika, hasło i ścieżkę dostępu do uruchamianego pliku.

// Plik źródłowy np. Unit1.cpp //-------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) {  STARTUPINFOW si = { 0 };  PROCESS_INFORMATION pi = { 0 };  String wUserName = "Uzytkownik";  String wPassword = "haslo";  String wExecute = "C:\\totalcmd\\Totalcmd.exe";  String wFile = "Totalcmd.exe";  si.cb = sizeof(si);  CreateProcessWithLogonW(WideString(wUserName).c_bstr(), NULL,                          WideString(wPassword).c_bstr(), LOGON_WITH_PROFILE,                          WideString(wExecute).c_bstr(), WideString(wFile).c_bstr(),                          CREATE_DEFAULT_ERROR_MODE, NULL, NULL, &si, &pi); } //---------------------------------------------------------------------------

Funkcja zadziała prawidłowo tylko na koncie dla którego utworzono hasło.
Jeżeli w Windows spróbujemy użyć polecenia 'Uruchom jako...' na koncie bez hasła to otrzymamy następujący komunikat:
"Błąd logowania: Ograniczenie konta użytkownika. Do możliwych przyczyn należą: niedozwolone puste hasła, ograniczenie godzin logowania lub wymuszanie ograniczenia zasad."

...powrót do menu. 

Odczytywanie klucza instalacyjnego Windows.

W życiu każdego informatyka może zdarzyć się sytuacja, gdy gubi klucz instalacyjny systemu. Stwarza to poważny problem, ponieważ nie można zainstalować systemu z oryginalnego "krążka", nie mając doń klucza. W przypadku systemu Windows 95/98 można było bez problemu odczytać ten klucz z rejestru, ale z systemem WindowsXP jest trudniej, ponieważ klucz nie występuje w rejestrze w postaci jawnej, lecz jest zakodowany w postaci binarnej, co uniemożliwia jego podejrzenie. Klucz znajduje się w kluczu rejestru 'HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion' 'DigitalProductId', a ta porada jest o tym, jak za pomocą prostej funkcji wyciągnąć ten klucz z rejestru i go wyświetlić np. w obiekcie Edit1. Nie będę objaśniał działania funkcji, Ci którym na tym zależy niech ją sobie przeanalizują, a pozostali mogą ją po prostu skopiować i użyć:
 

...powrót do menu. 

Wywoływanie okna właściwości pliku.

Z menu kontekstowego dla dowolnego pliku możemy wybrać polecenie 'Właściwości', które to polecenie wywołuje okno 'Właściwości' dla wybranego pliku. W BCB też możemy skorzystać ze struktury SHELLEXECUTEINFO umożliwiającej wywołanie właśnie okna właściwości pliku. W przykładzie stworzę funkcję o nazwie ShowProperties pobierającą jeden argument będący ścieżką dostępu do pliku dla którego chcemy wyświetlić okno 'Właściwości'. Całość jest banalnie prosta, więc nie będę tego wyjaśniał:
 

// Plik źródłowy np. Unit1.cpp //-------------------------------- void ShowProperties(String FileName) {  SHELLEXECUTEINFO ShExecInfo ={0};  ShExecInfo.cbSize = sizeof(ShExecInfo);  ShExecInfo.fMask = SEE_MASK_INVOKEIDLIST ;  ShExecInfo.hwnd = GetDesktopWindow();  ShExecInfo.lpVerb = "properties";  ShExecInfo.lpFile = FileName.c_str();  ShExecInfo.lpParameters = "";  ShExecInfo.lpDirectory = NULL;  ShExecInfo.nShow = SW_SHOW;  ShExecInfo.hInstApp = NULL;  ShellExecuteEx(&ShExecInfo); } //--------------------------------------------------------------------------- void __fastcall TForm1::Button7Click(TObject *Sender) {  ShowProperties("c:\\windows\\clock.avi"); } //---------------------------------------------------------------------------

...powrót do menu. 

Obliczanie częstotliwości procesora.

Myślę, że każdy użytkownik komputera wie z jaką częstotliwością pracuje jego procesor, więc ta porada jest raczej mało praktyczna, ponieważ pozwala tylko na sprawdzenie częstotliwości procesora. Nie bez powodu umieściłem w tytule porady określenie 'obliczanie', ponieważ sprawdzenie tej częstotliwości będzie się odbywało poprzez obliczenie różnicy czasu jaka upłynie pomiędzy wywołaniem funkcji QueryPerformanceFrequency i QueryPerformanceCounter, w związku z tym zwłoka w działaniu funkcji wyniesie do 1 sekundy. Przedstawiony kod wykorzystuje wstawki asemblerowe.
 

...powrót do menu. 

Odczytywanie identyfikatora procesora i zmiennych środowiskowych.

Niewiele osób zdaje sobie pewnie sprawę z istnienia bardzo przydatnej funkcji getenv przy pomocy której można odczytać identyfikator procesora i zmienne śropdowiskowe.

Przykład odczytania identyfikatora procesora:
 

Funkcja pobiera jeden argument i jest to typ odczytywanej wartości, zmiennej środowiskowej.
Jeżeli chcielibyśmy zmienić jakąś zmienną środowiskową, to należy posłużyć się funkcją putenv:

Jak widać funkcja putenv również pobiera jeden argument i jest to typ zmiennej środowiskowej którą chcemy zmienić plus znak równości plus nowa wartość wprowadzana. W przykładzie podałem jako typ zmiennej środowiskowej wartość PATH, która odpowiada ścieżce dostępu do katalogu Windows, następnie wprowadziłem nową wartość po znaku równości. Należy uważać przy korzystaniu z funkcji putenv, bo może się okazać, że po zmianie jakiejś zmiennej środowiskowej komputer się już nie uruchomi.

Niżej przedstawiam listę niektórych argumentów, które można przekazać funkcji getenv, nie wszystkie argumenty można zastosować w odniesieniu do funkcji putenv, niektóre zmienne środowiskowe odnoszą się tylko do konkretnego systemu operacyjnego..

• APPEND

• BLASTER

• COMSPEC

• COPYCMD

• DIRCMD

• DOSSHELL

• MSDOSDATA

• NO_SEP

• PATH

• PROMPT

• TEMP

• TZ

• CMDLINE

• COMPUTERNAME

• TMP

• winbootdir

• windir

• WINPMT

• ALLUSERSPROFILE

• APPDATA

• CD

• CMDCMDLINE

• CMDEXTVERSION

• COMMONPROGRAMFILES

• DATE

• ERRORLEVEL

• HOMEDRIVE

• HOMEPATH

• HOMESHARE

• LOGONSERVER

• MORE

• NUMBER_OF_PROCESSORS

• OS

• OS2LIBPATH

• PATHEXT

• PROCESSOR_ARCHITECTURE

• PROCESSOR_IDENTIFER

• PROCESSOR_LEVEL

• PROCESSOR_REVISION

• PROGRAMFILES

• RANDOM

• SESSIONNAME

• SYSTEMDRIVE

• SYSTEMROOT

• TIME

• USERDOMAIN

• USERNAME

• USERPROFILE

...powrót do menu.