P. 1
Retele-de-calculatoare

Retele-de-calculatoare

|Views: 844|Likes:
Published by angelus 13

More info:

Published by: angelus 13 on Jun 16, 2011
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

08/29/2014

pdf

text

original

Sections

  • 1 Introducere
  • 1.2 URL. Scheme URL
  • 1.3 Hipertext, hiperlegătură, hipermedia
  • 1.4 Protocolul HTTP (Hypertext Transfer Protocol)
  • 2 FTP şi poşta electronică
  • 2.1 Serviciul FTP - Transfer de fişiere
  • 2.1.2 Client FTP
  • 2.2 Serviciul de poştă electronică – e-mail
  • 3 Servere Web
  • 3.3 Exerciţii IIS
  • 3.6 Exerciţii NCSA, Apache
  • 4.2 Testarea unei configuraţii TCP/IP
  • 4.3 Exemple de folosire a unor utilitare TCP/IP
  • 5 Adresare IP
  • 5.1 Clase de adrese
  • 5.2 Exerciţii rezolvate
  • 6 Comunicaţie client-server la nivel de socket
  • 6.2 Interfaţa Socket
  • 6.3 Exemplificări
  • 7.1 Nivelul de acces la date
  • 7.1.1 Apelarea procedurilor stocate pe SQL Server
  • 7.1.2 Virtualizarea accesului la baza de date
  • 7.2 Nivelul logicii aplicaţiei
  • 7.2.1 Apelarea procedurilor la distanţă
  • 7.2.2 Serializarea tipurilor de date complexe
  • 7.2.3 Apelarea serviciilor Web în mod asincron
  • 7.2.4 Publicarea unei componente ca serviciu Web
  • 7.2.5 Servicii Web virtuale
  • 7.2.6 Autentificarea şi autorizarea accesului
  • 7.3 Nivelul de prezentare
  • 7.3.1 Construirea unei imagini într-o pagină ASP.NET
  • 7.3.2 Apelarea unei componente dintr-un servlet
  • 7.3.3 Definirea unui Custom Tag în JSP
  • 7.4 Interoperabilitatea platformelor .NET şi J2EE

Cuprins
1. Introducere .....................................................................................................
1.1. Modelul client - server ......................................................................................................... 1.2. URL. Scheme URL ................................................................................................................. 1.3. Hipertext, hiperlegătură, hipermedia ............................................................................. 1.4. Protocolul HTTP (Hypertext Transfer Protocol) ..........................................................

2. FTP şi poşta electronică ...............................................................................
2.1. Serviciul FTP – transfer de fişiere .................................................................................. 2.1.1. Server FTP ................................................................................................................ 2.1.2. Client FTP ................................................................................................................. 2.2. Serviciul de poştă electronică – e-mail ........................................................................... 2.3. Exerciţii ..................................................................................................................................

3. Servere WEB ..................................................................................................
3.1. Introducere ............................................................................................................................ 3.2. IIS ........................................................................................................................................... 3.3. Exerciţii IIS ......................................................................................................................... 3.4. NCSA ....................................................................................................................................... 3.5. Apache .................................................................................................................................... 3.6. Exerciţii NCSA, Apache .....................................................................................................

4. Utilitare TCP - IP ..........................................................................................
4.1. Utilitare TCP - IP .................................................................................................................. 4.2. Testarea unei configuraţii TCP - IP ................................................................................. 4.3. Exemple de folosire a unor utilitare TCP - IP ...............................................................

5. Adresare IP ....................................................................................................
5.1. Clase de adrese ..................................................................................................................... 5.2. Exerciţii rezolvate ...............................................................................................................

6. Comunicare client – server la nivel de socket .........................................
6.1. Introducere ............................................................................................................................ 6.2. Interfaţa socket .................................................................................................................. 6.2.1. Comunicaţie client – server TCP - IP ................................................................. 6.2.2. Comunicaţie client – server UDP - IP ................................................................ 6.3. Exemplificări .........................................................................................................................

4 5 6 8 9 10 10 10 11 12 18 19 19 19 21 22 26 27 30 30 33 34 35 35 39 43 43 44 48 52 53 65 68 68 71 81 81

7. Implementarea aplicaţiilor distribuite pe platformele .NET şi J2EE ......................................................................................................................
7.1. Nivelul de acces la date ....................................................................................................... 7.1.1. Apelarea procedurilor stocate pe SQL Server ............................................... 7.1.2. Vizualizarea accesului la baza de date .............................................................. 7.2. Nivelul logicii aplicaţiei ....................................................................................................... 7.2.1. Apelarea procedurilor la distanţă .......................................................................

7.2.2. Serializarea tipurilor de date complexe .......................................................... 7.2.3. Apelarea serviciilor WEB în mod asincron ....................................................... 7.2.4. Publicarea unei componente ca serviciu WEB ................................................. 7.2.5. Servicii WEB virtuale ............................................................................................ 7.2.6. Autentificarea şi autorizarea accesului ........................................................... 7.3. Nivelul de prezentare .......................................................................................................... 7.3.1. Construirea unei imagini într-o pagină ASP.NET ............................................. 7.3.2. Apelarea unei componente dintr-un servlet .................................................... 7.3.3. Definirea unui Custom Tag în JSP ..................................................................... 7.4. Interoperabilitatea platformelor .NET şi J2EE ..........................................................

Bibliografie ..........................................................................................................

86 90 94 99 103 105 105 107 110 113 116

1 Introducere
Reţelele de calculatoare s-au dezvoltat spectaculos în ultimii ani, datorită evoluţiei tehnologiilor hardware, software şi de interconectare. Tehnologii de mare viteză au dus la utilizarea reţelelor de calculatoare în toate domeniile vieţii socio-economice, cu rezultate deosebite. Clasificarea reţelelor de calculatoare, după criteriul distanţei, în LAN (Local Area Network), MAN (Metropplitan Area Nerwork) şi WAN (Wide Area Network) este foarte cunoscută astăzi, iar Internet-ul este accesibil aproape oricui. Extinderea utilizării Internet-ului a dus la dezvoltarea serviciilor şi aplicaţiilor distribuite, prezentate pe scurt în acest material. Serviciile Internet cele mai răspândite sunt: WWW, poşta electronică (e-mail), transferul fişierelor (ftp), conectarea la distanţă (telnet, ssh). Unul dintre cele mai folosite servicii Internet este serviciul Web. WWW (World Wide Web), cunoscut şi sub denumitrea de Web sau W3, reprezintă serviciul Internet care permite navigarea pe colecţii de documente multimedia (hypertexte), din diferite reţele, calculatoare prin hyperlegături, utilizând o interfaţă comună (browser-ul). Caracteristici: Se deosebeşte de alte servicii Internet deoarece, prin concepţia sa, înglobează alte servicii ca: FTP, Gopher, Telnet, News. Reprezintă subnivelul superior al nivelului aplicaţie. Face apel la următoarele elemente: o URL (Universal Resource Locators) identificatorul uniform al resurselor; o HTTP (HyperText Transfer Protocol); o HTML (HyperText Markup Languages). Serviciul Web se deosebeşte de alte servicii Internet prin faptul că înglobează unele dintre ele, cum ar fi FTP, Gopher, Telnet, Wais, News. 4

Reţele de calculatoare

1.1 Modelul client-server Cel mai răspândit model de comunicare în Internet, având la bază protocolul TCP/IP, este modelul client-server, model după care funcţionează toate aplicaţiile şi serviciile Internet. Clientul, de obicei, rulează pe calculatorul utilizatorului şi este folosit pentru a accesa informaţii sau alte aplicaţii din cadrul reţelei. Browser-ul: emite cererile şi recepţionează datele care vor fi afişate; formatează documentele ţinând cont de tag-urile HTML; afişează documentele. Exemple: Netscape, Internet Explorer, Lynx, HotJava, Mosaic. Serverul rulează, de obicei, pe un calculator centralizator sau aflat la distanţă, furnizând sau oferind informaţii/servicii clienţilor. Exemple: Apache, NCSA, IIS (daemon httpd).
Client (cerere/răspuns) Server

Figura 1.1 Modelul client-server Modelul client-server are la bază un protocol simplu, fără conexiune de tipul întrebare-răspuns. La implementarea modelului client-server se ţine seama de: adresarea proceselor server; tipul primitivelor utilizate în transferul mesajelor (sincrone/asincrone, cu/fără tampon, fiabile/nefiabile). Clientul şi serverul se pot găsi în acelaşi nod, când se utilizează mecanisme de comunicaţie locală sau în moduri diferite, când se utilizează mecanisme de comunicaţie în reţea. 5

Introducere

1.2 URL. Scheme URL Generalităţi: S-a pus problema unui sistem standardizat de regăsire uniformă a resurselor. Pentru a se putea referi în mod standard, în cadrul aplicaţiei Web, orice tip de document (text, imagine, sunet), a fost creată specificaţia URL (Uniform Resource Locator). Prin URL se înţelege o descriere completă a unui articol, ce conţine localizarea acestuia, articolul putând fi un fişier de pe maşina locală, sau altul din orice parte a Internet-ului. Suportul principal pentru URL îl reprezintă documentul de tip hipertext. Acest document conţine link-uri (legături la alte servere) normalizate de tip URL. Hipertextul se descrie printr-un limbaj foarte simplu, care se poate implementa în orice fişier ASCII, numit html. Sintaxa generală Un URL complet constă într-o schemă, urmată de un şir de caractere cu format special, care este o funcţie a respectivei scheme. [URL:] schema-de-denumire | sir URL-ul cuprinde trei părţi: un cod pentru a identifica protocolul de transfer ce va fi utilizat; adresa pentru a identifica host-ul pe care sunt stocate fişierele; un descriptor de cale pentru amplasarea punctului (locaţiei) pe acea maşină. URL-ul trebuie să înceapă cu numele schemei, urmat de “:”, apoi adresa locaţiei unde se găseşte resursa, încadrată între caracterele: “//” şi “/” şi opţional un nume de utilizator şi o parolă.

6

Specificaţiile URI definesc sintaxa pentru codificarea arbitrară a schemelor şi conţin o listă a acestor scheme. care vor fi prezentate în tabelul 1.Reţele de calculatoare Pentru protocoalele Internet avem următoarea formă generală: schema://[ [nume-utilizator] [:parola]@ ] nume-de-domeniu-Internet [:număr-port] [/lista-de-directori] [/nume-de-fisier] Dacă nu se specifică numele de utilizator şi parola corespunzătoare. există câteva scheme URL standard. Termeni UR*: URI – Universal Resource Identifier este numele pentru identificatorul generic WWW.exp: „doc/document_html”.1 PROTOCOL DESCRIERE MOD DE LUCRU HTTP Protocol de transfer http://host[:port][/cale][?cautare] hipertexte FTP Protocol de transfer de ftp://[user[:parola]@]host/cale fişiere MAILTO Adresa de E-mail mailto:user@host NEWS Ştiri Usenet news:grup-discutii NNTP Ştiri Usenet pentru acces nntp:grup/cifre local NNTP FILE Acces la fişiere file://host/cale TELNET Referire la o sesiune telnet://host[:port] interactivă Tipuri de URL–uri: relative . atunci înseamnă că avem de-a face cu un utilizator anonimous. absolute .1. 7 . Scheme URL standard Tabelul 1. Conform cu definiţia BNF a sintaxei.exp: „met_acces://nume_server[:port]/cale/”.

3 Hipertext.Introducere URL – Uniform Resource Locator este o reprezentare compactă a locaţiei şi a metodei de acces pentru resursele disponibile pe Internet. data calendaristică. URN – Uniform Resource Name este o schemă particulară care include autenticitate. URC – Uniform Resource Characteristics reprezintă un set de atribute care descriu un obiect. animaţie şi sunete. Urmărind aceste legături. conţinând imagini şi legături cu grafice. termenul hipertext semnifică doar textul de bază al documentului. Umărind un anumit set de legături. În prezent. Când este conţinut într-un document de bază. Un singur click cu mouse-ul pe fiecare frază superluminată şi browser-ul va urmări automat acea legătură şi va afişa pe ecran o nouă informaţie. cum ar fi: autorul. 8 . tipul de dată. cititorul se poate deplasa în interiorul unui document sau de la un document la altul. Multe alte documente din Web sunt hipermedia. Trebuie specificat că nu este necesară citirea linie cu linie a acestui hipertext. elemente de copyright şi dimensiunea documentului. către alte texte sau informaţii. reproducere şi disponibilitate pentru URL-uri. nefiind un URL în adevăratul sens al cuvântului. Hiperlegăturile sunt evidenţiate în cadrul browser-ului în mod grafic cu o culoare şi/sau subliniate. cititorul poate naviga înainte sau înapoi în cadrul unui singur document. URL-ul în forma sa absolută conţine un tip de informaţie care este deja cunoscută de serverul destinaţie. O hiperlegătură leagă textul curent cu altă informaţie aflată undeva în Internet sau cu o nouă locaţie din cadrul documentului curent. hipermedia Hipertext este un text ce conţine legături numite hiperlegături sau ancore. publicistul. în timp ce alte legături îl pot purta în oricare punct din cadrul oricărui alt document din cadrul Web-ului. 1. hiperlegătură. facilitând astfel transferul fişierelor.

Permite tipărirea şi negocierea reprezentării datelor. cum ar fi servere de nume şi sisteme de management distribuit. care poate fi folosit cu uşurinţă de multe task-uri. modulul HTTP al calculatoruluiclient şi modulul HTTP al calculatorului-server încep să comunice unul cu altul. cât şi ale clientului. cu extensiile cerute de metodele sale. Este un protocol de nivel aplicaţie. construirea de sisteme independente de date care vor fi transferate. duplicate sau recepţionate în altă ordine faţă de cea în care au fost transmise. Acest circuit virtual consumă resursele atât ale serverului. Este orientat pe conexiune şi asigură recepţionarea sigură a pachetelor de date. oferind şi o metodă de control al fluxului între hosturile sursă şi destinaţie. care garantează că datele au fost recepţionate corect.4 Protocolul HTTP (Hypertext Transfer Protocol) Caracteristici: Este cel mai important şi cel mai des folosit protocol al Reţelei Mondiale (Web). Este un protocol generic. hipermedia din Web. datele pot circula în ambele direcţii simultan. Procesul de recepţie are controlul asupra vitezei la care se recepţionează şi se transmit datele. Circuitul virtual este full-duplex. 9 . Este construit peste serviciile protocolului TCP/IP. special proiectat pentru mediul interactiv. prin mecanismul de fereastră glisantă. nu au fost pierdute. Aceste două module (client şi server) conţin informaţii de stare care definesc un circuit virtual.Reţele de calculatoare 1. Este un protocol rapid. Când se startează o aplicaţie. ce oferă uşurinţa şi viteza necesare dezvoltării aplicaţiilor hipermedia. orientat obiect.

Parola este transmisă în clar prin reţea.Secure Sockets Layer).1. folosind SSL . transferul de informaţii prin FTP se va efectua doar în zone în care se ştie că nu este posibilă monitorizarea reţelelor de către orice utilizator. 2. 10 . O altă posibilitate este folosirea de clienţi sau servere modificate. astfel încât transferul să se realizeze prin canale sigure (de exemplu. Protocolul este FTP (File Transfer Protocol) şi este specificat în RFC 454. un utilizator trebuie să deţină un nume de cont şi o parolă validă pentru respectivul server. Din acest motiv. Funcţionează pe modelul client-server. Este bazat pe un sistem de autentificare a utilizatorilor.Transfer de fişiere Caracteristici: Permite transferul fişierelor de orice tip (fie ele binare sau de tip text) între două calculatoare din Internet. permiţând oricărui utilizator local care are acces la un program de monitorizare a reţelei să o afle.1 Serviciul FTP . numit anonymous (sau ftp).2 FTP şi poşta electronică 2. sau cele care oferă FTP anonim. În mod normal.1 Server FTP Caracteristici: Importanţa serviciului FTP este indicată şi de faptul că toate sistemele Unix sunt instalate cu un set de programe client şi server. Există servere publice. pentru accesul la documentele de pe un server FTP. Există un cont special. care nu este protejat prin parolă şi pentru care majoritatea serverelor moderne cer introducerea ca parolă a adresei de poştă electronică a utilizatorului client. Browserele cunosc nativ şi protocolul FTP (schema URL este: ftp://[cont@]server.domeniu/ ).

2 Client FTP Suita programelor care includ clienţi FTP variază de la cele care dezvoltă şi administrează servere WWW (Microsoft FrontPage.Internet Information Server). 2. fie ca parte a server-ului Web (IIS .ase. Programele "ascund" comenzile clientului ftp din linia de comandă. Macromedia Dreamweaver) la cele de aplicaţii de birotică (Microsoft Office. Clientul – pe staţia utilizatorului. tasta upload al browser-ului Internet Explorer.Reţele de calculatoare Utilizează 2 porturi: portul 21 . folosind schema URL: ftp://user@infocib.conf) conţine o linie de forma: ftp stream ftpd tcp nowait root /usr/sbin/ftpd În sistemele Windows. spre deosebire de situaţia clasică.1. fie ca serviciu de reţea. În fişierul /etc/services trebuie să existe următoarele linii: ftp ftp-data 21/tcp. portul 20 . în care transferul majoritar era de la server la client. majoritatea punând accent sporit pe transferul informaţiilor de la client la server.de pe care serverul iniţiază conexiunea pe care se va face transferul de informaţie. poate fi: comanda ftp . FTP trebuie instalat explicit. 20/tcp. existând variante care integrează perfect clientul FTP cu Windows Explorer). administratorul trebuie să se asigure că fişierul de configurare a programului inetd (/etc/inetd. Când serviciul FTP este pornit de către super-serverul inetd.pe care se transmit comenzile de la client la server.de al prompt-ul DOS.ro/cale_HOME/ 11 . numărul de port TCP cu care este asociat acest serviciu. un program sub SO Windows (exp: WinFTP). Trebuie verificat dacă există în fişierul /etc/services o intrare care să facă asocierea dintre numele simbolic ftp şi 21.

locul în care ajunge poşta electronică şi din care agentul utilizator preia poşta. se recomandă pentru fişiere ZIP.FTP şi poşta electronică Există mai multe modalităţi de transfer. în sensul că emiţătorul şi receptorul nu trebuie să fie simultan conectaţi pentru ca mesajul să ajungă de la sursă la destinaţie.deschide conexiunea cu server-ul de ftp de pe infocib user: contul_vostru password: parola_voastra >lcd c:\director_local – schimbă directorul de pe maşina locală.ext – pune fişierul din directorul local curent pe server-ul infocib.User Agent). cerând confirmare la fiecare >get fis. agentul utilizator (UA .ro . 12 .ext – ia de pe server şi pune pe local >mget * .multiple get >quit – închidere sesiune 2. imagini etc. EXE. care este de obicei un program cu care utilizatorul îşi citeşte şi trimite poşta electronică. >hash – vizualizarea transferului fiecărui 2048 B >cd director_server – schimbă directorul din home directory-ul user-ului >put fis.ext – multiple put – pune toate fişierele cu extensia . Principalele componente sunt: 1. datorită caracteristicii sale de a permite trimiterea de documente electronice între utilizatorii conectaţi la reţea. este cel care a stat la baza dezvoltării Internet-ului.ase. acolo unde se găsesc fişierele voastra/ sau unde doriţi să le puneţi pe cele aduse >bin – trecerea modului de transfer din ASCII în binar. Funcţionarea serviciului poate fi considerată asincronă. în directorul din home-ul utilizatorului >mput *. serverul de poştă electronică (cutia poştală).2 Serviciul de poştă electronică – e-mail Cunoscut şi sub denumirea de e-mail (electronic mail). Vom exemplifica modul din prompt MS-DOS: c:\>ftp >? vă arată toate subcomenzile ftp >o infocib.ext. 2.

IMAP Agent postal (MTA) SMTP Agent postal (MTA) Cutie postala pentru Andrei Agent postal (MTA) Cutie postala pentru Bogdan Figura 2.1 Modul de transmisie a poştei electronice şi protocoalele utilizate în cadrul acestui sistem La terminarea compunerii unei scrisori. în conformitate cu protocolul SMTP (Simple Mail Transport Protocol). agentul de transfer acţionează ca un client şi contactează serverul maşinii de la distanţă în care se află cutia poştală a destinatarului. Acesta aşteaptă ca în coada sa de intrare să fie plasată o scrisoare. Programul de transfer este optimizat să trateze împreună toţi recipienţii situaţi într-o aceeaşi maşină distantă. Pentru comunicarea între utilizatorii diferitelor sisteme de poştă electronică s-au introdus porţi de poştă electronică (realizează conversia între formatele de mesaje proprietare şi permit. care preiau mesajele de la UA şi le retransmit prin reţea către cutia poştală a destinatarului. transmiterea mesajelor dintr-un sistem în altul). astfel. Programul care realizează retransmiterea 13 .Reţele de calculatoare 3. Andrei Agent Utilizator (UA) SMTP Bogdan Agent Utilizator (UA) Agent postal (MTA) POP.Mail Transfer Agent). Pentru a trimite scrisoarea unui destinatar. agenţii de transfer (MTA . Clientul stabileşte o legătură TCP cu serverul şi îi trimite mesajul. pe care o trimite tuturor destinatarilor. agentul utilizator o plasează într-o coadă prelucrată de agentul de transfer. Poşta electronică are facilităţi importante de retransmitere a mesajelor către unul sau mai mulţi destinatari. Serverul primeşte mesajul şi plasează copia scrisorii în cutia corespunzătoare destinatarului.

fişiere ataşate: sunt de regulă binare şi însoţesc mesajul principal. numit poartă poştală (e-mail gateway). numită listă poştală (mailing list) are propria sa adresă poştală şi conţine o mulţime de adrese. Câmpul to: specifică o listă de adrese de poştă electronică. La sosirea unei scrisori. Listele păstrate de porţile poştale sunt. copie la indigo invizibilă). definit în RFC 821. traseul mesajului etc. copie la indigo) specifică. de asemenea. Fiecare intrare în baza de date. Câmpul cc: (de la carbon copy. fără ca receptorii să cunoască acest lucru. Din punctul de vedere al utilizatorului. cele mai importante câmpuri ale antetului se referă la adresa destinatarului (sau ale destinatarilor). iar server_poştă este adresa staţiei care face serviciul de cutie poştală sau un nume de domeniu. Programul de retransmitere consumă resurse importante (memorie şi timp). fiecare destinatar din cei menţionaţi în această listă urmând să primească o copie a mesajului. Dacă da. El este folosit atât pentru comunicarea între agenţii de transport al poştei. Mesajele de poştă electronică sunt compuse din trei părţi. se poate folosi câmpul bcc: (blind carbon copy. o listă de persoane care vor primi copii ale mesajului. este acelaşi cu serverul care menţine cutiile poştale). mesaj: cuprinde mesajul propriu-zis. Atunci când se doreşte trimiterea mesajului către un destinatar. primele două fiind descrise în cadrul RFC 822: antet: zonă care cuprinde informaţiile de control ale mesajului (adresele emiţătorului şi receptorilor. publice. SMTP (Simple Mail Transport Protocol) – unul dintre cele mai importante protocoale de comunicaţie între MTA-uri. data expedierii. programul examinează adresa de destinaţie şi determină dacă aceasta corespunde unei liste poştale.FTP şi poşta electronică foloseşte o bază de date.). din care află cum trebuie să prelucreze mesajul. în mod uzual. unde utilizator este numele de cont sau un pseudonim al destinatarului. Protocoale implicate în transferul poştei electronice pe Internet: 1. atunci programul retransmite o copie a mesajului către fiecare adresă din listă. cât şi pentru transmisia mesajului de la agentul utilizator către serverul local de transmisie a poştei electronice (care. de obicei. Adresele de poştă electronică au formatul general utilizator@server_poştă. 14 . De aceea el este găzduit de un sistem care oferă aceste resurse.

definit în RFC 1225. După reconectare. Serverul POP3 poate fi folosit şi cu conexiuni comutate (dial-up). La apelul său. Presupune existenţa a două cutii poştale. Clientul POP3 se execută pe PC-ul utilizatorului. Modul de gestiune folosit de produsele bazate pe IMAP este cuplat (on-line). clientul POP3 face identificarea utilizatorului (numeparolă). scrisorile sunt retransferate şi sistemul este resincronizat. dar este diferit de acesta. ca şi SMTP.Reţele de calculatoare 2. Acesta permite ca agentul utilizator să lucreze cu copii temporare ale mesajelor. Post Office Protocol. Versiunea sa cea mai utilizată se numeşte POP3 – permite descărcarea poştei de pe serverul central. practic. Se foloseşte pentru a se înlătura deficienţele constatate în POP3. DMSP (Distributed Mail System Protocol) – definit în RFC 1056. 15 . IMAP (Interactive Mail Access Protocol) – definit în RFC 1064. fiind adaptată pentru reţele de tip Intranet. Sincronizarea între cele două cutii poştale nu este prevăzută explicit în cadrul protocolului şi este. una pentru recepţie (cea de pe server) şi una de lucru (cea gestionată de agentul utilizator). după care se deconectează. presupune existenţa mai multor cutii poştale şi permite transferul scrisorilor către o staţie de lucru. POP3 foloseşte tot protocolul TCP. imposibil de realizat o menţinere unitară a poştei electronice în cazul în care utilizatorul nu foloseşte întotdeauna acelaşi calculator pentru a-şi accesa poşta. Această abordare este comodă pentru utilizatorii care nu au un punct fix de lucru. Acesta accesează cutia poştală a utilizatorului şi transmite clientului noile scrisori aflate aici. iar modelul de lucru implementat este decuplat (off-line). Sistemul care păstrează cutia poştală găzduieşte două servere. apoi legătura cu serverul POP3. 4. 3. Serverul POP3 lucrează pe maşina pe care se află cutia poştală. iar toată gestiunea mesajelor este menţinută pe server. unul SMTP şi unul POP3. ajuns la versiunea 4.

semne de punctuaţie). iar la recepţie se va face uudecode. 2048 şi 2049. Cele binare trebuie trimise după ce li s-a aplicat uuencode. unde se utilizează programul mail pentru trimiterea mesajelor. La sistemele Unix.protocol uşor de acces la cataloage. Tipul documentului ataşat este indicat în antetul mesajului de poştă electronică. Transferul documentelor prin intermediul poştei electronice: Prin facilitatea de ataşare a documentelor la un mesaj de poştă electronică este posibilă transmiterea unui fişier binar.standard definit pe parcursul a mai multor documente RFC: 1521. printr-un serviciu centralizat de directoare şi clienţi LDAP (atât Netscape. fişerele se ataşează cu comanda ~r nume_fiş în corpul mesajulul. cât şi certificate necesare pentru criptarea şi semnarea mesajelor de poştă. cât şi Microsoft au adoptat LDAP). de la emiţător către destinatar. 16 . nu numai text. 2046. reprezentate pe 6 biţi. în special. 2047. Tipul documentului permite programelor de poştă electronică să lanseze în execuţie programul care ştie să vizualizeze documentul ataşat recepţionat. Se poate construi o agendă cu informaţii despre persoanele implicate în sistemul de poştă. care specifică transformarea unei secvenţe de 3 caractere pe 8 biţi într-o succesiune de 4 caractere care pot fi tipărite (litere. cifre.FTP şi poşta electronică Ambele protocoale au două mari deficienţe: autentificarea se face pe baza unei parole care circulă în clar prin reţea iar mesajele aduse de la server sunt transferate în clar. folosindu-se codificarea bazată pe tipurile MIME. în legătură cu sistemul de poştă electronică deoarece îi furnizează acestuia atât adrese. transferul se face conform standardului MIME. Pentru o transmisie corectă şi o identificare uşoară a tipului documentului ataşat. Documentele binare sunt codificate conform standardului BASE64. Implicit SMTP-ul permite transfer de documente ASCII. Caracteristici MIME: MIME (Multipurpose Internet Mail Extensions) . Serviciul de directoare este folosit. Servicii de directoare: LDAP (Lightweight Directory Access Protocol) . 2045.

introducând alte 5 antete de mesaje: MIME-version. image. cât şi transferul mesajelor. application. message. multiplart etc. singurul client de poştă electronică folosit pe scară largă care este capabil să stabilească conexiuni SSL este Netscape Messenger. cu tip nespecificat.Fişier binar. atunci când accesează o cutie poştală de tip IMAP. se stabileşte un canal criptat pe care se va face atât autentificarea. înainte de începerea "discuţiei" dintre agentul utilizatorului şi cutia poştală. Soluţia rezolvă ambele probleme ale sistemelor de poştă. Content-Tranfer-Encoding.Reţele de calculatoare Cel mai folosit mod de specificare a tipului de conţinut. Content-Type.1 Tip/subtip MIME text/plain Tipul informaţiei asociate Informaţie de tip text care nu necesită interpretări speciale text/html Document ce conţine o pagină HTML image/gif Document de tip imagine codificată conform standardului GIF image/jpeg Document de tip imagine codificată conform standardului JPEG application/octet. Tipuri/subtipuri MIME Tabel 2. care trebuie tratat ca un stream şir de octeţi video/mpeg Film codificat conform standardului MPEG Pentru transferul mesajelor în siguranţă. Este o completare a RFC 822. cele două componente fiind separate printr-un slash. La ora actuală. există două variante: Criptarea canalului de comunicaţie – se face prin intermediul unui protocol sigur. 17 . Identificatorul de tip este definit ca fiind compus dintr-un tip şi un subtip. tipurile documentelor sunt cunoscute şi sub numele de tipuri MIME. Sistemul MIME a fost preluat şi de Web prin protocolul HTTP.) cu mai multe subtipuri. Content-ID. Din acest motiv. Content-Description. de tipul SSL (Secure Sockets Layer). precum şi 7 tipuri (text. Practic. Dezvoltat iniţial pentru a permite introducerea în cadrul mesajelor de poştă electronică a unor noi tipuri de informaţii pe lângă cele clasice de tip text.

iar firma Microsoft a adus unele extensii protocolului POP3 (mecanismul SPA . Creaţi-vă un cont de e-mail pe http://mailcom. 2. Studiaţi RFC-urile menţionate în seminar (pentru ftp. MIME) 2. pop3 pe infocib (ps aux) şi portul pe care rulează (netstat –a) 3. Citiţi-vă e-mail-ul folosind un client de e-mail configurat pentru POP3. Porniţi şi testaţi serverul de ftp din PWS (Personal Web Server). Verificaţi existenţa serverelor de ftp. aceste soluţii nu au un sprijin important din partea producătorilor de servere de poştă electronică sau din partea producătorilor de clienţi. IMAP. e-mail. apoi folosiţi un browser. e-mail. Trimiteţi prin acest sistem (cu SMTP) un fişier binar (uuencode/ uudecode). SMTP.FTP şi poşta electronică Criptarea mesajului . soluţia de tip PGP poate fi implementată cu succes în medii Windows şi Unix.ase. cât şi prin extensiile aduse celor două protocoale care gestionează poşta electronică de la client. Recapitulaţi programul mail din Unix.lasă deschisă problema autentificării cu cutia poştală. Astfel. cât şi pe cea a verificării identităţii emiţătorului. 18 . protocolul IMAP prezintă un mod opţional de criptare doar pe perioada autentificării. IMAP. asigurând integrare cu toţi clienţii de poştă electronică. Din păcate. POP3. Citiţi-vă poşta de pe infocib folosind un client de e-mail sub SO Windows (folosiţi POP3). 5.3 Exerciţii 1. 6.ro. dar rezolvă atât problema transferului sigur al mesajului.Secure POP Authentication) care au fost înglobate în clienţii de mail Outlook şi Outlook Express. Problema autentificării în siguranţă a utilizatorului cu cutia poştală poate fi rezolvată atât prin criptarea canalului de comunicaţie. folosind consola de management MMC (se lansează din Internet Service Manager) 4. De exemplu.

ca de exemplu: Apache .1 Introducere Un server WWW este un program care răspunde pe o conexiune TCP şi furnizează servicii unuia sau mai multor clienţi. Windows 2000 Server Family. disponibil cu Windows 2000 Server. 3. disponibil cu Option Pack 4.3 Servere Web 3. Conţine negocieri.0. XP. IIS (Internet Information Server) – pentru WinNT Server. 19 . PWS (Personal Information Server) – pentru Win. Există o mare varietate de servere Web pentru diferite forme de date. CERN . Ajuns la versiunea 5. Windows. Elemente de securitate: Restricţii IP şi de domenii Internet – se poate da/lua accesul la anumite pagini în funcţie de adresa IP sau de domeniul de la care se conectează utilizatorul.2 IIS Serverul de Web IIS (Internet Information Server) are următoarele caracteristici: Internet Information Server – server de Web pentru SO Windows NT Server. fişiere log extinse. NCSA . Conţine instrumente de căutare şi facilităţi de autorizare a accesului. server public.pentru platforme Unix.95/NT Workstation. VMS. PWS – Personal Web Server – pentru Win 9x şi NT Workstation.pentru platforme Unix.pentru platforme Unix.

director sau fişier. gestionarea se realizează prin componenta Windows Certificate Manager. Stocare de certificate de autentificare – integrat cu Windwos CryptoAPI. Administrare: crearea de servere virtuale (porturi diferite. cu drepturi restrânse.Servere Web Comunicaţii sigure – prin SSL (Secure Socket Layer) şi TSL (Transport Layer Security). autentificarea şi controlul mesajelor. integritatea. ISAPI. contorizarea proceselor pentru fiecare server de Web care rulează. setări pentru drepturile de acces: Read. limitarea % CPU pentru procesele ASP. fiecare site suportă şi un Operator. aplicaţii CGI. include autentificare Windows pentru accesul la paginile deWeb. asigură confidenţialitatea. care permite utilizarea de criptări pe 128 biţi. administrare la distanţă prin Web. IP acelaşi sau diferit) şi directoare virtuale (alias – utile când paginile pe Web se găsesc pe mai multe drive-uri ale calculatorului. sunt reprezentate prin icoana cu glob într-un colţ). 20 . Execute. Fortezza – standard de securitate al guvernului USA. Write. administrare centralizată prin MMC (Microsoft Management Console) – include programe numite “snap-ins”. Autentificare rezumat (digest authentification) permite autentificarea utilizatorilor prin servere proxy şi ziduri de protecţie. SGC (Server-Gated Cryptography) – extensie a SSL. componentelor şi sistemelor. Kerberos v5 – protocol de autentificare integrat în Win2000 care permite trecerea elementelor de autentificare printr-o reţea de calculatoare Windows. Script la nivel de site.

3. High (Isolated) . 21 . ftproot pentru serverele de web şi ftp. 3.exe) Medium (pooled) .3 Exerciţii IIS 1. 4. proces.implicit.exe.aplicaţiile rulează în procese diferite de serviciile Web (DLLHost. Verificaţi dacă există c:\Inetpub (directorul rădăcină al IIS). serviciu. director. respectiv directoarele wwwroot. Lansaţi pagina implicită a IIS (http://localhost/).Reţele de calculatoare protecţia aplicaţiilor – IIS oferă 3 niveluri: • • • Low (IIS Processes) – aplicaţiile rulează în acelaşi process ca şi serviciile Web (Inetinfo. Verificaţi existenţa IIS: port. aplicaţiile rulează într-o altă instanţă a DLLHost.exe). 2.exe (serverul ca serviciu) (CRTLALT-DEL -> Task Manager -> Processes) (Control Panel-> Services). Verificaţi dacă rulează InetInfo.

2. Caracteristici NCSA: Codul sursă al versiunii httpd_1. 22 . Din consola de management. conf. 6. creaţi un alt director virtual în acelaşi site. BIN cu fişierul httpd. src. HTDOCS pentru fişierele de tip . port. icons.Servere Web 5. Utilizatorul trebuie să modifice anumiţi parametri doar din makefile-ul directorului src. în index.3 are şapte directoare: cgi-bin. Creaţi un site pe portul 8000 cu numele grupei. support. 4. Daţi drept de browse. ICONS cu fişiere de tip . Vizualizaţi setările implicite ale serverului implicit IIS (home directory.4 NCSA Crearea unui server http utilizarea un server deja existent.ase. după care reîncărcaţi site-ul. 8. Produsul httpd_3. 5. 6. 7. CGI-BIN pentru fişier cgi. 9. 3. după care testaţi-l. Vizualizaţi porturile ocupate (netstat –a –n|more) 10. puneţi un fişier cu extensia .ro crearea propriul server: gata compilat sau sub formă de surse.html (în consola de management). Modificati fişierul implicit de pornire în index. 3. Din Sharing.html. prin care se compilează produsul.gif şi .xbm.infocib. 11. Refaceţi paşii cu fişierul default. dintre care ultimele trei conţin fişiere "makefile". Faceţi în aşa fel încât accesul să se realizeze pe bază de cont de Windows cu parolă. Verificaţi site-ul.html în directorul setat ca root pentru documentele serverului. logs. LOGS pentru a se vedea logările/erorile de logare. apoi redenumiţi fişierul dvs.html.0 compilat după aplicarea utilitarelor uncompress şi tar se obţin directoarele: 1. cgi-src. drepturi etc). creaţi un director virtual cu numele dumneavoastră în site-ul creat anterior şi daţi drept de browse pe acel director (în afară de cele implicite). Lansaţi Computer Management. CONFIG cu patru fişiere de configurare. de exemplu www.

implicit este 80. AccessConfiguration şi ResourceConfiguration – calea fizică pe care se găsesc fişierele de configurare pe server. de exemplu: /usr/etc/httpd. de exemplu: conf/access. Principalele tipuri de fişiere şi directivele care trebuie configurate sunt: httpd. este o valoare între 0-65536. UserDirectory – directorul ce specifică un subdirector pe care trebuie sa-l creeze utilizatorii pentru html-urile proprii.directorul ce conţine fişierele pe care le pune la dispoziţie httpd-ul.conf. Alias – creează o legătură între un document/director virtual de pe serverul de Web şi un document/director de pe calculatorul server. şi pus pe "enable". modificarea fişierelor de configurare cu parametri specifici sistemului.conf. ServerRoot – locaţia unde se găseşte daemon-ul. conf/srm. configurare în timpul rulării. Pentru ca userii să poată scrie în acel director trebuie comutat de pe "disable".infocib.conf – fişierul de configurare al resurselor serverului. având de modificat variabile în /src/Makefile şi /src/config. De exemplu www.ro (orice server nou creat de forma www sau de altă formă trebuie să fie înregistrat pentru a putea fi utilizat şi de alţii). Port –indică portul pe care httpd-ul va asculta cererile clienţilor. ScriptAlias – indică directoarele care sunt autorizate să includă script CGI. adică numele serverului WWW.Reţele de calculatoare Se bazează pe CGI şi utilizează programe de criptare. care este implicit. sub forma în care este înregistrat. srm. ServerName – aliasul DNS.ase. Există trei tipuri de configurare a serverului: prin compilarea sursei httpd.conf – fişierul de configurare al serverului – conţine informaţii referitoare la: ServerType – tipul serverului (stand-alone sau inetd). Redirect – creează un document virtual pe server. DocumentRoot .h (la versiunea de la NCSA). cum ar fi amplasarea documentelor şi a scripturilor CGI. 23 . exemplu: /usr/etc/httpd/htdocs.

Utilizatorii îşi creează directorul Web.default.??* *~ *# */HEADER* */README* AccessFileName . ce conţine documentaţie: < Directory/usr/local/etc/httpd/htdocs> OptionsIndexes FollowSymLinks Allow Override All * pentru .hhtaccess DefaultType text/plain Alias /icons/ /usr/local/etc/httpd/icons Alias /info/ /usr/local/etc/httpd/htdocs/info Alias /document/ /u/pub/document ScriptAlias /cgi-bin/ /usr/local/etc/httpd/cgi-bin Configurarea accesului pentru directorul htdocs.ase. Pentru ca ceilalţi utilizatori să aibă acces la acest director.html Exemplu de fişier httpd.html. Atât în zona sistem.ro ServerRoot /usr/local/etc/httpd ErrorLog logs/error_log TransferLog logs/httpd.ro DocumentRoot /usr/local/etc/httpd/htdocs UserDir Web DirectoryIndex index. în cadrul home directorului. trebuie să i se pună atributele de read şi execute pentru alţii.pid ServerName www.conf .infocib.xbm ReadmeName README HeaderName HEADER IndexIgnore */.infocib.server/~username/nume_fişier.fişierul de configurare al accesului – defineşte politica de limitare a dreptului de acces la diferitele documente ale serverului. cât şi în home-ul utilizatorilor trebuie să existe directorul Web. Accesul la fişiere se va face astfel: http://www.Servere Web access. unde se depun documentele .conf: port 80 User nobody Group #2 ServerAdmina dmin_nume@www.ase.html FancyIndexing on DefaultIcon /icons/unknown.htaccess files < Limit GET > 24 .

Deny Allow from all < / Limit > < / Directory > * implicit este Deny Etapele de instalare a serverului httpd: prin rularea stand-alone – serverul se execută ca un daemon clasic.local sau rc.Reţele de calculatoare Order Allow. -l log_fişier înregistrează cererile de conectare. restartează un httpd ce deja rulează. -vv. Un exemplu de formă de rulare a serverului. Acesta este pornit printr-un fişier de comandă. ceilalţi useri având acces de la 1024 în sus. -restart. Este o cale mult mai rapidă (recomandată). portul de ascultare. El aşteaptă sosirea conexiunilor şi serveşte cererile. poate fi: httpd [-d director_iniţial_server] [-f fisier_de_configurare][-v] unde -v este opţiunea pentru afişarea versiunii de server http. -v.conf.. 25 . În cazul în care nu se pune.local şi rulează continuu ca un daemon de "sendmail". Dacă se utilizează modul stand-alone. very verbose – comută pe mult mai multe mesaje de depanare. doar root-ul poate rula httpd pe porturi mai mici decât 1024. Forma generală de lansare a unui server httpd este următoarea: httpd [-opt -opt -opt . reîncărcând fişierele de configurare şi redeschizând fişierul de login (log file).] [director] unde opt poate fi: -r fişier_de_Configurare. -gc_only. doar pentru opţiunea de "proxy". -p port. Se poate renunţa la semnul de background "&". pe sistemele Unix. Pentru aceasta trebuie introdusă comanda: "/usr/etc/httpd &" în rc.. verbose – comută pe colectorul de depanare. La fiecare cerere a clientului creează o copie a sa. dacă fişierul de configurare /etc/httpd. implicit se consideră /etc/httpd. Porturile mai mici decât 1024 sunt privilegiate. din inetd (Internet Daemon) – serverul este administrat printr-un superdaemon care ascultă un port TCP/IP şi se ocupă cu lansarea procesului httpd la fiecare cerere a unui client (inetd-ul facând swap către httpd). Fără acest argument se consideră că se rulează ca "inetd" şi utilizează stdin şi stdout drept canale de comunicaţie.conf se găseşte la locul implicit şi este specificat şi portul pe care trebuie să asculte. care sunt privilegiate. cel folosit drept fişier de configurare. de exemplu /etc/rc.

Exemplificaţi pentru Apache sub SO Windows şi sub SO Unix.conf -p 80 este un server standalone ce rulează pe portul 80. Exemplu: httpd -r /usr/etc/httpd.5 Apache Caracteristici: Versiuni sub SO Unix (/var/apache/) şi SO Windows (c:\Apache\). structură de directoare (asemănătoare cu NCSA). -ds vizualizare selectivă a directorilor. Exemplificaţi pentru Apache sub SO Windows şi sub SO Unix. idem. 26 . -dys. incluzând textul fişierului în partea superioară a directorului. Fişiere de configurare (asemănătoare cu NCSA). -dr dezactivează includerea fişierului README. -dy dă posibilitatea vizualizării (navigării) conţinutului directorilor. Aceste două opţiuni pot fi combinate cu -dy. etc. -db. Dacă se doreşte renunţarea la server atunci se poate folosi: if [-f /usr/etc/httpd].Servere Web -version afişează versiunea de httpd şi libwww (The WWW Common Library). Acestă opţiune se poate seta şi din directiva de configurare DirAccess. aceştia devenind nişte documente hipertext. cu fişierul de configurare de mai sus. -dty. 3. then (/usr/etc/httpd && (echo -n 'httpd')) & >/dev/console fi Dacă sunt probleme la instalare. consultarea documentaţiei referitoare la bug-uri. se recomandă rularea cu opţiunea -v şi citirea FAQ-ului corespunzător. înainte de listarea conţinului directorului (se setează directiva de configurare DirReadme). -dt pentru toţi directorii navigabili care conţin un fişier README. dar pune textul fişierului README în partea inferioară. -dn nu permite vizualizarea directorilor. accesul fiind permis doar pentru cei conţinuţi în fişierul www_browsable. o acţiune de încercare a accesului în directori va genera un mesaj de eroare.

Instalare: a. 2.6 Exerciţii NCSA. pentru a accesa paginile voastre de Web cu serverul de Web NCSA. cu toate subdirectoarele sale.) Pe ce porturi rulează (netstat –a). în care mutaţi fişierele . 6. alegeţi varianta custom b. Documentaţi-vă despre directivele care vă permit crearea unor servere virtuale.html. Accesaţi pagina voastră de Web de pe infocib.. 10.43-win32-x86no_ssl. directorul c:\apache\ 27 . Conectaţi-vă pe un server de Unix (exp: infocib.org/ şi local. care să afişeze de câte ori a fost vizitată pagina voastră (opţional). 3. apache) (ps aux). Care este denumirea directorului pe care trebuie să-l creaţi în Home Directory.html create în seminarul anterior. 8. utilizând fiecare server de Web instalat. Dar pentru Apache? Transferaţi pe server fişierele . după instalare Apache sub SO Windows sau sub SO Unix (infocib.ase. APACHE sub SO Windows 1. Studiaţi documentaţia apache sub Unix de pe server.pdf 3.ro) Verificaţi ce servere de Web rulează (NCSA. 7. 4.ro/ /apache2_0. (~cont).apache. Creaţi un mic script SHELL (pentru a-l pune în zona cgi-bin).ro:1800).. pornire manuală pe portul 8080 c.ase. Download kit: ftp://ecomm. Documentaţie: --------. ce versiune de software? (httpd –help) Vizualizaţi structura de directoare şi fişierele de configurare pentru fiecare în parte.-----------/apachedocs. /var/apache/. 9.. Daţi dreptul de citire şi execuţie pentru toată lumea directorului Web. Unde se găsesc aceste servere? (/usr/local/etc/httpd/.ase. 3. 11. 5. Creaţi în home directory un director Web.Reţele de calculatoare Documentaţie http://www. Accesaţi o pagină situată în alt subdirector din Web. Apache 1.msi 2.

Porniţi serverul apache ca serviciu. Configurare: a. Testaţi-l pe default. n. Porniţi serverul cu acest fişier nou şi testaţi-l (–f file_name). f. i. Documentaţi-vă în legătură cu porturile unui sistem. alt port). . Verificaţi dacă programul apache este pornit ca proces sau serviciu.conf. modificaţi denumirea fişierelor . Verificaţi noul server de Web de pe acest port (apache –t. e. pe care le puteţi folosi ca utilizator privilegiat şi ca utilizator obişnuit.deny 28 . care sunt ocupate. d. Verificaţi configuraţia (apache –t). Vizualizaţi structura de directori ai serverului apache. j. Atenţie la aspectele de securitate: <Files ~ "^htaccess"> Order allow. Intraţi cu cont şi parolă pe directorul vostru virtual. Puneţi în cgi-bin un script care să vă afişeze un contor pe pagina voastră. i.conf. c. h.Servere Web 4.htpasswd: <Directory "F:\users"> AllowOverride AuthConfig Options None Order allow. -l). Editaţi httpd. Ce module sunt încărcate? Cum se pot încărca celelalte? (-V. netstat -a). Accesaţi paginile noului server.deny Allow from all </Directory> ii. g. m. cât şi pentru un alt director. Verificaţi existenţa serviciului. Creaţi un nou fişier de configurare (alt nume. k. Intraţi în directorul bin. o. Porniţi serverul apache ca proces din linie de comandă (nu din meniu). Verificaţi ce opţiuni aveţi din linie de comandă pentru comanda „apache” (apache -?). astfel încât home-ul pentru utilizatori să fie: c:\stud_document\ (exp: Alias /users "F:\users" ).htaccess. Vizualizati si modificati fişierul httpd. l. b. Verificaţi dacă este portul 8080 ocupat.

Verificaţi-l.deny Deny from all </Files> iii. Creaţi în directorul vostru fişierul htaccess: AuthType Basic AuthName "Carmen's Area!" AuthUserFile "F:/users/carmen/htpasswd" require user cs iv.so”? Testaţi noul site (http//nume2:port). Creaţi fişierul de parole în directorul vostru: C:\apache\bin\htpasswd –c htpasswd cs p. NameVirtualHost * <VirtualHost *> DocumentRoot "F:/users/carmen" ServerName carmens2 # Other directives here </VirtualHost> <Directory "F:\users"> AllowOverride AuthConfig Options None Order allow. Trebuie pus şi modulul „LoadModule vhost_alias_module modules /mod_vhost_alias.Reţele de calculatoare Deny from all </Files> <Files ~ "^htpasswd"> Order allow. Creaţi un server virtual pe aceeaşi adresă IP.deny Allow from all </Directory> 29 . (-t –D DUMP_VHOST). (Fişierul hosts trebuie editat).

Pentru informaţii referitoare la modul în care se folosesc. Va fi afişat numele computerului. şi tastaţi comanda. 30 .1 Utilitare TCP/IP Utilitarele linie de comandă TCP/IP prezintă o mare importanţă. trebuie doar să tastaţi numele acestuia şi să apăsaţi tasta Enter. folosiţi parametrul |more. Pentru informaţii referitoare la modul de folosire a utilitarului tracert. cu excepţia hostname şi tracert. urmată de parametrul/?.1 Utilitar Descriere Testează conexiunea cu un computer ping Afişează conţinutul cache-ului local în care sunt stocate arp adresele IP asociate adreselor fizice ale plăcilor de reţea (MAC) pentru computerele din LAN Afişează configuraţia TCP/IP curentă ipconfig Afişează statistici şi conexiuni pentru protocolul NetBT nbtstat Afişează statistici şi conexiuni pentru protocolul TCP/IP netstat Afişează sau modifică tabela de rutare locală route hostname Afişează numele computerului Verifică ruta până la un computer aflat la distanţă tracert Verifică dacă routerele de pe drumul până la un computer aflat pathping la distanţă funcţionează corect şi în acelaşi timp detectează pierderile de pachete de date rezultate în urma trecerii prin diferite noduri ale reţelei Toate aceste utilitare sunt executate din linia de comandă. cât şi la aflarea de informaţii referitoare la configuraţia curentă. Utilitare pentru depanarea erorilor de configurare şi testarea conectivităţii Tabel 4. Pentru a folosi utilitarul hostname. deoarece pot fi folosite atât la depanarea erorilor de configurare. deschideţi o fereastră de comandă (Start->Programs->Accessories>Command Prompt). tastaţi numele acestuia şi apăsaţi tasta Enter.4 Utilitare TCP/IP 4. Dacă informaţiile afişate încap pe mai mult de un ecran şi nu le puteţi urmări.

Sistemele de operare Microsoft nu oferă suport decât pentru clienţi telnet. va fi afişată adresa alocată prin tehnologia APIPA. Utilitarul ipconfig Ipconfig se foloseşte pentru verificarea configuraţiei protocolului TCP/IP. dacă este cazul. dar în dreptul măştii de subreţea se va trece 0. Oferă o conexiune la un computer ce suportă protocolul telnet. Rezultatul tastării comenzii ipconfig /all este următorul: Dacă este setată o configuraţie validă. este afişată adresa IP şi masca de subreţea. Windows 2000 Server). Pentru afişarea tuturor informaţiilor disponibile. Ping transmite pachetele utilizând ICMP ECHO_REQUEST şi se aşteaptă primirea unui 31 . Rulează un proces pe un computer aflat la distanţă.0.2 Descriere Facilitează transferul bidirecţional de fişiere între un computer pe care rulează Windows şi un server FTP (de exemplu.0. va fi afişată adresa IP folosită. Dacă Windows nu a putut obţine o adresă IP de la un server DHCP. Copiază fişiere între un computer cu Windows şi unul ce oferă suport pentru RCP (Remote Copy Protocol). de exemplu un computer pe care rulează UNIX.0. Utilitarul ping Ping este un instrument folosit pentru testarea conexiunii TCP/IP între computerul dumneavoastră şi unul aflat la distanţă. Facilitează transferul bidirecţional de fişiere între un computer pe care rulează Windows şi un server TFTP. precum şi gateway-ul implicit. Dacă este detectat în reţea un duplicat al adresei IP folosite.Reţele de calculatoare Utilitare pentru conectarea la distanţă folosind protocolul TCP/IP Utilitar FTP TFTP Telnet RCP RSH REXEC Tabel 4. Rulează comenzi pe un computer pe care este instalat UNIX. se foloseşte parametrul /all. Vom descrie în continuare în detaliu o serie de utilitare TCP/IP.

Sintaxa comenzii este ping adresa_IP_a_computerului_de_la_distanţă. Opţiuni . 32 . conecţiile active. numele complet. fluxuri. În momentul în care nu există intrări ARP pentru o anumită adresă Internet se va afişa un mesaj în acest sens. Vom prezenta o serie de opţiuni folosite cu această comandă. -a Solicită afişarea stării socketurilor. Cele asociate cu procesele server nu sunt afişate -i Afişează starea interfeţelor ce au fost autoconfigurate -m Afişează modul de utilizare a memoriei -r Afişează tabelele de rutare -p nume_protocol Limitează informaţiile la un protocol anume Utilitarul traceroute Este utilizat pentru a identifica traseul ce trebuie urmat de un pachet pentru a ajunge la destinaţie. numele terminalului.Utilitare TCP/IP răspuns de confirmare pentru fiecare pachet transmis prin ICMP ECHO_REPLY. precum şi alte caracteristici.selectiv: Format de redare redus -b -f Suprimă afişarea părţii de antet -i Afişează o listă cu timpii inactivi -l Format de redare extins -q Afişează o listă rapidă de utilizatori Utilitarul netstat Comanda netstat este folosită pentru a extrage o serie de informaţii cum ar fi tabelele de rutare. Această comandă lucrează utilizând un câmp special TTL (time to live) din cadrul pachetului IP. Utilitarul finger Listează numele de login. Utilitarul arp Comanda arp afişează şi modifică tabela de corespondenţă între adrese Internet şi adrese Ethernet (MAC).

ping adresa_IP_a_unui_computer_aflat_la_distanţă (pe alt segment de reţea) Folosiţi utilitarul ping cu adresa IP a unui computer aflat pe alt segment de reţea (de exemplu. ce implică eventual şi existenţa unor routere. ping adresa_IP_a_gateway-ului_implicit Folosiţi utilitarul ping cu adresa IP a gateway-ului implicit (aceasta poate fi aflată folosind comanda ipconfig) pentru a verifica dacă gateway-ul implicit este operaţional şi computerul dumneavoastră poate să comunice cu acesta. dacă acest ultim pas reuşeşte. ping 127. În general.1 Folosiţi utilitarul ping cu adresa internă a plăcii de reţea pentru a verifica dacă protocolul TCP/IP este instalat corect şi placa dumneavoastră de reţea îl foloseşte. ping adresa_IP_a_computerului_dumneavoastră Folosiţi utilitarul Ping cu adresa IP a computerului dumneavoastră pentru a elimina riscul existenţei în reţea a unui duplicat al adresei IP folosite.0.2 Testarea unei configuraţii TCP/IP Vom prezenta în continuare care sunt paşii ce trebuie urmaţi pentru verificare configuraţiei computerului şi pentru testarea conexiunilor la computere aflate la distanţă. va trebuie să urmaţi succesiunea de paşi de mai sus pentru a putea localiza problema.Reţele de calculatoare Opţiuni: -a -d nume Afişează toate intrările din tabele ARP curentă Şterge intrările corespunzătoare din tabela ARP -s adresă host Crează o nouă intrare în tabela ARP folosind o adresă Ethernet 4.0. 33 . atunci ceilalţi paşi sunt inutili. ipconfig Folosiţi utilitarul ipconfig pentru a verifica dacă a fost iniţializată configuraţia TCP/IP. Totuşi. în cazul în care nu reuşeşte. infocib sau nemesis) pentru a verifica dacă se poate stabili o conexiune cu un computer aflat la distanţă prin intermediul unui router.

Utilitare TCP/IP

4.3 Exemple de folosire a unor utilitare TCP/IP Arp –a – afişează conţinutul cache-ului ARP (adrese IP asociate adreselor fizice ale plăcilor de reţea). Folosiţi mai întâi comanda ping pentru ca Windows să poată stoca adresa fizică (MAC) a plăcii de reţea folosită de computerul aflat la distanţă. Ex: Secvenţa ping ecomm.ase.ro arp -a va duce la afişarea adresei MAC a serverului ecomm. tracert adresa_IP_a_computerului_de_la_distanţă – afişează nodurile de reţea prin care trece un pachet de date până să ajungă la computerul destinaţie. pathping adresa_IP_a_computerului_de_la_distanţă – reprezintă o combinaţie între comenzile tracert şi ping, fiind testată conexiunea cu fiecare nod de reţea (router) până la computerul destinaţie, folosindu-se comanda ping în mod automat pentru fiecare dintre acestea. nbtstat –A adresa_IP_a_computerului_de_la_distanţă – afişează numele NetBIOS al unui computer aflat la distanţă, în cazul în care este cunoscută adresa IP a acestuia. netstat –a – afişează toate conexiunile stabilite în reţea, precum şi toate porturile deschise pe computerul dumneavostră.

34

5 Adresare IP
5.1 Clase de adrese Fiecare familie de protocoale trebuie să conţină un mod de adresare, pentru a identifica reţelele şi nodurile în cadrul acestora. Adresele Internet folosite de IP sunt reprezentate pe 32 de biţi şi sunt alocate în mod unic la nivel global, de o autoritate centrală şi mai multe autorităţi regionale. Adresele pe 32 de biţi sunt specificate de aşa-numita vesiune 4 a IP. Recent a fost standardizată versiunea 6 (IPv6), în care adresele se reprezintă pe 128 octeţi. În vederea unei alocări sistematice, adresele IP au fost divizate în cinci clase de adrese. Dintre acestea trei (clasa A, B, C) vor fi discutate în amănunt. Orice nod conectat într-o reţea TCP/IP trebuie să aibă o adresă IP (ruterele, care dispun de mai multe interfeţe de reţea, vor avea câte o adresă IP pentru fiecare interfaţă). A fost introdusă şi o convenţie de scriere a acestor adrese: fiecare din cei patru octeţi ai adresei este notat distinct prin numărul zecimal corespunzător, cele patru valori fiind separate prin punct, ca în exemplul următor: 123.1.232.11. O altă convenţie de scriere este următoarea: 20.0.0.0/12, ce denotă aplicarea unei măşti de 12 biţi pe adresa 20.0.0.0, adică selectează toate valorile posibile în ultimii 20 biţi de adresă. Analog, 194.110.6.0/26 aplică o mască de 26 biti pe adresa 194.110.6.0/, adică selectează ultimii şase biţi de adresă (64 valori). Recent a fost introdusă şi distincţia între adrese publice şi adrese private. Se numesc adrese publice cele care sunt obţinute de la autorităţile de alocare a adreselor şi sunt rutate în Internet. Aceste adrese au caracter de unicitate, în sensul că nici o adresă nu este multiplu alocată. Datorită creşterii explozive a conectărilor la Internet a apărut preocuparea faţă de epuizarea adreselor pe 32 de biţi şi una din soluţiile adoptate pentru evitarea acestui fenomen a fost să se rezerve câteva adrese care să poată fi utilizate intern (privat) de orice organizaţie, fără a fi vizibile în afara organizaţiei (nu vor fi rutate în afara organizaţiei). Astfel de adrese sunt: 10.0.0.0 - 10.255.255.255 (reţea de clasă A) 172.16.0.0 - 172.16.255.255 (reţea de clasă B) 192.168.0.0 - 192.168.255.255 (bloc de reţele de clasă C) 35

Adresare IP

Rămâne la latitudinea utilizatorului alegerea adreselor private pe care le foloseşte, dar aceasta trebuie făcută conform unor criterii de performanţă. Unul dintre criteriile de alegere este evident dimensiunea reţelei interne: dacă aceasta are doar câteva zeci de calculatoare nu se justifică alegerea adreselor private de clasă B sau A. Sintetizarea noţiunilor referitoare la adresarea IP Tabel 5.1 Denumire Adresa IP Adresă de reţea Descriere Număr pe 32 biţi, scris de obicei în format zecimal, grupat pe cei patru octeţi, prin care se poate identifica în mod unic un nod (interfaţă). Număr pe 32 biţi, scris de obicei în format zecimal, grupat pe cei patru octeţi, care identifică o reţea. Numărul nu poate fi asignat unui nod (interfeţă). Porţiunea din adresă corespunzătoare gazdei conţine numai valori binare de 0. Număr pe 32 biţi scris de obicei în format zecimal grupat pe cei patru octeţi, utilizat pentru a adresa toate nodurile (interfeţele) din cadrul unei reţele de calculatoare. Porţiunea din adresă corespunzătoare gazdei conţine numai valori binare de 1. Număr pe 32 biţi scris de obicei în format zecimal grupat pe cei patru octeţi, utilizat pentru a calcula adresa de reţea prin efectuarea unui şi logic între mască şi o adresă IP.

Adresă de broadcast

Mască de reţea

Prin definiţie, toate nodurile dintr-o reţea posedă aceeaşi valoare numerică pentru porţiunea de reţea din adresele IP. Cealaltă parte a adresei IP se numeşte zonă de gazdă (host). Aceasta diferă de la un nod (interfaţă) la altul. Adresele de clasa A sunt folosite în reţelele cu un număr foarte mare de noduri aflate sub aceeaşi autoritate (companii transnaţionale, organizaţii mondiale, etc.). Adresele de clasă A folosesc opt biţi (un octet) pentru a identifica reţeaua. Prin urmare ceilalţi 24 biţi sunt folosiţi pentru a identifica nodurile (interfeţele). Prin urmare unei reţele de clasă A i se pot asigna 224 noduri. Adresele de clasa B au rezervată o zonă de reţea de 16 biţi, iar cele de clasă C au rezervată o zonă de reţea de 24 biţi.

36

De exemplu.0.126 128 – 191 192 . 37 .0.4.0.0 identifică o reţea de clasă C.0.255.0.2 28 .0.255.0. La nivel conceptual adresele de reţea referă grupul tuturor adreselor IP dintr-o reţea.Reţele de calculatoare Adresele de clasa B au fost atribuite iniţial marilor universităţi şi companii.255. 130.2 A B C 1.0 este folosită ca adresă de broadcast. Caracteristici adrese Clasă Număr de octeţi-biţi utilizaţi pentru a identifica reţeaua Număr de octeţi-biţi utilizaţi pentru a identifica interfaţa Tabel 5.0 192.0 – 126. Adresele de reţea sunt similare adreselor IP obişnuite însă nu sunt asignabile unei interfeţe anume.0.0. iar adresa 127.0.254.0 şi 223. 192.0.0.2 28 .2 A 1 (8) 3 (24) B 2 (16) 2 (16) C 3 (24) 1 (8) *Există două adrese rezervate pentru fiecare reţea.254. De exemplu adresa 7. Tabelul 2 sintetizează aceste caracteristici.0.0 – 221 – 2 223.0. Alte exemple de adrese rezervate ar fi: 128.0.0 este folosită ca adresă de loopback.0 identifică o reţea de clasă B. În ultima vreme obţinerea unei adrese de clasa B este dificilă.0 – 214 – 2 191. Tabelul 3 sintetizează aspectele referitoare la adresele de reţea.3.0.255.0.1. iar 200.0. 191.2 216 .3 Numărul de adrese asignabile pe reţea 224 .223 Adrese de reţea valide Număr de adrese de reţea valide Tabel 5.0 Există o serie de excepţii care reies şi din tabelul 3. adresa 0.9.0.0.0.0 identifică o reţea de clasă A.0 27 – 2 128.1. Marje adrese IP Clasă Valoarea primului octet 1 .0.2 Numărul de adrese asignabile pe reţea* 24 2 -2 216 .

De exemplu o mască de reţea de forma: 255.0 255. utilizată în cadrul unei reţele de clasă C.0 255. subreţea şi host.0.240. 38 .0 În momentul în care se doreşte împărţirea în subreţele se alocă în cadrul adresei IP un număr de biţi care identifică subreţelele. în cadrul adresei IP.255. 8 24-x x Reţea Sub-reţea Host 16 16-x x Reţea Sub-reţea Host 24 8-x x Reţea Sub-reţea Host Figura 5.255.255. În tabelul 4 sunt definite măştile de reţea standard.255.0. cei de host sunt definiţi de către masca de reţea folosită.255.4 Masca de reţea standard 255. Astfel. determină un număr de patru biţi de host. iar cei de subreţea sunt obţinuţi prin preluarea biţilor rămaşi. Biţii ce identifică reţeaua sunt definiţi prin tipul clasei.Adresare IP O mască de reţea standard este definită ca având valori binare de 0 corespunzător poziţiilor din adresă ce definesc host-ul.1 Structurarea unei adrese de IP Putem face o serie de observaţii privitoare la cele discutate: Două adrese IP unice din aceeaşi reţea au valori identice pentru partea de reţea. sunt definite trei zone: reţea. diferind prin partea de host.0. Măşti de reţea standard Clasă A B C Număr de octeţi-biţi ce identifică reţeaua 1 (8) 2 (16) 3 (24) Tabel 5. Aceştia sunt preluaţi din cadrul zonei de host a adresei IP.

255. 39 .255. Având adresa IP 193.0 1111 1111 1111 1111 1111 1111 0000 0000 134. în cea de subreţea diferind doar prin partea de host.7.7.255.0 1111 1111 1111 1111 1111 1111 0000 0000 193.255. rezultă că nu se utilizează împărţirea în subreţele.255.7. iar masca este 255. B sau C în funcţie de caz).255. Dacă nu s-ar utiliza împărţirea în subreţele.7.Reţele de calculatoare Două adrese IP unice din aceeaşi subreţea au valori identice în partea de reţea. Având adresa IP 134. Adresa: Masca de reţea: Rezultatul: 134. Două adrese IP unice aflate în subreţele diferite dintr-o reţea de clasă A. Numărul de reţele disponibile ar fi insuficiente.141.0 să se specifice care este adresa de broadcast pentru subreţea.255.141. cel mai mic grup de hosturi ce s-ar putea forma ar fi echivalent cu o clasă de adrese (A. Ţinând cont că este vorba despre o adresă de clasă C.193.255. Având adresa IP 134.141.193.255.7 1100 0001 1100 0001 0000 0111 0000 0111 3.7. 5.255.2 Exerciţii rezolvate 1.7.193.7 1100 0001 1100 0001 0000 0111 0000 0111 255. Adresa este de clasa B.11 şi masca de reţea 255.0.141. B sau C au aceeaşi valoare în partea de reţea şi diferă prin partea de subreţea.11 şi masca de reţea 255.0 1000 0110 1000 1101 0000 0111 0000 0000 2.0 să se specifice care este numărul care identifică subreţeaua.11 1000 0110 1000 1101 0000 0111 0000 1011 255.7 şi masca de reţea 255.255.255. am evidenţiat îngroşat biţii care identifică subreţeaua. Adresa: Masca de reţea: Rezultatul: 193.0 să se specifice care este adresa care identifică subreţeaua.7.

7.1.193.0 10.255. Să se proiecteze o reţea care să cuprindă trei situri Ethernet legate prin linii seriale. Reţeaua poate creşte până la un număr de maxim 100 de subreţele.0 10.248 să se specifice care sunt adresele IP asignabile în această subreţea.1. Având adresa IP 10.0.0.0 1111 1111 0000 0000 134.141.1.193.1. fiecare cu maximum 200 noduri.3.1.0 să se specifice care sunt subreţelele ce se pot forma. Adresa de subreţea este 193. iar cea de broadcast este 193.255.7.7.7.2.0 10.0 10.7.1.255.7. Adresele de IP asignabile se găsesc în intervalul 193.255.7.254.1. Având adresa IP 140.7.255.0. Adresele de IP asignabile se găsesc în intervalul: 140.1.11 1000 0110 0000 1011 255.1.255.5.0.1.0.255. Acest lucru implică faptul că octeţii 2 şi 3 sunt în întregime rezervaţi pentru identificarea subreţelelor.193.141.255.6.0.7 şi masca de reţea 255.1 .4. Adresa de subreţea este 140.0. Adresa este de clasă A. Se va folosi adresa de reţea 40 .140.255. iar cea de broadcast este 140.1 şi masca de reţea 255.0 1000 0110 0000 0000 134.1 . 5.255.0 7.0.Adresare IP Adresa: Masca de reţea: Rezultatul: Adresa de broadcast 134.5.0 să se specifice care sunt adresele IP asignabile în această subreţea. S1 S2 S3 S4 S5 S6 Sn 0000 1010 0000 0000 0000 0000 0000 0000 0000 1010 0000 0000 0000 0001 0000 0000 0000 1010 0000 0000 0000 0010 0000 0000 0000 1010 0000 0000 0000 0011 0000 0000 0000 1010 0000 0000 0000 0100 0000 0000 0000 1010 0000 0000 0000 0101 0000 0000 0000 1010 1111 1111 1111 1111 0000 0000 10.255 1000 0110 1111 1111 1000 1101 0000 0111 1111 1111 1111 1111 1000 1101 0000 0111 1000 1101 0000 0111 4.141.7. Având adresa IP 193.193.3 şi masca de reţea 255.0 10.193.118.0 10.1.255.193. 6.0.

16.254.0. Să se determine măştile de subreţea care îndeplinesc criteriile date. Acest bit a fost marcat cu X. Există două posibilităţi de mască de reţea: 255.255.0. Ruterul A Ruterul B Ruterul C Rezolvare Masca trebuie să aibă minim 8 biţi pentru host. ceea ce ar fi insuficient pentru a acoperi necesarul de 200 adrese.0 sau 255.0. Primii 16 biţi vor avea valoarea 1. deoarece adresa indicată este de clasă B. Numărul de subreţele necesar este 100.255. Vom continua pe primul model. Arhitectura este cea prezentată în figură. Dacă am avea 7 biţi pentru host ar însemna că am putea identifica 27 -2 (126) interfeţe. cât şi grupului de biţi care identifică hostul. deoarece 27 este cea mai mică putere a lui doi mai mare decât 100.Reţele de calculatoare 172. În concluzie masca de subreţea va avea următoarea formă: 11111111 11111111 1111111X 00000000 Biţi de reţea Numărul minim de biţi de subreţea Numărul minim de biţi de host Observăm că rămâne un bit care poate fi asignat atât grupului de biţi ce identifică subreţeaua. 41 .255. deoarece cel de-al doilea este mai simplu. ceea ce implică un număr minim de şapte biţi rezervaţi.

0 172.16. 172.3 (B) 172.2.16..Adresare IP Subreţelele ce se pot forma sunt: 172.0.16.255..10..4.0/23 Ruterul A Subreţeaua 172.0 Adresă subreţea 172.0.2 (B) şi 172..0.0 255.254...0 172.0/23 Ruterul C Subreţeaua 172.254.0/23 42 .16.3 172.10.16.254.0 255.16.10.2 172.255.16.254.10.4.0/23 Subreţeaua 172..0 255..1 (A) şi 172.6.16.0 Adresa IP router 172.0/23 Subreţeaua 172..16..252.1 (A) şi 172.16.254...4.6.8.0 Vom selecta primele şase subreţele aşa cum reiese şi din tabelul următor: Subreţea Router A Ethernet Router B Ethernet Router C Ethernet Linie serială A-B Linie serială A-C Linie serială C-B Mască de subreţea 255.16.0 172.16.16.0 172.16.255.16.2 (B) 172..8.2.0 .2.4..16.16.255..16.16.255.0 172.0.2.16.0 172..16.16..0..16.0 172.0/23 Ruterul B Subreţeaua 172.0 255.1 172.0 172.16.16.3 (C) Subreţeaua 172.16.255.254.8.0 255.254..6..8.

6 Comunicaţie client-server la nivel de socket
6.1 Introducere Vom prezenta o serie de aspecte generale: Protocoalele TPC/IP de nivel transport oferă servicii ce permit programelor nivelului aplicaţie să comunice între ele prin intermediul mesajelor. Când o aplicaţie trimite o cerere către nivelul transport pentru a trimite un mesaj, protocolul folosit la acest nivel: • împarte informaţia în pachete; • adaugă un antet de pachet care include adresa destinaţiei; • trimite informaţia nivelului reţea pentru procesare ulterioară. Transmisia şi recepţia datelor se realizează prin intermediul unor porturi de pe server, care identifică destinaţia specifică a mesajului. Nivelul transport este implementat în reţelele TCP/IP prin intermediul a două protocoale: • UDP (User Datagram Protocol) – protocol datagramă utilizator; • TCP (Transmission Control Protocol) – protocol de control al transmisiei. Caracteristici UDP: Asigură servicii de tip datagramă nivelului aplicaţie; Nu este fiabil (nu asigură certitudinea livrării datagramelor, nici mecanismele de protecţie la pierderea sau duplicarea datagramelor); Viteză mare de transmisie; Este un serviciu fără conexiune (emiţătorul nu cunoaşte starea receptorului în momentul transmisiei); Pentru transferul datelor foloseşte nişte entităţi abstracte, numite porturi de protocol, identificate prin numere întregi pozitive şi care au asociate nişte cozi de mesaje prin care se transmit mesajele; Se utilizează pentru mesaje mici (sub 8KB) cu viteză mare; 43

Comunicaţie client-server la nivel de socket

Antetul datagramei UDP conţine: • Source Port Number – adresa portului sursă; • Destination Port Number – adresa portului destinaţie; • Length – lungimea datagramei în bytes; • Checksum – suma de control asociată datagramei (foloseşte acelaşi algoritm ca la protocolul IP). Caracteristici TCP (Transmission Control Protocol): Este fiabil (asigură integritatea datelor transmise, mecanisme de protecţie la pierderea sau duplicarea pachetelor, păstrarea numărului de secvenţă, mecanisme de control al fluxului de date în reţea). Asigură transmisia blocurilor continue de date între porturile de protocol asociate aplicaţiilor. Dimensiunea mesajelor nu este limitată. Viteza de transfer mai mică. SO oferă programelor la nivel aplicaţie o interfaţă comună pentru aceste două protocoale, şi anume interfaţa socket.

6.2 Interfaţa Socket Este o interfaţă între un program de aplicaţie şi serviciul de transport (este un standard de facto), fiind furnizat de o bibliotecă socket sau de sistemul de operare. Se foloseşte conceptul de descriptor, fiecare socket fiind tratat asemănător cu un fişier local. Acest descriptor este transmis aplicaţiei la crearea socket-ului şi apoi este utilizat ca argument în apelurile următoare. Primitive de serviciu Socket API Tabel 6.1
Primitive socket(protofamily, type, protocol) close(socket) bind(socket, localaddr, addrlen) listen(socket,queuesize) newsock = accept(socket, caddress, caddresslen) connect(socket, saddress, saddresslen) Descriere creează un socket închide un socket leagă socket-ul cu un port pune socket în mod pasiv acceptă o cerere de conectare stabileşte legătura cu un server care a făcut accept

44

Reţele de calculatoare Primitive send(socket, data, length, flags) sendto(socket, length, flags, destaddress, addresslen) sendmsg(socket, msgstruct, flags) recv(socket, buffer, length, flags) recvfrom(socket, buffer, length, flags, sndaddr, saddrlen) rcvmsg(socket, msgstruct, flags) Descriere transmite un mesaj transmite un mesaj folosind un socket neconectat primeşte un mesaj primeşte un mesaj pe un socket neconectat

Proprietăţi ale socketurilor în Unix: inovaţie a sistemului Berkeley UNIX; este un punct de comunicaţie prin care un proces poate emite sau recepţiona informaţie sub forma unui flux de bytes; este identificat printr-un descriptor, asemănător cu cel pentru fişier realizează următoarele operaţii elementare: • conectarea la staţia de la distanţă • emiterea datelor • recepţionarea datelor • închiderea unei conexiuni • ataşarea la un port • aşteptarea cererilor de conexiune emise de staţiile de la distanţă • acceptarea cererilor de conexiune la portul local O aplicaţie de reţea include: un program client – care creează un socket pentru a iniţia o conexiune cu o aplicaţie server un program server – care aşteaptă preluarea cererilor clienţilor Structura generală folosită pentru lucrul cu socketuri este: struct sockaddr { unsigned short sa_family; char sa_data[14]; //14 bytes pentru adrese }

45

Structura sockaddr este una generică (o putem privi ca o clasă abstractă) menită a stoca informaţii de adresă pentru oricare tip de socketuri.Comunicaţie client-server la nivel de socket Membrii structurii sunt: sa_family identifică familia de adrese. sin_zero[8] se iniţializează cu 0. // }. sin_addr identifică adresa IP. struct sin_addr. struct in_addr *inp) 46 . unsigned short int sin_port. Valorile articolelor sin_port şi sin_addr trebuie să fie în forma big endian. Pentru acest lucru va trebui să se facă conversia între formatul little endian (host order) şi cel big endian (network order). O altă funcţie ce poate fi folosită în locul celei de mai sus este inet_aton() cu prototipul: int inet_addr(const char *cp. care converteşte adrese IP din forma zecimală grupată în cea de tipul unsigned long în formatul big endian. Pentru aceste conversii se vor utiliza funcţiile: htons() – “host to network short” htonl() – “host to network long” ntohs() – “network to host short” ntohl() – “network to host long” O altă funcţie utilă de conversie este inet_addr(). sin_port identifică portul. sa_data identifică adresa de socket compusă din numărul portului şi adresa IP. Structura ajută la referirea facilă a elementelor adresei de socket: struct sockaddr_in { short int sin_family. unsigned char sin_zero[8]. Membrii: sin_family corespunde câmpului sa_family din structura sockaddr. Pentru a lucra mai uşor cu structura de mai sus se foloseşte o nouă structură ajutătoare sockaddr_in.

sin_zero).sin_family = AF_INET. 2 1 0 . &(my_addr. folosind stiva de protocoale TCP/IP (domeniul Internet). ' \ 0 ' . De exemplu. my_addr. iar pentru cazul în 47 . orientată-conexiune prin flux de date) sau SOCK_DGRAM (fără conexiune prin datagrame). Tipul de socket utilizat: SOCK_STREAM (comunicarea se va realiza full-duplex.Reţele de calculatoare În cazul în care avem o structură in_addr şi dorim să afişăm adresa IP în format little-endian. int protocol). cum ar fi: AF_UNIX – stabileşte domeniul de comunicare locală UNIX sau AF_INET – utilizat pentru comunicaţii între procese aflate pe aceeaşi maşină sau pe maşini diferite. astfel: printf ("%s". local gazdei respective. pentru domeniul AF_INET şi tipul SOCK_STREAM se va considera protocolul de transport TCP. atunci putem folosi funcţia inet_ntoa(). 3 3 . Parametrii funcţiei: Domeniul de comunicaţie poate fi setat cu valori de tipul AF_ceva. inet_aton( " 2 1 . Se mai poate folosi şi constanta SOCK_RAW care oferă un acces la protocolul reţea (protocolul IP). memset(&(my_addr. int tip.sin_addr)).sin_addr)). Vom prezenta un exemplu de iniţializare a structurii sockaddr_in: struct sockaddr_in my_addr. denumit port. #include <sys/types. 8 ) . de nivel inferior. 5 4 " . Acesta poate fi setat pe “0” pentru ca funcţia să-şi poată alege protocolul corect automat. inet_ntoa(ina. în caz de eroare.h> int socket (int domeniu.sin_port = htons(MYPORT). Pentru exemplele curente vom utiliza cea de-a doua variantă. fiecare socket va avea asociată o adresă formată din adresa IP a maşinii gazdă şi un număr de 16 biţi. my_addr. În acest caz. Protocol specifică protocolul particular care va fi utilizat pentru transmisia datelor.h> #include <sys/socket. Funcţia socket() crează un socket şi returnează descriptorul de socket (valoare întreagă prin care se identifică un socket) sau –1. sigură.

Comunicaţie client-server la nivel de socket care domain este AF_INET şi tipul SOCK_DGRAM se va considera implicit protocolul de transport UDP.1 Comunicaţie client-server TCP/IP În figura 6. connect() pentru a conecta socket-ul la un server. 48 . socket() pentru a crea un socket.1 este prezentat modul de comunicaţie client-server TCP/IP.1 Cient-server TCP/IP Clientul apelează: gethostbyname() pentru a converti numele unui calculator în adresa IP.2. 6. getprotobyname () socket() bind() ge thostbyname() listen() ge tprotobyname() acce pt() socke t() stabilire conexiune conne ct() read() ce rere write() răspuns close() write () read() close () Figura 6. getprotobyname() pentru a converti numele unui protocol în forma binară folosită de sockets.

close() pentru a închide noul socket. int addrlen).h> #include <sys/socket. close() pentru a închide socket-ul. struct sockaddr *my_addr.h> int bind(int sockfd. send() pentru a trimite date.Reţele de calculatoare recv() (în mod repetat) pentru transferul tuturor datelor de la server (clientul nu are de unde şti dacă serverul transmite datele într-un singur mesaj sau în mai multe).h> #include <sys/types. Serverul apelează: getprotobyname() pentru a converti numele unui protocol în forma binară folosită de sockets.h> #include <sys/socket. de exemplu.h> #include <netinet/in. Primitiva bind() asignează socketul la portul maşinii la care. connect (3 way handshake) şi gethostbyname (conectare cu un server de nume). accept() pentru a accepta o cerere de conectare şi a crea un socket nou pentru această conexiune. serverul va asculta cereri de conexiune din partea clienţilor. socket() pentru a crea un socket. Primitivele blocante folosite sunt accept. Prototipul funcţiei este următorul: #include <sys/types.h> #define MYPORT 3490 main() 49 . bind() pentru a specifica portul local pentru socket. Parametri: sockfd este descriptorul de socket my_addr este un pointer la structura ce conţine informaţii referitoare la adresă addrlen poate fi setat la valoarea sizeof(struct sockaddr) Vom prezenta un model de folosire a funcţiei bind(): #include <string. listen() pentru a plasa socket-ul în modul pasiv. apoi în buclă.

.. 50 .. struct sockaddr *addr. int backlog).s_addr = inet_addr("10. Primitiva listen() are următoarea formă: int listen(int sockfd.. sizeof (struct sockaddr)) ... 0).. '\0'.sin_family = AF_INET.sin_port = htons(MYPORT).. socklen_t *addrlen). Primitiva accept() permite acceptarea propriu-zisă a conexiunilor: int accept(int sockd.sin_addr. serverul va trebui să aştepte viitoarele conexiuni de la diverşi clienţi şi să le rezolve cererile. (struct sockaddr *)&my_addr. 8)...57"). stabilindu-se astfel un canal de comunicaţie duplex între server şi client.. Pentru aceasta se utilizează primitiva listen() urmată apoi de accept(). addrlen stochează lungimea acestei structuri.110. my_addr. backlog reprezintă numărul maxim de conecţii permise în coada de aşteptare. Parametri: sockfd este descriptorul de socket addr va conţine informaţii despre adresa IP şi portul folosite de clientul conectat la server.. // iniţializare cu 0 a structurii bind(sockfd. // little endian my_addr. Acest nou descriptor va putea fi folosit pentru a trimite şi recepţiona date via reţea prin mijlocitori precum send() sau write() şi recv() sau read().. Apelul va returna un descriptor de socket corespunzător clientului a cărui conexiune a fost acceptată.Comunicaţie client-server la nivel de socket { int sockfd. } După ataşarea portului....12. memset(&(my_addr. sockfd = socket(AF_INET. SOCK_STREAM. . Parametri: sockfd este descriptorul de socket. struct sockaddr_in my_addr.sin_zero). // big endian my_addr.

int len. Primitivele close() şi shutdown() Primitiva close() va închide conecţia aferentă descriptorului de socket. iar errno descrie eroarea. Parametri: sockfd este descriptorul de socket. Primitiva shutdown() permite un control superior al procesului de închidere a socketurilor. Valoarea returnată este numărul de octeţi trimişi în caz de succes. int flags) Parametri: sockfd este descriptorul de socket msg reprezintă o zonă de memorie în care se află datele ce trebuie trimise len reprezintă lungimea datelor în octeţi flags este de obicei setat pe 0 Primitiva recv() întoarce numărul de octeţi recepţionaţi. unsigned int flags). len reprezintă mărimea acestor date în octeţi. Valoarea returnată este numărul de octeţi primiţi în caz de succes. iar errno descrie eroarea. Dacă eşuează. dacă datele recepţionate trebuie reţinute şi după ce sunt recepţionate. msg reprezintă o zonă de memorie în care se vor copia datele recepţionate. flags este de obicei 0 sau setat la valoarea MSG_PEEK. const void *msg. cât şi trimiterea. cel ce va încerca acest lucru va primi mesaj de eroare. opt poate lua valorile: 0 (interzice orice recepţie ulterioară). similar cu close()) 51 . este returnat -l. int opt). care uneori diferă de numărul de octeţi ce dorim să-i transmitem. int send(int sockfd. int len. 1 (interzice orice trimitere ulterioară). int recv (int sockfd. este returnat -l. 2 (interzice atât recepţia. void *buf. Astfel se va bloca orice read() or write() ulterior. Dacă eşuează.Reţele de calculatoare Primitiva send() întoarce numărul de octeţi transmişi. Funcţia are forma: int shutdown(int sockfd. Parametri: sockfd este descriptorul pentru socketul ce trebuie închis.

2 este prezentat modul de comunicaţie client-server UDP/IP. 6. întoarce numărul de octeţi trimişi şi are următorul prototip: int sendto(int sockfd. Pot fi utilizate şi primitivele generale send() şi recv(). int len.2 Client-server UDP/IP Mecanismul de lucru este următorul: Se crează un socket care va trata conexiunile cu clienţii. Primitiva sento() este folosită pentru trimiterea datagramelor.Comunicaţie client-server la nivel de socket Funcţia întoarce valoarea 0 în caz de success şi valoarea -1 în caz de eroare. socket() socket() bind() bind() cerere recvfrom() sendto() răspuns sendto() recvfrom() close() close() Figura 6. unsigned int flags. int tolen).2 Comunicaţie client-server UDP/IP În figura 6. const void *msg. Se ataşează socketul la port (bind()). const struct sockaddr *to. Sunt pregătite structurile de date (sockaddr_in) pentru a ataşa socketul la portul folosit de aplicaţie. 52 .2. Se închide socketul client (close()). Sunt procesate cererile clientului prin schimbul de mesaje între server şi client (sendto() şi recvfrom()).

h> #include <netinet/in. serverul va păstra evidenţa numărului de clienţi care au accesat resursa şi va raporta acest număr la fiecare apel. unsigned int flags.h> #include <sys/socket. int len.3 Exemplificări 1. fromlen va fi iniţializat cu valoarea sizeof(struct sockaddr) 6. len reprezintă lungimea datelor primite. tolen va fi iniţializat cu valoarea sizeof(struct sockaddr).h> #include <netdb. /* SERVER TCP */ #include <sys/types. întoarce numărul de octeţi recepţionaţi şi are următorul prototip: int recvfrom(int sockfd.h> #include <stdio.h> 53 . Să se construiască un server şi un client TCP/IP. msg reprezintă o zonă de memorie în care se află datele ce trebuie trimise. int *fromlen). to reprezintă un pointer la o structură de tip sockaddr şi conţine adresa de IP şi portul destinaţiei. void *buf. from reprezintă un pointer la o structură de tip sockaddr şi conţine adresa de IP şi portul sursei. flags va fi iniţializat cu 0. flags va fi iniţializat cu 0 len reprezintă lungimea datelor ce vor fi trimise. În exemplu. msg reprezintă o zonă de memorie în care se află datele ce sunt primite.Reţele de calculatoare Parametrii funcţiei: sockfd este descriptorul de socket.h> #include <errno. struct sockaddr *from. Parametrii funcţiei: sockfd este descriptorul de socket. Primitiva recfrom() este folosită pentru recepţionarea datagramelor.

if(argc!= 2) { printf("Apel: %s port \n". sizeof(server)) <0) { perror("Eroare la obţinerea adresei"). } 54 . argv[0]). struct sockaddr_in client. &server. 32)) perror("Eroare la preluarea numelui serverului"). /* portul client */ char buffer[32]. exit(3). exit(1).s_addr = inet_addr("193.226. rc. int s. 0)) <0) { perror("Eroare la creare socket").sin_addr.34.61"). /*Creeaza un socket*/ if ((s=socket(AF_INET. AF_INET*/ server.Comunicaţie client-server la nivel de socket main(int argc. /*adresele client. ns. server. namelen. } /*Asociază socketului o adresă de server */ memset(&server. char ** argv) { unsigned short port. server. server.sin_port = htons(port). /*AF_UNIX. } /*preia numele calculatorului local */ if(gethostname(buffer. /*preia informatiile despre configurarea hostului*/ if (!(srvinfo=gethostbyname(buffer))) perror("Eroare la preluarea informatiilor despre server"). sizeof(server)). server*/ struct hostent * srvinfo. /* adresa Internet locala */ if ( bind ( s. SOCK_STREAM. buffer). port=(unsigned short) atoi(argv[1]).sin_family = AF_INET. printf("Nume server: %s \n". 0. exit(4).

comunicaţia serverclient */ namelen = sizeof(client). close(s). /*Trasmite confirmarea clientului */ if (send(ns. &client. buffer). exit(0). restul fiind refuzate */ if (listen(s. exit(6). } 55 . pe TCP: %s\n". buffer.Reţele de calculatoare /*Creează coadă pentru cererile de conexiune. if ((ns = accept( s. 0) <0) { perror("Eroare la transmisie"). strlen(buffer). va prelua maxim 5 cereri de conexiune de la clienţi. exit(7). exit(8). 32. } endhostent(). buffer. 5) != 0) { perror("Eroare la obţinerea cozii de cereri"). /* închide sesiunea TCP/IP */ close(ns). } /* Afişează mesajul primit de la client */ printf("Mesaj recepţionat de la client. } /* Creează un descriptor de socket pentru. exit(5). &namelen)) == -1) { perror("Eroare la acceptarea conexiunii"). 0) == -1) { perror ("Eroare la recepţie"). } /* Recepţionează mesajul de la client */ if(recv(ns.

} /*preia numele calculatorului local */ if (!(hostnm=(struct hostent *) gethostbyname(argv[1]))) { perror("Eroare la preluarea numelui serverului"). AF_INET*/ server. strcpy(buffer. exit(3).h> #include <sys/types. if (argc != 3) { printf("Apel: %s hostname port \n".h> #include <sys/socket.61"). struct sockaddr_in server.s_addr = inet_addr("193.sin_family = AF_INET.. port = (unsigned short)atoi(argv[2]). /*preia informaţiile despre server*/ server.sin_port = htons(port). /* aceeaşi ca la server */ 56 .Comunicaţie client-server la nivel de socket /* CLIENT TCP */ #include <stdio.sin_addr. rc. argv[0]). "Mesaj transferat prin socket. /*informaţii server */ int s.226.34. pe TCP"). /*AF_UNIX... \n").h> #include <netinet/in. } printf("A preluat numele de server. /*adresă server*/ struct hostent * hostnm.h> #include <netdb. acelaşi ca cel specificat în modulul server */ char buffer[32]. char ** argv) { unsigned short port. exit(1). server.h> main (int argc.h> #include <errno. /* portul client.

despre server. } 57 .. exit(7). } printf("A transmis mesajul.Reţele de calculatoare printf("A preluat inf. 0) < 0) { perror("Eroare la transmisie"). buffer. &server. if (connect(s. sizeof(server)) < 0) { perror("Eroare la obţinerea conexiunii").. /* Transmite mesajul serverului */ if (send(s.. } printf("A realizat conexiunea.\n"). buffer. } printf("Confirmarea de la server a fost făcută.\n"). exit(0)..SOCK_STREAM. close(s). } printf("A creat socket-ul.... strlen(buffer). exit(6)..... /* Confirmare de la server */ if (recv(s.. exit(4).0)) < 0) { perror("Eroare la creare socket")..... 0) < 0) { perror("Eroare la recepţie").. 32.\n"). if ((s = socket(AF_INET.\n"). \n"). exit(5).

Comunicaţie client-server la nivel de socket 2.sin_family = AF_INET. &namelen)) 58 .\n").h> #include <stdio. exit(2). /*adresele client. server.. /* orice port */ server.s_addr = INADDR_ANY. Să se construiască o aplicaţie server şi una client care să comunice prin datagrame.. } printf("S-a alocat o adresă .sin_addr.h> #include <netdb. /*Creează un socket*/ if ((s=socket(AF_INET. server. /* Modul SERVER UDP */ #include <sys/types. if ( bind( s.h> #include <sys/socket.. (struct sockaddr *) &server. 0. if (getsockname(s.. AF_INET*/ server. struct sockaddr_in client.\n").sin_port = 0. 0)) <0) { perror("Eroare la creare socket"). namelen. exit(1). sizeof(server)). } printf("A creat socket-ul. SOCK_DGRAM.. rc. /* Determină portul asignat*/ namelen = sizeof(server).. /*Asociază socketului o adresă de server */ memset(&server. &server.h> main() { char buffer[32].h> #include <errno.. server*/ int s. /*AF_UNIX. sizeof(server)) <0) { perror("Eroare la obţinerea adresei").

32.h> #include <sys/socket.sin_port). endhostent (). } printf("\n Portul asignat este: %d\n". ntohs(client. ntohs(server. /* Afişează mesajul primit de la client */ printf("\n Mesajul recepţionat de la client este: %s\n". } printf("A recepţionat mesajul de la client. \n"). inet_ntoa(client.h> #include <netinet/in. buffer.h> #include <errno. 0. exit(4).. sizeof(client)) < 0) { perror ("Eroare la recepţie"). exit(0). char ** argv) { 59 .sin_family == AF_INET? \Internet: %s "AF_INET":"AF_UNIX"). namelen = sizeof(client). printf("Parametrii: \n Nume domeniu: %s \n \Port: %d \n Adresa \n". buffer). &client.sin_port)). /* închide sesiunea UDP/IP */ close(s).h> #include <stdio.h> main(int argc. (client.sin_addr)). exit(3). /* Recepţioneaza mesajul de la client */ if (recvfrom ( s.h> #include <netdb...Reţele de calculatoare { perror("Eroare la determinarea portului"). } /* Modul CLIENT UDP */ /* Modul CLIENT UDP */ #include <sys/types.

/* portul client.34.226.61"). /*AF_UNIX. AF_INET*/ server. struct sockaddr_in server. sizeof(server)) < 0) { perror ("Eroare la transmisie"). } port=(unsigned short) atoi(argv[1]). } 60 . 0. strcpy(buffer.sin_port = htons(port).s_addr = inet_addr("193.sin_addr. pe UDP"). rc. if(argc!= 2) { printf("Apel: %s port \n". /*adresă server*/ int s. "Mesaj transferat prin socket.Comunicaţie client-server la nivel de socket unsigned short port. SOCK_DGRAM. strlen(buffer)+1. } /* Transmite mesajul serverului */ if(sendto(s.sin_family = AF_INET. /* aceeasi ca la server */ if ((s=socket(AF_INET. acelaşi ca cel specificat în modulul server */ char buffer[32]. /*preia informaţiile despre server*/ server. 0)) <0) { perror("Eroare la creare socket"). exit(1). server. exit(2). &server. exit(0). } close(s). buffer. exit(3). argv[0]).

h> #include <sys/socket. } } /* întoarce 0 dacă nu e prim.h> #include <stdlib. Se crează astfel un proces copil care va servi un anumit client.h> #include <netinet/in. i altfel */ int e_prim (int i) { int k. /* descriptor pentru client */ int nr = 0. care aşteaptă un număr N de la un client şi returnează lista numerelor prime mai mici decât N. nr--. Rezolvarea servirii concurente a mai multor clienţi se va face folosind apelul fork().h> #include <signal. extern int errno. Să se construiască o aplicaţie de tip server stream (TCP) concurent. /* am pierdut un client */ return. /* eroarea returnată */ int ds.h> #include <error.h> #include <string.Reţele de calculatoare 3. /* numarul maxim de clienţi acceptaţi */ const int CLIENTI_MAXIM = 10. /* numărul de clienţi */ void semnal (int nr_semnal) /* funcţia de tratare a semnalelor */ { if (nr_semnal == SIGCHLD) { wait (NULL). #include <sys/types.h> #include <unistd. /* descriptor pentru server */ int dc. 61 .h> /* portul folosit */ const int PORT_SERVER = 9001.

2). aux. exit (errno). aux. /* citeşte numarul sub forma de şir de caractere */ if (read (dc. strlen (aux))!=strlen (aux)) { shutdown (dc. buffer.Comunicaţie client-server la nivel de socket for (k = 2. for (k = 2. strlen (aux))!=strlen (aux)) { shutdown (dc. if (write (dc. 2). 2). k++) if ((i%k) == 0) return 0. /* eroare. char aux[100]. k < număr. strlen (aux))!=strlen (aux)) { shutdown (dc. 100). k * k <= i. "Daţi numărul:"). if (write (dc.t. } bzero (buffer. sprintf (aux. int numar. k. k++) if (e_prim (k)) { sprintf (aux. "Număr prim: %d\n". } /* din şir de caractere în întreg */ număr = atoi (buffer). int i. return 1. } 62 ."Eşti clientul numărul: %d\n". 2). if (write (dc. exit (errno).nr). 100) == 0) { shutdown (dc. exit (errno). } void client () /* funcţia de tratare a clientului */ { char buffer[100]. aux. am ieşit */ exit (errno). k). } sprintf (aux.

5) == -1) { perror ("listen() ") . return errno. sizeof (server)). } 63 . return errno. &server. semnal) == SIG_ERR) { perror ("signal()") . } if (listen (ds. } /* programul principal */ int main () { struct sockaddr_in server. } /* pregătim structurile de date */ bzero (&server. /* tratăm semnalele */ if (signal (SIGCHLD. SOCK_STREAM. 2).Reţele de calculatoare } shutdown (dc.sin_port = htons (PORT_SERVER). server. SIG_IGN) == SIG_ERR) { perror ("signal()"). server.addr.sin. return errno.s_addr = htonl (INADDR_ANY). server. /* ataşăm la port */ if (bind (ds. exit (errno). 0)) == -1) { perror ("socket() ") . exit (errno). } if (signal (SIGPIPE. } /* creăm socket-ul */ if ((ds = socket (AF_INET. exit (errno). sizeof (server)) == -1) { perror ("bind()").sin_family = AF_INET.

default: break. /* am ajuns la numărul maxim de clienţi? */ if (nr == CLIENTI_MAXIM) { shutdown (dc.Comunicaţie client-server la nivel de socket printf ("Aşteptăm clienţi la portul %d. while (1) { /* acceptăm un client */ dc = accept (ds. case -1: perror ("fork()").\n". } /* lansăm un proces care tratează cererile clientului */ switch (fork ()) { case 0: client ()... NULL). PORT_SERVER) . } nr++. /* a mai venit un client */ } } 64 . NULL. continue. 2) . break.

Intenţia platformei Java a fost să ofere suport pentru aplicaţiile scrise în limbajul Java şi compilate în cod de octeţi Java. suportul pentru standarde deschise. oferind limbaje compilate în cod intermediar împreună cu o bogată colecţie de interfeţe de programare pentru dezvoltarea aplicaţiilor. robusteţea şi scalabilitatea aplicaţiilor pe ansamblu. nivelul logicii aplicaţiei şi nivelul de prezentare prin care aplicaţia este accesată de către utilizatori. Globalizarea la nivel microeconomic a activităţii a transformat treptat modelul de prelucare client-server specific primelor aplicaţii de reţea. un mediu de dezvoltare care oferă suport pentru mai multe limbaje de programare standardizate sau proprietate Microsoft — Visual Studio . ambele constituie o abordare structurată pentru crearea aplicaţiilor distribuite. Jython fiind doar un exemplu 65 .NET Framework — Windows Server. cel mai simplu incluzând nivelul de acces la date. ele au rămas doar în sfera limbajelor formale.NET este soluţia propusă de Microsoft pentru programarea aplicaţiilor distribuite în Internet. sistemul de operare care oferă suport pentru aplicaţiile distribuite dezvoltate pe platforma .NET Framework. într-un model bazat pe niveluri de servicii. securitatea integrată. . distribuirea prelucrărilor. fiind identificată prin următoarele trei componente esenţiale: un mediu de execuţie independent de limbaj optimizat pentru prelucrări distribuite — .NET a avut în vedere asigurarea următoarelor deziderate: programarea independentă de limbaj. mentenabilitatea.7 Implementarea aplicaţiilor distribuite pe platformele .NET este similară platformei J2EE. . Viziunea care a stat la baza iniţiativei . uşurinţa implementării.NET şi J2EE Aplicaţiile economice vehiculează un volum mare de date care trebuie prelucrate în vedere obţinerii de informaţii necesare pentru fundamentarea procesului decizional.NET. facilităţi de depanare avansate. Chiar dacă au existat încercări de a porta şi alte limbaje pe platforma JVM.

. precum WebLogic de la BEA. pentru aplicaţii de întreprindere.NET.. Enterprise 66 .NET. plecând de la ideea: o singură platformă pe care pot rula mai multe limbaje. J#. platforma . pentru programarea de platformă şi în reţea. Linux. cât şi platformă pentru dezvoltarea aplicaţiilor distribuite. Firma Sun Microsystems a dezvoltat Java atât ca limbaj. Platforma J2EE dispune atât de implementări comerciale. iPlanet şi SunONE Application Server de la Sun. Încă de la început Java a fost proiectată să lucreze cu un număr mare de sisteme de operare. Spre deosebire de J2EE. suportul pentru limbajele de programare. permiţând dezvoltatorilor să creeze aplicaţii distribuite pe mai multe niveluri. Pascal (Delphi). existând însă încercări de portare a mediului de execuţie şi pe Linux. Pentru implementarea aplicaţiilor distribuite este nevoie de servere de aplicaţii pentru publicarea componentelor care înglobează logica aplicaţiei.NET se concretizează în: suportul pentru sisteme de operare. MacOS. existând în prezent trei ediţii ale platformei Java: J2SE (Java 2 Standard Edition). Paltforma . J2EE este un set de specificaţii standardizate şi nu un produs.NET a fost gândită să ruleze doar pe Windows. proiectele de tip Open Source. rulând în prezent pe platforme: Windows. Diferenţele fundamentale între J2EE şi .NET. J2EE (Java 2 Enterprise Edition). metoda de execuţie. Spre deosebire de . precum Mono şi Rotor oferind suport pentru majoritatea interfeţelor de programare din . Spre deosebire de J2EE. J2ME (Java 2 Micro Edition).NET şi J2EE didactic de portare a limbajului de scripting Python pe JVM. C++ Managed. sau chiar Java prin IkVm şi Mono.NET prin intermediul căruia se pot publica şi executa servicii Web scrise în limbaje compilabile pe CRL (Common Language Runtime) în MSIL (Microsoft Intermediate Language). BeOS.Implementarea aplicaţiilor distribuite pe platformele . şi asta pentru că ideea platformei Java a fost mereu una simplă şi eficientă: un singur limbaj care să ruleze pe mai multe sisteme de operare.NET oferă suport pentru mai multe limbaje de programare compilate în Microsoft Intermediate Language (MSIL). UNIX. WebSphere Application Server de la IBM. pentru dispozitive mobile.NET oferă IIS cu ASP. Visual Basic . cum sunt C#. Perl etc.

actualmente oferită de WebMethods. o interfaţă de programare pentru care există drivere de conectare la aproape orice bază de date relaţională sau sistem de fişiere. pentru a putea găzdui servicii Web. cele mai folosite fiind Tomcat.dll sau Apache cu modul dedicat ASP. Sybase. IBM DB2. precum Axis şi SOAP de la Apache. precum şi la MySQL sau PostGre SQL. Platforma J2EE oferă două tehnologii: servlet şi JSP. necesită. iniţial dezvoltată de The Mind Electric.. aplicaţiile distribuite fac apel la servere de baze de date relaţionale. un mediu de procesare a mesajelor SOAP şi de gestiune a componentelor de serviciu. sau Glue. MS Access. Access. Se execută atât pe servere Web.NET.NET oferă ActiveX Database Objects . MS SQL Server 2000.NET. cât şi pe servere de aplicaţii J2EE amintite la nivelul logicii aplicaţiei. Platform . Pentru accesul la date. incluzând Oracle Database Server. IBM DB2. Acestea sunt servere de componente EJB (Enterprise Java Beans). Necesită IIS cu modul ISAPI ASPNET. cărora li s-a adăugat recent JSF (Java Server Faces). Platforma J2EE dispune de Java Database Connectivity (JDBC). prin interfeţe de programare specifice.NET oferă ASP. Web Services Developement Kit (WSDK) de la Sun şi omonimul său de la IBM. dar şi la Oracle Database Server. În J2EE există mai multe implementări SOAP. MSDE. 67 . Orion sau Jetty.Reţele de calculatoare Server de la Borland etc. MSDE. prin intermediul căreia se poate conecta la server Microsoft precum SQL Server 2000 (sau Yukon în curând). PostGre SQL etc. o tehnologie echivalentă cu ASP.NET (ADO. Pentru clienţi Web este nevoie de servere Web cu suport dedicat tehnologiilor specifice. precum şi de implementări Open Source cum sunt JBoss sau JOnAs. permiţând o mai bună încapsulare a codului în executabile binare interpretabile pe CLR. care. MySQL. o tehnologie dezvoltată din ASP în sensul separării procesărilor pe server de formatarea HTML a rezultatului. ca şi IIS-ul.NET).NET. astfel: Platforma .

Procedurile stocate sunt disponibile pentru administrarea SQL Server şi afişarea informaţiilor despre baze de date şi utilizatori.Implementarea aplicaţiilor distribuite pe platformele . Caracteristicile pentru a aduce pe Web aplicaţiile noi şi existente sunt incluse cu suport XML şi acces HTTP. Procedurile stocate sunt o colecţie de declaraţii precompilate stocate sub un nume şi procesate ca o unitate.1 Nivelul de acces la date 7. de afaceri şi de depozitare a datelor.1 Apelarea procedurilor stocate pe SQL Server Microsoft SQL Server 2000 reduce vizibil timpul necesar pentru a construi soluţii bazate pe Web. SQL Server 2000 este optimizat pentru a fi folosit cu Windows 2000 şi este proiectat pentru a creşte o dată cu afacerea dumneavoastră. Avantajele folosirii procedurilor stocate în SQL Server în locul programelor Transact-SQL stocate local în sistemele client sunt: permit programarea modulară: procedura poate fi creată doar o singură dată. auto-gestionare şi adaptare dinamică. stocată în baza de date şi chemată ori de câte ori este nevoie în program. Procedurile stocate instalate o dată cu SQL Server se numesc proceduri stocate de sistem. automatizând în acelaşi timp sarcinile de gestionare şi adaptare. conţină declaraţii care să îndeplinească operaţiuni în baza de date. servicii de analiză integrate şi migrarea şi transformarea simplificată a datelor. Procedurile stocate sunt diferite de funcţii deoarece nu pot returna valori în locul numelui lor şi nu pot fi folosite direct într-o expresie. Manipularea şi execuţia procedurilor stocate se poate realiza în două moduri: prin stocarea locală a programelor şi crearea aplicaţiilor care să trimită comezile către SQL Server şi să proceseze rezultatele. limbajul de programare Transact-SQL (TSQL) este interfaţa primară de programare între aplicaţie şi baza de date SQL Server. Procedurile stocate pot fi create de o persoană 68 . prin stocarea programelor ca proceduri stocate în SQL Server şi crearea aplicaţiilor care să execute aceste proceduri şi să proceseze rezultatele. Când se creează o aplicaţie cu SQL Server.1.NET şi J2EE 7. inclusiv să cheme alte proceduri. Alte caracteristici includ capacitatea de căutare de text în bazele de date şi formate de documente cunoscute. Procedurile stocate din SQL Server sunt similare procedurilor din alte limbaje deoarece pot să: primească parametri introduşi şi să returneze valori multiple sub forma parametrilor de ieşire. Se poate folosi declaraţia EXECUTE pentru a rula o procedură stocată.

CommandType = CommandType.sqlCommand. ((byte)(0)). în cazul unei proceduri stocate care selectează date din mai multe tabele prin intermediul unui adapter trebuie mapate colecţiile extrase din bază peste tabelele DataSet-ului destinaţie: this.Connection = this.StoredProcedure. this.sqlCommand. "Products").SelectCommand = this.Reţele de calculatoare specializată în programarea bazelor de date şi pot fi modificate independent de codul sursă al programului care le foloseşte. false.sqlCommand. this. this.CommandText = "dbo.Add("data".Add("data3". this.Int. "Producers").TableMappings. this. Products. "Categories").Add("data2". procedurile stocate pot fi mai rapide decât codul Transact-SQL de la client. respectiv CommandText ca fiind numele procedurii stocate din spaţiul rolului conexiunii deschise. Pentru apelarea unei proceduri stocate. 4.sqlDataAdapter. permit rularea mai rapidă: dacă operaţiunea cere o cantitate mare de cod Transact-SQL sau este rulat în mod repetat. this.sqlConnection.TableMappings.sqlDataAdapter. clientul ADO. ((byte)(0)).Current.ReturnValue. procedura stocată selectează datele astfel: CREATE AS SELECT SELECT SELECT SELECT RETURN PROCEDURE dbo. SqlDbType.sqlDataAdapter.getProducts * * * * FROM FROM FROM FROM Categories. permit reducerea traficului pe reţea: o operaţiune care cere sute de linii de cod Transact-SQL poate fi executată printr-o singură declaraţie care execută codul în cadrul unei proceduri.Add(new SqlParameter("@RETURN_VALUE". ParameterDirection. Ele sunt analizate şi optimizate în momentul creării lor şi versiunea in-memory a procedurii poate fi folosită după ce este executată pentru prima dată.NET pentru SQL Server oferă obiectul SqlCommand pentru care se setează proprietatea CommandType la valoarea StoredProcedure.sqlDataAdapter. this.sqlCommand = new SqlCommand(). "". null)).sqlCommand.TableMappings. Stock.Parameters. "Stock"). astfel: this. Producers. DataRowVersion.TableMappings. 69 .sqlDataAdapter. decât să se trimită sute de linii de cod pe reţea.Add("data1".[getProducts]".sqlCommand. this.

public class Student implements Serializable { public int StudentId. public String Name. int port. import java. "data").Connection.util.database. public void open(String host. import java.Fill(dataSet. String password) throws SQLException.database. this. import java.NET şi J2EE apelul selecţiei datelor cu ajutorul adapter-ului presupune denumirea tabelei origine ale cărei mapări duc datele în tabele ale DataSet-ului: DataSet dataSet = new DataSet().SQLException.ResultSet.Serializable.sql.storedprocedure. public String FirstName.sql. ClassNotFoundException { Class.SQLServerDri ver").ForName("com.sql. this.Vector. import java.jdbc.DriverManager.sql.sqlserver. public short Version. import java. String user. public short Version. public class DataAccessor { private Connection connection. import java.io.connection = DriverManager. } Accesor package tutorials. String database. Obiecte Java package tutorials. public class Group implements Serializable { public int GroupId.microsoft.sql. import java.sqlDataAdapter.Implementarea aplicaţiilor distribuite pe platformele . } package tutorials.getConnection( 70 .CallableStatement. public String LastName.database.storedprocedure.Serializable. JDBC oferă obiectul CallableStatement prin intermediul căruia se pot apela proceduri stocate.io. import java.storedprocedure.

group. Vector vector = new Vector().next()) { Student student = new Student(). student. student.LastName = results. } } 7. platforma .NET permite accesul la baze de date prin interfaţa ADO. } public Group[] getGroups() throws SQLException { Vector vector = new Vector(). group.executeQuery().connection.getString(2). student.Version = results.setInt(1.2 Virtualizarea accesului la baza de date Platforma . while(results != null && results.DatabaseName=" + database + ". vector. } public void close() throws SQLException { this. } return (Student[]) vector.Password=" + password + ".Version = results.getInt(1). statement.1.add(student). oferind mecanisme de acces bazate pe conexiune activă sau deconectate.GroupId = results.toArray().0 căruia i s-a 71 .").Reţele de calculatoare "jdbc:microsoft:sqlserver://" + host + ":" + port + ". student. } public Student[] getStudentsByGroup(int groupId) throws SQLException { CallableStatement statement = this.User="+ user + ". În privinţa suportului nativ pentru conectarea la diferite servere.getString(3).connection.toArray(). CallableStatement statement = this.getShort(3).close(). groupId).getInt(1).NET oferă suport pentru SQL Server chiar de la versiunea 1.getShort(4). group.Name = results.prepareCall("call GetGroups()").FirstName = results. ResultSet results = statement. ResultSet results = statement.next()) { Group group = new Group(). while(results != null && results.NET.StudentId = results.getString(2). } return (Group[]) vector.prepareCall("call GetStudentsByGroup(?)").executeQuery().connection.

string table).NET clasele de acces la date se găsesc în pachete diferite şi au tipuri diferite. object ExecuteScalar(string statement). implementări care fac apel la pachetele şi clasele provider-ului respectiv. Pentru ca aceeaşi aplicaţie să se poată conecta la mai multe servere de baze de date este necesară virtualizarea accesului la baza de date prin implementarea unui mecanism de fabrică de obiecte care să asigure legarea implementării specifice bazei de date utilizate.NET au signaturi de pachete diferite. string user. } string Database { get. Prin intermediul signaturii comune a metodelor interfeţei ADO.Implementarea aplicaţiilor distribuite pe platformele . string Provider { get.NET care reuneşte funcţii pentru operaţiile cu baza de date. este necesară definirea unei interfeţe deoarece clasele oferite de către provider-ii ADO. restul serverelor fiind suportate prin intermediul provider-ilor oferiţi de diferite organizaţii. este totuşi posibilă definirea unei interfeţe de acces la date. Dacă în cazul punţii JDBC diferă doar protocolul de conectare în funcţie de server. ce urmează a avea implementări specifice fiecărui provider. string database. ceea ce face imposibilă legarea directă la metodele acestora. cel mai cunoscut fiind ByteFX.NET pe care fiecare clasă de acces o implementează. se defineşte o interfaţă peste ADO. restul metodelor fiind comune. pentru accesul la MySQL există mai mulţi provider-i comerciali cât şi Open Source. Spre exemplu.NET şi J2EE adăugat suportul pentru Oracle în versiunea 1.Database { internal interface IDatabaseConnection { void Open(string host. System. ceea ce face imposibilă instanţierea lor pentru acelaşi tip de bază: namespace Tutorials. void Close().Data. } } } 72 .DataSet ExecuteQuery(string statement.1. string password). pe platforma . int ExecuteNonQuery(string statement).

} public int ExecuteNonQuery(string statement) { return new System.Database { internal class SQLServerDatabaseConnection: IDatabaseConnection { private System. public SQLServerDatabaseConnection() { } public void Open(string host.Data. private string database.SqlClient.Data. string database. } public System.connection).SqlDataAdapter(statement.SqlClient.DataSet dataSet = new System. new System.SqlCommand(statement.SqlClient.Data.SqlConnection connection.SqlClient. } public void Close() 73 . string table) { System. database = " + database + ".connection).Data. string password) { this.Fill(dataSet.Data.SqlConnection("data source = " + host + ".NET specific: Clasă de acces la SQL Server 2000 namespace Tutorials. table).connection = new System.connection). return dataSet.DataSet ExecuteQuery(string statement.DataSet(). this. this.SqlClient.SqlCommand(statement. string user.Data.Open().Reţele de calculatoare se implementează interfaţa pentru fiecare server de baze de date utilizând clasele provider-ului ADO.Data.connection. } public object ExecuteScalar(string statement) { return new System.ExecuteScalar(). this.ExecuteNonQuery().Data. password = " + password). this. user id = " + user + ".

connection!=null) this. user id = " + user + ".Close().Data.Data.connection. } public System. password = " + password). private string database. } } public string Database { get { return this.DataSet().Data. database = " + database + ".OracleConnection("data source = " + host + ". this. } } Clasă de acces la Oracle namespace Tutorials. } } } public string Provider { get { return "SQLServer". string user.Implementarea aplicaţiilor distribuite pe platformele .Data.DataSet dataSet=new System.OracleClient.OracleClient. public OracleDatabaseConnection() { } public void Open(string host.NET şi J2EE { if(this.Data.Open().OracleConnection connection. string table) { System.Database { internal class OracleDatabaseConnection: IDatabaseConnection { private System.database. string database.connection = new System.connection. 74 . string password) { this.DataSet ExecuteQuery(string statement.

connection!=null) this. this.OracleDataAdapter(statement.connection). this.Fill(dataSet.OracleCommand(statement.OracleClient. } public int ExecuteNonQuery(string statement) { return new System.Reţele de calculatoare new System. table).MySqlConnection connection.connection).Data. } public void Close() { if(this. private string database. 75 . this.ExecuteNonQuery().OracleClient.MySqlClient. } public object ExecuteScalar(string statement) { return new System.OracleCommand(statement.database.Data.Data. } } public string Database { get { return this. } public string Provider { get { return "Oracle".Data.connection.OracleClient.ExecuteScalar(). } } } } Clasă de access la MySQL namespace Tutorials.Close().Database { internal class MySQLDatabaseConnection: IDatabaseConnection { private ByteFX.connection). return dataSet.

Open().database = database.connection). table).connection != null) this. return dataSet.Data. string password) { this.MySqlDataAdapter(statement.ExecuteScalar().NET şi J2EE public MySQLDatabaseConnection() { } public void Open(string host.password = "+password). this.connection = new ByteFX. } public void Close() { if(this.connection).Data.connection. } public string Provider { get { return "MySQL". this. this. new ByteFX.Close().database = "+database+".DataSet(). } public System.MySqlCommand(statement.this.ExecuteNonQuery().connec tion). } public int ExecuteNonQuery(string statement) { return new ByteFX. string database.Data.DataSet ExecuteQuery(string statement.Data.connection.string table) { System.Data.MySqlClient. } public object ExecuteScalar(string statement) { return new ByteFX.MySqlCommand(statement. this.MySqlClient.MySqlClient.MySqlConnection(" data source = "+host+".DataSet dataSet=new System.Implementarea aplicaţiilor distribuite pe platformele .Fill(dataSet.Data. } } public string Database { get 76 .MySqlClient.Data. string user.user id = "+user+".

default: this. case Providers. public void Open(Providers provider. SqlServer. } public System. break. } if(this.Data. case Providers. break.MySql: this. user. break.Database { public enum Providers{Oracle.databaseConnection = new SQLServerDatabaseConnection(). string database.databaseConnection != null) this. string host. string user. MySql} public class DatabaseConnection { private IDatabaseConnection databaseConnection = null. string table) { 77 . password).databaseConnection = new MySQLDatabaseConnection().databaseConnection = null.Oracle: this.database. } } se construieşte o clasă fabrică de obiecte care instanţiază implementarea interfeţei de acces la baza de date specifică unui anumit server: Clasă fabrică de conexiune la o anumită bază de date using System.Open(host. string password) { switch(provider) { case Providers.databaseConnection = new OracleDatabaseConnection().Reţele de calculatoare { } } return this.DataSet ExecuteQuery(string statement. database.SqlServer: this. namespace Tutorials.databaseConnection.

ExecuteQuery(statement.NET şi J2EE return this. Totuşi.databaseConnection = null. } } } } Spre deosebire de soluţia ADO.databaseConnection != null ? this.databaseConnection != null. JDBC oferă o interfaţă unitară de acces.databaseConnection != null) { this.databaseConnection. } } public string Provider { get { return this.databaseConnection != null ? this.Provider : null. crearea unei conexiuni este specifică fiecărui provider prin driverul şi protocolul de acces aferente. this. } public int ExecuteNonQuery(string statement) { return this. ceea ce impune definirea unei clase abstracte având o singură metodă abstractă care creează o conexiune la baza de date. table) : null.databaseConnection != null ? this.NET în care fiecare provider oferă drivere având signaturi de pachet diferite şi deci incompatibile ca tip de dată.Implementarea aplicaţiilor distribuite pe platformele .databaseConnection. 78 .Close().ExecuteNonQuery(statement) : -1. } public object ExecuteScalar(string statement) { return this. ceea ce facilitează implementarea unei clase unice de acces la diferite baze de date.databaseConnection.databaseConnection. } } public bool IsOpened { get { return this.databaseConnection. } public void Close() { if(this.databaseConnection != null ? this. restul metodelor apelând interfaţa JDBC.ExecuteScalar(statement) : null.

executeQuery(s tatement).createStatement()).Reţele de calculatoare se defineşte o clasă abstractă care va conţine metoda abstractă de conectare şi implementarea comună a metodelor de acces la date. int port.SQLException { return(this. } public boolean executeInsert(String statement) throws java.SQLException { return(this.sql. public void close()throws java. String user.sql.connection.sql. protected String database.sql.createStatement()).sql.execute(statem ent).SQLException.createStatement()).sql.close().SQLException { this. protected int port.connection. protected java. } public boolean executeDelete(String statement) throws java. } public java.lang. } } pentru conectarea la un anumit server se extinde clasa abstractă prin implementarea metodei de conectare. clasa derivată va arăta astfel: public class MySQLDatabaseConnection extends DatabaseConnection { public MySQLDatabaseConnection() { } 79 .execute(statem ent).execute(statem ent).SQLException { return(this. } public boolean executeUpdate(String statement) throws java.connection.connection.Connection connection.sql. protected String user. de forma: public abstract class DatabaseConnection { protected String host. String password) throws java.ClassNotFoundException. public abstract void connect(String host. protected String password.ResultSet executeQuery(String statement) throws java. spre exemplu.SQLException { return(this.connection. pentru conectarea la MySQL.sql. java.createStatement()). String database.

String user. astfel încât pentru deschiderea conexiunii prin JDBC este necesară plasarea claselor de acces în CLASSPATH. String user.password + ". 80 .DriverManager.jdbc.connection = java.mysql.SQLException { this.host + ":" + this.DriverManager. Class.password = password. String password) trows java.password = password.SQLException { this.user + ". this. this. this.database + "?user=" + this. this. } } în ambele cazuri metoda de conectare face apel la clasele punţii JDBC pentru serverul de baze de date respectiv.database = database.lang.sqlserver.getConnection("jdbc:microsoft:sqlserver ://" + this.mm.getConnection("jdbc:mysql://" + this. String database.user = user.java. java.forName("com.forName("org. } } pentru conectarea la SQL Server clasa derivată va arăta astfel: public class SQLServerDatabaseConnection extends DatabaseConnection { public SQLServerDatabaseConnection() { } public void connect(String host. this.lang. this.Implementarea aplicaţiilor distribuite pe platformele .connection = java.port + ".User=" + this.NET şi J2EE public void connect(String host.sql.host = host.port = port.port = port. this.database = database."). String database.database + ".sql. Class.Driver").DatabaseName=" + this.port + "/" + this.user = user.ClassNotFoundException.SQLServerDri ver").gjt.user + "&password=" + this.ClassNotFoundException.host+ ":" + this. this.sql. String password) throws java.sql.host = host. this.Password=" + this. int port.password).microsoft. int port. this.

Remoting. de forma: Obiect de serviciu using System.Remoting.Common { [Serializable] public class Customer { public string FirstName.Reţele de calculatoare 7. public string LastName.2 Nivelul logicii aplicaţiei 7.Runtime.Remoting.Channels.Remoting.Runtime.Runtime.2.Common. namespace Tutorials. namespace Tutorials.NET Remoting presupune următoarele acţiuni: se defineşte interfaţa şi obiectele de serviciu într-un assembly partajat între server şi client.Remoting. using System.Remoting.Common { public interface ICustomerManager { Customer[] GetCustomers().Http. } } Interfaţă serviciu namespace Tutorials. using System. using Tutorials. public DateTime DateOfBirth. ICustomerManager { 81 . } } se construieşte un proiect în care se implementează interfaţa de apel: using System.1 Apelarea procedurilor la distanţă Publicarea şi apelarea unui obiect prin .Channels.Service { public class CustomerManager : MarshalByRefObject.Remoting. using System.

customers[1].ReadLine().LastName = "Cuculescu". RemotingConfiguration. un serviciu de platformă sau o aplicaţiei consolă de test: using System. using Tutorials. "CustomerManager.DateOfBirth = new DateTime(1979. WellKnownObjectMode. using System.RegisterChannel(channel).Server { class Server { [STAThread] static void Main(string[] args) { HttpChannel channel = new HttpChannel(1979).soap". customers[1].Remoting.RegisterWellKnownServiceType( typeof(CustomerManager).Http. Console. 7.LastName = "Nemedi". ChannelServices.DateOfBirth = new DateTime(1979.Channels.Channels.Remoting.FirstName = "Dan".FirstName = "Iulian". } 82 . 1.Implementarea aplicaţiilor distribuite pe platformele .Runtime.Remoting. customers[0].Service.WriteLine("CustomerManager. namespace Tutorials.Remoting. customers[1] = new Customer(). customers[0] = new Customer(). customers[0]. 1).Runtime. } public Customer[] GetCustomers() { Customer[] customers = new Customer[2]. 24).Runtime.constructor: Object created").Remoting. } } } pentru publicarea serviciului se poate opta pentru un context Web pe IIS. customers[1]. using System. customers[0]. return customers. using System.Singleton).NET şi J2EE public CustomerManager() { Console.

Remoting. "http://localhost:1979/CustomerManager. Console.Common. using System. using System.FirstName + "\n" + "Last Name:\t" + customer. using System. namespace Tutorials.RegisterChannel(channel).yyyy") + "\n").Channels.Main(): Reference to CustomerManager acquired").LastName + "\n" + "Day of Birth:\t" + customer.Reţele de calculatoare } } clientul obţine o referinţă la obiectul la distanţă apelând activatorul canalului HTTP la serverul de obiecte. ChannelServices.ToString("dd\\.GetObject( typeof(ICustomerManager).Remoting.Channels.Remoting.DateOfBirth.Client { class Client { [STAThread] static void Main(string[] args) { HttpChannel channel = new HttpChannel().Remoting. } } } 83 .Runtime.Remoting.MM\\.GetCustomers().WriteLine("Customer:\n" + "First Name:\t" + customer. prin intermediul cărei apelează metodele obiectului: using System.soap"). Customer[] customers = manager.Runtime. using Tutorials.Http. foreach(Customer customer in customers) Console.Runtime. ICustomerManager manager = (ICustomerManager) Activator.WriteLine("Client.

server.rmi. import java. j * i <= n.RemoteException.remoting. int k = 0.rmi. import java.UnicastRemoteObject. } int[] numbers = new int[found]. i <= n. i <= n .Remote. import java.remoting.1. } Implementarea interfeţei de metode apelabile la distanţă package tutorials. public class PrimeNumbers extends UnicastRemoteObject implements IPrimeNumbers { public PrimeNumbers() throws RemoteException { super(). int found = 0. i++) if(isNotPrime[i] == false) numbers[k++] = i.rmi. return numbers. for(int i = 2.RemoteException.Implementarea aplicaţiilor distribuite pe platformele . i++) if(isNotPrime[i] == false) { found++.NET şi J2EE Arhitectura Java pentru apelarea procedurilor la distanţă prin RMI (Remote Method Invocation): Interfaţă de metode apelabile la distanţă package tutorials. public interface IPrimeNumbers extends Remote { public int[] getPrimeNumbers(int n) throws RemoteException. for(int j = 2. } public int[] getPrimeNumbers(int n) throws RemoteException { boolean[] isNotPrime = new boolean[n + 1]. j++) isNotPrime[j * i] = true. for(int i = 2. import java.rmi. } } 84 .

length() > 0 ? ".out. } catch(Exception exception) { System. } } } Client care apelează metode ale unui obiect la distanţă package tutorials. i < numbers.lookup("rmi://remoting/PrimeNumbersService").Naming.out. " : "") + numbers[i].RMISecurityManager.length.rmi.toString()). } catch(Exception exception) { System. import java. System.out. public class Client { public static void main(String[] args) { try { PrimeNumbers primeNumbers = (PrimeNumbers) Naming.remoting.toString()). try { PrimeNumbers primeNumbers = new PrimeNumbers().Naming. for(int i = 0.Reţele de calculatoare Server pentru obiectul ale cărui metode sunt apelabile la distanţă package tutorials. public class Server { public static void main(String[] args) { System.println(exception. } } } 85 .remoting. String message = "".setSecurityManager(new RMISecurityManager()). Naming.println(message). import java.rebind("//remoting/PrimeNumbersServer".parseInt(args[0]) : 1000. primeNumbers).getPrimeNumbers(n).rmi.length == 1 ? Integer. i++) message += (message.println(exception. int n = args.rmi. import java. int[] numbers = primeNumbers.

public String Email. 86 .NET şi J2EE 7.complextype. public class Contact implements Serializable { public String FirstName.Xml.services.Serializable. import java. } serviciul expune o metodă care întoarce un vector de obiecte serializate XML: Serviciu C# using System.ComponentModel.ase. using System. [XmlElement("Email")] public string Email.Serialization. [XmlElement("LastName")] public string LastName. public String LastName.2 Serializarea tipurilor de date complexe pentru transportul tipurilor de date complexe este necesară serializarea / deserializarea lor XML. mecanismul poate fi implementat declarativ prin intermediul atributelor sau imperativ prin instrucţiuni care apelează un obiect de tipul XmlWriter. using System.Collections. } } Clasă Java serializată XML în mod declarativ package tutorials. namespace Tutorials.Implementarea aplicaţiilor distribuite pe platformele . respectiv XmlReader: Clasă C# serializată XML în mod declarativ using System.io. using System.Service { [XmlRoot(Namespace = "http://aris.ro/schemas")] public class Contact { [XmlElement("FirstName")] public string FirstName.ComplexTypeServices.2.

se 87 .constantinescu@ase.Service { [WebService(Namespace = "http://aris.Web.FirstName = "Radu".ro". } base.Services.Dispose().nemedi@ase.ro/schemas")] public class ContactService : System. contacts[1]. } } } într-un proiect Java dezvoltat cu ajutorul mediului Eclipse.LastName = "Constantinescu".ro". using System.WebService { public ContactService() { InitializeComponent(). } #endregion [WebMethod] public Contact[] GetContacts() { Contact[] contacts = new Contact[2]. contacts[0].ase.Reţele de calculatoare using System. contacts[1]. } #region Component Designer generated code private IContainer components = null. contacts[1].Web.Email = "iulian. namespace Tutorials.Data. return contacts.LastName = "Ilie-Nemedi".Web.Dispose(disposing). private void InitializeComponent() { } protected override void Dispose( bool disposing ) { if(disposing && components != null) { components. using System.ComplexTypeServices. contacts[0] = new Contact(). contacts[0].Diagnostics.Email = "radu. se copiază structura unei aplicaţii Glue generate cu ajutorul utilitarului NewApp (copiată de fapt din Glue/app-template). using System. contacts[1] = new Contact().Services.FirstName = "Iulian". contacts[0].

pentru a putea fi serializat XML acesta trebuie să implementeze interfaţa java.ComplexTypeServices.constantinescu@ase.Serializable.Implementarea aplicaţiilor distribuite pe platformele .ClientForNetService 88 .ro".LastName = "Ilie-Nemedi". contacts[1].io.Email = "radu.services. în producţie metodele serviciului fac apel la o bază de date pentru extragerea informaţiilor: Serviciu Java package tutorials.LastName = "Constantinescu".FirstName = "Iulian". contacts[1] = new Contact().NET apelează serviciul prin intermediul unui proxy care conţine clase pentru deserializarea obiectelor complexe pe baza schemei XSD extrasă din descriptorul WSDL al serviciului: Client C# using System. public class ContactService implements IContactService { public Contact[] getContacts() { Contact[] contacts = new Contact[2].complextype. contacts[0]. se defineşte interfaţa serviciului Web: Interfaţa serviciului Java package tutorials. contacts[1]. respectiv într-un pachet Java în care se defineşte un tip complex care va fi întors de metodele serviciului Web. } se implementează interfaţa prin intermediul clasei serviciului.complextype.ro". public interface IContactService { public Contact[] getContacts().NET şi J2EE precizează că binarele aplicaţiei vor fi depuse în calea WEBINF/classes. contacts[0]. contacts[0].Email = "iulian.FirstName = "Radu". contacts[0] = new Contact(). } } clientul . se organizează clasele într-un director sursă.nemedi@ase. return contacts.services. contacts[1]. namespace Tutorials.

length.bind: Client Java package tutorials.println("Contact:\n" + "\tFirst Name: " + contacts[i]. i < contacts. apelarea din Java presupune importarea pachetelui cu definirea tipului de date complex şi a interfeţei serviciu.registry.Email + "\n").services.FirstName + "\n" + "\tLast Name: " + contacts[i].getContacts(). import electric. import electric.Contact[] contacts = new ContactProxy.WriteLine("Contact:\n" + "\tFirst Name: " + contacts[i].LastName + "\n" + 89 .ContactService().LastName + "\n" + "\tEmail: " + contacts[i].class).GetContacts().RegistryException.Reţele de calculatoare { class Client { [STAThread] static void Main(string[] args) { ContactProxy.bind(args[0]. i < contacts. pentru construirea acesteia platforma Glue Professional oferă utilitarul schema2java.out. for(int i = 0.Length. public class Client { public static void main(String[] args) throws RegistryException { IContactService proxy = (IContactService) Registry. Contact[] contacts = proxy. IContactService. for(int i = 0.Registry.registry.complextype.Registry. i++) System. i++) Console. clasa proxy se obţine prin apelul metodei statice electric.FirstName + "\n" + "\tLast Name: " + contacts[i]. } } } clientul Java are nevoie de o clasă pentru reprezentarea obiectului complex deserializat.revistry.

using System. portabilitatea unui singur tip elementar.Web.2.ro/schemas")] public class PrimeNumbersService : System. în ultimă instanţă programatorul putând folosi serializarea şi deserializarea String a obiectelor.WebService { public PrimeNumbersService() { InitializeComponent(). Apelarea asincronă a unui serviciu Web presupune iniţierea apelului prin execuţia metodei Begin care înregistrează o funcţie delegat callback ce va fi apelată la obţinerea răspunsului de la metoda serviciului.Collections. using System.Data.Service { [WebService(Namespace = "http://aris.Implementarea aplicaţiilor distribuite pe platformele . using System.AsyncCallService. de exemplu String. 7. presupunem un serviciu Web a cărui execuţie poate dura un timp mai îndelungat.Web. } 90 .Services.3 Apelarea serviciilor Web în mod asincron Utilitarul wsdl. permite traversarea platformei de către un obiect complex.Services. având o metodă care determină toate numerele prime până la un număr dat ca parametru: Serviciu C# using System. namespace Tutorials. cât asincron.ComponentModel. using System.NET şi J2EE "\tEmail: " + contacts[i].Email + "\n"). } } existenţa unor tipuri de date elementare echivalente face posibilă serializarea pe o platformă şi deserializarea pe alta a tipurilor de date complexe.Web. Pentru apelarea asincronă se generează câte o pereche de metode Begin_Apel_Metodă şi End_Apel_Metodă.exe generează metode pentru apelarea serviciului atât în mod sincron.ase.Diagnostics. using System. chiar şi în absenţa mecanismelor de serializare / deserializare ale containerelor de servicii Web. using System.

i++) if(isNotPrime[i] == false) for(int j = 2.Dispose(disposing). } } } Interfaţa serviciului Java package tutorials. private void InitializeComponent() { } protected override void Dispose( bool disposing ) { if(disposing && components != null) { components. for(int i = 2. j++) isNotPrime[j * i] = true. int found = 0.services. i <= n. j * i <= n.Dispose(). return (int[]) numbers. ArrayList numbers = new ArrayList(). } se implementează interfaţa printr-o clasă serviciu: Serviciu Java package tutorials. } base.services. 91 . public class PrimeNumbersService implements IPrimeNumbersService { public int[] getPrimeNumbers(int n) { boolean[] isNotPrime = new boolean[n + 1].ToArray(typeof(int)).asynccall.Add(i).Reţele de calculatoare #region Component Designer generated code private IContainer components = null. i++) if(isNotPrime[i] == false) numbers. } #endregion [WebMethod] public int[] GetPrimeNumbers(int n) { bool[] isNotPrime = new bool[n + 1].1.asynccall. i <= n . public interface IPrimeNumbersService { public int[] getPrimeNumbers(int n). for(int i = 2.

new PrimeNumbersService()).JMS. " : "") + 92 . i++) if(isNotPrime[i] == false) { found++.startup("jms:///AsyncCallService"). } } se publică serviciul pe un context Glue prin JMS (Java Messaging Services): Aplicaţie gazdă pentru serviciu Java package tutorials.registry. } int[] numbers = new int[found]. j * i <= n. import electric.numbers. } } clientul . for(int j = 2. return numbers.RegistryException.NET şi J2EE for(int i = 2. for(int i = 0.Registry. int k = 0.Length > 0 ? ".NET conţine o metodă care va fi apelată în mod asincron la primirea rezultatelor apelului către metoda serviciului Web: Metoda clientului C# public void LoadComplete(IAsyncResult result) { this.Implementarea aplicaţiilor distribuite pe platformele . public class AsyncServer { public static void main(String[] arguments) throws Exception { JMS.publish("PrimeNumbersService". i++) if(isNotPrime[i] == false) numbers[k++] = i.EndGetPrimeNumbers(result). i < this.Default. i++) message += (message.server.asynccall. import electric.1.Length. import electric. this.service. i <= n.Registry. j++) isNotPrime[j * i] = true.registry.jms. i <= n .numbers = this.registry.services.Cursor = Cursors. import electric. string message = "". for(int i = 2. Registry.

asynccall. import electric. } apelul sincron al metodei serviciului este înlocuit de apelul asincron al componentei Begin corespunzătoare acesteia: this.service. for(int i = 0. null).class). IPrimeNumbersService.numbers[i]. ceea ce face ca cererile să fie tratate asincron prin JMS: Client Java package tutorials.services. } } 93 . " : "") + numbers[i].length() > 0 ? ".println(message).registry.length.WriteLine(message). i++) message += (message. pe platforma Glue Professional clientul apelează serviciul asincron prin intermediul aceleaşi interfeţe ca şi pentru apelurile sincrone.LoadComplete).getPrimeNumbers(n).parseInt(args[0]) : 1000. String message = "".registry. int n = args.bind(url. spre deosebire de implementarea .NET în care clientul apela altă metodă a clasei proxy. import electric. System. utilizând însă alt URL pentru serviciu.wsdl".ToString().Reţele de calculatoare this.length == 1 ? Integer. i < numbers. new AsyncCallback(this. Console. int[] numbers = proxy.Registry.out. IPrimeNumbersService proxy = (IPrimeNumbersService) Registry.RegistryException. public class Client { public static void main(String[] args) throws RegistryException { String url = "jms://AsyncCallService/PrimeNumbersService.BeginGetPrimeNumbers(n.

ase.ServicedComponents.Common { [XmlRoot("Order". Namespace = "http://aris.Serialization. tipurile de date şi interfaţa de apel de la distanţă trebuie organizate într-o bibliotecă referită atât de serviciu care implementează interfaţa.NET şi J2EE 7. } } se implementează interfaţa de aplel prin intermediul unei componente de serviciu gestionată tranzacţional în COM+: Componentă de serviciu using System. using System. typeof(string))] public string Product. Publicarea unei componente ServicedComponent ca serviciu pe IIS presupune următoarele acţiuni: se scrie o componentă de serviciu. cât şi de clientul care face apelul către serviciu: extind Obiectul tranzacţiei using System. [XmlElement("Quantity".Common { public interface IDeliveryService { bool PlaceOrder(Order order).4 Publicarea unei componente ca serviciu Web Componentele COM+ sunt implicit apelabile la distanţă deoarece clasa MarshalByRefObject.Implementarea aplicaţiilor distribuite pe platformele .Xml. spre exemplu care necesită accesul tranzacţional la o bază de date pentru a înregistra o comandă. typeof(int))] public int Quentity.2. namespace Tutorials. } } Interfaţa de apel namespace Tutorials.EnterpriseServices.ro/schemas")] public class Order { [XmlElement("Product". 94 .ServicedComponents.

} #endregion } } se creează o aplicaţie Web pe IIS în care se publică binarele componentei SC împreună cu un descripor Web. prin intermediul căreia va putea apela metodele interfeţei serviciului: 95 .remoting> <application> <service> <wellknown mode="SingleCall" type="Tutorials.S ervicedComponents" objectUri="/ServicedComponents/DeliveryService.ServicedComponents { [Transaction(TransactionOption.Ticks % 2 == 0.Tutorials. obţine de la activator o referinţă locală a obiectului la distanţă.0" encoding="utf-8" ?> <configuration> <system.runtime. assembly-ul în care se găseşte şi adresa la care va răspunde.SOAP"/> </service> </application> </system.Reţele de calculatoare namespace Tutorials. precizând tipul clasei serviciu.DeliveryService.Now.runtime.Order order) { return DateTime.IDeliveryService { #region IDeliveryService Members [AutoComplete] public bool PlaceOrder(Common. clientul înregistrează un canal HTTP.remoting> </configuration> - descriptorul Web configurează în cadrul aplicaţiei un serviciu monocanal SOAP. Common.ServicedComponents.Required)] [JustInTimeActivation(true)] public class DeliveryService : ServicedComponent.config de forma: Descriptor Web <?xml version="1.

"). namespace Tutorials. Serviciile de tip EJB sunt găzduite de un 96 . "http://localhost/ServicedComponents/DeliveryService.Implementarea aplicaţiilor distribuite pe platformele .Runtime.Channels. order. Common.Product = "A Product".ToString()).Channels.IDeliveryService) Activator.Remoting.Runtime.NET şi J2EE Client pentru componeta de serviciu using System. using System.SOAP").IDeliveryService). platformele Java de servicii Web interceptează mesajele SOAP/HTTP ale clientului pe care le rutează conform descriptorilor de publicare către un anumit serviciu.Order().Quentity = 1.Remoting.Client { class Client { [STAThread] static void Main(string[] args) { try { HttpChannel channel = new HttpChannel().GetObject(typeof(Common. } } } } Componentele EJB găzduite de containere EJB ale serverelor de aplicaţii Java Enterprise sunt apelabile prin Remote Method Invocation (RMI). ChannelServices.Runtime. using System. order." : "Your order has been rejected.WriteLine(service.WriteLine(exception.RegisterChannel(channel).IDeliveryService service = (Common. using System.ServicedComponents.Http.Order order = new Common.Remoting.PlaceOrder(order) ? "Your order has been placed. } catch(Exception exception) { Console. Common. Console. Pentru a putea apela o componentă EJB prin intermediul protocolului SOAP.

aflat în subdirectorul de resurse WEB-INF. tot în fişierul web.xml. pentru o componentă EJB publicată în JBoss pe contextul ejb/Exchange se creează o aplicaţie Glue folosind utilitarul NewApp care de fapt copiază conţinutul directorului apptemplate într-un director cu numele aplicaţiei.service.StatelessSessionBeanService</class > <args> <contextFactory>org. responsabil cu rutarea mesajelor SOAP către procesorul serviciului: <servlet> <servlet-name>glue-SOAP</servlet-name> <servletclass>electric.ejb.NamingContextFactory</conte xtFactory> 97 .server. mapează metoda apelului SOAP peste metoda corespunzătoare a interfeţei Remote a componentei EJB pe care o apelează apoi prin RMI. având drept model fişierul sample. în subdirectorul services din WEB-INF se creează câte un descriptor XML pentru fiecare serviciu găzduit de aplicaţia curentă.0'?> <service> <constructor> <class>electric. în cazul publicării unei componente EJB ca serviciu Web fişierul descriptor are următoare formă: <?xml version='1.jnp. un serviciu Web de tip EJB nu este altceva decât un client Java pentru componenta EJB găzduit pe serverul de aplicaţii care este apelat prin SOAP de către clienţii externi. fişierul web. conţine maparea servlet-urilor contextului curent.xml este configurat şi procesorul de servicii SOAPServletContext. printre care se remarcă servlet-ul glue-SOAP.interfaces.ServletServer</servlet-class> <init-param> <param-name>httpRegistryRoot</param-name> <param-value>/</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> de asemenea.xml.http. descriptorul aplicaţiei Web. De fapt.Reţele de calculatoare procesor care gestionează starea acestora.

ejbstaff.ejbstaff.NET şi J2EE <url>jnp://localhost:1099</url> <jndiName>ejb/Exchange</jndiName> <homeInterfaceName>tutorials.client. System. contextul JNDI al componentei EJB pe serverul de aplicaţii şi interfaţa Remote de apel.out. import electric.class). } Client Java package tutorials.println("usa/japan exchange rate = " + rate). } catch(Exception exception) { System.toString()).getRate("usa".war director_aplicaţie se publică prin copiere în zona de publicare a serverului JBoss (server/default/deploy) pentru apelarea dintr-un client Java este necesară includerea unei interfeţe similare interfeţei Remote a componentei EJB: Interfaţă de apel la client package tutorials. IExchange. String country2). double rate = exchange.Implementarea aplicaţiilor distribuite pe platformele .ejbstaff.bind(url. } } } 98 . public class Client { public static void main(String[] args) { try { String url = args[0]. "japan"). IExchange exchange = (IExchange) Registry.client.interfaces. public interface IExchange { public double getRate(String county1.ExchangeHome< /homeInterfaceName> </args> </constructor> </service> descriptorul precizează tipul de Bean publicat. se construieşte arhiva aplicaţiei Web folosind utilitarul jar cu comanda: jar cf nume_arhivă.registry.Registry.out.println(exception.

în schimb se oferă posibilitatea înregistrării unor clase care să trateze la momentul apelului mesajele SOAP destinate serviciului virtual.virtual.Exchange exchange = new EjbService. String country2).println("usa/japan exchange rate = " + rate). iar numele serviciului este numele fişierului descriptor . Implementarea unui serviciu virtual High-Level se declară metodele interfeţei serviciu: package tutorials.Reţele de calculatoare pentru apelarea dintr-un client .5 Servicii Web virtuale Platforma Glue Professional permite publicarea unui descriptor WSDL pentru un serviciu Web virtual având la bază un set de interfeţe. public interface IExchange { public double getRate(String country1. double rate = exchange.war copiat în spaţiul de publicare JBoss. } } 7.wsdl unde numele aplicaţiei este numele fişierului arhivă .services. în timp ce legarea de nivel scăzut face apel la clasa VirtualSOAPHandler. Această legare poate fi de nivel înalt sau de nivel scăzut.NET se construieşte o clasă proxy prin adăugarea unei referinţe Web la descriptorul WSDL al serviciului.STAThread() */ public static void main(String[] args) { EjbService.out. Legarea de nivel înalt utilizează clasa VirtualService. System. "japan").xml din subdirectorul services al directorului de resurse al aplicaţiei Web (WEBINF): Client J# package Tutorials.NETClient. public class Client { /** @attribute System. platforma Glue găzduită în JBoss livrează descriptorul WSDL la adresa: http://server:port/nume_aplicaţie/services/nume_serviciu. } 99 .Exchange().EjbStaff.getRate("usa".2. Un serviciu virtual nu are ataşată o implementare statică în sensul consacrat.

public class ExchangePublish { 100 . } } tratarea legării implementării concrete de interfaţa publicată nu mai are loc în descriptorul aplicaţiei sau în aplicaţia gazdă. public Object invoke(Object proxy. Spre deosebire de serviciile Web obişnuite care ataşează o singură implementare unei interfeţe publicate.services.reflect.): package tutorials. String country2) { return Math. WebSphere. Arhitectura serviciilor virtuale High-Level are la bază mecanismul fabricii de obiecte. public class ExchangeHandler implements InvocationHandler { private IExchange exchange = new Exchange().reflect. import electric.Implementarea aplicaţiilor distribuite pe platformele .NET şi J2EE se oferă cel puţin o implementare pentru interfaţa serviciu. import electric. JBoss.http.VirtualService.Method.virtual.random() * 100.registry. import electric.invoke(exchange.util. Method method. public class Exchange implements IExchange { public double getRate(String country1.services.lang.lang. WebLogic etc.server. Object[] args) throws Throwable { return method. ci într-o clasă specială care se foloseşte de mecanismul de Reflection pentru dispecerizarea apelurilor metodelor serviciului către obiectul ce-l deserveşte la momentul apelului: package tutorials.InvocationHandler. import electric. } } publicarea se poate face printr-un descriptor care precizează interfaţa şi handler-ul virtual sau printr-o aplicaţie consolă gazdă ce poate fi instalată să ruleze ca serviciu de platformă. gen Glue sau un container pentru Glue (de exemplu Tomcat.Registry. în primul caz fiind nevoie de un server de aplicaţii gazdă.service. args).virtual. import java.virtual.HTTP. serviciile virtuale permit ataşarea la momentul apelului a implementării adecvate contextului cererii: package tutorials.Context.services.virtual. import java.

IExchange exchange = (IExchange) Registry. import electric. handler). double rate = exchange.startup("http://localhost:8004/glue").XPath. Registry. } } Implementarea unui serviciu virtual Low-Level un serviciu virtual de tip Low-Level implementează interfaţa electric. context).EncodedWriter.out.Reţele de calculatoare public static void main(String[] args) throws Exception { HTTP. import electric.SOAPMessage. exchange.virtual.services. Context context = new Context().println("usa/japan exchange rate = " + rate).publish("exchange".wsdl".SOAP. prin care ulterior poate apela metodele acestuia. "japan"). public class ExchangeInvoke { public static void main(String[] args) throws Exception { String url = "http://localhost:8004/glue/exchange.class).Registry. System.rmi. import electric.io. import electric.xml.xml.services.ISOAPHandler pentru a răspunde apelurilor SOAP către metodele serviciului: package tutorials. ExchangeHandler handler = new ExchangeHandler(). import java. 101 .ISOAPHandler.bind(url.getRate("usa". import electric.Element.xml. indiferent de clasa care le implementează pe server: package tutorials.class.registry.encoded. IExchange.virtual. } } clientul apelează serviciul virtual similar apelării unuia obişnuit.RemoteException.SOAP. prin legarea la URL-ul descriptorului WSDL şi conversia obiectului proxy obţinut la tipul interfeţei serviciului.SOAP. VirtualService exchange = new VirtualService(IExchange. import electric.

VirtualSOAPHandler exchange = new VirtualSOAPHandler(IExchange.http.virtual. SecurityException { String arg0 = request. public class ExchangeSOAPHandler implements ISOAPHandler { static final XPath country1 = new XPath("getRate/[1]"). writer.Registry. dintre care esenţial este cel care tratează mesajele SOAP şi prin intermediul căruia răspunde de fapt serviciul: package tutorials. Context context) throws RemoteException.setNamespace("n".IExchange").services. ExchangeHandler invokeHandler = new ExchangeHandler().getBody().publish("exchange". import electric. public class ExchangeSOAPPublish { public static void main(String[] args) throws Exception { HTTP.writeDouble("Result".util.startup("http://localhost:8004/glue").getString().random() * 100).SOAP.getBody(). static final XPath country2 = new XPath("getRate/[2]"). EncodedWriter writer = new EncodedWriter(result).server.Implementarea aplicaţiilor distribuite pe platformele . Math.NET şi J2EE import electric. Element result = body. import electric.Context.getElement(country2).HTTP.registry. invokeHandler. } } publicarea presupune înregistrarea interfeţei şi a handler-elor aferente. "http://tempuri. return response. exchange). public SOAPMessage handle(SOAPMessage request.addElement(). result. import electric. } } 102 . result.getElement(country1). Element body = response.publish.getString(). ExchangeSOAPHandler SOAPHandler = new ExchangeSOAPHandler().setName("n".VirtualSOAPHandler.class. "getRateResponse").virtual. SOAPMessage response = new SOAPMessage().addBody().org/examples. Registry. SOAPHandler). String arg1 = request.

adică verificarea identităţii utilizatorului. tratarea evenimentului Custom Authentification în Global. Passport: autentificarea utilizatorului se face cu ajutorul unei terţe părţi.config a unui modul HTTP care să implementeze metoda Init şi evenimentele Register ale interfeţei IHttpModule.asax verificându-se dacă informaţiile de autorizarea accesului nu există deja în colecţia Context. clientul neştiind detaliile implementării serviciului.NET avem trei categorii de autentificări.passport.Reţele de calculatoare apelarea unui serviciu virtual de tip Low-Level este similară apelării oricărui serviciu Web XML. crearea şi înregistrarea în web.6 Autentificarea şi autorizarea accesului Autentificarea presupune identificarea utilizatorului.2. De exemplu. 7. Pe baza unei proceduri de validare a datelor introduse se decide dacă este autentificat sau nu. pentru detalii despre cum anume se poate implementa acest mecanism de autentificare vezi www. atunci se construieşte un obiect de tip Credentials care se ataşează unui obiect de tipul Principal declarat ca utilizator curent al aplicaţiei prin încărcarea 103 .Cache. Pe platforma .NET: introduce două noi mecanisme de autentificare: Forms: dezvoltatorul creează o pagină prin care se cere utilizatorului să-şi introducă informaţiile de identificare. Etapele autentificării de tip antete SOAP personalizate: crearea unui antet SOAP prin derivarea unei clase din SOAPHeader conţinând credenţiale criptate.com Antete SOAP personalizate: prin care dezvoltatorul îşi implementează propriul mecanism de autentificare. informaţiile despre utilizator să fie trimise sub formă de parametri la metoda serviciului web. categorii dictate de cine anume implementează mecanismul de autentificare: IIS: Internet Information Server oferă următoare tipuri de autentificări: Anonymous Basic Authentification Digest Authentification Integrated Windows Authentification (NTLM sau Kerberos) ASP. Dacă nu sunt stocate în cache-ul aplicaţiei informaţii despre rolul utilizatorului.

config</config> o </args> </constructor> </realm> se editează fişierul WEB-INF/services/serviciu. Platforma GLUE oferă suport pentru autentificarea pe client şi pe server. în acest caz JAAS: <realm> <constructor> o <class>electric.NET şi J2EE obiectului Context. Role. o colecţie de informaţii vizând identitatea utilizatorului. entitate asociată identităţii utilizatorului.security.NET Roles. Noţiunile fundamentale pentru implementarea autentificării pe platfoma GLUE sunt: Principal. Verificarea contextului de rulare al aplicaţiei se face prin intermediul atributelor PrincipalPermission asociat metodelor expuse de serviciu Web. Principal Permissions. Pentru impementarea autentificării şi autorizării accesului pe platforma GLUE se au în vedere următoarele etape: se editează fişierul WEB-INF/glue-config. o acţiune care poate fi executată de un utilizator având un asociat un anumit rol.JAASRealm</class> o <args> <name>jaas</name> <config>security\jaas. Permission.xml în care se precizează tipul autentificării.User. GLUE include suport pentru integrarea cu standardul JAAS. care permite autentificarea bazată pe sistemul drepturilor de acces LDAP/NT. În varianta Professional. fiind compatibilă cu majoritatea platformelor care utilizează autentificarea de tip HTTP. colecţie de drepturi de acces asociată unei identităţi a utilizatorilor autentificaţi. şi anume: URL Authorization. Guard. o constrângere care utilizează o colecţie Realm pentru a verifica că un utilizator autentificat are dreptul să execute o anumită acţiune. File Authorization.jaas.Implementarea aplicaţiilor distribuite pe platformele . Autorizarea presupune acordarea drepturilor corespunzătoare rolului jucat de fiecare utilizator autentificat în sistem şi vizează mai multe niveluri de acces la resurse. . Realm.xml în care se specifică publicarea autentificării şi rolul aferent: 104 . rolul asociat şi permisiunile aferente.

Reţele de calculatoare <publish>yes</publish> <role>denumire_rol</role> se editează fişierul WEB-INF/web.NET 7.AspNet. Pagină ASP.NET cu Code Behind <%@ Page language="c#" Codebehind="RoomImage. astfel: ProxyContext context = new ProxyContext().1 Construirea unei imagini într-o pagină ASP.3 Nivelul de prezentare 7.microsoft.aspx. ISample sample = (ISample) Registry. context). context.NET Pentru exemplificare vom considera o pagină ASP.com/intellisense/ie5"> </head> <body MS_POSITIONING="GridLayout"> <form id="ImageForm" method="post" runat="server"> </form> </body> </html> 105 .RoomImage" %> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.xml în care se precizează metoda de autentificare: <login-config> <realm-name>acl</realm-name> </login-config> Pentru autentificarea apelului la un serviciu Web securizat se utilizează obiectul ProxyContext care va fi încărcat cu datele de autentificare ale utilizatorului declarat în fişierele de configurare.setAuthUser("denumire_rol").setAuthPassword("parolă"). 7.bind(ur_wsdll.3.0 Transitional//EN" > <html> <head> <title>RoomImage</title> <meta name="GENERATOR" Content="Microsoft Visual Studio .1"> <meta name="CODE_LANGUAGE" Content="C#"> <meta name=vs_defaultClientScript content="JavaScript"> <meta name=vs_targetSchema content="http://schemas.class.NET care afişează ca rezultat o imagine extrasă dintr-o bază de date şi primită de la un serviciu Web sub forma unui vector de octeţi.cs" AutoEventWireup="false" Inherits="Tutorials. ISample. context.

fileStream. using System.Open).UI. byte[] image = service. Clasa paginii using System. image. fileStream. using System. using System.Page. using System.MapPath("tmp/admin_no_image.MapPath("tmp/admin_no_image.jpg"). Session.Server. punctul de intrare în program este handler-ului evenimentului Load al paginii. Response.Length ].Web.Parse(this.Request["RoomId"])).Data.Response.UI.Server. using System. namespace Tutorials.AdministratorService().Web.ComponentModel.AdministratorService service = new Administrator. using System. în acest caz funcţia Page_Load. System.Read(image.SessionState.Close().Page { private void Page_Load(object sender. image = new byte[new FileInfo(this.Drawing.Web. 0.Web.Web.ContentType = "image/jpg".UI.WebControls.AspNet { public class RoomImage : System.Web.Implementarea aplicaţiilor distribuite pe platformele .UI. if(image == null) { FileStream fileStream = new FileStream(this. Context etc.Request["RoomId"]!=null) { this. using System. using System. are acces la interfaţa server-ului Web prin obiecte de forma Request.GetRoomImageData(int. Administrator.Collections. using System.NET şi J2EE o pagină Web extinde clasa System.IO.HtmlControls. FileMode. using System.EventArgs e) { if(this.jpg")).Web.UI. } 106 .Length).

0.Response. } } #region Web Form Designer generated code override protected void OnInit(EventArgs e) { InitializeComponent(). organizate în pachetele javax. 107 .Load += new System. Servlet care accesează o componentă EJB package tutorial.3. HttpServletResponse etc. răspunsul generat la ieşire devine sursa paginii HTML.IOException. base.PrintWriter. import java.war cum ar fi Ant sau XDoclet.servlet.web.http. având următoarele caracteristici funcţionale: pune la dispoziţia programatorului obiecte pentru accesarea interfeţei server-ului Web cum ar fi HttpServletRequest..OnInit(e).Reţele de calculatoare this. binarele unui servlet trebuie publicate în subdirectorul WEBINF/classes al unui context Web.OutputStream.xml sau cu ajutorul meta-tag-ului comentariu @web.Write(image. precum şi de securitate. } #endregion } } 7. pentru a putea fi accesat.2 Apelarea unei componente dintr-un servlet Tehnologia Servlet a fost gândită să suplinească deficienţele arhitectuiri CGI legate de gestiunea proceselor şi firelor de execuţie.servlet şi javax. astfel încât un servlet nu separă procesările şi conţinutul rezultat de formatarea acestuia.Length).io. image. import java.servlet-mapping.EventHandler(this. } private void InitializeComponent() { this.io. dacă se utilizează un mediu de construire a arhivei . servletului i se asociază un URL prin intermediul fişierului de configurare web.Page_Load).

Context.servlet.ServletConfig.http. import javax.servlet.Implementarea aplicaţiilor distribuite pe platformele .class).interfaces.narrow(ref.PortableRemoteObject. } public void init(ServletConfig config) throws ServletException { try { Context context = new InitialContext(). } catch (Exception e) { throw new ServletException("Lookup of java:/comp/env/ failed").Fibo" description="Reference to the * Fibo EJB" * * @jboss. /** * @web. IOException { 108 .HttpServletResponse. import javax. public ComputeServlet() { super(). import javax. import javax.rmi. FiboHome.interfaces.naming. } } protected void doPost(HttpServletRequest request.ServletException. import tutorial.ejb-ref-jndi ref-name="ejb/Fibo" jndiname="ejb/Fibo" */ public class ComputeServlet extends HttpServlet { private FiboHome home. Object ref = context. import javax.servlet name="Compute" display-name="Computation Servlet" * description="Servlet that compute Fibonacci suite" * * @web.HttpServletRequest.servlet.http.InitialContext. home = (FiboHome) PortableRemoteObject. HttpServletResponse response) throws ServletException.naming.servlet-mapping url-pattern="/Compute" * * @web.FiboHome" * remote="tutorial.lookup("java:/comp/env/ejb/Fibo"). import javax.servlet. import javax.FiboHome.Fibo.interfaces.interfaces.http. import tutorial.ejb-ref name="ejb/Fibo" type="Session" * home="tutorial.servlet.HttpServlet.NET şi J2EE import javax.

Reţele de calculatoare response.println(e. i++) { out. } out.length.print("The "). out. } catch(Exception e) { out. out.compute(limit). e. out. out. bean.print(limit). out.println(" : ").close(). if (value != null) { try { limit = Integer.println("</title></head>").parseInt(value).getWriter(). out. out.println("Fibonaci Computation").println("<html><head><title>"). out. out. out.print(" first Fibonacci numbers ").println("</p>"). for (int i = 0.getMessage()). String value = request.println("<h1>"). PrintWriter out = response.println(result[i]). try { Fibo bean = home.println("<p>").remove().println("<br>"). out. out. i < result. out.println("Fibonaci Computation"). } finally { out.println(i). int limit = 0.getParameter("limit").println("</body></html>").println("</h1>").setContentType("text/html"). } } } 109 . out.printStackTrace(out).create(). out.println("<body>"). } catch (Exception e) { } } double[] result = bean.

un fişier descriptor al bibliotecii de tag-uri: descrie în format XML numele.servlet. având următoarele caracteristici: permite intercalarea de cod procesat pe server cu formatări HTML.tagext. fişierele JSP: importă biblioteca de tag-uri prin intermediul fişierului descriptor.Implementarea aplicaţiilor distribuite pe platformele .jsp. prin care se generează conţinutul JSP. extinde clasa TagSupport sau BodyTagSupport şi implementează interfaţa Tag din pachetul javax. fiind publicat împreună cu paginile JSP sau pe o anumită adresă URL dacă aparţine altui context decât cel al aplicaţiei Web curente. metoda întoarce constanta SKIP_BODY în cazul unui tag simplu. Principiul separării procesărilor de formatarea rezultatelor este cel mai bine exemplificat în standarduol JSP 2. pentru orice altă cerere se compară data salvării paginii JSP cu data fişierului binar generat.3 Definirea unui Custom Tag în JSP Tehnologia JSP a fost dezvoltată din Servlet cu scopul separării prelucrărilor şi conţinutului de formatarea rezultatelor.0 de tehnologia Custom Tags. la momentul primei cereri o pagină JSP este translatată într-un servlet de către serverul de aplicaţii. Pentru implementarea unui Custom Tag este necesară scrierea următoarelor componente: o clasă tag handler: reprezintă o clasă Java care precizează modul în care tag-ul produce rezultat HTML.3. Implementarea handler-ului tag-ului necesită: extinderea clasei TagSupport din pachetul javax. verificându-se astfel dacă este necesară translatarea şi recompilarea paginii. 110 .jsp. care este apoi compilat în cod de octeţi şi interpretat.servlet.NET şi J2EE 7. fără imbricări de tip corp de tag. atributele şi handler-ele tag-urilor. se obţine o referinţă la obiectul JspWriter al fluxului de procesare a ieşirii paginii.tagext. rescrierea metodei doStartTag. asociindu-i un prefix de tag pentru a putea utiliza tag-uri ale acesteia în codul JSP. fiind publicată în contextul aplicaţiei împreună cu celelalte clase şi componente Bean ale acesteia.

Descriptor pentru biblioteca de tag-uri custom <?xml version="1. public class SimpleRandomTag extends TagSupport { protected int length.Random. nodul tagclass indică numele clasei handler calificat cu pachetul acesteia.0" encoding="ISO-8859-1" ?> <!DOCTYPE taglib PUBLIC "-//Sun Microsystems.pageContext.JspWriter. } return SKIP_BODY. Custom Tag fără imbricare package tutorials.toString()).Reţele de calculatoare codul este translatat în servlet la momentul primei cereri a paginii JSP.//DTD JSP Tag Library 1.servlet. nodul info conţine o scurtă descriere a tag-ului curent.com/j2ee/dtds/web-jsptaglibrary_1_1.jsp.util. import javax. tag-ul rădăcină este taglib.out.nextInt(this.customtags. nodul name precizează numele tag-ului curent. generând apoi răspuns HTML prin execuţie pentru fiecare cerere în parte. public int doStartTag() { try { JspWriter out = this.sun.1//EN" "http://java.IOException. } } Se scrie apoi descriptorul XML al bibliotecii de tag-uri custom. import javax.getOut(). } catch(IOException exception) { System. Inc.jsp.tagext.print(new Random().println(exception. import java. import java.length)).servlet.dtd"> <taglib> <tag> <name>simpleRandom</name> 111 . out.io. fiecare tag este definit de elementul tag precizând numele tag-ului şi handler-ul care-l tratează. atfel: după antetul documentului XML cu DOCTYPE.TagSupport.

</info> </tag> </taglib> Utilizarea unui tag dintr-o bibliotecă într-o pagină JSP presupune: se importă biblioteca de tag-uri precizând locaţia acesteia relativă la contextul aplicaţiei sau absolută: <%@ taglib uri="customjsp-taglib. setarea unui atribut în cadrul tag-ului echivalează cu apelarea metodei setter a obiectului handler.tld" prefix="mytags" %> <html> <head> <title>JSP Page</title> </head> <body bgcolor="#FFFFFF"> <mytags:simpleRandom/> </body> </html> Acest mecanism poate fi extins sub forma unui custom tag cu atribute şi conţinut: se declară în handler-ul tag-ului proprietăţi pentru fiecare atribut al său.tld" prefix="customjsp" %> se defineşte un prefix asociat bibliotecii importate <prefix:tagName /> se apelează tag-uri din bibliotecă prefixate corespunzător importului <customjsp:simpleRandom /> Pagină JSP care utilizează un Custom Tag <%@page contentType="text/html" %> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.w3. se declară atributul în descriptorul tag-ului 112 .NET şi J2EE <tagclass>tutorials.Implementarea aplicaţiilor distribuite pe platformele .dtd"> <%@ taglib uri="/WEB-INF/jsp/CustomTags.customtags.org/TR/xhtml1/DTD/xhtml1-transitional.0 Transitional//EN" "http://www.SimpleRandomTag</tagclass> <info>Outputs a random integer.

Reţele de calculatoare Custom Tag care extinde un tag simplu prin adăugarea unui atribut package tutorials. totuşi teoria avantajului comparativ evidenţiază necesitatea cooperării celor mai bune tehnologii pentru fiecare nivel în parte.NET şi J2EE.length = length. } } Descriptor pentru un Custom Tag cu atribute <tag> <name>random</name> <tagclass>tutorials. Interoperabilitatea celor două platforme este necesară din următoarele considerente practice: eterogenitatea platformelor hardware şi software existente în mediul de întreprindere. Deşi din raţiuni de compatibilitate şi integrare am fi tentaţi să optăm pentru o soluţie omogenă când se pune problema implementării unui sistem de întreprindere.NET şi J2EE Pe piaţa platformelor software pentru aplicaţii distribuite de întreprindere există în prezent două mari clase consacrate: . la baza oricărui demers de combinare a platformelor software stă satisfacerea nevoilor clienţilor într-o măsură cât mai mare. specificul aplicaţiei trebuie avut în vedere la alegerea unei platforme.customtags. majoritatea companiilor combină tehnologiile.customtags.4 Interoperabilitatea platformelor . ca rezultat.RandomTag</tagclass> <attribute> <name>length</name> <required>false</required> <rtexprvalue>false</rtexprvalue> </attribute> </tag> 7. controlul total este ineficient. public class RandomTag extends SimpleRandomTag { public void setLength(int length) { this. 113 .

NET este mai bună pe partea de client. ca dezavantaje se remarcă complexitatea ridicată. pe de altă parte. unele chiar împachetate binar şi arhivate. soluţia J2EE este potrivită pentru nivelurile logicii aplicaţiei şi de acces la date.NET. are un raport calitate / preţ superior. proprietatea obiectelor COM+ pe platforma .NET precum şi dependenţa de versiunea obiectelor. ca principal dezavantaj se înscrie absenţa operaţiilor sincrone. introducându-se penalizări temporare semnificative pentru sincronizare. permiţând comunicarea intra şi inter-niveluri. necesitând convertoare de protocol. în condiţiile existenţei unui suport extins pentru tranzacţii şi securitate. putând utiliza o gamă foarte largă de protocoale peste TCP. este mai mentenabilă decât . deoarece: oferă o performanţă ridicată. apelul prin cozi de mesaje: prezintă avantajul cuplării slabe. având un grad înalt de scalabilitate. 114 . oferă suport extins pentru dispozitive mobile şi protocoale dedicate gen WAP. alături de posibile neajunsuri de acces pe porturi prin Firewall.NET şi J2EE Potrivit percepţiei comune o aplicaţie eterogenă care se bazează pe cele două platforme ar trebui să folosească tehnologii . având drept atuuri: interfaţa client adaptată şi optimizată pentru platforma Windows.Implementarea aplicaţiilor distribuite pe platformele . Această abordare nu este întotdeauna cea optimă. oferind soluţii fiabile.NET pe partea de client şi tehnologii J2EE pe partea de server. Se pot imagina trei scenarii de interoperabilitate plauzibile: punte RMI – .NET Remoting: are drept principal avantaj performanţa ridicată a comunicaţiei. folosită de majoritatea utilizatorilor finali ai produselor informatice de întreprindere. se integrează cu suita de aplicaţii Office. deoarece: soluţia .

.

...... Server FTP .................... 7..................... 4................................................................................. Comunicare client – server la nivel de socket ................................................... 6............2....... 1.........Cuprins 4 5 6 8 9 10 10 10 11 12 18 19 19 19 21 22 26 27 30 30 33 34 35 35 39 43 43 44 48 52 53 65 1.......................................................... NCSA . IIS ................................................3.......................................................... Introducere ...... Adresare IP ......... Exerciţii ............................. Clase de adrese . Exemplificări .........1............................... 1..................................................................................................... 5..IP ................................................................................................................... Exerciţii IIS ...................... FTP şi poşta electronică .......................................................5....................................................................1....................... Interfaţa socket ....IP ............. Introducere ..........IP ...server .............................................................................................................. 1......6...................3........2........1.. Utilitare TCP ..................................................... hiperlegătură.......................... 2......................................................2.. 3.............................................................. 2............ 3.. 1......................................3.... Comunicaţie client – server UDP ...1....................2.............................................................. Serviciul de poştă electronică – e-mail ...................... Protocolul HTTP (Hypertext Transfer Protocol) ....................................... 3............................................................................................... 2........................1.. Client FTP .......................................................................................................................1.... Utilitare TCP ...............................................................................4........................................................................................................................................................... Apache ...................IP ..... Exemple de folosire a unor utilitare TCP ........................................................ Exerciţii NCSA............................1................................................ 4........ Implementarea aplicaţiilor distribuite pe platformele ................................. Servere WEB ....2.................................................................................................................................................2...................................................................... 6... 6............................................ 4....IP .. hipermedia ... Modelul client ..................4........... 3.............1..............................................3..1........ 2..................................... URL............ Hipertext................................................. Serviciul FTP – transfer de fişiere ................ 6........................2.....................2.................................. Exerciţii rezolvate ........................... 4................NET şi ..................... 3.... Testarea unei configuraţii TCP ................................. 2................................................................................ 5............................. Apache ............2........................................3................... Comunicaţie client – server TCP ....... 2..................... 3........... 5..................... Introducere ..................IP ........ 3.. 6.................. 6......................................... Scheme URL .................................1.......................2........................

.....2................................ 7......3..........2.....5.........4........ Nivelul de prezentare .......... Bibliografie . 7.... Construirea unei imagini într-o pagină ASP......7............................................................2.......................2..............3........... 7.......... Interoperabilitatea platformelor .....6........ Apelarea unei componente dintr-un servlet ...................... 7.3...............NET şi J2EE .. Serializarea tipurilor de date complexe ..................2.............................................. 7.......................................................................................3.................................................. Autentificarea şi autorizarea accesului .................. 7.............................. 7. 7......................... Publicarea unei componente ca serviciu WEB .............3........................4....... 86 90 94 99 103 105 105 107 110 113 116 .................... Definirea unui Custom Tag în JSP ..................3..............................................................2...... Servicii WEB virtuale .............. 7.1.......... Apelarea serviciilor WEB în mod asincron ............2.................NET ..................................

dar mai ales pentru tranzacţii.Reţele de calculatoare servicii Web: se remarcă drept varianta optimă de interoperabilitate pentru cele mai multe situaţii datorită cuplării slabe. fără restricţii de tip Firewall sau conversii de protocoale de comunicaţie. în condiţiile executării de operaţii sincrone. până în prezent are totuşi dezavantajul implementării parţiale a standardelor pentru securitate. 115 . cât şi asincrone. WS-Attachement sau WS-Routing. Dezvoltarea modelului GXA (Global XML Web Services Architecture) intenţionează să înlăture aceste neajunsuri prin protocoale de tipul WS-Security.

3. R.NET for Java Developers: Migrating to C#. GANESHAN. F. J. K. 116 .. GULZAR. Atelier de programare în reţelele de calculatoare. PELTZER. 2003. 1998 . 003. 2003. 7.. 2001. Editura de Vest. J. G. Editura Polirom. I. 2. K. P. Editura Econmică. I. WILLIAMS. 8. Bucureşti.. J2EE Design Patterns. APress. Tehnologia aplicaţiilor WEB. NĂSTASE. JURCA. Editura Economică. N. CRAWFORD W.NET Remoting. POTA.Bibliografie 1. Iaşi. Addison-Wesley. CIOBANU. 5. 9. McGraw-Hill. A. RAMMER. Addison Wesley. NAFTEL. PUVVALA. Arhitectura reţelelor de calculatoare. J2EE Web Services. 11... 2002. . MCLEAN. Timişoara. KAPLAN. D. Programarea reţelelor de calculatoare. O’Reilly. 10. 2002. Practical J2EE Application Architecture. 2001.NET Remoting. MONSON-HAEFEL. F. BURAGA. 4. S. 2003. S.NET & J2EE Interoperability. 6. 2003.. Advanced . NĂSTASE. McGraw-Hill. MS Press. J. . NĂSTASE. Bucureşti. 2004.

I. N. I. STANCIU.NET SDK.Concepte şi aplicaţii. * Sun Resurse Apache: Tomcat. Editura Economică.microsoft.webmethods. G. ATANASIU.. 2000. Baze de date pentru comerţ electronic pe suport Internet. COSTINESCU. Fl. UDDI SDK. STANCIU-TIMOFTE. C.go-mono..org Eclipse: Eclipse SDK – http://www. Sun Microsystems.com WebMethods: Glue – http://www. INTERNET & INTRANET . Struts – http://www. C.Bibliografie 12.apache. ADO.. JDBC Drivers – http://www. 14.org Microsoft: . MSDE – http://www. J2EE 1.eclipse.ibm.. 2002.com Mono: . V. B.NET Framework for Linux – http://www.mysql. PAIU.NET Providers. GODZA.com 117 . Editura Oscar Print.. JBoss IDE for Eclipse – http://www. 2003..com Sun: J2SDK. 13. ŢĂPUŞ. JWSDP – http://java.com MySQL: MySQL Server.. J2EE..com JBoss: JBoss Server.4 Tutorial. Bucureşti.jboss. NĂSTASE. Bucureşti. CRISTEA. ROŞCA.org IBM: WSDK – http://www.sun. O..

You're Reading a Free Preview

Download
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->