1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
|
//
// Send ICMP ECHO_REQUEST packets to network hosts /////////////////////////////
static void ping(const char *host); ////////////////////////////////////////////
//
//
static char *hostname = NULL; // préalable rassurant.
//
//
static int in_cksum(unsigned short *buf, int sz) ///////////////////////////////
{
int nleft = sz;
int sum = 0;
unsigned short *w = buf;
unsigned short ans = 0;
//
while (nleft > 1) {
sum += *w++;
nleft -= 2;
}
//
if(nleft == 1) {
*(unsigned char *) (&ans) = *(unsigned char *) w;
sum += ans;
}
//
sum = (sum >> 16) + (sum & 0xFFFF);
sum += (sum >> 16);
ans = ~sum;
return(ans);
}
//
//
static int imppkt(struct icmp pkt, char *sens) /////////////////////////////////
{
printf("\nimppkt: Ok impression du paquet %s :\n",sens);
printf("imppkt: type=%u, code=%u, chksum=%u\n",pkt.icmp_type,pkt.icmp_code,pkt.icmp_cksum);
return(0);
}
//
//
unsigned int ip2long(char *s) //////////////////////////////////////////////////
{
struct sockaddr_in n;
inet_aton(s,&n.sin_addr);
return ntohl(n.sin_addr.s_addr);
}
//
//
char* long2ip(unsigned int v) //////////////////////////////////////////////////
{
struct in_addr x;
x.s_addr=htonl(v); // passe dans l' ordre reseau
return inet_ntoa(x); // et convertit
}
//
//
char* long2ipnr(unsigned int v) //////////////////////////////////////////////////
{
struct in_addr x;
x.s_addr= v; // ne passe pas dans l' ordre reseau
return inet_ntoa(x); // et convertit
}
//
//
static void noresp(int ign) ////////////////////////////////////////////////////
{
printf("noresp: No response from %s\n", hostname);
exit(0);
}
//
//
static void read_server(SOCKET sock, char *buffer)
{
char *p;
int n = 0;
printf("read_server: sock=%d\n", sock); // ici, sock est un entier qui a été creéé par
// // connect(sock,(SOCKADDR *) &sin, sizeof(SOCKADDR)) , et
// // juste avant, on avait sock qui était une socket en stream :
// // SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);
{
if((n = recv(sock, buffer, BUF_SIZE - 1, 0)) < 0)
{
perror("recv()");
exit(errno);
}
if(n == 0)
{
printf("read_server: Connection lost\n");
exit(EXIT_FAILURE);
}
buffer[n] = 0;
p = strstr(buffer, CRLF);
if(p != NULL)
{
*p = 0;
}
}
}
//
//
static void write_server(SOCKET sock, char *buffer)
{
if(send(sock, buffer, strlen(buffer), 0) < 0)
{
perror("send()");
exit(errno);
}
}
//
//
char* monip(int argc, const char *host) ////////////////////////////////////////
{
struct hostent *h, *hh; // h et hh pointent sur des structures hostent.
// h est celle obtenue avant le ping-aller par gethostbyname(mon isp)
// hh est celle obtenue avant le pong-retour par gethostbyaddr(sonIP)
struct icmp *pkt; // pkt pointe sur une structure icmp.
struct sockaddr_in pingaddr, sin;
char *pmonIP;
unsigned long addr; // le paquet a été envoyé là bas
int c, pingsock, selectold=0, type;
char buffer[16];
char command[BUF_SIZE];
char line[LIN_SIZE];
char packet[DEFDATALEN + MAXIPLEN + MAXICMPLEN]; // packet est un tableau de caractères.
socklen_t len;
// SOCKADDR_IN sin; // déjà définie qq lignes + haut
// SOCKET sock = socket(AF_INET, SOCK_STREAM, 0); // à quoi ça sert ???
//
if(argc<2 || strcmp(host,"-h")==0) {
printf("\nmonip: Ce programme doit résolver [host],\n");
printf("monip: puis y envoyer un echorequest,\n");
printf("monip: puis en contrôler la teneur et la destination,\n");
printf("monip: puis contrôler la teneur et la provenance du retour.\n\n");
printf("monip: Ex: sudo ./mtn wanadoo.fr\n\n");
exit(1);
}
//
if((pingsock = socket(AF_INET, SOCK_RAW, 1)) < 0) { // 1 == ICMP
perror("monip: creating a raw socket");
exit(1);
}
else printf("\nmonip: Ok pour le premier socket qui sert au ping.\n");
//
// drop root privs ifrunning setuid
setuid(getuid());
//
memset(&pingaddr, 0, sizeof(struct sockaddr_in)); // memset() remplit les n premiers octets
// (avec n=sizeof(struct sockaddr_in)) de la zone mémoire pointée par s (s=&pingaddr)
// avec l’octet c (c=0).
pingaddr.sin_family = AF_INET; // pingaddr est la struct sockaddr_in pour laquelle
// vient d'être allouée de la mem.
if(!(h = gethostbyname(host))) {
fprintf(stderr, "monip: unknown host %s\n", host);
exit(1);
}
memcpy(&pingaddr.sin_addr, h->h_addr, sizeof(pingaddr.sin_addr)); // memcpy() copie n octets
// (n= sizeof(pingaddr.sin_addr)) depuis la zone mémoire src (src=h->h_addr) vers
// la zone mémoire dest (dest=&pingaddr.sin_addr); ce qui veut dire qu'on prend le membre
// h_addr de la struct hostent nommée h (qui vient d'être résolue par gethostbyname) pour
// le placer à &pingaddr.sin_addr.
hostname = h->h_name;
printf("monip: h->h_name=%s (résolu par gethostbyname sur ce socket qui est pingsock)\n",hostname);
//
pkt = (struct icmp *) packet; // rappel, pkt pointe sur une structure icmp;
// ici elle s'appelle packet.
memset(pkt, 0, sizeof(packet));
pkt->icmp_type = ICMP_ECHO; // le membre icmp_type de la struct icmp
// pointée par pkt est rempli par ICMP_ECHO
pkt->icmp_cksum = in_cksum((unsigned short *) pkt, sizeof(packet)); // le cksum est
// rempli aussi.
//
c = sendto(pingsock, packet, sizeof(packet), 0, (struct sockaddr *) &pingaddr, sizeof(struct sockaddr_in));
// ssize_t sendto(int s, const void *buf, size_t len, int flags,
// const struct sockaddr *to, socklen_t tolen);
if(c < 0 || c != sizeof(packet)) {
if(c < 0) perror("monip: sendto");
fprintf(stderr, "monip: write incomplete\n");
exit(1);
}
else { // alors par ici je peux essayer d'imprimer le paquet envoyé :
if(imppkt(*pkt, "envoyé")==-1) {
printf("monip: Problème d'impression du paquet.\n");
}
else {
addr=(unsigned int)pingaddr.sin_addr.s_addr; // le paquet a été envoyé là-bas.
printf("monip: adresse dest.=%u\n", addr); // je la veux en IP pointée.
//
// long2ip
printf("monip: long2ip(%u) => %s\n", addr, long2ip(addr) );
//
if(!(h = gethostbyname(host))) {
fprintf(stderr, "monip: unknown host %s\n", host);
exit(1);
}
else {
printf("monip: host de dest.=%s (le même h->h_name que résolu ci dessus)\n\n", h->h_name);
}
}
}
//
signal(SIGALRM, noresp);
alarm(5); // give the host 5000ms to respond
// listen for replies
while (1) {
struct sockaddr_in from;
size_t fromlen = sizeof(from);
//
//ssize_t recvfrom(int s, void *buf, size_t len, int flags,
// struct sockaddr *from, socklen_t *fromlen);
printf( "monip: avant recvfrom\n");
if((c = recvfrom(pingsock, packet, sizeof(packet), 0,
(struct sockaddr *) &from, &fromlen)) < 0) {
if(errno == EINTR)
continue;
perror("monip: recvfrom");
continue;
}
//
close(pingsock); // je n'ai plus besoin de ça.
printf( "monip: Ok après recvfrom\n");
//
if(c >= 76) { // ip + icmp
struct iphdr *iphdr = (struct iphdr *) packet;
//
pkt = (struct icmp *) (packet + (iphdr->ihl << 2)); // skip ip hdr
if(pkt->icmp_type == ICMP_ECHOREPLY) {
printf("monip: %s is alive !\n", hostname);
if(imppkt(*pkt, "reçu")==-1) {
printf("monip: Problème d'impression du paquet.\n");
}
else { // l'impression du paquet revenu est Ok
addr=from.sin_addr.s_addr; // from est une struct sockaddr_in,
// dont un membre nommé sin_addr est une struct in_addr,
// dont le seul membre est s_addr.
printf("monip: adresse source=%u\n", addr);
//
// long2ip
printf( "long2ip(%u) => %s\n", addr, long2ip(addr) );
//
// pour l'instant, AF_INET qui est le type vaut 2
if((hh=gethostbyaddr(&addr, sizeof(addr), 2))==NULL) {
// struct hostent *gethostbyaddr(const void *addr, socklen_t len, int type);
perror("monip: gethostbyaddr()");
printf("monip: gethostbyaddr() pas Ok\n\n");
}
else {
// gethostbyaddr a créé une struct hostent qui s'appeller hh
hostname = hh->h_name;
printf("monip: host de source du retour=%s (hh->h_name)\n", hostname);
printf("monip: gethostbyaddr() Ok\n\n");
printf("monip: adresse src du retour=%s\n", long2ip(iphdr->saddr)); // IP pointée.
// printf("monip: adresse dst du retour=%s\n", long2ip(iphdr->daddr)); // IP pointée.
printf("monip: adr. dst nr du retour=%s\n\n", long2ipnr(iphdr->daddr)); // IP pntnr.
//
pmonIP=long2ipnr(iphdr->daddr); //
} // c'est donc ici la fin du else
}
break;
} //
} //
}
return pmonIP; //
}
//
// pour voir si le port 23 attend du monde :
// nmap 127.0.0.1 -p 23
//
// pour voir ce que le client et le serveur se disent : (là ça cause, 1 ou 2 paquets +/- lisibles avec le -A)
// sudo tcpdump -vvvAXXti ppp0 -s 0 tcp port 23
// sudo tcpdump -vvvAXXi ppp0 -s 0 (tous les paquets avec timestamp)
// sudo tcpdump -vvvAXXti ppp0 -s 0 (tous les paquets mais sans timestamp)
//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
static int Stn(char* paddrIP)
{
unsigned int addrIPnr, *paddrIPnr;
unsigned int v;
printf("Stn: là, monIP=%s (=%u en %%u)\n\n",paddrIP,ip2long(paddrIP));
SOCKET sock = socket(AF_INET, SOCK_STREAM, 0); // ici sock est une socket en stream
char command[BUF_SIZE];
char line[LIN_SIZE];
unsigned char *buffer_RX,*buffer_TX;
int connection, etat, flag_nego_option, i, nb_lu, nb_ec, ntour=0, var_etat, verif_select, selectold=0;
struct sockaddr_in sin;
struct termios term_initial;
struct timeval delai;
fd_set rd, wr, er;
// creation d'un socket avec l'adresse que je construis ici :
// pour l'instant il faut ma propre sin_addr; c'est une struct in_addr,
sin.sin_addr.s_addr = htonl(ip2long(paddrIP)); // dont le seul membre est s_addr... ZZZ nr avec le htonl
// // (de type in_addr_t)
sin.sin_port = htons(PORT); // PORT=23 pour telnet.
sin.sin_family = AF_INET; // pour l'instant, AF_INET qui est le type vaut 2
printf("Stn: Contrôles :\n");
// printf("Stn: sin.sin_addr=%u\n",sin.sin_addr); // c'est une sin_addr mais il affiche
printf("Stn: sin.sin_port=%d\n",ntohs(sin.sin_port)); // son membre s_addr en unsigned
printf("Stn: sin.sin_family=%d\n",AF_INET);
printf("Stn: sin.sin_addr.s_addr=%u, (=%s) (nr)\n\n",sin.sin_addr.s_addr, // long dans l'ordre réseau
long2ip(sin.sin_addr.s_addr));
printf("Stn: try to connect :\n");
//
/*Connection au point distant avec 30 secs de delai max*/
etat=-1;
connection=-1;
while(connection!=0)
{
if((connection=connect(sock,(SOCKADDR *) &sin, sizeof(SOCKADDR))) == SOCKET_ERROR) {
perror("Stn: connect()");
exit(errno);
}
else printf("Stn: connect() Ok, connexion=%d\n",connection);
//
// printf("Stn: try to log in, now : (CRLF=\"%s\")\n",CRLF);
// printf("Stn: try to log in, now :\n");
if (errno==EINPROGRESS&&etat!=1)
printf("\nDemande de connection Changement de var_etat=%d\n",etat=1);
if (errno==EALREADY&&etat!=2)
printf("\nDemande de connection en cours connect=%d valeur de errno %d %s de etat=%d", connection, errno, strerror(errno), etat=2);
if(errno==234) {
var_etat=alarm(0);
printf("\nconnection OK=%d valeur etat %d",connection=0,etat=3);
}
if(connection==0&&etat!=3) {
var_etat=alarm(0);
printf("Stn: connection=%d OK valeur du timeout %d\n",connection,ETIMEDOUT);
}
} /*fin de Connection au point distant*/
//
MSG_DE_NEGO(sock);
//
/* on entre dans la boucle de communication */
while(connection == 0) { //DVA: c'est-à-d. tant que la connexion est Ok, car elle vaut 0 quand Ok.
/*Initialisation de l'ensemble des descripteurs a multiplexer*/
FD_ZERO(&rd);
FD_ZERO(&wr);
FD_SET(sock, &rd);
FD_SET(sock, &wr);
FD_SET(0, &rd);
FD_SET(0, &wr); // ça, il le faut pour multiplexer le sock et stdin-0.
// printf("DVA: FD_ISSET(sock, &rd)=%d\n",FD_ISSET(sock, &rd));
// printf("DVA: FD_ISSET(0, &rd)=%d\n",FD_ISSET(0, &rd));
// printf("DVA: FD_ISSET(sock, &wr)=%d\n",FD_ISSET(sock, &wr));
// printf("DVA: FD_ISSET(0, &wr)=%d\n",FD_ISSET(0, &wr));
ntour++;
/* Selection de l'ensemble des descripteurs a multiplexer en reception */
if(select(sock+1,&rd,&wr,NULL,&delai) != selectold) {
printf("DVA: ntour=%d\n",ntour);
printf("DVA: select(sock+1,&rd,&wr,NULL,&delai)=%d\n",select(sock+1,&rd,&wr,NULL,&delai));
selectold=select(sock+1,&rd,&wr,NULL,&delai);
}
if((verif_select=select(sock+1,&rd,&wr,NULL,&delai))<0) {
printf("DVA: select->errno=%d\n",errno);
perror("select()");
break;
}
if(verif_select>=3)
printf("valeur de verif_select = % d",verif_select);
if(FD_ISSET(0,&rd)) { /*Debut du if de lecture sur le 0 */
/*Initialisation d un bloc memoire pour un caractere*/
if((buffer_RX=(char*) calloc (LG_BUFFER,sizeof (char)))==NULL)
printf("\nImpossible d'allouer la memoire buffer_RX 0");
else memset(buffer_RX,NULL,sizeof (char));
/*printf("\ninitialisation du buffer_RX %d",*buffer_RX);*/
nb_lu=0;
if((nb_lu=read(0,buffer_RX,LG_BUFFER))<0)
printf("\nerreur sur lecture d'entree ou rien a ecrire retour de nb_lu %d",nb_lu);
if(nb_ec=write(sock,buffer_RX,nb_lu))
printf ("\nun caractere ecrit sur socket %d",*buffer_RX);
free(buffer_RX);
} /* Fin du if de lecture sur le 0 */
if(FD_ISSET(sock,&rd)) { /* Debut du if de lecture sur le sock */
if((buffer_RX=(unsigned char*) calloc (LG_BUFFER,sizeof (unsigned char)))==NULL)
printf("\nImpossible d'allouer la memoire buffer_RX pour sock");
nb_lu=0;
i=0;
// ssize_t recv(int s, void *buf, size_t len, int flags); //DVA: j'ajoute un flag=0
while((nb_lu=recv(sock,buffer_RX,LG_BUFFER,0))>=0) { /*Debut du while*/
if(nb_lu==0)
printf("\nValeur de connection = %d connection fermee par le distant",connection=1);
if(buffer_RX[0]==255) // 255=IAC
{ /*Un caractere IAC est arrive*/
i=1;
flag_nego_option=1;
/**mess_nego=*buffer_RX;*/
while(flag_nego_option==1) {/*debut du while*/
/*printf ("\nvaleur de i=%d",i);*/
if((buffer_RX=realloc(buffer_RX,(i+1)*sizeof(unsigned char)))==NULL)
printf("\nErreur sur attribution memoire");
nb_lu=read(sock,buffer_RX+i,LG_BUFFER);
if(*(buffer_RX+i)>=236 && *(buffer_RX+i)<255) { /*Phase de test 250>IAC<255*/
++i;
if((buffer_RX=realloc(buffer_RX,(i+1)*sizeof(unsigned char)))==NULL)
printf("\nErreur sur attribution memoire");
nb_lu=read(sock,buffer_RX+i,LG_BUFFER);
if(buffer_RX[i-1]==250) { /*detection de SB*/
do { /*lecture jusqu'a SE*/
++i;
if((buffer_RX=realloc(buffer_RX,(i+1)*sizeof(unsigned char)))==NULL)
printf("\nErreur sur attribution memoire");
nb_lu=read(sock,buffer_RX+i,LG_BUFFER);
}
while(buffer_RX[i]!=240);
}
*(buffer_RX+(i+1))=0;
NEGOCIATION(buffer_RX,sock,i);
}
flag_nego_option=0;
free(buffer_RX);
/*printf("\nle free(mes_nego) est ok valeur de l'adresse mess_nego %d %d\n",mess_nego,*mess_nego);*/
memset(buffer_RX,0,strlen(buffer_RX));
++i;
} /*fin de while(flag_nego_option)*/
/*printf("\nfin du if(buffer_RX[0]==255)");*/ // 255=IAC
} /*fin de if(buffer_RX[0]==255)*/ // 255=IAC
else { /*Debut du else*/
write(stdout, buffer_RX, nb_lu);
} /*Fin du else*/
nb_lu=0;
} /*fin du while((nb_lu=recv(sock,buffer_RX,LG_BUFFER))>0)*/
free(buffer_RX);
memset(buffer_RX, 0, strlen(buffer_RX));
} /* Fin du if de lecture sur le sock */
} /* Fin du while connection*/
printf("\nSortie de boucle sans raison nb_lu = %d",nb_lu);
close(sock);
//
if((tcsetattr(0,TCSANOW,&term_initial))!=0)
printf("\nremise en etat du 0 echoue\n");
printf ("\nSortie du prog\n");
//
printf("Stn: invite de login :\n");
read_server(sock, line); // lecture de l'invite de login
puts(line); // affichage de celle ci
printf("Stn: envoi de %s+\"%s\"\n\n", "guest", "CRLF");
sprintf(command, "%s%s", "guest", CRLF);
write_server(sock, command);
//
printf("Stn: invite de password :\n");
read_server(sock, line); // lecture de l'invite de password
puts(line); // affichage de celle ci
printf("Stn: envoi de %s+\"%s\"\n", "guest1", "CRLF");
sprintf(command, "%s%s", "guest1", CRLF);
write_server(sock, command);
//
read_server(sock, line);
puts(line);
//
printf("Stn: end of trial.\n"); // on n'arrive pas encore ici, tu rêves ???
return 0;
}
//
//
int main(int argc, char **argv) /////////////////////////////////////////
{
//DVA: argc--;
argv++;
char* paddrIP;
paddrIP=monip(argc, *argv); ////////////////////////////////////////////////
printf("mtn: monIP=%s\n",paddrIP);
printf("mtn: ici\n\n");
int a=Stn(paddrIP); ////////////////////////////////////////////////////////
exit(1);
}
//
// fin. |
