Pb sur lecture de socket

Pb sur lecture de socket - C - Programmation

Marsh Posté le 10-10-2006 à 12:22:32    

Bonjour,
Voici un code .
Je me trouve bloque pour rendre la socket non bloquante.
Au debut tout ce passe bien je me connecte a un equipement je lis tout ce qui arrive sur la socket.
Mais lorsque il n'y a plus rien qui arrive l'appel read reste en attente pendant un certain temp
et ensuite on boucle indefiniment mais sans arriver a lire l'entree standart.
Est il necessaire de rendre la lecture d'une socket non bloquante.
 
 

Code :
  1. #include<stdio.h>
  2. #include<sys/socket.h>
  3. #include<sys/types.h>
  4. #include<netinet/in.h>
  5. #include<netdb.h>
  6. #include<arpa/inet.h>
  7. #include<unistd.h>
  8. #include<termios.h>
  9. #include<sys/time.h>
  10. #include<stdlib.h>
  11. #define LG_BUFFER=1
  12. /*procedure de negociation d'option telnet*/
  13. OPTION_NEGOCIEE (message_nego)
  14. {
  15. /*char *message_nego;*/
  16. printf("\nN° d'option %d",message_nego);
  17. }
  19. main(argc,argv)
  20. int argc;
  21. char **argv;
  22. {/*Debut du main*/
  24. unsigned char *buffer_RX,*buffer_TX;
  25. unsigned char *mess_nego;
  26. int socket1,connection,nb_lu,nb_ec,i,j,flag_nego_option;
  27. struct sockaddr_in addr_distant;
  28. struct servent *service_distant;
  29. struct termios term_initial,term_com;
  30. struct timeval delai;
  31. fd_set set;
  32. flag_nego_option=0;
  34. /*Preparation des parametres de  connection*/
  35. printf("\nadresse %s",argv[1]);
  36. service_distant=getservbyname("telnet","tcp" );
  37. memset(&addr_distant,0,sizeof(struct sockaddr_in));
  38. addr_distant.sin_family=PF_INET;
  39. addr_distant.sin_port=htons(service_distant->s_port);
  40. if((inet_aton(argv[1],&addr_distant.sin_addr.s_addr))==0)
  41. printf("\nimpossible de remplir le  champ s_addr" );
  44. /*Creation du point de communicatio*/
  45. if((socket1=socket(AF_INET,SOCK_STREAM,0))<0)
  46. printf("\nCreation de socket echouee" );
  48. /*Connection au point distant*/
  49. connection=connect(socket1,(struct sockaddr*)&addr_distant,sizeof(addr_distant));
  51. /*Procedure de mis en place du mode non bloquant sur stdin*/
  52. tcgetattr(STDIN_FILENO,&term_initial);
  53. tcgetattr(STDIN_FILENO,&term_com);
  54. term_com.c_lflag &=~(ICANON,ECHO);/*,ECHONL,ICANON,IEXTEN);*/
  55. term_com.c_cc[VTIME]=0;
  56. term_com.c_cc[VMIN]=0;
  57. if(tcsetattr(STDIN_FILENO,TCSANOW,term_com)!=0)
  58. printf("\ntransformation du terminal echoue" );
  59. =
  62. /*Modification des delaie pour passer en mode non bloquant*/
  63. delai.tv_sec=0;
  64. delai.tv_usec=0;
  65. while(1)
  66. {/*Debut du while 1*/
  68. /*Initialisation de l'ensemble des descripteurs a multiplexer*/
  69. FD_ZERO (&set);
  70. FD_SET (socket1,&set);
  71. FD_SET (STDIN_FILENO,&set);
  73. /*Selection de l'ensemble des descripteurs a multiplexer en reception*/
  74. if(select(socket1+1,&set,NULL,NULL,&delai)<0)
  75. break;
  76. /*printf("\nOn teste STDIN_FILENO" );*/
  77.       if(FD_ISSET(STDIN_FILENO,&set))
  78.      
  79. {/*Debut du if*/
  80. /*Initialisation d un bloc memoire pour un caractere*/
  81. if((buffer_RX=(char*) calloc (LG_BUFFER,sizeof (char)))==NULL)
  82. printf("\nImpossible d'allouer la memoire buffer_RX STDIN_FILENO" );
  83. nb_lu=0;
  84. if((nb_lu=read(STDIN_FILENO,buffer_RX,LG_BUFFER))<0)
  85. printf("\nerreur sur lecture d'entree ou rien a ecrire retour de nb_lu %d",nb_lu);
  86. if(nb_lu>0)
  87. nb_ec=write(socket1,buffer_TX,nb_lu);
  88. free(buffer_RX);
  89. }/*Fin du if*/
  92. /*printf("\nOn teste socket1" );*/
  93. if(FD_ISSET(socket1,&set))
  95. {/*Debut du if*/
  96. if((buffer_RX=(unsigned char*) calloc (LG_BUFFER,sizeof (unsigned char)))==NULL)
  97. printf("\nImpossible d'allouer la memoire buffer_RX pour socket1" );
  98.  nb_lu=0;
  99.  i=0;
  100. /*Ici on lit temp qu'il y a des donnees a lire on lit sinon on devvrai sortir*/
  101.  while((nb_lu=read(socket1,buffer_RX,LG_BUFFER))>0)
  103.  {/*Debut du while*/
  105.   if(buffer_RX[0]==255)
  106.   {/*Un caractere IAC est arrive*/
  107.   i=1;
  108.   if((mess_nego=(unsigned char*) calloc (i,sizeof (unsigned char)))==NULL)
  109.   printf("\nErreur sur attribution memoire mess_nego" );
  110.   flag_nego_option=1;
  111.   *mess_nego=*buffer_RX;
  112.    while(flag_nego_option==1)
  114.    {/*debut du while*/
  115.    printf("\non est avant realloc valeur de i %d et mess_nego = %d",i,*mess_nego);
  116.    if((mess_nego=realloc(mess_nego,(i+1)*sizeof(unsigned char)))==NULL)
  117.    printf("\nErreur sur attribution memoire" );
  118.    printf("\non passe la realloc de mess_nego[0] qui est a %d *mess_nego[i] est a %d et i est a %d",*(mess_nego),*(mess_nego+i),i);
  119.    nb_lu=read(socket1,mess_nego+i,LG_BUFFER);
  121.     if(*(mess_nego+i)>250 && *(mess_nego+i)<255)
  123.     { /*Phase de test 250>=IAC<255*/
  124.     ++i;
  125.     printf("\nvaleur de i %d",i);
  126.     if((mess_nego=realloc(mess_nego,(i+1)*sizeof(unsigned char)))==NULL)
  127.     printf("\nErreur sur attribution memoire" );
  128.     nb_lu=read(socket1,mess_nego+i,LG_BUFFER);
  129.     printf("\nnouveau mess_nego = ",*(mess_nego+i));
  130.     for(j=0;j<=i;j++)
  131.     printf("\nfor %d j= %d",*(mess_nego+j),j);
  132.     /*OPTION_NEGOCIEE(mess_nego);*/
  133.     }
  135.    flag_nego_option=0;
  136.    free(mess_nego);
  137.    i=++i;
  138.    } /*fin de while(flag_nego_option)*/
  140.    } /*fin de if(buffer_RX[0]==255)*/
  143.    else
  145.    {/*Debut du else*/
  146.    write(STDOUT_FILENO,buffer_RX,nb_lu);
  147.    } /*Fin du else*/
  148.  nb_lu=0;
  149.  }/*fin du while*/
  150.  free(buffer_RX);
  152. }/*Fin du if*/
  153. }/*Fin du while 1*/
  154. close(socket1);
  155. if((tcsetattr(STDIN_FILENO,TCSANOW,term_initial))!=0)
  156. printf("\nremeise en etat du stdin echoue\n" );
  158. }/*fin du main*/

Reply

Marsh Posté le 10-10-2006 à 12:22:32   

Reply

Marsh Posté le 15-10-2006 à 00:54:39    

Rendre la socket non bloquante sert lorsque tu désire faire dautres traitements quand les données ne sont pas encore disponibles.
 
Sinon la socket se comporte comme un flux normal, et si tu le transforme en FILE* tu peux même tester si la fin de fichier est atteinte.
 
Si la connexion est coupé (de force et non avec une fermeture logicielle de socket close() ou fclose()) la lecture sur la socket peut échouer mais au bout de quelques secondes d attente.
 
Le problème vient d ailleurs. Pense à tester errno (include errno.h).


Message édité par nargy le 15-10-2006 à 00:55:47
Reply

Marsh Posté le 16-10-2006 à 09:34:20    

En effet c'est ce que j'ai fait.
Merci

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed