1. Procese Windows; comunicaţii prin pipe şi IPC 2

Procese Windows; comunicaţii prin pipe şi IPC - 1 - 

1. Procese Windows; comunicaţii prin pipe şi IPC ________________________________ 2 

1.1. Particularităţi privind dezvoltarea in cpp sub Windows __________________________ 2 

1.1.1. Constante şi tipuri de date ________________________________________________________ 2 

1.1.2. Aplicaţii consolă ________________________________________________________________ 3 

1.1.2.1. Exemplul 1: prima consolă ___________________________________________________ 3 

1.1.2.2. Exemplul 2: un filtru ________________________________________________________ 4 

1.1.3. Cum se compilează şi rulează programele cpp sub Windows? ____________________________ 4 

1.2. Access la fişiere şi aşteptarea unor evenimente Windows ________________________ 5 

1.2.1. Funcţii de access la fişiere ________________________________________________________ 5 

1.2.2. Funcţii de aşteptare a unor evenimente _____________________________________________ 6 

1.3. Lucrul cu procese sub Windows _____________________________________________ 7 

1.3.1. Crearea unui proces _____________________________________________________________ 7 

1.3.2. Terminarea unui proces Windows __________________________________________________ 8 

1.3.3. Exemple de utilizare de procese sub Windows ________________________________________ 9 

1.3.3.1. Exemplul 3: Rezumatul directorului curent ______________________________________ 9 

1.3.3.2. Exemplul 4: Cate perechi de numere nenule au suma numar par? __________________ 10 

1.3.3.3. Exemplul 5: Un program care compileaza si ruleaza alt program. ___________________ 11 

1.3.3.4. Exemplul 6: Prelucrarea simultana a mai multor fisiere text. _______________________ 12 

1.4. Pipe sub Windows _______________________________________________________ 13 

1.4.1. Pipe anonim Windows __________________________________________________________ 14 

1.4.2. Pipe cu nume sub windows ______________________________________________________ 14 

1.4.3. Exemplul 7: lista de fisiere cu nume de anumita forma; implementare pipe cu nume ________ 16 

1.5. Comunicarea între procese Windows prin memorie partajată ___________________ 20 

1.5.1. Fişiere I/O mapate în memorie şi segmente de memorie partajata _______________________ 20 

1.5.2. Semafoare Windows ____________________________________________________________ 22 

1.5.3. Exemplul 8: lista de fisiere cu nume de anumita forma; implementare memorie partajata 

+semafoare __________________________________________________________________________ 24 

1.6. Cozi de mesaje sub Windows ______________________________________________ 27 

1.6.1. Comunicarea între procese Windows prin Mailslot ___________________________________ 27 

1.6.2. Exemplul 9: lista de fisiere cu nume de anumita forma; implementare mailslot_____________ 29


1. Procese Windows; comunicaţii prin pipe şi IPC 

1.1. Particularităţi privind dezvoltarea in cpp sub Windows 

1.1.1. Constante şi tipuri de date 

Limbajul nativ de dezvoltare a aplicaţiilor Windows este C++. Din această cauză, în cele ce 

urmează vom descrie principiile programării folosind construcţii C şi C++. Headerul 

conţine principalele construcţii de limbaj folosite în interfaţa Windows. 

Constante. In se definesc o serie de constante. Numele acestora este 

compus din două părţi: o primă parte indică grupul din care face parte constanta, apoi 

caracterul “_” şi în final numele specific, de regulă suficient de lung încât să sugereze ce 

reprezintă. Iată câteva nume de grupe: 

CS stilul clasei de ferestre; 

CW crearea ferestrei; 

IDC identificator de cursor; 

IDI identificator de icon; 

DT atribut de afişare texte; 

WS stilul ferestrei; 

WM mesaj asociat unei ferestre 

De exemplu, pentru fixarea stilului unei clase se pot lega prin operatorul C „|‟ (sau) 

constantele de mai jos (care nu sunt singurele, mai pot fi şi altele): 

CS_DBLCLIKS - mesajele se transmit ferestrei prin dublu click; 

CS_HREDRAW sau CS_VREDRAW - provoacă redesenarea ferestrei după o 

redimensionare orizontală / verticală. 

Tipuri de date. Windows foloseşte o serie de tipuri de date noi, prin care s-a urmărit 

creşterea portabilităţii aplicaţiilor în cazul unor noi arhitecturi de calculatoare. Astfel, avem 

tipurile BOOL, BYTE, DWORD (32 biţi), FARPROC (pointer spre funcţie), LPSTR (pointer 

către string), LPMSG (pointer către o structură MSG) etc. 

Pentru desemnarea obiectelor sunt definite nişte tipuri de date speciale: descriptor sau 

handle. Acestea sunt întregi pe 16 biţi prin intermediul cărora se pot referi obiecte. Tipurile 

de handle folosite sunt: 

HANDLE indicator general; 

HBRUSH indicator spre obiect “pensulă”; 

HCURSOR indicator spre resursă cursor; 

HICON indicator spre icon; 

HMENU indicator spre o resursă meniu; 

HWND indicator spre o fereastră. 

Nume de variabile. Atribuirea de nume pentru variabile se face respectându-se anumite 

convenţii, provenite din experienţa programatorilor. Este vorba de notaţia ungară de 

denumire a variabilelor. Ele nu sunt restricţii impuse de sistem, dar este de preferat să fie 

respectate. De regulă numele atribuite sunt lungi, încep cu literă mică, iar în cadrul numelor


apar litere mari la începuturile cuvintelor care le compun. De multe ori, când este vorba de o 

singură variabilă de un anumit tip, numele ei este numele tipului, scris cu literă mică. 

Tot ca şi convenţii, începuturile (prefixele) numelor de variabile au semnificaţie: b pentru 

BOOL, by pentru BYTE, c pentru char, dw pentru DWORD, fn pentru funcţie h pentru 

handle, i pentru int, lp pentru pointer lung, w pentru WORD etc. 

1.1.2. Aplicaţii consolă 

In ceea ce priveşte programarea Windows, prezenta lucrare nu are, nici pe departe, intenţia de 

a o descrie exhaustiv. Vom aborda doar ceea ce este strict necesar pentru a crearea de procese 

şi comunicarea între ele. 

1.1.2.1. Exemplul 1: prima consolă 

Cele mai simple aplicaţii care se pot scrie sub Windows sunt aplicaţiile consolă. Acestea sunt, 

în fapt, aplicaţii cu intrare şi ieşire standard în mod text, la fel ca şi la programele simple sub 

Unix. Spre exemplu, un program extrem de simplu este programul PrimaConsola.cpp 

de mai jos: 

int main(int c, char* a[]) { 

int i; 

char n[120]; 

printf("Numele? "); 

gets(n); 

printf("Salut %s\nUrmeaza parametrii liniei de comanda\n", n); 

for (i=0; a[i]; i++) 

printf("%s\n",a[i]); 

return 0; 

} 

Presupunem că în urma compilării şi link-editării acestui program s-a obţinut fişierul 

executabil PrimaConsola.exe. O execuţie a lui se face într-o fereastră MSDos Prompt 

(fereastră Cmd) de sub Windows. Dacă se lansează programul prin comanda: 

...> PrimaConsola 11111 doi trei333 4 

şi se dă la cerere numele, atunci efectul ei este ilustrat în figura de mai jos.

1.1.2.2. Exemplul 2: un filtru 


Un al doilea exemplu de aplicaţie consolă simplă este un program filtru. Acesta citeşte linie 

cu linie de la intrarea standard şi dă la ieşire aceleaşi linii, scurtate la primele 10 caractere. 

Sursa Filtru.cpp este este prezentată în continuare. 

#include 

#include 

int main(int c, char* a[]) { 

char l[128]; 

for (;;) { 

if (gets(l)==NULL) 

break; 

if (strlen(l) > 10) 

l[10]= 0; 

printf("%s\r\n", l); 

} 

return 0; 

} 

Lansarea unui astfel de filtru se face, de asemenea, dintr-o fereastră Cmd, putându-se, la fel ca 

în Unix sau Dos, să se redirecteze intrarea şi ieşirea lui standard, astfel: 

Filtru.exe FisierIesire 

1.1.3. Cum se compilează şi rulează programele cpp sub Windows? 

Cum se ajunge de la aceste surse cpp la fişierele executabile corespunzătoare? Aceasta 

depinde de mediul cpp cu care se dezvoltă aplicaţiile. Recomandările noastre sunt două: 

� Distribuţia MinGW 

� Distribuţia Visual Studio (Dev Studio 

Vom expune, strict telegrafic, paşii realizării lor folosind mediul DevStudio pentru 

Microsoft Visual C++ 6.0. 

1. In meniul File se selectează New, în fereastra de dialog obţinută se selectează Project. 

2. In cadrul acesteia se selectează Win32 Console Application


3. In spaţiul Project Name se scrie numele proiectului, în cazul nostru prim sau filtru. 

4. In spaţiul Location se trece locul în structura de directori, în care mediul îşi va dezvolta 

aplicaţia, de exemplu \Useri\florin. Aici, mediul creează un subdirector cu numele 

proiectului (în cazul nostru prim sau filtru). 

5. Se alege tipul de aplicaţie consolă dorit: An empty project, A simple application, A “Hello 

world!” application, An application that supports MFC. Considerăm că în acest exemplu 

am ales: A simple application. 

6. După Ok, se afişează un mesaj de informare, iar în subdirectorul din location sunt create 

subdirectoarele: SourceFiles, HeaderFiles şi ResourceFiles. De asemenea, 

este depus acolo un fişier ReadMe.txt în care se explică rolul fiecărui fişier sau 

director creat de mediu. 

7. Se selectează din mediu FileView, se expandează directorul cu numele proiectului, apoi 

subdirectorul SourceFiles în care se află un fişier cu numele proiectului şi tipul cpp. 

Acest fişier sursă conţine, gata generat, scheletul programului principal (al funcţiei 

main). După un dublu click pe numele acestuia, el apare în fereastra de editare. 

8. Din acest moment programatorul poate să scrie efectiv conţinutul aplicaţiei sale, plecând 

de la scheletul furnizat de mediu. 

9. La terminare, meniul Build oferă, printre altele, posibilitatea de a compila sursa respectivă 

(Compile sau Ctrl+F7), respectiv să obţină un fişier exe (Build sau F7). 

10. Fişierul de tip exe obţinut este plasat în subdirectorul Debug al directorului cu numele 

proiectului. El poate fi lansat în execuţie din mediu sau dinafara lui, poate fi copiat în altă 

parte (cum l-am depus noi pe prim.exe în e:\florin) şi lansa de acolo, etc. 

1.2. Access la fişiere şi aşteptarea unor evenimente Windows 

1.2.1. Funcţii de access la fişiere 

Descriem pe scurt prototipurile funcţiilor de lucru cu fişiere sub Windows. Pentru mai multe 

informatii legate de prototipurile acestor funcţii, se recomandă consultarea documentaţiei 

MSDN. 

HANDLE CreateFile (LPCTSTR numeFisier, DWORD acces, 

DWORD partajare, LPSECURITY_ATTRIBUTES descr_sec, 

DWORD mod_deschid, DWORD atributeFisier); 

numeFisier –numele fişierului care se va crea 

acces –modul de acces (în citire şi/sau scriere) 

partajare –modul de partajare a fişierului 

mod_deschid –modul de creare a fişierului 

atributeFisier –atribute fişier 

HFILE OpenFile ( LPCSTR numeFisier, LPOFSTRUCT lpBuf, UINT uActiune); 

numeFisier –numele fişierului care se va deschide 

lpBuf –pointer la o structură care reţine informaţii despre fişier 

uActiune –indică operaţia care se va efectua asupra fişierului 

BOOL WriteFile (HANDLE hFisier, LPCVOID lpBuf, DWORD nNrOctetiDeScris, 

LPDWORD lpNumarOctetiScrisi, LPOVERLAPPED lpStructIO);


hFisier –handle-ul fisierului în care se va scrie 

lpBuf –pointer la datele care se vor scrie în fişier 

nNrOctetiDeScris –număr de octeţi de scris 

lpNumarOctetiScrisi –pointer la numărul de octeţi scrişi efectiv 

lpStructIO –de obicei are valoarea NULL 

BOOL ReadFile ( HANDLE hFisier, LPCVOID lpBuf, DWORD nNrOctetiDeCitit, 

LPDWORD lpNumarOctetiCititi, LPOVERLAPPED lpStructIO); 

hFisier –handle-ul fisierului din care se va citi 

lpBuf –pointer la un bufer în care se vor citi datele 

nNrOctetiDeCitit –număr de octeţi de citit 

lpNumarOctetiCititi –pointer la numărul de octeţi citiţi efectiv 

lpStructIO –de obicei are valoarea NULL 

BOOL CloseHandle ( HANDLE hObject ); 

hObject –handle-ul la un obiect deschis 

1.2.2. Funcţii de aşteptare a unor evenimente 

Win32 API oferă un set de funcţii de aşteptare pentru a permite unui program să îşi suspende 

temporar execuţia în aşteptarea unui eveniment. Funcţiile de aşteptare blochează execuţia 

programului până când criteriul specificat a fost îndeplinit. Tipul funcţiei de aşteptare 

determină criteriul utilizat. În timpul aşteptării procesul consumă foarte puţine resurse sistem, 

fiind vorba de o aşteptare pasivă – intrare în sleep. Există trei tipuri de funcţii de aşteptare: 

1. single-object: WaitForSingleObject, SignalObjectAndWait, 

WaitForSingleObjectEx 

2. multiple-object: WaitForMultipleObjects, WaitForMultipleObjectsEx, 

MsgWaitForMultipleObjects, MsgWaitForMultipleObjectsEx. 

3. alertable: MsgWaitForMultipleObjectsEx, SignalObjectAndWait, 

WaitForMultipleObjectsEx, WaitForSingleObjectEx 

Tabelul următor prezintă pe scurt rolurile principalelor funcţii de aşteptare. 

Funcţie wait Descriere 

WaitForSingleObject() Aşteaptă după un anumit obiect ca acesta să 

ajungă în starea setat (de exemplu 

terminarea unui proces sau valoarea pozitiva 

a unui semafor). 

WaitForSingleObjectEx() Ca şi precedentul, plus aşteptarea a altor 

două evenimente: terminarea unei operaţii 

de intrare ieşire, sau sosirea unui apel 

asincron în threadul curent. 

WaitForMultipleObjects() Aşteaptă după o mulţime de obiecte. Ieşirea 

din aşteptare se poate face fie când unul 

dintre obiecte este setat, fie când toate 

obiectele ajung în starea setat. 

WaitForMultipleObjectsEx() Ca şi precedentul, plus aşteptarea celor două 

evenimente specificate în cazul funcţiei 

WaitForSingleObjectEx.


Cea mai simplă dintre aceste funcţii şi cea mai des utilizată este WaitForSingleObject, 

al cărei prototip îl vom prezenta şi pe care o vom utiliza şi noi în secţiunile următoare. Pentru 

detalii privind celelalte funcţii recomandaconsultarea MSDN. 

DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMillisec); 

hHandle -handler-ul obiectului la care se aşteaptă 

dwMillisec -intervalul de timp maxim de aşteptare. Valoarea INFINITE indică aşteptare 

până la semnalarea obiectului. 

Funcţia poate să întoarcă următoarele valori: 

� WAIT_ABANDONED -dacă obiectul nu a fost eliberat de threadul său proprietar înainte 

ca apelul să se termine 

� WAIT_OBJECT_O -dacă obiectul a fost semnalat 

� WAIT_TIMEOUT -dacă intervalul de timp a expirat 

1.3. Lucrul cu procese sub Windows 

1.3.1. Crearea unui proces 

Crearea unui proces în Windows se face prin apelul funcţiei CreateProcess dintr-un alt 

proces. Funcţia are următorul prototip: 

BOOL CreateProcess (LPCTSTR lpszImageName, 

LPCTSTR lpszCommandLine, 

LPSECURITY_ATTRIBUTES lpsaProcess, 

LPSECURITY_ATTRIBUTES lpsaThread, 

BOOL fInheritHandles, 

DWORD fdwCreate, 

LPVOID lpvEnvironment, 

LPTSTR lpszCurDir, 

LPSTARTUPINFO lpsiStartInfo, 

LPPROCESS_INFORMATION lppiProcInfo); 

Atunci când se apelează funcţia CreateProcess, sistemul creează un spaţiu de adresare şi 

încarcă noul proces în acest spaţiu. După această operaţie, sistemul creează threadul primar 

pentru noul proces şi-l lansează în execuţie. Să vedem semnificaţia parametrilor funcţiei 

CreateProcess: 

lpszImageName - parametrul identifică numele fişierului executabil în care este memorat 

codul pentru procesul ce se va crea. CreateProcess va căuta fişierul mai întâi în directorul 

curent, şi apoi în directoarele descrise de variabila de mediu PATH. Dacă acest parametru 

este NULL, funcţia va lua numele fişierului din primul cuvânt al liniei de comandă 

specificată de parametrul lpszCommandLine. 

lpszCommandLine - parametrul specifică argumentele care trebuie transmise către noul 

proces. La pornirea procesului, aceste argumente vor fi regăsite în argumentul 

lpszCmdLine al funcţiei WinMain. lpszCommandLine punctează către un sir de 

caractere ANSI.


lpsaProcess şi lpsaThread identifică atributele de securitate care trebuie date noului 

proces şi threadului său primar. Dacă valorile lor sunt NULL, sistemul va furniza valori 

implicite pentru aceşti parametri. 

fInheritHandles - specifică modul în care se moştenesc referinţele la obiecte de către 

procesul fiu. In mod normal, în Windows acestea nu sunt aceleaşi pentru fiecare proces. 

Chiar dacă este vorba de acelaşi obiect sistem, procese diferite pot lucra cu valori diferite. 

Dacă dorim ca aceste valori să fie identice în procesul tată şi procesul fiu, atunci putem 

specifica valoarea TRUE acestui parametru. 

fdwCreate - conţine comutatorii (flags) ce afectează modul în care este creat noul proces. 

Se pot specifica mai mulţi comutatori combinându-i prin operatorul “|”. 

lpvEnvironment - referă un bloc de memorie în care sunt memorate şirurile, care descriu 

variabilele de mediu ce trebuiesc utilizate de noul proces. De obicei, valoarea acestui 

parametru trebuie să fie NULL, caz în care procesul fiu primeşte aceleaşi variabile de mediu 

ca şi părintele. 

lpszCurDir - parametrul permite specificarea unui nou disc şi a unui nou director curent 

pentru procesul nou creat. Dacă valoarea transmisă pentru acest parametru este NULL, 

directorul şi discul de lucru ale noului proces sunt aceleaşi ca şi cele ale procesului părinte. 

lpsiStartInfo – punctează către o structură STARTUPINFO. Aceste informaţii sunt 

necesare pentru subsistemul Win32 la crearea unui nou proces. Această structură este prea 

complexă pentru a o descrie aici. Să reţinem doar că în ea se pot specifica caracteristicile unei 

ferestre consolă: culoare, număr de linii, coloane, poziţie pe ecran, titlu, etc.; informaţii 

despre modul în care va fi afişată fereastra aplicaţiei: maximizată, icon, etc.; informaţii despre 

comportarea sistemului în timpul încărcării aplicaţiei: forma cursorului, etc. 

lppiProcInfo - conţine adresa unei structuri care va fi completată cu informaţii de către 

funcţia CreateProces înainte ca aceasta să-şi termine execuţia. Această structură va conţine 

referinţele pentru noul proces, pentru threadul său primar, precum şi identificatorii acestora. 

Structura este declarată astfel: 

typedef struct _PROCESS_INFORMATION { 

HANDLE hProcess; 

HANDLE hThread; 

DWORD dwProcessId; 

DWORD dwThreadId; 

} PROCESS_INFORMATION; 

1.3.2. Terminarea unui proces Windows 

Un proces poate fi terminat pe două căi: apelând din interior funcţia ExitProcess sau 

apelând din exterior funcţia TerminateProcess. Este preferabilă prima cale, cea de-a doua 

trebuie folosită doar pentru situaţii extreme. 

Prototipul funcţiei ExitProcess este: 

VOID ExitProcess (UINT fuExitCode); 

Funcţia termină procesul care a apelat-o şi setează codul de retur pe valoarea fuExitCode.


Funcţia TerminateProcess are următorul prototip: 

BOOL TerminateProcess (HANDLE hProcess, UINT fuExitCode); 

Cu această funcţie, un process poate termina orice alt proces din sistem, inclusiv pe el însuşi. 

Procesul terminat este dat de referinţa hProcess. Codul de retur a procesului terminat va fi 

setată pe valoarea parametrului fuExitCode. Folosirea funcţiei TerminateProcess poate 

fi periculoasă la o programare neîngrijită. In mod normal, evenimentul de terminare a unui 

proces este semnalat de către Windows tuturor DLL-urilor ataşate de proces. La terminarea 

procesului, folosind funcţia TerminateProcess, aceste DLL-uri nu vor fi avertizate, 

producându-se eventuale pierderi de date. Windows garantează totuşi că toate resursele 

sistem utilizate de proces vor fi eliberate indiferent cum este terminat procesul. 

1.3.3. Exemple de utilizare de procese sub Windows 

1.3.3.1. Exemplul 3: Rezumatul directorului curent 

Pentru utilizare sub Windows, vom folosi ca intermediar un fisier de comenzi ls.bat, care 

contine o singura linie: 

dir %1 

Sursa execWin.cpp a programului este: 

#include 

#include 

int main() { 

STARTUPINFO si = { sizeof(si) }; 

PROCESS_INFORMATION pi; 

// ls.bat contine linia: dir %1 

printf("Procesul parinte %d va creea un fiu\n", GetCurrentProcessId()); 

// Rulati alternativ cu una dintre urmatoarele doua linii comentata: 

BOOL b = CreateProcess("ls.bat", NULL, NULL, NULL, 

// BOOL b = CreateProcess("ls.bat", "ls.bat *.cpp", NULL, NULL, 

FALSE, 0, NULL, NULL, &si, &pi); 

WaitForSingleObject(pi.hProcess, INFINITE); 

printf("Terminat procesul fiu %d creeat de parintele %d\n", 

pi.dwProcessId, GetCurrentProcessId()); 

return 0; 

} 

Efectul compilarii si a executiei este: 

D:\Florin\Didactic\20102011\SO\probleme\WProc-H>gcc execWin.cpp 

D:\Florin\Didactic\20102011\SO\probleme\WProc-H>a 

Procesul parinte 2320 va creea un fiu 

D:\Florin\Didactic\20102011\SO\probleme\WProc-H>dir 

Volume in drive D is fmbData 

Volume Serial Number is F6C0-1474 

Directory of D:\Florin\Didactic\20102011\SO\probleme\WProc-H


04/10/2011 12:47 PM . 

04/10/2011 12:47 PM .. 

04/10/2011 12:47 PM 18,597 a.exe 

04/10/2011 12:13 PM 679 capitalizare.cpp 

04/10/2011 12:08 PM 18,945 ceva.exe 

04/10/2011 12:08 PM 435 compilerun.cpp 

04/10/2011 11:40 AM 671 execWin.cpp 

04/10/2011 11:19 AM 23 ls.bat 

04/10/2011 12:18 PM 656 master.cpp 

03/23/2011 07:32 PM 17,874 OS_UIPC-H.txt 

03/23/2011 01:06 PM 13,081 OS_UPipe-H.txt 

03/19/2011 03:51 PM 14,999 OS_UProc-H.txt 

04/10/2011 11:58 AM 982 paritate.cpp 

04/10/2011 11:58 AM 18,945 paritate.exe 

04/10/2011 11:45 AM 320 paritateFiu.cpp 

04/10/2011 11:45 AM 17,413 paritateFiu.exe 

03/23/2011 12:45 PM 19,781 SO_UIPC-H.txt 

03/23/2011 01:11 PM 13,805 SO_UPipe-H.txt 

03/19/2011 03:40 PM 14,738 SO_UProc-H.txt 

03/19/2011 03:40 PM 14,738 SO_WProc-H.txt 

18 File(s) 186,682 bytes 

2 Dir(s) 239,633,485,824 bytes free 

Terminat procesul fiu 4972 creeat de parintele 2320 

Daca se comenteaza invers linia care il defineste pe b, efectul este: 

D:\Florin\Didactic\20102011\SO\probleme\WProc-H>a 

Procesul parinte 6068 va creea un fiu 

D:\Florin\Didactic\20102011\SO\probleme\WProc-H>dir *.cpp 

Volume in drive D is fmbData 

Volume Serial Number is F6C0-1474 

Directory of D:\Florin\Didactic\20102011\SO\probleme\WProc-H 

04/10/2011 12:13 PM 679 capitalizare.cpp 

04/10/2011 12:08 PM 435 compilerun.cpp 

04/10/2011 12:51 PM 671 execWin.cpp 

04/10/2011 12:18 PM 656 master.cpp 

04/10/2011 11:58 AM 982 paritate.cpp 

04/10/2011 11:45 AM 320 paritateFiu.cpp 

6 File(s) 3,743 bytes 

0 Dir(s) 239,633,485,824 bytes free 

Terminat procesul fiu 4824 creeat de parintele 6068 

1.3.3.2. Exemplul 4: Cate perechi de numere nenule au suma numar par? 

Problema este trivial de simpla, insa potrivita pentru a exemplifica utilizarea 

CreateProcess, WaitForSingleObject si ExitProcess. 

Enuntul problemei: Se dau la linia de comanda n perechi de numere intregi. Programul va 

crea n procese fii, fiecare primind doua argumente consecutive din linia de comanda. 

Oricare dintre fii intoarce codul de retur: 

� 0 daca perechea are suma para, 

� 1 daca suma este impara, 

� 2 daca unul dintre argumente este nul sau nenumeric. 

Parintele asteapta terminarea fiilor si va afisa rezultatul. In continuare vom implementa un 

program separat pentru procesul fiu. Sursa lui, paritateFiu.cpp este:


#include 

#include 

main(int argc, char* argv[]) { 

int n1, n2; 

n1 = atoi(argv[1]); // atoi intoarce 0 

n2 = atoi(argv[2]); // si la nenumeric 

if (n1 == 0 || n2 == 0) ExitProcess(2); 

if ((n1 + n2) % 2 == 0) ExitProcess(0); 

else ExitProcess(1); 

} 

Acesta va fi compilat cu: 

gcc -o paritateFiu paritateFiu.cpp 

Sursa paritate.cpp este: 

#include 

#include 



PROCESS_INFORMATION pi[100]; 

char linieCom[1000]; 

int pare = 0, impare = 0, nenum = 0, i; 

DWORD n1; 

for (i = 1; i < argc-1; i += 2) { 

strcpy(linieCom, "paritateFiu.exe "); 

strcat(linieCom, argv[i]); 

strcat(linieCom, " "); 

strcat(linieCom, argv[i+1]); 

BOOL b = CreateProcess("paritateFiu.exe", linieCom, NULL, NULL, 

FALSE, 0, NULL, NULL, &si, &pi[i]); 

} 

// Parintele asteapta terminarile fiilor 

for (i = 1; i < argc-1; i += 2) { 

WaitForSingleObject(pi[i].hProcess, INFINITE); 

GetExitCodeThread(pi[i].hThread, &n1); 

switch (n1) { 

case 0: pare++;break; 

case 1: impare++;break; 

default: nenum++; 

} 

} 

printf("Pare %d, impare %d, nenumerice %d\n",pare, impare, nenum); 

} 

1.3.3.3. Exemplul 5: Un program care compileaza si ruleaza alt program. 

Sursa compilerun.cpp a acestuia este: 

#include 

#include 



PROCESS_INFORMATION pi; 

char com[200]; 

strcpy(com, "gcc -o ceva "); // fabricat comanda 

strcat(com, argv[1]); 

if (system(com) == 0)

} 


BOOL b = CreateProcess("ceva", NULL, NULL, NULL, 

FALSE, 0, NULL, NULL, &si, &pi); 

else printf("Erori de compilare\n"); 

Compilarea lui se face 

gcc -o comprun compilerun.cpp 

Executia se face, de exemplu, prin 

comprun sursa.cpp 

Ca efect, daca compilarea sursei argument (sursa.cpp) este corecta, atunci compilatorul 

gcc creeaza fisierul ceva si intoarce cod de retur o, dupa ceva este lansat prin 

CreateProcess. Daca esueaza compilarea, se va tipari doar mesajul. 

1.3.3.4. Exemplul 6: Prelucrarea simultana a mai multor fisiere text. 

Dorim sa transformam un fisier text intr-un alt fisier text, cu acelasi continut, dar in care toate 

cuvintele din el sa inceapa cu litera mare. Un astfel de program va fi apelat: 

capitalizare fisierintrare fisieriesire 

Ne propunem sa prelucram simultan mai multe astfel de fisiere. De aceea vom creea un 

proces master, care primeste la linia de comanda numele fisierelor al caror continut va fi 

capitalizat: 

master fisier1 fisier2 - - - fisiern 

Rezultatul va consta din fisierele: 

fisier1.CAPIT, fisier2.CAPIT, - - - fisiern.CAPIT 

Procesul master va crea n procese fii, iar fiecare fiu i va lansa prin CreateProcess 

programul: 

capitalizare fisi fisi.CAPIT 

Sursa capitalizare.cpp este: 

#include 

#include 

#include 

#define MAXLINIE 100 


FILE *fi, *fo; 

char linie[MAXLINIE], *p; 

fi = fopen(argv[1], "r"); 

fo = fopen(argv[2], "w"); 

if (fi == NULL && fo == NULL) ExitProcess(1); 

for ( ; ; ) { 

p = fgets(linie, MAXLINIE, fi); 

linie[MAXLINIE-1] = '\0'; 

if (p == NULL) break; 

for (p = linie; ; ) {

} 


p = strstr(p, " "); 

if (p == NULL) break; 

p++; 

if (*p == '\n') break; 

*p = toupper(*p); 

} 

fprintf(fo, "%s", linie); 

} 

fclose(fo); 

fclose(fi); 

Programul primeste la linia de comanda numele celor doua fisiere. Se deschid aceste fisiere si 

se citeste fisierul de intrare linie cu linie. Cu ajutorul pointerului p, se parcurge linia curenta 

si se cauta pe rand cate un spatiu, dar care sa nu fie ultimul caracter din linie. Urmatorul 

caracter este apoi transformat in litera mare (toupper face aceasta transformare numai daca 

caracterul este efectiv o litera mica). 

Sursa master.cpp este: 

#include 

#include 



PROCESS_INFORMATION pi[100]; 

int i; 

char nume[200]; 

for (i=1; argv[i]; i++) { 

strcpy(nume, "capitalizare "); 

strcat(nume, argv[i]); 

strcat(nume, " "); 

strcat(nume, argv[i]); 

strcat(nume, ".CAPIT"); // fabricat numele iesirii 

// incarcat programul de capitalizare 

BOOL b = CreateProcess("capitalizare.exe", nume, NULL, NULL, 

FALSE, 0, NULL, NULL, &si, &pi[i]); 

} 

printf("Lansat simultan %d procese de capitalizare\n",i-1); 

} 

Se parcurg argumentele liniei de comanda si pentru fiecare dintre ele se creeaza un proces fiu. 

In tabloul nume se construieste numele fisierului de iesire. Apoi se incarca programul 

capitalizare cu cele doua nume de fisiere date "la linia de comanda". 

Cele doua programe se compileaza: 

gcc -o capitalizare capitalizare.c 

gcc -o master master.c 

Lansarea se face: 

master fis1 fis2 - - - fisn 

1.4. Pipe sub Windows 

În Windows există două posibilităţi de a folosi pipe în IPC. O primă variantă este pipe 

anonime, care se pot folosi numai pentru comunicarea între procese de pe aceeaşi maşină. A


doua variantă este pipe cu nume, folosite pentru comunicarea între procese ce operează nu 

neapărat pe aceeaşi maşină Windows. 

1.4.1. Pipe anonim Windows 

Ne vom ocupa mai întâi de pipe anonime, ca şi mecanism IPC în programarea concurentă sub 

Windows. Un pipe anonim poate fi folosit, ca şi pipe-ul de sub Unix, pentru comunicarea 

între procese descendente din creatorul pipe-ului. In urma creării, procesul creator obţine doi 

descriptori - handle - unul de citire şi altul de scriere. Procesul creator poate trimite fiilor 

(nepoţilor etc.) handle-urile pipe-ului, în momentul creării proceselor fii prin apeluri ale 

funcţiei CreateProces. Pentru ca fiul să moştenească handle-ul la pipe, părintele trebuie 

să seteze parametrul fInheritedHandle din apelul CreateProces, la valoarea TRUE. 

Un pipe fără nume se creează folosind apelul CreatePipe. Pipe-ul se închide cu ajutorul 

funcţiei CloseHandle. Funcţia CreatePipe creează un pipe fară nume şi are următorul 

prototip: 

BOOL CreatePipe (PHANDLE phRead,PHANDLE phWrite, 

LPSECURITY_ATTRIBUTES lpsa, DWORD cbPipe); 

Funcţia întoarce TRUE în caz de succes sau FALSE la eşec. 

phRead şi phWrite sunt pointerii spre cele două handle-uri (de citire şi de scriere) obţinute 

în urma creării. 

parametrul lpsa are o dublă semnficaţie: determină dacă handle-ul la pipe, returnat de 

funcţie poate fi moştenit în procesele fii, proprietate care are loc pentru o valoare diferită de 

NULL. Acelaşi parametru reprezintă un descriptor de securitate. Dacă se specifică pentru 

acest parametru valoarea NULL, sistemul va fixa atributele de securitate implicite 

cbPipe specifică dimensiunea buferului rezervat pentru operaţiile de I/O prin pipe. Dacă 

această valoare este 0, atunci dimensiunea implicită a buferului o stabileşte sistemul de 

operare. 

Scrierea şi citirea din pipeurile anonime se face folosind funcţiile ReadFile şi 

WriteFile, similare cu read şi write de sub Unix. Operaţiile sunt atomice. O citire va opri 

procesul până când va reuşi să se execute. In mod similar, o scriere va bloca procesul până 

când va avea suficient spaţiu în pipe pentru efectua operaţia de scriere dorită. 

Atât procesul creator, cât şi procesele fii care moştenesc cele două handle-uri ale pipe-ului, le 

pot folosi între momentul primirii lor şi momentul închiderii. Astfel, procesul creator poate 

începe imediat să folosească pipe prin apelurile ReadFile şi WriteFile. După creare şi 

primirea handle-urilor, procesele fii pot să folosească la rândul lor funcţiile ReadFile şi 

WrieFile pentru a citi sau scrie din pipe. 

1.4.2. Pipe cu nume sub windows 

Pipe cu nume este un mecanism de comunicare între două sisteme diferite, ambele fiind 

operaţionale pe platforme Windows


In figura următoare sunt prezentate succesiunile apelurilor sistem, atât pentru server, cât şi 

pentru client. Cititorul poate uşor observa particularizările necesare pentru comunicarea prin 

pipe anonim. 

1. C re at eN am ed Pi pe 

2. Co nn ec tN am ed Pi pe 

3. R ea dF il e 

4. W ri te Fi le 

5. D is co nn ec tN am ed Pi pe 

6. C lo se Ha nd le 

1. C re at eF il e 

2. R ea dF il e 

3. W ri te Fi le 

4. C lo se Ha nd le 

Server Client 

P ipe cu num e 

Crearea unui pipe cu nume se face prin apelul sistem CreateNamedPipe, cu prototipul: 

HANDLE CreateNamedPipe(LPSTR numePipe, 

DWORD optiuniModOpen, 

DWORD optiuniModPipe, 

DWORD nMaxInstances, 

DWORD lungBufOut, 

DWORD lungBufIn, 

DWORD timeOut, 

LPSECURITY_ATTRIBUTES lpsa) 

numePipe este un string prin care se indică numele pipe-ului. Convenţiile Microsoft de 

specificare a acestor nume impun două sintaxe, una pentru pipe local şi alta pentru pipe de pe 

o altă maşină. Aceste specificări sunt: 

\\.\PIPE\numePipePeMAsina 

\\adresaMasina\PIPE\numePipePeMasina 

adresa maşinii este fie o specificare Internet, fie o adresă IP. Atenţie! In constantele string de 

specificare a acestor nume, fiecare caracter \ trebuie dublat, aşa cum cer regulile de evitare 

specifice limbajului C. 

optiuniModOpen specifică direcţia de deschidere a pipe-ului. Valoarea lui poate fi una 

dintre constantele: PIPE_ACCESS_DUPLEX, PIPE_ACCESS_INBOUND, 

PIPE_ACCESS_OUTBOUND, indicând fie ambele sensuri, fie numai de la client la server, 

fie numai de la server spre client. 

optiuniModPipe precizează caracteristicile acestui pipe. Pentru specificare, se folosesc 

constante sau combinaţii legate între ele prin operatorul '|': 

� PIPE_TYPEBYTE, PIPE_TYPE_MESSAGE pentru scrierea ca flux de octeţi, respectiv 

ca şi mesaj; 

� PIPE_READMODE_BYTE, PIPE_READMODE_MESSAGE pentru citirea după 

regulile fluxului de octeţi sau citirea ca şi mesaj; 

� PIPE_WAIT, PIPE_NOWAIT pentru comunicarea sincronă, respectiv asincronă. 

nMaxInstances specifică numărul de clienţi care se vor conecta la acest pipe. La nevoie, 

se poate folosi constanta PIPE_UNLIMITED_INSTANCES.


lungBufOut şi lungBufIn specifică dimensiunile bufferelor, pentru ieşire şi intrare. 

Sistemul ia aceste numere doar ca sugestii, în funcţie de context el putând să redimensioneze 

aceste buffere. 

timeOut indică, în milisecunde, durata maximă de aşteptare. 

lpsa specifică atributele de securitate. De cele mai multe ori se specifică NULL, lăsând 

astfel pe seama sistemului fixarea acestora. 

Apelul sistem întoarce un handle, care va fi folosit ca şi argument în celelalte apeluri sistem 

legate de pipe. 

După crearea unui pipe cu nume, serverul apelează: 

ConnectNamedPipe(HANDLE hNamedPipe, LPOVERLAPPED lpo) 

Primul handle este cel întors de crearea pipe. Al doilea parametru, de regulă NULL, indică 

faptul că se aşteaptă la conectare până când un client se conectează efectiv la pipe. (A se 

compara această regulă cu cea similară de la FIFO de sub Unix). 

La fel ca şi la pipe anonime, se folosesc apelurile ReadFile şi WriteFile pentru 

schimbul cu pipe. 

Serverul îşi încheie activitatea apelând: 

DisconnectNamedPipe(HANDLE hNamedPipe); 

CloseHandle (HANDLE hNamedPipe); 

Pentru client, conectarea la un pipe cu nume presupune un apel sistem CreateFile: 

In cazul creării unui pipe cu nume, numeFisier reprezintă numele pipe-ului, cu sintaxa 

specificată mai sus, la apelul CreateNamedPipe. 

1.4.3. Exemplul 7: lista de fisiere cu nume de anumita forma; implementare 

pipe cu nume 

Enuntul problemei este: Se cere un server si un client. Clientul trimite serverului un intreg l si 

un string s. Serverul ii intoarce clientului lista a maximum l fisiere din directorul lui curent, 

ale caror nume se termina cu stringul s. 

Vom descrie implementarea separat pe functionalitati. Pentru fiecare functionalitate am 

intocmit o sursa separata. 

Mai intai vom construi o functie cu rolul de a furniza lista numelor de fisiere: 

Vom descrie mai intai tipul de date Mesaj. El va diferi de la un tip de canal la altul, insa 

pentru functiile de mai sus aceasta diferenta nu le va influenta raspunsurile. 

Structura Mesaj este:


/--PLUS--\ /------------- MAXS --------------\ 

|lung| |s | 

|----|----------|xxxxxxxxxxxxxxxxxxxxxxxxxxxx|------| 

| | 

\ -------------- lung ----------------/ 

lung este un intreg ce contine lungimea efectiva a continutului mesajului. 

Zona de PLUS octeti contine cativa intregi, depinde de tipul canalului pe care se comunica. 

s este un tablou de maximum MAXS caractere, aflat in partea finala a mesalului. 

Evident, in functie de natura problemei utilizatorul poate sa isi defineasca suprapuneri 

convenabile (union) in Mesaj. 

Sursa dir.cpp contine functia ce obtine lista fisierelor: 

Mesaj *dir(int l, char *s) { 

static Mesaj resp; 

WIN32_FIND_DATA d; 

char *p, *q, *n, dirc[] = ".\\*.*"; 

int i; 

p = resp.s; 

resp.lung = 0; 

HANDLE hf = FindFirstFile(dirc, &d); 

for (i=0; i MAXS) break; 

i++; 

strcpy(p, n); 

resp.lung += strlen(n)+1; 

p += strlen(n)+1; 

} 

resp.lung += PLUS; 

return &resp; 

} 

Functia dir primeste intregul l si stringul s precizati in enuntul problemei "lista a maximum 

l nume de fisiere din directorul curent al caror nume se termina cu s". 

La terminare intoarce un pointer la un Mesaj care contine lista numelor. 

Mesajul contine in s succesiunea de stringuri (conventie C) cu numele fisierelor raspuns, 

iar lung suma lungimilor acestor stringuri (plus zerourile terminale), plus PLUS. 

Pentru comunicarea prin pipe cu nume structura mesajului este descrisa in sursa mesaj.h: 

#define MAXS 10000 

#define MAXL 1000 

typedef struct { 

int lung; 

int i; 

char s[MAXS]; 

} Mesaj; 

#define PLUS (sizeof(int)) 

Citirea / scrierea unui Mesaj la comunicarea prin pipe se face in doua etape: 

1. Se scrie / citeste lung. 

2. Se fac scrieri / citiri repetate, pana cand sunt schimbati toti octetii continutului 

mesajului.


Pentru implementarea schimbului de mesaje sunt folosite functiile Read, Write, 

ReadMes, WriteMes. 

Primele doua aplica repetat apeluri ReadFile, WriteFile pana la schimbarea a exact n 

octeti, n parametru de intrare. 

ReadMes, WriteMes schimba mai intai lungimea continutului, dupa care cere schimbul 

complet al acestuia. 

Cele patru functii sunt prezentate in sursa ReadWrite.cpp: 

void Read(HANDLE f, char *t, int n) { 

char *p; 

int c; 

DWORD i; 

for (p=t, c=n; ; ) { 

ReadFile(f, p, c, &i, NULL); 

if (i == c) return; 

c -= i; 

p += i; 

} 

} 

void Write(HANDLE f, char *t, int n) { 

char *p; 

int c; 

DWORD i; 

for (p=t, c=n; c; ) { 

WriteFile(f, p, c, &i, NULL); 

if (i == c) return; 

c -= i; 

p += i; 

} 

} 

Mesaj *ReadMes(HANDLE canal) { 

static Mesaj mesaj; 

DWORD no; 

ReadFile(canal, (char*)&mesaj.lung, sizeof(int), &no, NULL); 

Read(canal, (char*)&mesaj+sizeof(int), mesaj.lung); 

return &mesaj; 

} 

void WriteMes(HANDLE canal, Mesaj *pm) { 

DWORD no; 

WriteFile(canal, (char*)pm, sizeof(int), &no, NULL); 

Write(canal, (char*)pm+sizeof(int), pm->lung); 

} 

Sursa parinte.cpp este: 

void parinte(HANDLE in, HANDLE out) { 

Mesaj *pm; 

for ( ; ; ) { 

pm = ReadMes(in); 

pm = dir(pm->i, pm->s); 

WriteMes(out, pm); 

} 

} 

Actiunea principala a clientului este dirijata de functia descrisa in sursa fiu.cpp: 

void fiu(HANDLE in, HANDLE out) {

} 


Mesaj *pm, mesaj; 

char *pc,linie[MAXL]; 

int i; 

for ( ; ; ) { 

printf("Dati: numar|sufix: "); 

pc = (char*)fgets(linie, MAXL, stdin); 

if (pc == NULL) break; 

linie[strlen(linie)-1] = '\0'; 

pc = strstr(linie, "|"); 

if (pc == NULL) continue; 

mesaj.i = atoi(linie); 

strcpy(mesaj.s, pc+1); 

mesaj.lung = PLUS + strlen(mesaj.s) + 1; 

} 

WriteMes(out, &mesaj); 


pc = pm->s; 

printf("%d\n",pm->lung); 

for (i = PLUS; i < pm->lung; ) { 

printf("%d %s\n", i, pc); 

i += strlen(pc) + 1; 

pc += strlen(pc) + 1; 

} 

In sfarsit, vom prezenta programele principale. 

Sursa fifos.cpp prezinta programul principal al serverului: 

#include 

#include 

#include "mesaj.h" 

#include "ReadWrite.cpp" 

#include "dir.cpp" 

#include "parinte.cpp" 

main() { 

HANDLE f1, f2; 

fclose(stdin); 

fclose(stdout); 

f1=CreateNamedPipe("\\\\.\\PIPE\\fifo1", PIPE_ACCESS_INBOUND, 

PIPE_TYPE_BYTE|PIPE_WAIT, 3, 0, 0, 0, NULL); 

f2=CreateNamedPipe("\\\\.\\PIPE\\fifo2", PIPE_ACCESS_OUTBOUND, 

PIPE_TYPE_BYTE|PIPE_WAIT, 3, 0, 0, 0, NULL); 

ConnectNamedPipe(f1, NULL); 

ConnectNamedPipe(f2, NULL); 

parinte(f1, f2); 

// Prin specificul problemei noastre cuncrete, nu se va ajunge la 

// instructiunile de mai jos. Le scriem totusi pentru exemplificare. 

DisconnectNamedPipe(f1); 

DisconnectNamedPipe(f2); 

CloseHandle(f1); 


} 

Sursa fifoc.cpp prezinta programul principal al clientului: 

#include 

#include 

#include "mesaj.h" 



#include "fiu.cpp"


main() { 


f1=CreateFile("\\\\.\\PIPE\\fifo1", GENERIC_WRITE, FILE_SHARE_WRITE, 

NULL, OPEN_EXISTING, 0, NULL); 

f2=CreateFile("\\\\.\\PIPE\\fifo2", GENERIC_READ, FILE_SHARE_READ, 


fiu(f2, f1); 



} 

In final prezentam comenzile de compilare, de lansare in executie si cateva cereri de liste de 

fisiere: 

D:\Florin\Didactic\20102011\SO\probleme\WProc-H>gcc -o fifos fifos.cpp 

D:\Florin\Didactic\20102011\SO\probleme\WProc-H>gcc -o fifoc fifoc.cpp 

D:\Florin\Didactic\20102011\SO\probleme\WProc-H>start fifos 

D:\Florin\Didactic\20102011\SO\probleme\WProc-H>fifoc 

Dati: numar|sufix: 5|cpp 

66 

4 capitalizare.cpp 

21 compilerun.cpp 

36 dir.cpp 

44 execWin.cpp 

56 fifoc.cpp 

Dati: numar|sufix: 10| 

103 

4 .. 

7 a.exe 

13 b.bat 



51 dir.cpp 


71 fifoc.cpp 

81 fifoc.exe 

91 fifocre.cpp 

Dati: numar|sufix: 

1.5. Comunicarea între procese Windows prin memorie partajată 

1.5.1. Fişiere I/O mapate în memorie şi segmente de memorie partajata 

Maparea (găzduirea) fişierelor în memoria internă este o facilitate preluată de Windows de la 

sistemul de operare DOS. Această mapare permite aplicaţiilor să acceseze părţi ale fişierului 

mapat folosind pointeri din memoria internă, în loc de accesare a discului. Prin aceasta se 

obţine o viteză de acces mult mai mare. Printre alte avantaje ale mapării, mai amintim faptul 

că se beneficiază de mecanismul de cache-ing şi de paginare a memoriei interne, oferit de 

Windows. 

O aplicaţie poate mapa fişiere de la 1 octet până la 2G octeţi. Fişerele mapate în memorie 

permit, de asemenea, ca două sau mai multe procese să partajeze aceste fişiere şi implicit să 

partajeze memoria internă.


In continuare, prezentăm o succesiune de 5 (cinci) paşi ce trebuie urmaţi de orice aplicaţie 

Windows care foloseşte o zonă de memorie partajată: 

1. Crearea segmentului de memorie partajată folosind funcţia CreateFileMapping. 

Această operaţie se poate realiza în două moduri: 

a) folosind un fişier definit anterior de către utilizator, cu ajutorul apelurilor 

CreateFile sau OpenFile. 

b) folosind o pagină sistem, specificată cu ajutorul unui handler predefinit, cu valoarea 

0xFFFFFFFF. 

Dacă segmentul de memorie partajatăError! Bookmark not defined. există deja, 

deschiderea accesului la segment se obţine cu ajutorul funcţiei OpenFileMapping. 

Obiectul Windows, asociat segmentului de memorie partajată, poartă numele de filemapping. 

Atât funcţia CreateFileMapping, cât şi funcţia OpenFileMapping întorc 

un handle la obiectul file-mapping asociat segmentului de memorie partajată referit. 

2. Maparea propriu-zisă a segmentului de memorie partajată (reprezentat prin obiectul filemapping), 

în spaţiul de memorie al procesului curent, este realizată cu ajutorul apelului 

MapViewOfFile. Această funcţie întoarce un pointer la o porţiune din această memorie 

partajată. 

3. Pointerul obţinut în urma apelului precedent, permite aplicaţiei apelante să acceseze zona 

de memorie partajată în citire şi/sau scriere, în funcţie de parametrii specificaţi la apel. 

4. Operaţia complementară celei de mapare, se realizează cu autorul apelului 

UnmapViewOfFile. Astfel, se realizează “detaşarea” aplicaţiei curente de la segmentul de 

memorie partajată, prin eliberarea spaţiului de memorie ocupat prin operaţia de mapare. 

5. In final, închiderea handle-ului la obiectul file-mapping se realizează cu funcţia 

CloseHandle. De asemenea, folosind CloseHandle, se închide fişierul deschis cu 

CreateFile sau OpenFile. 

Crearea / deschiderea în varianta 1.b, cu handle-ul special 0xFFFFFFFF permite folosirea 

unei singure zone partajate în sistem. Folosind numai acest handle, NU este posibil ca pe 

acelaşi sistem să existe mai multe zone de memorie partajată. Pentru a permite ca fiecare grup 

de procese să-şi folosească propria zonă de memorie partajată, trebuie să se folosească 

crearea / deschiderea în varianta 1.a, CreateFile / OpenFile. Astfel, se crează / 

deschide câte un fişier mapat în memorie pentru fiecare zonă de memorie partajată dorită. 

In continuare, punctăm o comparaţie, la nivel API, între operaţiile de lucru cu memorie 

partajată sub Unix şi sub Windows: 

CreateFileMapping shmget 

MapViewOfFile shmat 

UnmapViewOfFile shmdt 

CloseHandle shmctl 

Sintaxa exactă, a funcţiilor implicate în utilizarea segmentelor de memorie partajată sub 

Windows, va fi descrisă mai jos. 

HANDLE CreateFileMapping(HANDLE hFis, LPSECURITY_ATTRIBUTES descr_sec, 

DWORD prot, DWORD maxHigh, DWORD maxLow, LPCTSTR nume_file_mapping);


hFis –handle la fişierul de mapat; valoarea 0xFFFFFFFF pentru acest parametru indică o 

pagină implicită sistem. 

descr_sec –descriptor de securitate; dacă se specifică valoarea NULL pentru acest 

parametru, sistemul va folosi atributele de securitate implicite. 

prot –atribut de protecţie pentru obiectul de mapat. 

maxHigh, maxLow –compun dimensiunea pe 32 de biţi a obiectului de mapat. 

nume_file_mapping –numele obiectului file-mapping 

HANDLE OpenFileMapping( DWORD acces, BOOL bHandleMostenire, 

LPCTSTR nume_file_mapping); 

acces –indică modul de acces (citire şi/sau scriere) 

bHandleMostenire –indică dacă obiectul file-mapping va fi moştenit de eventualele procese 

fii 

nume_file_mapping –numele obiectului file-mapping 

LPVOID MapViewOfFile( HANDLE hFileMap, DWORD acces, DWORD offsetHigh, 

DWORD offsetLow, DWORD nrOctetiDeMapat); 

hFileMap –handle la obiectul file-mapping (handle returnat de CreateFileMapping) 

acces –indică modul de acces (citire şi/sau scriere) 

offsetHigh, offsetLow –compun offsetul pe 32 de biţi, a zonei de memorie de mapat 

nrOctetiDeMapat –numărul de octeţi de mapat 

BOOL UnmapViewOfFile(LPCVOID lpAdresaMapata); 

lpAdresaMapata –adresa de memorie unde începe maparea 

Pentru mai multe informatii legate de semnificaţia parametrilor şi prototipurile funcţiilor ce 

operarează cu memorie partajată sub Windows, se recomandă consultarea documentaţiei 

MSDN 

1.5.2. Semafoare Windows 

Crearea unui obiect semafor windows de către un proces se face folosind apelul 

CreateSemaphore. Semaforul windows poate fi: 

� semafor cu nume, folosit pentru comunicarea între procesele de pe aceeaşi maşină. In 

acest scop, numele este elementul de identificare al semaforului de către toate procesele 

interesate, care folosesc acest nume în apelul OpenSemaphore. 

� semafor anonim, folosit pentru comunicarea între thread-urile aceluiaşi proces. Elementul 

de identificare în această situaţie este constituit de handle-ul întors de funcţia 

CreateSemaphore, care este moştenit de thread-urile fii interesate. 

Prototipul CreateSemaphore este: 

HANDLE CreateSemaphore (LPSECURITY_ATTRIBUTES securitate, 

LONG valoareInitiala, 

LONG valoareMaxima, 

LPCTSTR numeSemafor); 

securitate –reprezintă un descriptor de securitate, care specifică dacă handlerul la 

semafor va fi moştenit în procesele fii; pentru valoarea NULL a acestui parametru, handlerul 

nu poate fi moştenit.


valoareInitiala – specifică valoarea iniţială a semaforului; trebuie să fie mai mare sau 

egală decât 0 şi mai mică sau egală decât valoareMaxima. 

valoareMaxima –indică valoarea maximă pe care o poate lua semaforul şi trebuie să fie 

mai mare decât 0. 

numeSemafor –specifică numele semaforului. 

Funcţia întoarce un handle la semafor, care poate fi utilizat în thread-urile fii. 

valoareInitiala şi valoareMaxima sunt numere nenegative. Dacă numeSemafor 

este un string, atunci avem de-a face cu un semafor cu nume, iar dacă această valoare este 

NULL avem de-a face cu semafor anonim. 

Se observă, că spre deosebire de semafoarele Unix, în acest caz se impune o limită superioară 

a valorii acestora. 

Odată creat un semafor cu nume, se poate face deschiderea accesului la semafor de către un 

proces. Deschiderea se face cu OpenSemaphore, care are prototipul: 

HANDLE OpenSemaphore (DWORD modDeAcces, 

BOOL mostenire, 

LPCTSTR numeSemafor); 

modDeAcces –indică modul de acces la semafor şi poate lua una (combinaţii): 

SEMAPHORE_ALL_ACCESS, SEMAPHORE_MODIFY_STATE, SYNCHRONIZE. 

(aceste valori pot fi restricţionate prin atribute de securitate la creare). 

mostenire –atribut de moştenire: indică (pentru valoarea TRUE) dacă handlerul la 

semafor va fi moştenit în procesele fii 

Orice semafor windows este caracterizat prin starea lui, care poate fi una dintre următoatele: 

� setat sau semnalat atunci când valoarea semaforului este strict pozitivă; 

� nesetat sau nesemnalat atunci când valoarea este egală cu zero. 

Cresterea valorii unui semafor se face prin apelul: 

BOOL ReleaseSemaphore(HANDLE hSemafor, 

LONG valoareDeAdaugat, 

LPLONG adresaVechiiValori ); 

hSemafor –specifică handlerul semaforului de incrementat. 

valoareDeAdaugat –indică valoarea cu care se incrementează valoarea curentă a 

semaforului. 

adresaVechiiValori –specifică adresa unde va fi memorată vechea valoare a 

semaforului. 

Dacă semaforul hSemafor are valoarea maximă (specificată la creare), atunci acest apel de 

incrementare eşuează. De asemenea, dacă se specifică o valoare negativă pentru parametrul 

valoareDeAdaugat, apelul eşuează.


Decrementarea valorii semaforului este realizată atunci când asupra obiectului semafor se 

aplică o operaţie de aşteptare. Această operaţie se realizează prin intermediul funcţiilor de 

aşteptare, prezentate mai sus. 


memorie partajata +semafoare 

In cele ce urmeaza, reluam exemplul 7 prezentat mai sus. Aici vom prezenta doar fisierele ce 

sunt modificate fata de acesta. 

Segmentul de memorie partajata va fi numit aici "SegmentMemoriePartajata", iar 

HANDLE la el shm. 

In segmentul de memorie partajata se va afla un singur mesaj, care poate fi o cerere sau un 

raspuns. 

Vom folosi doua semafoare: 

� unul pentru a asigura accesul exclusiv la segmentul de memorie partajata, numit 

"OcupaSegment" iar HANDLE la el semafor. 

� al doilea va indica daca in segment exista o cerere, semaforul este numit 

"ExistaCerere" iar HANDLE la el cerere. 

Sursa dir.cpp este identica cu cea de la exemplul de mai sus. 

Definirea tipului Mesaj si a structurii de date Segment aflata in segmentul de memorie 

partajata, este facuta in fisierul shmmesaj.h: 




int lung; 

int i; 

char s[MAXS]; 

} Mesaj; 



int tip; 

int pid; 

Mesaj mesaj; 

} Segment; 

Segmentul de memorie partajata contine: 

� tip - identifica ce informatie se afla in segmentul de memorie partajata: -1 cerere, 1 

raspuns, 0 nimic. 

� pid - este PID-ul serverului. El va fi folosit de server si de clienti pentru trimitere spre 

server a unor semnale de adormire sau de trezire pentru rezolvarea unei cereri. 

� mesaj - este spatiul pentru mesaj, folosit atat pentru cerere, cat si pentru raspuns. 

Implementarea schimbului de mesaje inseamna de fapt copierea in / din cu segmentul de 

memorie partajata. 

Fisierul shmReadWrite.cpp contine functiile ReadMes si WriteMes


void Wait(HANDLE semafor) {WaitForSingleObject(semafor, INFINITE);} 

void Signal(HANDLE semafor) {ReleaseSemaphore(semafor, 1, NULL);} 

Mesaj *ReadMes(Segment *segment) { 


mesaj.lung = segment->mesaj.lung; 

memcpy((char*)&mesaj+sizeof(int), 

(char*)segment+3*sizeof(int), mesaj.lung); 


} 

void WriteMes(Segment *segment, Mesaj *pm) { 

segment->mesaj.lung = pm->lung; 

memcpy((char*)segment+3*sizeof(int), 

(char*)pm+sizeof(int), pm->lung); 

} 

Actiunea principala a serverului este dirijata de functia parinte. Sursa parintelui este in 

shmparinte.cpp 

void parinte(Segment *segment, HANDLE semafor, HANDLE cerere) { 

Mesaj *pm; 

for ( ; ; ) { 

Wait(cerere); // Doarme, asteptand cereri 

if (segment->tip != -1) continue; 

} 

} 

Wait(semafor); 

pm = ReadMes(segment); 


WriteMes(segment, pm); 

segment->tip = 1; 

Signal(semafor); 

Actiunea principala a clientului este dirijata de functia fiu. Sursa fiului este in shmfiu.cpp 

void fiu(Segment *segment, HANDLE semafor, HANDLE cerere) { 



int i; 

for ( ; ; ) { 











segment->tip = -1; // Cerere 

WriteMes(segment, &mesaj); 

Signal(semafor); 

Signal(cerere); //Desteptarea 

for( ; segment->tip != 1; Sleep(100)); // Eventual wait 


pm = ReadMes(segment); 

segment->tip = 0; //Liber 

Signal(semafor);

} 

} 


pc = pm->s; 



printf("%d %s\n", i, pc); 



} 

In sfarsit vom prezenta programele principale. 

Programului principal al serverului este dat in shms.cpp: 

#include 

#include 

#include "shmmesaj.h" 

#include "shmReadWrite.cpp" 


#include "shmparinte.cpp" 

main() { 

HANDLE shm, semafor, cerere; 

Segment *segment; 



shm = CreateFileMapping((HANDLE)0xFFFFFFFF, NULL, PAGE_READWRITE, 

0, sizeof(Segment), "SegmentMemoriePartajata"); 

segment = (Segment*)MapViewOfFile(shm, FILE_MAP_WRITE, 0, 0, 

sizeof(Segment)); 

segment->tip = 0; 

segment->pid = GetCurrentProcessId(); 

semafor = CreateSemaphore(NULL, 1, 1000, "OcupaSegment"); 

cerere = CreateSemaphore(NULL, 0, 1000, "ExistaCerere"); 

parinte(segment, semafor, cerere); 



CloseHandle(cerere); 

CloseHandle(semafor); 

UnmapViewOfFile(segment); 

CloseHandle(shm); 

} 

Sursa clientului este data in shmc.cpp: 

#include 

#include 

#include "shmmesaj.h" 

#include "shmReadWrite.cpp" 

#include "shmfiu.cpp" 

main() { 

HANDLE shm, semafor, cerere; 

Segment *segment; 

shm = OpenFileMapping(FILE_MAP_ALL_ACCESS, TRUE, 

"SegmentMemoriePartajata"); 

segment = (Segment*)MapViewOfFile(shm, FILE_MAP_WRITE, 0, 0, 

sizeof(Segment)); 

semafor = OpenSemaphore(EVENT_ALL_ACCESS, TRUE, "OcupaSegment"); 

cerere = OpenSemaphore(EVENT_ALL_ACCESS, TRUE, "ExistaCerere"); 

fiu(segment, semafor, cerere); 

CloseHandle(cerere); 

CloseHandle(semafor); 

UnmapViewOfFile(segment); 

CloseHandle(shm);

} 

In final iata cateva executii: 


D:\Florin\Didactic\20102011\SO\probleme\WProc-H>gcc -o shms shms.cpp 

D:\Florin\Didactic\20102011\SO\probleme\WProc-H>gcc -o shmc shmc.cpp 

D:\Florin\Didactic\20102011\SO\probleme\WProc-H>start shms 

D:\Florin\Didactic\20102011\SO\probleme\WProc-H>shmc 

Dati: numar|sufix: 5|p 

66 



36 dir.cpp 


56 fifoc.cpp 


109 

4 .. 

7 a.exe 



45 dir.cpp 


65 fifoc.cpp 

75 fifoc.exe 


97 fifodel.cpp 

Dati: numar|sufix: 

1.6. Cozi de mesaje sub Windows 

1.6.1. Comunicarea între procese Windows prin Mailslot 

Arhitectura mailslot permite dezvoltarea de aplicaţii client/server care pot să comunice 

unidirecţional, de la client la server. 

Mailslot este o facilitate de comunicaţii în care un client, (de obicei staţie de lucru Windows), 

poate transmite prin datagramă un mesaj: 

� unui server mailslot -unicast; 

� serverelor mailslot din reţeaua locală care aparţin unui domeniu stabilit de administrator - 

multicast; 

� tuturor serverelor mailslot din reţeaua locală - broadcast; 

O comunicare de la client spre server se constituie într-un mesaj, deci serverul, dacă primeşte 

mesajul, este sigur că acesta conţine mesajul complet. Din cauză că se operează cu datagrame 

(pentru spor de viteză), nu este asigurată livrarea, nici livrarea de duplicate. Aşa că 

proiectantul trebuie să-şi proiecteze mecanisme proprii de control al livrărilor. Este adevărat 

că, într-o reţea LAN bine construită şi bine configurată, probabilitatea de eşec a unei livrări 

este foarte mică. 

Sintaxa numelor folosite în mailslot este prezentată în tabelul de mai jos:


Sintaxa Descriere 

\\.\mailslot\numeMailslot Serverul mailslot de pe maşina locală 

\\adresaMasina\mailslot\numeMailslot Serverul mailslot de pe maşina având 

adresa specificată 

\\numeDomeniu\mailslot\numeMailslot Multicast spre toate serverele mailslot 

care fac parte din domeniul specificat 

\\*\mailslot\numeMailslot Broadcast spre toate serverele 

mailslot din reţeaua LAN 

Un server mailslot creează un obiect mailslot care citeste mesajele trimise de clienţi. Serverul 

şi clienţii se pot afla pe aceeaşi maşină (local) sau pot rula pe două maşini diferite. 

Crearea unui server mailslot se face cu funcţia CreateMailslot. Stabilirea unui contact 

de către un client cu serverul - deschidere -de mailslot se face prin funcţia CreateFile. 

Citirea unui mesaj de către server se face prin funcţia ReadFile. Scrierea de către client a 

unui mesaj se face prin funcţia WriteFile. 

Inchiderea unui mailslot, atât la client cât şi la server se face folosind funcţia 

CloseHandle. 

In continuare, prezentăm prototipul funcţiei CreateMailslot. 

HANDLE CreateMailslot (LPCTSTR lpszName, DWORD cbMaxMsg, 

DWORD dwReadTimeout, LPSECURITY_ATTRIBUTES lpsa); 

lpszName– specifică numele mailslot indicând obligatoriu maşina locală, conform tabelului 

de mai sus. 

cbMaxMsg – indică dimensiunea maximă a mesajului în octeţi. Serverul poate primi unul 

sau mai multe mesaje, fiecare trebuind sã fie egal sau mai mic decât dimensiunea maximã 

specificatã. Nu existã limitã pentru numãrul de mesaje care se pot recepţiona. Serverul poate 

specifica NULL ca şi dimensiune maximã pentru a putea recepţiona mesaje de orice 

dimensiune acceptatã de sistem. 

dwReadTimeout – specificã, în milisecunde, perioada implicitã de time-out asociatã citirii 

unui mesaj din mailslot cand acesta este gol. Valoarea 0 inseamnã cã ReadFile se opreste 

imediat fãrã nici o eroare când mailslot-ul este vid. Valoarea 

MAILSLOT_WAIT_FOREVER asigurã serverul cã ReadFile nu se va bloca panã când 

este accesibil un mesaj. Dacã existã deja un mesaj în coada de mesaje atunci functia 

ReadFile se va executa imediat indiferent de valoarea dwReadTimeout. 

lpsa– permite asocierea unei variabile de tipul SECURITY_ATRIBUTES mailslot-ului. 

Astfel, serverul poate restricţiona accesul la mailslot. Specificând NULL ca şi atribut de 

securitate, se lasã în seama sistemului de operare. 

În urma apelului CreateMailslot() serverul obţine un handle către noul mailslot creat, 

pe care îl foloseste pentru a citi mesaje folosind funcţia ReadFile. Serverul specifică 

funcţiei handle-ul respectiv şi un buffer unde doreşte să recepţioneze mesajele.


Dacă există deja un mesaj în coada de mesaje funcţia ReadFile se execută imediat copiind 

în bufer mesajul. Dacă coada de mesaje este goală, funcţia va aştepta până în mailslot vor fi 

atâţia octeţi câţi aşteaptă funcţia. 

Un client mailslot este un program care trimite mesaje către un server mailslot. dimensiunea 

mesajului este limitată la 64K octeţi atunci când clientul scrie către un anumit mailslot, 

respectiv la 400 octeţi atunci când clientul trimite un broadcast către toate serverele mailslot 

din domeniu. 


mailslot 

In cele ce urmeaza, reluam exemplul 7 prezentat la mai sus. Aici vom prezenta doar fisierele 

ce sunt modificate fata de acest exemplu. 

Sursa dir.cpp este identica cu cea deja prezentată. 

Pentru comunicarea prin mailslot, folosim fisierul msgmesaj.h: 




int lung; 

long pid; 

int i; 

char s[MAXS]; 

} Mesaj; 


S-a introdus in plus campul pid. In el este retinut PID-ul clientului solicitant. Spre deosebire 

de implementarea prin pipe cu nume, aici serverul aplicatiei, cel care livreaza liste cu nume 

de fisiere, poate servi mai multi clienti. Fiecare client solicitant isi pune in mesaj PID-ul, 

pentru ca serverul sa stie cui sa ii intoarca lista. 

Aceasta implementare are un mailslot pe serverul aplicatiei, in care fiecare client isi scrie 

cererile. Din cauza specificului mailslot, si pentru a folosi tot mailslot pentru raspunsuri, 

fiecare client isi creeaza un mailslot propriu (numele lui contine PID). Prin intermediul 

acestuia serverul aplicatiei ii scrie clientului raspunsul. 

Pentru implementarea schimbului de mesaje sunt folosite functiile ReadMes si WriteMes. 

Continutul acestora este prezentat in sursa msgReadWrite.cpp 

Mesaj *ReadMes(HANDLE canal) { 


DWORD no; 

ReadFile(canal, (char*)&mesaj, sizeof(Mesaj), &no, NULL); 


} 

void WriteMes(HANDLE canal, Mesaj *pm) { 

DWORD no; 

WriteFile(canal, (char*)pm, sizeof(Mesaj), &no, NULL); 

}


Se scriu si se citesc mesaje de aceeasi lungime (maxima). 

Actiunea principala a serverului este dirijata de functia parinte care are doar un parametru, 

descriptorul mailslotului de pe server. Sursa serverului este data in fisierul 

msgparinte.cpp 

void parinte(HANDLE in) { 

Mesaj *pm; 

HANDLE out; 

long pid; 


for ( ; ; ) { 


pid = pm->pid; 


sprintf(nume, "\\\\.\\mailslot\\p2f%d", pid); 

out = CreateFile(nume, GENERIC_WRITE, 

FILE_SHARE_WRITE|FILE_SHARE_READ, 


WriteMes(out, pm); 

CloseHandle(out); 

} 

} 

In mod ciclic, serverul aplicatiei repeta: 

� Parintele asteapta (cea mai mare parte a timpului) sa citeasca un mesaj din mailslotul 

lui (cel ce contine cereri). 

� Preia din cerere PID-ul clientului. 

� Intocmeste lista de fisiere ceruta. 

� Creeaza un fisier de acces la mailslotul clientului. 

� Ii scrie acestuia mesajul de raspuns. 

� Inchide fisierul creeat. 

Actiunea principala a clientului este dirijata de functia fiu, unde in si out sunt descriptorii 

celor doua mailsloturi cu care lucreaza, iar pid este PID-ul clientului. Sursa clientului este 

data in fisierul msgfiu.cpp 

void fiu(HANDLE in, HANDLE out, long pid) { 



int i; 

for ( ; ; ) { 







mesaj.pid = pid; 




WriteMes(out, &mesaj); 


pc = pm->s; 



printf("%d %s\n", i, pc);

} 

} 

} 




Fata de sursa corespondenta din exemplul de mai sus, aici apare in plus un parametru si 

atribuirea prin care este depus in mesaj. 

In sfarsit vom prezenta programele principale. Sursa programului principal al serverului este 

data in msgs.cpp 

#include 

#include 

#include "msgmesaj.h" 



#include "msgparinte.cpp" 

main() { 

HANDLE f1; 



f1 = CreateMailslot("\\\\.\\mailslot\\f2p", sizeof(Mesaj), 

MAILSLOT_WAIT_FOREVER, NULL); 

parinte(f1); 




} 

Se creeaza mailslotul pentru cereri dupa care se apeleaza functia parinte. Sursa programului 

principal al clientului este data in msgc.cpp 

#include 

#include 

#include "msgmesaj.h" 


#include "fiu.cpp" 

main() { 


long pid = GetCurrentProcessId(); 


f2 = CreateFile("\\\\.\\mailslot\\f2p", GENERIC_WRITE, 

FILE_SHARE_WRITE|FILE_SHARE_READ, 


sprintf(nume, "\\\\.\\mailslot\\p2f%d", pid); 

f1 = CreateMailslot(nume, sizeof(Mesaj), 

MAILSLOT_WAIT_FOREVER, NULL); 

fiu(f1, f2, pid); 



} 

Aici se creeaza mai intai fisierul de acces la mailslotul de cereri. Apoi se creeaza un mailslot 

propriu, prin intermediul caruia serverul ii trimite raspunsul la cerere. Dupa cum se poate 

vedea din sursele msgc.cpp, msgs.cpp si msgparinte.cpp, se fac mai intai 

creerile legate de mailslotul de cereri (al serverului aplicatiei), apoi cele ale mailslotului 

propriu al clientului prin care primeste raspunsul. A se revedea observatia facuta mai sus 

pentru cazurile cand se folosesc mai multe mailsloturi. 

In final iata cateva executii:


D:\Florin\Didactic\20102011\SO\probleme\WProc-H>gcc -o msgs msgs.cpp 

D:\Florin\Didactic\20102011\SO\probleme\WProc-H>gcc -o msgc msgc.cpp 

D:\Florin\Didactic\20102011\SO\probleme\WProc-H>start msgs 

D:\Florin\Didactic\20102011\SO\probleme\WProc-H>msgc 

Dati: numar|sufix: 5|p 

66 



36 dir.cpp 


56 fifoc.cpp 


109 

4 .. 

7 a.exe 



45 dir.cpp 


65 fifoc.cpp 

75 fifoc.exe 


97 fifodel.cpp 

Dati: numar|sufix:

1. Procese Windows; comunicaţii prin pipe şi IPC 2

Create successful ePaper yourself

Delete template?

Save as template?