Docstoc

Win32 Programming

Document Sample
Win32 Programming Powered By Docstoc
					Win32 Programming
Lesson 8: Processes
Where are we?
o   We’re starting to have some foundational 
    understanding of Windows
o   But really, we don’t know how to get any 
    work done (doesn’t that sound like your 
    Sophomore year?)
Executing Code
o   The Operating System organizes executing 
    code into a logical hierarchy
    n   Processes
    n   Threads
    n   Fibers
Definition
o   A Process is defined as
    n   “An instance of a running program, which 
        consists of two components:
        o   A kernel object used by the operating system to 
            manage the process
        o   An address space which contains all the DLLs, 
            executable code and data  used by the process”
    n   Processes are inert: to accomplish anything, a 
        process must have at least one thread that runs in 
        its context
Threads
o   Each thread executes “simultaneously” (in 
    some sense of the word… why, why not?)
o   Each thread has its own stack frame, and set 
    of CPU registers
Scheduling
o   The OS schedules some time for each thread
o   Each thread gets a time slice or quantum from the 
    CPU which provides the illusion of concurrency
o   We can think of it as a “round robin” scheduler… 
    but it is significantly much more complicated
o   When a process is created, it is generally created 
    with one thread, called the primary thread – this 
    thread can create other threads
Windows Applications
o   Two flavors
    n   GUI (all that Windowsy stuff)
    n   CUI (command line – the One True Way™)
o   Of course, life isn’t so simple – it’s not a binary 
    decision
o   Every program needs an entry point – WinMain, 
    wWinMain etc.
o   The Operating System doesn’t call this – it calls a 
    special startup function
Startup Code
o   The Runtime Libraries do a number of things
    n   Retrieve a pointer to the command line 
        parameters of the process
    n   Retrieve a pointer to the new environment 
        variables of the process
    n   Initialize the RTL’s global variables
    n   Initialize the heap for the RTL
    n   Call constructors for global and static objects
A Process’ Instance Handle
o   Every DLL or executable gets its own 
    Instance Handle, which is unique
o   Used when we load resources (like icons)
o   Can get the handle of a DLL with something 
    like:
    n   HMODULE GetModuleHandle(PCTSTR 
        pszModule);
The Command Line
o   Can use the global variables __argv
o   Can call down to PTSTR GetCommandLine()
o   Can go from here to an argv-like structure 
    using:
    n   PWSTR CommandLineToArgvW(    
            PWSTR pszCmdLine,     
            int* pNumArgs
        ); 
Free alloced memory
o   int nNumArgs; 
    PWSTR *ppArgv = CommandLineToArgvW(
      GetCommandLineW(), 
      &nNumArgs); 
    // Use the arguments… 
    if (*ppArgv[1] == L'x') {       } 

    // Free the memory block 
    HeapFree(GetProcessHeap(), 0, ppArg
    v); 
Environment Variables
o   Associated on a per-process basis
o   Stored in the environment block
o   Stored in the form:
    n   VarName1=Value1\0
        VarName2=Value2\0
        …
        VarNameX=ValueX\0
        \0
Associated Functions
o   GetEnvironmentVariable(
       PCTSTR pszName,
       PTSTR pszValue,
       DWORD dwSize);
o   Often in the form “%USERPROFILE%\My 
    Documents”
o   Windows supplies a helper function for this case
ExpandEnvironmentString
o   ExpandEnvironmentStrings(
       PCTSTR pszSrc,
       PTSTR pszDst,
       DWORD nSize);
o   Where nSize is the maximum space available 
    for expansion
ErrorModes
o   A process can choose to trap certain errors 
    itself instead of having the Operating System 
    trap those errors
o   UINT SetErrorMode(UINT fuErrorMode)
CurrentDirectory and Directory
o   Example: CreateFile
o   DWORD GetCurrentDirectory (
      DWORD cchCurDir,
      PTSTR pszCurDir);
o   BOOL SetCurrentDirectory(PCTSTR 
    pszCurDir);
o   Current Directories are also stored in the 
    environment variables
Finally…
o   GetVersion and GetVersionEx
o   Read the history, it’s somewhat amusing
Creating a Process
o   Simple: use CreateProcess:
    n   BOOL CreateProcess(
                PCTSTR pszApplicationName,
                PTSTR pszCommandLine,
                PSECURITY_ATTRIBUTES psaProcess,
                PSECURITY_ATTRIBUTES psaThread,
                BOOL bInheritHandles,
                DWORD fdwCreate,
                PVOID pvEnvironment,
                PCTSTR pszCurDir,
                PSTARTUPINFO psaStartInfo,
                PPROCESS_INFORMATION ppiProcInfo);
    n   I could write out the usage, but let’s just look it up…
Terminating a Process
o   Four ways
    n   The primary thread’s entry-point function returns 
        (YES)
    n   One thread in the process calls ExitProcess (NO)
    n   A thread in another process calls 
        TerminateProcess (NO)
    n   All the threads just happen to die on their own 
        (Never happens)
Entry point returns
o   When the primary thread dies
    n   Any C++ objects are destroyed using destructors
    n   Memory from the stack is correctly freed
    n   The process’ exit code is set
    n   The process’ kernel object is decremented
ExitProcess
o   Fine from an OS perspective
o   Horrible from the RTL perspective as 
    Destructors aren’t called – you can prove this 
    to yourself if you want to
ChildProcesses
PROCESS_INFORMATION pi; 
DWORD dwExitCode; // Spawn the child process. 
BOOL fSuccess = CreateProcess(..., &pi); if (fSuccess) {   
       // Close the thread handle as 
       // soon as it is no longer needed!    
       CloseHandle(pi.hThread);   
       // Suspend our execution until 
       // the child has terminated.    
       WaitForSingleObject(pi.hProcess, INFINITE);    
       // The child process terminated; 
       //get its exit code.    
       GetExitCodeProcess(pi.hProcess, &dwExitCode);   
        // Close the process handle as soon as it
       // is no longer needed.    
       CloseHandle(pi.hProcess); 
} 
Detaching a Process
o   In the previous example, the processes are 
    linked – the child process won’t be destroyed 
    until the Parent reads the exit code
o   However, you can detach a process by closing 
    the associated handles in the parent process
Enumerating Processes
o   Assignment time!
o   Easily create a simple application which enumerates 
    all the processes on a machine. You may use a 
    command-line application if you wish, or a GUI. 
    Print out as much information about each process as 
    you can.
o   This looks really nice in .NET… but that’s a little 
    more tricky. 
o   Your call – CLI is okay.
o   Use the Submit server!

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:0
posted:7/16/2013
language:English
pages:24