I need help. I apologize for my bad English. I hope to explain exactly my problem. 
I have programmed a client / server program in C Unix. 
The server is multi-threading.
I had no problems with the server until it started to manipulate files. 
Be careful, though, because the real problem is not in the file manipulation: the server manipulates files without problems. It opens and closes these files several times and reads and writes smoothly.
The real problem: when the client, who has used the services that manipulate files, disconnects himself or whether a new client wants to connect when a previous client has used the services of file manipulation, the server accepts the connection, launches the pthread\_create function but this fails to complete the creation of the new thread. Then the startup function is not executed. I have realized this behavior because pthread\_join returns the error "invalid argument" and my startup function does not print "SERVER: New Thread created!" and the same pthread\_create NOT returns the "value > 0" for errors.
I want to clarify that when the server is started and after it are started any number of clients, everything works ok. But as soon as one client invokes a service that manipulates file, then the server is not able to finish the pthread\_create function. 
Why is this? I am days I try to understand what happens. Who helps me?
This is the function that creates the new thread/s:

```
void gestisciConnessioni(int serverfdin, int numeroconnessioniIn, struct sockaddr_in *clientindirizzoin, int *connessioneclientin) {

    //Variabile/i locale/i:
    struct sockaddr *clientindirizzoptr; //Puntatore alla Struttura indirizzo del client
    int clientindirizzodim; //Dimensione dell'indirizzo del client
    char *indirizzoip;
    tipoinfoconnessioneclient *unainfoclient = NULL;
    pthread_t tid;
    int errore = -1;

    //Blocco codice:
    //Il server si mette in ascolto dei clients:

    if ((listen(serverfdin, numeroconnessioniIn)) != 0) {
        printf("SERVER: Attenzione, listening... fallito!\n");
        exit(1);
    }
    //Preparazione indizzamento client:
    clientindirizzoptr = (struct sockaddr *) clientindirizzoin;
    clientindirizzodim = sizeof ((*clientindirizzoin));
    //Inizio concorrenza:
    //Il Server accetta la connessione del client;
    //Verifica la presenza di errori;
    //Inizia l'elaborazione.
    while (1) {
        *connessioneclientin = accept(serverfdin, clientindirizzoptr, &clientindirizzodim);
        if ((*connessioneclientin) > -1) {
            indirizzoip = inet_ntoa((*clientindirizzoin).sin_addr);
            printf("SERVER: Nuova connessione stabilita con %s.\n", indirizzoip);
            unainfoclient = (tipoinfoconnessioneclient *) (malloc(sizeof (tipoinfoconnessioneclient)));
            (*unainfoclient).descrittorefile = *connessioneclientin;
            (*unainfoclient).indirizzoip = indirizzoip;
            errore = pthread_create(&tid, NULL, elaborazioneServizi, (void *) (unainfoclient));
            if (errore != 0) {
                printf("SERVER: Impossibile creare un nuovo thread!\n");
                printf("(SERVER, ERRORE: %s)\n", strerror(errore));
                exit(1);
            }
            pthread_detach(tid);
            errore = pthread_join(tid, NULL);
            if (errore != 0) {
                printf("SERVER: Impossibile attendere la terminazione del thread!\n");
                printf("(SERVER, ERRORE: %s)\n", strerror(errore));
                exit(1);
            }
        } else {
            printf("SERVER: Attenzione, connessione con %s... fallita!\n", indirizzoip);
            exit(1);
        }
    }
}

```

This is the starting-function:

```
void *elaborazioneServizi(void *args) {

    //Varibile/i locale/i:
    tipoinfoconnessioneclient unainfo;
    tipoinfoutente giocatore;
    int n;
    char messaggioin[100];
    char **messaggioSplittato = NULL;
    int risposta = 0;
    int scelta = -1;
    fd_set insiemelettura;
    int fdmassimo;

    //Blocco codice:
    unainfo = *((tipoinfoconnessioneclient *) args);
    //**************************************************************************
    //Inizializzazione giocatore:
    //**************************************************************************
    giocatore.ip = unainfo.indirizzoip;
    giocatore.nome = " ";
    giocatore.stato = 2;
    giocatore.ultimaposizione.x = -1;
    giocatore.ultimaposizione.y = -1;
    //**************************************************************************
    printf("SERVER: Sto dentro la funzione di avvio!\n");
    fdmassimo = unainfo.descrittorefile;
    FD_SET(unainfo.descrittorefile, &insiemelettura);
    printf("SERVER: Nuovo Thread appena creato!\n");
    select(fdmassimo + 1, &insiemelettura, NULL, NULL, NULL);
    while (risposta == 0) {
        if (FD_ISSET(unainfo.descrittorefile, &insiemelettura)) {
            //*****************************************************************
            if ((n = read(unainfo.descrittorefile, messaggioin, 100)) == -1) {
                printf("SERVER: Errore in ricezione messaggio!\n");
                exit(1);
            }
            while (n == 0) {
                pthread_cond_wait(&condizione, &mutex);
            }
            pthread_cond_signal(&condizione);
            printf("SERVER: Messaggio ricevuto per SWICTH: %s\n", messaggioin);
            messaggioSplittato = messaggioAvettore(messaggioin, 5, 50);
            scelta = atoi(messaggioSplittato[0]);
            switch (scelta) {
                case 0:
                    daiUscita(unainfo.descrittorefile, &risposta);
                    break;
                case 1:
                    daiRegistrazione(unainfo.descrittorefile, messaggioSplittato);
                    break;
                case 2:
                    daiLogin(unainfo.descrittorefile, messaggioSplittato);
                    break;
                default:
                    printf("SERVER: Servizio, non disponibile!\n");
                    risposta = 1;
                    break;
            }
            //*****************************************************************
        }
    }
    printf("SERVER: Thread... eliminato!\n");
    close(unainfo.descrittorefile);
    pthread_exit(NULL);
}

```

This is the function that performs the manipulation of a file.txt (the shortest among other):

```
void daiLogin(int canalecomunicazionein, char **messaggioin) {

    //Variabile/i locale/i:
    int dimensionemessaggio = (NICKNAME_DIMENSIONE + PASSWORD_DIMENSIONE) + 2;
    char *nomeutente = NULL;
    char *password = NULL;
    char messaggioletto[NICKNAME_DIMENSIONE + PASSWORD_DIMENSIONE];
    char **messaggiosplittato = NULL;
    char *stringaconvalidata = NULL;
    char *messaggioout = NULL;
    char tmp[3];
    int trovato = 0; //Trovato indica un utente registrato (1) oppure da registrare (0)
    int *fd = NULL;
    int n = -1;

    //Blocco codice:
    pthread_mutex_lock(&mutex);
    printf("SERVER: Sto eseguendo la funzione daiLogin()\n");
    nomeutente = messaggioin[1];
    password = messaggioin[2];
    printf("SERVER: (%s,%s)\n", nomeutente, password);
    fd = inizializzaFileInLettura("registrazioni.txt");
    if (*fd != -1) {
        lseek(*fd, 0, SEEK_SET);
        while ((n = read(*fd, messaggioletto, dimensionemessaggio))&&(trovato == 0)) {
            messaggiosplittato = messaggioAvettore(messaggioletto, 3, dimensionemessaggio);
            if ((strcmp(messaggiosplittato[0], nomeutente) == 0)&&(strcmp(messaggiosplittato[1], password) == 0)) {
                trovato = 1;
            }
            free(messaggiosplittato);
            messaggiosplittato = NULL;
        }
        close(*fd);
        free(fd);
        fd = NULL;
        snprintf(tmp, sizeof (tmp), "%d", trovato);
        messaggioout = componiMessaggio(tmp, "X", "X", "X", "X", 10);
        n = write(canalecomunicazionein, messaggioout, 10);
        pthread_mutex_unlock(&mutex);
    }
}

```

> 
> pthread\_create not go out error/s. Only error come from pthread\_join
>  that say "invalid argument". I use one FD (only) that is always open
>  and close (every time).
> 
> 
>