[C] Problemi di compilazione

[Manugal]

Ciao...

Allora ho un progetto da fare per l'università è mi hanno fornito tutta la gerarchia delle directory che si presenta in questo modo:

DBF/
       doc/       contiene la documentazione relativa al progetto
       include/   contiene un header da includere in tutti i moduli del progetto
       Modulo1/  il modulo che devo compilare
       Modulo2/
       Modulo3/
       Modulo4/
       obj/         una volta compilato un modulo qui andrà il file .o della gest. errori
       src/         c'è il sorgente della funzione che gestisce gli errori

Per compilare devo entrare nella cartella Modulo1 e digitare make test. La cartella Modulo1 si presenta così:

Modulo1/
           doc/   documentazione inerente questo Modulo
           include/   ci va un header che creo per contenere costanti, struct e prototipi di funzione
           lib/     dopo la compilazione ci aggiunge il file Modulo1.a
           obj/    dopo la compilazione ci aggiunge i file .o dei sorgenti da me creati
           src/    sorgenti da me creati
           test/   qui dentro ci sono le funzioni per testare la funzionalità dei miei sorgenti
           makefile   penso che sappiate tutti cosa sia :)

Praticamente entro dentro la cartella Modulo1, lancio make test e poi dovrei andare nella cartella test e lanciare ./TestM1 (creato durante la fase di compilazione), solamente che mi dice sempre "Permission Denied" (sia se sono root che user normale) e la cosa strana è che ha anche i permessi di esecuzione

Da cosa può dipendere questo comportamento?

Grazie.

[Manugal]

Se può esservi utile vi faccio vede come è fatto il makefile:

####################
# Comandi e flags
AR=ar
CC=gcc
DEBUG=-g
CCFLAGS= -c $(DEBUG)
ARFLAGS= rc

# Directories
SRCDIR=src
OBJDIR=obj
LIBDIR=lib
TESTDIR=test
ERROBJDIR=../obj
ERRSRCDIR=../src

# Include e altre libs
INCLUDE=-I include -I ../include
LIBS =  

# Elementi da creare
LIBMODULE = Modulo1.a
TESTEXE = TestM1

# Elementi da utilizzare
OBJS =  $(OBJDIR)/LPC_Common.o $(OBJDIR)/LPC_CreateDBF.o $(OBJDIR)/LPC_DeleteDBF.o
TESTOBJ = $(TESTDIR)/TestM1.o
ERROBJ=$(ERROBJDIR)/LPC_Err.o

TARGET=$(LIBDIR)/$(LIBMODULE)
TEST=$(TESTDIR)/$(TESTEXE)

# Dipendenze
$(OBJDIR)/%.o : $(SRCDIR)/%.c
	$(CC) $(CCFLAGS) $(INCLUDE) $< -o $@

$(TESTDIR)/%.o : $(TESTDIR)/%.c
	$(CC) $(CCFLAGS) $(INCLUDE) $< -o $@

$(ERROBJDIR)/%.o : $(ERRSRCDIR)/%.c
	$(CC) $(CCFLAGS) $(INCLUDE) $< -o $@

# Target

$(TARGET): $(OBJS)
	$(AR) $(ARFLAGS) $@ $?

$(TEST): $(TESTOBJ) $(ERROBJ) $(TARGET)
	$(CC) $(TESTOBJ) $(ERROBJ) $(TARGET) -o $(TEST)


all: $(TARGET) $(TEST)

module: $(TARGET)

test: $(TEST)

clean: 
	rm -f $(OBJS)
	rm -f $(TARGET)
	rm -f $(TEST)
	rm -f $(TESTOBJ)

[Manugal]

Ho risolto. Ho fatto partire il progetto dalla partizione dove ho installato Linux (mentre prima lo facevo partire su una partizione FAT32) ed ora va. Grazie lo stesso

[Manugal]

Senza che apro un nuovo thread (perché tanto sempre di compilazione si tratta ) avevo bisogno di un aiuto riguardo la compilazione del mio progetto. Allora vi posto sia il codice della funzione che testa il mio codice sia il mio codice.

Test:

void TestCreate(void)
{
	int ret= 0;
	int NumFields = 0;
	FILE *fp;
	FIELD_DATA_t FieldData[MAX_NUM_FIELDS];
	int len, len1;
	char buf[500], buftest[500];

// Verifica correttezza
	test[numtest].testid = 10113;
	test[numtest].weight = 10;
	strcpy(test[numtest].desc, "CREATE: Verifica correttezza");
	printf("Test:[%d] Peso:[%d] - [%s]\n", test[numtest].testid, test[numtest].weight,test[numtest].desc);
	for(;;)
	{
		ret = -1;

		fp = fopen("ProvaTest.dbf", "r");
		len = fread(buftest, sizeof(char), 500, fp);
		fclose(fp);

		fp = fopen("Prova.dbf", "r");
		len1 = fread(buf, sizeof(char), 500, fp);
		fclose(fp);
		if (len1 != len)
			break;

		// Confronto la prima parte (prima del timestamp)
		len = DBF_NAME_LENGTH+1+2+4+2+2;
		if (memcmp(buf, buftest, len))
			break;

		// Confronto la seconda parte (dopo il timestamp)
		if (memcmp(buf+len+4, buftest+len+4, len1-len-4))
			break;

		ret = LPC_OK;
		break;
	}
	if (ret == LPC_OK)
		test[numtest].passed = 1;
	numtest++;

	Result("CREATE");

}

Mio codice: (lo posto per intero cmq dovrebbe servire solo l'ultima parte dalla fwrite in poi)

#include "LPC_M1_Include.h"
#include "LPC_Include.h"
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <time.h>

int CreateDatabaseFile(char *Name, int NumFields, FIELD_DATA_t *FieldData){
    int test;
    int i;
    char *finale;
    header *h;
    Name=(char *)malloc(sizeof(char)*DBF_NAME_LENGTH);
    FieldData=(FIELD_DATA_t *)malloc(sizeof(FIELD_DATA_t));
    if((Name==NULL) || (cercaErr(Name)==1)){
       char Err1[256];
       (void) sprintf(Err1, "Nome DB nullo o non valido o NumFields<=0");
       LPC_GestioneErrore(LPC_BAD_ARG, "CreateDatabaseFile", Err1);
       return LPC_BAD_ARG;
    }
    if((NumFields<=0) || (NumFields>MAX_NUM_FIELDS)){
       char Err10[256];
       (void) sprintf(Err10, "Nome DB nullo o non valido o NumFields<=0");
       LPC_GestioneErrore(LPC_BAD_ARG, "CreateDatabaseFile", Err10);
       return LPC_BAD_ARG;
    }
    h=(header *)malloc(sizeof(header)*(DBF_FIXED_HEADER_LEN+MAX_NUM_FIELDS*(DBF_FIELD_LEN+MAX_NUM_FIELDS)+2));
    if(h==NULL){
       char Err4[256];
       (void) sprintf(Err4, "Errore allocazione memoria");
       LPC_GestioneErrore(LPC_NO_MEMORY, "CreateDatabaseFile", Err4);
       return LPC_NO_MEMORY;
    }
    if(strlen(Name)>DBF_NAME_LENGTH+1)
       Name[DBF_NAME_LENGTH+1]='\0';
    finale=strcat(Name,DBF_EXTENSION);
    if((test=access(finale,F_OK))==0){
       char Err2[256];
       (void) sprintf(Err2, "File DBF già esistente");
       LPC_GestioneErrore(LPC_FILE_EXISTS, "CreateDatabaseFile", Err2);
       return LPC_FILE_EXISTS;
    }
    FILE *fp=fopen(strcat(Name,DBF_OPEN_EXT),"wb+");
    if(fp==NULL){
       char Err3[256]; 
       (void) sprintf(Err3, "Errore allocazione memoria");
       LPC_GestioneErrore(LPC_NO_MEMORY, "CreateDatabaseFile", Err3);
       return LPC_NO_MEMORY;
    }
    h->NumCampi=(uint16_t) htons(h->NumCampi);
    h->NumCampi=NumFields;
    h->NumRecords=(uint32_t) htonl(h->NumRecords);
    h->NumRecords=0;
    h->dimHeader=(uint16_t) htons(h->dimHeader);
    h->dimHeader=DBF_FIXED_HEADER_LEN+NumFields*(DBF_FIELD_LEN+NumFields)+2;
    h->dimRecord=(uint16_t) htons(h->dimRecord);
    h->dimRecord=0;
    h->timestamp=(uint32_t) htonl(h->timestamp);
    h->timestamp=time(NULL);
    for(i=0; i<NumFields; ++i){
       if(cercaErr(FieldData->Name)==1){
          char Err5[256]; 
          (void) sprintf(Err5, "Valore di uno dei campi non valido: nome, tipo o lunghezza");
          LPC_GestioneErrore(LPC_BAD_FIELD, "CreateDatabaseFile", Err5);
          return LPC_BAD_FIELD;
       }
       if(StringaUguale(FieldData->Name,h,i)==1){
          char Err8[256]; 
          (void) sprintf(Err8, "Valore di uno dei campi non valido: nome, tipo o lunghezza");
          LPC_GestioneErrore(LPC_BAD_FIELD, "CreateDatabaseFile", Err8);
          return LPC_BAD_FIELD;
       }
       strcpy(h->campo[i].name,FieldData->Name);   
       if ((FieldData->FieldType!=CHARACTER) || (FieldData->FieldType!=NUMERIC) || (FieldData->FieldType!=DATE) || (FieldData->FieldType!=LOGICAL)){
          char Err6[256];
          (void) sprintf(Err6, "Valore di uno dei campi non valido: nome, tipo o lunghezza");
          LPC_GestioneErrore(LPC_BAD_FIELD, "CreateDatabaseFile", Err6);
          return LPC_BAD_FIELD;
	}
       h->campo[i].fieldtype=(uint16_t) htons(h->campo[i].fieldtype);
       h->campo[i].fieldtype=FieldData->FieldType;
       h->campo[i].fieldlen=(uint16_t) htons(h->campo[i].fieldlen);
       if((h->campo[i].fieldtype!=CHARACTER) || (h->campo[i].fieldtype!=NUMERIC) || (h->campo[i].fieldtype!=DATE) || (h->campo[i].fieldtype!=LOGICAL)){
          char Err7[256];
             (void) sprintf(Err7, "Valore di uno dei campi non valido: nome, tipo o lunghezza");
             LPC_GestioneErrore(LPC_BAD_FIELD, "CreateDatabaseFile", Err7);
             return LPC_BAD_FIELD;
       }
       if((h->campo[i].fieldtype==CHARACTER) && ((FieldData->FieldLen>=1) && (FieldData->FieldLen<=FIELD_CHAR_LEN)))
           h->campo[i].fieldlen=FieldData->FieldLen;
       if((h->campo[i].fieldtype==NUMERIC) && (FieldData->FieldLen<=FIELD_NUM_LEN)) 
           h->campo[i].fieldlen=FieldData->FieldLen;
       if((h->campo[i].fieldtype==DATE) && (FieldData->FieldLen<=FIELD_DATE_LEN))
           h->campo[i].fieldlen=FieldData->FieldLen;
       if((h->campo[i].fieldtype==LOGICAL) && (FieldData->FieldLen<=FIELD_LOGI_LEN))
           h->campo[i].fieldlen=FieldData->FieldLen;
     }
   int ret=fwrite(h,sizeof(h),(size_t) h->dimHeader,fp);
   if(ret!=h->dimHeader){
      char Err9[256];
             (void) sprintf(Err9, "Errore di scrittura su file");
             LPC_GestioneErrore(LPC_ERR_WRITE, "CreateDatabaseFile", Err9);
             return LPC_ERR_WRITE;
       }
   rename(Name,finale);
   fclose(fp);
   free(fp);
   free(FieldData);
   free(h);
   free(Name);
   return LPC_OK;
   putchar('\n');
}

Mi passa tutti i test tranne questo. Praticamente mi va in Segmentation Fault, ma non capisco cosa mi sono dimenticato di allocare.

Grazie.