DSIK – Zajęcia 5 – UDP, aplikacje socket bezpołączeniowe

List

DSIK – Zajęcia 5 – UDP, aplikacje socket bezpołączeniowe

April 11, 2016 | Maciej Kalkowski | Classes, Computer Networks

Komunikacja bezpołączeniowa

UDP (z ang. User Datagram Protocol – protokół datagramów użytkownika) to bardzo lekki protokół umożliwiający przesyłanie komunikatów między klientem i serwerem, o następujących cecach:

brak utrzymania informacji o stanie połączenia,
brak potwierdzenia dotarcia komunikatu (w efekcie brak retransmisji w przypadku utraty komunikatu)
mały narzut komunikacyjny (wielkość nagłówka to 64 bity, podczas gdy w TCP to 160 bitów),
brak kontroli nad kolejnością docierania komunikatów (w szczególnych przypadkach jeden datagram może nawet zostać dostarczony dwa razy),
minimalne informacje przekazywane, 4 pola po 16 bitów:
- port źródłowy
- port docelowy (oba porty określają strony komunikacji),
- suma kontrolna
- długość datagramu UDP.

Podobnie jak w przypadku TCP porty o wartości poniżej 1024 są zarezerwowane dla znanych usług i wymagają uprawnień administratora w celu komunikacji.

Wykorzystywane funkcje:

sockfd = socket(int socket_family, int socket_type, int protocol); (dla komunikacji UDP należy podać odpowiednio AF_INET, SOCK_DGRAM, 0)
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen);
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);
ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);

struktura msghdr:

struct msghdr {
    void         *msg_name;       /* optional address */
    socklen_t     msg_namelen;    /* size of address */
    struct iovec *msg_iov;        /* scatter/gather array */
    size_t        msg_iovlen;     /* # elements in msg_iov */
    void         *msg_control;    /* ancillary data, see below */
    size_t        msg_controllen; /* ancillary data buffer len */
    int           msg_flags;      /* flags on received message */
};

struct msghdr {

void *msg_name; /* optional address */

socklen_t msg_namelen; /* size of address */

struct iovec *msg_iov; /* scatter/gather array */

size_t msg_iovlen; /* # elements in msg_iov */

void *msg_control; /* ancillary data, see below */

size_t msg_controllen; /* ancillary data buffer len */

int msg_flags; /* flags on received message */

};

struktura iovec:

struct iovec {                    /* Scatter/gather array items */
    void  *iov_base;              /* Starting address */
    size_t iov_len;               /* Number of bytes to transfer */
};

struct iovec { /* Scatter/gather array items */

void *iov_base; /* Starting address */

size_t iov_len; /* Number of bytes to transfer */

};

Funkcje sendto i recvfrom są prostsze i będziemy je wykorzystywać na zajęciach.

UDP server:

#include &lt;stdio.h&gt;
#include &lt;string.h&gt;
#include &lt;netinet/in.h&gt;
#include &lt;sys/types.h&gt;
#include &lt;sys/socket.h&gt;
#include &lt;arpa/inet.h&gt;
#include &lt;netdb.h&gt; 


char buf[512];

int main(int argc, char **argv)
{
    struct sockaddr_in myaddr, endpoint;
    int sdsocket, r;
    socklen_t addrlen;
    unsigned int port;
    
    printf("Na ktorym porcie mam sluchac? : ");
    scanf("%u", &amp;port);

    if ((sdsocket = socket(AF_INET, SOCK_DGRAM, 0)) &lt; 0) {
        printf("socket() nie powiodl sie\n");
        return 1;
    }
        
    myaddr.sin_family = AF_INET;
    myaddr.sin_port = htons(port);
    myaddr.sin_addr.s_addr = INADDR_ANY;

    if (
        bind(sdsocket,
             (struct sockaddr*) &amp;myaddr,
             sizeof(struct sockaddr_in)) &lt; 0) {
        printf("bind() nie powiodl sie\n");
        return 1;
    }

    addrlen = sizeof(struct sockaddr_in);
    while (1) { /* nieskonczona petla */
        memset(buf, 0, 512);
        r = recvfrom(sdsocket,
                     buf,
                     512,
                     0,
                     (struct sockaddr*) &amp;endpoint,
                     &amp;addrlen);
        printf("Wiadomosc od %s: %s\n",
               inet_ntoa(endpoint.sin_addr),
               buf);
    }    
    return 0;
}

#include <stdio.h>

#include <string.h>

#include <netinet/in.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <arpa/inet.h>

#include <netdb.h>

char buf[512];

int main(int argc, char **argv)

{

struct sockaddr_in myaddr, endpoint;

int sdsocket, r;

socklen_t addrlen;

unsigned int port;

printf("Na ktorym porcie mam sluchac? : ");

scanf("%u", &port);

if ((sdsocket = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {

printf("socket() nie powiodl sie\n");

return 1;

}

myaddr.sin_family = AF_INET;

myaddr.sin_port = htons(port);

myaddr.sin_addr.s_addr = INADDR_ANY;

if (

bind(sdsocket,

(struct sockaddr*) &myaddr,

sizeof(struct sockaddr_in)) < 0) {

printf("bind() nie powiodl sie\n");

return 1;

}

addrlen = sizeof(struct sockaddr_in);

while (1) { /* nieskonczona petla */

memset(buf, 0, 512);

r = recvfrom(sdsocket,

buf,

512,

(struct sockaddr*) &endpoint,

&addrlen);

printf("Wiadomosc od %s: %s\n",

inet_ntoa(endpoint.sin_addr),

buf);

}

return 0;

}

UDP client:

#include &lt;stdio.h&gt;
#include &lt;string.h&gt;
#include &lt;netinet/in.h&gt;
#include &lt;sys/types.h&gt;
#include &lt;sys/socket.h&gt;
#include &lt;arpa/inet.h&gt;
#include &lt;netdb.h&gt; 


char buf[512];

int main(int argc, char **argv)
{
    struct sockaddr_in adr;
    int gniazdo, r;
    unsigned int port;
    char abcd[512];    

    printf("Podaj adres IP odbiorcy: ");
    scanf("%s", abcd);
    printf("Podaj numer portu odbiorcy: ");
    scanf("%u", &amp;port);
    gniazdo = socket(AF_INET, SOCK_DGRAM, 0);
    adr.sin_family = AF_INET;
    adr.sin_port = htons(port);
    adr.sin_addr.s_addr = inet_addr(abcd);
    printf("Podaj wiadomosc: ");
    fflush(stdout); fgetc(stdin);
    fgets(buf, 512, stdin);
           
    r = sendto(gniazdo,
               buf,
               512,
               0,
               (struct sockaddr*) &amp;adr,
               sizeof(adr));
    if (r != 512) printf("sendto() nie powiodl sie\n");
    else printf("Wiadomosc wyslana.\n");
    close(gniazdo);
    return 0;
}

#include <stdio.h>

#include <string.h>

#include <netinet/in.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <arpa/inet.h>

#include <netdb.h>

char buf[512];

int main(int argc, char **argv)

{

struct sockaddr_in adr;

int gniazdo, r;

unsigned int port;

char abcd[512];

printf("Podaj adres IP odbiorcy: ");

scanf("%s", abcd);

printf("Podaj numer portu odbiorcy: ");

scanf("%u", &port);

gniazdo = socket(AF_INET, SOCK_DGRAM, 0);

adr.sin_family = AF_INET;

adr.sin_port = htons(port);

adr.sin_addr.s_addr = inet_addr(abcd);

printf("Podaj wiadomosc: ");

fflush(stdout); fgetc(stdin);

fgets(buf, 512, stdin);

r = sendto(gniazdo,

buf,

512,

(struct sockaddr*) &adr,

sizeof(adr));

if (r != 512) printf("sendto() nie powiodl sie\n");

else printf("Wiadomosc wyslana.\n");

close(gniazdo);

return 0;

}

Zadania:

W oparciu o kod z Przykładu 2 zaimplementować następujące przypadki:

Przesyłanie bloków 10000-bajtowych za pomocą protokołu UDP z pomiarem czasu. Program powinien działać wg schematu pomiar czasu, socket, 100 razy sendto i recvfrom, close, pomiar czasu, podanie czasu podzielonego przez 100.
Przesyłanie bloków 10000-bajtowych za pomocą protokołu TCP w jednej sesji z pomiarem czasu. Program powinien działać wg schematu pomiar czasu, socket, connect, 100 razy send i recv, close, pomiar czasu, podanie czasu podzielonego przez 100.

Przeimplementować należy zarówno stronę klienta, jak i stronę serwera.
Program proszę uruchamiać na dwóch komputerach w laboratoriach wydziału aby uzyskane wyniki faktycznie uwzględniały przesyłanie danych przez sieć.

Uwagi:

przykłady klienta i serwera UDP oraz zadanie wzięte ze strony Tomasza Tyrakowskiego http://www.staff.amu.edu.pl/~ttomek/sik/cwiczenia2.html),
opisy struktur i dokumentacje protokołu wzięte z manuala (podręcznika systemowego linux).

Posts

May 20th, 2017

Different kernel types

https://en.wikipedia.org/wiki/Kernel_%28operating_system%29#Kernel-wide_design_approaches https://en.wikipedia.org/wiki/Unikernel https://en.wikipedia.org/wiki/Exokernel https://en.wikipedia.org/wiki/Nemesis_%28operating_system%29 http://windowsitpro.com/windows-server/top-ten-what-you-need-know-about-microsoft-nano-server

April 21st, 2017

Maciej Kalkowski

Webpage and blog