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 - funzioniServer.c

funzioniServer.c

 Caricato da:
Scarica il programma completo

  1. /* funzioniServer.c */
  2.  
  3. #include "macro.h"
  4. #include "funzioniServer.h"
  5.  
  6. int aggiungiRecord(Record record){
  7.  
  8.         /* Apertura dell'archivio "ElencoTelefonico.txt" */
  9.         if(( ElencoTelefonico = fopen("ElencoTelefonico.txt", "a")) == NULL){
  10.                 printf("Non è possibile aprire l'elenco telefonico, verificare la consistenza dell'archivio");fflush(stdout);
  11.                 chiusuraServer();
  12.         }
  13.         else{
  14.                 /* Stampa su file del record */
  15.                 fprintf( ElencoTelefonico, "%s %s %s\n", record.nome, record.cognome, record.numeroTelefono);
  16.                 while(fclose(ElencoTelefonico) != 0){
  17.                         if(errno != EINTR){
  18.                                 printf("\nErrore fclose\n");
  19.                                 chiusuraServer();
  20.                         }
  21.                 }
  22.  
  23.                 /* Verifica presenza del record appena inserito */
  24.                 Record recordTemp = cercaRecord(record);
  25.                 if((strcmp(record.nome, recordTemp.nome) == 0) && (strcmp(record.cognome, recordTemp.cognome) == 0) && (strcmp(record.numeroTelefono, recordTemp.numeroTelefono) == 0)){
  26.                         return 1;
  27.                 }
  28.                 else return -1;
  29.         }
  30. }
  31.  
  32. int cancellaRecord(Record record){
  33.  
  34.         Record recordTemp;
  35.  
  36.         /* Resetto i valori della struct recordTemp */
  37.         memset(recordTemp.nome, 0, sizeof(recordTemp.nome));
  38.         memset(recordTemp.cognome, 0, sizeof(recordTemp.cognome));
  39.         memset(recordTemp.numeroTelefono, 0, sizeof(recordTemp.numeroTelefono));       
  40.         FILE *temp;
  41.  
  42.         /* Apertura dell'archivio "ElencoTelefonico.txt" */
  43.         if(( ElencoTelefonico = fopen("ElencoTelefonico.txt", "r")) == NULL){
  44.                 printf("\nNon è possibile aprire l'elenco telefonico, verificare la consistenza dell'archivio\n");fflush(stdout);
  45.                 chiusuraServer();
  46.         }
  47.         else{
  48.                 /* Apertura di un file temporaneo nel quale copiare l'archivio */
  49.                 if(( temp = fopen("temp.txt", "w")) == NULL){
  50.                         printf("\nImpossibile creare file temporaneo...\n\n");fflush(stdout);
  51.                         chiusuraServer();
  52.                 }
  53.                 else{
  54.                         /* Copio tutti i record dell'archivio escludendone quello da eliminare */
  55.                         while(fscanf(ElencoTelefonico, "%s %s %s", recordTemp.nome, recordTemp.cognome, recordTemp.numeroTelefono) == -1){
  56.                                 if(errno != EINTR){
  57.                                         printf("\nErrore fscanf\n");
  58.                                         chiusuraServer();
  59.                                 }
  60.                         }
  61.                         while(!feof(ElencoTelefonico)){
  62.                                 if((strcmp(record.nome, recordTemp.nome) == 0) && (strcmp(record.cognome, recordTemp.cognome) == 0)){
  63.                                         while(fscanf(ElencoTelefonico, "%s %s %s", recordTemp.nome, recordTemp.cognome, recordTemp.numeroTelefono) == -1){
  64.                                                 if(errno != EINTR){
  65.                                                         printf("\nErrore fscanf\n");
  66.                                                         chiusuraServer();
  67.                                                 }
  68.                                         }
  69.                                 }
  70.                                 else{
  71.                                         fprintf( temp, "%s %s %s\n", recordTemp.nome, recordTemp.cognome, recordTemp.numeroTelefono);
  72.                                         while(fscanf(ElencoTelefonico, "%s %s %s", recordTemp.nome, recordTemp.cognome, recordTemp.numeroTelefono) == -1){
  73.                                                 if(errno != EINTR){
  74.                                                         printf("\nErrore fscanf\n");
  75.                                                         chiusuraServer();
  76.                                                 }
  77.                                         }
  78.                                 }              
  79.                         }
  80.  
  81.                         /* Chiusura dei file */
  82.                         while(fclose(ElencoTelefonico) != 0){
  83.                                 if(errno != EINTR){
  84.                                         printf("\nErrore fclose\n");
  85.                                         chiusuraServer();
  86.                                 }
  87.                         }
  88.                         while(fclose(temp) != 0){
  89.                                 if(errno != EINTR){
  90.                                         printf("\nErrore fclose\n");
  91.                                         chiusuraServer();
  92.                                 }
  93.                         }
  94.                        
  95.                         /* Eliminazione del file ElencoTelefonico.txt */
  96.                         while(remove("ElencoTelefonico.txt") == -1){
  97.                                 if(errno != EINTR){
  98.                                         printf("\nErrore remove\n");
  99.                                         chiusuraServer();
  100.                                 }
  101.                         }
  102.  
  103.                         /* Rinomino il file "temp.txt" */
  104.                         while(rename("temp.txt", "ElencoTelefonico.txt") == -1){
  105.                                 if(errno != EINTR){
  106.                                         printf("\nErrore rename\n");
  107.                                         chiusuraServer();
  108.                                 }
  109.                         }
  110.                        
  111.                 }
  112.         }
  113. }
  114.  
  115. Record cercaRecord(Record record){
  116.  
  117.         Record recordTemp;
  118.  
  119.         /* Resetto i valori della struct recordTemp */
  120.         memset(recordTemp.nome, 0, sizeof(recordTemp.nome));
  121.         memset(recordTemp.cognome, 0, sizeof(recordTemp.cognome));
  122.         memset(recordTemp.numeroTelefono, 0, sizeof(recordTemp.numeroTelefono));       
  123.         int cont=0;
  124.  
  125.         /* Apertura dell'archivio "ElencoTelefonico.txt" */
  126.         if(( ElencoTelefonico = fopen("ElencoTelefonico.txt", "r")) == NULL){
  127.                 printf("Non è possibile aprire l'elenco telefonico, verificare la consistenza dell'archivio");fflush(stdout);
  128.                 chiusuraServer();
  129.         }
  130.         else{  
  131.                 /* Lettura del file e conteggio del numero di record presenti */
  132.                 while(fscanf(ElencoTelefonico, "%s %s %s", recordTemp.nome, recordTemp.cognome, recordTemp.numeroTelefono) == -1){
  133.                         if(errno != EINTR){
  134.                                 printf("\nErrore fscanf\n");
  135.                                 chiusuraServer();
  136.                         }
  137.                 }
  138.                 while(!feof(ElencoTelefonico)){
  139.                         while(fscanf(ElencoTelefonico, "%s %s %s", recordTemp.nome, recordTemp.cognome, recordTemp.numeroTelefono) == -1){
  140.                                 if(errno != EINTR){
  141.                                         printf("\nErrore fscanf\n");
  142.                                         chiusuraServer();
  143.                                 }
  144.                         }
  145.                         ++cont;
  146.                 }
  147.  
  148.                 /* Riposizionamento dell'indice di lettura del file */
  149.                 rewind(ElencoTelefonico);
  150.  
  151.                 /* Rilettura del file alla ricerca del record richiesto */
  152.                 int i;
  153.                 for(i=0; i<cont; ++i){
  154.                         while(fscanf(ElencoTelefonico, "%s %s %s", recordTemp.nome, recordTemp.cognome, recordTemp.numeroTelefono) == -1){
  155.                                 if(errno != EINTR){
  156.                                         printf("\nErrore fscanf\n");
  157.                                         chiusuraServer();
  158.                                 }
  159.                         }
  160.                         if((strcmp(record.nome, recordTemp.nome) == 0 && strcmp(record.cognome, recordTemp.cognome) == 0)){    
  161.                                 while(fclose(ElencoTelefonico) != 0){
  162.                                         if(errno != EINTR){
  163.                                                 printf("\nErrore fclose\n");
  164.                                                 chiusuraServer();
  165.                                         }
  166.                                 }                              
  167.                                 return recordTemp;
  168.                         }
  169.                 }
  170.  
  171.                 /* Chiusura del file */
  172.                 while(fclose(ElencoTelefonico) != 0){
  173.                         if(errno != EINTR){
  174.                                 printf("\nErrore fclose\n");
  175.                                 chiusuraServer();
  176.                         }
  177.                 }
  178.  
  179.                 /* Valore ritornato in caso in cui il record richiesto non sia presente nell'archivio */
  180.                 Record risultatoNullo = { "NULL", "NULL", "NULL" };
  181.                 return risultatoNullo;
  182.         }
  183. }
  184.  
  185. void stampaElencoTelefonico(){
  186.  
  187.         Record record;
  188.  
  189.         /* Resetto i valori della struct record */
  190.         memset(record.nome, 0, sizeof(record.nome));
  191.         memset(record.cognome, 0, sizeof(record.cognome));
  192.         memset(record.numeroTelefono, 0, sizeof(record.numeroTelefono));
  193.  
  194.         /* Apertura dell'archivio ElencoTelefonico.txt" */
  195.         if(( ElencoTelefonico = fopen("ElencoTelefonico.txt", "r")) == NULL){
  196.                 printf("Non è possibile aprire l'elenco telefonico, verificare la consistenza dell'archivio");fflush(stdout);
  197.                 chiusuraServer();
  198.         }
  199.  
  200.                 /* Lettura del file e stampa dei record */
  201.         else{
  202.                 printf("Stampa elenco telefonico in corso...\n\n");fflush(stdout);
  203.                 printf("----------ELENCO TELEFONICO----------\n\n");fflush(stdout);
  204.                 printf("%-13s %-13s %s\n\n", "NOME", "COGNOME", "N. TEL");fflush(stdout);
  205.                 while(fscanf(ElencoTelefonico, "%s %s %s", record.nome, record.cognome, record.numeroTelefono) == -1){
  206.                         if(errno != EINTR){
  207.                                 printf("\nErrore fscanf\n");
  208.                                 chiusuraServer();
  209.                         }
  210.                 }
  211.         }
  212.         while(!feof(ElencoTelefonico)){
  213.                 printf("%-13s %-13s %s\n", record.nome, record.cognome, record.numeroTelefono);fflush(stdout);
  214.                 while(fscanf(ElencoTelefonico, "%s %s %s", record.nome, record.cognome, record.numeroTelefono) == -1){
  215.                         if(errno != EINTR){
  216.                                 printf("\nErrore fscanf\n");
  217.                                 chiusuraServer();
  218.                         }
  219.                 }
  220.         }
  221.         printf("\n-------------------------------------\n\n");fflush(stdout);
  222.  
  223.         /* Chiusura del file */
  224.         while(fclose(ElencoTelefonico) != 0){
  225.                 if(errno != EINTR){
  226.                         printf("\nErrore fclose\n");
  227.                         chiusuraServer();
  228.                 }
  229.         }
  230.  
  231.         /* "Premi INVIO per continuare" */
  232.         premiInvio();  
  233. }
  234.  
  235. int aggiungiUtente(Utente utente){
  236.  
  237.         /* Apertura dell'archivio "Permessi.txt" */
  238.         if(( Permessi = fopen("Permessi.txt", "a")) == NULL){
  239.                 printf("\nNon è possibile aprire l'elenco utenti, verificare la consistenza dell'archivio\n");fflush(stdout);
  240.                 chiusuraServer();
  241.         }
  242.         else{
  243.  
  244.                 /* Scrittura su file del record */
  245.                 while(fprintf( Permessi, "%s %s %d\n", utente.nickname, utente.password, utente.permessi) == -1){
  246.                         if(errno != EINTR){
  247.                                 printf("\nErrore fprintf\n");
  248.                                 chiusuraServer();
  249.                         }
  250.                 }
  251.  
  252.                 /* Chiusura del file */
  253.                 while(fclose(Permessi) != 0){
  254.                         if(errno != EINTR){
  255.                                 printf("\nErrore fclose\n");
  256.                                 chiusuraServer();
  257.                         }
  258.                 }
  259.  
  260.                 /* Verifica della presenza del record appena inserito */
  261.                 Utente utenteTemp = cercaUtente(utente);
  262.                 if( (strcmp(utente.nickname, utenteTemp.nickname) == 0) && (strcmp(utente.password, utenteTemp.password) == 0) && (utente.permessi == utenteTemp.permessi) ){
  263.                         return 1;
  264.                 }
  265.                 else return -1;
  266.         }
  267. }
  268.  
  269. int cancellaUtente(Utente utente){
  270.  
  271.         Utente utenteTemp;
  272.  
  273.         /* Resetto i valori della struct utenteTemp */
  274.         memset(utenteTemp.nickname, 0, sizeof(utenteTemp.nickname));
  275.         memset(utenteTemp.password, 0, sizeof(utenteTemp.password));
  276.         FILE *temp;
  277.  
  278.         /* Apertura dell'archivio "Permessi.txt" */
  279.         if(( Permessi = fopen("Permessi.txt", "r")) == NULL){
  280.                 printf("Non è possibile aprire l'elenco utenti, verificare la consistenza dell'archivio");fflush(stdout);
  281.                 chiusuraServer();
  282.         }
  283.         else{
  284.                 /* Apertura del file temporaneo "temp.txt" */
  285.                 if(( temp = fopen("temp.txt", "w")) == NULL){
  286.                         printf("\nOperazione fallita. Chiusura programma...\n\n");fflush(stdout);
  287.                         chiusuraServer();
  288.                 }
  289.                 else{
  290.                         /* Copio i record di Permessi.txt in temp.txt ad eccezione del record da cancellare */
  291.                         while(fscanf(Permessi, "%s %s %d", utenteTemp.nickname, utenteTemp.password, &utenteTemp.permessi) == -1){
  292.                                 if(errno != EINTR){
  293.                                         printf("\nErrore fscanf\n");
  294.                                         chiusuraServer();
  295.                                 }
  296.                         }
  297.                         while(!feof(Permessi)){
  298.                                 if((strcmp(utente.nickname, utenteTemp.nickname) == 0)){
  299.                                         while(fscanf(Permessi, "%s %s %d", utenteTemp.nickname, utenteTemp.password, &utenteTemp.permessi) == -1){
  300.                                                 if(errno != EINTR){
  301.                                                         printf("\nErrore fscanf\n");
  302.                                                         chiusuraServer();
  303.                                                 }
  304.                                         }
  305.                                 }
  306.                                 else{
  307.                                         while(fprintf( temp, "%s %s %d\n", utenteTemp.nickname, utenteTemp.password, utenteTemp.permessi) == -1){
  308.                                                 if(errno != EINTR){
  309.                                                         printf("\nErrore fprintf\n");
  310.                                                         chiusuraServer();
  311.                                                 }
  312.                                         }
  313.                                         while(fscanf(Permessi, "%s %s %d", utenteTemp.nickname, utenteTemp.password, &utenteTemp.permessi) == -1){
  314.                                                 if(errno != EINTR){
  315.                                                         printf("\nErrore fscanf\n");
  316.                                                         chiusuraServer();
  317.                                                 }
  318.                                         }
  319.                                 }                      
  320.                         }
  321.  
  322.                         /* Chiusura dei file */
  323.                         while(fclose(Permessi) != 0){
  324.                                 if(errno != EINTR){
  325.                                         printf("\nErrore fclose\n");
  326.                                         chiusuraServer();
  327.                                 }
  328.                         }
  329.                         while(fclose(temp) != 0){
  330.                                 if(errno != EINTR){
  331.                                         printf("\nErrore fclose\n");
  332.                                         chiusuraServer();
  333.                                 }
  334.                         }
  335.                        
  336.                         /* Cancellazione del file "Permessi.txt" */
  337.                         while(remove("Permessi.txt") == -1){
  338.                                 if(errno != EINTR){
  339.                                         printf("\nErrore remove\n");
  340.                                         chiusuraServer();
  341.                                 }
  342.                         }
  343.  
  344.                         /* Rinomino il file "temp.txt" */
  345.                         while(rename("temp.txt", "Permessi.txt") == -1){
  346.                                 if(errno != EINTR){
  347.                                         printf("\nErrore rename\n");
  348.                                         chiusuraServer();
  349.                                 }
  350.                         }
  351.                        
  352.                 }
  353.         }
  354. }
  355.  
  356. Utente cercaUtente(Utente utente){
  357.  
  358.         Utente utenteTemp;
  359.  
  360.         /* Resetto i valori della struct utenteTemp */
  361.         memset(utenteTemp.nickname, 0, sizeof(utenteTemp.nickname));
  362.         memset(utenteTemp.password, 0, sizeof(utenteTemp.password));
  363.         int cont=0;
  364.  
  365.         /* Apertura dell'archivio "Permessi.txt" */
  366.         if(( Permessi = fopen("Permessi.txt", "r")) == NULL){
  367.                 printf("\nNon è possibile aprire l'elenco utenti, verificare la consistenza dell'archivio\n");fflush(stdout);
  368.                 chiusuraServer();
  369.         }
  370.         else{  
  371.                 /* Conteggio del numero di record presenti nel file */
  372.                 while(fscanf(Permessi, "%s %s %d", utenteTemp.nickname, utenteTemp.password, &utenteTemp.permessi) == -1){
  373.                         if(errno != EINTR){
  374.                                 printf("\nErrore fscanf\n");
  375.                                 chiusuraServer();
  376.                         }
  377.                 }
  378.                 while(!feof(Permessi)){
  379.                         while(fscanf(Permessi, "%s %s %d", utenteTemp.nickname, utenteTemp.password, &utenteTemp.permessi) == -1){
  380.                                 if(errno != EINTR){
  381.                                         printf("\nErrore fscanf\n");
  382.                                         chiusuraServer();
  383.                                 }
  384.                         }
  385.                         ++cont;
  386.                 }
  387.  
  388.                 /* Riposizionamento dell'indice di lettura del file */
  389.                 rewind(Permessi);
  390.  
  391.                 /* Rilettura del file alla ricerca del record richiesto */
  392.                 int i;
  393.                 for(i=0; i<cont; ++i){
  394.                         while(fscanf(Permessi, "%s %s %d", utenteTemp.nickname, utenteTemp.password, &utenteTemp.permessi) == -1){
  395.                                 if(errno != EINTR){
  396.                                         printf("\nErrore fscanf\n");
  397.                                         chiusuraServer();
  398.                                 }
  399.                         }
  400.                         if(strcmp(utente.nickname, utenteTemp.nickname) == 0){
  401.                                 while(fclose(Permessi) != 0){
  402.                                         if(errno != EINTR){
  403.                                                 printf("\nErrore fclose\n");
  404.                                                 chiusuraServer();
  405.                                         }
  406.                                 }
  407.                                 return utenteTemp;
  408.                         }
  409.                 }
  410.  
  411.                 /* Chiusura del file */
  412.                 while(fclose(Permessi) != 0){
  413.                         if(errno != EINTR){
  414.                                 printf("\nErrore fclose\n");
  415.                                 chiusuraServer();
  416.                         }
  417.                 }
  418.  
  419.                 /* Risultato ritornato nel caso in cui il record richiesto non sia presente nel file */
  420.                 Utente nullo = { "NULL", "NULL", 0 };
  421.                 return nullo;
  422.         }
  423. }
  424.  
  425. void stampaElencoUtenti(){
  426.  
  427.         Utente utente;
  428.  
  429.         /* Resetto i valori della struct utente */
  430.         memset(utente.nickname, 0, sizeof(utente.nickname));
  431.         memset(utente.password, 0, sizeof(utente.password));
  432.  
  433.         /* Apertura dell'archivio "Permessi.txt" */
  434.         if(( Permessi = fopen("Permessi.txt", "r")) == NULL){
  435.                 printf("Non è possibile aprire l'elenco utenti, verificare la consistenza dell'archivio");fflush(stdout);
  436.                 chiusuraServer();
  437.         }
  438.         else{
  439.                 /* Lettura e stampa di tutti i record del file */
  440.                 printf("-------------ELENCO UTENTI-------------\n\n");fflush(stdout);
  441.                 printf("%-13s %-13s %s\n\n", "NICKNAME", "PASSWORD", "TIPO PERMESSI");fflush(stdout);
  442.                 while(fscanf(Permessi, "%s %s %d", utente.nickname, utente.password, &utente.permessi) == -1){
  443.                         if(errno != EINTR){
  444.                                 printf("\nErrore fscanf\n");
  445.                                 chiusuraServer();
  446.                         }
  447.                 }
  448.         }
  449.         while(!feof(Permessi)){
  450.                 printf("%-13s %-13s %d\n", utente.nickname, utente.password, utente.permessi);fflush(stdout);
  451.                 while(fscanf(Permessi, "%s %s %d", utente.nickname, utente.password, &utente.permessi) == -1){
  452.                         if(errno != EINTR){
  453.                                 printf("\nErrore fscanf\n");
  454.                                 chiusuraServer();
  455.                         }
  456.                 }
  457.         }
  458.         printf("\n---------------------------------------\n\n");fflush(stdout);
  459.  
  460.         /* Chiusura del file */
  461.         while(fclose(Permessi) != 0){
  462.                 if(errno != EINTR){
  463.                         printf("\nErrore fclose\n");
  464.                         chiusuraServer();
  465.                 }
  466.         }
  467.  
  468.         /* "Premere INVIO per continuare" */
  469.         premiInvio();
  470. }
  471.  
  472. int login(int newSock){
  473.  
  474.         int tentativi = 3; // Variabile che tiene il conteggio del numero di tentativi di LOGIN disponibili
  475.        
  476.         while(tentativi>0){
  477.                 Utente utente;
  478.  
  479.                 /* Resetto i valori della struct utente */
  480.                 memset(utente.nickname, 0, sizeof(utente.nickname));
  481.                 memset(utente.password, 0, sizeof(utente.password));
  482.  
  483.                 /* Ricevo il nickname dal client*/
  484.                 while(read(newSock, utente.nickname, NICKNAME) <= 0){
  485.                         if(errno != EINTR){
  486.                                 if(errno == ECONNRESET || errno == EPIPE){
  487.                                         printf("\n\nCONNESSIONE INTERROTTA, il server si è disconnesso in maniera scorretta!");fflush(stdout);
  488.                                         return -1;
  489.                                 }
  490.                                 else{
  491.                                         printf("La read è fallita\n");fflush(stdout);
  492.                                         perror("Errore tipo");fflush(stdout);
  493.                                         return -1;
  494.                                 }
  495.                         }
  496.                         printf("Errore durante la system call, ripeto\n");fflush(stdout);
  497.                 }
  498.  
  499.                 /* Ricevo la password dal client */
  500.                 while(read(newSock, utente.password, PASSWORD) <= 0){
  501.                         if(errno != EINTR){
  502.                                 if(errno == ECONNRESET || errno == EPIPE){
  503.                                         printf("\n\nCONNESSIONE INTERROTTA, il server si è disconnesso in maniera scorretta!");fflush(stdout);
  504.                                         return -1;
  505.                                 }
  506.                                 else{
  507.                                         printf("La read è fallita\n");fflush(stdout);
  508.                                         perror("Errore tipo");fflush(stdout);
  509.                                         return -1;
  510.                                 }
  511.                         }
  512.                         printf("Errore durante la system call, ripeto\n");fflush(stdout);
  513.                 }
  514.  
  515.                 printf("\nHo passato le 2 read (nick e pass)\n");
  516.  
  517.                 /* Ricerca dell'utente appena connesso */
  518.                 Utente utenteTemp = cercaUtente(utente);
  519.  
  520.                 if((strcmp(utente.nickname, utenteTemp.nickname) == 0) && (strcmp(utente.password, utenteTemp.password) == 0)){
  521.                        
  522.                         /* L'utente connesso è presente nell'archivio */
  523.                         while(write(newSock, "OK", RISPOSTA) <= 0){
  524.                                 if(errno != EINTR){
  525.                                         if(errno == ECONNRESET || errno == EPIPE){
  526.                                                 printf("\n\nCONNESSIONE INTERROTTA, il server si è disconnesso in maniera scorretta!");fflush(stdout);
  527.                                                 return -1;
  528.                                         }
  529.                                         else{
  530.                                                 printf("La read è fallita\n");fflush(stdout);
  531.                                                 perror("Errore tipo");fflush(stdout);
  532.                                                 return -1;
  533.                                         }
  534.                                 }
  535.                                 printf("Errore durante la system call, ripeto\n");fflush(stdout);
  536.                         }
  537.                         printf("\n%s ha appena effettuato il LOGIN\n", utenteTemp.nickname);fflush(stdout);
  538.  
  539.                         /* Resetto i valori della struct utente */
  540.                         memset(utente.nickname, 0, sizeof(utente.nickname));
  541.                         memset(utente.password, 0, sizeof(utente.password));
  542.                         return utenteTemp.permessi;
  543.                 }
  544.                 else {
  545.                        
  546.                         /* L'utente connesso non è presente nell'archivio */
  547.                         while(write(newSock, "NO", RISPOSTA) <= 0){
  548.                                 if(errno != EINTR){
  549.                                         if(errno == ECONNRESET || errno == EPIPE){
  550.                                                 printf("\n\nCONNESSIONE INTERROTTA, il server si è disconnesso in maniera scorretta!");fflush(stdout);
  551.                                                 return -1;
  552.                                         }
  553.                                         else{
  554.                                                 printf("La read è fallita\n");fflush(stdout);
  555.                                                 perror("Errore tipo");fflush(stdout);
  556.                                                 return -1;
  557.                                         }
  558.                                 }
  559.                                 printf("Errore durante la system call, ripeto\n");fflush(stdout);
  560.                         }
  561.  
  562.                         printf("\n%s non presente nell'elenco utenti\n", utente.nickname);fflush(stdout);
  563.  
  564.                         while(write(newSock, "NO", RISPOSTA) <= 0){
  565.                                 if(errno != EINTR){
  566.                                         if(errno == ECONNRESET || errno == EPIPE){
  567.                                                 printf("\n\nCONNESSIONE INTERROTTA, il server si è disconnesso in maniera scorretta!");fflush(stdout);
  568.                                                 return -1;
  569.                                         }
  570.                                         else{
  571.                                                 printf("La read è fallita\n");fflush(stdout);
  572.                                                 perror("Errore tipo");fflush(stdout);
  573.                                                 return -1;
  574.                                         }
  575.                                 }
  576.                                 printf("Errore durante la system call, ripeto\n");fflush(stdout);
  577.                         }
  578.  
  579.                         --tentativi;
  580.                         printf("%s ha ancora %d tentativi a disposizione\n", utente.nickname, tentativi);fflush(stdout);
  581.  
  582.                         /* Resetto i valori della struct utente */
  583.                         memset(utente.nickname, 0, sizeof(utente.nickname));
  584.                         memset(utente.password, 0, sizeof(utente.password));
  585.                 }
  586.         }
  587.        
  588.         printf("Tentativo di LOGIN fallito dopo 3 tentativi\n");fflush(stdout);
  589.         return -1;
  590. }
  591.  
  592. void trova(int newSock){
  593.  
  594.         printf("\nRicevuta richiesta ""Trova record""\n");fflush(stdout);
  595.  
  596.         Record record, risultato;
  597.  
  598.         /* Resetto i valori della struct record */
  599.         memset(record.nome, 0, sizeof(record.nome));
  600.         memset(record.cognome, 0, sizeof(record.cognome));
  601.         memset(record.numeroTelefono, 0, sizeof(record.numeroTelefono));
  602.  
  603.         /* Resetto i valori della struct risultato */
  604.         memset(risultato.nome, 0, sizeof(risultato.nome));
  605.         memset(risultato.cognome, 0, sizeof(risultato.cognome));
  606.         memset(risultato.numeroTelefono, 0, sizeof(risultato.numeroTelefono));
  607.  
  608.         /* Ricevo il nome dal client */
  609.         while(read(newSock, record.nome, NOME) <= 0){
  610.                 if(errno != EINTR){
  611.                         if(errno == ECONNRESET || errno == EPIPE){
  612.                                 printf("\n\nCONNESSIONE INTERROTTA, il server si è disconnesso in maniera scorretta!");fflush(stdout);
  613.                                 return;
  614.                         }
  615.                         else{
  616.                                 printf("La read è fallita\n");fflush(stdout);
  617.                                 perror("Errore tipo");fflush(stdout);
  618.                                 return;
  619.                         }
  620.                 }
  621.                 printf("Errore durante la system call, ripeto\n");fflush(stdout);
  622.         }
  623.  
  624.         printf("\nRicevuto il nome dal client\n");
  625.  
  626.         /* Ricevo il cognome dal client */
  627.         while(read(newSock, record.cognome, COGNOME) <= 0){
  628.                 if(errno != EINTR){
  629.                         if(errno == ECONNRESET || errno == EPIPE){
  630.                                 printf("\n\nCONNESSIONE INTERROTTA, il server si è disconnesso in maniera scorretta!");fflush(stdout);
  631.                                 return;
  632.                         }
  633.                         else{
  634.                                 printf("La read è fallita\n");fflush(stdout);
  635.                                 perror("Errore tipo");fflush(stdout);
  636.                                 return;
  637.                         }
  638.                 }
  639.                 printf("Errore durante la system call, ripeto\n");fflush(stdout);
  640.         }
  641.  
  642.         printf("Ricevuta il cognome dal client\n");
  643.  
  644.         /* Cerco il record nell'archivio */
  645.         risultato = cercaRecord(record);
  646.  
  647.         /* Invio il nome al client */
  648.         while(write(newSock, risultato.nome, NOME) <= 0){
  649.                 if(errno != EINTR){
  650.                         if(errno == ECONNRESET || errno == EPIPE){
  651.                                 printf("\n\nCONNESSIONE INTERROTTA, il server si è disconnesso in maniera scorretta!");fflush(stdout);
  652.                                 return;
  653.                         }
  654.                         else{
  655.                                 printf("La read è fallita\n");fflush(stdout);
  656.                                 perror("Errore tipo");fflush(stdout);
  657.                                 return;
  658.                         }
  659.                 }
  660.                 printf("Errore durante la system call, ripeto\n");fflush(stdout);
  661.         }
  662.  
  663.         printf("Inviato il nome-risultato al client\n");
  664.  
  665.         /* Invio il cognome al client */
  666.         while(write(newSock, risultato.cognome, COGNOME) <= 0){
  667.                 if(errno != EINTR){
  668.                         if(errno == ECONNRESET || errno == EPIPE){
  669.                                 printf("\n\nCONNESSIONE INTERROTTA, il server si è disconnesso in maniera scorretta!");fflush(stdout);
  670.                                 return;
  671.                         }
  672.                         else{
  673.                                 printf("La read è fallita\n");fflush(stdout);
  674.                                 perror("Errore tipo");fflush(stdout);
  675.                                 return;
  676.                         }
  677.                 }
  678.                 printf("Errore durante la system call, ripeto\n");fflush(stdout);
  679.         }
  680.  
  681.         printf("Inviato il cognome-risultato al client\n");
  682.  
  683.         /* Invio il numero al client */
  684.         while(write(newSock, risultato.numeroTelefono, NUMERO) <= 0){
  685.                 if(errno != EINTR){
  686.                         if(errno == ECONNRESET || errno == EPIPE){
  687.                                 printf("\n\nCONNESSIONE INTERROTTA, il server si è disconnesso in maniera scorretta!");fflush(stdout);
  688.                                 return;
  689.                         }
  690.                         else{
  691.                                 printf("La read è fallita\n");fflush(stdout);
  692.                                 perror("Errore tipo");fflush(stdout);
  693.                                 return;
  694.                         }
  695.                 }
  696.                 printf("Errore durante la system call, ripeto\n");fflush(stdout);
  697.         }
  698.  
  699.         printf("Inviato il numero-risultato al client\n");
  700. }
  701.  
  702. void aggiungi(int newSock){
  703.  
  704.         printf("\nRicevuta richiesta ""Aggiungi record""\n");fflush(stdout);           
  705.  
  706.         Record record;
  707.  
  708.         /* Resetto i valori della struct record */
  709.         memset(record.nome, 0, sizeof(record.nome));
  710.         memset(record.cognome, 0, sizeof(record.cognome));
  711.         memset(record.numeroTelefono, 0, sizeof(record.numeroTelefono));
  712.  
  713.         /* Ricevo il nome dal client */
  714.  
  715.         while(read(newSock, record.nome, NOME) <= 0){
  716.                 if(errno != EINTR){
  717.                         if(errno == ECONNRESET || errno == EPIPE){
  718.                                 printf("\n\nCONNESSIONE INTERROTTA, il server si è disconnesso in maniera scorretta!");fflush(stdout);
  719.                                 return;
  720.                         }
  721.                         else{
  722.                                 printf("La read è fallita\n");fflush(stdout);
  723.                                 perror("Errore tipo");fflush(stdout);
  724.                                 return;
  725.                         }
  726.                 }
  727.                 printf("Errore durante la system call, ripeto\n");fflush(stdout);
  728.         }      
  729.         printf("\nRicevuto il nome dal client\n");
  730.  
  731.         /* Ricevo il cognome dal client */
  732.         while(read(newSock, record.cognome, COGNOME) <= 0){
  733.                 if(errno != EINTR){
  734.                         if(errno == ECONNRESET || errno == EPIPE){
  735.                                 printf("\n\nCONNESSIONE INTERROTTA, il server si è disconnesso in maniera scorretta!");fflush(stdout);
  736.                                 return;
  737.                         }
  738.                         else{
  739.                                 printf("La read è fallita\n");fflush(stdout);
  740.                                 perror("Errore tipo");fflush(stdout);
  741.                                 return;
  742.                         }
  743.                 }
  744.                 printf("Errore durante la system call, ripeto\n");fflush(stdout);
  745.         }
  746.         printf("\nRicevuto il cognome dal client\n");
  747.  
  748.         /* Ricevo il numero dal client */
  749.         while(read(newSock, record.numeroTelefono, NUMERO) <= 0){
  750.                 if(errno != EINTR){
  751.                         if(errno == ECONNRESET || errno == EPIPE){
  752.                                 printf("\n\nCONNESSIONE INTERROTTA, il server si è disconnesso in maniera scorretta!");fflush(stdout);
  753.                                 return;
  754.                         }
  755.                         else{
  756.                                 printf("La read è fallita\n");fflush(stdout);
  757.                                 perror("Errore tipo");fflush(stdout);
  758.                                 return;
  759.                         }
  760.                 }
  761.                 printf("Errore durante la system call, ripeto\n");fflush(stdout);
  762.         }
  763.         printf("\nRicevuto il numero dal client\n");
  764.  
  765.         /* Aggiungo il record all'archivio */
  766.         if(1 == aggiungiRecord(record)){
  767.  
  768.                 printf("\nAggiunto un nuovo record all'archivio!\n");fflush(stdout);
  769.                 while(write(newSock, "OK", RISPOSTA) <= 0){
  770.                         if(errno != EINTR){
  771.                                 if(errno == ECONNRESET || errno == EPIPE){
  772.                                         printf("\n\nCONNESSIONE INTERROTTA, il server si è disconnesso in maniera scorretta!");fflush(stdout);
  773.                                         return;
  774.                                 }
  775.                                 else{
  776.                                         printf("La read è fallita\n");fflush(stdout);
  777.                                         perror("Errore tipo");fflush(stdout);
  778.                                         return;
  779.                                 }
  780.                         }
  781.                         printf("Errore durante la system call, ripeto\n");fflush(stdout);
  782.                 }
  783.         }
  784.         else{
  785.                 /* Tentativo fallito */
  786.                 printf("\nTentativo di aggiungere un record all'archivio è fallito!\n");fflush(stdout);
  787.                 while(write(newSock, "NO", RISPOSTA) <= 0){
  788.                         if(errno != EINTR){
  789.                                 if(errno == ECONNRESET || errno == EPIPE){
  790.                                         printf("\n\nCONNESSIONE INTERROTTA, il server si è disconnesso in maniera scorretta!");fflush(stdout);
  791.                                         return;
  792.                                 }
  793.                                 else{
  794.                                         printf("La read è fallita\n");fflush(stdout);
  795.                                         perror("Errore tipo");fflush(stdout);
  796.                                         return;
  797.                                 }
  798.                         }
  799.                         printf("Errore durante la system call, ripeto\n");fflush(stdout);
  800.                 }
  801.         }      
  802. }
  803.  
  804. void premiInvio(){
  805.  
  806.         printf("\nPremere INVIO per continuare...\n");fflush(stdout);
  807.  
  808.         /* Svuoto l'input buffer */
  809.         while ( getchar() != '\n' );
  810.  
  811.         /* Leggo dallo stdin SOLO \n */
  812.         while(scanf("%*[^\n]") == -1){
  813.                 if(errno != EINTR){
  814.                         printf("\nErrore scanf\n");
  815.                         chiusuraServer();
  816.                 }
  817.         }
  818. }
  819.  
  820. void chiusuraServer(){
  821.        
  822.         printf("\033[00m\n\nCHIUSURA SERVER IN CORSO...");fflush(stdout);
  823.         printf("\nSERVER CHIUSO CORRETTAMENTE\n\n");fflush(stdout);
  824.         exit(0);
  825. }
  826.  
  827. void servizio(int permessi, int newSock){
  828.  
  829.         printf("\nSono entrato nella funzione servizio\n");
  830.  
  831.         char opzione[RISPOSTA];
  832.  
  833.         while(1){
  834.                
  835.                 /* Resetto la stringa opzione */
  836.                 memset(opzione, 0, strlen(opzione));
  837.  
  838.                 /* Ricevo la richiesta dal client */
  839.                 while(read(newSock, opzione, RISPOSTA) <= 0){
  840.                         if(errno != EINTR){
  841.                                 if(errno == ECONNRESET || errno == EPIPE){
  842.                                         printf("\n\nCONNESSIONE INTERROTTA, il server si è disconnesso in maniera scorretta!");fflush(stdout);
  843.                                         return;
  844.                                 }
  845.                                 else{
  846.                                         printf("La read è fallita\n");fflush(stdout);
  847.                                         perror("Errore tipo");fflush(stdout);
  848.                                         return;
  849.                                 }
  850.                         }
  851.                         printf("Errore durante la system call, ripeto\n");fflush(stdout);
  852.                 }
  853.  
  854.                 /* Elaboro la richiesta del client invocando la funzione di gestione adatta */
  855.                 if(strcmp("TROVA", opzione) == 0){
  856.                        
  857.                         memset(opzione, 0, strlen(opzione));
  858.                         trova(newSock);
  859.                 }
  860.  
  861.                 /* Il client vuole aggiungere un record all'archivio ed ha i permessi sufficienti */
  862.                 if((strcmp("AGGIUNGI", opzione) == 0) && permessi == 2){
  863.                                        
  864.                         while(write(newSock, "OK", RISPOSTA) <= 0){
  865.                                 if(errno != EINTR){
  866.                                         if(errno == ECONNRESET || errno == EPIPE){
  867.                                                 printf("\n\nCONNESSIONE INTERROTTA, il server si è disconnesso in maniera scorretta!");fflush(stdout);
  868.                                                 return;
  869.                                         }
  870.                                         else{
  871.                                                 printf("La read è fallita\n");fflush(stdout);
  872.                                                 perror("Errore tipo");fflush(stdout);
  873.                                                 return;
  874.                                         }
  875.                                 }
  876.                                 printf("Errore durante la system call, ripeto\n");fflush(stdout);
  877.                         }
  878.                         memset(opzione, 0, strlen(opzione));
  879.                         aggiungi(newSock);                     
  880.                 }
  881.  
  882.                 /* Il client vuole aggiungere un record all'archivio e non dispone dei permessi sufficienti */
  883.                 if((strcmp("AGGIUNGI", opzione) == 0) && permessi == 1){
  884.  
  885.                         printf("\nRicevuta richiesta ""Aggiungi record""");fflush(stdout);
  886.                         printf("\nL'utente non ha i permessi sufficienti per l'operazione\n");fflush(stdout);
  887.                        
  888.                         while(write(newSock, "NO", RISPOSTA) <= 0){
  889.                                 if(errno != EINTR){
  890.                                         if(errno == ECONNRESET || errno == EPIPE){
  891.                                                 printf("\n\nCONNESSIONE INTERROTTA, il server si è disconnesso in maniera scorretta!");fflush(stdout);
  892.                                                 return;
  893.                                         }
  894.                                         else{
  895.                                                 printf("La read è fallita\n");fflush(stdout);
  896.                                                 perror("Errore tipo");fflush(stdout);
  897.                                                 return;
  898.                                         }
  899.                                 }
  900.                                 printf("Errore durante la system call, ripeto\n");fflush(stdout);
  901.                         }
  902.                 }
  903.  
  904.                 /* Il client ha comunicato che desidera interrompere la connessione */
  905.                 if(strcmp("OFF", opzione) == 0){
  906.                         printf("\nL'utente ha concluso correttamente le sue operazioni");fflush(stdout);
  907.                         return;
  908.                 }
  909.  
  910.                 char off[RISPOSTA];
  911.                
  912.                 while(read(newSock, off, RISPOSTA) <= 0){
  913.                         if(errno != EINTR){
  914.                                 if(errno == ECONNRESET || errno == EPIPE){
  915.                                         printf("\n\nCONNESSIONE INTERROTTA, il server si è disconnesso in maniera scorretta!");fflush(stdout);
  916.                                         return;
  917.                                 }
  918.                                 else{
  919.                                         printf("La read è fallita\n");fflush(stdout);
  920.                                         perror("Errore tipo");fflush(stdout);
  921.                                         return;
  922.                                 }
  923.                         }
  924.                         printf("Errore durante la system call, ripeto\n");fflush(stdout);
  925.                 }
  926.  
  927.                 if(strcmp("OFF", off) == 0){
  928.                         printf("\nL'utente ha concluso correttamente le sue operazioni");fflush(stdout);
  929.                         return;
  930.                 }
  931.         }
  932. }