Reading from a file causes an error at the last line - c

Question

The problem that I have is that, once I want to read the file, the program prints out everything, but it doesn't read the last element of the file.
So in the file lets say I have:
admin:pass:1000:off
test:testxx:1000:off
ret:passx:1000:off
It prints out the first 2 lines and then it says "End of the buffer" (its just a printf that I put into the code in order to understand where is the problem).
After printing out "End of the buffer" it prints out the last line..
What am I doing wrong?
#include <stdlib.h> /* exit */
#include <errno.h> /* perror */
#include <stdio.h>
#include <unistd.h> /* write, read, close*/
#include <sys/types.h>
#include <sys/stat.h> /*open */
#include <fcntl.h>
#include <string.h>
#define MAX 500
struct utente{
char username[MAX];
char password[MAX];
int gettoni;
char stato[MAX];
struct utente *next;
};
void menu(int);
struct utente* lettura_file(struct utente *);
struct utente* ins_coda(struct utente *t, char username[], char password[], char gettoni[], char stato[]);
void stampa_lista(struct utente*);
struct utente* elabora(struct utente *top, char buffer[]);
int check(struct utente *, char *);
void aggiornamento_file(struct utente *top);
int main(){
while(1){
char scelta[MAX], stringa[MAX];
int i=0, res=0;
struct utente *TOP=NULL;
printf("1. STAMPA LISTA\nInserisci scelta --> ");
scanf("%s", scelta);
i=atoi(scelta);
switch(i){
case 1:
TOP=lettura_file(TOP);
stampa_lista(TOP);
/*printf("Inserisci stringa da trovare: ");
scanf("%s", stringa);
res=check(TOP, stringa);
if(res==1)
aggiornamento_file(TOP);
*/
break;
}
}
return 0;
}
struct utente* lettura_file(struct utente *top){
int fd, nread;
char buffer[MAX];
fd=open("utenti.txt", O_RDONLY);
if(fd==-1){
perror("ERRORE APERTURA FILE");
return top;
}
while((nread=read(fd, buffer, MAX)>0)){
top=elabora(top,buffer);
}
close(fd);
return top;
}
struct utente* elabora(struct utente *top, char buffer[]){
char username[MAX], password[MAX], gettoni[MAX], stato[MAX];
int i=0;
int j=0; //indice username
int k=0; //indice password
int t=0; //indice gettoni
int x=0; //indice stato
int count=0;
printf("Inzio buffer:\n%sfine buffer\n" ,buffer);
while(buffer[i]!='\0'){
//ELABORO NOME
while(buffer[i]!=':'){
username[j]=buffer[i];
j++;
i++;
}
username[j]='\0';
i++;
//ELABORO COGNOME
while(buffer[i]!=':'){
password[k]=buffer[i];
k++;
i++;
}
password[k]='\0';
i++;
//ELABORO GETTONI
while(buffer[i]!=':'){
gettoni[t]=buffer[i];
t++;
i++;
}
gettoni[t]='\0';
i++;
while(buffer[i]!='\n' && buffer[i]!='\0'){
stato[x]=buffer[i];
x++;
i++;
}
stato[x]='\0';
if(buffer[i]=='\n')
i++;
if(buffer[i]=='\0'){
printf("\nEnd of the buffer %c\n", buffer[i]);
printf("Fine%s %s %s %s\n\n", username, password, gettoni, stato);
top=ins_coda(top, username, password, gettoni, stato);
return top;
}
printf("Utente %d, %s %s %s %s\n\n", count, username, password, gettoni, stato);
top=ins_coda(top, username, password, gettoni, stato);
bzero(username, MAX);
bzero(password, MAX);
bzero(gettoni, MAX);
bzero(stato, MAX);
j=0;
k=0;
t=0;
x=0;
}
return top;
}
struct utente* ins_coda(struct utente *t, char username[], char password[], char gettoni[], char stato[]){
struct utente *p, *top;
int n_gettoni;
p=(struct utente*)malloc(sizeof(struct utente));
strcpy(p->username, username);
strcpy(p->password, password);
n_gettoni=atoi(gettoni);
p->gettoni=n_gettoni;
strcpy(p->stato, stato);
p->next=NULL;
if(t==NULL)
return p;
top=t;
while(t->next!=NULL)
t=t->next;
t->next=p;
return top;
}
void stampa_lista(struct utente *TOP){
int i=1;
while(TOP!=NULL){
printf("Utente %d:\n Username: %s\nPassword: %s\nGEttoni: %d\nStato: %s\n", i, TOP->username, TOP->password, TOP->gettoni, TOP->stato);
TOP=TOP->next;
i++;
}
return;
}
int check(struct utente *top, char stringa[]){
int len=strlen(stringa);
while(top!=NULL){
if(strncmp(top->username, stringa, len)==0){
strcpy(top->stato, "on");
printf("OK\n");
return 1;
}else{
printf("KO\n");
return 0;
}
top=top->next;
}
return 0;
}
void aggiornamento_file(struct utente *top){
char username[MAX], password[MAX], gettoni[MAX], stato[MAX]="";
int fd;
fd = open("utenti.txt", O_WRONLY |O_TRUNC, S_IRUSR | S_IWUSR);
if(fd==-1){
perror("ERROR apertura file utenti!");
exit(1);
}else{
while(top!=NULL){
strcpy(username, top->username);
strcpy(password, top->password);
sprintf(gettoni, "%d", top->gettoni);
strcpy(stato, top->stato);
write(fd, username, strlen(username));
write(fd, ":", 1);
write(fd, password, strlen(password));
write(fd, ":", 1);
write(fd, gettoni, strlen(gettoni));
write(fd, ":", 1);
write(fd, stato, strlen(stato));
write(fd, "\n", 1);
top=top->next;
}
}
close(fd);
return;
}

Answer 1

Unless your file contains binary data and you actually put a 0x00 at the end of it, it shouldn't contain any zeros for the buffer[i] != '\0' check.
C strings are NULL terminated, but it's not usual to include this terminating zero when writing to text files. Text file editors don't do that either.
One problem is that you are not initializing the buffer variable.
Probably you are getting zeros by chance when the program allocates the 500 bytes for it.
One way you can initialize a buffer with zeros is by setting it's first element to zero at the declaration:
char buffer[MAX] = {0,};
Now, if I understood correctly your doubt, I don't see that the end of the file is happening before the program reads the last entry. What is happening there is that the program is printing the message with the last line after it prints the message of the end of the file. But the program did read the last line before the end of the file and stored it in the variables used by printf.
Confusion typically arises in codes with big functions. elabora function is big, complicated and hard to debug. You can make it simpler if you break it in smaller functions. I believe it gets much better if it reads lines instead of the whole file. I rewrote it quickly as an example:
void get_field(char **src, char dst[MAX])
{
int j = 0;
while (*(*src) && *(*src) != ':' && *(*src) != '\n') {
dst[j++] = *(*src);
(*src)++;
}
}
struct utente* elabora(struct utente *top, char *line, ssize_t line_len, int *count)
{
char username[MAX] = {0,};
char password[MAX] = {0,};
char gettoni[MAX] = {0,};
char stato[MAX] = {0,};
get_field(&line, username);
get_field(&line, password);
get_field(&line, gettoni);
get_field(&line, stato);
printf("Utente %d, %s %s %s %s\n\n", ++(*count), username, password, gettoni, stato);
top = ins_coda(top, username, password, gettoni, stato);
return top;
}
It can now be called from a function that reads the file by lines using geline function:
struct utente* lettura_file(struct utente *top)
{
FILE *file = NULL;
char *buffer = NULL;
size_t buffer_size = 0;
int count = 0;
ssize_t n_read = 0;
if ((file = fopen("utenti.txt", "r")) == NULL) {
perror("ERRORE APERTURA FILE");
return top;
}
while ((n_read = getline(&buffer, &buffer_size, file)) > 0) {
top = elabora(top, buffer, n_read, &count);
}
if (buffer != NULL)
free(buffer);
if (file != NULL)
fclose(file);
return top;
}
These functions are still not safe, but I believe they have better readability and tend to be easier do debug. strtok would be better than parsing tokens this way. Using other functions for opening and reading the file, as suggested by the questions' comments, would also improve the code.