[C] Return di una funzione

[Manugal]

Ciao.

Ho alcuni problemi con la return di una mia funzione. Praticamente la funzione è la seguente:

#include "LPC_M2_Include.h"
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>

#define DBF_NAME_LENGTH		10
#define MAX_DBF_OPEN		32
#define DBF_EXTENSION	".dbf"
#define DBF_OPEN_EXT	".$$$"
#define DBF_FILENAME_LENGTH   DBF_NAME_LENGTH+1+3


int OpenDatabaseFile (char *Name){
   int cntOpenDatabases=-1;
   int numerorecords;
   int test;
   char *filename;
   infohandle ihndl[MAX_DBF_OPEN];
   char *filenameopen;
   if((Name==NULL) || (cercaErr(Name))){
       char Err[256];
       (void) sprintf(Err, "Nome DB nullo o non valido");
       LPC_GestioneErrore(LPC_BAD_ARG, "OpenDatabaseFile", Err);
       return LPC_BAD_ARG;
    }
   if(strlen(Name)>=DBF_NAME_LENGTH)
       Name[DBF_NAME_LENGTH+1]='\0';
   filename=(char *)malloc(sizeof(char)*DBF_FILENAME_LENGTH);
   sprintf(filename,"%s%s", Name, DBF_EXTENSION);
   if(filename==NULL){
      char Err[256];
      (void) sprintf(Err, "Errore di allocazione memoria");
      LPC_GestioneErrore(LPC_NO_MEMORY, "OpenDatabaseFile", Err);
      return LPC_NO_MEMORY;
   }
   if(access(filename,F_OK)!=0){
      char Err[256];
      (void) sprintf(Err, "File non esistente o non accessibile");
      LPC_GestioneErrore(LPC_FILE_ACCESS, "OpenDatabaseFile", Err);
      if(filename!=NULL)
         free(filename);
      return LPC_FILE_ACCESS;
   }
   filenameopen=(char *)malloc(sizeof(char)*DBF_FILENAME_LENGTH);
   sprintf(filenameopen,"%s%s", Name, DBF_OPEN_EXT);
   if(filenameopen==NULL){
      char Err[256];
      (void) sprintf(Err, "Errore di allocazione memoria");
      LPC_GestioneErrore(LPC_NO_MEMORY, "OpenDatabaseFile", Err);
      if(filename!=NULL)
         free(filename);
      return LPC_NO_MEMORY;
   }
   if(access(filenameopen,F_OK)==0){
      char Err[256];
      (void) sprintf(Err, "DBF già aperto");
      LPC_GestioneErrore(LPC_DBF_OPEN, "OpenDatabaseFile", Err);
      if(filenameopen!=NULL)
         free(filenameopen);
      if(filename!=NULL)
         free(filename);
      return LPC_DBF_OPEN;
   }
   ++cntOpenDatabases;
   if(cntOpenDatabases>MAX_DBF_OPEN){
      char Err[256];
      (void) sprintf(Err, "Massimo numero di DBF aperti");
      LPC_GestioneErrore(LPC_NO_SPACE, "OpenDatabaseFile", Err);
      if(filename!=NULL)
         free(filename);
      return LPC_NO_SPACE;
   }
   FILE *fp=fopen(filenameopen,"rb+");
   if(fp==NULL){
      char Err[256];
      (void) sprintf(Err, "Errore di allocazione memoria");
      LPC_GestioneErrore(LPC_NO_MEMORY, "OpenDatabaseFile", Err);
      if(filenameopen!=NULL){
         remove(filenameopen);
         free(filenameopen);
      }
      if(filename!=NULL)
         free(filename);
      return LPC_NO_MEMORY;
   }
   ihndl[cntOpenDatabases].handle=cntOpenDatabases;
   test=fseek(fp, sizeof(header)+1, SEEK_SET);
   if(test!=0){
      char Err[256];
      (void) sprintf(Err, "Errore di spostamento su file");
      LPC_GestioneErrore(LPC_ERR_SEEK, "OpenDatabaseFile", Err);
      rewind(fp);
      if(filenameopen!=NULL){
         remove(filenameopen);
         free(filenameopen);
      }
      if(filename!=NULL)
         free(filename);
      return LPC_ERR_SEEK;
   }
   ihndl[cntOpenDatabases].currentRec=1;
   ihndl[cntOpenDatabases].fp=fp;
   sprintf(ihndl[cntOpenDatabases].name, "%s", Name);   
   fclose(fp);
   remove(filenameopen);
   free(filenameopen);
   free(filename);
   return ihndl[cntOpenDatabases].handle;
   putchar('\n');
}

Il codice che testa la mia funzione invce è il seguente:

/* Test per verificare la funzionalità della funzione */
int handle;
remove("Prova.$$$"); /* Il file con questa estensione identifica un file aperto */
handle = OpenDatabaseFile("Prova");
if (handle >= 0)
   OK TEST PASSATO!

/* Test per verificare che il file sia aperto */
int ret;
ret = OpenDatabaseFile("Prova");
if(ret<0)
   OK TEST PASSATO!

Il problema è che in questi ultimi due test mi dà sempre l'errore relativo a "Errore di allocazione memoria". Inserendo, per provare, alcune printf qua e là mi sono accorto che praticamente questo errore mi viene tornato dal file pointer fp. Quindi, come controprova, ho inserito un controllo per verificare se il file con estensione .$$$ esistesse e infatti come pensavo, mettendo questo controllo, mi ritorna l'errore "File inesistente". Questo mi sembra molto strano. Voi che ne dite?

Grazie e scusate per la lunghezza del post ma ho cercato di farvi vedere il problema in modo più chiaro.

[oregon]

Se ho capito, intendi dire che la open

FILE *fp=fopen(filenameopen,"rb+");

fallisce?

Hai controllato il valore della filenameopen in modalita' debug (passo passo) prima che venga passata alla fopen ?

E inoltre, prova a scrivere subito dopo la fopen

int le = GetLastError();

e mostra il valore della le dopo la chiamata.

[Manugal]

Praticamente si la fopen fallisce, ma fallisce perché filenameopen non esiste (secondo i controlli che ho descritto prima). Ed è questo che non mi torna perché la funzione di testo chiama la OpenDatabase passandogli la stringa "Prova" (che sarà il nome del file). Io all'interno della funzione gli dico esplicitamente di fare:

sprintf(filenameopen,"%s%s", Name, DBF_OPEN_EXT);

Non è che forse c'è qualche free di troppo?

[Manugal]

Con il debugger ddd praticamente se carico il codice sorgente dei test non me lo carica tutto ma solamente una parte

[oregon]

Che vuoi dire con "filenameopen non esiste" ?

E' la malloc della stringa filenameopen che fallisce?

Perche' non inserisci delle printf alla fine di ogni fase per controllare "esattamente" dove termina l'esecuzione?

[Manugal]

Allora io praticamente ho messo questo controllo prima della fopen:

if(filenameopen==NULL)
  return "ERRORE";

Visto che eseguendo quel test mi ritorna appunto l'errore allora significa che la fopen fallisce perché filenameopen è NULL (cioè non esiste).

Quando dico che non esiste dico che siccome filenameopen è la stringa che identifica un file aperto, avendo questa stringa a NULL sta a significare che quel file non è presente.

[Manugal]

Ho risolto. Faceva così perché il file lo aprivo in modalità rb+ invece che wb+. Ma rb+ non significa lettura e scrittura in binario?