how to read and write from .dat file in verifone

Question

I want to read and write a text or .dat file in verifone to store data on it. How can I make it ? here is my code

int main()
{
  char buf [255];
  FILE *tst;
  int dsply = open(DEV_CONSOLE , 0);
  tst = fopen("test.txt","r+");
  fputs("this text should write in file.",tst);
  fgets(buf,30,tst);

  write(dsply,buf,strlen(buf));
  return 0;
}

Answer 1

Chapter 3 of the "Programmers Manual for Vx Solutions" ("23230_Verix_V_Operating_System_Programmers_Manual.pdf") is all about file management and contains all the functions I typically use when dealing with data files on the terminal. Go read through that and I think you'll find everything you need.

To get you started, you'll want to use open() together with the flags you want

• O_RDONLY (read only)
• O_WRONLY (write only)
• O_RDWR (read and write)
• O_APPEND (Opens with the file position pointer at the end of the file)
• O_CREAT (create the file if it doesn't already exist),
• O_TRUNC (truncate/delete previous contents if the file already exists),
• O_EXCL (Returns error value if the file already exists)

On success, open will return a positive integer that is a handle which can be used for subsequent access to the file. On failure, it returns -1;

When the file is open, you can use read() and write() to manipulate the contents.

Be sure to call close() and pass in the return value from open when you are done with the file.

Your example above would look something like this:

int main()
{
  char buf [255];
  int tst;
  int dsply = open(DEV_CONSOLE , 0);
  //next we will open the file.  We will want to read and write, so we use
  // O_RDWR.  If the files does not already exist, we want to create it, so
  // we use O_CREAT.  If the file *DOES* already exist, we want to truncate
  // and start fresh, so we delete all previous contents with O_TRUNC
  tst = open("test.txt", O_RDWR | O_CREAT | O_TRUNC);

  // always check the return value.
  if(tst < 0)
  {
     write(dsply, "ERROR!", 6);
     return 0;
  }
  strcpy(buf, "this text should write in file.")
  write(tst, buf, strlen(buf));
  memset(buf, 0, sizeof(buf));
  read(tst, buf, 30);
  //be sure to close when you are done
  close(tst);

  write(dsply,buf,strlen(buf));
  //you'll want to close your devices, as well
  close(dsply);
  return 0;
}

Your comments also ask about searching. For that, you'll also need to use lseek with one of the following which specifies where you are starting from:

• SEEK_SET — Beginning of file
• SEEK_CUR — Current seek pointer location
• SEEK_END — End of file

example

SomeDataStruct myData;
...
//assume "curPosition" is set to the beginning of the next data structure I want to read
lseek(file, curPosition, SEEK_SET);
result = read(file, (char*)&myData, sizeof(SomeDataStruct));
curPosition += sizeof(SomeDataStruct);
//now "curPosition" is ready to pull out the next data structure.

NOTE that the internal file pointer is already AT "curPosition", but doing it this way allows me to move forward and backward at will as I manipulate what is there. So, for example, if I wanted to move back to the previous data structure, I would simply set "curPosition" as follows:

curPosition -= 2 * sizeof(SomeDataStruct);

If I didn't want to keep track of "curPosition", I could also do the following which would also move the internal file pointer to the correct place:

lseek(file, - (2 * sizeof(SomeDataStruct)), SEEK_CUR);

You get to pick whichever method works best for you.