Very Computer

I'm trying to write a program that makes an data file, with records
(structs) and makes an index of them in a seperated file.
The first two function seem to work very well but the last function that
needs too read from the file and return a value from the first record
(dedicated for file info) then the whole progam hangs.

I've striped the function so it only try's to read the first record, and it
hangs on the funcion call read. Does anyone knows what is the error in this
code.

All function resides in unistd.h, it's the first time i'm programming under
Linux.

#include "idfile.h"

int         init_indexFile    (char* fName , size_t  size){
  rec newR;
  size_t length = sizeof(rec);
  int i;
  int filedescriptor, indexfile ;
  char datName[255], idxName[255] ;
  strcpy(datName, fName );
  strcat(datName, ".dat");
  strcpy(idxName, fName );
  strcat(idxName, ".idx");
  newR.key = size;
  newR.next = 1;
  strncpy(&(newR.data),"", DATAL);
  filedescriptor = open ( datName , O_WRONLY | O_CREAT , 0666);
  if (filedescriptor == -1) { perror("create"); return 0; }
  write(filedescriptor, &newR,length);                          
  for(i=0; i<=size; i++){
    if (i != size){ newR.next = i+1;} else newR.next=-1;
    if (write(filedescriptor, &newR, length) != length) { perror("write
1"); };
  }
  indexfile = open( idxName, O_WRONLY | O_CREAT , 0666 );
  close (filedescriptor);
  close (indexfile);

Quote:}

indexFile*  open_indexFile(char* fName){
  char idxName[255], datName[255];
  indexFile *index =  (indexFile*)malloc(sizeof(indexFile));
  strcpy(idxName, fName);
  strcat(idxName, ".idx");
  strcpy(datName, fName);
  strcat(datName, ".dat");
  if (index->idxfile = open (idxName, O_RDWR ) == -1){ perror("open
idxfile"); return NULL;}
  if (index->datfile = open (datName, O_RDWR ) == -1){ perror("open
datfile"); return NULL;}
  return index;

Quote:}

void  close_indexFile   (indexFile* iFile){
  close(iFile->idxfile);
  close(iFile->datfile);

Quote:}

unsigned    sizeOf_indexFile  (indexFile* iFile){
  rec *tmprec = (rec*)malloc(sizeof(rec));
  size_t length = sizeof(rec);
  //simple version only read first record no return to previous point
  lseek(iFile->datfile, 0,SEEK_SET );

/************************************
the program keeps* on the next instruction
*************************************/
  read(iFile->datfile, tmprec, length);
  return 0;

Quote:}

/*************************************
** and here a few lines from main.c **
**************************************/

int main(){
  indexFile *idx;
  init_indexFile    ("hlp",10000);
  idx = open_indexFile("hlp");
  if (idx == NULL ) printf("Nok/n");
  printf("%d\n", sizeOf_indexFile(idx));
  close_indexFile(idx);

Quote:}

Use the 'n' versions of these functions... (strncpy, strncat) ... you
have a potential buffer overflow exploit here.

Quote:>     if (i != size){ newR.next = i+1;} else newR.next=-1;

You could probably make this more readable.

Quote:>   char idxName[255], datName[255];
>   indexFile *index =  (indexFile*)malloc(sizeof(indexFile));
>   strcpy(idxName, fName);
>   strcat(idxName, ".idx");
>   strcpy(datName, fName);
>   strcat(datName, ".dat");

Another potential buffer overflow.

Quote:>   if (index->idxfile = open (idxName, O_RDWR ) == -1){ perror("open
>   if (index->datfile = open (datName, O_RDWR ) == -1){ perror("open

This is definitely a problem.  It should be:

    if( (index->datfile = open(datName, O_RDWR)) == -1 ) { ... }

Fix this problem first.

--
 Joshua Jones
 josh(at)homemail.com  |  jonesjos(at)us.ibm.com

As Joshua pointed out this is where your problem lies, not with the read(2)
function. The reason the read(2) function is* is that it is attempting
to read from file descriptor zero (stdin) and hence your terminal. The reason
it is reading from file descriptor zero are the two statements above.

You need to grab your book on the C language and review the section that
discusses operator precedence. But I'll give you a hint. Note that zero
represents "false" in a boolean condition. Since the if() condition is false
(i.e., zero) the error handling blocks are not executed making it appear that
the opens were successful. Which they were. Because had the opens failed then
the if() condition would have been true. Need another hint? Consider the two
ways the if() condition statement could be parenthesized. Then consider that
the implied parenthesisation you expected is not the one the compiler used.

in comp.unix.programmer i read:

better: replace them with snprintf's.

--
bringing you boring signatures for 17 years