Weird behaviour with fscanf in C program - c

Question

I would like to know in below code snippet why fscanf is throwing -1 in the middle of the execution and due to this I am not getting desired output.
#include<stdio.h>
#include<string.h>
#include<malloc.h>
int main(){
FILE *fp=NULL;
char fname[200], cmd[200];
int i=0,j=0;
system("ls /tmp/*.msg -1rt > /tmp/xyz.txt");
fp=fopen("/tmp/xyz.txt","r+");
if(fp!=NULL){
i=fscanf(fp,"%s",fname);
while(i!=EOF){
sleep(2);
printf("Filename is:'%s'\n",fname);
sprintf(cmd, "rm -rf %s; touch /tmp/a_%d_new.msg",fname,j++);
system(cmd);
memset(fname, 0, 200);
memset(cmd,0, 200);
system("ls /tmp/*.msg -rt1 > /tmp/xyz.txt");
i=fscanf(fp,"%s",fname);// fscanf will return error after some iterations
printf("The I Value is: '%d'\n",i);
}
}
if(fp!=NULL)
fclose(fp);
return 0;
}
Reproducing steps:
Create a /tmp/xyz.txt file (no data)
> xyz.txt ( make it empty if any data there)
rm -rf *.msg
touch a.msg b.msg c.msg d.msg e.msg f.msg
Here I am expecting gracefull exit from while loop . in current scenario it is not happening due to fscanf function.

Answer 1

It occurred to me that I did a better job at explaining this the second time, so here is my better explanation:
FILE is a stateful device that includes an EOF flag and a buffer. If when buffering, end of file is reached then it might be queued in the buffer, and the buffer won't be updated until it's exhausted. What is essentially happening is a copy of part of the file is made in memory, and when you make external changes to that file the copy in memory becomes out of sync.
The solution is to synchronise the buffer somehow. If you change the file position, then the standard library will have no choice but to update the cached version and reset the EOF flag. You have two options:
rewind makes sense if you intend to use < the way you have, because you're overwriting the file each loop, so you'll want to read from the start of the file.
fgetpos, followed by your fscanf, followed by fsetpos only makes sense if you intended to use << instead of <, because << concatenates to the end of the file, so when fscanf fails you'll be able to pick up where you left off after you update the file.
In my first answer, I also posed a question about the design you have chosen. The gist of that is, whichever of the above choices you make, fscanf should not normally produce an EOF value unless one of your system calls fails to create files. I think you have gathered this based on a conversation we had below. Unfortunately I can't make any suggestions unless you give a more broad overview on what problem your program is supposed to solve... All I can say is, while(i!=EOF) doesn't make a whole lot of sense.
Having said that, it's unusual (kind of wasteful, possibly erroneous and insecure) for C code to be calling system... Again, I need to know what problem your program is expected to solve to make a better suggestion.