WNDCW07a
/******************************************/
/* Dziedziczenie strumieni przez procesy  */
/* - kod programu dla procesu nadrzednego */
/******************************************/

// dodatkowa konfiguracja dla kompilatora MSVC
#pragma warning(disable:4244)
#pragma warning(disable:4996 4005)
#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#ifdef UNICODE
# undef UNICODE
# define _MBCS
#endif

// pliki naglowkowe standardu jezyka C++ oraz interfejsu Win32 API:
#include <cstdlib>
#include <cstdio>
#include <windows.h>
using namespace std;

int main()
{
 CHAR obraz[MAX_PATH] = "potomny.exe"; // nazwa pliku z obrazem programu
 CHAR polecenie[MAX_PATH]; // polecenie do zaladowania programu w ramach procesu
 STARTUPINFO prolog; // rekord z elementami dla prologu procesu
 PROCESS_INFORMATION program; // rekord z uchwytami procesu i glownego watka do wykonywania programu
 BOOL sukces; // flaga sukcesu operacji
 CHAR tymczasowy[MAX_PATH]; // nazwa pliku tymczasowego
 HANDLE wymiana; // uchwyt pliku tymczasowego do dziedziczenia
 SECURITY_ATTRIBUTES dziedziczenie = {sizeof (SECURITY_ATTRIBUTES), NULL, TRUE}; // atrybuty bezpieczenstwa dla dziedziczonych uchwytow (TRUE)

 sprintf(polecenie, "%s %d", obraz, 10); // formatowanie polecenia z nazwa obrazu oraz liczba krokow interakcji

 // utworzenie tymczasowego pliku wymiany danych pomiedzy procesami:
 sukces = GetTempFileName(".", "xyz", 0, tymczasowy)!=0;
 if (!sukces) {
  printf("Blad utworzenia nazwy pliku tymczasowego!\n");
  ExitProcess(-1);
 }
 wymiana = CreateFile(tymczasowy,
                      GENERIC_READ | GENERIC_WRITE, // plik do operacji we/wy, ale tylko zapis bedzie potrzebny
                      FILE_SHARE_READ | FILE_SHARE_WRITE, // plik we/wy bedzie wspoldzielony przez procesy
                      &dziedziczenie, // plik bedzie dziedziczony
                      CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL
 );
 if (wymiana == INVALID_HANDLE_VALUE) {
  printf("Blad otwarcia tymczasowego pliku wymiany!\n");
  ExitProcess(-1);
 }

 // utworzenie nowego procesu:
 GetStartupInfo(&prolog); // skopiowanie elementow prologu z biezacego procesu
 prolog.dwFlags = STARTF_USESTDHANDLES;
 prolog.hStdOutput = wymiana; // obydwa wyjscia procesu sa przekierowane na plik wymiany
 prolog.hStdError = wymiana;
 prolog.hStdInput = GetStdHandle(STD_INPUT_HANDLE); // wejscie procesu jest standardowym strumieniem (klawiatura konsoli)
 prolog.lpTitle = obraz; // tytul okna konsoli dla nowego procesu
 sukces = CreateProcess(obraz, // nazwa programu
                        polecenie, // j/w (polecenie zaladowania programu)
                        NULL, // atrybuty bezpieczenstwa procesu
                        NULL, // atrybuty bezpieczenstwa watka glownego
                        TRUE, // flaga dziedziczenia uchwytow (zasobow) z biezacego procesu do nowego procesu
                        CREATE_NEW_CONSOLE, // dodatkowe falgi tworzenia procesu, tu nowa konsola dla procesu
                        NULL, // lancuch zawierajacy zmienne srodowiskowe dla nowego procesu lub dziedziczenie srodowiska biezacego procesu
                        NULL, // lancuch ze sciezka do katalogu roboczego dla nowego procesu lub katalog biezacego procesu
                        &prolog, // elementy prologu dla nowego procesu
                        &program // uchywty procesu i watka programu
 );
 if (!sukces) {
  printf("Blad tworzenia procesu!\n");
  ExitProcess(-1);
 }
 CloseHandle(wymiana); // niskopoziomy strumien do pliku wymiany nie bedzie juz potrzebny w biezacym procesie, ale jest uzywany przez nowy proces
 CloseHandle(program.hThread); // zwolnienie uchwytu do watka (ale watek dalej istnieje bo jest uzywany przez nowy proces)

 // oczekiwanie na zakonczenie procesu wykonywania programu:
 WaitForSingleObject(program.hProcess, INFINITE);
 CloseHandle(program.hProcess); // zwolnienie uchwytu do procesu i usuniecie procesu

 // przetwarzanie pliku tymczasowego poprzez strumien biblioteki standardowej:
 printf("Wyjscie z programu potomnego:\n\n");
 printf(">>>>>>\n");
 {
  CHAR wiersz[120];
  CHAR *nazwa = tymczasowy;
  FILE *plik;

  plik = fopen(nazwa, "rt");
  if (plik == NULL) {
   printf("Blad otwarcia pliku wyjsciowego!\n");
   exit(-1);
  }

  while (!feof(plik)) {
   if (fgets(wiersz, sizeof wiersz, plik)==NULL) break;
   printf("%s", wiersz);
  }

  fclose(plik);
 }
 printf("<<<<<<\n");

 // usuniecie tymczasowego pliku wymiany danych:
 sukces = DeleteFile(tymczasowy);
 if (!sukces) {
  printf("Blad usuniecia tymczasowego pliku wymiany!\n");
  ExitProcess(-1);
 }

 getchar();
 return 0;
}

WNDCW07b
/*****************************************/
/* Dziedziczenie strumieni przez procesy */
/* - kod programu dla procesu potomnego  */
/*****************************************/

// dodatkowa konfiguracja dla kompilatora MSVC
#pragma warning(disable:4244)
#pragma warning(disable:4996 4005)
#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES

// pliki naglowkowe standardu jezyka C++:
#include <cstdlib>
#include <iostream>
using namespace std;

int main(int argc, const char *argv[])
{
 int n;
 cout << "POCZATEK PROGRAMU" << endl;

 // odczytanie argumentow programu:
 if (argc < 2) abort();
 n = atoi(argv[1]);

 // wykonanie prostej interakcji:
 char dane[120];
 for (int i=0; i<n; i++) {
  cin.getline(dane, sizeof dane);
  cout << (i+1) << ") " << dane << endl;
 }

 cout << "KONIEC PROGRAMU" << endl;
 return 0;
}

WNDCW10A
/***************************************************************************/
/* Komunikacja miedzyprocesowa z uzyciem gniazd typu UDP - modul nadrzedny */
/***************************************************************************/
/* Niniejszy program stanowi nadrzedny modul w prostym systemie sieciowym.
 * Program tworzy gniazdo typu UDP i rozpowszechnia komunikaty znakowe w sieci
 * na danym porcie, obierane przez dowolne maszyny zdalne. Jednoczesnie program
 * odbiera od sieci znaki alfabetu, z ktorego generowane sa znaki tekstu.
 */

// dodatkowa konfiguracja dla kompilatora MSVC
#pragma warning(disable:4244)
#pragma warning(disable:4996 4005)
#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#ifdef UNICODE
# undef UNICODE
# define _MBCS
#endif

// pliki naglowkowe standardu C++ oraz interfejsu Win32API:
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <ctime>
using namespace std;
#include <conio.h>
#include <winsock2.h>

// dodatkowa konfiguracja dla linkera MSVC
#pragma comment(lib, "ws2_32.lib")

// glowne parametry programu:
const u_short iPort = 5000;
const char cWiersz = '\n';
const char cString = '\0';
const char cKoniec = '\a';
const char kEscape = '\33';
const u_int nWiersz = 50;
const size_t nAlfabet = 30;

// glowny kod programu:
int main()
{
 printf(">> Poczatek programu <<\n\n");

 // pomocnicze zmienne programu:
 WSADATA srodowisko;
 SOCKET komunikacja;
 u_short port;
 sockaddr_in lokalny,dowolny,zdalny;
 int rozmiar,znaki,kolumny;
 char alfabet[nAlfabet+1];
 BOOL rozpowszechnianie;
 u_long bezblokowania;

 // odczytanie parametrow programu:

 printf("Podaj numer portu komunikacyjnego (np. %hu): ", iPort);
 port = iPort;
 scanf("%hu", &port);

 // otwarcie srodowiska Winsock 2.2 oraz gniazda do komunikacji typu UDP:
 if (WSAStartup(MAKEWORD(2,2), &srodowisko) != 0) abort();
 komunikacja = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 if (komunikacja == INVALID_SOCKET) abort();
 printf("\nOtwarcie komunikacji nadrzednej w srodowisku: %s\n", srodowisko.szDescription);

 // powiazanie gniazda ze lokalna maszyna do odbioru komunikatow z dowolnego adresu poprzez podany port:
 lokalny.sin_family = AF_INET;
 lokalny.sin_addr.s_addr = INADDR_ANY;
 lokalny.sin_port = htons(port);
 if (bind(komunikacja, (const sockaddr *)&lokalny, sizeof lokalny) == SOCKET_ERROR)
 printf("Lokalny port (%hu) zajety, odbior komunikatow domyslny!\n", port);
 else printf("Odbior komunikatow ze sieci na lokalnym porcie: %hu\n", port);

 // przetwarzanie komunikatow i wymiana znakow w sieci:
 printf("Rozpowszechnianie komunikatow w sieci...");
 {
  rozpowszechnianie = TRUE;
  dowolny.sin_family = lokalny.sin_family;
  dowolny.sin_addr.s_addr = INADDR_BROADCAST;
  dowolny.sin_port = lokalny.sin_port;
  if (setsockopt(komunikacja, SOL_SOCKET, SO_BROADCAST, (const char*)&rozpowszechnianie, sizeof rozpowszechnianie) == SOCKET_ERROR) abort();
  printf("\n(nacisnij klawisz ESC, aby zakonczyc komunikacje)\n");
  memset(alfabet,cString,sizeof alfabet);
  znaki = -1;
  while (rozpowszechnianie) {
   char znak;
   if (_kbhit() && _getch()==kEscape) znak = cKoniec;
   else if (znaki <= 0) znak = cString;
   else if (++kolumny>nWiersz) {
    znak = cWiersz;
    kolumny = 0;
   } else znak = alfabet[rand()%znaki];
   if (sendto(komunikacja, &znak, 1, 0, (const sockaddr *)&dowolny, sizeof dowolny) <= SOCKET_ERROR) abort();
   if (znaki<0) {
    printf("znaki alfabetu:\n");
    memset(alfabet,cString,sizeof alfabet);
    kolumny = znaki = 0;
   }
   if (znak == cKoniec) rozpowszechnianie = FALSE;
   else {
    if (znaki < nAlfabet) {
     clock_t zwloka = clock()+(clock_t)(0.25*CLOCKS_PER_SEC);
     while (clock()<zwloka);
    }
    bezblokowania = TRUE;
    if (ioctlsocket(komunikacja, FIONBIO, &bezblokowania) == SOCKET_ERROR) abort();
    do {
     rozmiar = sizeof zdalny;
     if (recvfrom(komunikacja, &znak, 1, 0, (sockaddr *)&zdalny, &rozmiar) <= SOCKET_ERROR)
     if (WSAGetLastError() == WSAEWOULDBLOCK) break;
     else abort();
     if (znak == cKoniec) _ungetch(kEscape);
     else if (znaki>0 && znak == cString) znaki = -1;
     else if (znaki<nAlfabet && isalnum(znak)) {
      alfabet[znaki++] = znak;
      printf("{ %s }\n", alfabet);
     }
    } while (true);
    bezblokowania = FALSE;
    if (ioctlsocket(komunikacja, FIONBIO, &bezblokowania) == SOCKET_ERROR) abort();
   }
  }
  if (setsockopt(komunikacja, SOL_SOCKET, SO_BROADCAST, (const char*)&rozpowszechnianie, sizeof rozpowszechnianie) == SOCKET_ERROR) abort();
 }

 // zakonczenie komunikacji i zamkniecie srodowiska Winsock:
 closesocket(komunikacja);
 if (WSACleanup()!=0) abort();

 system("pause");
 printf("\nKoniec programu.\n");
 return 0;
}

WNDCW10b
/**************************************************************************/
/* Komunikacja miedzyprocesowa z uzyciem gniazd typu UDP - modul podlegly */
/**************************************************************************/
/* Niniejszy program stanowi podlegly modul w prostym systemie sieciowym.
 * Program tworzy gniazdo typu UDP i oczekujac odbiera zdalne komunikaty znakowe
 * od sieci na danym porcie maszyny lokalnej, z ktorych tworzy tekst w strumieniu
 * wyjsciowym. Jednoczesnie program odczytuje pojednyncze znaki wprowadzone lokalnie
 * do strumienia wejsciowego i nastepnie wysyla je zwrotnie pod zdalny adres.
 */

// dodatkowa konfiguracja dla kompilatora MSVC
#pragma warning(disable:4244)
#pragma warning(disable:4996 4005)
#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#ifdef UNICODE
# undef UNICODE
# define _MBCS
#endif

// pliki naglowkowe standardu C++ oraz interfejsu Win32API:
#include <cstdio>
#include <cstdlib>
#include <cstring>
using namespace std;
#include <conio.h>
#include <winsock2.h>

// dodatkowa konfiguracja dla linkera MSVC
#pragma comment(lib, "ws2_32.lib")

// glowne parametry programu:
const u_short iPort = 5000;
const char cString = '\0';
const char cKoniec = '\a';
const char kSpacja = ' ';
const char kEscape = '\33';

// glowny kod programu:
int main()
{
 printf(">> Poczatek programu <<\n\n");

 // pomocnicze zmienne programu:
 WSADATA srodowisko;
 SOCKET komunikacja;
 u_short port;
 sockaddr_in lokalny,zdalny;
 int rozmiar,znaki;

 // odczytanie parametrow programu:

 printf("Podaj numer portu komunikacyjnego (np. %hu): ", iPort);
 port = iPort;
 scanf("%hu", &port);

 // otwarcie srodowiska Winsock 2.2 oraz gniazda do komunikacji typu UDP:
 if (WSAStartup(MAKEWORD(2,2), &srodowisko) != 0) abort();
 komunikacja = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 if (komunikacja == INVALID_SOCKET) abort();
 printf("\nOtwarcie komunikacji podleglej w srodowisku: %s\n", srodowisko.szDescription);

 // powiazanie gniazda ze lokalna maszyna do odbioru komunikatow z dowolnego adresu poprzez podany port:
 lokalny.sin_family = AF_INET;
 lokalny.sin_addr.s_addr = INADDR_ANY;
 lokalny.sin_port = htons(port);
 if (bind(komunikacja, (const sockaddr *)&lokalny, sizeof lokalny) == SOCKET_ERROR) abort();
 else printf("Odbior komunikatow ze sieci na lokalnym porcie: %hu\n", port);

 // przetwarzanie komunikatow i wymiana znakow w sieci:
 printf("Oczekiwanie na odbior komunikatu...");
 {
  bool poczatek = true;
  bool wtoku = poczatek;
  znaki = -1;
  while (wtoku) {
   char znak = cKoniec;
   rozmiar = sizeof zdalny;
   if (recvfrom(komunikacja, &znak, 1, 0, (sockaddr *)&zdalny, &rozmiar) <= SOCKET_ERROR) abort();
   if (poczatek) {
    printf("\n(nacisnij klawisz, aby wyslac znak alfabetu,\n lub spacje, aby zresetowac alfabet,\n lub ESC, aby zakonczyc komunikacje)\n");
    poczatek = false;
   }
   if (znak == cKoniec) {
    if (znaki>0) printf("\n");
    wtoku = false;
   } else
   if (znak == cString) {
    if (znaki>0) {
     printf("\n");
     znaki = -1;
    }
    if (znaki<0) {
     printf("znaki tekstu:\n");
     znaki = 0;
    }
   } else {
    putchar(znak);
    znaki++;
   }
   if (_kbhit() && wtoku) {
    znak = _getch();
    if (znak == kEscape) znak = cKoniec;
    else if (znak == kSpacja) znak = cString;
    if (sendto(komunikacja, &znak, 1, 0, (const sockaddr *)&zdalny, sizeof zdalny) <= SOCKET_ERROR) abort();
   }
  }
 }

 // zakonczenie komunikacji i zamkniecie srodowiska Winsock:
 closesocket(komunikacja);
 if (WSACleanup()!=0) abort();

 system("pause");
 printf("\nKoniec programu.\n");
 return 0;
}

WNDCW11b
/**********************************************************************************************/
/* Obliczenia rozproszone w wielomaszynowym klastrze z komunikacja typu UDP - modul nadrzedny */
/**********************************************************************************************/
/* Niniejszy program stanowi nadrzedny wezel (ang. master node) w klastrze maszyn.
 * Program tworzy gniazdo typu UDP i wysyla komunikat z argumentami obliczen do sieci
 * na danym porcie, obierany przez maszyny zdalne. Nastepnie program odbiera komunikaty
 * z czastkowymi wynikami obliczen i otrzymuje wynik bedacy calka pewnego wyrazenia.
 */

// dodatkowa konfiguracja dla kompilatora MSVC
#pragma warning(disable:4244)
#pragma warning(disable:4996 4005)
#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#ifdef UNICODE
# undef UNICODE
# define _MBCS
#endif

// pliki naglowkowe standardu C++ oraz interfejsu Win32API:
#include <cstdio>
#include <cstdlib>
#include <cstring>
using namespace std;
#include <winsock2.h>

// dodatkowa konfiguracja dla linkera MSVC
#pragma comment(lib, "ws2_32.lib")

// glowne parametry programu:
const char sAdres[] = "localhost";
const u_short iPort = 5000;
const char cSygnal = '\a';
const char cRekord = '\n';
const char cString = '\0';
const size_t nKlaster = 100;
const size_t nOpis = 256;
const size_t nPakiet = 512;
const size_t nRekord = 1024;
const int nCalka = 100000;

// glowny kod programu:
int main()
{
 printf(">> Poczatek programu <<\n\n");

 // pomocnicze zmienne programu:
 WSADATA srodowisko;
 SOCKET komunikacja;
 u_short port;
 sockaddr_in lokalny,dowolny,zdalny;
 char adresy[nKlaster][nOpis];
 sockaddr_in klaster[nKlaster];
 int rozmiar,wezel,wezly;
 BOOL rozpoznanie;

 // odczytanie parametrow programu:

 printf("Podaj numer portu komunikacyjnego (np. %hu): ", iPort);
 port = iPort;
 scanf("%hu", &port);

 printf("Podaj liczbe wszystkich wezlow klastera (<= %u): ", nKlaster);
 wezly = nKlaster;
 scanf("%u", &wezly);

 printf("Czy adresy zdalnych wezlow maja byc rozpoznane (0/1)? ");
 rozpoznanie = FALSE;
 scanf("%d", &rozpoznanie);

 // odczytanie adresow wezlow w klasterze:
 for (wezel=0; wezel<wezly; wezel++)
 strcpy(adresy[wezel], sAdres);
 if (!rozpoznanie) {
  printf("Podaj adresy zdalnych wezlow klastera (np. %s):\n", sAdres);
  for (wezel=1; wezel<wezly; wezel++) {
   printf("%d) ", wezel);
   scanf("%s", adresy[wezel]);
  }
 }

 // otwarcie srodowiska Winsock 2.2 oraz gniazda do komunikacji typu UDP:
 if (WSAStartup(MAKEWORD(2,2), &srodowisko) != 0) abort();
 komunikacja = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 if (komunikacja == INVALID_SOCKET) abort();
 printf("\nOtwarcie komunikacji dla wezla MASTER w srodowisku: %s\n", srodowisko.szDescription);
 {
  char nazwa[nOpis];
  if (gethostname(nazwa, sizeof nazwa)!=SOCKET_ERROR) {
   hostent *maszyna = gethostbyname(nazwa);
   if (maszyna!=NULL) {
    in_addr adres;
    memcpy(&adres, maszyna->h_addr, maszyna->h_length);
    printf("adres wezla: %s\n", inet_ntoa(adres));
    printf("nazwa wezla: %s\n", maszyna->h_name);
    for (wezel=0; wezel<wezly; wezel++)
    if (strcmp(adresy[wezel], sAdres) == 0)
    strcpy(adresy[wezel], inet_ntoa(adres));
   }
  }
 }

 // powiazanie gniazda ze lokalna maszyna do odbioru komunikatow z dowolnego adresu poprzez podany port:
 lokalny.sin_family = AF_INET;
 lokalny.sin_addr.s_addr = INADDR_ANY;
 lokalny.sin_port = htons(port);
 if (bind(komunikacja, (const sockaddr *)&lokalny, sizeof lokalny) == SOCKET_ERROR)
 printf("Lokalny port (%hu) zajety, odbior komunikatow domyslny!\n", port);
 else printf("Odbior komunikatow ze sieci na lokalnym porcie: %hu\n", port);

 // rozpoznanie adresow zdalnych maszyn klastera w sieci poprzez rozpowszechnianie komunikatow do dowolnych adresow:
 if (rozpoznanie) {
  char znak = cSygnal;
  printf("Rozpoznawanie wezlow zdalnych w sieci...");
  dowolny.sin_family = lokalny.sin_family;
  dowolny.sin_addr.s_addr = INADDR_BROADCAST;
  dowolny.sin_port = lokalny.sin_port;
  if (setsockopt(komunikacja, SOL_SOCKET, SO_BROADCAST, (const char*)&rozpoznanie, sizeof rozpoznanie) == SOCKET_ERROR) abort();
  printf("\n");
  if (sendto(komunikacja, &znak, 1, 0, (const sockaddr *)&dowolny, sizeof dowolny) <= SOCKET_ERROR) abort();
  for (wezel=1; wezel<wezly; wezel++) {
   do {
    rozmiar = sizeof zdalny;
    if (recvfrom(komunikacja, &znak, 1, 0, (sockaddr *)&zdalny, &rozmiar) <= SOCKET_ERROR) abort();
   } while (znak!=cSygnal);
   strcpy(adresy[wezel], inet_ntoa(zdalny.sin_addr));
  }
  rozpoznanie = FALSE;
  if (setsockopt(komunikacja, SOL_SOCKET, SO_BROADCAST, (const char*)&rozpoznanie, sizeof rozpoznanie) == SOCKET_ERROR) abort();
 }

  // ustawienie adresow wszystkich wezlow klastera na potrzeby komunikacji przez podany port:
 for (wezel=0; wezel<wezly; wezel++) {
  klaster[wezel].sin_family = lokalny.sin_family;
  klaster[wezel].sin_addr.s_addr = inet_addr(adresy[wezel]);
  klaster[wezel].sin_port = lokalny.sin_port;
  if (klaster[wezel].sin_addr.s_addr == INADDR_NONE) {
   hostent *maszyna = gethostbyname(adresy[wezel]);
   if (maszyna == NULL) abort();
   memcpy(&klaster[wezel].sin_addr, maszyna->h_addr, maszyna->h_length);
  }
 }
 printf("Wszystkie komunikacyjne wezly w klasterze:\n");
 for (wezel=0; wezel<wezly; wezel++) {
  printf("%d) %s:%hu", wezel, inet_ntoa(klaster[wezel].sin_addr), ntohs(klaster[wezel].sin_port));
  if (wezel==0) printf(" (master)\n");
  else printf("\n");
 }

 // przetwarzanie komunikatow i wymiana danych w klasterze:
 printf("Przekazywanie komunikatow w sieci...");
 {
  char pakiet[nPakiet] = {cString};
  char rekord[nRekord] = {cString};
  int zwrot,wszystko,pozostale;
  double wynik,suma = 0.0;
  for (wezel=1; wezel<wezly; wezel++) {
   int N = nCalka;
   int n = wezly-1;
   int i1 = (wezel-1)*N/n;
   int i2 = wezel*N/n-1;
   if (wezel==n) i2 = N;
   sprintf(pakiet,"(%d,%d)",i1,i2);
   wszystko = strlen(pakiet);
   zwrot = sendto(komunikacja, pakiet, wszystko, 0, (const sockaddr *)&klaster[wezel], sizeof klaster[wezel]);
   if (zwrot <= SOCKET_ERROR) abort();
   else if (zwrot < wszystko) break;
  }
  printf("\n");
  if (wezel >= wezly) {
   printf("Wyslano %d bajtowy pakiet komunikatu, oczekiwanie na odbior danych...\n", zwrot);
   for (wezel=1; wezel<wezly; wezel++) {
    wszystko = 0;
    pozostale = nRekord;
    do {
     rozmiar = sizeof zdalny;
     zwrot = recvfrom(komunikacja, &rekord[wszystko], pozostale, 0, (sockaddr *)&zdalny, &rozmiar);
     if (zwrot == 0) break;
     else if (zwrot <= SOCKET_ERROR) abort();
     wszystko += zwrot;
     pozostale -= zwrot;
    } while (rekord[wszystko-1]!=cRekord);
    wszystko--;
    rekord[wszystko] = cString;
    printf("Otrzymano %d bajtowy rekord danych: %s\n", wszystko, rekord);
    if (sscanf(rekord,"wynik = %lf",&wynik) < 1) abort();
    suma+=wynik;
   }
   printf("koncowy wynik obliczen: %f\n", suma);
  }
 }

 // zakonczenie komunikacji i zamkniecie srodowiska Winsock:
 closesocket(komunikacja);
 if (WSACleanup()!=0) abort();

 system("pause");
 printf("\nKoniec programu.\n");
 return 0;
}

WNDCW11b
/*********************************************************************************************/
/* Obliczenia rozproszone w wielomaszynowym klastrze z komunikacja typu UDP - modul podlegly */
/*********************************************************************************************/
/* Niniejszy program stanowi podlegly wezel (ang. slave node) w klastrze maszyn.
 * Program tworzy gniazdo typu UDP i oczekujac odbiera zdalny komunikat z argumentami
 * od sieci na danym porcie maszyny lokalnej. Nastepnie program wysyla pod zdalny adres
 * komunikat z czastkowym wynikiem obliczen.
 */

// dodatkowa konfiguracja dla kompilatora MSVC
#pragma warning(disable:4244)
#pragma warning(disable:4996 4005)
#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#ifdef UNICODE
# undef UNICODE
# define _MBCS
#endif

// pliki naglowkowe standardu C++ oraz interfejsu Win32API:
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
using namespace std;
#include <winsock2.h>

// dodatkowa konfiguracja dla linkera MSVC
#pragma comment(lib, "ws2_32.lib")

// glowne parametry programu:
const u_short iPort = 5000;
const char cSygnal = '\a';
const char cRekord = '\n';
const char cString = '\0';
const size_t nOpis = 256;
const size_t nPakiet = 512;
const size_t nRekord = 1024;
const double aCalka = 0.0;
const double bCalka = 1.0;
const int nCalka = 100000;

// glowny kod programu:
int main()
{
 printf(">> Poczatek programu <<\n\n");

 // pomocnicze zmienne programu:
 WSADATA srodowisko;
 SOCKET komunikacja;
 u_short port;
 sockaddr_in lokalny,zdalny;
 int rozmiar;

 // odczytanie parametrow programu:

 printf("Podaj numer portu komunikacyjnego (np. %hu): ", iPort);
 port = iPort;
 scanf("%hu", &port);

 // otwarcie srodowiska Winsock 2.2 oraz gniazda do komunikacji typu UDP:
 if (WSAStartup(MAKEWORD(2,2), &srodowisko) != 0) abort();
 komunikacja = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 if (komunikacja == INVALID_SOCKET) abort();
 printf("\nOtwarcie komunikacji dla wezla SLAVE w srodowisku: %s\n", srodowisko.szDescription);
 {
  char nazwa[nOpis];
  if (gethostname(nazwa, sizeof nazwa)!=SOCKET_ERROR) {
   hostent *maszyna = gethostbyname(nazwa);
   if (maszyna!=NULL) {
    in_addr adres;
    memcpy(&adres, maszyna->h_addr, maszyna->h_length);
    printf("adres wezla: %s\n", inet_ntoa(adres));
    printf("nazwa wezla: %s\n", maszyna->h_name);
   }
  }
 }

 // powiazanie gniazda ze lokalna maszyna do odbioru komunikatow z dowolnego adresu poprzez podany port:
 lokalny.sin_family = AF_INET;
 lokalny.sin_addr.s_addr = INADDR_ANY;
 lokalny.sin_port = htons(port);
 if (bind(komunikacja, (const sockaddr *)&lokalny, sizeof lokalny) == SOCKET_ERROR) abort();
 else printf("Odbior komunikatow ze sieci na lokalnym porcie: %hu\n", port);

 // przetwarzanie komunikatow i wymiana danych w klasterze:
 printf("Oczekiwanie na odbior komunikatu...");
 {
  char pakiet[nPakiet] = {cString};
  char rekord[nRekord] = {cString};
  int zwrot,wszystko,biezacy;
  double argument,wynik = 0.0;
  rozmiar = sizeof zdalny;
  zwrot = recvfrom(komunikacja, pakiet, nPakiet, 0, (sockaddr *)&zdalny, &rozmiar);
  printf("\n");
  if (zwrot <= SOCKET_ERROR) abort();
  else if (zwrot > 0) {
   pakiet[zwrot] = cString;
   if (strlen(pakiet)==1 && pakiet[0]==cSygnal) {
    printf("Przetwarzanie komunikatu rozpoznawania...\n");
    if (sendto(komunikacja, pakiet, 1, 0, (const sockaddr *)&zdalny, rozmiar) <= SOCKET_ERROR) abort();
    rozmiar = sizeof zdalny;
    zwrot = recvfrom(komunikacja, pakiet, nPakiet, 0, (sockaddr *)&zdalny, &rozmiar);
    if (zwrot <= SOCKET_ERROR) abort();
    else if (zwrot > 0) pakiet[zwrot] = cString;
   }
  }
  if (zwrot > 0) {
   int i1,i2,i;
   printf("Odebrano %d bajtowy pakiet komunikatu: %s\n", zwrot, pakiet);
   if (sscanf(pakiet, "(%d,%d)", &i1, &i2) < 2) abort();
   for (i=i1;i<=i2;i++) {
    double a = aCalka;
    double b = bCalka;
    int N = nCalka;
    double d = (b-a)/N;
    argument = a+i*d;
    wynik += tanh(argument)/sqrt(argument*argument+exp(sin(argument)*cos(argument)));
   }
   sprintf(rekord, "wynik = %f%c", wynik, cRekord);
   wszystko = strlen(rekord);
   biezacy = 0;
   printf("Wysylanie %d bajtowy rekord danych...\n", (wszystko-1));
   while (wszystko > 0) {
    zwrot = sendto(komunikacja, &rekord[biezacy], wszystko, 0, (sockaddr *)&zdalny, sizeof zdalny);
    if (zwrot == 0) break;
    else if (zwrot <= SOCKET_ERROR) abort();
    wszystko -= zwrot;
    biezacy += zwrot;
   }
  }
 }

 // zakonczenie komunikacji i zamkniecie srodowiska Winsock:
 closesocket(komunikacja);
 if (WSACleanup()!=0) abort();

 system("pause");
 printf("\nKoniec programu.\n");
 return 0;
}