Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - Disperato
Forum - C/C++ - Disperato

Avatar
prince (Normal User)
Newbie


Messaggi: 1
Iscritto: 17/07/2009

Segnala al moderatore
Postato alle 13:09
Venerdì, 17/07/2009
Salve a tutti,

sono uno studente di ingegneria informatica e ho ultimato un progetto consistente nella realizzazione di un repository concorrente. Il problema è che non capisco come mai il codice di upload nel server (funzione upload_to_server) simmetrica alla download_from_server non mi funziona. E' esattamente lo stesso codice però la upload mi legge caratteri strani da una read in cui prendo la lunghezza del messaggio successivo. La cosa è ancora più strana in quanto se avvio il debugger DDD e vado di passo in passo il tutto funziona benissimo. Sono veramente disperato e la consegna del progetto per l'esame vicinissima. Spero che qualcuno di voi possa aiutarmi in breve tempo. Vi ringrazio fin da ora. Posto il codice della download_from server e upload_to_server lato server. L'errore si verifica sul server e sembrerebbe che il client scriva sul socket le cose giuste! Se vi servono altre informazioni non esitate a chidere.

void download_from_server(int sa){ //Questa funziona benissimo e non si blocca mai
    struct tab_file *tb;    
    int sd=sa;    
    int len_string=0;    
    int ret=0;
    int msg_len=0;
    char aux[BUFFER_LEN];
    memset(&aux,0,BUFFER_LEN);    
    char msg[BUFFER_LEN];
    memset(&msg,0,BUFFER_LEN);    
    
    ret=read(sd,&msg_len,sizeof(msg_len));
    if (ret!=sizeof(msg_len)){
        printf("SERVER_DOWN: Error while getting msg_len from the client\n");
        exit(1);
    }
    if(msg==NULL){
        printf("SERVER: Can't get the heap\n");
        exit(1);
    }
    ret=read(sd, msg, msg_len);
    if(ret!=msg_len){
        printf("SERVER_DOWN: Error while getting the msg from the client\n");
        exit(1);
    }
    while(pthread_mutex_lock(&mutex));
    int ris=ricerca_file(msg);
    pthread_mutex_unlock(&mutex);    
    while(ris==2);    
    while(pthread_mutex_lock(&mutex));        
    crea_file(msg,strlen(msg));
    pthread_mutex_unlock(&mutex);
    printf("Elemento %s correttamente inserito (primo ciclo)\n",msg);        
    run_download(msg,sd);                
    while(pthread_mutex_lock(&mutex));        
    elimina_file(msg);
    pthread_mutex_unlock(&mutex);
    printf("Eliminazione file : %s riuscita\n",msg);    
    char terminazione[]="Fine";
    while(1){
        msg_len=0;        
        memset(&msg,0,BUFFER_LEN);        
        while(pthread_mutex_lock(&mutex));        
        read(sd,&msg_len,sizeof(msg_len));        
        read(sd,msg,msg_len);        
        if(strcmp(msg,terminazione)==0){
            pthread_mutex_unlock(&mutex);
            break;
        }
        pthread_mutex_unlock(&mutex);        
        while((ricerca_file(msg)==2));            
        while(pthread_mutex_lock(&mutex));        
        crea_file(msg,strlen(msg));
        pthread_mutex_unlock(&mutex);
        printf("Elemento %s correttamente inserito (dentro while)\n",msg);                        
        run_download(msg,sd);                    
        while(pthread_mutex_lock(&mutex));
        elimina_file(msg);
        pthread_mutex_unlock(&mutex);
        printf("Eliminazione file : %s riuscita\n",msg);    
    }
    printf("Elementi totali: %d\n",totale);
    if(primo!=NULL)
        printf("elemento sbagliato %s\n",primo->nomefile);    
}

void run_download(char *p, int sd){
    char aux[BUFFER_LEN];
    memset(aux,0,BUFFER_LEN);    
    char path_file[]="/home/fabio/sisop/";
    FILE *fp=NULL;
    unsigned len=0;    
    len=strlen(p);    
    char nome_file[len];
    memset(nome_file,0,len);    
    strcpy(nome_file,p);
    nome_file[len]='\0';
    
    strncat(aux,path_file, strlen(path_file)+strlen(aux));
    strncat(aux,nome_file,strlen(aux)+strlen(nome_file));
    fp=fopen(aux,"rb");
    if(fp==NULL){
        printf("SERVER: Error can't open the file\n");
        exit(1);
    }
    int size=get_filesize(aux);
    char buf[DIM];
    memset(buf,0,DIM);
    write(sd,&size,sizeof(int));
    while(size>0){
        fread(buf,1,DIM,fp);
        write(sd,buf,DIM);
        size=size-DIM;
    }
    fclose(fp);    
}

void upload_to_server(int sa){
    struct tab_file *tb;    
    int sd=sa;    
    int len_string=0;    
    int ret=0;
    int msg_len2=0;
    char aux[DIM];
    memset(&aux,0,DIM);    
    //char* aux=NULL;
    char msg[BUFFER_LEN];
    memset(&msg,0,BUFFER_LEN);
    //char* p=NULL;    
    
    ret=read(sd,&msg_len2,sizeof(msg_len2));
    if (ret!=sizeof(msg_len2)){
        printf("SERVER_DOWN: Error while getting msg_len from the client\n");
        exit(1);
    }
    //msg=calloc(msg_len,sizeof(char));    
    if(msg==NULL){
        printf("SERVER: Can't get the heap\n");
        exit(1);
    }
    ret=read(sd, msg, msg_len2);  
    printf("%s\n",msg);    
    if(ret!=msg_len2){
        printf("SERVER_DOWN: Error while getting the msg from the client\n");
        exit(1);
    }
    if(totale!=0){
        tb=primo;
        while(pthread_mutex_lock(&mutex));        
        crea_file(msg,strlen(msg));
        for(tb;strcmp(msg,tb->nomefile)!=0;tb=tb->pun);
        while(pthread_mutex_lock(&(tb->access)));
        tb->shared=1;            
        pthread_mutex_unlock(&mutex);        
        run_upload(sd,msg);
        pthread_mutex_unlock(&(tb->access));
        printf("Upload eseguito di %s\n",msg);
        while(pthread_mutex_lock(&mutex));
        tb->shared=0;            
        elimina_file(msg);
        printf("Eliminazione eseguito di %s\n",msg);        
        pthread_mutex_unlock(&mutex);                    
    }    
    else {
        while(pthread_mutex_lock(&mutex));        
        crea_file(msg,strlen(msg));
        tb=primo;        
        for(tb;strcmp(msg,tb->nomefile)!=0;tb=tb->pun);
        while(pthread_mutex_lock(&(tb->access)));        
        tb->shared=1;        
        pthread_mutex_unlock(&mutex);                        
        run_upload(sd,msg);
        pthread_mutex_unlock(&(tb->access));
        printf("Upload eseguito di %s\n",msg);
        while(pthread_mutex_lock(&mutex));
        tb->shared=0;
        elimina_file(msg);
        printf("Eliminazione eseguito di %s\n",msg);        
        pthread_mutex_unlock(&mutex);                                        
    }    
    char terminazione[]="Fine";
    printf("sono qui\n");    
    while(1){ // in questo while praticamente msg_len2 assume valore del tipo -511111423 che è totalmente errato in quanto dovrebbe avere al suo interno invece un semplice intero e ciò mi invalida anche la seconda read!!!


        //aux=(char*)malloc(10);        
        msg_len2=0;        
        memset(&msg,'\0',BUFFER_LEN);        
        read(sd,&msg_len2,sizeof(msg_len2));
        printf("msg_len : %p %d\n",&msg_len2,msg_len2);        
        read(sd,msg,msg_len2);
        printf("Sono qui : %d %s\n",msg_len2,msg);        
        if(strcmp(msg,terminazione)==0){
            break;
        }
        if(totale!=0){        
            tb=primo;
            while(pthread_mutex_lock(&mutex));        
            crea_file(msg,strlen(msg));
            for(tb;strcmp(msg,tb->nomefile)!=0;tb=tb->pun);
            while(pthread_mutex_lock(&(tb->access)));        
            tb->shared=1;            
            pthread_mutex_unlock(&mutex);        
            run_upload(sd,msg);
            pthread_mutex_unlock(&(tb->access));
            printf("Upload eseguito (dentro while) di %s\n",msg);
            while(pthread_mutex_lock(&mutex));
            tb->shared=0;            
            elimina_file(msg);
            printf("Eliminazione eseguito (dentro while) di %s\n",msg);
            pthread_mutex_unlock(&mutex);
        }
        else {
            while(pthread_mutex_lock(&mutex));        
            crea_file(msg,strlen(msg));
            tb=primo;            
            for(tb;strcmp(msg,tb->nomefile)!=0;tb=tb->pun);
            pthread_mutex_lock(&(tb->access));        
            tb->shared=1;            
            pthread_mutex_unlock(&mutex);        
            run_upload(sd,msg);
            pthread_mutex_unlock(&(tb->access));
            printf("Upload eseguito (dentro while) di %s\n",msg);
            while(pthread_mutex_lock(&mutex));
            tb->shared=0;            
            elimina_file(msg);
            printf("Eliminazione eseguito (dentro while) di %s\n",msg);            
            pthread_mutex_unlock(&mutex);
        }
    }
    printf("Elementi totali: %d\n",totale);    
}

void run_upload(int sd,char* p){
    
    char aux[BUFFER_LEN];
    memset(&aux,0,BUFFER_LEN);    
    char buf[DIM];    
    memset(&buf,0,DIM);    
    char path_file[]="/home/fabio/sisop/";
    FILE *fp=NULL;
    unsigned len=0;    
    //int size=0;
    len=strlen(p);    
    char nome_file[len];
    memset(&nome_file,0,len);    
    strcpy(nome_file,p);
    nome_file[len]='\0';
    //read(sa,&len,sizeof(len));
    //read(sa,buf,100);
    //size=atoi(buf);
            
    strncat(aux,path_file, strlen(path_file)+strlen(aux));
    strncat(aux,nome_file,strlen(aux)+strlen(nome_file));
    printf("%d %d %s\n",sd,size,aux);    
    
    fp=fopen(aux,"wb");
    if(fp==NULL){
        printf("SERVER: Error can't open the file (upload)\n");
        fprintf(stderr, "Error (upload): %s.\n", strerror(errno));
        exit(1);
    }    
    read(sd,&size,sizeof(int));
    printf("valore di size : %d\n",size);    
    while(size>0){
        //memset(buf,0,DIM);        
        read(sd,&buf,DIM);        
        fwrite(buf,1,DIM,fp);        
        size=size-DIM;
        /*if(size<=512){
            read(sd,&buf,size);
            fwrite(buf,1,size,fp);
            break;
        }*/
    }
    //write(sa,"OK",2);    
    fclose(fp);
    
}

Ultima modifica effettuata da prince il 17/07/2009 alle 13:10
PM Quote
Avatar
genuzzu (Normal User)
Pro


Messaggi: 107
Iscritto: 24/06/2009

Segnala al moderatore
Postato alle 13:38
Venerdì, 17/07/2009
Testo quotato

Postato originariamente da prince:

Salve a tutti,

sono uno studente di ingegneria informatica e ho ultimato un progetto consistente nella realizzazione di un repository concorrente. Il problema è che non capisco come mai il codice di upload nel server (funzione upload_to_server) simmetrica alla download_from_server non mi funziona. E' esattamente lo stesso codice però la upload mi legge caratteri strani da una read in cui prendo la lunghezza del messaggio successivo. La cosa è ancora più strana in quanto se avvio il debugger DDD e vado di passo in passo il tutto funziona benissimo. Sono veramente disperato e la consegna del progetto per l'esame vicinissima. Spero che qualcuno di voi possa aiutarmi in breve tempo. Vi ringrazio fin da ora. Posto il codice della download_from server e upload_to_server lato server. L'errore si verifica sul server e sembrerebbe che il client scriva sul socket le cose giuste! Se vi servono altre informazioni non esitate a chidere.
Codice sorgente - presumibilmente C++

  1. void download_from_server(int sa){ //Questa funziona benissimo e non si blocca mai
  2.         struct tab_file *tb;   
  3.         int sd=sa;     
  4.         int len_string=0;      
  5.         int ret=0;
  6.         int msg_len=0;
  7.         char aux[BUFFER_LEN];
  8.         memset(&aux,0,BUFFER_LEN);     
  9.         char msg[BUFFER_LEN];
  10.         memset(&msg,0,BUFFER_LEN);     
  11.        
  12.         ret=read(sd,&msg_len,sizeof(msg_len));
  13.         if (ret!=sizeof(msg_len)){
  14.                 printf("SERVER_DOWN: Error while getting msg_len from the client\n");
  15.                 exit(1);
  16.         }
  17.         if(msg==NULL){
  18.                 printf("SERVER: Can't get the heap\n");
  19.                 exit(1);
  20.         }
  21.         ret=read(sd, msg, msg_len);
  22.         if(ret!=msg_len){
  23.                 printf("SERVER_DOWN: Error while getting the msg from the client\n");
  24.                 exit(1);
  25.         }
  26.         while(pthread_mutex_lock(&mutex));
  27.         int ris=ricerca_file(msg);
  28.         pthread_mutex_unlock(&mutex);  
  29.         while(ris==2); 
  30.         while(pthread_mutex_lock(&mutex));             
  31.         crea_file(msg,strlen(msg));
  32.         pthread_mutex_unlock(&mutex);
  33.         printf("Elemento %s correttamente inserito (primo ciclo)\n",msg);              
  34.         run_download(msg,sd);                          
  35.         while(pthread_mutex_lock(&mutex));             
  36.         elimina_file(msg);
  37.         pthread_mutex_unlock(&mutex);
  38.         printf("Eliminazione file : %s riuscita\n",msg);       
  39.         char terminazione[]="Fine";
  40.         while(1){
  41.                 msg_len=0;             
  42.                 memset(&msg,0,BUFFER_LEN);             
  43.                 while(pthread_mutex_lock(&mutex));             
  44.                 read(sd,&msg_len,sizeof(msg_len));             
  45.                 read(sd,msg,msg_len);          
  46.                 if(strcmp(msg,terminazione)==0){
  47.                         pthread_mutex_unlock(&mutex);
  48.                         break;
  49.                 }
  50.                 pthread_mutex_unlock(&mutex);          
  51.                 while((ricerca_file(msg)==2));                 
  52.                 while(pthread_mutex_lock(&mutex));             
  53.                 crea_file(msg,strlen(msg));
  54.                 pthread_mutex_unlock(&mutex);
  55.                 printf("Elemento %s correttamente inserito (dentro while)\n",msg);                                             
  56.                 run_download(msg,sd);                                  
  57.                 while(pthread_mutex_lock(&mutex));
  58.                 elimina_file(msg);
  59.                 pthread_mutex_unlock(&mutex);
  60.                 printf("Eliminazione file : %s riuscita\n",msg);       
  61.         }
  62.         printf("Elementi totali: %d\n",totale);
  63.         if(primo!=NULL)
  64.                 printf("elemento sbagliato %s\n",primo->nomefile);     
  65. }
  66.  
  67. void run_download(char *p, int sd){
  68.         char aux[BUFFER_LEN];
  69.         memset(aux,0,BUFFER_LEN);      
  70.         char path_file[]="/home/fabio/sisop/";
  71.         FILE *fp=NULL;
  72.         unsigned len=0;
  73.         len=strlen(p); 
  74.         char nome_file[len];
  75.         memset(nome_file,0,len);       
  76.         strcpy(nome_file,p);
  77.         nome_file[len]='\0';
  78.        
  79.         strncat(aux,path_file, strlen(path_file)+strlen(aux));
  80.         strncat(aux,nome_file,strlen(aux)+strlen(nome_file));
  81.         fp=fopen(aux,"rb");
  82.         if(fp==NULL){
  83.                 printf("SERVER: Error can't open the file\n");
  84.                 exit(1);
  85.         }
  86.         int size=get_filesize(aux);
  87.         char buf[DIM];
  88.         memset(buf,0,DIM);
  89.         write(sd,&size,sizeof(int));
  90.         while(size>0){
  91.                 fread(buf,1,DIM,fp);
  92.                 write(sd,buf,DIM);
  93.                 size=size-DIM;
  94.         }
  95.         fclose(fp);    
  96. }
  97.  
  98. void upload_to_server(int sa){
  99.         struct tab_file *tb;   
  100.         int sd=sa;     
  101.         int len_string=0;      
  102.         int ret=0;
  103.         int msg_len2=0;
  104.         char aux[DIM];
  105.         memset(&aux,0,DIM);    
  106.         //char* aux=NULL;
  107.         char msg[BUFFER_LEN];
  108.         memset(&msg,0,BUFFER_LEN);
  109.         //char* p=NULL;
  110.        
  111.         ret=read(sd,&msg_len2,sizeof(msg_len2));
  112.         if (ret!=sizeof(msg_len2)){
  113.                 printf("SERVER_DOWN: Error while getting msg_len from the client\n");
  114.                 exit(1);
  115.         }
  116.         //msg=calloc(msg_len,sizeof(char));    
  117.         if(msg==NULL){
  118.                 printf("SERVER: Can't get the heap\n");
  119.                 exit(1);
  120.         }
  121.         ret=read(sd, msg, msg_len2);  
  122.         printf("%s\n",msg);    
  123.         if(ret!=msg_len2){
  124.                 printf("SERVER_DOWN: Error while getting the msg from the client\n");
  125.                 exit(1);
  126.         }
  127.         if(totale!=0){
  128.                 tb=primo;
  129.                 while(pthread_mutex_lock(&mutex));             
  130.                 crea_file(msg,strlen(msg));
  131.                 for(tb;strcmp(msg,tb->nomefile)!=0;tb=tb->pun);
  132.                 while(pthread_mutex_lock(&(tb->access)));
  133.                 tb->shared=1;                  
  134.                 pthread_mutex_unlock(&mutex);          
  135.                 run_upload(sd,msg);
  136.                 pthread_mutex_unlock(&(tb->access));
  137.                 printf("Upload eseguito di %s\n",msg);
  138.                 while(pthread_mutex_lock(&mutex));
  139.                 tb->shared=0;                  
  140.                 elimina_file(msg);
  141.                 printf("Eliminazione eseguito di %s\n",msg);           
  142.                 pthread_mutex_unlock(&mutex);                                  
  143.         }      
  144.         else {
  145.                 while(pthread_mutex_lock(&mutex));             
  146.                 crea_file(msg,strlen(msg));
  147.                 tb=primo;              
  148.                 for(tb;strcmp(msg,tb->nomefile)!=0;tb=tb->pun);
  149.                 while(pthread_mutex_lock(&(tb->access)));              
  150.                 tb->shared=1;          
  151.                 pthread_mutex_unlock(&mutex);                                          
  152.                 run_upload(sd,msg);
  153.                 pthread_mutex_unlock(&(tb->access));
  154.                 printf("Upload eseguito di %s\n",msg);
  155.                 while(pthread_mutex_lock(&mutex));
  156.                 tb->shared=0;
  157.                 elimina_file(msg);
  158.                 printf("Eliminazione eseguito di %s\n",msg);           
  159.                 pthread_mutex_unlock(&mutex);                                                                          
  160.         }      
  161.         char terminazione[]="Fine";
  162.         printf("sono qui\n");  
  163.         while(1){ // in questo while praticamente msg_len2 assume valore del tipo -511111423 che è totalmente errato in quanto dovrebbe avere al suo interno invece un semplice intero e ciò mi invalida anche la seconda read!!!
  164.  
  165.  
  166.                 //aux=(char*)malloc(10);               
  167.                 msg_len2=0;            
  168.                 memset(&msg,'\0',BUFFER_LEN);          
  169.                 read(sd,&msg_len2,sizeof(msg_len2));
  170.                 printf("msg_len : %p %d\n",&msg_len2,msg_len2);        
  171.                 read(sd,msg,msg_len2);
  172.                 printf("Sono qui : %d %s\n",msg_len2,msg);             
  173.                 if(strcmp(msg,terminazione)==0){
  174.                         break;
  175.                 }
  176.                 if(totale!=0){         
  177.                         tb=primo;
  178.                         while(pthread_mutex_lock(&mutex));             
  179.                         crea_file(msg,strlen(msg));
  180.                         for(tb;strcmp(msg,tb->nomefile)!=0;tb=tb->pun);
  181.                         while(pthread_mutex_lock(&(tb->access)));              
  182.                         tb->shared=1;                  
  183.                         pthread_mutex_unlock(&mutex);          
  184.                         run_upload(sd,msg);
  185.                         pthread_mutex_unlock(&(tb->access));
  186.                         printf("Upload eseguito (dentro while) di %s\n",msg);
  187.                         while(pthread_mutex_lock(&mutex));
  188.                         tb->shared=0;                  
  189.                         elimina_file(msg);
  190.                         printf("Eliminazione eseguito (dentro while) di %s\n",msg);
  191.                         pthread_mutex_unlock(&mutex);
  192.                 }
  193.                 else {
  194.                         while(pthread_mutex_lock(&mutex));             
  195.                         crea_file(msg,strlen(msg));
  196.                         tb=primo;                      
  197.                         for(tb;strcmp(msg,tb->nomefile)!=0;tb=tb->pun);
  198.                         pthread_mutex_lock(&(tb->access));             
  199.                         tb->shared=1;                  
  200.                         pthread_mutex_unlock(&mutex);          
  201.                         run_upload(sd,msg);
  202.                         pthread_mutex_unlock(&(tb->access));
  203.                         printf("Upload eseguito (dentro while) di %s\n",msg);
  204.                         while(pthread_mutex_lock(&mutex));
  205.                         tb->shared=0;                  
  206.                         elimina_file(msg);
  207.                         printf("Eliminazione eseguito (dentro while) di %s\n",msg);                    
  208.                         pthread_mutex_unlock(&mutex);
  209.                 }
  210.         }
  211.         printf("Elementi totali: %d\n",totale);
  212. }
  213.  
  214. void run_upload(int sd,char* p){
  215.        
  216.         char aux[BUFFER_LEN];
  217.         memset(&aux,0,BUFFER_LEN);     
  218.         char buf[DIM]; 
  219.         memset(&buf,0,DIM);    
  220.         char path_file[]="/home/fabio/sisop/";
  221.         FILE *fp=NULL;
  222.         unsigned len=0;
  223.         //int size=0;
  224.         len=strlen(p); 
  225.         char nome_file[len];
  226.         memset(&nome_file,0,len);      
  227.         strcpy(nome_file,p);
  228.         nome_file[len]='\0';
  229.         //read(sa,&len,sizeof(len));
  230.         //read(sa,buf,100);
  231.         //size=atoi(buf);
  232.                        
  233.         strncat(aux,path_file, strlen(path_file)+strlen(aux));
  234.         strncat(aux,nome_file,strlen(aux)+strlen(nome_file));
  235.         printf("%d %d %s\n",sd,size,aux);      
  236.        
  237.         fp=fopen(aux,"wb");
  238.         if(fp==NULL){
  239.                 printf("SERVER: Error can't open the file (upload)\n");
  240.                 fprintf(stderr, "Error (upload): %s.\n", strerror(errno));
  241.                 exit(1);
  242.         }      
  243.         read(sd,&size,sizeof(int));
  244.         printf("valore di size : %d\n",size);  
  245.         while(size>0){
  246.                 //memset(buf,0,DIM);           
  247.                 read(sd,&buf,DIM);             
  248.                 fwrite(buf,1,DIM,fp);          
  249.                 size=size-DIM;
  250.                 /*if(size<=512){
  251.                         read(sd,&buf,size);
  252.                         fwrite(buf,1,size,fp);
  253.                         break;
  254.                 }*/
  255.         }
  256.         //write(sa,"OK",2);    
  257.         fclose(fp);
  258.        
  259. }



PM Quote
Avatar
HeDo (Founder Member)
Guru^2


Messaggi: 2763
Iscritto: 21/09/2007

Segnala al moderatore
Postato alle 12:58
Domenica, 19/07/2009

mai visto un codice tanto brutto e così mal strutturato.

non c'è un commento neanche a pagarlo, i nomi delle variabili sono completamente fuorivianti.

netarrow mi ha mandato il progetto completo, chiedendomi aiuto disperato pure lui, non per il programma in se ma per l'assurdità di questo codice.

cmq chi è "pippo"? chi è "alfa"? chi è "prova"? chi è "aux"?

e questi sarebbero nomi di variabili? mah...


Ingegnere Informatico
https://ldlagency.it
PM Quote
Avatar
Lawliet (Normal User)
Expert


Messaggi: 386
Iscritto: 09/04/2009

Segnala al moderatore
Postato alle 17:03
Domenica, 19/07/2009
In effetti, io non posso aiutare tanto meno non ho capito nemmeno una h del codice xD.
E poi mi sembra di vedere che ha preso un progetto da un altro, e ha cercato di modificarlo a modo suo. Se fosse così, fa solo male.. MOLTO male ^^'. Altrimenti dimostra il contrario, e fai in modo che HeDo e netarrow ti capiscano e che possano aiutarti e non solo loro :|.

Ultima modifica effettuata da Lawliet il 19/07/2009 alle 17:10


"Dai un pesce (programma) a un uomo e lo nutrirai per un giorno. Insegnagli a pescare (programmare) e lo nutrirai per tutta la vita." (niente pappa pronta)
cit. theprogrammer
PM Quote