Executarea Serviciilor de Internet Paging In Internet Si In Retele Locale Bazate pe Setul de Protocoale Tcpip

CUPRINS

ADNOTARE 5

ANNOTATION 6

INTRODUCERE 7

1. COMUNICAREA CU AJUTORUL MESAJELOR PRIN INTERMEDIUL REȚELELOR BAZATE PE SETUL DE PROTOCOALE TCP/IP 8

1.1 Internet și serviciile de Internet Paging 8

1.2 Principiile creării legăturilor ale aplicațiilor prin rețea cu ajutorul Window Socket. 8

1.3 Lucrul cu Window Socket în Visual C++ 10

1.3.1 Crearea Socket-ului 10

1.3.2 Crearea conexiunii 12

1.3.3 Transmiterea și primirea mesajelor. 14

1.3.4 Întreruperea conexiunii 16

1.3.5 Evenimentele Socketelor 16

2. DESCRIEREA PROGRAMULUI 17

2.1 Arhitectura programului 17

2.2 Deosebirea programului elaborat față de programele existente 17

2.3 Avantajele și dezavantajele programului elaborat față de programele existente. 17

2.4 Cerințele programului 18

2.5 Posibilitățile programului 18

2.6 Descrierea meniului programului 19

Fig.2 Fereastra principală a programului 19

3. PROTECȚIA MUNCII 21

3.1 Analiza condițiilor de muncă tehnica a securității 23

3.2 Noțiuni despre electrotraumatism 25

3.3 Calcularea protecției “legarea la nul” 26

4.PROIECTAREA TEHNICO-ECONOMICĂ A PROIECTULUI 31

4.1 Situația generală 31

4.2. Etapele cercetării științifice. 32

4.3. Evaluarea economică a proiectului 37

4.4. Determinarea eficacității economice a proiectului 39

CONCLUZIE 41

BIBLIOGRAFIE 42

ANEXE 43

Anexa 1 Schema schimbului de mesaje intre utilizatori în cazul arhitecturii cu Server. 43

Anexa 2 Schema schimbului de mesaje intre utilizatori în cazul în care nu este Server. 44

Anexa 3 Schema-bloc a programei. 45

Anexa 4 Listingul programului 46

=== DIP ===

ADNOTARE

Acest proiect a fost elaborat pentru executarea serviciilor de Internet-Paging în Internet și în rețele locale bazate pe setul de protocoale TCP/IP.

În primul capitol sînt descrise principiile generale de proiectare a unui Internet-Pager, deasemenea sînt descrise principiile creării legăturilor aplicațiilor prin rețea cu ajutorul Window Socket și implementarea sa cu ajutorul Visual C++.

În capitolul doi este descrisă programa elaborată: principiul de funcționare, arhitectura sa, particularitățile sale, avantajele și dezavantajele față de programele existente etc.

În capitolol trei se analizează problemele referitoare la protecția muncii și sanitaria de producere, unde se analizează acțiunea factorilor nocivi de la exploatarea calculatorului și standardele de lucru cu tehnica de calcul.

În capitolul cinci sunt estimate cheltuielile proiectului și costul proiectului. Este prezentată analiza efectului social de la introducerea proiectului în exploatare.

Sînt anexate schema funcționării unor Internet-Pagere de diferite arhitecturi, deasemenea și schema-bloc al programului elaborat. Mai este anexat listingul programului elaborat în Visual C++.

ANNOTATION

The project is desighned to execute the Internet-Paging services in local network and global network Internet.

The first section of the given work contains general information about the Internet-Pagers. Also is describe the principes interconections between diferent pagers.

Section number two discribe this project: architecture, work principes, advantage and other.

Section number three contains the data about labour protection and industrial hygiene, where influence per capita of such harmful factors as noise, radiation and other, and also sanitary rules and norms of work of the person that uses computers is considered.

In the four section the economic cost of the project is computed, and also the social effects of introducing this system are presented.

On this work was anexed then architecture of diferent types of Internet-Pagers. Also was atached architecture and listing of the elaborated aplication.

INTRODUCERE

Internetul ne pune la dispoziție un șir de servicii cum sunt: poșta electronică, copiere a fișierelor, convorbiri interactive, grupuri de știri, servicii web ș.a. În ultimii ani o deosebire dezvoltare a cunoscut serviciile de Internet-Paging. În curent de aceste servicii se folosesc zeci de milioane de utilizatori. În prezent cele mai răspîndite aplicații(Internet Pager) ce oferă astfel de servicii sunt: ICQ, Odigo, MSN Messenger Service, Yahoo Messenger, AOL Instant Messenger etc. Aplicațiile moderne oferă o gamă foarte largă de servicii, împrumutind deseori idei de la celelalte servicii asemănătoare. Astfel ele pot include servicii de poștă electronică, transmitere de fișiere, convorbiri interactive transmiterea mesajelor în formă de sunete, desene, adrese internet. Deobicei ele posedă o gamă largă de posibilități de a face cunoștință cu persoane noi ce la fel comunică prin rețeaua Internet.

Scopul acestui proiect este de a efectua este de a elabora o aplicatie cu unele deosebiri față de cele existente, în unele cazuri fiind mai potrivit cerințelor avute de utilizatori.

Un specific a aplicației elaborate este lipsa unui program server. Aceasta include un set de avantaje fața de alte Internet-pagere ca de exemplu: nu necesită întreținerea unui calculator „Server”, sistemul în acest caz este mai fiabil este mai fiabil, nu există riscul ca „Serverul” să nu reușească să prelucreze cererile venite, crește nivelu securității, din cauza că mesajele nu trebuie să „treacă” prin „Server”.

1. COMUNICAREA CU AJUTORUL MESAJELOR PRIN INTERMEDIUL REȚELELOR BAZATE PE SETUL DE PROTOCOALE TCP/IP

1.1 Internet și serviciile de Internet Paging

Aplicatiile ce oferă ecest tip de servicii pot avea diferite arhitecturi. În majoritatea cazurilor exista un program server ce efectuiază unele lucrări de gestionare a clienților ei. Lucrările de le execută depinde în mare măsură de principiul ce stă la baza aplicației. Aplicația poate folosi diferite tipuri de protocoale. Cel mai des folosit este UDP însă uneori se folosesc și alte tipuri de protocoale ca de exemplu TCP. Ajunsurile și neajunsurile acestor pagere evident se moștenesc de la caracteristicile protocoalelor folosite. Ca de exemplu folosind protocolul UTP, de regulă mesajele se transmit destul de rapid, însă acest protocol nu ne garantează ajungerea la destinație a mesajului transmis. Protocolul TCP ne garanteza acest lucru, însă de regulă pagerele bazate pe acest protocol sînt destul de lente.

Pentru a comunicarea programului server cu programele clienți e nevoie de a crea canale de legătură. Există mai multe posibilități de a crea canale de legatură cum ar fi de exemplu cu ajutorul NetBEUI, Window Sockets sau Pipes.

1.2 Principiile creării legăturilor ale aplicațiilor prin rețea cu ajutorul Window Socket.

Toate aplicațiile de rețea se împart în două categorii: Programe Client și programe Server. Diferențele între ele constă în modul după care se face legătura. Programul Server trebuie să primească cererea de legătură de la programul Client, iar programul Client trimite cererea de legătură programei Server și așteaptă răspunsul. După aceste proceduri diferențele dintre aceste două programe dispar. Între ele are loc un dialog, în care ambele programe sînt echivalente. Regulele organizării dialogului sînt stabilite de un protocol. Între Server și Client se crează un canal de comunicare. Citirea și scrierea se face cu ajutorul unor obiecte – Socket.

Fig.1 Schema principială după care sînt construite aplicațiile de rețea cu ajutorul Window Socket

Programul Client

Ciclul de lucru al unui program Client constă din următoarele etape:

Crearea Socket-ului. După creare se pot stabili careva parametri ai socket-ului, de exemplu blocabil sau neblocabil.

Se unește socketul cu programul Server.

Se transmite o cerere programului Server.

Se primește răspunsul. Posibil aceste două puncte se repetă, în dependență de tipul protocolului folosit.

Se închide socketul. În același timp se întrerupe legătura cu Serverul.

Programul Server

Ciclul de lugru al Server-ului constă din următoarele etape.

Crearea socket-ului.

Se unește socket-ul cu un port local(bind).

Se stabilește socket-ul în regim de ascultare(listen).

Trece în regim de așteptare a cererii(accept).

Citește cererea.

Scrie răspunsul.

Trece iarăși în regim de așteptare.

1.3 Lucrul cu Window Socket în Visual C++

1.3.1 Crearea Socket-ului

Pentru a crea un socket într-o aplicație în primul rînd e nevoie de a declara o variabilă de tipul CAsincSocket (sau o clasă descendentă din CAsincSocket) ca o membră a unei clase din aplicație.

class CMyDlg : public CDialog

{

private:

CAsyncSocket m_sMySocket;

};

Înainte de a folosi obiectul socket, e nevoie de chemat metoda sa Create(). Această metodă crează socket-ul și îl gătește de întrebuințare. Modul în care este chemată metoda Create() depinde de modul de întrebuințare a secket-ului. Dacă socket-ul va fi folosit pentru unică folosință (la programul client), atunci nu este nevoie de a-i pasa unii parametri metodei Create().

De exemplu:

if (m_sMySocket.Create())

{

// Continuă stabilirea legăturii

}

else

// Nu sa putut crea clasa. Trebuie de prelucrat eroarea existentă

În cazul cînd e nevoie ca socket-ul să lucreze ca server, adică e nevoie ca ea să aștepte o eventuală conecțiune, atunci e nevoie de ai pasa cel puțin numărul portului pe care socket-ul trebuie să-l “asculte”.

De exemplu:

if (m_sMySocket.Create(4000))

{

// Continuă mai departe

}

else

// Nu sa putut crea clasa. Trebuie de prelucrat eroarea existentă

Se poate include alți parametric la folosirea metodei Create(), ca de exemplu se poate indica tipul socket-ului folosit, evenimentele la care ar trebui să răspundă și adresa la care ar trebui să răspundă (în cazul cînd calculatorul are mai multe cartele de rețea.

1.3.2 Crearea conexiunii

Odată ce a fost creat, socketul are nevoie de a fi conectat. E nevoie de 3 pași pentru a stabili o conexiune. Două dintre ele au loc pe Server, ascultara portului pentru conectare, iar a treilea pas se face de client odată cu apelarea.

Pentru client stabilirea legăturii înseamnă pur și simplu chemarea metodei Connect(). Alientul are nevoie de a-i pasa doi parametri metodei Connect(): numele calculatorului, adresa în rețea și a portului aplicației cu care se conectează. Metoda Connect se poate folosi prin două metode:

if (m_sMySocket.Connect("numelecalc.com", 4000))

{

// Continuă mai departe

}

else

// Se prelucrează erarea comisă

O altă formă este:

if (m_sMySocket.Connect("178.1.25.82", 4000))

{

// Continuă mai departe

}

else

// Se prelucrează erarea comisă

Pentru programul server, sau a părții ce scultă, aplicația trebuie să-i comunice socket-ului să asculte apelările ce vin prin metoda Listen(). Metoda Listen() ia un singur argument. Acest argument specifică numărul de apeluri ce pot aștepta conexiunea în rîndul de așteptare. Valoarea maximă a lui este 5. Apelarea metodei Listen() se poate face în felul următor:

if (m_sMySocket.Listen())

{

// Continuă mai departe

}

else

// Se prelucrează eroarea apărută.

Cînd altă aplicație încearcă să stabilească o conexiune, evenimentul e înregistrat și aplicația e înștiințată de apelare. Aplicașia ce așteptă trebuie să accepte cererea chemînd metoda Accept(). Această metodă necesită de a întrebuința o a doua variabilă de tipul CasyncSocket, care este cu o altă aplicație. Odată ce socketul e stabilit în regimul de ascultare, el rămîne în regimul de ascultare. Cînd cererea de conexiune e primită socket-ul ce ascultă crează alt socket, care se unește cu altă aplicație. Al doilea Socket nu are nevoie de a chema metoda Create() deoarece ea este chemată de metoda Accept(). Chemarea metodei Accept() se face în modul următor:

if (m_sMySocket.Accept(m_sMySecondSocket))

{

// Continuă mai departe

}

else

// Se prelucrează eroarea apărută

Ca rezultat aplicația client se conecteaza cu al doilea socket a aplicației Server.

1.3.3 Transmiterea și primirea mesajelor.

Deorece socketurile au fost elaborate să poată transmite orce fel de date, și nu are importanță ce date sînt, funcțiile de transmitere și primire așteaptă să-I fie pasate pointere a unui buffer de date care trebuie transmise. Pentru partea ce primește, acest buffer înseamnă locul unde vor fi plasate datele. În cazul cînd se transmite și se primește simplu text e foarte simplu de folsit clasa Cstrings pentru aceste bufere.

Pentru a transmite un mesaj prin conexiune,se folosește metoda Send(). Această metodă are nevoie de doi parametric, și al treilea opțional. Primul parametru este pointerul la buferul cu datele ce trebuie transmise. Cînd mesajul este un obiect CString, se poate folosi operatorul LPCTSTR pentru a pasa o variabilă CString ca bufer. Al doilea parametru este lungimea buferului. Dacă apare vre-o eroare, metoda Send întoarce SOCKET_ERROR. Metoda Send() se poate folosi în forma următoare:

CString strMyMessage;

int iLen;

int iAmtSent;

.

.

.

iLen = strMyMessage.GetLength();

iAmtSent = m_sMySocket.Send(LPCTSTR(strMyMessage), iLen);

if (iAmtSent == SOCKET_ERROR)

{

// Se prelucrează eroarea apărută

}

else

{

// Totul este în ordine

}

Cînd datele sînt pregătite, aplicația ce primește este înștiințată. Aceasta face ca aplicația să poată primi și prelucra mesjul. Pentru a primi mesajul e folosită metoda Receive(). Această metodă are aceiași parametri ca și metoda Send() cu o mică diferență. Primul parametru indică pointerul la buferul unde datele trebuie înscrise. Al doilea parametru este marimea buferului. Aceasta înștiințează aplicația ce volum de date va sosi. Ca și în cazul metodei Send() metoda Receive() poate întoarce SOCKET_ERROR. Dacă mesajul este un text, el poate fi copiat direct într-o variabilă string. Metoda Receive() se poate folosi în modul următor:

char *pBuf = new char[1025];

int iBufSize = 1024;

int iRcvd;

CString strRecvd;

iRcvd = m_sMySocket.Receive(pBuf, iBufSize);

if (iRcvd == SOCKET_ERROR)

{

// Se prelucrează eroarea apărută

}

else

{

pBuf[iRcvd] = NULL;

strRecvd = pBuf;

// Se prelucrează mesajul mai departe.

}

1.3.4 Întreruperea conexiunii

Odată ce aplicația nu mai are nevoie să comunice cu cealaltă aplicație ea poate închide conecsiunea cu ajutorul metodei Close(). Metoda Close() nu are nevoie de parametri și se folosește în modul următor:

m_sMySocket.Close();

1.3.5 Evenimentele Socketelor

O cauză care ne impune să creăm o clasă descendentă din clasa CAsyncSocket eate necesitatea da a capta și prelucra mesaje cînd mesajul e primit, conecțiunea e stabilită etc. Clasa CAsyncSocket are o serie de funcții care sînt apelate la unele din aceste evenimente. Aceste funcții se declară cu acelas nume, unica diferență este că ea acoperă funcțiile din clasa de bază. Toate aceste funcții sînt declarate ca membri protejați ai clasei CAsyncSocket și probabil ar trebui declarați protejați și in clasele descendente.

2. DESCRIEREA PROGRAMULUI

2.1 Arhitectura programului

Arhitectura programului este prezentată grafic in Anexa nr3.

Componenta Server ascultă portul specificat așteptînd o conexiune.

2.2 Deosebirea programului elaborat față de programele existente

Acest program posedă o serie de deosebiri față de programele existente. Cele mai importante din ele sînt:

Spre deosebire de pagerile tradiționale acest program nu are nevoie de un program aparte numit „Server”. Acest lucru generează o serie de avantaje și dezavantaje descrise mai jos.

Protocolul folosit este TCP, deobicei fiind folosit UDP ca fiind mai rapid, însă nu garanteză primirea mesajului de către destinatar.

2.3 Avantajele și dezavantajele programului elaborat față de programele existente.

Avantajele

Nu sînt cheltuieli adaugătoare pentru întreținerea Serverului;

Fiabilitatea sistenului este ridicată

Utilizatorii nu sînt dependenți de Server.

Se folosește protocolul TCP

Spre deosebire de pagerile existente acest program folosește protocolul TCP în loc de obișnuitul în acest caz UDP. Aceasta îi garantează utilizatorului ce transmite că mesajul a fost primit de adresat.

Securitatea este mai înaltă

Mesajele nu sunt transmise prin intermediului serverului deacea e mai greu de interceptat mesajul. Deobicei Internet-pagerile existente colectează o serie de date despre utilizatori.

Nu există riscul de ca serverul să nu poată prelucra toate cererile.

Posibilitatea de a fi folosit in rețele locale fără a avea ieșire în Internet.

Dezavantajele

Din cauza lipsei Serverului este imposibil de trimitere a mesajelor off-line;

Necesitatea ca rețeaua să lucreze prin setul de protocoale TCP/IP;

2.4 Cerințele programului

Acest program are nevoie de ca la calculator să fie instalat un sistem de operare din familia Microsoft Windows xx. Rețeaua să fie organizată pe setul de protocoale TCP/IP.

2.5 Posibilitățile programului

Acest program oferă un set de posibilități privind gestiunea mesajelor enumerate în lista de mai jos:

transmiterea unui mesaj textual;

cererea unui fișier de pe un calculator indepartat;

executarea unui set de comenzi din fereastra de redactare a mesajelor;

păstrarea adreselor altor utilizatori al acestui progarmă

posibilitatea de ascultare a unui port specificat după dorința utilizatorului.

Destinatarul poate fi atît din lista de adrese cît și introdus manual împlinind cîmpurile cu adresa IP și portul de ascultare a destinatarului;

Stabilirea unui set de opțiuni privind lucrul pagerului;

Găsirea statutului utilizatorilor.

2.6 Descrierea meniului programului

Programul constă dintru-un set de ferestre de dialog. Fereastra principală este prezentată în figura 2. Ea este

Fig.2 Fereastra principală a programului

Fig.3 Lista de adrese a utilizatorilor

Fig.4 Fereastra de dialog a opțiunilor

3. PROTECȚIA MUNCII

Lucrul în domeniul protecției muncii în timpul de față urmărește una din cele mai importante direcții în domeniul ocrotirii sănătății și ușurarea condițiilor de muncă prin introducerea tehnologiilor noi și automatizarea producerii, înlăturarea muncii manuale pe regiunile dăunătoare ceea ce pozitiv se reflectă asupra sănătății oamenilor.

Sub noțiunea de protecție a muncii (PM) înțelegem un sistem de acte legislative, social-economice, tehnice, igienice și măsuri curativo-profilactice, care asigură securitatea, sănătatea oamenilor în procesul de producție. Asigurarea protecției muncii se realizează cât la proiectarea proceselor de producție, atât și la procesul de realizare a lor. Direcția tranșantă de îmbunătățire a condițiilor de muncă este trecerea la noi tehnologii avansate cu un înalt grad de protecție a muncii.

Protecția muncii este asigurată prin conducerea procesului de producție după standardele de protecție a muncii, normele igienice, instrucții pentru protecția muncii. Importanța tot mai majoră în asigurarea protecției muncii o capătă conducerea după sistemul standardelor de securitate a muncii (SSSM). În standarde sunt formulate cerințele de protecție față de procesele de producție, utilaj, producția industrială, mijloace de protecție individuală a lucrătorilor, sunt stabilite normele și cerințele față de parametrii care caracterizează zgomotul, vibrația, ultrasunetul, impurificarea aerului, protecția electrică și antiincendiară.

Cu problemele de protecție a muncii este legată și organizarea științifică a muncii, care ia în considerație crearea condițiilor bune de lucru, folosirea îmbrăcămintei speciale, instrumentelor de muncă speciale etc.

Metodele de protecție a muncii sunt compuse din cercetarea condițiilor de lucru în acela timp și a proceselor tehnologice, a utilajului, a încăperii de producție, analiza cazurilor accidentale și a bolilor profisionale. Măsurile legate de crearea condițiilor de protecție în procesul muncii la întreprinderi se efectuiază în mod planificat. Ele sunt concretizate în urma semnării contractului colectiv dintre administrație și comitetul sindical local. Aceste măsuri conțin trei parți: măsuri pentru prevenirea bolilor profesionale, măsuri pentru prevenirea cazurilor accidentale, măsuri pentru îmbunătățirea condițiilor de muncă.

Conducerea cu protecția muncii este însărcinată cu îndeplinirea următoarelor funcții:

Determinată de formarea organelor de conducere a protecției muncii, coordonarea și organizarea lucrărilor în domeniul protecției muncii, reglamentarea obligațiilor și ordinii de interacțiune a persoanelor care sunt antrenate în conducere, primirea și realizarea hotărârilor (conducerea totală și răspunderea pentru starea protecției muncii este lăsată pe seama directorului; coordonarea lucrărilor pentru protecția muncii se îndeplinește sub conducerea inginerului principal). Organizarea nemijlocită a protecției muncii la întreprinderi este pusă pe seama secțiilor (birouri) pentru protecția muncii, inginerilor de protecția muncii.

Pregătirea organizării lucrului la întreprinderi pentru crearea condițiilor sănătoase de lucru a muncitorilor, preîntâmpinarea cazurilor accidentale în procesul producerii și a bolilor profisionale (pentru aceste probleme răspunderea totală este pe seama secției protecției muncii).

Printre problemele de bază pe care le rezolvă secția de protecție a muncii mai sunt: îmbunătățirea organizării măsurilor pentru protecția muncii, introducerea ideilor noi în domeniul protecției muncii, efectuarea controlului situației protecției muncii la întreprinderi.

Problemele administrației secției și maiștrilor de producere sunt:

asigurarea bunăstării utilajului, sculelor, mijloacelor de transport, îngrădirilor, organizarea corectă a locurilor de muncă, controlul lucrărilor, dacă acestea se conduc de instrucții în activitatea sa, efectuarea la timp a instructajului persoanelor noi angajate.

Controlul nivelului protecției muncii este îndreptat la verificarea condițiilor de muncă a muncitorilor, la determinarea abaterilor de la standardele (SSSM), normele și legile controlului de stat și a altor documente normative a protecției muncii, controlul îndeplinirii de către servicii și subunități a obligațiunilor în domeniul protecției muncii, la primirea hotărârilor efective pentru înlăturarea neajunsurilor.

Formele de bază de control pot fi: controlul operativ a șefului sau a altor conducători, controlul social-administrativ (cu trei nivele), controlul efectuat de serviciile de protecție a muncii la întreprindere, controlul efectuat de organele superioare, controlul efectuat de organele de control statal și inspecția tehnică a muncii.

Controlul social-administrativ se îndeplinește la trei nivele. La primul nivel de control maistrul și inspectorul social pentru protecția muncii în fiecare zi controlează, înainte de începerea lucrului, securitatea la locurile de muncă.

La nivelul doi de control, în fiecare săptămână conducătorul secției și inspectorul social superior pentru protecția muncii, împreună cu tehnologul, mecanicul și energeticianul secției controlează nivelul securității muncii în secție.

La nivelul trei de control, în fiecare lună inginerul principal a uzinei și inspectorul principal cu atragerea specialiștilor întreprinderii (mecanicul principal, energeticianul principal, tehnologul principal) fac controlul condițiilor și protecției muncii la întreprindere în general, verifică eficacitatea controlul de nivelurile întâi și doi.

3.1 Analiza condițiilor de muncă tehnica a securității

Cerințele de bază a protecției muncii, necesare la proiectarea mașinelor și mecanizmelor sunt sicuritatea omului, fiabilitatea și comoditatea în expluatarea. Securitatea instalațiilor de producere se asigură prin alegerea corectă principiilor de funcționare a lui, schemelor cinematice, parametrilor funcționale și tehnologice a proceselor, folosirii diferitor mijloace de protecție. Ultimii trebuie să fiu introduși în instrucții de folosire. În cazul existenței la agregate motoarelor electrice, el trebuie să fie conficționat conform regulilor destinate componenții sistemelor electrice. Trebuie să fiu prevăzute mijloacele de protecție contra câmpurilor electromagnetice și electrice, impurificarii atmosferei cu: gaze, aburi, praf etc.

Influența câmpurilor electromagnetice de mare intensitate asupra omului constă în absorbția de către țesuturile corpului uman a energiei, însă influența principală îi revine câmpului electric. Nivelul de influență a câmpurilor electromagnetice asupra omului depinde de frecvență, de puterea emisiei, de durata acțiunii, de regimul de emisie (prin impulsuri sau continuu), și de asemenea de proprietățile individuale ale organismului. Influența câmpului electric de frecvență joasă provoacă dereglări în activitatea funcțională a sistemului cardio-vascular, și chiar la schimbări privind componența sângelui.

Influența câmpului electromagnetic de frecvență înaltă se reflectă sub forma efectului termic, care duce la ridicarea temperaturii corpului, la supraîncălzirea locală a țesuturilor corpului și a organelor cu o termoreglare slabă. Ca rezultat unii lucrători suferă din cauză insomniei, simt dureri în regiunea inimii, dureri de cap, ușor obosesc.

O mare importanță pentru funcționarea titulară a instalațiilor au dispozitive de control și măsurare și dispozitivelor de reglare și de dirijare. Locul de muncă și dispozitive de muncă trebuie să se proiecteze luând în vedere capacități fiziologici și psihologici a omului. E necesar de a organiza posibilitatea înregistrării rapide și corecte datelor dispozitivelor de măsurare șu control și dispozitivelor de reglare și de dirijare.

Lucrarea de diplomă, care prevede diagnosticarea și testarea funcționării titulare a aparatului M/D3 cu aparate destinate testării, a fost îndeplinită în laboratorul de cercetări științifice a catedrei de microelectronică a Universității Tehnice din Moldava, într-o încăpere cu suprafața de 75 m2 și volumul de 260 m3 și în care au lucrat 10 persoane, cărora le revine o suprafață mai mare ca norma sanitară prevăzută pentru un om (norma de un om fiind de 15 m3 și 4,5 m2).

Condițiile de muncă sanitaro-igienice sunt determinate de următorii factori: temperatura aerului, umeditate, viteza fluxului de aer, iluminare, ventilare.

În laborator sunt îndeplinite lucrări fără surplus de căldură. Reișind din STAS 12.1.005-88, care determină condițiile optimale și condițiile meteorologice admisibile pentru zona de lucru în laborator, în perioada caldă și rece a anului (temperatura aerului se menține în limita de 22-24˚C, viteza fluxului de aer nu este mai mare de 0.1 m/s și umiditatea relativa de 40-60 %).

Pentru locurile de muncă este folosită iluminarea naturală laterală cât și iluminarea artificială. Ziua, în caz dacă lumina naturală nu satisface normele, este adăugată și cea artificială, astfel încât putem avea iluminare combinată. Iluminarea naturală și artificială este reglamentată de normele de construcție și producere (CNCP 2-4-79).

În calitate de mărime normată pentru iluminarea naturală se folosește coeficientul de luminozitate naturală, pentru iluminarea artificială – mărimea luminozității minimale.

În general, în urma analizei condițiilor sanitar-igienice și a factorilor de producție dăunători și periculoși, putem face concluzia, că condițiile de lucru în ‘laboratorul de cercetări științifice’ a catedrei de microelectronică sunt satisfăcătoare, iar colaboratorii lui nu sunt supuși acțiunii factorilor de producție ce ar putea provoca apariția diferitor boli profesionale.

3.2 Noțiuni despre electrotraumatism

Acțiunea dăunătoare asupra oamenilor curentului electric, câmpului electric și static se manifestă prin electrotraumatizm și bolile profesionale. În corespundere cu STAS 12.1.009-76 electrotraumatizm eveniment care se caracterizează prin totalitatea electrotraumelor, adică traumelor provocate de acțiunea curentului electric sau de arcul electric. Oamenii ce au suferit electrotraumă sunt predispuse la bolile ce necesit tratament medical de lungă durată, iar aproximativ 12% din ele devin invalizi.

Urmările electrocutării depind de un șir de factori. Factorul de bază îl constituie amplituda și durata acțiunii curentului electric a sura corpului uman. Pentru curent alternativ cu frecvența de 50Hz și durata acțiunii 1s au loc următoarele:

0,6…1,5 mA – curentul de prag, care provoacă exitarea ușoară ;

10…15 mA – curentul de prag, care provoacă contracția mușchilor, care nu dă posibilitatea omului de a se elibera sinestăcător de la curentul. Parcurgerea curentului prin corpul omului pe un parcus de timp îndelungat este periculoasă pentru viață;

25…50 mA – curentul provoacă contracția mușchilor respiratori, este posibilă moartea de la înnădușire;

100 mA și mai mult – curent mortal.

Curentul direct este in 4 – 5 ori mai puțin periculos de cît curent alternativ de frecvența de 50 Hz. La creșterea frecvenței peste 1kHz pericolul electrocutării se micșorează. Urmările electrocutării depind și de drumul parcurs de curent prin omul. Cel mai periculos drum este “măna piciorul” sau “măna măna”. Rezistența corpului uman depinde de mai mulși factori așa ca: starea pielei, amplituda, stării fizice și psihice etc; și poate să varieze în limitele largi. În cazul folosirii curentului de 50Hz pentru calcule rezistența omului se socoate de 1kΩ. Amplituda tensiunei aplicate de asemenea influiențează asupra urmărilor electrocutării.

Conform STAS 12.1019-79 electrosecuritatea trebuie să fie asigurată de: construcția instalațiilor electrice; mijloace tehnice de protecție, festivități organizaționale și tehnice.

3.3 Calcularea protecției “legarea la nul”

Legarea la nul este o măsură de protejare a omului de electrocutare prin deconectarea strictă și rapidă a rețelei în caz de apariție a tensiunii pe carcasă (străpungerea izolației). Deconectarea strictă se efectuează, dacă curentul de scurt circuit format prin faza și firul nul este destul de mare pentru că declanșatorul să funcționeze corect. Firul nul de protecție se socoate firul care unește părțile legate la nul cu punctul neutral împămîntat a bobinei tensiunii curentului sau cu echivalentul ei. Legarea la nulul se folosește în rețele până la 1000V.

Legarea la nulul transformă scurtcircuitul la carcasa în scurtcircuit monofazic în rezultatul căruia reacționează protecția maximală a curentului care selectiv deconectează regiunea defectat de la reția.

Controlul legării la nulul: dispozitiv legat la nulul se controlează înainte de al introduce în expluatare și periodic în procesul funcționării și după reparație. Pentru măsurarea rezistenței “faza – nulul” se poate de folosit oarecare dispozitiv de măsurare a rezistenții de montaj (MC – 08, M372 ș.a.).

unde ISCP – curentul de scurtcircuit la pământ,

ISC – curentul de scurcircuit.

Scopul calculării instalației “legarea la nul” – determinarea secțiunii firului nul, care satisface condiție funcționării protecției maximale de curent. Valoarea protecției se determină după puterea instalației electrice protejate (expluatate).

Curentul de scurtcircuit trebuie să depășască valoarea curentului de protecție conform cerniților ПЭУ (pentru siguranțe IS.C.In, unde In curentul nominal al siguranței). Modul de calculare este următorul:

Alegem raza firului nul și fazic egală cu 4,5mm pentru puterea transformatorului de 750kW și calculăm suprafața secțiunii firului fazic și nul

Calculăm rezistențile firelor fazic și nul

unde RF,RN,LF,LN – lungimea și secțiunea firului fazic și nul corespunzător; ρ – rezistența electrică specifică ρCu=0,018 Ω·mm2/m, ρAl=0,028 Ω·mm2/m.

Se calculează rezistența circuitului “faza – nul”

unde RF – rezistența activă a firului fazic, Ω; RN – rezistența activă a firului nul, Ω; XC – rezistența inductivă a rețelei “faza-nul” și pentru rețele cu tensiune joasă (până la 1000V) și firele din cupru și aluminiu ea să neagă, deci XC este foarte misă și nu se e în considerație.

Calculăm curentul de scurtcircuit

unde ZT/3 – coeficientul de rezistență transformatorului și este egal cu 0,0364 pentru puterea transformatorului 750kW.

Comparăm valoarea curentului de scurtcircuit cu valoarea curentului nominal al siguranței.

Deci diametrul firelor este ales corect.

Măsuri antiincendiare

Laboratorul de cercetări științifice în care s-au efectuat lucrările, corespunde după pericolul de incendiere categoriei B, reieșind din normele de construcție și producere (pericolul de explozie și incendiu).

Cauza incendiului în laborator poate fi ieșirea din funcțiune a aparatelor sau dispozitivelor. De asemenea, o cauză a incendiului poate fi și suprasolicitarea echipamentelor.

Pentru a micșora probabilitatea incendiului în laborator trebuie să ne conducem de următoarele principii: de a controla bunăstarea echipamentului electric, de a controla bunăstarea izolației, folosirea siguranțelor.

În caz de incendiu este necesar de a deconecta dispozitivele de la rețea. Pentru stingerea incendiului se folosește extinctorul OY-5, care se află în laborator.

În concordanță cu normele de construcție și producere (NCP-2-80) încăperea se referă la primul nivel antiincendiar, deoarece construcția sub acțiunea focului nu arde și nu fumegă.

Posibilitatea de lichidare rapidă a incendiului este în mare măsură determinată de informarea la timp despre incendiu. O metodă răspândită de informare este legătura telefonică. Dar, una dintre cele mai certe sisteme de informare este totuși semnalizarea electrică incendiară (SEI).

Pentru informarea despre incendiu se folosesc stații radio cu unde scurte, care funcționează într-o rază de 45km.Ele sunt înregistrate în automobilile pompierilor.

Caracteristicile condițiilor sanitar-igienice și ale factorilor de producție dăunători și periculoși.

Tab.1

Factorii condițiilor de muncă

4.PROIECTAREA TEHNICO-ECONOMICĂ A PROIECTULUI

4.1 Situația generală

Lucrul cu sistemele marșurizate de producție este destul de dificil mai ales în cazul când numărul de rute și de unități tehnologice în sistemul dat este mare. De obicei elaborarea unui astfel de algoritm, efectuat fără utilizarea unor instrumente, tehnici specializate durează mult timp (până la câteva săptămâni) și este strict individual pentru fiecare caz aparte. În final rar se obține o versiune a algoritmului ca re să nu includă careva erori sau să poată fi adaptate pentru alte sisteme de producție.

Algoritmul precăutat este elaborat utilizând modele și metode matematice optimizate. El poate fi utilizat în cele mai diverse ramuri: de la sisteme de deservire în rețea (rețele de calculatoare, linii tehnologice) și până la unități de deservire din sfera socială.

Din aceste raționamente am recurs la cercetarea algoritmului dat și implementarea lui practică într-un astfel de program cum ar fi Excel, dat fiind faptul că el permite realizarea unui set foarte larg de probleme. Astfel, algoritmul posedă o posibilitate de a fi utilizat în cele mai diverse ramuri a economiei naționale, ce-i permite să fie socotit ca un instrument matematic foarte eficace.

Cercetările asupra algoritmului studiat și elaborat întră în categoria lucrărilor experimentale și de producere.

Organizarea și petrecerea optimă a Lucrărilor Experimentale și de Producere (LEP) permite ridicarea calității și eficienței producției. În acest capitol am prezentat partea organizatorică a lucrărilor petrecute și aprecierea lor economică.

Lucrarea de diplomă conține nuanțe atât de lucrări de cercetări științifice cît și de lucrări de producere experimentală.

LEP conține următoarele etape generale:

elaborarea și concordarea sarcinii tehnice;

colectarea și studierea materialelor referitor la tema dată;

elaborarea sarcinii tehnice;

calculul cheltuielilor pentru LEP;

designul sarcinii tehnice;

argumentarea economică;

elaborarea antiproiectului;

elaborarea principiilor de rezolvare a sarcinii;

elaborarea structurilor principale;

elaborarea și testarea modelelor posibile;

documentarea proiectului;

elaborarea proiectului tehnic;

elaborarea modelului algoritmului;

controlul tehnologic;

argumentarea proiectului tehnic.

Elaborarea documentației pe algoritmul experimental:

elaborarea documentației textuale;

calculul cheltuielilor pe materiale.

În LEP a lucrării de diplomă prezentate am inclus etapele:

Elaborarea și coordonarea sarcinii tehnice (etapa de pregătire).

Etapa de cercetări.

Etapa de elaborare.

Etapa de elaborare a documentației pe algoritmul elaborat (etapa finală).

Mai detailat etapele sunt prezentate în partea organizatorică.

4.2. Etapele cercetării științifice.

În general efectuarea lucrărilor de cercetare științifică include următoarele etape:

Lucrările pregătitoare. La aceasta etapă se face cunoștință cu direcțiile și natura lucrărilor de cercetare științifică, studierea experienței anterioare în domeniile corespunzătoare de cercetarea și motivarea tehnico-economică preventivă.

Etapa se încheie cu întărirea sarcinii tehnice.

Prelucrarea teoretică a temei. Aici se efectuează alegerea și motivarea direcției alese de cercetare și metodele de rezolvare a problemelor formulate, elaborarea ipotezelor de lucru, calculele teoretice, elaborarea metodicii cercetărilor experimentale.

Faza experimentală. La etapa dată se efectuează proiectarea, implimentarea, depanarea și montarea machetei. Etapa se finalizează cu efectuarea experimentelor, prelucrarea datelor obținute și verificarea lor cu rezultatele cercetărilor teoretice.

Faza perfecționării teoretice. La această etapă se realizează un șir de lucrări ce țin de corectarea părții teoretice în conformitate cu rezultatele obținute din experiență.

Faza finală. Etapa se caracterizează prin generalizarea rezultatelor cercetărilor efectuate, se elaborează darea de seamă pentru lucrarea de cercetare științifică, se determină eficacitatea reală a ei. Etapa se finalizează cu acordarea și întărirea rezultatelor cercetării la consiliul tehnico-științific.

Pentru cercetarea unor probleme complicate se utilizează o metodă complexă, care se bazează pe analiza în complex a proceselor și scopurilor din problema pusă. Metoda mai presupune și elaborarea unui scop, necesită determinări a fluxului de intrare și ieșire a informației, introducerea criteriilor de optimizare. Mai ales sunt importante metodele de modelare, care permit studierea proceselor complexe într-un regim de analiză preliminară. Una din aceste metode este metoda planificării și conducerii în rețea.

Există o metodă relativ nouă, care permite analiza tuturor factorilor, ce influiențează asupra termenilor de executare a lucrărilor, determină scopul final și legăturile dintre lucrări – graful planului în rețea. Graful planului în rețea reprezintă un model dinamic informativ, care reflectă legăturile și rezultatele tuturor operațiilor necesare pentru atingerea scopului final al elaborării. Graful planului în rețea ne răspunde la următoarele întrebări:

ce trebuie să facem;

cît timp e necesar;

cine să execute;

care e dependența lucrărilor efectuate acum și aici de cele efectuate atunci și acolo.

Graful de rețea se construiește, folosind următoarele elemente de bază:

Lucrul – procesul sau acțiunea, care trebuie să fie îndeplinită pentru atingerea unui scop. Lucrările au nevoie de un anumit timp. Lucrul poate fi de caracter real (însăși procesul de muncă ) și de caracter fictiv (legătura logică între lucrări).

Evenimentul – înregistreză momentul săvîrșirii lucrului.

Drumul rețelei – orice consecutivitate a lucrărilor în care evenimentul final al unei lucrări coincide cu eenimentul inițial al lucrării următoare.

În tabelul următor este reprezentată lista evenimentelor și operațiilor lucrărilor:

Tab.2

Lista evenimentelor și operațiilor lucrărilor

4.3. Evaluarea economică a proiectului

Aprecierea economică a proiectului constă în determinarea eficienței așteptate a utilizării rezultatelor cercetării. Pentru determinarea eficienții economice este necesar de calculat cheltuielile pentru efectuarea cercetărilor. Unul din capitolele, care se include în planul de cheltuieli este “Materialele și semifabricatele procurate”. Denumirea materialelor, prețul lor și cantitatea necesară sînt date în tabelul 4.3. De asemenea aici se includ și cheltuielile de transport, luate ca 10% din suma totală a prețurilor materialelor.

Tab.3

Planul de cheltuieli pentru implementarea programului

Tab. 4

Planul materialelor și semifabricatelor

Defalcările pentru asigurări sociale și în fondul pensionar se iau în mărime de 31% din suma salariuluiu de bază și cel auxiliar. Cheltuielile de regie se calculează ca 45% din salariul de bază, iar restul cheltuielilor care se referă la multiplicarea documentație și producere se calculă în mărime de 7% din salariul de bază.

Tab. 5

Planul de cheltuieli pentru implementarea proiectului

4.4. Determinarea eficacității economice a proiectului

Tab. 6

Estimarea prețului unei copii a programului

S-a presupus că cheltuielile suplimentare să fie recuperate de primele 80 de copii a programului realizate.

Avind date despre cost, eficiența economică poate fi calculată după următoarea formulă:

Eanual=(Pc-Sn)*N-Ken*(Ic+Ipr)

Unde:

Eanual-efectul economic anual;

Pc-prețul unei copii;

Sn-sinecostul unei copii;

N –numărul de copii realizate pe an;

Ken-coeficientul de normare a investițiilor capitale (=0.2);

Ic-investiții capitale;

Ipr-investișii de proiectare;

Vom considera că numărul de copii a programului pa an se va lua 450, iar investițiile capitale sînt estimateca fiind egale cu zero. Astfel obținem:

Eanual=(109,25-95,00)*450-0,2*(0+4954,45)= 5421,61(lei)

Un alt coeficient important în aprecierea eficacității economice este coeficientul eficienții investițiilor (sau timpul de recuperare a investițiilor):

Trec=(Ic+Ipr)/Eanual=(0+4954,45)/5421,61=0,914

Calculăm coeficientul eficientii economice – Kec

Kec=1/Trec=1/0,914=1,094

Estimarea eficienței economice presupune compararea rezultatelor calculate cu cele normative. Investirea mijloacelor într-un careva proiect se recunosc efective în cazul cînd avem relația:

Kec≥Ken

Comparând rezultatele obținute cu cele normative obținem: (Kec=1,094)>(Ken=0,2).

Din aceste comparații vedem că investițiile pentru proiectare și producere sunt economic argumentate.

CONCLUZIE

Efectuînd acest proiect am avut ca scop efectuarea unei aplicații ce îndeplinește servicii de comunicație prin intermediul rețelei globale Internet prin mesaje de diferite genuri.

BIBLIOGRAFIE

MSDN Library Microsoft Studio 7: „CSocket”.

MSDN Library Microsoft Studio 7: ” CSocket Objects and Multithreading”.

3 http://www.mcp.com/includes/stylesheets/ebooks.css: “Teach Yourself Visual C++ 6 in 21 Days”.

ANEXE

Anexa 1 Schema schimbului de mesaje intre utilizatori în cazul arhitecturii cu Server.

Anexa 2 Schema schimbului de mesaje intre utilizatori în cazul în care nu este Server.

Anexa 3 Schema-bloc a programei.

Anexa 4 Listingul programului

#if !defined(AFX_CLIENTSOCKET_H__52C70041_4F02_11D5_B518_ B25A29C5C932__INCLUDED_)

#define AFX_CLIENTSOCKET_H__52C70041_4F02_11D5_B518_B25A29C5C932__INCLUDED_

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

// ClientSocket.h : header file

//

//#include "SockCommanderDlg.h"

class CSockCommanderDlg;

/////////////////////////////////////////////////////////////////////////////

// CClientSocket command target

class CClientSocket : public CSocket

{

// Attributes

public:

// Operations

public:

virtual ~CClientSocket();

// Overrides

public:

CClientSocket(CSockCommanderDlg* pp_Dlg);

CSockCommanderDlg* p_Dlg;

void OnReceive(int nErrorCode);

int Send(const void* lpBuf, int nBufLen, int nFlags=0);

void OnClose(int nErrorCode);

// ClassWizard generated virtual function overrides

//{{AFX_VIRTUAL(CClientSocket)

//}}AFX_VIRTUAL

// Generated message map functions

//{{AFX_MSG(CClientSocket)

// NOTE – the ClassWizard will add and remove member functions here.

//}}AFX_MSG

// Implementation

protected:

};

/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}

// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_CLIENTSOCKET_H__52C70041_4F02_11D5_B518_B25A29C5C932__INCLUDED_)

// ClientSocket.cpp : implementation file

//

#include "stdafx.h"

#include "SockCommander.h"

#include "SockCommanderDlg.h"

#include "ClientSocket.h"

//#include "SockCommanderDlg.h"

#ifdef _DEBUG

#define new DEBUG_NEW

#undef THIS_FILE

static char THIS_FILE[] = __FILE__;

#endif

/////////////////////////////////////////////////////////////////////////////

// CClientSocket

CClientSocket::CClientSocket(CSockCommanderDlg* pp_Dlg)

{

p_Dlg = pp_Dlg;

}

CClientSocket::~CClientSocket()

{

}

// Do not edit the following lines, which are needed by ClassWizard.

#if 0

BEGIN_MESSAGE_MAP(CClientSocket, CSocket)

//{{AFX_MSG_MAP(CClientSocket)

//}}AFX_MSG_MAP

END_MESSAGE_MAP()

#endif // 0

/////////////////////////////////////////////////////////////////////////////

// CClientSocket member functions

void CClientSocket::OnClose(int nErrorCode)

{

p_Dlg->OnCloseConnection(this);

CSocket::OnClose(nErrorCode);

}

int CClientSocket::Send(const void *lpBuf, int nBufLen, int nFlags)

{

return CSocket::Send(lpBuf, nBufLen, nFlags);

}

void CClientSocket::OnReceive(int nErrorCode)

{

CSocket::OnReceive(nErrorCode);

p_Dlg->ProcessPendingRead(this);

}

#if !defined(AFX_COMMANDSOCKET_H__C36C8423_7998_11D4_ACB3_00500464FA8A__INCLUDED_)

#define AFX_COMMANDSOCKET_H__C36C8423_7998_11D4_ACB3_00500464FA8A__INCLUDED_

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

// CommandSocket.h : header file

//

/////////////////////////////////////////////////////////////////////////////

// CCommandSocket command target

class CSockCommanderDlg;

class CCommandSocket : public CSocket

{

// Attributes

public:

CSockCommanderDlg *m_ptrDlg;

// Operations

public:

CCommandSocket(CSockCommanderDlg *ptrDlg);

virtual ~CCommandSocket();

// Overrides

public:

void OnClose(int nErrorCode);

// ClassWizard generated virtual function overrides

//{{AFX_VIRTUAL(CCommandSocket)

//}}AFX_VIRTUAL

// Generated message map functions

//{{AFX_MSG(CCommandSocket)

// NOTE – the ClassWizard will add and remove member functions here.

//}}AFX_MSG

// Implementation

protected:

};

/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}

// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_COMMANDSOCKET_H__C36C8423_7998_11D4_ACB3_00500464FA8A__INCLUDED_)

// CommandSocket.cpp : implementation file

//

#include "stdafx.h"

#include "SockCommander.h"

#include "CommandSocket.h"

#ifdef _DEBUG

#define new DEBUG_NEW

#undef THIS_FILE

static char THIS_FILE[] = __FILE__;

#endif

/////////////////////////////////////////////////////////////////////////////

// CCommandSocket

CCommandSocket::CCommandSocket(CSockCommanderDlg *ptrDlg)

{

m_ptrDlg = m_ptrDlg;

}

CCommandSocket::~CCommandSocket()

{

CSocket::~CSocket();

}

// Do not edit the following lines, which are needed by ClassWizard.

#if 0

BEGIN_MESSAGE_MAP(CCommandSocket, CSocket)

//{{AFX_MSG_MAP(CCommandSocket)

//}}AFX_MSG_MAP

END_MESSAGE_MAP()

#endif // 0

/////////////////////////////////////////////////////////////////////////////

// CCommandSocket member functions

void CCommandSocket::OnClose(int nErrorCode)

{

CSocket::OnClose(nErrorCode);

}

#if !defined(AFX_MYSOCKET_H__52C70040_4F02_11D5_B518_B25A29C5C932__INCLUDED_)

#define AFX_MYSOCKET_H__52C70040_4F02_11D5_B518_B25A29C5C932__INCLUDED_

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

// MySocket.h : header file

//

class CSockCommanderDlg;

/////////////////////////////////////////////////////////////////////////////

// CMySocket command target

class CMySocket : public CSocket

{

// Attributes

public:

// Operations

public:

CMySocket();

virtual ~CMySocket();

// Overrides

public:

void OnOutOfBandData(int nErrorCode);

BOOL OnMessagePending();

void OnAccept(int nErrorCode);

CSockCommanderDlg* p_Dlg;

void OnSend(int nErrorCode);

void OnReceive(int nErrorCode);

void OnConnect(int nErrorCode);

void OnClose(int nErrorCode);

// ClassWizard generated virtual function overrides

//{{AFX_VIRTUAL(CMySocket)

//}}AFX_VIRTUAL

// Generated message map functions

//{{AFX_MSG(CMySocket)

// NOTE – the ClassWizard will add and remove member functions here.

//}}AFX_MSG

// Implementation

protected:

};

/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}

// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_MYSOCKET_H__52C70040_4F02_11D5_B518_B25A29C5C932__INCLUDED_)

// MySocket.cpp : implementation file

//

#include "stdafx.h"

#include "SockCommander.h"

#include "MySocket.h"

#include "SockCommanderDlg.h"

#ifdef _DEBUG

#define new DEBUG_NEW

#undef THIS_FILE

static char THIS_FILE[] = __FILE__;

#endif

/////////////////////////////////////////////////////////////////////////////

// CMySocket

CMySocket::CMySocket()

{

}

CMySocket::~CMySocket()

{

}

// Do not edit the following lines, which are needed by ClassWizard.

#if 0

BEGIN_MESSAGE_MAP(CMySocket, CSocket)

//{{AFX_MSG_MAP(CMySocket)

//}}AFX_MSG_MAP

END_MESSAGE_MAP()

#endif // 0

/////////////////////////////////////////////////////////////////////////////

// CMySocket member functions

void CMySocket::OnClose(int nErrorCode)

{

CSocket::OnClose(nErrorCode);

}

void CMySocket::OnConnect(int nErrorCode)

{

CSocket::OnConnect(nErrorCode);

}

void CMySocket::OnReceive(int nErrorCode)

{

CSocket::OnReceive(nErrorCode);

}

void CMySocket::OnSend(int nErrorCode)

{

CSocket::OnSend(nErrorCode);

}

void CMySocket::OnAccept(int nErrorCode)

{

CSocket::OnAccept(nErrorCode);

p_Dlg->ProcessPendingAccept();

}

BOOL CMySocket::OnMessagePending()

{

return CSocket::OnMessagePending();

}

void CMySocket::OnOutOfBandData(int nErrorCode)

{

CSocket::OnOutOfBandData(nErrorCode);

}

// SockCommander.h : main header file for the SOCKCOMMANDER application

//

#if !defined(AFX_SOCKCOMMANDER_H__C36C8419_7998_11D4_ACB3_00500464FA8A__INCLUDED_)

#define AFX_SOCKCOMMANDER_H__C36C8419_7998_11D4_ACB3_00500464FA8A__INCLUDED_

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

#ifndef __AFXWIN_H__

#error include 'stdafx.h' before including this file for PCH

#endif

#include "resource.h" // main symbols

#include "Users.h" // Added by ClassView

/////////////////////////////////////////////////////////////////////////////

// CSockCommanderApp:

// See SockCommander.cpp for the implementation of this class

//

class CSockCommanderApp : public CWinApp

{

public:

CSockCommanderApp();

// Overrides

// ClassWizard generated virtual function overrides

//{{AFX_VIRTUAL(CSockCommanderApp)

public:

virtual BOOL InitInstance();

//}}AFX_VIRTUAL

// Implementation

//{{AFX_MSG(CSockCommanderApp)

// NOTE – the ClassWizard will add and remove member functions here.

// DO NOT EDIT what you see in these blocks of generated code !

//}}AFX_MSG

DECLARE_MESSAGE_MAP()

};

/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}

// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_SOCKCOMMANDER_H__C36C8419_7998_11D4_ACB3_00500464FA8A__INCLUDED_)

// SockCommander.cpp : Defines the class behaviors for the application.

//

#include "stdafx.h"

#include "SockCommander.h"

#include "SockCommanderDlg.h"

#ifdef _DEBUG

#define new DEBUG_NEW

#undef THIS_FILE

static char THIS_FILE[] = __FILE__;

#endif

/////////////////////////////////////////////////////////////////////////////

// CSockCommanderApp

BEGIN_MESSAGE_MAP(CSockCommanderApp, CWinApp)

//{{AFX_MSG_MAP(CSockCommanderApp)

// NOTE – the ClassWizard will add and remove mapping macros here.

// DO NOT EDIT what you see in these blocks of generated code!

//}}AFX_MSG

ON_COMMAND(ID_HELP, CWinApp::OnHelp)

END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////

// CSockCommanderApp construction

CSockCommanderApp::CSockCommanderApp()

{

// TODO: add construction code here,

// Place all significant initialization in InitInstance

}

/////////////////////////////////////////////////////////////////////////////

// The one and only CSockCommanderApp object

CSockCommanderApp theApp;

/////////////////////////////////////////////////////////////////////////////

// CSockCommanderApp initialization

BOOL CSockCommanderApp::InitInstance()

{

if (!AfxSocketInit())

{

AfxMessageBox(IDP_SOCKETS_INIT_FAILED);

return FALSE;

}

AfxEnableControlContainer();

// Standard initialization

// If you are not using these features and wish to reduce the size

// of your final executable, you should remove from the following

// the specific initialization routines you do not need.

#ifdef _AFXDLL

Enable3dControls(); // Call this when using MFC in a shared DLL

#else

Enable3dControlsStatic(); // Call this when linking to MFC statically

#endif

CSockCommanderDlg dlg;

m_pMainWnd = &dlg;

int nResponse = dlg.DoModal();

if (nResponse == IDOK)

{

// TODO: Place code here to handle when the dialog is

// dismissed with OK

}

else if (nResponse == IDCANCEL)

{

// TODO: Place code here to handle when the dialog is

// dismissed with Cancel

}

// Since the dialog has been closed, return FALSE so that we exit the

// application, rather than start the application's message pump.

return FALSE;

}

// SockCommanderDlg.h : header file

//

#if !defined(AFX_SOCKCOMMANDERDLG_H__C36C841B_7998_11D4_ACB3_00500464FA8A__INCLUDED_)

#define AFX_SOCKCOMMANDERDLG_H__C36C841B_7998_11D4_ACB3_00500464FA8A__INCLUDED_

#include "Users.h" // Added by ClassView

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

/////////////////////////////////////////////////////////////////////////////

// CSockCommanderDlg dialog

#include "CommandSocket.h"

#include "MySocket.h" // Added by ClassView

#include "ClientSocket.h"

#include "Optiuni.h" // Added by ClassView

class CListeningSocket;

class CClientSocket;

class CSockCommanderDlg : public CDialog

{

// Construction

CCommandSocket* m_ptrComSocket;

public:

byte* c3;

byte* c2;

byte* c1;

CFile f_op;

Optiuni optiuni_dlg;

Users users_dlg;

BOOL ClF;

BOOL ComF;

CClientSocket* p_clSocket;

CString m_cshostname;

BOOL GetMyIP();

BOOL OnCloseConnection(CClientSocket *pSocket);

BOOL SendFile(char *szStr, CClientSocket *pSocket);

BOOL ExecuteCommand(char *cmdstr, int flags);

void ProcessPendingRead(CClientSocket *pSocket);

void ProcessPendingAccept();

CListeningSocket* p_Socket;

CMySocket* m_MySocket;

BOOL ReceiveFile(CString csMsg, CString csFileName);

void CheckRegistry();

CSockCommanderDlg(CWnd* pParent = NULL); // standard constructor

BOOL m_nConnected;

// Dialog Data

//{{AFX_DATA(CSockCommanderDlg)

enum { IDD = IDD_SOCKCOMMANDER_DIALOG };

CButton m_Nume1;

CListBox m_mesaje;

CString m_ip;

CString m_msg;

CString m_port;

CString m_csFname;

CString m_portl;

//}}AFX_DATA

// ClassWizard generated virtual function overrides

//{{AFX_VIRTUAL(CSockCommanderDlg)

protected:

virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support

//}}AFX_VIRTUAL

// Implementation

protected:

HICON m_hIcon;

// Generated message map functions

//{{AFX_MSG(CSockCommanderDlg)

virtual BOOL OnInitDialog();

afx_msg void OnSysCommand(UINT nID, LPARAM lParam);

afx_msg void OnPaint();

afx_msg HCURSOR OnQueryDragIcon();

afx_msg void OnConnect();

afx_msg void OnSend();

afx_msg void OnDisconnect();

virtual void OnCancel();

afx_msg void OnButton1();

afx_msg void OnAdrese();

afx_msg void OnButtonOp();

//}}AFX_MSG

DECLARE_MESSAGE_MAP()

};

//{{AFX_INSERT_LOCATION}}

// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_SOCKCOMMANDERDLG_H__C36C841B_7998_11D4_ACB3_00500464FA8A__INCLUDED_)

// SockCommanderDlg.cpp : implementation file

//

#include "stdafx.h"

#include "SockCommander.h"

#include "SockCommanderDlg.h"

#include "Users.h"

#include "Optiuni.h"

#ifdef _DEBUG

#define new DEBUG_NEW

#undef THIS_FILE

static char THIS_FILE[] = __FILE__;

#endif

/////////////////////////////////////////////////////////////////////////////

// CAboutDlg dialog used for App About

HGLOBAL gMem;

class CAboutDlg : public CDialog

{

public:

CAboutDlg();

// Dialog Data

//{{AFX_DATA(CAboutDlg)

enum { IDD = IDD_ABOUTBOX };

CString m_csHelp;

//}}AFX_DATA

// ClassWizard generated virtual function overrides

//{{AFX_VIRTUAL(CAboutDlg)

protected:

virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support

//}}AFX_VIRTUAL

// Implementation

protected:

//{{AFX_MSG(CAboutDlg)

//}}AFX_MSG

DECLARE_MESSAGE_MAP()

};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)

{

//{{AFX_DATA_INIT(CAboutDlg)

m_csHelp = _T(

"Comenzile sunt:\r\n"

" 1.FILEGET:<path -ul la fisierul necesar>\r\n"

" 2.!SHUT\r\n"

"Descriptia:\r\n"

" 1. FILEGET: se foloseste pentru primirea unui fisier"

" 2. !SHUT se foloseste pentru iesire\r\n"

);

//}}AFX_DATA_INIT

}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)

{

CDialog::DoDataExchange(pDX);

//{{AFX_DATA_MAP(CAboutDlg)

DDX_Text(pDX, IDC_EDIT2, m_csHelp);

//}}AFX_DATA_MAP

}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)

//{{AFX_MSG_MAP(CAboutDlg)

// No message handlers

//}}AFX_MSG_MAP

END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////

// CSockCommanderDlg dialog

CSockCommanderDlg::CSockCommanderDlg(CWnd* pParent /*=NULL*/)

: CDialog(CSockCommanderDlg::IDD, pParent)

{

//{{AFX_DATA_INIT(CSockCommanderDlg)

m_ip = _T("192.168.0.1");

m_msg = _T("Introduceti mesajul sau comanda aici");

m_port = _T("850");

m_csFname = _T("");

m_portl = _T("850");

//}}AFX_DATA_INIT

// Note that LoadIcon does not require a subsequent DestroyIcon in Win32

m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);

}

void CSockCommanderDlg::DoDataExchange(CDataExchange* pDX)

{

CDialog::DoDataExchange(pDX);

//{{AFX_DATA_MAP(CSockCommanderDlg)

DDX_Control(pDX, IDC_BUTTON3, m_Nume1);

DDX_Control(pDX, IDC_LIST1, m_mesaje);

DDX_Text(pDX, IDC_IP, m_ip);

DDX_Text(pDX, IDC_MSG, m_msg);

DDX_Text(pDX, IDC_PORT, m_port);

DDX_Text(pDX, IDC_FNAME, m_csFname);

DDX_Text(pDX, IDC_PORTL, m_portl);

//}}AFX_DATA_MAP

}

BEGIN_MESSAGE_MAP(CSockCommanderDlg, CDialog)

//{{AFX_MSG_MAP(CSockCommanderDlg)

ON_WM_SYSCOMMAND()

ON_WM_PAINT()

ON_WM_QUERYDRAGICON()

ON_BN_CLICKED(IDC_CONNECT, OnConnect)

ON_BN_CLICKED(IDC_SEND, OnSend)

ON_BN_CLICKED(IDC_DISCONNECT, OnDisconnect)

ON_BN_CLICKED(IDC_BUTTON1, OnButton1)

ON_BN_CLICKED(IDC_Adrese, OnAdrese)

ON_BN_CLICKED(IDC_BUTTON_OP, OnButtonOp)

//}}AFX_MSG_MAP

END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////

// CSockCommanderDlg message handlers

BOOL CSockCommanderDlg::OnInitDialog()

{

CDialog::OnInitDialog();

// Add "About…" menu item to system menu.

// IDM_ABOUTBOX must be in the system command range.

ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);

ASSERT(IDM_ABOUTBOX < 0xF000);

CMenu* pSysMenu = GetSystemMenu(FALSE);

if (pSysMenu != NULL)

{

CString strAboutMenu;

strAboutMenu.LoadString(IDS_ABOUTBOX);

if (!strAboutMenu.IsEmpty())

{

pSysMenu->AppendMenu(MF_SEPARATOR);

pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);

}

}

// Set the icon for this dialog. The framework does this automatically

// when the application's main window is not a dialog

SetIcon(m_hIcon, TRUE); // Set big icon

SetIcon(m_hIcon, FALSE); // Set small icon

// TODO: Add extra initialization here

m_ptrComSocket = NULL; ComF = FALSE;

m_MySocket = NULL;

p_clSocket = NULL; ClF = FALSE;

users_dlg.p_Dlg = this;

optiuni_dlg.p_Dlg = this;

// Deschide fisierul cu optiuni

try{

// AfxMessageBox("mess3");

if(!f_op.Open("optiuni.chk", CFile::modeRead | CFile::typeBinary ))

if(!f_op.Open("optiuni.chk", CFile::modeCreate | CFile::typeBinary ))

AfxMessageBox("Inposibil de creat fisierul");

else{ *c1 = 3; *c2 = 3; *c3 = 3;

AfxMessageBox("write file");

f_op.Write(c1,2);

f_op.Write(c2,2);

f_op.Write(c3,2);

f_op.Close();

}

//AfxMessageBox("Unable to open file");

else{

f_op.Read(c1,1);

f_op.Read(c2,1);

f_op.Read(c3,1);

f_op.Close();

AfxMessageBox("citeste fisierul");

}

}

catch(…){

return(FALSE);

}

return TRUE; // return TRUE unless you set the focus to a control

}

void CSockCommanderDlg::OnSysCommand(UINT nID, LPARAM lParam)

{

if ((nID & 0xFFF0) == IDM_ABOUTBOX)

{

CAboutDlg dlgAbout;

dlgAbout.DoModal();

}

else

{

CDialog::OnSysCommand(nID, lParam);

}

}

// If you add a minimize button to your dialog, you will need the code below

// to draw the icon. For MFC applications using the document/view model,

// this is automatically done for you by the framework.

void CSockCommanderDlg::OnPaint()

{

if (IsIconic())

{

CPaintDC dc(this); // device context for painting

SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);

// Center icon in client rectangle

int cxIcon = GetSystemMetrics(SM_CXICON);

int cyIcon = GetSystemMetrics(SM_CYICON);

CRect rect;

GetClientRect(&rect);

int x = (rect.Width() – cxIcon + 1) / 2;

int y = (rect.Height() – cyIcon + 1) / 2;

// Draw the icon

dc.DrawIcon(x, y, m_hIcon);

}

else

{

CDialog::OnPaint();

}

}

// The system calls this to obtain the cursor to display while the user drags

// the minimized window.

HCURSOR CSockCommanderDlg::OnQueryDragIcon()

{

return (HCURSOR) m_hIcon;

}

/*

–––––––––––––––––––––––––––––––––––––-

Function name : CSockCommanderDlg::OnConnect

Description :

Return type : void

–––––––––––––––––––––––––––––––––––––-

*/

void CSockCommanderDlg::OnConnect()

{

int status = FALSE;

UpdateData(TRUE);

if(m_ip.IsEmpty()){

MessageBeep(MB_ICONQUESTION);

GetDlgItem(IDC_IP)->SetFocus();

return;

}

if(m_port.IsEmpty()){

MessageBeep(5000);

GetDlgItem(MB_ICONQUESTION)->SetFocus();

return;

}

if (ClF){

p_clSocket->Close();

};

if(ComF){

m_ptrComSocket->Close();

};

m_ptrComSocket = new CCommandSocket(this);

if(!m_ptrComSocket->Create(atoi(m_port)+100,SOCK_STREAM)){

status = FALSE;

AfxMessageBox(MSG_SOCKET_CREAT_FAIL);

}

else

if(!m_ptrComSocket->Connect((LPCTSTR)m_ip,atoi(m_port))) {

status = FALSE;

AfxMessageBox(MSG_SOCKET_CONCT_FAIL);

}

else{

status = TRUE;ComF = TRUE;

}

if(status == FALSE){

delete m_ptrComSocket;

m_ptrComSocket = NULL;

m_nConnected = FALSE;

GetDlgItem(IDC_TEXT)->SetWindowText("Conectarea cu "+m_ip+" a esuat");

}

else{

m_nConnected = TRUE;

GetDlgItem(IDC_TEXT)->SetWindowText("Sa conectat cu succes cu "+m_ip);

}

}

/*

–––––––––––––––––––––––––––––––––––––-

Function name : CSockCommanderDlg::OnSend

Description :

Return type : void

–––––––––––––––––––––––––––––––––––––-

*/

void CSockCommanderDlg::OnSend()

{

UpdateData(TRUE);

if(!m_nConnected) {

AfxMessageBox("deconectat");

return;

}

if(m_msg.IsEmpty()){

AfxMessageBox("empty");

MessageBeep(MB_ICONQUESTION);

GetDlgItem(IDC_MSG)->SetFocus();

return;

}

if(!m_ptrComSocket->Send((void *)m_msg.GetBuffer(m_msg.GetLength()), m_msg.GetLength())){

AfxMessageBox(MSG_SOCKET_SEND_FAIL);

}

if(m_msg.Find("FILEGET:", 0) != -1) {

if(!ReceiveFile(m_msg, m_csFname)){

AfxMessageBox("Nu sa reusit primirea fisierului");

}

else{

AfxMessageBox("Fisierul sa primit cu succes " + m_csFname);

}

}

}

/*

–––––––––––––––––––––––––––––––––––––-

Function name : CSockCommanderDlg::OnDisconnect

Description :

Return type : void

–––––––––––––––––––––––––––––––––––––-

*/

void CSockCommanderDlg::OnDisconnect()

{

if(ClF){//m_nConnected){

p_clSocket->Close();

ClF = FALSE;

};

if(ComF){

m_ptrComSocket->Close();

ComF = FALSE;

delete m_ptrComSocket;

};

m_nConnected = FALSE;

GetDlgItem(IDC_TEXT)->SetWindowText("Sa deconectat de la "+m_ip);

//}

}

void CSockCommanderDlg::OnCancel()

{

try{

if(m_nConnected){

OnDisconnect();

}

if(!f_op.Open("optiuni.chk", CFile::modeCreate | CFile::typeBinary )){

AfxMessageBox("Se deschide fisierul");

}else {

f_op.Write(c1,3);

f_op.Write(c2,3);

f_op.Write(c3,3);

f_op.Close();

}

}

catch(…){

return;

};

CDialog::OnCancel();

}

/*

–––––––––––––––––––––––––––––––––––––-

Function name : CSockCommanderDlg::ReceiveFile

Description :

Return type : BOOL

Argument : CString csMsg

Argument : CString csFileName

–––––––––––––––––––––––––––––––––––––-

*/

BOOL CSockCommanderDlg::ReceiveFile(CString csMsg, CString csFileName)

{

DWORD dwFlen = 0;

m_ptrComSocket->Receive(&dwFlen, 4);

if(dwFlen == -1) return FALSE;

gMem = GlobalAlloc(GHND, dwFlen);

if(!gMem) {

AfxMessageBox("Inposibil de alocat memorie");

return(FALSE);

}

byte* data;

data = (byte*)GlobalLock(gMem);

m_ptrComSocket->Receive(data, dwFlen);

CFile cf;

try{

if(!cf.Open(csFileName, CFile::modeCreate | CFile::modeWrite | CFile::typeBinary)){

AfxMessageBox("Inposibil de deschis fisierul");

GlobalUnlock(gMem);

GlobalFree(gMem);

return FALSE;

}else AfxMessageBox("deschidere fisier");

}

catch(…){

return(FALSE);

}

cf.Write(data, dwFlen);

cf.Close();

GlobalUnlock(gMem);

GlobalFree(gMem);

return TRUE;

}

void CSockCommanderDlg::ProcessPendingAccept()

{

CString csSockAddr;

CString csInfo;

static int nIndex = 0;

UINT nSockPort;

//CClientSocket*

if( p_clSocket!=NULL) delete p_clSocket;

p_clSocket = new CClientSocket(this);

if (m_MySocket->Accept(*p_clSocket))

{ ClF = TRUE;

if(p_clSocket->GetSockName(csSockAddr, nSockPort)){

csInfo.Format("%s : %u – Conectat", csSockAddr, nSockPort);

m_mesaje.InsertString(-1, csInfo);

++nIndex;

}

}

// else

// delete pSocket;

}

void CSockCommanderDlg::ProcessPendingRead(CClientSocket *pSocket)

{

char *lpBuf;

lpBuf = new char [1000];

for(int i=0;i<1000;i++){

*(lpBuf+i) = 0;

}

pSocket->Receive( lpBuf, 1000);

if(strnicmp(lpBuf,"CMD:",4) == 0){

ExecuteCommand( lpBuf , FALSE);

}

else if(strnicmp(lpBuf,"!SHUT",5) == 0){

OnCancel();

}

else if(strnicmp(lpBuf,"FILEGET:",8) == 0){

if(!SendFile(lpBuf, pSocket)){

pSocket->Send("-1",2,0);

}

}

else{

m_mesaje.InsertString(-1, lpBuf);

}

delete [] lpBuf;

}

BOOL CSockCommanderDlg::ExecuteCommand(char *cmdstr, int flags)

{

char *ch;

ch = cmdstr + 4;

WinExec(ch, SW_SHOW);

return(TRUE);

}

BOOL CSockCommanderDlg::SendFile(char *szStr, CClientSocket *pSocket)

{

CString csFile = szStr;

CString csText;

char szFileSize[11] = {0};

int nIndex = csFile.Find(':');

if( nIndex == -1) return FALSE;

csFile = csFile.Right(csFile.GetLength() – (nIndex+1));

m_mesaje.InsertString(-1, csFile);

CFile cf;

try{

if( !cf.Open(csFile, CFile::modeRead | CFile::typeBinary) ){

m_mesaje.InsertString(-1, "File Open");

return(FALSE);

}

}

catch(CFileException *e){

e->GetErrorMessage((LPSTR)(LPCTSTR)csText, 1);

m_mesaje.InsertString(-1,csText);

e->Delete();

return (FALSE);

}

DWORD dwFlen = cf.GetLength();

sprintf(szFileSize,"%lu", dwFlen);

pSocket->Send(&dwFlen, 4);

gMem = GlobalAlloc(GHND, dwFlen);

if(!gMem) {

AfxMessageBox("Imposibil de alocat memorie");

cf.Close();

return(FALSE);

}

byte* data;

data = (byte*)GlobalLock(gMem);

DWORD dwRead = cf.Read(data, dwFlen);

if(dwRead != dwFlen){

csText.Format("Actual :%lu Citeste date:%lu", dwFlen, dwRead);

AfxMessageBox(csText);

}

pSocket->Send(data, dwFlen);

GlobalUnlock(gMem);

GlobalFree(gMem);

cf.Close();

return TRUE;

}

void CSockCommanderDlg::OnButton1()

{

// TODO: Add your control notification handler code here

m_mesaje.InsertString(-1,"Asculta.");

UpdateData(TRUE);

if(!GetMyIP()){

AfxMessageBox("Imposibil de gasit IP", MB_OK|MB_ICONERROR);

}

else{

if(m_MySocket!=NULL) {

m_MySocket->Close();

};

m_MySocket = new CMySocket;

m_MySocket->p_Dlg = this;

m_MySocket->Create(atoi(m_portl),SOCK_STREAM);

m_MySocket->Listen();

}

m_nConnected = FALSE;

}

BOOL CSockCommanderDlg::OnCloseConnection(CClientSocket *pSocket)

{

CString csSockAddr;

CString csInfo;

static int nIndex = 0;

UINT nSockPort;

if(pSocket->GetSockName(csSockAddr, nSockPort)){

csInfo.Format("%s : %u – DisConnected", csSockAddr, nSockPort);

m_mesaje.InsertString(-1, csInfo);

}

return(TRUE);

}

BOOL CSockCommanderDlg::GetMyIP()

{

HOSTENT *hs;

UCHAR ch[4]={0};

CString csInfo;

::gethostname((LPSTR)(LPCTSTR)m_cshostname, 50);

hs = gethostbyname((LPSTR)(LPCTSTR)m_cshostname);

memcpy(ch, hs->h_addr,4);

csInfo.Format("%s %d.%d.%d.%d", m_cshostname,

ch[0], ch[1], ch[2], ch[3]);

GetDlgItem(IDC_TEXT)->SetWindowText(csInfo);

/*

::WSAAsyncGetHostByName

(

this->m_hWnd, WM_USER_HOSTNAME,

(LPCTSTR) m_cshostname, m_szBufHostent,

MAXGETHOSTSTRUCT

);

*/

return(TRUE);

}

void CSockCommanderDlg::OnAdrese()

{

// TODO: Add your control notification handler code here

// Users users_dlg;

CString Nume;

// m_pMainWnd = &dlg;

int nResponse = users_dlg.DoModal();

if (nResponse == IDOK)

{// m_Nume1.Label = users_dlg.Nume1;

// users_dlg.GetDlgItem(IDC_EDIT1)->GetWindowText(Nume);

// GetDlgItem(IDC_BUTTON3)->SetWindowText(Nume);

// TODO: Place code here to handle when the dialog is

// dismissed with OK

}

else if (nResponse == IDCANCEL)

{

// TODO: Place code here to handle when the dialog is

// dismissed with Cancel

}

}

void CSockCommanderDlg::OnButtonOp()

{

// TODO: Add your control notification handler code here

//CString Optiuni;

// m_pMainWnd = &dlg;

int nResponse = optiuni_dlg.DoModal();

if (nResponse == IDOK)

{

}

else if (nResponse == IDCANCEL)

{

// TODO: Place code here to handle when the dialog is

// dismissed with Cancel

}

}

#if !defined(AFX_USERS_H__F77C0400_5542_11D5_B518_AD4700A69032__INCLUDED_)

#define AFX_USERS_H__F77C0400_5542_11D5_B518_AD4700A69032__INCLUDED_

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

// Users.h : header file

//

class CSockCommanderDlg;

/////////////////////////////////////////////////////////////////////////////

// Users dialog

class Users : public CDialog

{

// Construction

public:

CSockCommanderDlg* p_Dlg;

Users(CWnd* pParent = NULL); // standard constructor

// Dialog Data

//{{AFX_DATA(Users)

enum { IDD = IDD_DIALOG1 };

CIPAddressCtrl m_IP1;

CEdit m_Port1;

CString m_Nume1;

//}}AFX_DATA

// Overrides

// ClassWizard generated virtual function overrides

//{{AFX_VIRTUAL(Users)

protected:

virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support

//}}AFX_VIRTUAL

// Implementation

protected:

// Generated message map functions

//{{AFX_MSG(Users)

virtual void OnOK();

//}}AFX_MSG

DECLARE_MESSAGE_MAP()

};

//{{AFX_INSERT_LOCATION}}

// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_USERS_H__F77C0400_5542_11D5_B518_AD4700A69032__INCLUDED_)

// Users.cpp : implementation file

//

#include "stdafx.h"

#include "SockCommander.h"

#include "Users.h"

#include "SockCommanderDlg.h"

#ifdef _DEBUG

#define new DEBUG_NEW

#undef THIS_FILE

static char THIS_FILE[] = __FILE__;

#endif

/////////////////////////////////////////////////////////////////////////////

// Users dialog

Users::Users(CWnd* pParent /*=NULL*/)

: CDialog(Users::IDD, pParent)

{

//{{AFX_DATA_INIT(Users)

m_Nume1 = _T("");

//}}AFX_DATA_INIT

}

void Users::DoDataExchange(CDataExchange* pDX)

{

CDialog::DoDataExchange(pDX);

//{{AFX_DATA_MAP(Users)

DDX_Control(pDX, IDC_IPADDRESS1, m_IP1);

DDX_Control(pDX, IDC_EDIT4, m_Port1);

DDX_Text(pDX, IDC_EDIT1, m_Nume1);

//}}AFX_DATA_MAP

}

BEGIN_MESSAGE_MAP(Users, CDialog)

//{{AFX_MSG_MAP(Users)

//}}AFX_MSG_MAP

END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////

// Users message handlers

void Users::OnOK()

{

// TODO: Add extra validation here

CString Nume;

GetDlgItem(IDC_EDIT1)->GetWindowText(Nume);

p_Dlg->GetDlgItem(IDC_BUTTON3)->SetWindowText(Nume);

GetDlgItem(IDC_EDIT5)->GetWindowText(Nume);

p_Dlg->GetDlgItem(IDC_BUTTON4)->SetWindowText(Nume);

GetDlgItem(IDC_EDIT7)->GetWindowText(Nume);

p_Dlg->GetDlgItem(IDC_BUTTON5)->SetWindowText(Nume);

GetDlgItem(IDC_EDIT9)->GetWindowText(Nume);

p_Dlg->GetDlgItem(IDC_BUTTON6)->SetWindowText(Nume);

GetDlgItem(IDC_EDIT11)->GetWindowText(Nume);

p_Dlg->GetDlgItem(IDC_BUTTON7)->SetWindowText(Nume);

GetDlgItem(IDC_EDIT13)->GetWindowText(Nume);

p_Dlg->GetDlgItem(IDC_BUTTON8)->SetWindowText(Nume);

CDialog::OnOK();

}