Newsgroup: it.comp.os.linux.development
Titolo: client server linux windows

Saluti a tutti.
E' da un po' che cerco di mettere in piedi una comunicazione "affidabile"
tra linux e windows, ma ho delle difficoltà.
Mi spiego:
Ho una applicazione linux a carattere usata con ssh  che, a richiesta deve
far partire una applicazione windows sul pc collegato.
La parte server della comunicazione gira di continuo sul pc ( scritta in
vb6) e rimane li ad aspettare che linux gli mandi i dati su una porta
definita.
La parte client gira all'occorrenza su linux e, quando serve, gli manda una
serie di dati.
La trasmissione viene sempre composta da 5120 caratteri.
Di solito funza tutto ma........
qualche volta il windows mi spezza i buffer che riceve da linux e quindi mi
risultano come 2 trasmissioni distinte.
Ho provato a mettere dei while per aspettare che le trasmissioni successive
mi riempiano il buffer, ma non ci riesco.
Probabilmente ( anzi certamente) sono io che non conosco abbastanza bene il
funzionamento del winsock di windows ( o più in generale della comunicazione
tcp), ma, ho guardato una serie di esempi e non vedo differenza con i miei.
C'è qualcuno che ha fatto qualcosa del genere che mi può dare delle dritte?
ovviamente se serve posto gli estratti dei listati c-linux e vb6-windows.
Ciao e grazie
P.S.
quale utility posso usare per controllare la comunicazione TCP tra i due?

 
io uso ethereal
-- 
SF
"Breaking something which works as intended in order to solve a problem 
existing in delusion-space is not usually called 'a workaround'."

 C'è qualcuno che ha fatto qualcosa del genere che mi può dare delle dritte?
senti il metodo che io uso di norma è questo:
prima di tutto implemenatre un protocollino semplice semplice, cioè
pirmadi ogni trasmissione trasmettere un header a lunghezza fissa dove
metti un magic number[2 byte], la lunghezza dei dati del corpo del
pacchetto[4 byte], eventuali flag[2 byte]
letto ed interpretato l'header puoi iniziare a ricevere i dati.
Adesso Come lo setti il socket?
prova (lato server) a metterlo non bloccante e ciclare su EAGAIN fino a
quando nn arrivano tutti i dati del body che hai ricavatodalla lettura
dell'header (ma anche senza header se già sai quanti sono i dati)
in ogni caso, non conosco vb6 (il problema sta li), meglio se chiedi in un
gruppo appropriato


Ma così come faccio a sapere quanti byte mi devo aspettare? ( un byte
iniziale non mi basta per specificare la lunghezza del messaggio).
Inoltre, non rallento di molto la comunicazione?
Ciao


Purtroppo il server è sotto winzozz.
Comunque posto la parte linux per vedere se ci sono cavolate...
CLIEXE( char *msg)
{
     int sendbuffy;
   int sockfd, numbytes;
   char buf[MAXDATASIZE];
   char sendbuf[MAXDATASIZE];
   char argv[20];
   int status;
   struct hostent *he;
    struct sockaddr_in their_addr;
   int pause=0;
strcpy(sendbuf, msg);
/*printf(" msg:%s \n",msg);*/
MIOIP(&argv, &status);
/*printf(" argv:%s , status:%d \n",argv,status);*/
 if ((he=gethostbyname(argv)) == NULL)
   {
     perror("gethostbyname");
     exit(1);
   }
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
   {
     perror("socket");
     exit(1);
   }
   their_addr.sin_family = AF_INET;
   their_addr.sin_port = htons(PORT);
   their_addr.sin_addr = *((struct in_addr *)he->h_addr);
   bzero(&(their_addr.sin_zero), 8);
   if (connect(sockfd, (struct sockaddr *)&their_addr, sizeof(struct
sockaddr))+
    {
       perror("connect");
       exit(1);
     }
   if (!send(sockfd,sendbuf,MAXDATASIZE ,0)) // send daten
        perror("send");
   if ((numbytes=recv(sockfd, buf, MAXDATASIZE, 0)) == -1)
     {
      perror("send");
   if ((numbytes=recv(sockfd, buf, MAXDATASIZE, 0)) == -1)
     {
       perror("recv");
       exit(1);
     }
        strcpy(msg,buf);
        buf[numbytes] = '\0';
/*printf(" msg:%s , numbytes:%d \n",msg,numbytes);*/
//if(pause==1)
//system("PAUSE");
//         getchar();
   // fine del gioco
    close(sockfd);
   return 0;

 
parlavo di fase di test: la ricezione di un pacchetto deve essere 
robusta e funzionare *anche* in questo caso limite.


 
come ti dicevo, non è detto che numbytes corrisponda alla dimensione di 
un pacchetto completo.


       rimuovi il pacchetto dal buffer;
Da dove vedo che il pacchetto č completo?

 
a me lo chiedi? :-)


 un numero diverso da MAXDATASIZE
Supponiamo che non ha inviato tutto...., che faccio?
il send di tutto quello che mi serviva l'ho già fatto....



Nel senso... se il client non sa quanti bytes devono arrivare ( dimensioni
del paccetto) come fa a sapere che la trasmissione č finita(il pacchetto č
completo)?

 
direi che non lo può sapere.


 Supponiamo che non ha inviato tutto...., che faccio?
devi continuare a chiamare send() fintanto che
1) il pacchetto è stato spedito completamente, oppure
2) send() restituisce 0 ed il peer remoto chiude la connessione, oppure
3) send() restituisce -1, cioè errore


 completo)?
leggi la mia risposta, ed in ogni caso i pacchetti arrivano al server
(almeno alla prima mandata :))

 il send di tutto quello che mi serviva l'ho già fatto....
lo rifai dall' n-esimo byte, dove n è il retval della send
ovviamente tutto in un ciclo fino a quando la somma di tutti i precedenti
non raggiunge la lunghezza del buffer che devi spedire

 non raggiunge la lunghezza del buffer che devi spedire
OK provo e poi vi faccio sapere.
Perň, cosě e come se parte del primo send fosse " evaporato"......
Se č cosě, sono decisamente deluso dalle routines di base del TCP, mi
aspettavo un modo di livello meno "basso".
Magari c'č qualcosa, ma io non la conosco, ma mi aspettavo di trovare una
cosa del tipo:
manda questo pacchetto di n bytes e aspetta (fino ad un timeout che ti do)
che sia stato ricevuto tutto; altrimenti vai in errore.
Mi sembra di capire che me lo devo costriure da solo.
Ho capito bene?
Ciao

 
sì, ma non è che sia tutto questo sbattone eh! :-)


 Mi sembra di capire che me lo devo costriure da solo.
eh sě


Oh beh,..... se esisteva una pappina pronta ma la mangiavo...:))))
O magari una pappina da cui prendere spunto.
Il fatto č che per quanto ormai senza TCP/IP non si vada neanche in bagno o
a fare sesso,
tutto viene fatto a basso livello.
Comunque...
Provo....
Grazie


No,
mi aspettavo che le routine a livello di trasporto facessero altro ( oltre
al resto).
Il trasporto si puň fare in maniera "cruda" o "cotta" ma questo non sposta
il livello iso/osi.
Con il cambio di livello non c'entra niente.
Non ti pare?
Ma sostanzianzialmente mi riferivo al fatto che non ho trovato niente (API
per esempio) che diano un'uso dei socket
piů "comodo" e non al fatto che dovessero necessariamente esistere a livello
di libreria di base
Ma probabilmente della roba esiste....
Ciao

 Ma probabilmente della roba esiste....
forse sì, di certo non nelle librerie standard.
Sicuro che qualcuno qualche wrapper (anche in C, piu' probabile in c++ che
non conosco bene) a socket l'ha sviluppato, e altrettanto sicuro che con
tale wrapper avrai delle limitazioni sull'utilizzo dei socket. anche io
tra le mie librerie ho delle classi che implementano ad esempio:
"architettura server/client dove il client  prende un file, zippa il file,
lo cripta , ci appende (in testa) un header e lo spedisce in modo sicuro,
su una PREdeterminata porta, al server  e chiude il socket. Ma alla fine
cosa ho fatto? ho implementato un protocollo che si posiziona sopra tcp!