t4

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


// Apufunktio osoitteen tulostamiseen
void print_address(const char *prefix, const struct addrinfo *res) {
        char outbuf[80];
        struct sockaddr_in *sin = (struct sockaddr_in *)res->ai_addr;
        struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)res->ai_addr;
        void *address;

        if (res->ai_family == AF_INET)
                address = &(sin->sin_addr);
        else if (res->ai_family == AF_INET6)
                address = &(sin6->sin6_addr);
        else {
                printf("Unknown address\n");
                return;
        }

        const char *ret = inet_ntop(res->ai_family, address,
                                    outbuf, sizeof(outbuf));
        printf("%s %s\n", prefix, ret);
}


int main(int argc , char *argv[]) {
    int sock, n;
    struct sockaddr_in server;
    char server_reply[2000];
    char *message1 = "594930\n";
    char *message2 = "4-names\n";
    char *address = "195.148.124.236";

    //Create socket
    if ((sock = socket(AF_INET , SOCK_STREAM , 0)) < 0) {
        printf("Could not create socket");
        perror("socket error");
        return 1;
    }

    puts("Socket created");



    // Alustetaan osoitetta esittävä tietorakenne nollilla.
    // Sen jälkeen kerrotaan että osoiteperhe on IPv4,
    // ja määritellään palvelimen portti johon tullaan ottamaan yhteyttä
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port   = htons(5000); /* daytime server = 13 */

    // Seuraava funktio muuntaa ASCII-muotoisen IP-osoitteen binääriseksi.
    // Se talletetaan servaddr - rakenteeseen.
    if (inet_pton(AF_INET, address, &server.sin_addr) <= 0) {
        fprintf(stderr, "inet_pton error for %s\n", address);
        return 1;
    }


    /*Toinen tapa
    server.sin_addr.s_addr = inet_addr("195.148.124.236");
    server.sin_family = AF_INET;
    server.sin_port = htons( 5000 );*/

    //Connect to remote server
    if (connect(sock , (struct sockaddr *)&server , sizeof(server)) < 0) {
        perror("connect failed. Error");
        return 1;
    }

    //Send student number
    if( send(sock , message1 , strlen(message1) , 0) < 0) {
        puts("Send failed");
        return 1;
    }

    //Send message
    if( send(sock , message2 , strlen(message2) , 0) < 0) {
         puts("Send failed");
            return 1;
    }

    //Receive a reply from the server
    if( (n = recv(sock , server_reply , 2000 , 0)) < 0) {
        puts("recv failed");
    }

    puts(server_reply);
    //char *str1 = "OK\n";
    //char *str2 = "FAIL\n";
    int sendFailed = 0;

    while ((strstr(server_reply, "OK") == NULL) && (strstr(server_reply, "FAIL") == NULL)) {

        //Variables for new address and port
        int ret;//, newPort;
        char newPort[20];
        char host[50];
        char conn[10];

        //Copy address and port
        ret = sscanf(server_reply, "%s %s %s", conn, host, newPort);
        printf("%d %s %s\n", ret, host, newPort);

        //New variables for socket
        int sock2;
        struct addrinfo hints, *res, *ressave;

        // Ensiksi kerrotaan hints-rakenteessa, että osoiteperhettä ei ole
        // rajoitettu, eli sekä IPv4 ja IPv6 - osoitteet kelpaavat.
        // Lisäksi sanomme, että olemme pelkästään kiinnostuneita TCP-yhteyksistä
        memset(&hints, 0, sizeof(struct addrinfo));
        hints.ai_family = AF_UNSPEC;
        hints.ai_socktype = SOCK_STREAM;

        puts(server_reply);

        // Tehdään nimikysely käyttäen ylläolevaa hints-rakennetta
        // Funktio varaa vastaukselle tilan itse, osoitin palautuu res-muuttujaan
        if ( (n = getaddrinfo(host, newPort, &hints, &res)) != 0) {
                fprintf(stderr, "tcp_connect error for %s, %s: %s\n", host, newPort, gai_strerror(n));
                exit(1);
        }

        ressave = res; // so that we can release the memory afterwards

        // res-rakenne osoittaa linkitettyyn listaan. Käydään läpi linkitettyä
        // listaa yksi kerrallaan ja yritetään yhdistää saatuun osoitteeseen.
        // res-rakenne sisältää kaikki parameterit mitä tarvitsemme socket-
        // ja connect - kutsuissa.
        do {
              sock2 = socket(res->ai_family, res->ai_socktype,
                                res->ai_protocol);
                if (sock2 < 0)
                        continue;       /* ignore this one */

                print_address("Trying to connect", res);

                // Mikäli yhteys onnistuu, silmukka keskeytetään välittömästi,
                // koska meillä on toimiva yhteys, eikä loppuja osoitteita
                // tarvitse kokeilla
                if (connect(sock2, res->ai_addr, res->ai_addrlen) == 0)
                      break;          /* success */

                printf("connect failed\n");

                close(sock2);  /* ignore this one */
        } while ( (res = res->ai_next) != NULL);



        // Päästiinkö linkitetyn listan loppuun, mutta yhteys ei onnistunut?
        // ==> virhe
        if (res == NULL) {      /* errno set from final connect() */
            fprintf(stderr, "tcp_connect error for %s\n", host);
            sock2 = -1;
            sendFailed = 1;

            //Send FAIL to first sock
            char *message4 = "FAIL\n";
            if( send(sock , message4 , strlen(message4) , 0) < 0) {
                puts("Send failed");
            }

        } else {
                print_address("We are using address", res);
        }

        // Järjestelmä on varannut muistin linkitetylle listalle, se pitää vapauttaa
        freeaddrinfo(ressave);

        //Stuff to send to first socket
        char message3[80];
        //sprintf(message3, "ADDR 195.148.125.210 %s %s\n", newPort, message1);

        char hostname[128];
        char myIP[100];

        if (!sendFailed) {
            gethostname(hostname, sizeof hostname);
            printf("My hostname: %s\n", hostname);

            struct hostent *he;
            struct sockaddr_in sa;
            he = gethostbyname(hostname);
            sa.sin_family = he->h_addrtype;
            strcpy(myIP, inet_ntoa(sa.sin_addr));
            memcpy(&sa.sin_addr, he->h_addr, sizeof(sa.sin_addr));

            printf("\n\n%s\n\n",inet_ntoa(sa.sin_addr));

            struct sockaddr_in sin;
            socklen_t len = sizeof(sin);
            if (getsockname(sock2, (struct sockaddr *)&sin, &len) == -1) {
                perror("getsockname");
            }
            int local_port = ntohs(sin.sin_port);

            printf("%d\n",local_port);

            //sprintf(message3, "ADDR %s %s %s", inet_ntoa(sa.sin_addr), newPort, message1);
            sprintf(message3, "ADDR %s %d %s\n", inet_ntoa(sa.sin_addr), local_port, message1);

            puts(message3);

            //Send message
            if( send(sock2, message3 , strlen(message3) , 0) < 0) {
                 puts("Send failed");
                    return 1;
            }


        }

        //Receive a reply from the first server
        if( (n = recv(sock , server_reply , 2000 , 0)) < 0) {
                puts("recv failed");
        }

        puts(server_reply);
        puts("Print reply again");
        puts(server_reply);

    }


    close(sock);
    return 0;
}