Visualizzazione dei risultati da 1 a 3 su 3
  1. #1

    [C] - thread_get_info_callback: Assertion `thread_info != NULL' failed.

    Salve a tutti!

    Ho scritto un'applicazione client/server in linguaggio C su linux.

    Il server gestisce un array di partite. Quando un client crea una nuova partita questa viene memorizzata nell'array.

    Nel menu posso visualizzare le opzioni della partita.

    Se ci sono 4 partite ATTIVE, cioè in attesa di un avversario, e un quinto client si collega e utilizza la funzione di visualizzazione delle opzioni delle partite ATTIVE, il server va in segmentation fault.

    Per i primi 4 non succede niente, perchè il quinto fa cascare tutto?

    Con il gdb ho provato a mettere dei breakpoint nella funzione che si occupa di stampare le opzioni, e non ho rilevato niente di anomalo nel passaggio dei parametri.

    Per i primi 4 va sempre bene, al quinto si impalla tutto!

    Non riesco proprio a capire come fare...

    Avete mai visto questo errore?

    warning: Can't attach LWP 1094852713: No such process
    /build/buildd/gdb-6.8/gdb/linux-thread-db.c:302: internal-error: thread_get_info_callback: Assertion `thread_info != NULL' failed.
    A problem internal to GDB has been detected,
    further debugging may prove unreliable.
    Quit this debugging session? (y or n) EOF [assumed Y]
    /build/buildd/gdb-6.8/gdb/linux-thread-db.c:302: internal-error: thread_get_info_callback: Assertion `thread_info != NULL' failed.
    A problem internal to GDB has been detected,
    further debugging may prove unreliable.
    Create a core file of GDB? (y or n) y

    Qualcuno potrebbe aiutarmi a trovare dove sta il problema?

    Se serve del codice fatemi sapere... A presto!

  2. #2
    Utente di HTML.it L'avatar di XWolverineX
    Registrato dal
    Aug 2005
    residenza
    Prague
    Messaggi
    2,565
    Senza vedere il codice non possiamo fare proprio niente.
    "Se proprio devono piratare, almeno piratino il nostro." (Bill Gates)

    "Non è possibile che 2 istituzioni statali mi mettano esami nello stesso giorno." (XWolverineX)

    http://xvincentx.netsons.org/programBlog

  3. #3
    Server.c
    Codice PHP:
    else if(strcmp(buffer,"new")==0)
    {    
        
    pthread_mutex_lock(&m_pos);
            
    pos trovaPartitaLibera(battagliaNavalestatistiche.partiteMax);
                
        if(
    pos == -1)
        {
            
    write_socket(fd"partiteMax\0");
            
    pthread_mutex_unlock(&m_pos);        
        }
        else
        {        
            
    battagliaNavale[pos].opzioni.statoPartita ATTESA;
            
    write_socket(fd"postoOK\0");
            
    pthread_mutex_unlock(&m_pos);
                    
            
    // Legge il nome del campo di Battaglia dal client
            
    read_socket(fdbuffer);
                    
            
    // Controllo se il client si è disconnesso mentre inseriva il combatField
            
    if(strcmp(buffer"int")==0)
            {
                
    pthread_mutex_lock(&m_coda);                    
                    
    eliminaNodo(&codafd);
                    
    nConnessioni--;
                
    pthread_mutex_unlock(&m_coda);
                
    initGioco(&(battagliaNavale[pos]));
            }
            else
            {
                
    flag verificaNomePartita(battagliaNavalestatistiche.partiteMaxbuffer);
                                    
                if(
    flag==0)
                {
                    
    initGioco(&(battagliaNavale[pos]));
                    
    write_socket(fd"partitaEsistente\0");
                }
                else
                {
                    
    write_socket(fd"partitaNonPresente\0");
                    while(
    1)
                    {
                        
    // Controllo se il client si è disconnesso mentre inseriva le opzioni della partita
                        
    read_socket(fdbuffer);
                        if(
    strcmp(buffer"int")==0)
                        {
                            
    pthread_mutex_lock(&m_coda);                    
                                
    eliminaNodo(&codafd);
                                
    nConnessioni--;    
                            
    pthread_mutex_unlock(&m_coda);                    
                            
    initGioco(&(battagliaNavale[pos]));    
                        }
                        else
                        {
                            
    write(fd, &(statistiche.durataMax), sizeof(int));
                            
    read_socket(fdbuffer);
                            if(
    strcmp(buffer"datiConfermati")==0)
                                break;
                        }
                    }
                            
                    
    read(fd, &(battagliaNavale[pos]), sizeof(PARTITA));
                            
                    
    dimCampo[pos].componenti = (int*)malloc(battagliaNavale[pos].opzioni.dimensione*sizeof(int));

                    for(
    i=0i<battagliaNavale[pos].opzioni.dimensionei++)
                        
    read(fd, &(dimCampo[pos].componenti[i]), sizeof(int));
                            
                    
    dimCampo[pos].dimensioneCampo = (char*)malloc(256*sizeof(char));
                    
    calcolaDimensioneCampo(dimCampo[pos].componentibattagliaNavale[pos].opzioni.dimensionedimCampo[pos].dimensioneCampo);
                            
                    
    read(fd, &(battagliaNavale[pos].players[0]), sizeof(GIOCATORE));
                            
                    
    battagliaNavale[pos].players[0].fd fd;
                            
                    
    pthread_mutex_lock(&m_stats);
                        
    // Aggiorna il numero di partite in attesa
                        
    statistiche.partiteInAttesa++;
                    
    pthread_mutex_unlock(&m_stats);
                            
                    
    battagliaNavale[pos].opzioni.statoPartita ATTIVO;
                                                        
                    
    // Aspetta che un avversario entri in partita
                    
    while(1)
                    {
                        
    write(fd, &(battagliaNavale[pos].opzioni.statoPartita), sizeof(int));
                        
    read_socket(fdbuffer);
                        if(
    strcmp(buffer"int")==0)
                        {
                            
    pthread_mutex_lock(&m_coda);                    
                                
    eliminaNodo(&codafd);
                                
    nConnessioni--;    
                            
    pthread_mutex_unlock(&m_coda);
                            
                            
    pthread_mutex_lock(&m_stats);
                                
    statistiche.partiteInAttesa--;
                            
    pthread_mutex_unlock(&m_stats);
                                    
                            
    initGioco(&(battagliaNavale[pos]));    
                                    
                            break;
                        }
                        else if(
    strcmp(buffer"OK")==0)
                            break;
                    }
                    return 
    0;
                }
            }
        }

    Client.c

    Codice PHP:
    int nuovaPartita(char *combatName)
    {
           
        
    int flag 0i;
        
        
    PARTITA nuova;
        
        
    initGioco(&nuova);
        
        
    flag impostaOpzioni(&nuovacombatName);
        
        if(
    flag==1)
        {
            
    write(sock_fd, &nuovasizeof(PARTITA));
            
            for(
    i=0i<nuova.opzioni.dimensionei++)
                
    write(sock_fd, &componenti[i], sizeof(int));
                
            
    write(sock_fd, &nuova.players[0], sizeof(GIOCATORE));    
        }
        
        return 
    flag
    }


    int impostaOpzioni(PARTITA *new, char *combatName)
    {
        
    char buffer[4096], combatField[128], fileName[32], *dimensioneCampo NULL;
        
        
    int iflagdurata;
        
        do
        {
            
    azzeraStringa(bufferstrlen(buffer));
            
    intestazione(buffer);
            
    printf("%s\n "buffer);

            
            
    printf("Creazione Nuova Partita\n ");
            
            
    printf(" Inserisci il nome del campo di battaglia -> ");
            
    azzeraStringa(combatField16);
            
    GetString(combatField15);
            
    strcat(combatField"\0");
            
    printf("\n\n Il campo di battaglia è stato chiamato -> %s"combatField);
            
    flag chiediConferma();
        }while(
    flag==0);
        
        
    // Comunica il combatField al server
        
    write_socket(sock_fdcombatField);
        
        
    azzeraStringa(bufferstrlen(buffer));
        
        
    // Legge se combatField è una partita valida
        
    read_socket(sock_fdbuffer);
        if(
    strcmp(buffer"partitaEsistente") == 0)
            return 
    0;
        
        
    flag 0;
        do
        {
            
    azzeraStringa(bufferstrlen(buffer));
            
    intestazione(buffer);
            
    printf("%s\n "buffer);

            
            
    printf("Creazione Nuova Partita\n ");
            
    printf(" Inserisci il nome del campo di battaglia -> %s\n\n"combatField);
            
            do
            {
                
    azzeraStringa(bufferstrlen(buffer));
                
    printf(" Inserisci il numero di dimensioni del campo di battaglia (MAX 99)-> ");
                
    GetString(buffer2);
            }
            while(
    atoi(buffer) <= 0);
        
            new->
    opzioni.dimensione atoi(buffer);
        
            
    componenti = (int*)malloc(new->opzioni.dimensione*sizeof(int));
            for(
    i=0i<new->opzioni.dimensionei++)
            {
                do
                {
                    
    azzeraStringa(bufferstrlen(buffer));
                    
    printf("\tOra inserisci il numero di componenti sulla dimensione %d (MAX 10) -> "i+1);
                    
    GetString(buffer2);
                    if(
    atoi(buffer)<=|| atoi(buffer)>10)
                        
    printf("\n\n\tErrore: il numero di componenti deve essere un intero positivo minore di 10\n\n");
                }
                while(
    atoi(buffer)<=|| atoi(buffer)>10);
            
                
    componenti[i] = atoi(buffer);
            }
            
            do
            {
                
    azzeraStringa(bufferstrlen(buffer));
                
    printf(" Bene! Adesso inserisci il numero di navi della flotta -> ");
                
    GetString(buffer3);
                if(
    atoi(buffer)<=0)
                    
    printf("\n\n\tErrore: il numero di navi delle flotta deve essere un intero positivo\n\n");
            }
            while(
    verificaPosto(componenti, new->opzioni.dimensioneatoi(buffer))==0);
            
            new->
    opzioni.numeroNavi atoi(buffer);
            new->
    opzioni.naviG1 =  new->opzioni.numeroNavi;

            
    dimensioneCampo = (char*)malloc(256*sizeof(char));
            
    dimCampo calcolaDimensioneCampo(componenti, new->opzioni.dimensionedimensioneCampo);
            
    campo = (int*)malloc(dimCampo*sizeof(int));
            
    creaCampo(campodimCampo);
            
            
    // Chiede all'utente se creare una flotta "pseudo-casuale" o caricarla da un file esistente
            
    do
            {
                
    sprintf(fileName"flotta%s"combatName);
                
                
    azzeraStringa(bufferstrlen(buffer));
                
    intestazione(buffer);
                
    printf("%s\n "buffer);
                
                
    printf("Creazione Nuova Flotta\n ");
                
    printf(" Vuoi che il programma crei una nuova flotta random e la salvi nel file %s ? [S]ì / [N]o -> "fileName);
                
    GetString(buffer1);
                    
                if(
    buffer[0] == 's' || buffer[0] == 'S')
                {
                    
    flag 1;
                    
    azzeraStringa(bufferstrlen(buffer));
                    
    intestazione(buffer);
                    
    printf("%s\n "buffer);
                    
                    
    printf("Creazione Nuova Flotta\n ");
                    
    printf(" Sto costruendo la flotta...\n");

                    
    creaFlottaRandom(campo, new->opzioni.dimensionecomponenti, new->opzioni.numeroNavifileName);

                    
    azzeraStringa(bufferstrlen(buffer));
                    
    intestazione(buffer);
                    
    printf("%s\n "buffer);
                    
                    
    printf("Creazione Nuova Flotta\n ");
                    
    printf("  La flotta è stata salvata correttamente nel file %s\n"fileName);
                }
                else if(
    buffer[0] == 'n' || buffer[0] == 'N')
                    
    flag 2;
                
                if(
    flag==2)
                {
                    do
                    {
                        
    azzeraStringa(bufferstrlen(buffer));
                        
    intestazione(buffer);
                        
    printf("%s\n "buffer);
                        
    printf("Creazione Nuova Flotta\n ");
                        
    printf(" Inserisci il nome del file contenente la tua flotta -> ");
                        
    azzeraStringa(buffer16);
                        
    GetString(buffer15);
                        
    strcat(buffer"\0");
                        
    printf("\n\n Il nome del file è questo -> %s"buffer);
                        
    flag chiediConferma();
                        if(
    flag==1)
                            
    strcpy(fileNamebuffer);
                    }while(
    flag==0);
                
                    
    flag acquisisciFlotta(campo, new->opzionicomponentifileName);

                    if(
    flag == -1)
                    {
                        
    printf("\n Il file \"%s\" non esiste!\n\t-> Premere un tasto per inserire un nuovo nome file\n"fileName);
                        
    GetString(buffer1);
                    }
                    else if(
    flag == -2)    
                    {
                        
    printf("\n Il file \"%s\" non è conforme alle opzioni della partita!\n"fileName);
                        
    printf("\t-> Assicurati che il file abbia %d righe, ognuna con %d coordinate, separate da uno \"spazio\"\n", new->opzioni.numeroNavi, new->opzioni.dimensione);
                        
    printf("\t-> Correggere la flotta \"%s\" e premere un tasto per inserire nuovamente il nome file\n\n"fileName);
                        
    GetString(buffer1);
                    }
                    else if(
    flag 0)
                    {
                        
    printf("\n Le coordinate della nave in riga %d non rispettano le opzioni della partita!\n\t-> Correggere le coordinate e premere un tasto per reinserire il nome file\n"flag);
                        
    GetString(buffer1);
                    }
                    
                }
                
            }while(
    flag!=&& flag!=0);
            
            
    strcpy(new->players[0].combatNamecombatName);
            new->
    players[0].naviRestanti = new->opzioni.numeroNavi;

            
    strcpy(new->opzioni.combatFieldcombatField);
            
    strcpy(new->opzioni.combatNameG1, new->players[0].combatName);
            
    strcpy(new->opzioni.combatNameG2"Nessuno\0");    

            
    write_socket(sock_fd"datiMemorizzati\0");

            
    read(sock_fd, &duratasizeof(int));
            
            new->
    opzioni.tempoRestante durata;
            
            
    stampaOpzioni(new->opzionidimensioneCampobuffer0);
            
    printf("\n\n%s\n\n"buffer);        
            
    flag chiediConferma();
            
            if(
    flag==0)
            {
                
    free(campo);
                
    free(componenti);
                
    free(dimensioneCampo);
                
    write_socket(sock_fd"datiNonConfermati\0");
            }
            else
                
    write_socket(sock_fd"datiConfermati\0");
            
        }while(
    flag==0);
        
        
    opzioni = new->opzioni;
        
        return 
    1;

    Aspetto nuove...

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2024 vBulletin Solutions, Inc. All rights reserved.