Programowanie sieciowe z użyciem interfejsu gniazdek
|
|
- Sylwia Szewczyk
- 7 lat temu
- Przeglądów:
Transkrypt
1 Jędrzej Ułasiewicz 1 Programowanie sieciowe z użyciem interfejsu gniazdek Spis treści: Programowanie sieciowe z użyciem interfejsu gniazdek Interfejs gniazdek - wprowadzenie Domeny komunikacji, style komunikacji i protokoły Domeny Styl komunikacji Protokoły Kolejność bajtów w adresach Adresy gniazd Dziedzina internetu AF_INET Dziedzina internetu AF_INET Dziedzina Unixa AF_UNIX Funkcje dotyczące adresów Komunikacja bez kontroli połączenia Przebieg komunikacji Funkcje sendto i recfrom Przykład komunikacja w domenie internetu AF_INET Przykład komunikacja w domenie Unix a AF_UNIX Komunikacja grupowa i rozgłoszenia Komunikacja z kontrolą połączenia Obsługa sygnałów Konfigurowanie gniazdek Wykorzystanie standardowej biblioteki wejścia / wyjścia Serwery współbieżne Serwer wieloprocesowy Serwer asynchroniczny Serwer wielowątkowy Testowanie stanu gniazd...68
2 Jędrzej Ułasiewicz 2 1. Interfejs gniazdek - wprowadzenie Jednolity interfejs API (Application Program Interface) do mechanizmów komunikacji sieciowej. Wprowadzony w wersji Unixa BSD 4.2 Aplikacja klienta Aplikacja serwera Poziom aplikacji Gniazdko Protokól transportu TCP, UDP Protokól sieci IP Sterownik interfejsu Sprzęt Poziom systemu operacyjnego pakiet Gniazdko Protokól transportu TCP, UDP Protokó sieci IP Sterownik interfejsu Sprzęt Komputer 1 Sieć LAN / WAN Komputer 2 Rys. 1-1 Ogólny schemat komunikacji sieciowej z użyciem gniazd Główna idea gniazdek polega na użyciu do komunikacji (lokalnej i zdalnej) tego samego mechanizmu, co dostępu do plików. Jest to mechanizm oparty o deskryptory plików i funkcje read, write. Termin gniazdko ma dwa znaczenia: 1. Biblioteka + funkcje interfejsowe (API). 2. Końcowy punkt komunikacji Biblioteka gniazdek maskuje mechanizmy transportu sieci. Własności gniazd: Gniazdo jest identyfikowane przez liczbę całkowitą nazywaną deskryptorem gniazda Gniazdo można nazwać i wykorzystywać do komunikacji z innymi gniazdami w tej samej domenie komunikacyjnej
3 Jędrzej Ułasiewicz 3 2. Domeny komunikacji, style komunikacji i protokoły Kiedy tworzone jest gniazdko następujące dane muszą być określone: - Domena komunikacji - Styl komunikacji - Protokół Tworzenie gniazdka int socket(int domain, int typ, int protcol) domain Specyfikacja domeny komunikacyjnej. Podstawowe domeny: AF_UNIX, AF_INET, AF_INET6, Typ Semantyka komunikacji. Podstawowe style: SOCK_STREAM, SOCK_DGRAM, SOCK_SEQPACKET, SOCK_RAW protcol Specyfikacja protokołu. Zwykle dla domeny i stylu jest implementowany tylko jeden protokół. Funkcja zwraca: > 0 Uchwyt gniazdka 0 błąd main() { int sock; sock = socked(af_inet,sock_stream,0); if(sock < 0) { perror( gniazdko ); exit(0);... Przykład 2-1 Tworzenie gniazda strumieniowego w domenie internetu
4 Jędrzej Ułasiewicz 4 Zamykanie gniazdka Zamknięcie gniazdka może być wykonane przez funkcje: close(int socket) shutdown(int socket, int how) Gdzie: socket Uchwyt gniazdka how SHUT_WR zamknięcie gniazdka do zapisu SHUT_RD zamknięcie gniazdka do odczytu SHUT_RDWR zamknięcie gniazdka do odczytu i zapisu int res; int s; // gniazdko res = shutdown(s, SHUT_WR); if (res == -1 ) perror("shutdown"); Listing 2-1 Przykład zamknięcia gniazdka Działanie: Wymuszenie zapisu buforowanych danych Wysłanie znaku EOF do połączonego gniazdka Gdy gniazdko pozostaje niezamkniete do odczytu można odebrać potwierdzenie Uwaga: Gdy gniazdko s zostanie zduplikowane poleceniem d = dup(s) to aby polecenie close(d) zamknie tylko jedno gniazdko i trzeba ponownie wykonać close(s). Problem rozwiązuje użycie polecenia: shutdown(s,shut_rdwr)
5 Jędrzej Ułasiewicz Domeny Komunikacja odbywa się w pewnej domenie. Od domeny zależy sposób adresowania w sieci. Są trzy podstawowe domeny: Domena internetu wersja IPv4 - AF_INET Domena internetu wersja IPv6 - AF_INET6 Domena Unixa - AF_UNIX Inne domeny: AF_IPX AF_NETLINK AF_AX25 AF_PACKET Protokół IPX Novell Protokół komunikacji z jądrem - Protokół komunikacji amatorskiej - Komunikacja z driverem sieciowym Rodzina adresów AF_INET Ta rodzina adresów umożliwia komunikację między procesami działającymi w tym samym systemie lub w różnych systemach. Używa protokołu IP w wersji 4. Adres w dziedzinie AF_INET składa się z: Numeru Portu Adresu IP maszyny Adres IP maszyny jest 32 bitowy. Rodzina adresów AF_INET6 Ta rodzina adresów zapewnia obsługę protokołu IP w wersji 6 (IPv6). Adres gniazda składa się z: Numeru Portu Adresu IP maszyny Rodzina adresów AF_INET6 używa 128-bitowych (16-bajtowych) adresów maszyny. Rodzina adresów AF_UNIX Ta rodzina adresów umożliwia komunikację między procesami w ramach jednego systemu. Adres jest nazwą ścieżki do pozycji systemu plików.
6 Jędrzej Ułasiewicz Styl komunikacji Interfejs realizuje następujące podstawowe style komunikacji: Strumienie (ang. stream) SOCK_STREAM Datagramy (ang. datagram) SOCK_DGRAM Protokół surowy (ang. raw) SOCK_RAW Strumienie Metoda strumieni zapewnia połączenie pomiędzy gniazdkami. Korekcja i detekcja błędów zapewniana jest przez system. Pojedynczy odczyt instrukcją read może dostarczać danych zapisanych wieloma instrukcjami write lub tylko część danych zapisanych instrukcją write po drugiej stronie połączenia. Aplikacja jest zawiadamiana gdy połączenie zostanie zerwane. Datagramy W komunikacji datagramowej nie są używane połączenia. Każda porcja danych (datagram) adresowany jest indywidualnie. Gdy adres jest prawidłowy a połączenie sprawne, datagram jest dostarczany do adresata, ale nie jest to gwarantowane. Aplikacja sama musi zadbać o sprawdzenie czy dane dotarły (np. poprzez potwierdzenia). Granice datagramów są zachowane. Protokół surowy Umożliwia dostęp do protokołów niższych warstw np. ICMP Protokoły Protokół jest zestawem reguł, formatów danych i konwencji które są wymagane do przesłania danych. Zadaniem kodu implementującego protokół jest: Zamiana adresów symbolicznych na fizyczne Ustanowienie połączeń Przesyłanie danych przez sieć Ten sam styl komunikacji może być implementowany przez wiele protokołów.
7 Jędrzej Ułasiewicz 7 Domena Styl komunikacji Protokół gniazda AF_UNIX SOCK_STREAM - SOCK_DGRAM - SOCK_SEQPACKET Komunikacja połączeniowa, zachowuje granice pakietów AF_INET SOCK_STREAM TCP SOCK_DGRAM UDP SOCK_SEQPACKET SCTP SOCK_RAW IP, ICMP AF_INET6 SOCK_STREAM TCP SOCK_DGRAM UDP SOCK_SEQPACKET SCTP SOCK_RAW IP6, ICMP6 Tab. 0-1 Zestawienie parametrów gniazd
8 Jędrzej Ułasiewicz Kolejność bajtów w adresach Sposób zapisywania danych w różnych typach maszyn może być odmienny. Dotyczy to w szczególności kolejności bajtów składających się na zmienne int. mniejsze niżej little endian bajt mniej znaczący bajt bardziej znaczący mniejsze wyżej big endian bajt bardziej znaczący bajt mniej znaczący adresy A A+1 Rys. 0-1 Sposoby wewntrznej reprezentacji liczb Mniejsze niżej Intel 80x86, DEC VAX Mniejsze wyżej Motorola 68000, Power PC Tab. 0-2 Sposoby reprezentacji liczb w zależności od typu maszyny Dla protokołów TCP/IP przyjęto konwencję mniejsze wyżej. Jest to tzw. Format sieciowy. Funkcje konwersji formatów sieciowego na lokalny: unsigned long ntohl(unsigned long netlong) unsigned short ntohs(unsigned short netshort) unsigned long htonl(unsigned long hostlong) unsigned short htons(unsigned short hostshort)
9 Jędrzej Ułasiewicz Adresy gniazd Nowo utworzone gniazdo nie posiada jeszcze adresu. Aby mogło uczestniczyć w komunikacji musi mu być nadany adres. Definicja adresu zawarta jest w pliku nagłówkowym <sys.socket.h>. stuct sockaddr { u_short sa_family; // Określenie domeny komunikacji char sa_data[14]; // Bajty adresu Wartości pola sa_family są: AF_UNIX, AF_INET, AF_INET6 Powyższy format jest formatem ogólnym jest on słuszny dla różnych dziedzin (danych powyżej). W poszczególnych domenach stosowane są odmienne metody adresowania. Nazywanie gniazdka Gdy gniazdko jest utworzone istnieje ono w przestrzeni nazw danej domeny, ale nie ma adresu. Przypisywanie adresu odbywa się za pomocą funkcji bind. int bind(int sock, struct sockaddr * name, int namelen) sock - Uchwyt gniazdka name - Adres przypisany gniazdku namelen - Długość nazwy Funkcja zwraca: 0 Sukces -1 Błąd
10 Jędrzej Ułasiewicz Dziedzina internetu AF_INET Adres w dziedzinie AF_INET składa się z: Adresu IP maszyny Numeru Portu Liczba 32 bit Liczba 16 bit Adres gniazda ma postać struktury sockadr_in. Format adresu sockadr_in określony w pliku nagłówkowym <netinet/in.h> struct sockaddr_in { sa_family_t sin_family; /* AF_INET */ in_port_t sin_port; /* port format sieciowy */ struct in_addr sin_addr; /* adres internetowy */ ; /* adres internetowy */ struct in_addr { uint32_t s_addr; /* adres format sieciowy */ ; Tworzenie takich gniazd odbywa się jak poniżej: #include <sys/socket.h> #include <netinet/in.h> #include <netinet/ip.h> tcp_socket = socket(af_inet, SOCK_STREAM, 0); udp_socket = socket(af_inet, SOCK_DGRAM, 0); raw_socket = socket(af_inet, SOCK_RAW, protocol); Adresy internetowe są zwykle zapisywane jako czwórki rozdzielone kropkami. Każda czwórka odpowiada jednemu bajtowi. Na przykład: Zapis z kropką Szesnastkowo 0x7D11182A Dziesiętnie Zajętość portów można sprawdzić oglądając plik: /etc/services
11 Jędrzej Ułasiewicz 11 echo 7/tcp echo 7/udp daytime 13/tcp daytime 13/udp netstat 15/tcp ftp-data 20/tcp ftp 21/tcp ssh 22/tcp # SSH Remote Login Protocol ssh 22/udp telnet 23/tcp smtp 25/tcp mail time 37/tcp timserver time 37/udp timserver nameserver 42/tcp name # IEN 116 tftp 69/udp www 80/tcp http # WorldWideWeb HTTP www 80/udp # HyperText Transfer Protocol rtelnet 107/tcp # Remote Telnet rtelnet 107/udp pop3 110/tcp pop-3 # POP version 3 pop3 110/udp pop-3 sunrpc 111/tcp portmapper # RPC 4.0 portmapper sunrpc 111/udp portmapper ntp 123/udp # Network Time Protocol snmp 161/tcp # Simple Net Mgmt Protocol snmp 161/udp # Simple Net Mgmt Protocol Tab. 0-3 Fragment pliku /etc/services Zakres numerów Przeznaczenie portów Porty których używać może tylko root Dobrze znane porty K Porty efemeryczne Tab. 0-4 Zakresy portów i ich przeznaczenie struct sockaddr_in adr_moj, adr_cli; int s, I;... s=socket(af_inet, SOCK_DGRAM, IPPROTO_UDP); if(s < 0) blad("socket"); printf("gniazdko %d utworzone\n",s); // Ustalenie adresu IP nadawcy memset((char *) &adr_moj, 0, sizeof(adr_moj)); adr_moj.sin_family = AF_INET; adr_moj.sin_port = htons(port); adr_moj.sin_addr.s_addr = htonl(inaddr_any);
12 Jędrzej Ułasiewicz 12 if (bind(s, &adr_moj, sizeof(adr_moj))==-1) blad("bind"); Przykład 0-1 Przypisanie adresu do gniazda dziedziny AF_INET
13 Jędrzej Ułasiewicz Dziedzina internetu AF_INET6 W dziedzinie internetu AF_INET6 adres gniazda ma postać struktury sockadr_in6. struct sockaddr_in6 { sa_family_t sin6_family; /* AF_INET6 */ in_port_t sin6_port; /* port number */ uint32_t sin6_flowinfo; /* IPv6 flow information */ struct in6_addr sin6_addr; /* IPv6 address */ uint32_t sin6_scope_id; /* Scope ID */ ; struct in6_addr { unsigned char s6_addr[16]; /* IPv6 address */ ; Pole sin6_flowinfo jest obecnie nieużywane i ma wartość 0. Pole sin6_scope_id identyfikuje zestaw interfejsów odpowiednich dla zakresu adresów określonych w polu sin6_addr. Adres IP komputera (pole s6_addr[16]) jest 16 bitowy (128 bajtów).
14 Jędrzej Ułasiewicz Dziedzina Unixa AF_UNIX Ta rodzina adresów umożliwia komunikację między procesami w ramach jednego systemu. Adres jest nazwą ścieżki do pozycji systemu plików. Wystepuje także jako AF_LOCAL. #include <sys/socket.h> #include <sys/un.h> unix_socket = socket(af_unix, type, 0); error = socketpair(af_unix, type, 0, int fd[2]); Adres dziedziny AF_UNIX jest reprezentowany przez następującą strukturę: #define UNIX_PATH_MAX 108 struct sockaddr_un { sa_family_t sun_family; /* AF_UNIX */ char sun_path[unix_path_max]; /* pathname */ Pole sun_family zawsze zawiera stałą AF_UNIX. Funkcja socketpair tworzy dwa połączone gniazdka. Ich deskryptory zawarte są w elementach tablicy fd[0] i fd[1]. Funkcja stosowana gdy procesy są w relacji macierzysty potomny (deskryptory są dziedziczone). Nie ma różnicy do którego gniazdka fd[0] czy fd[1] się pisze,
15 Jędrzej Ułasiewicz 15 /* Przyklad uzycia funkcji socketpair */ #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <errno.h> #include <string.h> #include <sys/types.h> #include <sys/socket.h> int main(int argc,char *argv[]) { int z,n; int fd[2]; /* Para gniazdek */ const char hello[] = "witam - pisze do gniazdka"; char buf[80]; z = socketpair(af_unix,sock_stream,0,fd); if ( z < 0 ) { perror("socket"); return 1; printf("s[0] = %d;\n",fd[0]); printf("s[1] = %d;\n",fd[1]); if(fork() == 0) { close(fd[0]); n = write(fd[1], hello, sizeof(hello)); printf("proces potomny wyslal: %d znakow\n", n); else { /* you are the parent */ close(fd[1]); /* Close the child file descriptor */ n = read(fd[0], buf, sizeof(buf)); printf("proces macierzysty odebral: %d %s\n", n, buf); n = wait(null); return 0; Przykład 0-1 Użycie funkcji socketpair.
16 Jędrzej Ułasiewicz Funkcje dotyczące adresów inet_addr Konwersja z zapisu kropkowego na binarny inet_aton Konwersja z zapisu kropkowego na binarny inet_ntoa Konwersja z zapisu binarnego na kropkowy gethostbyname Ustalanie adresu sieciowego na podstawie nazwy gethostname Pobieranie nazwy komputera Pobieranie adresu komputera int gethostname(char *name, size_t len) Gdzie: name Nazwa komputera w postaci łańcucha zakończonego 0 len Maksymalna długość łancucha Funkcja zwraca: 0 sukces -1 błąd Funkcja zwraca nazwę komputera na którym wykonywany jest program. Do ustawiania adresu służy funkcja: int sethostname(const char *name, size_t len); Wykonać ją może tylko użytkownik z przywilejami administratora. Konwersja z zapisu kropkowego na binarny Funkcje systemowe nie obsługują zapisu z kropką ale zapis binarny 32 bitowy zdefiniowany jako in_addr_t. Konwersji z adresu kropkowego na binarny dokonują funkcje: inet_addr inet_aton in_addr_t inet_addr(char * ip_addres) Gdzie: ip_addres Zapis adresu IP z kropką w postaci łańcucha Funkcja zwraca pole sin_addr części adresowej struktury in_addr.
17 Jędrzej Ułasiewicz 17 int inet_aton(char * ip_addres, struct in_addr * inp) Gdzie: ip_addres Zapis adresu IP z kropką w postaci łańcucha inp Pole sin_addr części adresowej struktury in_addr int main(int argc, char * argv[]) { struct sockaddr_in adr_moj, adr_serw; s=socket(af_inet, SOCK_DGRAM, IPPROTO_UDP); if(s < 0) blad("socket"); memset((char *) &adr_serw, 0, sizeof(adr_serw)); adr_serw.sin_family = AF_INET; adr_serw.sin_port = htons(port); if (inet_aton(argv[1], &adr_serw.sin_addr)==0) {... Przykład 0-2 Ustalanie adresu klienta za pomocą funkcji inet_aton Konwersja z zapisu kropkowego na binarny dla AF_INET i AF_INET6 int inet_pton(int af, const char *src, void *dst); Gdzie: af src dst Domena AF_INET lub AF_INET6 Zapis adresu IP z kropką w postaci łańcucha Pole sin_addr części adresowej struktury in_addr Konwersja z zapisu binarnego na kropkowy Konwersji z adresu binarnego na kropkowy dokonuje funkcja: char *inet_ntoa( struct in_addr in ) Gdzie: in Binarny zapis adresu IP Funkcja przekształca zapis binarny adresu IP na zapis kropkowy w postaci łańcucha.
18 Jędrzej Ułasiewicz 18 Przykład: rec = recvfrom(s, &msg, blen, 0, &adr_cli, &slen); if(rec < 0) blad("recvfrom()"); printf("odebrano kom. z %s:%d \n", inet_ntoa(adr_cli.sin_addr),ntohs(adr_cli.sin_port) ); Przykład 0-3 Uzyskiwanie adresu kropkowego z binarnego Ustalanie adresu sieciowego na podstawie nazwy Aby ustalić adres IP komputera na podstawie jego nazwy należy użyć funkcji gethostbyname. struct hostend *gethostbyname(char * hostname) hostname - Nazwa komputera Funkcja zwraca wskaźnik na strukturę której elementem jest adres IP komputera. struct hostend { char *name; // Oficjalna nazwa komputera char **h_aliases; // Lista pseudonimów komputera int h_addrtype; // Typ dziedziny (AF_INET) int h_length; // Dlugość adresu (4) char **h_addr_list; // Lista adresów IP komputera Dla celów kompatybilności definiuje się h_addr jako h_addr_list[0]. Informacja otrzymywana jest z serwera nazw NIS lub lokalnego pliku /etc/hosts. Funkcja zwraca: NULL Gdy błąd wskaźnik Gdy znaleziono adres
19 Jędrzej Ułasiewicz 19 // Wywołanie prog nazwa_komp #include <netdb.h> #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { unsigned int i=0; struct hostent *hp; if (argc < 2) { printf("uzycie: %s hostname", argv[0]); exit(-1); hp = gethostbyname(argv[1]); if (hp == NULL) { printf("gethostbyname() -blad \n"); else { printf("%s = ", hp->h_name); while ( hp -> h_addr_list[i]!= NULL) { printf("%s ", inet_ntoa(*( struct in_addr*) (hp->h_addr_list[i]))); i++; printf("\n"); Przykład 0-4 Uzyskanie adresu komputera z linii poleceń W pliku nagłówkowym <netinet/in.h> definiuje się adres lokalnego komputera jako INADDR_ANY.
20 Jędrzej Ułasiewicz Komunikacja bez kontroli połączenia 3.1. Przebieg komunikacji Klient: Tworzy gniazdko - socket Nadaje gniazdku adres - bind (konieczne przy odbiorze) Nadaje lub odbiera dane - sendto, recfrom, write, read, recv, send Serwer: Tworzy gniazdko Nadaje gniazdku adres Nadaje lub odbiera dane - socket - bind (konieczne przy odbiorze) - sendto, recfrom, write, read, recv, send Aplikacja klienta Aplikacja serwera Socket(...) bind(...) Socket(...) bind(...) sendto(...) recfrom(...) recfrom(...) sendto(...) Rys. 3-1 Przebieg komunikacji bezpołączeniowej
21 Jędrzej Ułasiewicz Funkcje sendto i recfrom Odbiór danych z gniazdka - funkcja recfrom Funkcja recfrom umożliwia odczyt bajtów z gniazdka znajdującego się w stanie nie połączonym jak i połączonym. int recfrom(int sock, void *buf, int nbytes,int flags, struct sockaddr *from, int *fromlen ) sock Identyfikator gniadka buf Bufor w którym umieszczane są odczytane bajty nbytes Długość bufora odbiorczego flags Np. MSG_OOB (dane pilne), MSG_PEEK (odbiór bez usuwania) from Adres skąd przyszły dane (wartość nadawana przez funkcję). fromlen Długość adresu (wartość nadawana przez funkcję). Funkcja zwraca: >0 liczbę odebranych bajtów -1 Gdy błąd Zapis do gniazdka - funkcja sendto Funkcja sendto umożliwia wysłanie bajtów do gniazdka znajdującego się w stanie nie połączonym jak i połączonym. int sendto(int sock, void *buf, int nbytes,int flags, struct sockaddr *to, int tolen ) sock Identyfikator gniadka buf Bufor w którym umieszczane są bajty przeznaczone do zapisu nbytes Liczba bajtów którą chcemy zapisać flags Np. MSG_OOB (dane pilne) to Adres docelowy tolen Dlugość adresu Funkcja zwraca: >0 Liczbę wysłanych bajtów -1 Gdy błąd
22 Jędrzej Ułasiewicz Przykład komunikacja w domenie internetu AF_INET // Uruchomienie: udp_serw adres // Proces odbierajacy komunikaty - wysyla udp_cli #include <arpa/inet.h> #include <netinet/in.h> #include <stdio.h> #include <sys/types.h> #include <sys/socket.h> #include <unistd.h> #define BUFLEN 80 #define KROKI 10 #define PORT 9950 typedef struct { int typ; char buf[buflen]; msgt; void blad(char *s) { perror(s); exit(1); int main(void) { struct sockaddr_in adr_moj, adr_cli; int s, i, slen=sizeof(adr_cli),snd, rec; int blen=sizeof(msgt); char buf[buflen]; msgt msg; // Utworzenie gniazdka s=socket(af_inet, SOCK_DGRAM, IPPROTO_UDP); if(s < 0) blad("socket"); printf("gniazdko %d utworzone\n",s); // Ustalenie adresu IP odbiorcy memset((char *) &adr_moj, 0, sizeof(adr_moj)); adr_moj.sin_family = AF_INET; adr_moj.sin_port = htons(port); adr_moj.sin_addr.s_addr = htonl(inaddr_any);
23 Jędrzej Ułasiewicz 23 if (bind(s, &adr_moj, sizeof(adr_moj))==-1) blad("bind"); // Odbior komunikatow for (i=0; i<kroki; i++) { rec = recvfrom(s,&msg,blen,0,&adr_cli, &slen); if(rec < 0) blad("recvfrom()"); printf("odebrano z %s:%d res %d\n Typ: %d %s\n", inet_ntoa(adr_cli.sin_addr), ntohs(adr_cli.sin_port), rec,msg.typ,msg.buf); // Odpowiedz sprintf(msg.buf,"odpowiedz %d",i); snd = sendto(s, &msg, blen, 0, &adr_cli, slen); if(snd < 0) blad("sendto()"); close(s); return 0; Przykład 3-1 Transmisja bezpolaczeniowa serwer
24 Jędrzej Ułasiewicz 24 // Uruchomienie udp_cli adres_serwera #include <netinet/in.h> #include <stdio.h> #include <sys/types.h> #include <sys/socket.h> #include <unistd.h> #define BUFLEN 80 #define KROKI 10 #define PORT 9950 typedef struct { int typ; char buf[buflen]; msgt; void blad(char *s) { perror(s); exit(1); int main(int argc, char * argv[]) { struct sockaddr_in adr_moj, adr_serw, adr_x; int s, i, slen=sizeof(adr_serw), snd; int blen=sizeof(msgt),rec; char buf[buflen]; msgt msg; s=socket(af_inet, SOCK_DGRAM, IPPROTO_UDP); if(s < 0) blad("socket"); printf("gniazdko %d utworzone\n",s); memset((char *) &adr_serw, 0, sizeof(adr_serw)); adr_serw.sin_family = AF_INET; adr_serw.sin_port = htons(port); if (inet_aton(argv[1], &adr_serw.sin_addr)==0) { fprintf(stderr, "inet_aton() failed\n"); exit(1); for (i=0; i<kroki; i++) { msg.typ = 1; sprintf(msg.buf, "Komunikat %d", i); snd = sendto(s,&msg,blen,0,&adr_serw, slen); if(snd < 0) blad("sendto()");
25 Jędrzej Ułasiewicz 25 printf("wyslano komunikat do %s:%d %s\n", inet_ntoa(adr_serw.sin_addr), ntohs(adr_serw.sin_port), msg.buf); rec=recvfrom(s,&msg,blen,0,&adr_x, &slen); if(rec < 0) blad("recvfrom()"); sleep(1); close(s); return 0; Przykład 3-2 Transmisja bezpołączeniowa - klient
26 Jędrzej Ułasiewicz Przykład komunikacja w domenie Unix a AF_UNIX // Proces odbierajacy komunikaty - wysyla udp_cli #define BUFLEN 80 #define KROKI 10 #define PORT 9951 #define MY_SOCK_PATH "gniazdko1"... int main(void) { struct sockaddr_un my_addr, peer_addr; socklen_t peer_addr_size,rlen,slen; int s, i, snd, rec, blen=sizeof(msgt); char buf[buflen]; msgt msg; s = socket(af_unix, SOCK_DGRAM, 0); if (s == -1) blad("socket"); memset(&my_addr, 0, sizeof(struct sockaddr_un)); /* Clear structure */ my_addr.sun_family = AF_UNIX; strncpy(my_addr.sun_path, MY_SOCK_PATH, sizeof(my_addr.sun_path) - 1); if (bind(s, (struct sockaddr *) &my_addr, sizeof(struct sockaddr_un)) == -1) blad("bind"); // Odbior komunikatow for (i=0; i<kroki; i++) { rec = recvfrom(s, &msg, blen, 0, &peer_addr, &rlen); if(rec < 0) blad("recvfrom()"); printf("odebrano komunikat z :%d res %d\n Typ: %d %s\n",msg.typ,msg.buf); // Odpowiedz sprintf(msg.buf,"odpowiedz %d",i); snd = sendto(s, &msg, blen, 0, &peer_addr, slen); if(snd < 0) blad("sendto()"); close(s); return 0; Przykład 3-1 Komunikacja w dziedzinie AF_UNIX proces serwera
27 Jędrzej Ułasiewicz 27 int main(int argc, char * argv[]) { struct sockaddr_in adr_moj, adr_serw, adr_x; int s, i, slen=sizeof(adr_serw), snd, blen=sizeof(msgt),rec; char buf[buflen]; msgt msg; s=socket(af_inet, SOCK_DGRAM, IPPROTO_UDP); if(s < 0) blad("socket"); printf("gniazdko %d utworzone\n",s); memset((char *) &adr_serw, 0, sizeof(adr_serw)); adr_serw.sin_family = AF_INET; adr_serw.sin_port = htons(port); if (inet_aton(argv[1], &adr_serw.sin_addr)==0) { fprintf(stderr, "inet_aton() failed\n"); exit(1); for (i=0; i<kroki; i++) { // printf("sending packet %d\n", i); msg.typ = 1; sprintf(msg.buf, "Komunikat %d", i); snd = sendto(s, &msg, blen, 0, &adr_serw, slen); if(snd < 0) blad("sendto()"); printf("wyslano komunikat do %s:%d %s\n", inet_ntoa(adr_serw.sin_addr), ntohs(adr_serw.sin_port), msg.buf); rec = recvfrom(s, &msg, blen, 0, &adr_x, &slen); if(rec < 0) blad("recvfrom()"); sleep(1); close(s); return 0; Przykład 3-2 Komunikacja w dziedzinie AF_UNIX proces klienta
28 Jędrzej Ułasiewicz Komunikacja grupowa i rozgłoszenia Dotychczas omawiana komunikacja była typu jeden do jeden. W komunikacji klient / serwer komunikaty wymieniane były pomiędzy dwoma procesami. Jest to typ komunikacji jeden do jednego. Zdarzają się sytuacje że komunikacja obejmuje grupę procesów. Jest to typ komunikacji jeden do wielu. Grupa zbiór procesów działających wspólnie w sposób określony poprzez system lub użytkownika. O grupa N O jeden do jednego O N O jeden do wielu O Grupy wprowadza się po to aby procesy mogły działać na zbiorach procesów traktowanych jako jeden obiekt. Proces może wysłać komunikat do grupy jako całości nie orientując się w jej składzie i położeniu pojedynczych procesów. W sieciach istnieje wsparcie dla komunikacji grupowej. Rodzaje transmisji w sieciach: Jednonadawanie (ang. Unicasting) komunikat otrzymuje jedna stacje w grupie Wielonadawanie (ang. Multicasting) komunikaty otrzymują wybrane stacje w grupie Rozgłaszanie (ang. Broadcasting) komunikaty otrzymują wszystkie stacje w grupie Datagram rozsyłania grupowego powinien być odbierany przez te interfejsy które ich potrzebują.
29 Jędrzej Ułasiewicz jednonadawanie wielonadawanie rozgloszenie Rysunek 3-1 Rodzaje komunikacji w sieciach Rodzaj Ipv4 Ipv6 TCP UDP Liczba określanych interfejsów Liczba używanych interfejsów Jednostkowe jeden jeden Grupowe Opcja zbiór wszystkie ze zbioru Rozgłaszanie zbiór wszystkie Tab. 3-1 Wsparcie dla różnych rodzajów komunikacji dla protokołów rodziny IP Użycie rozgłaszania w sieciach standardu IP4 wymaga znajomości adresacji rozgłaszania. Adres IP 32 bitowy dzieli się na adres sieci (ang. network) i adres komputera (ang. host). Sposób podziału podaje poniższa tabela. Klasa Adres najniższy Adres najwyższy Bitów sieci A B C D brak E brak Tab. 3-2 Podział adresu IP4 na klasy Bitów hosta Klasa D używana jest do wielonadawania. 28 bitów określa adres grupy bitów adres rozsyłania grupowego
30 Jędrzej Ułasiewicz 30 Przyjeto konwencję że adres rozgłaszania jest adresem który posiada same jedynki w części dotyczącej hosta. Część sieciowa może być poszerzona przez maskę sieciową (ang. netmask). W prawidłowo skonfigurowanym interfejsie sieciowym adres rozgłaszania można uzyskac przez polecenie ifconfig (jak poniżej). $/sbin/ifconfig eth0 Link encap:ethernet HWaddr 00:0c:29:3e:ce:3f inet addr: Bcast: Mask: inet6 addr: fe80::20c:29ff:fe3e:ce3f/64 Scope:Link UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1 Listing 3-1 Uzyskanie adresu rozgłaszania przez polecenie ifconfig Do rozgłaszania może być też użyty specjalny adres: Nie jest on jednak polecany, gdyż różne systemy mogą go odmiennie interpretować, w przypadku gdy komputer ma więcej interfejsów sieciowych.
31 Jędrzej Ułasiewicz 31 // Uzycie:./bclient <port_serwera> #include <stdio.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #include <netdb.h> #define MAXBUF int main(int argc, char*argv[]){ int sock, status, buflen, sinlen; char buffer[maxbuf]; struct sockaddr_in sock_in; int yes = 1; sinlen = sizeof(struct sockaddr_in); memset(&sock_in, 0, sinlen); buflen = MAXBUF; // Utworzenie gniazdka UDP sock = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP); sock_in.sin_addr.s_addr = htonl(inaddr_any); sock_in.sin_port = htons(0); sock_in.sin_family = PF_INET; status = bind(sock, (struct sockaddr *)&sock_in, sinlen); printf("bind Status = %d\n", status); status = setsockopt(sock,sol_socket,so_broadcast,&yes, sizeof(int)); printf("setsockopt Status = %d\n", status); sock_in.sin_addr.s_addr=htonl(-1); // Wysylamy komunikat na adres rozgl sock_in.sin_port = htons(atoi(argv[1])); /* port number */ sock_in.sin_family = PF_INET; sprintf(buffer, "To jest rozgloszenie!!!"); buflen = strlen(buffer); status = sendto(sock, buffer, buflen, 0, (struct sockaddr *)&sock_in, sinlen); printf("sendto Status = %d\n", status); shutdown(sock, 2); close(sock); Przykład 3-3 Rozgłoszenia proces wysyłający (na podstawie [3])
32 Jędrzej Ułasiewicz 32 // Uzycie./bserver #include <stdio.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #include <netdb.h> #define MAXBUF #define PORT int main() { int sock, status, buflen; unsigned sinlen; char buffer[maxbuf]; struct sockaddr_in sock_in; int i,yes = 1; sinlen = sizeof(struct sockaddr_in); memset(&sock_in, 0, sinlen); sock = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP); sock_in.sin_addr.s_addr = htonl(inaddr_any); sock_in.sin_port = htons(port); sock_in.sin_family = PF_INET; status = bind(sock, (struct sockaddr *)&sock_in, sinlen); printf("bind Status = %d\n", status); status=getsockname(sock,(struct sockaddr*)&sock_in, &sinlen); printf("sock port %d\n",htons(sock_in.sin_port)); buflen = MAXBUF; for(i=0;i<10;i++) { memset(buffer, 0, buflen); status = recvfrom(sock, buffer, buflen, 0, (struct sockaddr *)&sock_in, &sinlen); printf("recfrom Status = %d\n", status); printf("%s\n",buffer); shutdown(sock, 2); close(sock); Przykład 3-4 Rozgłoszenia proces odbierający (na podstawie [3])
33 Jędrzej Ułasiewicz Komunikacja z kontrolą połączenia Klient: 1. Tworzy gniazdko socket 2. Nadaje gniazdku adres bind (konieczne przy odbiorze) 3. Łączy się z serwerem connect 4. Nadaje lub odbiera dane write, read, recv, send Serwer: 1. Tworzy gniazdko socket 2. Nadaje gniazdku adres bind (konieczne przy odbiorze) 3. Wchodzi w tryb akceptacji listen połączeń 4. Oczekuje na połączenia accept Gdy połączenie zostanie nawiązane: 1. Tworzy dla tego połączenia nowe gniazdko 2. Nadaje lub odbiera dane - write, read, recv, send 3. Zamyka gniazdko Aplikacja klienta Aplikacja serwera Socket(...) Socket(...) bind(...) listen(...) connect(...) accept(...) write(...) read(...) read(...) write(...) close close Rys. 4-1 Przebieg komunikacji z kontrolą połączenia
34 Jędrzej Ułasiewicz 34 Połączenie ze zdalnym gniazdkiem int connect(int sock, struct sockaddr *name, int namelen) sock name len Numer gniazdka Nazwa (adres) komputera Długość adresu Funkcja powoduje próbę nawiązania połączenie ze zdalnym gniazdkiem wyspecyfikowanym jako adres. Funkcja zwraca: -1 Gdy błąd 0 Gdy nawiązano połączenie Wprowadzenie serwera w stan gotowości do nawiązania połączenia int listen(int sock, int len) sock len Numer gniazdka Długość kolejki oczekujących połączeń Funkcja zwraca: -1 Błąd 0 Sukces
35 Jędrzej Ułasiewicz 35 Nawiązanie połączenia przez serwer int accept(int sock, struct sockaddr * name, int *namelen) sock Identyfikator gniazdka name Adres skąd przyszło połączenie (wartość nadana przez system po wykonaniu ) namelen Długość adresu (wykonanie funkcji nadaje zmiennej wartość) Działanie funkcji accept: Wywołanie accept może być blokujące. Gdy przychodzi nowe połączenie następuje odblokowanie procesu bieżącego i wykonanie następujących czynności: 1. Pobranie pierwszego połączenie z kolejki oczekujących połączeń. 2. Utworzenie nowego gniazdka o identycznych własnościach jak gniazdko utworzone poleceniem socket. 3. Alokacja nowego deskryptora pliku dla gniazdka. 4. Nadanie wartości parametrom name i namelen. Funkcja zwraca: >0 Identyfikator nowego gniazdka -1 Błąd Odczyt z gniazdka funkcja read Funkcja jest używana do odbioru danych z gniazdka w trybie połączeniowym. int read(int sock, void *bufor, int nbytes) sock Uchwyt gniadka bufor Bufor w którym umieszczane są przeczytane bajty nbytes Liczba bajtów którą chcemy przeczytać. Funkcja powoduje odczyt z gniazdka identyfikowanego przez sock nbytes bajtów i umieszczenie ich w buforze. Funkcja zwraca: > 0 Liczbę rzeczywiście odczytanych bajtów -1 Gdy błąd
36 Jędrzej Ułasiewicz 36 Nie ma gwarancji, że pojedyncze wywołanie funkcji odbierze dane wysłane za pomocą pojedynczego wywołania funkcji write. Zapis do gniazdka - funkcja write int write(int sock, void *bufor, int nbytes) sock Uchwyt gniazdka bufor Bufor w którym umieszczane są bajty przeznaczone do zapisu nbytes Liczba bajtów którą chcemy zapisać Funkcja powoduje zapis do gniazdka identyfikowanego przez sock nbytes bajtów znajdujących buforze. Funkcja zwraca: >0 liczbę rzeczywiście wysłanych bajtów -1 Gdy błąd
37 Jędrzej Ułasiewicz 37 Odczyt z gniazdka funkcja recv Funkcja jest używana do odbioru danych z gniazdka w trybie połączeniowym lub bezpołączeniowym. int recv(int sock, void *bufor, int nbytes, int flags) sock Identyfikator gniadka bufor Bufor w którym umieszczane są przeczytane bajty nbytes Liczba bajtów którą chcemy przeczytać. flags Flagi modyfikujące działanie funkcji: MSG_OOB, MSG_PEEK, MSG_WAITALL Funkcja powoduje odczyt z gniazdka identyfikowanego przez sock nbytes bajtów i umieszczenie ich w buforze. Funkcja zwraca: > 0 liczbę rzeczywiście przeczytanych bajtów, - 1 gdy błąd. MSG_WAITALL Funkcja czeka na tyle bajtów ile wymieniono w wywołaniu MSG_OOB Odbiór danych poza pasmem znaczenie zależy od protokołu MSG_PEEK Dane odczytane na próbę, nie znikają z bufora
38 Jędrzej Ułasiewicz 38 Zapis do gniazdka - funkcja send Funkcja jest używana do zapisu danych do gniazdka w trybie połączeniowym. int send(int sock, void *bufor, int nbytes, int flags) sock Identyfikator gniazdka bufor Bufor w którym umieszczane są bajty przeznaczone do zapisu nbytes Liczba bajtów którą chcemy zapisać flags Flagi modyfikujące działanie funkcji: MSG_OOB, MSG_ DONTROUTE, MSG_EOR Funkcja powoduje zapis do gniazdka identyfikowanego przez sock nbytes bajtów znajdujących buforze. Funkcja zwraca: >0 liczbę rzeczywiście wysłanych bajtów -1 Gdy błąd MSG_OOB Wysyłanie danych pilnych (ang. out of band) MSG_DONTROUTE Cel diagnostyczny MSG_EOR Koniec rekordu
39 Jędrzej Ułasiewicz 39 // - przyklad trybu polaczeniowego // Uzywany port 2000 // Uruchomienie: tcp-serw #include <sys/socket.h> #include <netinet/in.h> #include <stdlib.h> #define MY_PORT 2000 #define TSIZE 32 typedef struct { // Komunikat int typ; char tekst[tsize]; komunikat_t; main() { int sock, length; struct sockaddr_in server; int msgsock; int rval, res,i, cnt; komunikat_t msg; // Tworzenie gniazdka sock = socket(af_inet, SOCK_STREAM, 0); if (sock < 0) { perror("blad gniazdka"); exit(1); // Adres gniazdka server.sin_family = AF_INET; server.sin_addr.s_addr = INADDR_ANY; server.sin_port = ntohs(my_port); if (bind(sock, &server, sizeof(server))) { perror("tworzenie gniazdka"); exit(1); // Uzyskanie danych poloczenia length = sizeof(server); if (getsockname(sock, &server, &length)) { perror("getting socket name"); exit(1); printf("numer portu %d\n", ntohs(server.sin_port)); // Start przyjmowania polaczen listen(sock, 5);
40 Jędrzej Ułasiewicz 40 do { printf("czekam na polaczenie \n"); msgsock = accept(sock, 0, 0); cnt = 0; if (msgsock == -1) perror("accept"); else { printf("polaczenie %d \n",msgsock); do { /* przesylanie bajtow */ cnt++; // Odbior res = read(msgsock,&msg,sizeof(msg)); if(res < 0) { perror("blad odczytu"); break; if(res == 0) { printf("pol zamkn\n"); break; printf("odeb: Msg %d %s\n",cnt,msg.tekst); msg.typ = 1; sprintf(msg.tekst,"odpowiedz %d",cnt); printf("wysylam: %s\n",msg.tekst); res = write(msgsock,&msg,sizeof(msg)); sleep(1); while (res!= 0); close(msgsock); while (1); printf("koniec\n"); Przykład 4-1 Serwer tcp_serw.c działający w trybie z kontrolą połączenia // Program odbiera dane od programu tcp-serw // uruchomionego na wezle addr. Uzywany port 2000 // Uruchomienie: tcp-cli addr #include <sys/socket.h> #include <netinet/in.h> #include <netdb.h> #include <stdlib.h> #define MY_PORT 2000 #define TSIZE 32
41 Jędrzej Ułasiewicz 41 typedef struct { // Komunikat int typ; char tekst[tsize]; komunikat_t; main(int argc, char *argv[]){ int sock, cnt,res; struct sockaddr_in server; struct hostent *hp, *gethostbyname(); komunikat_t msg; // Tworzenie gniazdka sock = socket(af_inet, SOCK_STREAM, 0); if (sock < 0) { perror("blad gniazdka"); exit(1); // Uzyskanie adresu maszyny z linii polecen server.sin_family = AF_INET; hp = gethostbyname(argv[1]); if (hp == 0) { printf("%s nieznany\n",argv[1]); exit(2); memcpy(&server.sin_addr, hp->h_addr, hp->h_length); server.sin_port = htons(my_port); // Proba polaczenia if (connect(sock, &server, sizeof(server)) < 0) { perror("polaczenie"); exit(1); printf("polaczenie nawiazane\n"); // Petla odczytu cnt = 0; do { cnt++; // memset(&msg,0,sizeof(msg)); // Wyslanie komunikatu msg.typ = 1; sprintf(msg.tekst,"komunikat %d",cnt);
42 Jędrzej Ułasiewicz 42 printf("wysylam: %s\n",msg.tekst); res = write(sock,&msg,sizeof(msg)); // Odbior komunikatu res = read(sock,&msg,sizeof(msg)); if(res < 0) { perror("blad odczytu"); break; if(res == 0) { printf("polaczenie zamkniete"); printf("odebramo %s\n",msg.tekst); while( cnt < 10 ); Przykład 4-2 Klient tcp_cli.c w trybie z kontrolą połączenia break;
43 Jędrzej Ułasiewicz Obsługa sygnałów Pewne istotne zdarzenia powodują generowanie sygnałów. SIGIO SIGURG SIGPIPE gniazdka. - W gniazdku znalazły się nowe gotowe do czytania dane - Do gniazdka przybyła wiadomość pilna - Połączenie zostało przerwane i niemożliwe jest pisanie do 4.2. Konfigurowanie gniazdek Do konfigurowania gniazdek używa się następujących funkcji: Testowanie bieżących opcji: int getsockopt(int s, int level, int optname, void *optval, int *optlen); Ustawianie bieżących opcji: int setsokopt(int s, int level, int optname, void *optval, int optlen); Przykłady opcji: SO_BRODCAST SO_RCVBUF SO_SNDBUF SO_KEEPALIVE SO_RCVTIMEO SO_SNDTIMEO Ustawienie trybu rozgłaszania Ustawienie wielkości bufora odbiorczego Ustawienie wielkości bufora nadawczego Wysyłaj pakiety kontrolne Timeout odbioru Timeout nadawania
44 Jędrzej Ułasiewicz Wykorzystanie standardowej biblioteki wejścia / wyjścia Standardowa biblioteka wejścia oferuje szerokie możliwości przetwarzania i formatowania plików. Korzysta ona ze strumieni - struktury FILE zdefiniowanej w pliku nagłówkowym stdio.h. Strumień otwiera się za pomocą funkcji fopen. FILE *we; we = fopen(pathname,"r"); if ( we == NULL ) { perror( fopen ); exit(1); Do połączenia gniazdka ze strumieniem może być użyta funkcja fdopen. #include <stdio.h> FILE *fdopen(int fildes,const char *mode); Gdzie: fildes Identyfikator pliku w tym przypadku gniazdka mode Tryb dostępu, tak sam jak w funkcji fopen Funkcja zwraca:!=null Identyfikator strumienia połączonego z gniazdkiem NULL Błąd int s; /* socket */ FILE *strm; /* stream */ s = socket(pf_inet,sock_stream,0); strm = fdopen(s,"r+"); if ( strm == NULL ) { perror(fdopen); exit(1); Listing 0-1 Połączenie gniazdka s ze strumieniem Jak przerwać połączenie gniazdka ze strumieniem, funkcja close zamyka gniazdko.
45 Jędrzej Ułasiewicz 45 Oddzielne strumienie dla zapisu i odczytu W powyższym przykładzie strumień strm może być użyty do zapisu i odczytu. Często wygodnie jest te funkcje rozdzielić (buforowanie może powodować trudności). Wykorzystana będzie funkcja dup. int dup(int oldfd) Funkcja dup tworzy kopię uchwytu oldfd. Nowy uchwyt, będący wolnym uchwytem o najmniejszym numerze (pierwszy wolny) zwracany jest przez funkcję dup. int s; /* socket */ FILE *rx; /* read stream */ FILE *tx /* write stream */ s = socket(pf_inet,sock_stream,0); rx = fdopen(s,"r"); if ( rx == NULL ) { perror(fdopen1); exit(1); tx = fdopen(dup(s),"w"); if ( tx == NULL ) { perror(fdopen2); exit(1); Listing 0-2 Utworzenie oddzielnych strumieni do odczytu i zapisu Strumienie mogą być zamykane niezależnie: fclose(rx) zamyka strumień wejściowy fclose(tx) zamyka strumień wejściowy Przed zamknięciem strony do zapisu należy spowodować zapis buforów przez wykorzystanie funkcji fflush. fflush(tx); /* Flush buffer out */ Buforowanie Strumienie umozliwiają buforowanie. Możliwe są następujące tryby buforowania: Pełne bufowanie (blokowe) Buforowanie linii
46 Jędrzej Ułasiewicz 46 Brak buforowania #include <stdio.h> int setbuf(file *stream,char *buf); int setbuffer(file *stream, char *buf, size_t size); int setlinebuf(file *stream); int setvbuf(file *stream, char *buf, int mode, size_t size); Gdzie: stream Identyfikator strumienia buf Adres bufora, gdy NULL użyty będzie bufor wewnętrzny size Wielkość bufora mode Flaga patrz tabela niżej Flaga Opis _IOFBF Pełne buforowanie _IOLBF Buforowanie liniami _IONBF Brak buforowania. Tabela 0-1 Znaczenie parametru mode funkcji setvbuf
47 Jędrzej Ułasiewicz 47 #include <unistd.h> #define PORT #define BUFSIZE 2000 int main(void) { int server_sock_fd; int rc; char buf[bufsize]; int done = 0; struct sockaddr_in server_addr; int client_socket_fd; struct sockaddr_in client_addr; socklen_t client_addr_size = sizeof(client_addr); s_sock= socket(af_inet, SOCK_STREAM, 0); if (s_sock< 0) { perror("couldn't create socket"); exit(1); server_addr.sin_family = AF_INET; server_addr.sin_port = htons(port); inet_pton(af_inet, " ", &server_addr.sin_addr); rc = bind(server_sock_fd,(struct sockaddr *) &server_addr, sizeof(server_addr)); if (rc < 0) { perror("couldn't bind server socket"); exit(1); rc = listen(server_sock_fd, 5); if (rc < 0) { perror("couldn't listen on server socket"); exit(1);
48 Jędrzej Ułasiewicz 48 while (1) { // Oczekiwanie na polaczenie c_sock= accept( s_sock,(struct sockaddr*) &client_addr,&client_addr_size); if (c_sock< 0) { perror("couldn't accept connection"); exit(1); // Otwarcie gniazdka jako strumienia FILE *client_socket_fh = fdopen(c_sock,"r"); do { // Odczyt linii ze strumienia fgets(buf, BUFSIZE, client_socket_fh); printf("%s", buf); if(strcmp(buf, "stop\r\n") == 0) done = 1; while(!done); fclose(c_sock); close(s_sock); return 0; Przykład 0-1 Przekształcenie gniazdka w strumień program serwera (na podstawie [2])
49 Jędrzej Ułasiewicz #define PORT int main(int argc, char *argv[]) { int rc; FILE *fh = fdopen(s, "w"); int s; if (argc < 2) { fprintf(stderr, "Uzycie: client <message>\n"); exit(1); s = socket(af_inet, SOCK_STREAM, 0); if (s < 0) { perror("socket"); exit(1); struct sockaddr_in server_addr; server_addr.sin_family = AF_INET; server_addr.sin_port = htons(port); inet_pton(af_inet, " ", &server_addr.sin_addr); rc = connect(s,(struct sockaddr *) &server_addr, sizeof(server_addr)); if (rc < 0) { perror("connect"); exit(1); // Przeksztalcenie gniazdka w strumien FILE * dla zapisu // Wyslanie komunikatu do serwera fprintf(fh, "%s\r\n", argv[1]); // Zamkniecie gniazdk fclose(fh); return 0; Przykład 0-2 Przekształcenie gniazdka w strumień program klienta (na podstawie [2])
50 Jędrzej Ułasiewicz 50 Testowanie przykładu Na jednym terminalu uruchamiamy program serwer, na drugim uruchamiamy polecenie netstat: $netstat -lt Active Internet connections (only servers) Proto Recv-Q Send-Q Local Address Foreign Address State tcp :sybaseanywhere :* LISTEN tcp :aminet :* LISTEN tcp :ssh :* LISTEN tcp : :* LISTEN tcp 0 0 localhost:ipp :* LISTEN tcp 0 0 localhost:smtp :* LISTEN Listing 0-3 Wynik działania polecenia netstat widoczny proces nasłuchujący na porcie Następnie uruchamiamy polecenie telnet: $telnet Tekst wpisany w oknie telneta będzie widoczny w terminalu serwera.
51 Jędrzej Ułasiewicz Serwery współbieżne Typową sytuacją jest taka, gdy do serwera łączy się wielu klientów. Aby mogli być oni obsłużeni współbieżnie także serwer musi działać współbieżnie. Aby zwiększyć przepustowość serwera stosuje się następujące rozwiązania: 1. Serwer wieloprocesowy - Dla każdego klienta tworzony jest proces który go obsługuje 2. Serwer wielowątkowy - Dla każdego klienta tworzony jest wątek który go obsługuje 3. Serwer asynchroniczny Obsługuje się zdarzenia gotowości na gniazdach, wykorzystanie funkcji select lub poll Gdzie szukamy możliwości zwiększenia przepustowości? 1. Podział na procesy lub wątki by umożliwić wykorzystanie równoległości sprzętowej (wiele rdzeni lub procesorów). 2. Eliminacja oczekiwania na gotowość klienta i urządzeń wejścia / wyjścia przez obsługę zdarzeń asynchronicznych.
52 Jędrzej Ułasiewicz Serwer wieloprocesowy Pierwsze rozwiązanie jest najprostsze, jednak powoduje trudności gdy procesy musza się między sobą komunikować. Do komunikacji wykorzystuje się: Łącza Kolejki FIFO Kolejki POSIX Pamięć dzielona i semafory Zaletą jest możliwość wykonywania procesów obsługi klienta na oddzielnych rdzeniach procesora lub oddzielnych procesorach. Schemat działania serwera wieloprocesowego podano poniżej: Proces główny: 1. Proces główny tworzy gniazdko - socket 2. Nadaje gniazdku adres - bind (konieczne przy odbiorze) 3. Wchodzi w tryb akceptacji połączeń - listen 4. Oczekuje na połączenia - accept 5. Gdy przychodzi nowe połączenie funkcja accept zwraca identyfikator nowego gniazdka. To gniazdko będzie używane w połączeniu z klientem. Dla połączenia tworzy się nowy proces potomny i przechodzi się do 4. Proces obsługujący połączenie korzysta z nowego gniazdka którego numer jest przekazany jako parametr. Proces potomny: 1. Nadaje lub odbiera dane - write, read, recv, send 2. Zamyka gniazdko
53 Jędrzej Ułasiewicz 53 Srodowisko serwera Nowe polaczenie Proces glówny Proces przyjmujacy nowe polaczenia Procesy klienckie TCP klient 1 klient 2 klient N Obsluga klienta 1 Obsluga klienta 2 Obsluga klienta N Rys. 5-1 Serwer współbieżny każdy z klientów obsługiwany przez oddzielny proces socket(...) socket(...) bind(...) listen(...) connect(...) write(...) uchwyt gniazdka accept(...) potomny fork(...) read(...) read(...) close write(...) Aplikacja klienta Rys. 5-2 Serwer współbieżny close Aplikacja serwera
54 Jędrzej Ułasiewicz 54 Gdy kończone są procesy obsługujące połączenia przebywają one w stanie zombie. Proces macierzysty powinien usuwać te procesy. Może się to odbywać w następujący sposób: 1. Obsługiwać sygnał SIGCHLD 2. W procedurze obsługi tego sygnału wykonać funkcję wait.
55 Jędrzej Ułasiewicz 55 // - przyklad trybu polaczeniowego // Serwer wspolbiezny // Uzywany port 2000 // Uruchomienie: tcp_serw_wsp #include <sys/socket.h> #include <netinet/in.h> #include <stdlib.h> #define MY_PORT 2000 #define TSIZE 32 typedef struct { // Komunikat int typ; char tekst[tsize]; komunikat_t; main() { int sock, length; struct sockaddr_in server; int msgsock; int rval, res,i, cnt; komunikat_t msg; // Tworzenie gniazdka sock = socket(af_inet, SOCK_STREAM, 0); if (sock < 0) { perror("blad gniazdka"); exit(1); // Adres gniazdka server.sin_family = AF_INET; server.sin_addr.s_addr = INADDR_ANY; server.sin_port = ntohs(my_port); if (bind(sock, &server, sizeof(server))) { perror("tworzenie gniazdka"); exit(1); // Uzyskanie danych poloczenia length = sizeof(server); if (getsockname(sock, &server, &length)) { perror("getting socket name"); exit(1); printf("numer portu %d\n", ntohs(server.sin_port)); cnt = 0; // Start przyjmowania polaczen
56 Jędrzej Ułasiewicz 56 listen(sock, 5); do { printf("czekam na polaczenie \n"); msgsock = accept(sock, 0, 0); if (msgsock == -1) perror("accept"); cnt++; printf("polaczenie %d cnt: %d\n",msgsock,cnt); if(fork() == 0) { // Nowy proces i = 0; do { // Odbior i++; res = read(msgsock,&msg,sizeof(msg)); if(res < 0) { perror("bl odcz"); break; if(res == 0) { printf("pol zamkn\n"); break; printf("pol. %d Od: Msg %d %s\n", cnt,i,msg.tekst); msg.typ = 1; sprintf(msg.tekst,"pol %d odpowiedz %d",cnt,i); printf("wysylam: %s\n",msg.tekst); res = write(msgsock,&msg,sizeof(msg)); sleep(10); while (res!= 0); close(msgsock); exit(cnt); while (1); printf("koniec\n"); Przykład 5-1 Serwer współbieżny w trybie połączeniowym. Dla każdego połączenia tworzony nowy proces.
57 Jędrzej Ułasiewicz Serwer asynchroniczny Inną metodą zwiększenia szybkości działania serwera jest wykorzystanie schematu serwera asynchronicznego. Rozwiązanie polega wykorzystaniu funkcji select (lub poll) która blokuje proces wykonawczy w oczekiwaniu na zdarzenia wystąpienia gotowości na którymś z nadzorowanych deskryptorów a następnie na obsłudze tych zdarzeń. Schemat postępowania jest następujący: 1. Tworzony jest pusty zbiór gniazd readfds 2. Tworzone jest gniazdko master_socket na którym będą przyjmowane połączenia. Do readfds dodajemy master_socket 3. Funkcja select blokuje process w oczekiwaniu na gotowość na którymś z gniazd ze zbioru S. select(max_sd + 1, &readfds, NULL, NULL, NULL); 4. Gdy wystąpiła gotowość na master_socket znaczy to że jest nowe połączenie. client_socket=accept(master_socket,...). Dodajemy nowe gniazdo client_socket do readfds 5. Gdy wystąpiła gotowość na którymś z gniazd klienta client_socket obsługujemy żądanie. 6. Gdy okaże się że klient się rozłączył (np. funkcja read(client_socket,...) zwróci 0) usuwamy gniazdko client_socket ze zbioru readfds 7. Przechodzimy do punktu 3
58 Jędrzej Ułasiewicz 58 Tworzymy pusty zbiów readfds Tworzymu gniazdo master_socket = socket(af_inet,sock_stream,0) dolacz master_socket do readfs czekamy na gotowosc na readfds select(max_sd + 1, &readfds, NULL, NULL, NULL); gotowosc na master_socket gdzie gotowość? gotowosc na client_socket client_socket = accept(master_socket,...) dodajemy client_socket do readfds Obsluga zlecenia na client_socket res = read(client_socket,...) czy rozlączenie? res == 0 tak nie usuwamy client_socket z readfds Rysunek 5-1 Schemat działania serwera asynchronicznego
59 Jędrzej Ułasiewicz 59 /* */ Handle multiple socket connections with select and fd_set on Linux Silver Moon ( m00n.silv3r@gmail.com)... #define TRUE 1 #define FALSE 0 #define PORT 8888 int main(int argc, char *argv[]) { int opt = TRUE; int master_socket, addrlen, new_socket, client_socket[30], max_clients = 30, activity, i, valread, sd, res; int max_sd; struct sockaddr_in address; char buffer[1025]; //data buffer of 1K //set of socket descriptors fd_set readfds; //a message char *message = "ECHO Daemon v1.0 \r\n"; //initialise all client_socket[] to 0 so not checked for (i = 0; i < max_clients; i++) { client_socket[i] = 0; //create a master socket if( (master_socket = socket(af_inet, SOCK_STREAM, 0)) == 0) { perror("socket failed"); exit(exit_failure); //set master socket to allow multiple connections, // this is just a good habit, it will work without this if( setsockopt(master_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(opt)) < 0 ) { perror("setsockopt"); exit(exit_failure); //type of socket created address.sin_family = AF_INET; address.sin_addr.s_addr = INADDR_ANY; address.sin_port = htons( PORT ); //bind the socket to localhost port 8888 if(bind(master_socket, (struct sockaddr *)&address,sizeof(address))<0) { perror("bind failed"); exit(exit_failure); printf("listener on port %d \n", PORT); //try to specify maximum of 3 pending connections for the master socket
Komputery i Systemy Równoległe Jędrzej Ułasiewicz 1
Komputery i Systemy Równoległe Jędrzej Ułasiewicz 1 1 Interfejs gniazdek Jednolity interfejs API (Application Program Interface) do mechanizmów komunikacji sieciowej. Wprowadzony w wersji Unixa BSD 4.2
Bardziej szczegółowoProgramowanie sieciowe z użyciem interfejsu gniazdek
Jędrzej Ułasiewicz 1 Programowanie sieciowe z użyciem interfejsu gniazdek Spis treści: 1. Interfejs gniazdek - wprowadzenie...2 2. Domeny komunikacji, style komunikacji i protokoły...3 2.1. Domeny...5
Bardziej szczegółowoLiteratura uzupełniająca: W. Richard Stevens, Programowanie zastosowań sieciowych w systemie Unix WNT 1998
Gniazda BSD Literatura uzupełniająca: W. Richard Stevens, Programowanie zastosowań sieciowych w systemie Unix WNT 1998 socket() Użycie gniazd w transmisji połączeniowej bind() listen() socket() accept()
Bardziej szczegółowoKomunikacja sieciowa - interfejs gniazd
SOE Systemy Operacyjne Wykład 14 Komunikacja sieciowa - interfejs gniazd dr inŝ. Andrzej Wielgus Instytut Mikroelektroniki i Optoelektroniki WEiTI PW Model komunikacji sieciowej Model OSI (ang. Open System
Bardziej szczegółowo3. Identyfikacja. SKŁADNIA #include <sys/socket.h> int getpeername(int socket, struct sockaddr *addr, int *addrlen);
3.1. Określanie adresu połączonego hosta 3. #include int getpeername(int socket, struct sockaddr *addr, int *addrlen); Funkcja getpeername dostarcza adresu drugiej strony połączenia. Parametry:
Bardziej szczegółowo1.1 Przykład znajdowanie liczb pierwszych leżących w zadanym zakresie, tryb bezpołączeniowy
1.1 Przykład znajdowanie liczb pierwszych leżących w zadanym zakresie, tryb bezpołączeniowy Należy znaleźć liczby pierwsze w zakresie od 2 do N na P komputerach. Zarządca pocz[i], kon[i] wykonawca 1 wykonawca
Bardziej szczegółowoGniazda BSD. komunikacja bezpołączeniowa
Gniazda BSD komunikacja bezpołączeniowa Użycie gniazd w transmisji bezpołączeniowej socket() socket() bind() bind() STOP! recv() żądanie send() send() odpowiedź recv() STOP! recvfrom() #include
Bardziej szczegółowoIteracyjny serwer TCP i aplikacja UDP
Iteracyjny serwer TCP i aplikacja UDP Iteracyjny serwer TCP Funkcje wywoływane przez serwer TCP socket() - bind() - listen() - accept() - read() / write() - close() socket() Creates an endpoint for communication
Bardziej szczegółowoProgramowanie Sieciowe 1
Programowanie Sieciowe 1 dr inż. Tomasz Jaworski tjaworski@iis.p.lodz.pl http://tjaworski.iis.p.lodz.pl/ Klient UDP Kolejność wykonywania funkcji gniazdowych klienta UDP Protokół UDP jest bezpołączeniowy:
Bardziej szczegółowoProgramowanie przy użyciu gniazdek
Programowanie przy użyciu gniazdek Gniazdo (ang. socket) pojęcie abstrakcyjne reprezentujące dwukierunkowy punkt końcowy połączenia. Dwukierunkowość oznacza możliwość wysyłania i przyjmowania danych. Wykorzystywane
Bardziej szczegółowoProgramowanie aplikacji równoległych i rozproszonych. Wykład 4
Wykład 4 p. 1/44 Programowanie aplikacji równoległych i rozproszonych Wykład 4 Dr inż. Tomasz Olas olas@icis.pcz.pl Instytut Informatyki Teoretycznej i Stosowanej Politechnika Częstochowska Gniazda - Wstęp
Bardziej szczegółowo2. Interfejs gniazd. 2.1. Gniazdo
2. 2.1. Gniazdo Gniazdo (ang. socket): pewna abstrakcja wykorzystywana do wysyłania lub otrzymywania danych z innych procesów. Pełni rolę punktu końcowego w linii komunikacyjnej. to interfejs między programem
Bardziej szczegółowoProgramowanie sieciowe
Programowanie sieciowe dr Tomasz Tyrakowski Dyż ury: wtorki 12:00 13:00 czwartki 14:00 15:00 pokój B4-5 e-mail: ttomek@amu.edu.pl materiały: http://www.amu.edu.pl/~ttomek 1 Wymagania podstawowa znajomość
Bardziej szczegółowoGniazda - Wstęp. Oprogramowanie systemów równoległych i rozproszonych. Sposób komunikacji. Domena adresowa. olas@icis.pcz.pl
Gniazda - Wstęp Oprogramowanie systemów równoległych i rozproszonych Dr inż. Tomasz Olas olas@icis.pcz.pl Instytut Informatyki Teoretycznej i Stosowanej Politechnika Częstochowska Domena adresowa 1/??
Bardziej szczegółowoGniazda BSD. Procesy w środowisku sieciowym. Gniazda podstawowe funkcje dla serwera. Gniazda podstawowe funkcje dla klienta
Procesy w środowisku sieciowym! Obsługa! Protokół! Numery portów i ogólnie znane adresy! Połączenie (asocjacja) i gniazdo (półasocjacja)! Model klient-serwer " Serwer - bierne otwarcie kanału " Klient
Bardziej szczegółowoGniazda UDP. Bartłomiej Świercz. Łódź, 3 kwietnia Katedra Mikroelektroniki i Technik Informatycznych. Bartłomiej Świercz Gniazda UDP
Gniazda UDP Bartłomiej Świercz Katedra Mikroelektroniki i Technik Informatycznych Łódź, 3 kwietnia 2006 Wstęp ZewzględunaróżnicewprotokołachTCPiUDPsposób korzystania z gniazd UDP różni sie znacznie od
Bardziej szczegółowoArchitektura typu klient serwer: przesyłanie pliku tekstowo oraz logowania do serwera za pomocą szyfrowanego hasła
Architektura typu klient serwer: przesyłanie pliku tekstowo oraz logowania do serwera za pomocą szyfrowanego hasła Wydział Inżynierii Mechanicznej i Informatyki Instytut Informatyki Teoretycznej i Stosowanej
Bardziej szczegółowoGniazda. S. Samolej: Gniazda 1
Gniazda dr inż. Sławomir Samolej Katedra Informatyki i Automatyki Politechnika Rzeszowska Program przedmiotu oparto w części na materiałach opublikowanych na: http://wazniak.mimuw.edu.pl/ oraz na materiałach
Bardziej szczegółowoGniazda BSD implementacja w C#
BSD implementacja w C# Implementacja w C#: Przestrzeń nazw: System.Net.Sockets Klasa: public class Socket : IDisposable Implementacja w C#: Konstruktor: public Socket( AddressFamily addressfamily, SocketType
Bardziej szczegółowoKlient-Serwer Komunikacja przy pomocy gniazd
II Klient-Serwer Komunikacja przy pomocy gniazd Gniazda pozwalają na efektywną wymianę danych pomiędzy procesami w systemie rozproszonym. Proces klienta Proces serwera gniazdko gniazdko protokół transportu
Bardziej szczegółowoPodstawowe typy serwerów
Podstawowe typy serwerów 1. Algorytm serwera. 2. Cztery podstawowe typy serwerów. iteracyjne, współbieżne, połączeniowe, bezpołączeniowe. 3. Problem zakleszczenia serwera. 1 Algorytm serwera 1. Utworzenie
Bardziej szczegółowoMODEL WARSTWOWY PROTOKOŁY TCP/IP
MODEL WARSTWOWY PROTOKOŁY TCP/IP TCP/IP (ang. Transmission Control Protocol/Internet Protocol) protokół kontroli transmisji. Pakiet najbardziej rozpowszechnionych protokołów komunikacyjnych współczesnych
Bardziej szczegółowo1. Model klient-serwer
1. Model klient-serwer 1.1. Model komunikacji w sieci łącze komunikacyjne klient serwer Tradycyjny podział zadań: Klient strona żądająca dostępu do danej usługi lub zasobu Serwer strona, która świadczy
Bardziej szczegółowoKomunikacja międzyprocesowa. Krzysztof Banaś Systemy rozproszone 1
Komunikacja międzyprocesowa Krzysztof Banaś Systemy rozproszone 1 Komunikacja międzyprocesowa Dla funkcjonowania systemów rozproszonych konieczna jest sprawna komunikacja pomiędzy odległymi procesami Podstawowym
Bardziej szczegółowoŁącza nienazwane(potoki) Łącza nienazwane mogą być używane tylko pomiędzy procesami ze sobą powiązanymi.
Przykład: $ ls more Łącza nienazwane(potoki) Łącza nienazwane mogą być używane tylko pomiędzy procesami ze sobą powiązanymi. Tworzenie łącza #include int pipe(int filedes[2]); Przykład: int
Bardziej szczegółowo5. Model komunikujących się procesów, komunikaty
Jędrzej Ułasiewicz str. 1 5. Model komunikujących się procesów, komunikaty Obecnie stosuje się następujące modele przetwarzania: Model procesów i komunikatów Model procesów komunikujących się poprzez pamięć
Bardziej szczegółowoGniazda surowe. Bartłomiej Świercz. Łódź,9maja2006. Katedra Mikroelektroniki i Technik Informatycznych. Bartłomiej Świercz Gniazda surowe
Gniazda surowe Bartłomiej Świercz Katedra Mikroelektroniki i Technik Informatycznych Łódź,9maja2006 Wstęp Gniazda surowe posiadają pewne właściwości, których brakuje gniazdom TCP i UDP: Gniazda surowe
Bardziej szczegółowoKrótkie wprowadzenie do korzystania z OpenSSL
Krótkie wprowadzenie do korzystania z OpenSSL Literatura: http://www.openssl.org E. Rescola, "An introduction to OpenSSL Programming (PartI)" (http://www.linuxjournal.com/article/4822) "An introduction
Bardziej szczegółowoOprogramowanie komunikacyjne dla Internetu rzeczy Laboratorium nr 4 komunikacja unicastowa IPv6
Oprogramowanie komunikacyjne dla Internetu rzeczy Laboratorium nr 4 komunikacja unicastowa IPv6 Celem ćwiczenia jest zdobycie umiejętności programowania komunikacji unicastowej za pomocą protokołu IPv6
Bardziej szczegółowoProgramowanie sieciowe
Programowanie sieciowe Wykład dla studentów Informatyki Stosowanej i Fizyki Komputerowej UJ 2014/2015 Michał Cieśla pok. D-2-47, email: michal.ciesla@uj.edu.pl konsultacje: środy 10-12 http://users.uj.edu.pl/~ciesla/
Bardziej szczegółowoInstytut Teleinformatyki
Instytut Teleinformatyki Wydział Inżynierii Elektrycznej i Komputerowej Politechnika Krakowska programowanie usług sieciowych Dziedzina Unix laboratorium: 06 Kraków, 2014 06. Programowanie Usług Sieciowych
Bardziej szczegółowoProtokoły sieciowe - TCP/IP
Protokoły sieciowe Protokoły sieciowe - TCP/IP TCP/IP TCP/IP (Transmission Control Protocol / Internet Protocol) działa na sprzęcie rożnych producentów może współpracować z rożnymi protokołami warstwy
Bardziej szczegółowoSUMA KONTROLNA (icmp_cksum) NUMER KOLEJNY (icmp_seq)
Program my_ping: wysłanie komunikatu ICMP z żądaniem echa Struktura icmp (plik netinet/ip_icmp.h) 0 7 8 15 16 31 TYP (icmp_type) KOD (icmp_code) IDENTYFIKATOR (icmp_id) SUMA KONTROLNA (icmp_cksum) NUMER
Bardziej szczegółowoArchitektura typu klient serwer: uproszczony klient POP3
Architektura typu klient serwer: uproszczony klient POP3 Wydział Inżynierii Mechanicznej i Informatyki Instytut Informatyki Teoretycznej i Stosowanej dr inż. Łukasz Szustak Składniki systemu poczty e-mail
Bardziej szczegółowoiseries Programowanie z użyciem gniazd
iseries Programowanie z użyciem gniazd iseries Programowanie z użyciem gniazd Copyright International Business Machines Corporation 2000, 2001. Wszelkie prawa zastrzeżone. Spis treści Część 1. Programowanie
Bardziej szczegółowoPodstawy Transmisji Danych. Wykład IV. Protokół IPV4. Sieci WAN to połączenia pomiędzy sieciami LAN
Podstawy Transmisji Danych Wykład IV Protokół IPV4 Sieci WAN to połączenia pomiędzy sieciami LAN 1 IPv4/IPv6 TCP (Transmission Control Protocol) IP (Internet Protocol) ICMP (Internet Control Message Protocol)
Bardziej szczegółowosocket(int domain, int type, int protocol)
Co identyfikuje adres IP a co port? IP identyfikuje hosta w sieci port identyfikuje typ procesu (np. 21 FTP, 25 SMTP, 49 LOGIN) gniazdo identyfikuje unikalny nr połączenia Czym różni się deskryptor gniazda
Bardziej szczegółowoSieci komputerowe. Wykład 7: Transport: protokół TCP. Marcin Bieńkowski. Instytut Informatyki Uniwersytet Wrocławski
Sieci komputerowe Wykład 7: Transport: protokół TCP Marcin Bieńkowski Instytut Informatyki Uniwersytet Wrocławski Sieci komputerowe (II UWr) Wykład 7 1 / 23 W poprzednim odcinku Niezawodny transport Algorytmy
Bardziej szczegółowoZESZYTY ETI ZESPOŁU SZKÓŁ W TARNOBRZEGU Nr 1 Seria: Teleinformatyka 2013
ZESZYTY ETI ZESPOŁU SZKÓŁ W TARNOBRZEGU Nr 1 Seria: Teleinformatyka 2013 Paweł Kowalik Zespół Szkół im. ks. S. Staszica w Tarnobrzegu KOMUNIKACJA SIECIOWA MIĘDZY URZĄDZENIAMI Z WYKORZYSTANIEM PROTKOŁU
Bardziej szczegółowoProgramowanie sieciowe
Programowanie sieciowe email: dawid@us.edu.pl Programowanie warstwy transportu. - Berkeley sockets. - koncepcja gniazda - bibliteka sockets (connect(),socket(),bind(),listen(),accept(),read(),write() )
Bardziej szczegółowoInstrukcja do laboratorium Systemów Operacyjnych. (semestr drugi)
Instrukcja do laboratorium Systemów Operacyjnych (semestr drugi) Ćwiczenie dziesiąte Temat: Gniazda BSD protokoły internetowe Opracowanie: mgr in ż. Arkadiusz Chrobot Wprowadzenie 1. Usługi sieciowe w
Bardziej szczegółowoSieci Komputerowe. Wykład 1: TCP/IP i adresowanie w sieci Internet
Sieci Komputerowe Wykład 1: TCP/IP i adresowanie w sieci Internet prof. nzw dr hab. inż. Adam Kisiel kisiel@if.pw.edu.pl Pokój 114 lub 117d 1 Kilka ważnych dat 1966: Projekt ARPANET finansowany przez DOD
Bardziej szczegółowoStos protokołów TCP/IP (ang. Transmission Control Protocol/Internet Protocol)
Stos protokołów TCP/IP (ang. Transmission Control Protocol/Internet Protocol) W latach 1973-78 Agencja DARPA i Stanford University opracowały dwa wzajemnie uzupełniające się protokoły: połączeniowy TCP
Bardziej szczegółowoTransport. część 2: protokół TCP. Sieci komputerowe. Wykład 6. Marcin Bieńkowski
Transport część 2: protokół TCP Sieci komputerowe Wykład 6 Marcin Bieńkowski Protokoły w Internecie warstwa aplikacji HTTP SMTP DNS NTP warstwa transportowa TCP UDP warstwa sieciowa IP warstwa łącza danych
Bardziej szczegółowoTIN Techniki Internetowe zima
TIN Techniki Internetowe zima 2016-2017 Grzegorz Blinowski Instytut Informatyki Politechniki Warszawskiej Plan wykładów 2 Intersieć, ISO/OSI, protokoły sieciowe, IP 3 Protokół IP i prot. transportowe:
Bardziej szczegółowoProgramowanie Programowanie z użyciem gniazd
Systemy IBM - iseries Programowanie Programowanie z użyciem gniazd Wersja 5 Wydanie 4 Systemy IBM - iseries Programowanie Programowanie z użyciem gniazd Wersja 5 Wydanie 4 Uwaga Przed korzystaniem z tych
Bardziej szczegółowoAplikacja Sieciowa. Najpierw tworzymy nowy projekt, tym razem pracować będziemy w konsoli, a zatem: File->New- >Project
Aplikacja Sieciowa Jedną z fundamentalnych właściwości wielu aplikacji jest możliwość operowania pomiędzy jednostkami (np. PC), które włączone są do sieci. W Windows operacja ta jest możliwa przy wykorzystaniu
Bardziej szczegółowoPolitechnika Łódzka. Instytut Systemów Inżynierii Elektrycznej
Politechnika Łódzka Instytut Systemów Inżynierii Elektrycznej Laboratorium komputerowych systemów pomiarowych Ćwiczenie 7 Wykorzystanie protokołu TCP do komunikacji w komputerowym systemie pomiarowym 1.
Bardziej szczegółowoSieci komputerowe. Zajęcia 3 c.d. Warstwa transportu, protokoły UDP, ICMP
Sieci komputerowe Zajęcia 3 c.d. Warstwa transportu, protokoły UDP, ICMP Zadania warstwy transportu Zapewnienie niezawodności Dostarczanie danych do odpowiedniej aplikacji w warstwie aplikacji (multipleksacja)
Bardziej szczegółowoObsługa plików. Systemy Operacyjne 2 laboratorium. Mateusz Hołenko. 25 września 2011
Obsługa plików Systemy Operacyjne 2 laboratorium Mateusz Hołenko 25 września 2011 Plan zajęć 1 Pliki w systemie Linux i-węzły deskryptory plików 2 Operacje na plikach otwieranie i zamykanie zapis i odczyt
Bardziej szczegółowo4. Komunikacja pomiędzy procesami przez łącza nienazwane i nazwane
Jędrzej Ułasiewicz Łącza nienazwane, nazwane, funkcja select 1 4. Komunikacja pomiędzy procesami przez łącza nienazwane i nazwane Łącza nienazwane (ang. Unnamed Pipes) i nazwane (ang. Named Pipes) - jedna
Bardziej szczegółowoSieci komputerowe. Wykład dla studentów Informatyki Stosowanej i Fizyki Komputerowej UJ 2007/2008. Michał Cieśla
Sieci komputerowe Wykład dla studentów Informatyki Stosowanej i Fizyki Komputerowej UJ 2007/2008 Michał Cieśla pok. 440a, email: ciesla@if.uj.edu.pl konsultacje: wtorki 10-12 http://users.uj.edu.pl/~ciesla/
Bardziej szczegółowoTransport. część 2: protokół TCP. Sieci komputerowe. Wykład 6. Marcin Bieńkowski
Transport część 2: protokół TCP Sieci komputerowe Wykład 6 Marcin Bieńkowski Protokoły w Internecie warstwa aplikacji HTTP warstwa transportowa SMTP TCP warstwa sieciowa warstwa łącza danych warstwa fizyczna
Bardziej szczegółowoLaboratorium Systemów Operacyjnych. Ćwiczenie 4. Operacje na plikach
Laboratorium Systemów Operacyjnych Ćwiczenie 4. Operacje na plikach Wykonanie operacji wymaga wskazania pliku, na którym operacja ma zostać wykonana. Plik w systemie LINUX identyfikowany jest przez nazwę,
Bardziej szczegółowo1. Model klient-serwer
1. 1.1. Model komunikacji w sieci łącze komunikacyjne klient serwer Tradycyjny podziała zadań: Klient strona żądająca dostępu do danej usługi lub zasobu Serwer strona, która świadczy usługę lub udostępnia
Bardziej szczegółowoProgramowanie Sieciowe 1
Programowanie Sieciowe 1 dr inż. Tomasz Jaworski tjaworski@iis.p.lodz.pl http://tjaworski.iis.p.lodz.pl/ Cel przedmiotu Zapoznanie z mechanizmem przesyłania danych przy pomocy sieci komputerowych nawiązywaniem
Bardziej szczegółowoModel OSI/ISO. Komputer B. Warstwy w modelu OSI aplikacji. aplikacji. prezentacji Komputer A. prezentacji. sesji. sesji. komunikacja wirtualna
1 Plan wykładu 1. Model ISO/OSI warstwy modelu OSI transmisja w modelu OSI 2. Model TCP/IP protokół UDP protokół TCP 3. Połączenie i rozłączenie w TCP 4. Programowanie z wykorzystaniem gniazd. 2 Model
Bardziej szczegółowoProgramowanie Programowanie z użyciem gniazd
System i Programowanie Programowanie z użyciem gniazd Wersja 6 wydanie 1 System i Programowanie Programowanie z użyciem gniazd Wersja 6 wydanie 1 Uwaga Przed skorzystaniem z tych informacji oraz z produktu,
Bardziej szczegółowoTryb bezpołączeniowy (datagramowy)
Tutaj trochę szerzej opisałam mechanizm gniazdek. 3 tematy wymienione poniŝej przeplatają się ze sobą więc wrzuciłam je do jednego worka i przedstawiłam w takim porządku, który wydawał mi się najbardziej
Bardziej szczegółowoPrzykład aplikacji UDP
#include #include #include /* atoi */ #include /* htons, ntohs... */ #include /* memset */ #include /* inet_ntoa */ #include
Bardziej szczegółowoUnicast jeden nadawca i jeden odbiorca Broadcast jeden nadawca przesyła do wszystkich Multicast jeden nadawca i wielu (podzbiór wszystkich) odbiorców
METODY WYMIANY INFORMACJI W SIECIACH PAKIETOWYCH Unicast jeden nadawca i jeden odbiorca Broadcast jeden nadawca przesyła do wszystkich Multicast jeden nadawca i wielu (podzbiór wszystkich) odbiorców TRANSMISJA
Bardziej szczegółowoSygnał mechanizm asynchronicznego powiadamiania procesów o zdarzeniach zwykle awaryjnych.
J. Ułasiewicz 1 1. 1 INFORMACJE WSTĘPNE Sygnał mechanizm asynchronicznego powiadamiania procesów o zdarzeniach zwykle awaryjnych. Metoda powiadamiania procesów za pomocą sygnałów wywodzi się z systemu
Bardziej szczegółowoPROTOKOŁY WARSTWY TRANSPORTOWEJ
PROTOKOŁY WARSTWY TRANSPORTOWEJ Na bazie protokołu internetowego (IP) zbudowane są dwa protokoły warstwy transportowej: UDP (User Datagram Protocol) - protokół bezpołączeniowy, zawodny; TCP (Transmission
Bardziej szczegółowoSygnały i ich obsługa
J. Ułasiewicz Programowanie aplikacji współbieżnych 1 i ich obsługa 1. i ich obsługa...2 1.1 Informacje wstępne...2 1.2 Standardy obsługi sygnałów...3 1.3 Wysyłanie sygnałów...6 1.4 Maskowanie sygnałów...10
Bardziej szczegółowoProgramowanie współbieżne i rozproszone
Programowanie współbieżne i rozproszone WYKŁAD 6 dr inż. Komunikowanie się procesów Z użyciem pamięci współdzielonej. wykorzystywane przede wszystkim w programowaniu wielowątkowym. Za pomocą przesyłania
Bardziej szczegółowoSockety TCP/IP - podstawy. Sieci Komputerowe II Wyk ład 2
Sockety TCP/IP - podstawy Sieci Komputerowe II Wyk ład 2 Plan Klient IPv4 Serwer IPv4 Pierwszy program Aplikacja w architekturze klient-serwer Realizacja protokołu echo Zasada działania: klient łączy się
Bardziej szczegółowoKolejki FIFO (łącza nazwane)
Kolejki FIFO (łącza nazwane) Systemy Operacyjne 2 laboratorium Mateusz Hołenko 6 listopada 2011 Plan zajęć 1 Łącza w systemie Linux kolejki FIFO vs. potoki specyfika łączy nazwanych schemat komunikacji
Bardziej szczegółowoTunelowanie, kapsułkowanie, XDR. 1. Transmisja tunelowa i kapsułkowanie serwery proxy. 2. Zewnętrzna reprezentacja danych XDR.
Tunelowanie, kapsułkowanie, XDR 1. Transmisja tunelowa i kapsułkowanie serwery proxy. 2. Zewnętrzna reprezentacja danych XDR. 1 Transmisja tunelowa i kapsułkowanie Sieci komputerowe rozwijały się stopniowo
Bardziej szczegółowoTCP - receive buffer (queue), send buffer (queue)
BSD sockets c.d. TCP - receive buffer (queue), send buffer (queue) Z każdym gniazdem sieciowym są skojarzone: Bufor do odbierania danych (ang. receive buffer) Przychodzące dane są umieszczane w buforze
Bardziej szczegółowoŁącza nienazwane(potoki)
8. Łącza nienazwane(potoki) Łącze (potok, ang. pipe) jest to urządzenie komunikacyjne pozwalające na przesyłanie informacji w jedną stronę. Jeden proces wysyła dane do łącza za pomocą funkcji write, zaś
Bardziej szczegółowoIBM i Wersja 7.2. Programowanie Programowanie z użyciem gniazd
IBM i Wersja 7.2 Programowanie Programowanie z użyciem gniazd IBM i Wersja 7.2 Programowanie Programowanie z użyciem gniazd Uwaga Przed skorzystaniem z tych informacji oraz z produktu, którego dotyczą,
Bardziej szczegółowoKomunikacja międzyprocesowa. Krzysztof Banaś Systemy rozproszone 1
Komunikacja międzyprocesowa Krzysztof Banaś Systemy rozproszone 1 Komunikacja międzyprocesowa Dla funkcjonowania systemów rozproszonych i równoległych z pamięcią rozproszoną konieczna jest sprawna komunikacja
Bardziej szczegółowoT: Konfiguracja interfejsu sieciowego. Odwzorowanie nazwy na adres.
T: Konfiguracja interfejsu sieciowego. Odwzorowanie nazwy na adres. Podczas wykonywania poniższych zadań w zeszycie w sprawozdaniu 1. podaj i wyjaśnij polecenia, które użyjesz, aby: wyświetlić informacje
Bardziej szczegółowoTworzenie aplikacji rozproszonej w Sun RPC
Tworzenie aplikacji rozproszonej w Sun RPC Budowa aplikacji realizowana jest w następujących krokach: Tworzenie interfejsu serwera w języku opisu interfejsu RPCGEN Tworzenie: namiastki serwera namiastki
Bardziej szczegółowoRPC. Zdalne wywoływanie procedur (ang. Remote Procedure Calls )
III RPC Zdalne wywoływanie procedur (ang. Remote Procedure Calls ) 1. Koncepcja Aplikacja wywołanie procedury parametry wyniki wykonanie procedury wynik komputer klienta komputer serwera Zaletą takiego
Bardziej szczegółowoW różnych systemach definicje mogą się różnić od powyższej. W linuxie sprobuj man 7 ip do wyswietlenia opisu.
Interfejs gniazd. Gniazda TCP. Gniazda (sockets) to abstrakcyjne mechanizmy umożliwiające wykonywanie systemowych funkcji wejścia wyjścia w odniesieniu do sieci. Gniazda zostały zaprojektowane w Berkeley
Bardziej szczegółowoSieci komputerowe. Wykład 5: Warstwa transportowa: TCP i UDP. Marcin Bieńkowski. Instytut Informatyki Uniwersytet Wrocławski
Sieci komputerowe Wykład 5: Warstwa transportowa: TCP i UDP Marcin Bieńkowski Instytut Informatyki Uniwersytet Wrocławski Sieci komputerowe (II UWr) Wykład 5 1 / 22 Warstwa transportowa Cechy charakterystyczne:
Bardziej szczegółowoDR INŻ. ROBERT WÓJCIK DR INŻ. JERZY DOMŻAŁ
DR INŻ. ROBERT WÓJCIK DR INŻ. JERZY DOMŻAŁ PROTOKOŁY TCP I UDP WSTĘP DO SIECI INTERNET Kraków, dn. 12 grudnia 2016 r. PLAN TCP: cechy protokołu schemat nagłówka znane numery portów UDP: cechy protokołu
Bardziej szczegółowoProgramownie współbieżne i rozproszone Jędrzej Ułasiewicz 1. Komunikacja. Model procesów komunikujących się poprzez pamięć dzieloną
Programownie współbieżne i rozproszone Jędrzej Ułasiewicz 1 Komunikacja 1 Podstawowe modele przetwarzania Obecnie stosuje się następujące modele przetwarzania: Model procesów i komunikatów Model procesów
Bardziej szczegółowoModel sieci OSI, protokoły sieciowe, adresy IP
Model sieci OSI, protokoły sieciowe, adresy IP Podstawę działania internetu stanowi zestaw protokołów komunikacyjnych TCP/IP. Wiele z używanych obecnie protokołów zostało opartych na czterowarstwowym modelu
Bardziej szczegółowoPliki. Funkcje tworzące pliki i operujące na nich opisane są w części 2 pomocy systemowej. Tworzenie i otwieranie plików:
Pliki W celu wykonania jakiejkolwiek operacji na istniejącym pliku, plik ten musi zostać otwarty, natomiast jeśli plik jeszcze nie istnieje, to musi zostać utworzony. Plik może zostać otwarty w trybie:
Bardziej szczegółowoJ. Ułasiewicz Łącza nienazwane, nazwane, select 1
J. Ułasiewicz Łącza nienazwane, nazwane, select 1 4. Komunikacja pomiędzy procesami przez łącza nienazwane i nazwane Łącza nienazwane (ang. Unnamed Pipes) i nazwane (ang. Unnamed Pipes) - jedna z historycznie
Bardziej szczegółowoZestaw ten opiera się na pakietach co oznacza, że dane podczas wysyłania są dzielone na niewielkie porcje. Wojciech Śleziak
Protokół TCP/IP Protokół TCP/IP (Transmission Control Protokol/Internet Protokol) to zestaw trzech protokołów: IP (Internet Protokol), TCP (Transmission Control Protokol), UDP (Universal Datagram Protokol).
Bardziej szczegółowoWarstwa sieciowa. Model OSI Model TCP/IP. Aplikacji. Aplikacji. Prezentacji. Sesji. Transportowa. Transportowa
Warstwa sieciowa Model OSI Model TCP/IP Aplikacji Prezentacji Aplikacji podjęcie decyzji o trasowaniu (rutingu) na podstawie znanej, lokalnej topologii sieci ; - podział danych na pakiety Sesji Transportowa
Bardziej szczegółowoSieci komputerowe Warstwa transportowa
Sieci komputerowe Warstwa transportowa 2012-05-24 Sieci komputerowe Warstwa transportowa dr inż. Maciej Piechowiak 1 Wprowadzenie umożliwia jednoczesną komunikację poprzez sieć wielu aplikacjom uruchomionym
Bardziej szczegółowoSieci komputerowe - Wstęp do intersieci, protokół IPv4
Piotr Kowalski KAiTI Internet a internet - Wstęp do intersieci, protokół IPv Plan wykładu Informacje ogólne 1. Ogólne informacje na temat sieci Internet i protokołu IP (ang. Internet Protocol) w wersji.
Bardziej szczegółowoPrzesyłania danych przez protokół TCP/IP
Przesyłania danych przez protokół TCP/IP PAKIETY Protokół TCP/IP transmituje dane przez sieć, dzieląc je na mniejsze porcje, zwane pakietami. Pakiety są często określane różnymi terminami, w zależności
Bardziej szczegółowoPliki w C/C++ Przykłady na podstawie materiałów dr T. Jeleniewskiego
Pliki w C/C++ Przykłady na podstawie materiałów dr T. Jeleniewskiego 1 /24 Pisanie pojedynczych znaków z klawiatury do pliku #include void main(void) { FILE *fptr; // wkaznik do pliku, tzw. uchwyt
Bardziej szczegółowoSerwer współbieżny połączeniowy
Serwery współbieżne 1. Serwery współbieżne serwery połączeniowe, usuwanie zakończonych procesów, serwery bezpołączeniowe, 2. Jednoprocesowe serwery współbieżne. koncepcja i implementacja. 1 Serwer współbieżny
Bardziej szczegółowoSieci komputerowe Wykład dla studentów Informatyki Stosowanej studia niestacjonarne
Sieci komputerowe Wykład dla studentów Informatyki Stosowanej studia niestacjonarne UJ 2007/2008 Michał Cieśla pok. 440a, email: ciesla@if.uj.edu.pl http://users.uj.edu.pl/~ciesla/ 1 2 Plan wykładu 1.
Bardziej szczegółowoAplikacja Sieciowa wątki po stronie klienta
Aplikacja Sieciowa wątki po stronie klienta Na ostatnich zajęciach zajmowaliśmy się komunikacją pomiędzy klientem a serwerem. Wynikiem naszej pracy był program klienta, który za pomocą serwera mógł się
Bardziej szczegółowoSystemy operacyjne i sieci komputerowe Szymon Wilk Adresowanie w sieciach Klasy adresów IP a) klasa A
i sieci komputerowe Szymon Wilk Adresowanie w sieciach 1 1. Klasy adresów IP a) klasa A sieć host 0 mało sieci (1 oktet), dużo hostów (3 oktety) pierwszy bit równy 0 zakres adresów dla komputerów 1.0.0.0-127.255.255.255
Bardziej szczegółowoFunkcje zawarte w bibliotece < io.h >
PLIKOWE OPERACJE WEJŚCIA - WYJŚCIA Język C/C++ nie ma wbudowanych żadnych instrukcji umożliwiających wykonywanie operacji wejścia-wyjścia! Służą do tego funkcje biblioteczne. Funkcje zawarte w bibliotece
Bardziej szczegółowoKolejki komunikatów POSIX
Jędrzej Ułasiewicz IIAiR Politechnika Wrocławska 1 Kolejki komunikatów POSIX 1 Wstęp Kolejka komunikatów Q posiada następujące własności: - Posiada określoną pojemność N komunikatów (długość bufora komunikatów).
Bardziej szczegółowoTryby komunikacji między procesami w standardzie Message Passing Interface. Piotr Stasiak Krzysztof Materla
Tryby komunikacji między procesami w standardzie Message Passing Interface Piotr Stasiak 171011 Krzysztof Materla 171065 Wstęp MPI to standard przesyłania wiadomości (komunikatów) pomiędzy procesami programów
Bardziej szczegółowoSystemy rozproszone. Krzysztof Banaś Obliczenia równoległe 1
Systemy rozproszone Krzysztof Banaś Obliczenia równoległe 1 Historia i pojęcia wstępne Przetwarzanie współbieżne realizacja wielu programów (procesów) w taki sposób, że ich trwanie od momentu rozpoczęcia
Bardziej szczegółowoIPC: Kolejki komunikatów
IPC: Kolejki komunikatów Systemy Operacyjne 2 laboratorium Mateusz Hołenko 7 listopada 2011 Plan zajęć 1 Mechanizmy IPC kolejki komunikatów pamięć współdzielona semafory 2 Kolejki komunikatów kolejka komunikat
Bardziej szczegółowoLaboratorium z systemów operacyjnych. System plików - funkcje systemowe. Anna Wojak
Laboratorium z systemów operacyjnych System plików - funkcje systemowe Anna Wojak 1 Zagadnienia do samodzielnego przygotowania: podstawowe polecenia linux, podstawy programowania w jezyku C, deskryptor
Bardziej szczegółowoAdresowanie grupowe. Bartłomiej Świercz. Katedra Mikroelektroniki i Technik Informatycznych. Łódź, 25 kwietnia 2006
Adresowanie grupowe Bartłomiej Świercz Katedra Mikroelektroniki i Technik Informatycznych Łódź, 25 kwietnia 2006 Wstęp Na potrzeby sieci komputerowych zdefiniowano rożne rodzaje adresowania: adresowanie
Bardziej szczegółowoZdalne wywołania procedur. Jarosław Kuchta Programowanie Współbieżne
Zdalne wywołania procedur Jarosław Kuchta Programowanie Współbieżne Podstawy RPC Remote Procedure Call Wywołanie procedur jednego procesu z innego procesu. Proces wywoływany serwer Proces wywołujący -
Bardziej szczegółowo