Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
666 connectés 

  FORUM HardWare.fr
  Programmation
  C

  Client telnet

 
 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

Client telnet

n°1556577
yartempion
Posté le 07-05-2007 à 16:19:58  profilanswer
 

Bonjour,
Et oui merevoila avec mon client telnet.
Il fonctionne mais a quelques imperfections.
Je vous fournis mon code source.

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. #include<fcntl.h>
  12. #include <errno.h>
  13. #include<signal.h>
  14. #include<term.h>
  15. #include<ctype.h>
  16. #define LG_BUFFER=1
  17. /*#define ETIMEDOUT=30*/
  19. /*negociation de depart*/
  20. MSG_DE_NEGO(socket1)
  21. {
  22. unsigned char mesg_nego[7];
  23. printf("\ndemande des negos initiales\n\n" );
  24. printf("\nDO ECHO" );
  25. mesg_nego[0]=255;
  26. mesg_nego[1]=253;/*DO*/
  27. mesg_nego[2]=1;/*ECHO*/
  28. mesg_nego[3]=0;
  29. write(socket1,mesg_nego,3);
  30. printf("\nDO SUPPRESS GO AHEAD" );
  31. mesg_nego[2]=3;/*SUPPRESS GO AHEAD*/
  32. write(socket1,mesg_nego,3);
  33. mesg_nego[1]=251;/*WILL*/
  34. printf("\nWILL TERMINAL TYPE" );
  35. mesg_nego[2]=24;/*TERMINAL TYPE*/
  36. write(socket1,mesg_nego,3);
  37. printf("\nWILL NAWS" );
  38. mesg_nego[2]=31;/*TAILLE TERMINAL NAWS*/
  39. write(socket1,mesg_nego,3);
  40. mesg_nego[2]=32;/*TERMINAL SPEED*/
  41. /*write(socket1,mesg_nego,3);*/
  42. mesg_nego[2]=33;/* REMOTE FLOW CONTROL */
  43. /*write(socket1,mesg_nego,3);*/
  44. /*mesg_nego[1]=250;*/
  45. /*mesg_nego[3]=1;*/
  46. /*mesg_nego[4]=255;*/
  47. /*mesg_nego[5]=240;*/
  48. /*write(socket1,mesg_nego,3);*/
  49. printf("\n\n" );
  50. }
  52. /*lancement des options de session*/
  53. LANCEMENT (socket1)
  54. {
  55. }
  58. /*procedure de negociation d'option telnet*/
  59. NEGOCIATION (buffer_RX,socket1,i)
  60. {
  61. unsigned char *mess_nego11,*rep_mess_nego1;
  62. int socket11,j,k;
  63. /*int socket1;*/
  64. socket11=socket1;
  65. j=i;
  66. rep_mess_nego1=mess_nego11=buffer_RX;
  67. printf("\n\n\nDebut de nego" );
  68. printf("\nvaleur de j=%d \n valeur des octets reçus:  ",j);
  69. for(k=0;k<j+1;k++)
  70. printf("\noctet %d= %d  ",k,*(mess_nego11+k));
  71. /*printf("\nN° traitement des  types de message %d  %d %d valeur de la socket %d",*mess_nego11,*(mess_nego11+1),*(mess_nego11+2),socket1);*/
  72. switch(*(mess_nego11+1))
  73. {
  74. case 250:
  75. printf("\nSB %d demande de sous negociation",*(mess_nego11+1));
  76. SOUS_OPTION_NEGOCIEE(mess_nego11,socket11);
  77. break;
  78. case 251:
  79. printf("\nWILL %d demande de negociation",*(mess_nego11+1));
  80. OPTION_NEGOCIEE(mess_nego11,socket11);
  81. break;
  82. case 252:
  83. printf("\nWONT %d refus de negociation",*(mess_nego11+1));
  84. OPTION_NEGOCIEE(mess_nego11,socket11);
  85. *(rep_mess_nego1+1)=254;
  86. write(socket1,rep_mess_nego1,3);
  87. printf("\nReponse a WONT = %d",*(rep_mess_nego1+1));
  88. break;
  89. case 253: printf("\nDO %d demande de negociation",*(mess_nego11+1));
  90. OPTION_NEGOCIEE(mess_nego11,socket11);
  91. break;
  92. case 254: printf("\nDONT %d refus de negociation",*(mess_nego11+1));
  93. OPTION_NEGOCIEE(mess_nego11,socket11);
  94. *(rep_mess_nego1+1)=252;
  95. write(socket1,rep_mess_nego1,3);
  96. printf("\nReponse a WONT = %d",*(rep_mess_nego1+1));
  97. break;
  98. default: printf("\nErreur de traitement sur negociation N° option %d",*(mess_nego11+1));
  99. break;
  100. }
  102. }
  105. /*N° d'option a negocier*/
  106. OPTION_NEGOCIEE(mess_nego11,socket11)
  107. {
  108. struct termios terminal_out;
  109. speed_t speed_o,speed_i;
  110. int socket12,i;
  111. unsigned char *mess_nego12;
  112. socket12=socket11;
  113. mess_nego12=mess_nego11;
  114. printf("\nProcedure OPTION_NEGOCIEE" );
  116. switch (*(mess_nego12+2))
  117. {
  118. case 1:
  119.  {
  120. printf ("\n Option ECHO" );
  121. if (*(mess_nego12+1)==253)
  122.  {
  123.  printf("\nreponse %d %d %d %d",*(mess_nego12+0),*(mess_nego12+1)=252,*(mess_nego12+2),*(mess_nego12+3));
  124.  i=write(socket11,mess_nego12,4);
  125.  }
  126. }
  127. break;
  128. case 3: {
  129. printf ("\n Option GA" );
  130. }
  132. break;
  133. case 24:
  134. {
  135. printf ("\n Option Terminal type" );
  136. /*printf ("\n Option Terminal type sens de requet %d %d %d %d",*(mess_nego12+0),*(mess_nego12+1),*(mess_nego12+2),*(mess_nego12+3));*/
  137. *(mess_nego12+1)=251;
  138. i=write(socket11,mess_nego12,3);
  139. /*printf("\nReponse envoyee i= %d, %d %d %d %d",i,*(mess_nego12+0),*(mess_nego12+1),*(mess_nego12+2),*(mess_nego12+3));*/
  140. }
  141. break;
  142. case 31: {
  143. printf("\nOption NAWS" );
  144. /*printf("\nEnvoie de la sous option direct" );*/
  145. if((mess_nego12=realloc(mess_nego12,10*sizeof(unsigned char)))==NULL)
  146. printf("\nrealloc echouee sur SB 31" );
  147. *(mess_nego12+0)=255;
  148. *(mess_nego12+1)=250;
  149. *(mess_nego12+2)=31;
  150. *(mess_nego12+3)=0;
  151. *(mess_nego12+4)=80;
  152. *(mess_nego12+5)=0;
  153. *(mess_nego12+6)=24;
  154. *(mess_nego12+7)=255;
  155. *(mess_nego12+8)=240;
  156. /*printf("\nmessage a envoye %d %d %d %d %d %d %d %d",*(mess_nego12+0),*(mess_nego12+1),*(mess_nego12+2),*(mess_nego12+3),*(mess_nego12+4),*(mess_nego12+5),*(mess_nego12+6),*(mess_nego12+7));*/
  157. i=write(socket11,mess_nego12,9);
  158. /*printf("\nReponse NAWS envoyee" );*/
  159. }
  160. break;
  161. /*case 32:
  162. {
  163.  printf("\nOption Terminal speed" );*/
  164.  /*printf("\nSous option Terminal speed N° 32" );*/
  165.  /*printf ("\n Option Terminal speed sens de requet %d",*(mess_nego12+3));*/
  167.  /*}*/
  168. /*break;*/
  169. case 33: {
  170. printf ("\nOption LFLOW" );
  171. if (*(mess_nego12+1)==253)
  172. {
  173. if((mess_nego12=realloc(mess_nego12,6*sizeof(unsigned char)))==NULL)
  174. printf("\n Erreur fatal reallocation de memoire OPTION_NEGOCIEE N° 33" );
  175. *(mess_nego12+0)=255;
  176. *(mess_nego12+1)=250;
  177. *(mess_nego12+2)=33;
  178. *(mess_nego12+3)=1;
  179. *(mess_nego12+4)=255;
  180. *(mess_nego12+5)=240;
  181. /*printf("\nReponse %d %d %d ",*(mess_nego12+0),*(mess_nego12+1),*(mess_nego12+2));*/
  182. i=write(socket12,mess_nego12,6);
  183. printf("\nMessage reponse envoyé %d %d %d %d %d %d ",*(mess_nego12+0),*(mess_nego12+1),*(mess_nego12+2),*(mess_nego12+3),*(mess_nego12+4),*(mess_nego12+5));
  184. }
  185. }
  186. break;
  187. /*case 36: printf("\nOption d'environnement" );*/
  188. /*break;*/
  189. default:
  190. {
  191. printf("\noption inconnue ou non negociee\nnombre de carateres de mess_nego recu %d:",sizeof(mess_nego12));
  192. for(i=0;i<sizeof(mess_nego12);i++)
  193. printf(" i=%d mess_nego= %d",i,*(mess_nego12+i));
  194. if (*(mess_nego12+1)==251)
  195. *(mess_nego12+1)=254;
  196. else
  197. *(mess_nego12+1)=252;
  198. printf("\nreponse envoyee: " );
  199. for(i=0;i<sizeof(mess_nego12);i++)
  200. printf(" i=%d mess_nego= %d",i,*(mess_nego12+i));
  201. write(socket12,mess_nego12,sizeof(mess_nego12));
  202. printf("\nwrite passe" );
  203. }
  204. break;
  205. free(mess_nego12);
  206. }
  208. }
  210. /*Sous option negociee*/
  211. SOUS_OPTION_NEGOCIEE(mess_nego11,socket11)
  212. {
  213. int i,j;
  214. unsigned char *terminal,*mess_nego13,*rep_mess_nego,*vitesse,DEB_SB,FIN_SB,donnee[4];
  215. struct termios terminal_out;
  216. speed_t speed_o,speed_i;
  217. mess_nego13=mess_nego11;
  218. DEB_SB=250;
  219. FIN_SB=240;
  220. donnee[0]="9";
  221. donnee[1]="6";
  222. donnee[2]="0";
  223. donnee[3]="0";
  224. printf("\nProcedure SOUS_OPTION_NEGOCIEE sous option a negocier valeur de la SB %d",*(mess_nego13+2));
  225. switch (*(mess_nego13+2))
  226. {
  227. case 24:{
  228. /*Recuperation d'info sur le treminal*/
  229. printf("\nSous option Type de terminal actuel: %s,\nlongueur de la chaine terminal %d,\nsizeof de messnego13 %d,\nstrlen+sizeof %d,\nstrlen de messnogo13  %d",terminal=getenv("TERM" ),strlen(terminal),sizeof(mess_nego13),i=(strlen(terminal)+strlen(mess_nego13)),strlen(mess_nego13));
  230. printf("\nsequence recue taille du message %d %d %d  %d %d %d",*(mess_nego13+0),*(mess_nego13+1),*(mess_nego13+2),*(mess_nego13+3),*(mess_nego13+4),*(mess_nego13+5));
  231. if((mess_nego13=realloc(mess_nego13,(i+1)*sizeof(unsigned char)))==NULL)
  232. printf("\nrealloc echouee sur SB 24" );
  233. printf("\ntaille de mess_nego13 %d",strlen(mess_nego13));
  234. if((terminal=(char*) calloc (strlen(getenv("TERM" )),sizeof (char)))==NULL)
  235. printf("\nImpossible d'allouer la memoire terminal" );
  236. terminal=getenv("TERM" );
  237. *terminal=toupper(*terminal);
  238. printf("\nterminal =%s",terminal);
  239. /*strcpy(terminal,getenv("TERM" );*/
  240. toupper(*terminal);
  241. printf("\nContenu de terminal :%s",*terminal);
  242. printf("\nen majuscule" );
  243. for(j=0;j<(strlen(getenv("TERM" )));j++)
  244. {
  245. *(terminal+j)=toupper(*(terminal+j));
  246. printf("%d %c",j,*(terminal+j));
  247. }
  248. strcat(mess_nego13,terminal);
  249. printf("\nsequence du message modifié %d %d %d %d %d %d ",*(mess_nego13+0),*(mess_nego13+1),*(mess_nego13+2),*(mess_nego13+3)=0,*(mess_nego13+4),*(mess_nego13+5));
  250. printf("\nchaine de terminal %s",terminal);
  251. memmove((mess_nego13+4),terminal,strlen(terminal)+1);
  252. printf("\nsequence recue modifiee %d %d %d %d %c%c%c%c%c%c %d %d %d",*(mess_nego13+0),*(mess_nego13+1),*(mess_nego13+2),*(mess_nego13+3)=0,*(mess_nego13+4),*(mess_nego13+5),*(mess_nego13+6),*(mess_nego13+7),*(mess_nego13+8),*(mess_nego13+9),*(mess_nego13+10)=255,*(mess_nego13+11)=240,*(mess_nego13+12)=0);
  253. i=write(socket11,mess_nego13,13);
  254. printf("\nnombre de caracteres ecris= %d\n",i);
  255. i=write(1,"mess_nego13",13);
  256. printf("\ndeuxieme valeur de i=%d",i);
  257. free (mess_nego13);
  258. }
  259. break;
  260. case 32:{
  261. /*printf("\nSous option Terminal speed" );
  262. printf("\nsequence recue taille du message %d %d %d %d %d %d %d %d",*(mess_nego13+0),*(mess_nego13+1),*(mess_nego13+2),*(mess_nego13+3),*(mess_nego13+4),*(mess_nego13+5),*(mess_nego13+6),strlen(mess_nego13));
  263. printf("\nRecuperation de la vitesse du terminal" );*/
  264. tcgetattr(STDIN_FILENO,&terminal_out);
  265. speed_o=cfgetospeed(&terminal_out);
  266. /*printf("\nvitesse du terminal en out %d",speed_o);*/
  267. if((mess_nego13=realloc(mess_nego13,(strlen(mess_nego13)+11)*sizeof(unsigned char)))==NULL)
  268. printf("\nrealloc echouee sur SB 32" );
  269. /*printf("\nmodification du *(mess_nego13+3) %d",*(mess_nego13+3)=0);*/
  271. i=write(1,"mess_nego13",13);
  272. free (mess_nego13);
  274. }
  275. break;
  276. case 33:{
  277. printf("\nSous option LFLOW" );
  278. printf("\nsequence recue taille du message %d %d %d %d %d %d\n",*(mess_nego13+0),*(mess_nego13+1),*(mess_nego13+2),*(mess_nego13+3),*(mess_nego13+4),*(mess_nego13+5));
  279. }
  280. break;
  281. case 36: printf("\nSous option environnement" );
  282. break;
  283. default: printf("\nSous option non negociee" );
  284. break;
  285. }
  286. }
  288. /*timeout sur connect*/
  289. TIMEOUT()
  290. {
  291. printf("\nDelai d'attente depasse 30s d'ecoule\n\n" );
  292. raise(SIGTERM);
  293. }
  295. extern int errno;
  296. /*DEBUT DE LA ROUTINE PRINCIPALE*/
  297. main(argc,argv)
  298. int argc;
  299. char **argv;
  300. {/*Debut du main*/
  302. unsigned char *buffer_RX,*buffer_TX;
  303. unsigned char *mess_nego;
  304. int socket1,connection,deblocage,nb_lu,nb_ec,i,j,k,flag_nego_option,fdisset,verif_select;
  305. int var_etat,etat;
  306. struct sockaddr_in addr_distant;
  307. struct servent *service_distant;
  308. struct termios term_initial,term_com,sock_ini,sock_com;
  309. struct timeval delai;
  310. struct sigaction delai_av,delai_ap,act_time;
  311. fd_set set;
  312. flag_nego_option=0;
  315. /*Preparation des parametres de  connection*/
  316. printf("\nadresse %s",argv[1]);
  317. service_distant=getservbyname("telnet","tcp" );
  318. memset(&addr_distant,0,sizeof(struct sockaddr_in));
  319. addr_distant.sin_family=PF_INET;
  320. addr_distant.sin_port=htons(service_distant->s_port);
  321. if((inet_aton(argv[1],&addr_distant.sin_addr.s_addr))==0)
  322. printf("\nimpossible de remplir le  champ s_addr" );
  323. printf("\nvaleur apres inet_aton() \t%08X",ntohl(addr_distant.sin_addr.s_addr));
  325. /*Creation du point de communicatio*/
  326. printf("\ncration de la socket" );
  327. if((socket1=socket(AF_INET,SOCK_STREAM,0))<0)
  328. printf("\nCreation de socket echouee" );
  329. printf("\nNumero de socket \t%d",socket1);
  331. /*Mis en place du mode non bloquant pour la socket*/
  332. printf("\nDeblocage de la socket" );
  333. if((fcntl(socket1,F_SETFL,O_NONBLOCK))<0)
  334. printf("\nProbleme sur fcntl" );
  335. printf("\naddr_distant.sin_family \t%d",addr_distant.sin_family);
  336. printf("\naddr_distant.sin_port\t%d",addr_distant.sin_port);
  337. printf("\naddr_distant.sin_addr.s_addr\t%s\n",inet_ntoa(addr_distant.sin_addr.s_addr));
  341. /*Procedure de mis en place du mode non bloquant sur stdin*/
  342. tcgetattr(STDIN_FILENO,&term_initial);
  343. tcgetattr(STDIN_FILENO,&term_com);
  344. term_com.c_iflag &=ICRNL;
  345. term_com.c_lflag &=~ICANON;/*,ECHONL,ICANON,IEXTEN);*/
  346. term_com.c_lflag &=~ECHO;
  347. term_com.c_cc[VTIME]=0;
  348. term_com.c_cc[VMIN]=0;
  349. if(tcsetattr(STDIN_FILENO,TCSANOW,&term_com)!=0)
  350. printf("\ntransformation du terminal echoue" );
  351. printf("\nPasssage du terminal en mode brut OK" );
  353. /*Preparation du timer de connexion echouee*/
  354. printf("\ntentative de connection %d etat = %d",connection=-1,var_etat=0);
  355. act_time.sa_handler=TIMEOUT;
  356. act_time.sa_flags=0;
  357. deblocage=sigaction(SIGALRM,&act_time,0);
  358. var_etat=alarm(10);
  359. printf("\nDelai d'attente fixe a %d",var_etat);
  361. /*Connection au point distant avec 30 secs de delai max*/
  362. etat=-1;
  363. while(connection!=0)
  364. {
  365. connection=connect(socket1,(struct sockaddr*)&addr_distant,sizeof(addr_distant));
  366. if (errno==EINPROGRESS&&etat!=1)
  367. printf("\nDemande de connection  Changement de var_etat=%d\n",etat=1);
  368. if (errno==EALREADY&&etat!=2)
  369. printf("\nDemande de connection en cours connect %d valeur de errno %s %d de etat=%d",connection,strerror(errno),errno,etat=2);
  370. if(errno==234)
  371. {
  372. var_etat=alarm(0);
  373. printf("\nconnection OK=%d valeur etat %d",connection=0,etat=3);
  374. }
  375. if(connection==0&&etat!=3)
  376. {
  377. var_etat=alarm(0);
  378. printf("\nconnection OK=%d valeur du timeout %d",connection=0,ETIMEDOUT);
  379. }
  380. }/*fin de tentative de Connection au point distant*/
  382. MSG_DE_NEGO(socket1);
  383. /*on ebtre dans la boucle de communication*/
  384. while(connection ==0)
  385. {/*Debut du while 1*/
  387. /*Initialisation de l'ensemble des descripteurs a multiplexer*/
  388. FD_ZERO (&set);
  389. FD_SET (socket1,&set);
  390. FD_SET (STDIN_FILENO,&set);
  392. /*Selection de l'ensemble des descripteurs a multiplexer en reception*/
  393. if((verif_select=select(socket1+1,&set,&set,NULL,&delai))<0)
  394. break;
  395. if(verif_select>3)
  396. printf("\nvaleur de verif_select = % d",verif_select);
  397.       if(FD_ISSET(STDIN_FILENO,&set))
  398.      
  399. {/*Debut du if*/
  400. /*Initialisation d un bloc memoire pour un caractere*/
  401. if((buffer_RX=(char*) calloc (LG_BUFFER,sizeof (char)))==NULL)
  402. printf("\nImpossible d'allouer la memoire buffer_RX STDIN_FILENO" );
  403. else memset(buffer_RX,NULL,sizeof (char));
  404. nb_lu=0;
  405. if((nb_lu=read(STDIN_FILENO,buffer_RX,LG_BUFFER))<0)
  406. printf("\nerreur sur lecture d'entree ou rien a ecrire retour de nb_lu %d",nb_lu);
  407. if(nb_ec=write(socket1,buffer_RX,nb_lu))
  408. printf ("\nun caractere ecrit sur socket %d",*buffer_RX);
  409. free(buffer_RX);
  410. }/*Fin du if*/
  413. if(FD_ISSET(socket1,&set))
  414. {/*Debut du if*/
  415. if((buffer_RX=(unsigned char*) calloc (LG_BUFFER,sizeof (unsigned char)))==NULL)
  416. printf("\nImpossible d'allouer la memoire buffer_RX pour socket1" );
  417.  nb_lu=0;
  418.  i=0;
  420.  while((nb_lu=recv(socket1,buffer_RX,LG_BUFFER))>=0)
  421.  {/*Debut du while*/
  422.  if(nb_lu==0)
  423.  printf("\nValeur de connection = %d connection fermee par le distant",connection=1);
  424.    if(buffer_RX[0]==255)
  425.    {/*Un caractere IAC est arrive*/
  426.    i=1;
  427.    flag_nego_option=1;
  428.    /**mess_nego=*buffer_RX;*/
  429.     while(flag_nego_option==1)
  431.     {/*debut du while*/
  432.     /*printf ("\nvaleur de i=%d",i);*/
  433.     if((buffer_RX=realloc(buffer_RX,(i+1)*sizeof(unsigned char)))==NULL)
  434.     printf("\nErreur sur attribution memoire" );
  435.     nb_lu=read(socket1,buffer_RX+i,LG_BUFFER);
  437.      if(*(buffer_RX+i)>=236 && *(buffer_RX+i)<255)
  439.      { /*Phase de test 250>IAC<255*/
  440.      ++i;
  441.      if((buffer_RX=realloc(buffer_RX,(i+1)*sizeof(unsigned char)))==NULL)
  442.      printf("\nErreur sur attribution memoire" );
  443.      nb_lu=read(socket1,buffer_RX+i,LG_BUFFER);
  444.       if(buffer_RX[i-1]==250)/*detection de SB*/
  445.       {
  446.        do/*lecture jusqu'a SE*/
  447.        {
  448.        ++i;
  449.        if((buffer_RX=realloc(buffer_RX,(i+1)*sizeof(unsigned char)))==NULL)
  450.        printf("\nErreur sur attribution memoire" );
  451.        nb_lu=read(socket1,buffer_RX+i,LG_BUFFER);
  452.        }while(buffer_RX[i]!=240);
  453.       }
  454.      *(buffer_RX+(i+1))=0;
  455.      NEGOCIATION(buffer_RX,socket1,i);
  456.      }
  458.     flag_nego_option=0;
  459.     free(buffer_RX);
  460.     /*printf("\nle free(mes_nego) est ok valeur de l'adresse mess_nego %d %d\n",mess_nego,*mess_nego);*/
  461.     memset(buffer_RX,0,strlen(buffer_RX));
  462.     ++i;
  463.     } /*fin de while(flag_nego_option)*/
  464.     /*printf("\nfin du if(buffer_RX[0]==255)" );*/
  466.    } /*fin de if(buffer_RX[0]==255)*/
  469.    else
  471.    {/*Debut du else*/
  472.    printf(
  473.    write(STDOUT_FILENO,buffer_RX,nb_lu);
  474.    } /*Fin du else*/
  475.  nb_lu=0;
  476.  }/*fin du while((nb_lu=recv(socket1,buffer_RX,LG_BUFFER))>0)*/
  477.  free(buffer_RX);
  478.  memset(buffer_RX,0,strlen(buffer_RX));
  480. }/*Fin du if*/
  481. }/*Fin du while connection*/
  482. printf("\nSortie de boucle sans raison nb_lu = %d",nb_lu);
  483. close(socket1);
  484. if((tcsetattr(STDIN_FILENO,TCSANOW,&term_initial))!=0)
  485. printf("\nremeise en etat du stdin echoue\n" );
  486. printf ("\nSortie du prog\n" );
  488. }/*fin du main*/


 
Quand je le lance ce client telnet je constate des defaut et je ne comprends pas pourquoi.
login: ^@^@^@^@^@^@^@^@
pourquoi au momment de demander le login une suite de caracters est envoyé ce qui m'oblige a taper deux fois le login password?

mood
Publicité
Posté le 07-05-2007 à 16:19:58  profilanswer
 

n°1570600
yartempion
Posté le 05-06-2007 à 22:08:21  profilanswer
 

Bonjour,
J'aii posé la même question sur d'autres sites et  c'est à croire que personne n'a jamais essayé d'ecrire un client telnet de sa vie.
Y'a t'il quelqu'un qui connaisse cette problématique?
Vraiment jai l'impression d'avoir epuisé le sujet sans  arrivé a trouver de solution.
A l'aide  merci même si vous ne faites que des susjections.

n°1570684
Taz
bisounours-codeur
Posté le 06-06-2007 à 09:14:59  profilanswer
 

à croire que personne n'a envie de lire ta soupe.

n°1570753
yartempion
Posté le 06-06-2007 à 10:54:45  profilanswer
 

C'est bien dommage, je pense que ça en aiderai plus d'un d'avoir un module client que l'on puisse contrloer.

n°1570754
_darkalt3_
Proctopathe
Posté le 06-06-2007 à 10:56:02  profilanswer
 

t'as passé le debugger ?


---------------
Töp of the plöp
n°1570923
yartempion
Posté le 06-06-2007 à 13:55:20  profilanswer
 

Le debuger je ne connais pas mais ça compile sans pb je pense qu'il y quelque chose que je negocie mal avec le serveur distant au niveua du control de flux.
Sur certains routeurs tout se passe bien je n'ai a taper qu'une fois le mot de passe mais la le controle de flux n'est pas négocié.
Sur d'autre ou sur des machines unix le controle de flux est négocié je dois taper deux fois le login password.
Et sur d'autre type routeur CISCO idem deux fois login password et a chaque fois c'est le login qui est incorrect. Je reçois avant chaque demande d'authentification cette petite séquence de caractéres plus ou moins longue selon les équipements que je n'arrive pas a interpréter

n°1570927
_darkalt3_
Proctopathe
Posté le 06-06-2007 à 14:02:19  profilanswer
 

Debugger alors, rien que pour suivre la cinématique exacte de ton code. C'est pas parce que ca compile que ca fonctionne, ca se saurait.


---------------
Töp of the plöp
n°1570977
yartempion
Posté le 06-06-2007 à 14:43:16  profilanswer
 

Quand je lance le programme ça fonctionne et j'obtiens le resultat escompté a un defaut prés.
Au départ je mettais des message a chaque entrée et sortie de boucle ,test ou d'appel fonction tout se passe comme prévue le seul hic c'est cette sequenceet le fait qu'il faille passer deux fois par le login password. Actuellement on peut suivre le code grace aux message qu'il renvoie a chaque etape et on peut constater que le processus s'execute comme prévu.


Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C

  Client telnet

 

Sujets relatifs
[Java]Obtenir l'IP d'un clientOffice sur un poste client
comment ouvrir le client de messagerie par défaut en c# ?problème jeux devinette client/serveur
[C] Client/Serveur : tchat, envoi à tous les clientsproblème d'affichage client telnet
client telnet en cclient telnet
[socket TCP] gestion de la deconnexion d1 client telnet[Java] développer un client Telnet
Plus de sujets relatifs à : Client telnet

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo
Page générée en 0.151 secondes

Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR