Labo 5: applications réseaux socket

///...
socket      (PF_INET, SOCK_STREAM, IPPROTO_IP)      = 3
setsockopt  (3, SOL_SOCKET, SO_REUSEADDR, [1], 4)   = 0
bind        (3, {sa_family=AF_INET, sin_port=htons(12345), sin_addr=inet_addr("0.0.0.0")}, 16) = 0
listen      (3, 1)                                  = 0
accept      (3, 

int socket(int domain, int type, int protocol);

int bind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen);

int listen(int s, int backlog);

int accept(int sock, struct sockaddr *adresse, socklen_t *longueur);

accept(3, Process 7127 attached
 <unfinished ...>
[pid  7127] close(3)                    = 0
[pid  7127] fstat(1, {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 1), ...}) = 0
[pid  7127] mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fe86d900000
[pid  7127] write(1, "7127: new connection from client"..., 547127: new connection from client 127.0.0.1 port 47530
) = 54
[pid  7127] fcntl(4, F_GETFL)           = 0x2 (flags O_RDWR)
[pid  7127] brk(0)                      = 0x245a000
[pid  7127] brk(0x247b000)              = 0x247b000
[pid  7127] fstat(4, {st_mode=S_IFSOCK|0777, st_size=0, ...}) = 0
[pid  7127] mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fe86d8ff000
[pid  7127] lseek(4, 0, SEEK_CUR)       = -1 ESPIPE (Illegal seek)
[pid  7127] read(4, 

accept(3, Process 7127 attached

socket(PF_INET, SOCK_STREAM, IPPROTO_TCP) = 3

connect(3, {sa_family=AF_INET, sin_port=htons(12345), sin_addr=inet_addr("127.0.0.1")}, 16) = 0

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>

static FILE *tcp_connect(const char *hostname, const char *port);

int main(int argc, char **argv)
{
    int result = EXIT_FAILURE;

    if (argc == 3)
    {
        FILE *f;

        if ((f = tcp_connect(argv[1], argv[2])))
        {
        }
        /* else: failure */
    }
    else
    {
        fprintf(stderr, "%s remote-host port\n", argv[0]);
        fprintf(stderr, "%s: bad args.\n", argv[0]);
    }
    return result;
}

static FILE *tcp_connect(const char *hostname, const char *port)
{
    FILE *f = NULL;

    int s; 
    struct addrinfo hints; 
    struct addrinfo *result, *rp;

    hints.ai_family = AF_UNSPEC; /* IPv4 or v6 */ 
    hints.ai_socktype = SOCK_STREAM; /* TCP */ 
    hints.ai_flags = 0; 
    hints.ai_protocol = 0; /* any protocol */

    if ((s = getaddrinfo(hostname, port, &hints, &result))) 
    { 
        fprintf(stderr, "getaddrinfo(): failed: %s.\n", gai_strerror(s)); 
    } 
    else 
    { 
        for (rp = result; rp != NULL; rp = rp->ai_next) 
        {
            // AFFICHER UNE ADR 
            char ipname[INET_ADDRSTRLEN]; 
            char servicename[6]; /* "65535\0" */
            if (!getnameinfo(rp->ai_addr, 
                             rp->ai_addrlen, 
                             ipname, 
                             sizeof(ipname), 
                             servicename, 
                             sizeof(servicename), 
                             NI_NUMERICHOST|NI_NUMERICSERV)) 
            { 
                printf("Trying connection to host %s:%s ...\n", 
                        ipname, 
                        servicename); 
            
                /* CREATION DE SOCKET */ 
                if ((s = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol)) == -1) 
                { 
                    perror("socket() failed: "); 
                }
                /* connexion */ 
                if (connect(s, rp->ai_addr, rp->ai_addrlen) != -1) 
                {
                    // ...
                } 
                else 
                { 
                    perror("connect(): "); 
                }
            }
        }
        freeaddrinfo(result);
    }
    return f;
}

socket(PF_LOCAL, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0) = 3

connect(3, {sa_family=AF_LOCAL, sun_path="/var/run/nscd/socket"}, 110) = -1 ENOENT (No such file or directory)

socket(PF_LOCAL, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0) = 3

connect(3, {sa_family=AF_LOCAL, sun_path="/var/run/nscd/socket"}, 110) = -1 ENOENT (No such file or directory)

socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE) = 3

socket(PF_INET, SOCK_DGRAM, IPPROTO_IP) = 3

connect(3, {sa_family=AF_INET, sin_port=htons(7000), sin_addr=inet_addr("127.0.0.1")}, 16) = 0

socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP) = 3

connect(3, { sa_family=AF_INET6,
             sin6_port=htons(7000),
             inet_pton(AF_INET6, "::1", &sin6_addr),
             sin6_flowinfo=0,
             sin6_scope_id=0 
          }, 
          28
        ) 
= 0

Trying connection to host ::1:7000 ...

socket(PF_INET6, SOCK_STREAM, IPPROTO_TCP) = 3

connect(
        3, { sa_family=AF_INET6, 
             sin6_port=htons(7000), 
             inet_pton(AF_INET6, "::1", &sin6_addr),
             sin6_flowinfo=0, sin6_scope_id=0
            }, 28
        ) 
= -1 ECONNREFUSED (Connection refused)


connect(): : Connection refused
Trying connection to host 127.0.0.1:7000 ...
socket(PF_INET, SOCK_STREAM, IPPROTO_TCP) = 4
connect(4, {sa_family=AF_INET, sin_port=htons(7000), sin_addr=inet_addr("127.0.0.1")}, 16) = 0
+++ exited with 1 +++

__libc_start_main(0x4007a6, 3, 0x7ffe79c13c18, 0x4009b0 <unfinished ...>

getaddrinfo("localhost", "7000", 0x7ffe79c13ab0, 0x7ffe79c13aa8)            = 0
getnameinfo(0x16271e0, 28, "", 16, "Xg\356w\355\177", 6, 3)                 = 0

printf("Trying connection to host %s:%s "..., "::1", 
       "7000"Trying connection to host ::1:7000 ... )                       = 39 
socket(10, 1, 6)                                                            = 3
connect(3, 0x16271e0, 28, 0x16271e0)                                        = -1
perror("connect(): "connect(): : Connection refused)
                                                                            = <void>
getnameinfo(0x1627190, 16, "::1", 16, "7000", 6, 3)                         = 0
printf("Trying connection to host %s:%s "..., "127.0.0.1", 
       "7000"Trying connection to host 127.0.0.1:7000 ...)
                                                                            = 45
socket(2, 1, 6)                                                             = 4
connect(4, 0x1627190, 16, 0x1627190)                                        = -1
perror("connect(): "connect(): : Connection refused)
                                                                            = <void>
freeaddrinfo(0x16271b0)                                                     = <void>
+++ exited (status 1) +++

// ...
// printf("Trying connection to host %s:%s ...\n", 
//         ipname, 
//         servicename); 

    // affichage brut de la valeur du champ sin_port
   if (rp->ai_family == AF_INET)
   {
       printf("HACK: raw port number: %d\n",
               ((struct sockaddr_in * ) rp->ai_addr)   ->sin_port);
   }                 // cast

// CREATION DE SOCKET 
// ...

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>

static FILE *tcp_connect(const char *hostname, const char *port);

int main(int argc, char **argv)
{
    int result = EXIT_FAILURE;

    if (argc == 3)
    {
        FILE *f;

        if ((f = tcp_connect(argv[1], argv[2])))
        {
            // creation d'un buffer affin de stocker la premiere ligne
            char buff[1024];
            if (fgets(buff, sizeof(buff), f))
            { 
                puts(buff);
            }
        }
        // else: fail
    }
    else
    {
        fprintf(stderr, "%s remote-host port\n", argv[0]);
        fprintf(stderr, "%s: bad args.\n", argv[0]);
    }
    return result;
}

static FILE *tcp_connect(const char *hostname, const char *port)
{
    FILE *f = NULL;

    int s; 
    struct addrinfo hints; 
    struct addrinfo *result, *rp;

    hints.ai_family = AF_UNSPEC; // IPv4 or v6  
    hints.ai_socktype = SOCK_STREAM; // TCP  
    hints.ai_flags = 0; 
    hints.ai_protocol = 0; // any protocol 

    if ((s = getaddrinfo(hostname, port, &hints, &result))) 
    { 
        fprintf(stderr, "getaddrinfo(): failed: %s.\n", gai_strerror(s)); 
    } 
    else 
    { 
        for (rp = result; rp != NULL; rp = rp->ai_next) 
        {
            // AFFICHER UNE ADR 
            char ipname[INET_ADDRSTRLEN]; 
            char servicename[6]; // "65535\0" 

            if (!getnameinfo(rp->ai_addr, rp->ai_addrlen, 
                             ipname, sizeof(ipname), 
                             servicename, sizeof(servicename), 
                             NI_NUMERICHOST|NI_NUMERICSERV)) 
            { 
                printf("Trying connection to host %s:%s ...\n", 
                        ipname, 
                        servicename); 

                //     // affichage brut de la valeur du champ sin_port
                // if (rp->ai_family == AF_INET)
                // {
                //     printf("HACK: raw port number: %d\n",
                //           ((struct sockaddr_in * ) rp->ai_addr)->sin_port);
                // }                 // cast
            
                // CREATION DE SOCKET  
                if ((s = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol)) == -1) 
                { 
                    perror("socket() failed: "); 
                }

                // CONNEXION 
                else
                { 
                    if (connect(s, rp->ai_addr, rp->ai_addrlen) != -1) 
                    {
                        // conversion de socket en un FILE *
                        // fdopen() permet d'utiliser un socket comme un fichier
                        if ((f = fdopen(s, "r+"))) 
                        { // utilisation de fonctions classiques maintenant possible
                            break; // !! Si on return maintenant, la memoire n'est pas liberee!
                        }
                    } 
                    else 
                    { 
                        perror("connect(): "); 
                    }
                    close(s); // new -> delete | open -> close
                }
            }
        }
        freeaddrinfo(result);
    }
    return f;
}

#include<stdio.h>
#include<string.h>
#include<sys/socket.h>
#include<netdb.h> // hostent
#include<arpa/inet.h> // inet_addr
#include<unistd.h>

bool resolveDomain(char *ip);

int main(int argc, char **argv)
{
    // test arguments
    if (argc != 3)
    {
        fprintf(stderr, "\n%s bad args\n", argv[0]);
        return 1;
    }

    // variables
    int   _socket;
    char* _message;
    char  _buffer[4096];

    struct sockaddr_in _server;

    // s'assure qu'argv[1] est une IP notation point.
    resolveDomain(argv[1]);

    // creation du socket
    _socket = socket(AF_INET, SOCK_STREAM, 0); // ipv4, TCP, 0 (=IPPROTO_IP)
    if (_socket == -1)
    {
        puts("Could not create socket");
    }   

    // initialisation des membres de l'objet _server
    _server.sin_addr.s_addr = inet_addr(argv[1]); // ip
    _server.sin_family = AF_INET;                 // ipv4
    _server.sin_port = htons(80);                 // port (client HTTP = port 80)
    
    // connexion au serveur
    if (connect(_socket, (struct sockaddr *)&_server, sizeof(_server)) < 0)
    {
        puts("connection error\n");
        return 1;
    }

    puts("\nconnected\n");

    // envoie requete HTTP
    _message = "GET / HTTP/1.1\r\n\r\n";
    if (send(_socket, _message, strlen(_message), 0) < 0)
    {
        puts("Send failed\n");
        return 1;
    }

    // reponse du serveur
    if (recv(_socket, _buffer, 4096, 0) < 0)
    {
        puts("recv failed");
    }

    puts("Reply received\n");
    puts(_buffer);

    close(_socket);

    return 0;
}

bool resolveDomain(char *ip)
{
    char *_hostname = ip;
    struct hostent *_he;
    struct in_addr **_addr_list;

    if ((_he = gethostbyname(_hostname)) == NULL)
    {
        puts("gethostbyname error");
        return 1;
    }

    _addr_list = (struct in_addr ** )_he->h_addr_list;

    strcpy(ip, inet_ntoa(*_addr_list[0]));
    return 0;
}

#include<stdio.h>
#include <stdlib.h>
#include<string.h>
#include<sys/socket.h>
#include<netdb.h>    
#include<arpa/inet.h>
#include<unistd.h>

int main(int argc, char **argv)
{
   // variables
    int    _socket, _newSock, c;
    struct sockaddr_in _server, _client;
    char*  _message;

    // creation de socket
    _socket = socket(AF_INET, SOCK_STREAM, 0);
    if (_socket == -1)
    {
        printf("\nCould not create socket\n");
    }

    // initialisation des membres de l'objet _server
    _server.sin_family      = AF_INET;
    _server.sin_addr.s_addr = INADDR_ANY;
    _server.sin_port        = htons(atoi(argv[1])); // conversion (char->int)->NetworkShort

    // bind
    if (bind(_socket, (struct sockaddr * )&_server, sizeof(_server)) < 0)
    {
        puts("\nbind failded\n");
    }
    puts("\nbind done\n");

    // ecoute
    listen(_socket, 3);

    // Accepte les connexions
    puts("Waiting for incoming connections...\n");
    c = sizeof(struct sockaddr_in);

    while ( (_newSock = accept(_socket, (struct sockaddr * )&_client, (socklen_t * )&c)) )
    {
        // affiche les infos du _client
        printf("Connection from %s:%d accepted\n",inet_ntoa(_client.sin_addr), ntohs(_client.sin_port));

        // repond au client
        _message = "Hey client! \n.";
        write(_newSock, _message, strlen(_message));
    }

    if (_newSock < 0)
    {
        puts("accept failed\n");
    }
    return 0;
}

#include<stdio.h>
#include<stdlib.h>
#include<string.h>    // strlen
#include<sys/socket.h>
#include<arpa/inet.h> // inet_addr
#include<unistd.h>    // write
#include<pthread.h>   // threading

void* connection_handler(void *);

int main(int argc, char **argv)
{
   // variables
    int    _socket, _newSock, c;
    int *  _newSockPtr;
    struct sockaddr_in _server, _client;
    char*  _message;

    // creation de socket
    _socket = socket(AF_INET, SOCK_STREAM, 0);
    if (_socket == -1)
    {
        printf("\nCould not create socket\n");
    }

    // initialisation des membres de l'objet _server
    _server.sin_family      = AF_INET;
    _server.sin_addr.s_addr = INADDR_ANY;
    _server.sin_port        = htons(atoi(argv[1])); // conversion (char->int)->NetworkShort

    // bind
    if (bind(_socket, (struct sockaddr * )&_server, sizeof(_server)) < 0)
    {
        puts("\nbind failded\n");
    }
    puts("\nbind done\n");

    // ecoute
    listen(_socket, 3);

    // Accepte les connexions
    puts("Waiting for incoming connections...\n");
    c = sizeof(struct sockaddr_in);

    while ( (_newSock = accept(_socket, (struct sockaddr * )&_client, (socklen_t * )&c)) )
    {
        // affiche les infos du _client
        printf("Connection from %s:%d accepted\n",inet_ntoa(_client.sin_addr), ntohs(_client.sin_port));

        // repond au client
        _message = "Hey client! You will be assigned to a handler... \n.";
        write(_newSock, _message, strlen(_message));

        // creation d'un nouveau thread
        pthread_t sniffer_thread;
        _newSockPtr = (int *)malloc(sizeof(int));
        *_newSockPtr = _newSock;

        if (pthread_create( &sniffer_thread, NULL, connection_handler, (void * ) _newSockPtr) < 0)
        {
            puts("could not create thread\n");
            return 1;
        }

        perror("Handler assigned\n");
    }

    if (_newSock < 0)
    {
        puts("accept failed\n");
    }

    return 0;
}

void* connection_handler(void *socket_desc)
{
    // prend la description du socket
    int sock = *(int *)socket_desc;
    int read_size;
    char *message, client_message[2000];

    // envoie quelques messages au client
    message = "Greetings! I'm your connection handler\n";
    write(sock, message, strlen(message));

    message = "Now type somthing and I will repeat it.";
    write(sock, message, strlen(message));

    // reception de message
    while ((read_size = recv(sock, client_message, 2000, 0)) > 0)
    {
        // renvoie le message au client
        write(sock, client_message, strlen(client_message));
    }

    if (read_size == 0)
    {
        puts("Client disconnected");
        fflush(stdout);
    }
    else if (read_size == -1)
    {
        perror("recv failed");
    }

    // libere la memoire
    free(socket_desc);

    return 0;
}