Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Username: Password: oppure
Elenco Telefonico Remoto - Client.c

Client.c

Caricato da:
Scarica il programma completo

  1. /* Client.c */
  2.  
  3. #include "macro.h"
  4. #include "funzioniClient.h"
  5. #include "Client.h"
  6.  
  7. void stampaMenu(){
  8.  
  9.                 /* Stampo il menù principale del client (in formato colorato) */
  10.  
  11.                 while(printf("\033[01;34m---------------------------------\n") == -1){
  12.                         if(errno != EINTR){
  13.                                 printf("\nErrore fprintf\n");
  14.                                 chiusuraClient();
  15.                         }
  16.                 }fflush(stdout);
  17.                 while(printf("-----------\033[00;34mMENU CLIENT\033[01;34m-----------\n") == -1){
  18.                         if(errno != EINTR){
  19.                                 printf("\nErrore fprintf\n");
  20.                                 chiusuraClient();
  21.                         }
  22.                 }fflush(stdout);
  23.                 while(printf("---------------------------------\033[00m\n\n") == -1){
  24.                         if(errno != EINTR){
  25.                                 printf("\nErrore fprintf\n");
  26.                                 chiusuraClient();
  27.                         }
  28.                 }fflush(stdout);
  29.                 while(printf("\033[01;33m 1. Trova numero di telefono\033[00m\n") == -1){
  30.                         if(errno != EINTR){
  31.                                 printf("\nErrore fprintf\n");
  32.                                 chiusuraClient();
  33.                         }
  34.                 }fflush(stdout);
  35.                 while(printf("\033[00;33m 2. Aggiungi numero di telefono\033[00m\n") == -1){
  36.                         if(errno != EINTR){
  37.                                 printf("\nErrore fprintf\n");
  38.                                 chiusuraClient();
  39.                         }
  40.                 }fflush(stdout);
  41.                 while(printf("\n") == -1){
  42.                         if(errno != EINTR){
  43.                                 printf("\nErrore fprintf\n");
  44.                                 chiusuraClient();
  45.                         }
  46.                 }fflush(stdout);
  47.                 while(printf(" 3. ESCI\n") == -1){
  48.                         if(errno != EINTR){
  49.                                 printf("\nErrore fprintf\n");
  50.                                 chiusuraClient();
  51.                         }
  52.                 }fflush(stdout);
  53.                 while(printf("\n\033[01;34m---------------------------------\n") == -1){
  54.                         if(errno != EINTR){
  55.                                 printf("\nErrore fprintf\n");
  56.                                 chiusuraClient();
  57.                         }
  58.                 }fflush(stdout);
  59.                 while(printf("---------------------------------") == -1){
  60.                         if(errno != EINTR){
  61.                                 printf("\nErrore fprintf\n");
  62.                                 chiusuraClient();
  63.                         }
  64.                 }fflush(stdout);
  65.                 while(printf("\n---------------------------------\033[00m\n") == -1){
  66.                         if(errno != EINTR){
  67.                                 printf("\nErrore fprintf\n");
  68.                                 chiusuraClient();
  69.                         }
  70.                 }fflush(stdout);
  71.  
  72. }
  73.  
  74. int menu(){
  75.  
  76.         int modalita;
  77.         int testscanf;
  78.        
  79.         /* Stampo il menù principale del client */
  80.         stampaMenu();
  81.  
  82.         printf("\033[01;32mSelezionare l'opzione...\033[00m\n");fflush(stdout);
  83.        
  84.         /* Seleziono l'opzione desiderata scartando quelle "illegali" */
  85.         do{    
  86.                 testscanf = scanf("%d", &modalita);
  87.                 while(-1 == testscanf){
  88.                         if(errno != EINTR){
  89.                                 printf("\nErrore scanf\n");
  90.                                 chiusuraClient();
  91.                         }
  92.                         else{
  93.                                 testscanf = scanf("%d", &modalita);
  94.                         }
  95.                 }
  96.                 if(testscanf == 0 || modalita>3 || modalita<1){ // Ho scelto un'opzione "illegale"
  97.                         while(scanf("%*[^\n]") == -1){ // Svuoto l'input buffer
  98.                                 if(errno != EINTR){
  99.                                         printf("\nErrore scanf\n");
  100.                                         chiusuraClient();
  101.                                 }
  102.                         }
  103.                         printf("Opzione non valida...\n");fflush(stdout);
  104.                         void premiInvio();
  105.                         stampaMenu();
  106.                         printf("Selezionare l'opzione...\n\n");fflush(stdout);
  107.                 }
  108.         } while(testscanf == 0 || modalita>3 || modalita<1);
  109.        
  110.         /* Ritorno il valore dell'opzione selezionata*/
  111.         return modalita;
  112. }
  113.  
  114. int main(int argc, char** argv){       
  115.  
  116.         if(argc != 3){
  117.                 printf("\033[01;31m\nERRORE - Avviare il programma usando il comando: \033[00m%s [Indirizzo IP] [Porta]", argv[0]);fflush(stdout);
  118.                 chiusuraClient();
  119.         }
  120.         else{
  121.  
  122.                 /* Imposto la gestione dei segnali asincroni */
  123.                 signal(SIGINT, chiusuraClient);
  124.                 signal(SIGQUIT, chiusuraClient);
  125.                 signal(SIGILL, chiusuraClient);
  126.                 signal(SIGSEGV, chiusuraClient);
  127.                 signal(SIGTERM, chiusuraClient);
  128.  
  129.                 /* Ignoro il segnale SIGPIPE */
  130.                 signal(SIGPIPE, SIG_IGN);
  131.  
  132.                 printf("\n\nInizializzazione client in corso...\n");fflush(stdout);
  133.  
  134.                 struct sockaddr_in target;
  135.  
  136.                 /* Resetto la struct target */
  137.                 memset(&target, 0, sizeof(target));
  138.  
  139.                 /* Stabilisco l'indirizzo IP del server (secondo argomento da linea di comando, il protocollo utilizzato e il port number (terzo argomento da linea di comando*/
  140.                 if(-1 == (inet_aton(argv[1], (struct in_addr *) (&target.sin_addr))) ){
  141.                         printf("\nErrore: indirizzo IP non valido!\n\n");fflush(stdout);
  142.                         chiusuraClient();
  143.                 }
  144.                 target.sin_family = AF_INET;
  145.                 target.sin_port = htons(atoi(argv[2]));
  146.  
  147.                 /* Creo il socket */
  148.                 int sock;
  149.                 printf("\nCreazione socket in corso...");fflush(stdout);
  150.                 if(-1 == (sock = socket(AF_INET, SOCK_STREAM, 0))){
  151.                         printf("\nErrore: Impossibile creare il socket!");fflush(stdout);
  152.                         chiusuraClient();
  153.                 }
  154.        
  155.                 /* Mi connetto al server */
  156.                 if(-1 == (connect(sock, (struct sockaddr *) &target, sizeof(target)))){
  157.                         printf("\nErrore: tentativo di connettersi a %s alla porta %s fallito", argv[1], argv[2]);fflush(stdout);
  158.                         chiusuraClient();
  159.                 }
  160.  
  161.                 printf("Inizializzazione completata con successo\n");
  162.  
  163.                 /* Effettuo il login */
  164.                 int loginOK;
  165.                 loginOK = login(sock);
  166.  
  167.                 if(loginOK == 1){
  168.  
  169.                         int opzione;
  170.        
  171.                         while(1){
  172.                                 /* Seleziono l'opzione dal menù principale */
  173.                                 opzione = menu();
  174.  
  175.                                 /* Chiamo la funzione specifica per l'opzione selezionata */
  176.  
  177.                                 /* Opzione "Trova record" */
  178.                                 if(opzione==1){
  179.                                         if(trovaRecord(sock) == 1){
  180.  
  181.                                                 /* Informo il server che voglio continuare con una richiesta */
  182.                                                 while(write(sock, "OK", RISPOSTA) <= 0){
  183.                                                         if(errno != EINTR){
  184.                                                                 if(errno == ECONNRESET || errno == EPIPE){
  185.                                                                         printf("\n\nCONNESSIONE INTERROTTA, il server si è disconnesso in maniera scorretta!");fflush(stdout);
  186.                                                                         chiusuraClient();
  187.                                                                 }
  188.                                                                 else{
  189.                                                                         printf("La read è fallita\n");fflush(stdout);
  190.                                                                         perror("Errore tipo");fflush(stdout);
  191.                                                                         chiusuraClient();
  192.                                                                 }
  193.                                                         }
  194.                                                         printf("Errore durante la system call, ripeto\n");fflush(stdout);
  195.                                                 }
  196.                                         }
  197.                                         else{
  198.                                                 printf("\nIl server non risponde, è offline\n");              
  199.                                                 chiusuraClient();
  200.                                         }
  201.                                 }
  202.  
  203.                                 /* Opzione "Aggiungi record" */
  204.                                 if(opzione==2){
  205.                                         if(aggiungiRecord(sock) == 1){
  206.  
  207.                                                 /* Informo il server che voglio continuare con una richiesta */
  208.                                                 while(write(sock, "OK", RISPOSTA) <= 0){
  209.                                                         if(errno != EINTR){
  210.                                                                 if(errno == ECONNRESET || errno == EPIPE){
  211.                                                                         printf("\n\nCONNESSIONE INTERROTTA, il server si è disconnesso in maniera scorretta!");fflush(stdout);
  212.                                                                         chiusuraClient();
  213.                                                                 }
  214.                                                                 else{
  215.                                                                         printf("La read è fallita\n");fflush(stdout);
  216.                                                                         perror("Errore tipo");fflush(stdout);
  217.                                                                         chiusuraClient();
  218.                                                                 }
  219.                                                         }
  220.                                                         printf("Errore durante la system call, ripeto\n");fflush(stdout);
  221.                                                 }
  222.                                         }
  223.                                         else{
  224.                                                 printf("\nIl server non risponde, è offline\n");              
  225.                                                 chiusuraClient();
  226.                                         }
  227.                                 }
  228.                                 if(opzione==3){
  229.                                         /* Informo il server che ho terminato le richieste... */
  230.                                         while(write(sock, "OFF", RISPOSTA) <= 0){
  231.                                                 if(errno != EINTR){
  232.                                                         if(errno == ECONNRESET || errno == EPIPE){
  233.                                                                 printf("\n\nCONNESSIONE INTERROTTA, il server si è disconnesso in maniera scorretta!");fflush(stdout);
  234.                                                                 chiusuraClient();
  235.                                                         }
  236.                                                         else{
  237.                                                                 printf("La read è fallita\n");fflush(stdout);
  238.                                                                 perror("Errore tipo");fflush(stdout);
  239.                                                                 chiusuraClient();
  240.                                                         }
  241.                                                 }
  242.                                                 printf("Errore durante la system call, ripeto\n");fflush(stdout);
  243.                                         }
  244.                                         /* ...e chiudo il client */
  245.                                         chiusuraClient();
  246.                                 }
  247.                         }
  248.                 }
  249.                
  250.                 /* La connessione si è interrotta improvvisamente */
  251.                 else{
  252.                         printf("\nIl server non risponde, è offline");        
  253.                         chiusuraClient();
  254.                 }
  255.         }
  256. }