bakalarska_praca/kniznica/komunikacia.c

//////////////////////////////////////////////////
// Bakalarska praca                             //
// Meno studenta: Tomas Lukac                   //
// Veduci BP: prof. Ing. Milos Drutarovsky CSc. //
// Skola: KEMT FEI TUKE                         //
// Datum poslednej upravy: 9.3.2020             //
//////////////////////////////////////////////////

#include "komunikacia.h"
#include "kryptografia.h"

int poslat_subor(WOLFSSL* ssl, WOLFSSL_CTX* ctx, char* cesta)
{
  wolfSSL_write(ssl, cesta, 64);
  
  FILE* subor = fopen(cesta, "r");
  if(subor == NULL)
  {
    fprintf(stderr, "Nebolo mozne najst pozadovany subor.\n");
    ukoncit_spojenie(ssl, ctx);
    return -1;
  }
  else
  {
    printf("Posielam subor.\n");

    //nastavi ukazovatel na koniec suboru
    //a zisti velkost suboru
    fseek(subor, 0, SEEK_END);
    long velkost = ftell(subor);
    char velkost_suboru[32];
    sprintf(velkost_suboru, "%ld", velkost);
    printf("Velkost suboru: %s bajtov\n", velkost_suboru);
    wolfSSL_write(ssl, velkost_suboru, 32);
    
    //nastavi ukazovatel na zaciatok suboru
    //a nacita data zo suboru do pola
    char* pole = malloc(velkost);
    char* pole_uk = pole;
    fseek(subor, 0, SEEK_SET);
    fread(pole, 1, velkost, subor);
    fclose(subor);

    //posielanie jednotlivych bajtov
    for(int i = 0; i < velkost + 1; ++i)
    {
      wolfSSL_write(ssl, pole_uk, velkost);
      pole_uk += 1;
    }
    printf("Subor bol uspesne odoslany.\n");
    return 0;
  }
}

int prijat_subor(WOLFSSL* ssl, WOLFSSL_CTX* ctx)
{
  char* cesta = calloc(100, sizeof(char));
  wolfSSL_read(ssl, cesta, 64);
  printf("Prebieha prijimanie suboru %s\n", cesta);

  //ziskanie informacie od klienta o velkosti odoslaneho suboru
  char velkost_suboru[32];
  wolfSSL_read(ssl, velkost_suboru, 32);
  long velkost = atol(velkost_suboru);
  if(velkost < 1)
  {
    printf("Nastala chyba pri prijati suboru\n");
    return -1;
  }
  else
  {
    printf("Velkost suboru: %s bajtov\n", velkost_suboru);
  }
  
  //prijem jednotlivych bajtov
  char* pole = malloc(velkost);
  char* pole_uk = pole;
  for(int i = 0; i < velkost + 1; ++i)
  {
    wolfSSL_read(ssl, pole_uk, velkost);
    pole_uk += 1;
  }
  printf("Subor bol uspesne prijaty.\n");

  //zapis nacitanych dat do suboru
  FILE* subor = fopen(cesta, "w");
  fwrite(pole, 1, velkost, subor);
  fclose(subor);
  return 0;
}

int pripojit_na_server(char *ip_adresa, int cislo_portu, int pocet_sekund)
{
  struct timeval casovy_interval; 
  int uspech;
  int cislo_soketu;
  struct hostent* hostitel;
  struct sockaddr_in adresa;
  fd_set sada_soketov;
  socklen_t velkost_soketu;
  int optval;
  
  if((hostitel = gethostbyname(ip_adresa)) == NULL)
  {
    printf("Nastala chyba pri spracovani nazvu hostitela.\n");
    return 0;
  }
  printf("Vytvaranie soketu...\n");
  cislo_soketu = socket(AF_INET, SOCK_STREAM, 0);
  memset(&adresa, 0, sizeof(adresa));
  adresa.sin_family = AF_INET; //IPv4
  adresa.sin_port = htons(cislo_portu);
  adresa.sin_addr.s_addr = *(long*)(hostitel->h_addr);
  
  //pokus o pripojenie s casovym intervalom
  uspech = connect(cislo_soketu, (struct sockaddr*)&adresa, sizeof(adresa));
  if(uspech < 0)
  {
    if(errno == EINPROGRESS)
    {
      fprintf(stderr, "Nebolo mozne okamzite vytvorit spojenie\n");
      do
      {
        casovy_interval.tv_sec = pocet_sekund;
        casovy_interval.tv_usec = 0;
        FD_ZERO(&sada_soketov);
        FD_SET(cislo_soketu, &sada_soketov);
        uspech = select(cislo_soketu + 1, NULL, &sada_soketov, NULL, &casovy_interval);
        if (uspech < 0 && errno != EINTR) 
        { 
          fprintf(stderr, "Nastala chyba pri pokuse o vytvorenie spojenia\nCislo chyby: %d\nPopis: %s\n", errno, strerror(errno));
          ukoncit_soket(cislo_soketu);
          exit(0);
        }
        //bol zvoleny soket
        else if(uspech > 0)
        {
          velkost_soketu = sizeof(int);
          if (getsockopt(cislo_soketu, SOL_SOCKET, SO_ERROR, (void*)(&optval), &velkost_soketu) < 0) 
          { 
            fprintf(stderr, "Nastala chyba v nastaveni soketu\nCislo chyby: %d\nPopis: %s\n", errno, strerror(errno));
            ukoncit_soket(cislo_soketu);
            exit(0); 
          }
          if(optval) 
          { 
            fprintf(stderr, "Nastala chyba v spojeni\nCislo chyby: %d\nPopis: %s\n", optval, strerror(optval)); 
            ukoncit_soket(cislo_soketu);
            exit(0); 
          } 
          break;
        }
        else
        {
          fprintf(stderr, "Casovy interval vyprsal\n");
          ukoncit_soket(cislo_soketu);
          exit(0);
        }
      } while(1);
    }
    else
    {
      fprintf(stderr, "Spojenie zlyhalo.\nCislo chyby: %d\nPopis: %s\n", errno, strerror(errno));
      ukoncit_soket(cislo_soketu); 
      exit(0);
    }
  }
  return cislo_soketu;
}

int cakat_na_komunikaciu(int cislo_portu)
{
  int cislo_soketu;
  struct sockaddr_in adresa;
  
  printf("Vytvaranie socketu...\n");
  cislo_soketu = socket(PF_INET, SOCK_STREAM, 0);
  memset(&adresa, 0, sizeof(adresa));
  adresa.sin_family = AF_INET; //IPv4
  adresa.sin_port = htons(cislo_portu);
  adresa.sin_addr.s_addr = INADDR_ANY;
  
  if(bind(cislo_soketu, (struct sockaddr*)&adresa, sizeof(adresa)) != 0)
  {
    fprintf(stderr, "Nebolo mozne priradit soket ku danemu portu.\n");
    return 0;
  }
   
  if(listen(cislo_soketu, 10) != 0)
  {
    fprintf(stderr, "Na danom porte nie je mozne cakat na komunikaciu.\n");
    return 0;
  }
  else
  {
    printf("Server caka na komunikaciu na porte %d.\n", cislo_portu);
  }
  return cislo_soketu;
}