Question : Comment employer une unité

Comment employer la nécessité de l'unité IPHelper.
I de savoir s'il y a quelqu'un qui cingle mon computer.

I ont écrit un petit code, MAIS je ne suis pas sûr si c'est l'usage.
Can quelqu'un ajoute mon code pour le former un peu. le

type
TIcmpMessage =
private
icmpstate de classe (TObject) : TMibICMPInfo ; getMessage du
function : TMibICMPInfo ; le
public
constructor créent (icmpMessage : TMibICMPInfo) ; virtuel ; le
destructor détruisent ; dépassement ; icmpMessage du
property : TMibICMPInfo a lu le getMessage ;
protected
end ;


constructor TIcmpMessage.Create (icmpMessage : TMibICMPInfo) ;
end du
begin
… ;
destructor TIcmpMessage.Destroy ; le
begin
a hérité ;
end ;

function TicmpMessage.getMessage: TMibICMPInfo ;
begin
result : = icmpstate ;
end ;

procedure TForm1.Timer1Timer (expéditeur : TObject) ;
showmessage du
begin
… (le « some_one pingponging à votre ordinateur ") ;
end du
… ;
class= > " clair " de
> de " codeSnippet " de class= de
class= " lineNumbers " de
class= de
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 :
483 :
484 :
485 :
486 :
487 :
488 :
489 :
490 :
491 :
492 :
493 :
494 :
495 :
496 :
497 :
498 :
499 :
500 :
501 :
502 :
503 :
504 :
505 :
506 :
507 :
508 :
509 :
510 :
511 :
512 :
513 :
514 :
515 :
516 :
517 :
518 :
519 :
520 :
521 :
522 :
523 :
524 :
525 :
526 :
527 :
528 :
529 :
530 :
531 :
532 :
533 :
534 :
535 :
536 :
537 :
538 :
539 :
540 :
541 :
542 :
543 :
544 :
545 :
546 :
547 :
548 :
549 :
550 :
551 :
552 :
553 :
554 :
555 :
556 :
557 :
558 :
559 :
560 :
561 :
562 :
563 :
564 :
565 :
566 :
567 :
568 :
569 :
570 :
571 :
572 :
573 :
574 :
575 :
576 :
577 :
578 :
579 :
580 :
581 :
582 :
583 :
584 :
585 :
586 :
587 :
588 :
589 :
590 :
591 :
592 :
593 :
594 :
595 :
596 :
597 :
598 :
599 :
600 :
601 :
602 :
603 :
604 :
605 :
606 :
607 :
608 :
609 :
610 :
611 :
612 :
613 :
614 :
615 :
616 :
617 :
618 :
619 :
620 :
621 :
622 :
623 :
624 :
625 :
626 :
627 :
628 :
629 :
630 :
631 :
632 :
633 :
634 :
635 :
636 :
637 :
638 :
639 :
640 :
641 :
642 :
643 :
644 :
645 :
646 :
647 :
648 :
649 :
650 :
651 :
652 :
653 :
654 :
655 :
656 :
657 :
658 :
659 :
660 :
661 :
662 :
663 :
664 :
665 :
666 :
667 :
668 :
669 :
670 :
671 :
672 :
673 :
674 :
675 :
676 :
677 :
678 :
679 :
680 :
681 :
682 :
683 :
684 :
685 :
686 :
687 :
688 :
689 :
690 :
691 :
692 :
693 :
694 :
695 :
696 :
697 :
698 :
699 :
700 :
701 :
702 :
703 :
704 :
705 :
706 :
707 :
708 :
709 :
710 :
711 :
712 :
713 :
714 :
715 :
716 :
717 :
718 :
719 :
720 :
721 :
722 :
723 :
724 :
725 :
726 :
727 :
728 :
729 :
730 :
731 :
732 :
733 :
734 :
735 :
736 :
737 :
738 :
739 :
740 :
741 :
742 :
743 :
744 :
745 :
746 :
747 :
748 :
749 :
750 :
751 :
752 :
753 :
754 :
755 :
756 :
757 :
758 :
759 :
760 :
761 :
762 :
763 :
764 :
765 :
766 :
767 :
768 :
769 :
770 :
771 :
772 :
773 :
774 :
775 :
776 :
777 :
778 :
779 :
780 :
781 :
782 :
783 :
784 :
785 :
786 :
787 :
788 :
789 :
790 :
791 :
792 :
793 :
794 :
795 :
796 :
797 :
798 :
799 :
800 :
801 :
802 :
803 :
804 :
805 :
806 :
807 :
808 :
809 :
810 :
811 :
812 :
813 :
814 :
815 :
816 :
817 :
818 :
819 :
820 :
821 :
822 :
823 :
824 :
825 :
826 :
827 :
828 :
829 :
830 :
831 :
832 :
833 :
834 :
835 :
836 :
837 :
838 :
839 :
840 :
841 :
842 :
843 :
844 :
845 :
846 :
847 :
848 :
849 :
850 :
851 :
852 :
853 :
854 :
855 :
856 :
857 :
858 :
859 :
860 :
861 :
862 :
863 :
864 :
865 :
866 :
867 :
868 :
869 :
870 :
871 :
872 :
873 :
874 :
875 :
876 :
877 :
878 :
879 :
880 :
881 :
882 :
883 :
884 :
885 :
886 :
887 :
888 :
889 :
890 :
891 :
892 :
893 :
894 :
895 :
896 :
897 :
898 :
899 :
900 :
901 :
902 :
903 :
904 :
905 :
906 :
907 :
908 :
909 :
910 :
911 :
912 :
913 :
914 :
915 :
916 :
917 :
918 :
919 :
920 :
921 :
922 :
923 :
924 :
925 :
926 :
927 :
928 :
929 :
930 :
931 :
932 :
933 :
934 :
935 :
936 :
937 :
938 :
939 :
940 :
941 :
942 :
943 :
944 :
945 :
946 :
947 :
948 :
949 :
950 :
951 :
952 :
953 :
954 :
955 :
956 :
957 :
958 :
959 :
960 :
961 :
962 :
963 :
964 :
965 :
966 :
967 :
968 :
969 :
970 :
971 :
972 :
973 :
974 :
975 :
976 :
977 :
978 :
979 :
980 :
981 :
982 :
983 :
984 :
985 :
986 :
987 :
988 :
989 :
990 :
991 :
992 :
993 :
994 :
995 :
996 :
997 :
998 :
999 :
1000 :
1001 :
1002 :
1003 :
1004 :
1005 :
1006 :
1007 :
1008 :
1009 :
1010 :
1011 :
1012 :
1013 :
1014 :
1015 :
1016 :
1017 :
1018 :
1019 :
1020 :
1021 :
1022 :
1023 :
1024 :
1025 :
1026 :
1027 :
1028 :
1029 :
1030 :
1031 :
1032 :
1033 :
1034 :
1035 :
1036 :
1037 :
1038 :
1039 :
1040 :
1041 :
1042 :
1043 :
1044 :
1045 :
1046 :
1047 :
1048 :
1049 :
1050 :
1051 :
1052 :
1053 :
1054 :
1055 :
1056 :
1057 :
1058 :
1059 :
1060 :
1061 :
1062 :
1063 :
1064 :
1065 :
1066 :
1067 :
1068 :
1069 :
1070 :
1071 :
1072 :
1073 :
1074 :
1075 :
1076 :
1077 :
1078 :
1079 :
1080 :
1081 :
1082 :
1083 :
1084 :
1085 :
1086 :
1087 :
1088 :
1089 :
1090 :
1091 :
1092 :
1093 :
1094 :
1095 :
1096 :
1097 :
1098 :
1099 :
1100 :
1101 :
1102 :
1103 :
1104 :
1105 :
1106 :
1107 :
1108 :
1109 :
1110 :
1111 :
1112 :
1113 :
1114 :
1115 :
1116 :
1117 :
1118 :
1119 :
1120 :
1121 :
1122 :
1123 :
1124 :
1125 :
1126 :
1127 :
1128 :
1129 :
1130 :
1131 :
1132 :
1133 :
1134 :
1135 :
1136 :
1137 :
1138 :
1139 :
1140 :
1141 :
1142 :
1143 :
1144 :
1145 :
1146 :
1147 :
1148 :
1149 :
1150 :
1151 :
1152 :
1153 :
1154 :
1155 :
1156 :
1157 :
1158 :
1159 :
1160 :
1161 :
1162 :
1163 :
1164 :
1165 :
1166 :
1167 :
1168 :
1169 :
1170 :
1171 :
1172 :
1173 :
1174 :
1175 :
1176 :
1177 :
1178 :
1179 :
1180 :
1181 :
1182 :
1183 :
1184 :
1185 :
1186 :
1187 :
1188 :
1189 :
1190 :
1191 :
1192 :
1193 :
1194 :
1195 :
1196 :
1197 :
1198 :
1199 :
1200 :
1201 :
1202 :
1203 :
1204 :
1205 :
1206 :
1207 :
1208 :
>unit " de l'id= " codeSnippet821926 de
 128
Ajouter :  ICMP - statistiques
Ajouter :  Numéros d'accès bien connus
Ajouter :  Liste de RecentIP
Ajouter :  Mise à jour de temporisateur

dirkcl v1.2
----
Difficulté :  La mise à jour correcte de l'IP récent
AJOUTER :  les codes d'ICMP-erreur ont traduit

v1.3 - 18 septembre 2001
----
  Angus Robertson, Magenta Systems Ltd, Angleterre
     [email protected], http://www.magsys.co.uk/delphi/
  Lentement convertissant des procs en fonctions qui peuvent être employées par d'autres programmes,
     IE Get_ devient IpHlp
  Les améliorations primaires sont que le serveur de DNS courant est maintenant montré, également
     bytes d'in/out pour chaque interface (adapteur d'aka)
  Toutes les fonctions sont dynamiquement chargées ainsi le programme peut être employé sur W95/NT4
  Examiné avec Delphes 6 sur le Windows 2000 et le XP

v1.4 - 28 février 2002 - Angus
----
  Fuite de mémoire principale fixe dans IpHlpIfTable (excepté au lieu de finalement)
  Fuite de mémoire principale fixe dans Get_AdaptersInfo (indicateur incrémenté d'amortisseur)
  IpHlpAdaptersInfo créé qui renvoie TAdaptorRows


  Note : Adresse dynamique des retours DNS d'IpHlpNetworkParams (et toute autre substance)
  Note : IpHlpIfEntry renvoie les bytes in/out pour un adapteur de réseau

v1.5 - 5 octobre 2003
----
  Jean-Pierre Turchi « des sud de la France » 
  Cosmétique (plus lisible) et addition d'iana.org dans « WellKnownPorts »

}
*)

interface

utilisations
  Windows, messages, SysUtils, classes, dialogues, IpHlpApi ;

const
  NULL_IP = « 0. 0. 0. 0 » ;

//------conversion des numéros d'accès bien connus pour entretenir des noms----------------

type
  TWellKnownPort = disque
    Prt : DWORD ;
    Srv : corde [20] ;
  extrémité ;


const
    // seulement la plupart des services « populaires »…
  WellKnownPorts : rangée [1..32] de TWellKnownPort
  = (
// (Prt : 0 ; Srv :   « RESRVED "), {réservé}
    (Prt : 7 ; Srv :   « ÉCHO "), {cinglement}
    (Prt : 9 ; Srv :   « ÉCART "),
    (Prt : 13 ; Srv :  « JOURNÉE "),
    (Prt : 17 ; Srv :  « QOTD "), {citation du jour}
    (Prt : 19 ; Srv :  « CHARGEN "), {générateur de caractères}
    (Prt : 20 ; Srv :  « FTPDATA "), {File Transfer Protocol - datas}
    (Prt : 21 ; Srv :  « FTPCTRL "), {File Transfer Protocol - commande}
    (Prt : 22 ; Srv :  « SSH "),
    (Prt : 23 ; Srv :  « Telnet "),
    (Prt : 25 ; Srv :  « Smtp "), {Simple Mail Transfer Protocol}
    (Prt : 37 ; Srv :  « TEMPS "), {protocole de temps}
    (Prt : 43 ; Srv :  « WHOIS "), {l'OMS EST service}
    (Prt : 53 ; Srv :  « DNS "), {service de Domain Name}
    (Prt : 67 ; Srv :  « BOOTPS "), {serveur de BOOTP}
    (Prt : 68 ; Srv :  « BOOTPC "), {client de BOOTP}
    (Prt : 69 ; Srv :  « TFTP "), {ftp insignifiant}
    (Prt : 70 ; Srv :  « GOPHER "), {Gopher}
    (Prt : 79 ; Srv :  « DOIGT "), {doigt}
    (Prt : 80 ; Srv :  « HTTP "), {HTTP}
    (Prt : 88 ; Srv :  « KERBROS "), {Kerberos}
    (Prt : 109 ; Srv : « POP2 "), {version 2 de Post Office Protocol}
    (Prt : 110 ; Srv : « POP3 "), {version 3 de Post Office Protocol}
    (Prt : 111 ; Srv : « SUN_RPC "), {Remote Procedure Call du SOLEIL}
    (Prt : 119 ; Srv : « NNTP "), {Network News Transfer Protocol}
    (Prt : 123 ; Srv : « NTP "), {Network Time Protocol}
    (Prt : 135 ; Srv : « DCOMRPC "), {service d'endroit}
    (Prt : 137 ; Srv : « NBNAME "), {service nommé de NETBIOS}
    (Prt : 138 ; Srv : « NBDGRAM "), {service de datagramme de NETBIOS}
    (Prt : 139 ; Srv : « NBSESS "), {service de session de NETBIOS}
    (Prt : 143 ; Srv : « IMAP "), {protocole d'accès message Internet}
    (Prt : 161 ; Srv : « SNMP "), {Netw simple. Protocole de gestion}
    (Prt : 169 ; Srv : « ENVOYER ")
    ) ;


//-----------conversion des codes d'erreur d'ICMP aux cordes--------------------------
             {pris de www.sockets.com/ms_icmp.c}

const
  ICMP_ERROR_BASE = 11000 ;
  IcmpErr : rangée [1..22] de corde =
  (
   « IP_BUFFER_TOO_SMALL », « IP_DEST_NET_UNREACHABLE », « IP_DEST_HOST_UNREACHABLE »,
   « IP_PROTOCOL_UNREACHABLE », « IP_DEST_PORT_UNREACHABLE », « IP_NO_RESOURCES »,
   « IP_BAD_OPTION », « IP_HARDWARE_ERROR », « IP_PACKET_TOO_BIG », « IP_REQUEST_TIMED_OUT »,
   « IP_BAD_REQUEST », « IP_BAD_ROUTE », « IP_TTL_EXPIRED_TRANSIT »,
   « IP_TTL_EXPIRED_REASSEM », « IP_PARAMETER_PROBLEM », « IP_SOURCE_QUENCH »,
   « IP_OPTION_TOO_BIG », « IP_BAD_DESTINATION », « IP_ADDRESS_DELETED »,
   « IP_SPEC_MTU_CHANGE », « IP_MTU_CHANGE », « IP_UNLOAD »
  ) ;


//----------conversion des valeurs énumérées diverses aux cordes------------------

  ARPEntryType : rangée [1..4] de corde = (« autre », « inadmissible »,
    « Dynamique », « charge statique »
    ) ;
  TCPConnState :
    rangée [1..12] de corde =
    (« s'est fermé », « écoutant », « syn_sent »,
    le « syn_rcvd », « a établi », « fin_wait1 »,
    « fin_wait2 », « close_wait », « se fermant »,
    « last_ack », « time_wait », « delete_tcb »
    ) ;

  TCPToAlgo : rangée [1..4] de corde =
    (« Const.Timeout », « MIL-STD-1778 »,
    « Van Jacobson », « autre ") ;

  IPForwTypes : rangée [1..4] de corde =
    (« autre », « inadmissible », « gens du pays », « extérieur ") ;

  IPForwProtos : rangée [1..18] de corde =
    (« AUTRE », « GENS DU PAYS », « NETMGMT », « ICMP », « EGP »,
    « GGP », « HÉLICOPTÈRE », « DÉCHIRURE », « IS_IS », « ES_IS »,
    « CISCO », « BBN », « OSPF », « BGP », « BOOTP »,
    « AUTO_STAT », « CHARGE STATIQUE », « NOT_DOD ") ;

type

// pour IpHlpNetworkParams
  TNetworkParams = disque
    Hostname : corde ;
    Domain Name : corde ;
    CurrentDnsServer : corde ;
    DnsServerTot : nombre entier ;
    DnsServerNames : rangée [0..9] de corde ;
    NodeType : UINT ;
    ScopeID : corde ;
    EnableRouting : UINT ;
    EnableProxy : UINT ;
    EnableDNS : UINT ;
  extrémité ;

  TIfRows = rangée de TMibIfRow ; choix dynamique de // de rangées

// pour IpHlpAdaptersInfo
  TAdaptorInfo = disque
    AdapterName : corde ;
    Description : corde ;
    MacAddress : corde ;
    Index : DWORD ;
    aType : UINT ;
    DHCPEnabled : UINT ;
    CurrIPAddress : corde ;
    CurrIPMask : corde ;
    IPAddressTot : nombre entier ;
    IPAddressList : rangée de corde ;
    IPMaskList : rangée de corde ;
    GatewayTot : nombre entier ;
    GatewayList : rangée de corde ;
    DHCPTot : nombre entier ;
    DHCPServer : rangée de corde ;
    HaveWINS : BOOL ;
    PrimWINSTot : nombre entier ;
    PrimWINSServer : rangée de corde ;
    SecWINSTot : nombre entier ;
    SecWINSServer : rangée de corde ;
    LeaseObtained : LongInt ; // UNIX chronomètrent, des secondes depuis 1970
    LeaseExpires : LongInt ;   // UNIX chronomètrent, des secondes depuis 1970
  extrémité ;

  TAdaptorRows = rangée de TAdaptorInfo ;


substance de //---------------exported-----------------------------------------------

fonction IpHlpAdaptersInfo (variété AdpTot : nombre entier ; variété AdpRows : TAdaptorRows) : nombre entier ;
procédé Get_AdaptersInfo (liste : TStrings) ;
fonction IpHlpNetworkParams (variété NetworkParams : TNetworkParams) : nombre entier ;
procédé Get_NetworkParams (liste : TStrings) ;
procédé Get_ARPTable (liste : TStrings) ;
procédé Get_TCPTable (liste : TStrings) ;
procédé Get_TCPStatistics (liste : TStrings) ;
fonction IpHlpTCPStatistics (variété TCPStats : TMibTCPStats) : nombre entier ;
procédé Get_UDPTable (liste : TStrings) ;
procédé Get_UDPStatistics (liste : TStrings) ;
fonction IpHlpUdpStatistics (UdpStats : TMibUDPStats) : nombre entier ;
procédé Get_IPAddrTable (liste : TStrings) ;
procédé Get_IPForwardTable (liste : TStrings) ;
procédé Get_IPStatistics (liste : TStrings) ;
fonction IpHlpIPStatistics (variété IPStats : TMibIPStats) : nombre entier ;
fonction Get_RTTAndHopCount (IPAddr : DWORD ; MaxHops : Longint ;
  RTT de variété : longint ; variété HopCount : longint) : nombre entier ;
procédé Get_ICMPStats (ICMPIn, ICMPOut : TStrings) ;
fonction IpHlpIfTable (variété IfTot : nombre entier ; variété IfRows : TIfRows) : nombre entier ;
procédé Get_IfTable (liste : TStrings) ;
fonction IpHlpIfEntry (index : nombre entier ; variété IfRow : TMibIfRow) : nombre entier ;
procédé Get_RecentDestIPs (liste : TStrings) ;

utils de conversion de //
fonction MacAddr2Str (MacAddr : TMacAddress ; taille : nombre entier) : corde ;
fonction IpAddr2Str (IPAddr : DWORD) : corde ;
fonction Str2IpAddr (IPStr : corde) : DWORD ;
fonction Port2Str (nwoPort : DWORD) : corde ;
fonction Port2Wrd (nwoPort : DWORD) : DWORD ;
fonction Port2Svc (port : DWORD) : corde ;
fonction ICMPErr2Str (ICMPErrCode : DWORD) : corde ;

exécution

variété
  RecentIPs : TStringList ;

utilités de //--------------General-----------------------------------------------

{les extraits après « marque » de corde, mange alors la corde}
fonction NextToken (variété s : corde ; Séparateur : char) : corde ;
variété
  Sep_Pos : byte ;
commencer
  Résultat : = '' ;
  si les longueurs > 0 commencent alors
    Sep_Pos : = position (séparateur, s) ;
    si Sep_Pos > 0 commencent alors
      Résultat : = copie (s, 1, Pred (Sep_Pos)) ;
      Suppression (s, 1, Sep_Pos) ;
    extrémité
    commencer autrement
      Résultat : = s ;
      s : = '' ;
    extrémité ;
  extrémité ;
extrémité ;

//------------------------------------------------------------------------------
{MAC-address numérique de concerts à corde ww-xx-yy-zz}
fonction MacAddr2Str (MacAddr : TMacAddress ; taille : nombre entier) : corde ;
variété
  i : nombre entier ;
commencer
  si taille = 0 puis
  commencer
    Résultat : = « 00-00-00-00-00-00 » ;
    SORTIE ;
  extrémité
  résultat d'autre : = '' ;
  //
  pour I : = 1 à la taille font
    Résultat : = résultat + IntToHex (MacAddr [I], 2) + « - » ;
  Suppression (résultat, longueur (résultat), 1) ;
extrémité ;

//------------------------------------------------------------------------------
{IP address de convertis dans ordre DWORD de byte de réseau à pointillé - corde décimale}
fonction IpAddr2Str (IPAddr : DWORD) : corde ;
variété
  i : nombre entier ;
commencer
  Résultat : = '' ;
  pour I : = 1 à 4 font
  commencer
    Résultat : = résultat + format (« %3d.  », [IPAddr et $FF]) ;
    IPAddr : = shr 8 d'IPAddr ;
  extrémité ;
  Suppression (résultat, longueur (résultat), 1) ;
extrémité ;

//------------------------------------------------------------------------------
{convertis pointillés - IP address décimal à ordre DWORD de byte de réseau}
fonction Str2IpAddr (IPStr : corde) : DWORD ;
variété
  i : nombre entier ;
  Numérique : DWORD ;
commencer
  Résultat : = 0 ;
  pour I : = 1 à 4 font
  essai
    Numérique : = (StrToInt (NextToken (IPStr, « ."))) shl 24 ;
    Résultat : = (shr de résultat 8) ou numérique ;
  excepté
    Résultat : = 0 ;
  extrémité ;

extrémité ;

//------------------------------------------------------------------------------
{numéro d'accès de convertis dans l'ordre de byte de réseau à DWORD}
fonction Port2Wrd (nwoPort : DWORD) : DWORD ;
commencer
  Résultat : = échange (MOT (nwoPort)) ;
extrémité ;

//------------------------------------------------------------------------------
{numéro d'accès de convertis dans l'ordre de byte de réseau à la corde}
fonction Port2Str (nwoPort : DWORD) : corde ;
commencer
  Résultat : = IntToStr (Port2Wrd (nwoPort)) ;
extrémité ;

//------------------------------------------------------------------------------
{numéros d'accès bien connus de convertis à l'identification de service}
fonction Port2Svc (port : DWORD) : corde ;
variété
  i : nombre entier ;
commencer
  Résultat : = format (« %4d », [port]) ; // au cas où port non trouvé
  pour I : = bas (WellKnownPorts) à la haute (WellKnownPorts) faire
    si port = WellKnownPorts [I]. Prt alors
    commencer
      Résultat : = WellKnownPorts [I]. Srv ;
      COUPURE ;
    extrémité ;
extrémité ;

//-----------------------------------------------------------------------------
{paramètres de réseau généraux et fixes}

procédé Get_NetworkParams (liste : TStrings) ;
variété
    NetworkParams : TNetworkParams ;
    I, ErrorCode : nombre entier ;
commencer
    sinon assigné (liste) SORTIR alors ;
    List.Clear ;
    ErrorCode : = IpHlpNetworkParams (NetworkParams) ;
    si <> 0 d'ErrorCode puis
    commencer
        List.Add (SysErrorMessage (ErrorCode));
        sortie ;
    extrémité ;
    avec NetworkParams faire
    commencer
        List.Add (« HOSTNAME :  » + hostname) ;
        List.Add (« DOMAINE :  » + Domain Name) ;
        List.Add (« TYPE de NOEUD de NETBIOS :  » + NETBIOSTypes [NodeType]) ;
        List.Add (« PORTÉE de DHCP :  » + ScopeID) ;
        List.Add (le « CHEMINEMENT A PERMIS :  » + IntToStr (EnableRouting)) ;
        List.Add (la « PROCURATION A PERMIS :  » + IntToStr (EnableProxy)) ;
        List.Add (le « DNS A PERMIS :  » + IntToStr (EnableDNS)) ;
        si <> 0 de DnsServerTot puis
        commencer
            pour I : = 0 à Pred (DnsServerTot) font
                List.Add (« ADDR de SERVEUR de DNS :  » + DnsServerNames [I]) ;
        extrémité ;
    extrémité ;
extrémité ;

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
fonction IpHlpNetworkParams (variété NetworkParams : TNetworkParams) : nombre entier ;
variété
  FixedInfo : PTFixedInfo ;         // Angus
  InfoSize : Longint ;
  PDnsServer : PTIP_ADDR_STRING ;   // Angus
commencer
    InfoSize : = 0 ;   // Angus
    résultat : = ERROR_NOT_SUPPORTED ;
    sinon LoadIpHlp sortent alors ;
    résultat : = GetNetworkParams (zéro, @InfoSize) ;  // Angus
    si le <> ERROR_BUFFER_OVERFLOW de résultat sortent alors ; // Angus
    GetMem (FixedInfo, InfoSize) ;                    // Angus
    essai
    résultat : = GetNetworkParams (FixedInfo, @InfoSize) ;   // Angus
    si le <> ERROR_SUCCESS de résultat sortent alors ;
    NetworkParams.DnsServerTot : = 0 ;
    avec FixedInfo^ faire
    commencer
        NetworkParams.HostName : = équilibre (hostname) ;
        NetworkParams.DomainName : = équilibre (Domain Name) ;
        NetworkParams.ScopeId : = équilibre (ScopeID) ;
        NetworkParams.NodeType : = NodeType ;
        NetworkParams.EnableRouting : = EnableRouting ;
        NetworkParams.EnableProxy : = EnableProxy ;
        NetworkParams.EnableDNS : = EnableDNS ;
        NetworkParams.DnsServerNames [0] : = DNSServerList.IPAddress ;  // Angus
        si 0] <> de NetworkParams.DnsServerNames ['' puis
                                        NetworkParams.DnsServerTot : = 1 ;
        PDnsServer : = DnsServerList.Next ;
        tandis que zéro de <> de PDnsServer font
        commencer
            NetworkParams.DnsServerNames [NetworkParams.DnsServerTot] : =
                                        PDnsServer^.IPAddress ;  // Angus
            inc. (NetworkParams.DnsServerTot) ;
            si >= de NetworkParams.DnsServerTot
                            La longueur (NetworkParams.DnsServerNames) sortent alors ;
            PDnsServer : = PDnsServer.Next ;
        extrémité ;
    extrémité ;
    finalement
       FreeMem (FixedInfo) ;                     // Angus
    extrémité ;
extrémité ;

//------------------------------------------------------------------------------

fonction ICMPErr2Str (ICMPErrCode : DWORD) : corde ;
commencer
   Résultat : = « UnknownError :  » + IntToStr (ICMPErrCode) ;
   décembre (ICMPErrCode, ICMP_ERROR_BASE) ;
   s'ICMPErrCode dedans [le bas (ICMpErr). Haut (ICMPErr)] puis
     Résultat : = ICMPErr [ICMPErrCode] ;
extrémité ;


//------------------------------------------------------------------------------

// incluent les bytes in/out pour chaque adapteur

fonction IpHlpIfTable (variété IfTot : nombre entier ; variété IfRows : TIfRows) : nombre entier ;
variété
  I,
  TableSize : nombre entier ;
  pBuf, pNext : PChar ;
commencer
  résultat : = ERROR_NOT_SUPPORTED ;
  sinon LoadIpHlp sortent alors ;
  SetLength (IfRows, 0) ;
  IfTot : = 0 ; // Angus
  TableSize : = 0 ;
   de // appel d'abord : obtenir memsize nécessaire
  résultat : = GetIfTable (zéro, @TableSize, faux) ;  // Angus
  si le <> ERROR_INSUFFICIENT_BUFFER de résultat sortent alors ;
  GetMem (pBuf, TableSize) ;
  essai
      FillChar (pBuf^, TableSize, #0) ;  amortisseur clair de //, puisque W98 ne fait pas

   // obtiennent l'indicateur de table
      résultat : = GetIfTable (PTMibIfTable (pBuf), @TableSize, faux) ;
      si le <> NO_ERROR de résultat sortent alors ;
      IfTot : = PTMibIfTable (pBuf) ^.dwNumEntries ;
      s'IfTot = 0 sortent alors ;
      SetLength (IfRows, IfTot) ;
      pNext : = pBuf + SizeOf (IfTot) ;
      pour I : = 0 à Pred (IfTot) font
      commencer
         IfRows [I] : = ^ de PTMibIfRow (pNext) ;
         inc. (pNext, SizeOf (TMibIfRow)) ;
      extrémité ;
  finalement
      FreeMem (pBuf) ;
  extrémité ;
extrémité ;

procédé Get_IfTable (liste : TStrings) ;
variété
  IfRows : TIfRows ;
  Erreur, I : nombre entier ;
  NumEntries : nombre entier ;
  sDescr, sIfName : corde ;
commencer
  sinon assigné (liste) SORTIR alors ;
  List.Clear ;
  SetLength (IfRows, 0) ;
  Erreur : = IpHlpIfTable (NumEntries, IfRows) ;
  si (<> 0 d'erreur) puis
      List.Add (SysErrorMessage (GetLastError))
  autrement si NumEntries = 0 puis
      List.Add (« non entries.")
  autrement
  commencer
      pour I : = 0 à Pred (NumEntries) font
      commencer
          avec IfRows [I] faire
          commencer
             si wszName [1] = #0 alors
                 sIfName : = ''
             autrement
                 sIfName : = WideCharToString (@wszName) ;  converti Unicode de // à la corde
             sIfName : = équilibre (sIfName) ;
             sDescr : = bDescr ;
             sDescr : = équilibre (sDescr) ;
             List.Add (format (
               « %0.8x |%3d | %16s |%8d |%12d |%2d |%2d |%10d |%10d | %-s| %-s »,
               [dwIndex, dwType, MacAddr2Str (TMacAddress (bPhysAddr),
               dwPhysAddrLen), dwMTU, dwSpeed, dwAdminStatus,
               le dwOPerStatus, Int64 (dwInOctets), Int64 (dwOutOctets), compteurs de // sont à 32 bits
               le sIfName, le sDescr]) // Angus, ont ajouté in/out
               ) ;
          extrémité ;
      extrémité ;
  extrémité ;
  SetLength (IfRows, 0) ;  // libèrent la mémoire
extrémité ;

fonction IpHlpIfEntry (index : nombre entier ; variété IfRow : TMibIfRow) : nombre entier ;
commencer
  résultat : = ERROR_NOT_SUPPORTED ;
  sinon LoadIpHlp sortent alors ;
  FillChar (IfRow, SizeOf (TMibIfRow), #0) ;  amortisseur clair de //, puisque W98 ne fait pas
  IfRow.dwIndex : = index ;
  résultat : = GetIfEntry (@IfRow) ;
extrémité ;

//-----------------------------------------------------------------------------
{Information sur les adapteurs installés}

fonction IpHlpAdaptersInfo (variété AdpTot : nombre entier ; variété AdpRows : TAdaptorRows) : nombre entier ;
variété
  BufLen : DWORD ;
  AdapterInfo : PTIP_ADAPTER_INFO ;
  PIpAddr : PTIP_ADDR_STRING ;
  PBuf : PCHAR ;
  I : nombre entier ;
commencer
  SetLength (AdpRows, 4) ;
  AdpTot : = 0 ;
  BufLen : = 0 ;
  résultat : = GetAdaptersInfo (zéro, @BufLen) ;
  si (<> ERROR_INSUFFICIENT_BUFFER de résultat) et (résultat = NO_ERROR) sortir alors ;
  GetMem (pBuf, BufLen) ;
  essai
      FillChar (pBuf^, BufLen, #0) ;  amortisseur clair de //
      résultat : = GetAdaptersInfo (PTIP_ADAPTER_INFO (PBuf), @BufLen) ;
      si résultat = NO_ERROR puis
      commencer
         AdapterInfo : = PTIP_ADAPTER_INFO (PBuf) ;
         tandis que (zéro de <> d'AdapterInfo) faire
         commencer
            AdpRows [AdpTot] .IPAddressTot : = 0 ;
            SetLength (AdpRows [AdpTot] .IPAddressList, 2) ;
            SetLength (AdpRows [AdpTot] .IPMaskList, 2) ;
            AdpRows [AdpTot] .GatewayTot : = 0 ;
            SetLength (AdpRows [AdpTot] .GatewayList, 2) ;
            AdpRows [AdpTot] .DHCPTot : = 0 ;
            SetLength (AdpRows [AdpTot] .DHCPServer, 2) ;
            AdpRows [AdpTot] .PrimWINSTot : = 0 ;
            SetLength (AdpRows [AdpTot] .PrimWINSServer, 2) ;
            AdpRows [AdpTot] .SecWINSTot : = 0 ;
            SetLength (AdpRows [AdpTot] .SecWINSServer, 2) ;
            AdpRows [AdpTot] .CurrIPAddress : = NULL_IP ;
            AdpRows [AdpTot] .CurrIPMask : = NULL_IP ;
            AdpRows [AdpTot] .AdapterName : = équilibre (corde (AdapterInfo^.AdapterName)) ;
            AdpRows [AdpTot]. Description : = équilibre (corde (AdapterInfo^.Description)) ;
            AdpRows [AdpTot] .MacAddress : = MacAddr2Str (TMacAddress (
                                 AdapterInfo^.Address), AdapterInfo^.AddressLength) ;
            AdpRows [AdpTot]. Index : = AdapterInfo^.Index ;
            AdpRows [AdpTot] .aType : = AdapterInfo^.aType ;
            AdpRows [AdpTot] .DHCPEnabled : = AdapterInfo^.DHCPEnabled ;
            si zéro de <> d'AdapterInfo^.CurrentIPAddress alors
            commencer
                AdpRows [AdpTot] .CurrIPAddress : = AdapterInfo^.CurrentIPAddress.IpAddress ;
                AdpRows [AdpTot] .CurrIPMask : = AdapterInfo^.CurrentIPAddress.IpMask ;
            extrémité ;

        // obtiennent la liste d'IP address et de masques pour IPAddressList
            I : = 0 ;
            PIpAddr : = @AdapterInfo^.IPAddressList ;
            tandis que (zéro de <> de PIpAddr) faire
            commencer
                AdpRows [AdpTot] .IPAddressList [I] : = PIpAddr.IpAddress ;
                AdpRows [AdpTot] .IPMaskList [I] : = PIpAddr.IpMask ;
                PIpAddr : = PIpAddr.Next ;
                inc. (i) ;
                si <= I de longueur (AdpRows [AdpTot] .IPAddressList) puis
                commencer
                     SetLength (AdpRows [AdpTot] .IPAddressList, I * 2) ;
                     SetLength (AdpRows [AdpTot] .IPMaskList, I * 2) ;
                extrémité ;
            extrémité ;
            AdpRows [AdpTot] .IPAddressTot : = I ;

        // obtiennent la liste d'IP address pour GatewayList
            I : = 0 ;
            PIpAddr : = @AdapterInfo^.GatewayList ;
            tandis que (zéro de <> de PIpAddr) faire
            commencer
                AdpRows [AdpTot] .GatewayList [I] : = PIpAddr.IpAddress ;
                PIpAddr : = PIpAddr.Next ;
                inc. (i) ;
                si <= I de longueur (AdpRows [AdpTot] .GatewayList) puis
                             SetLength (AdpRows [AdpTot] .GatewayList, I * 2) ;
            extrémité ;
            AdpRows [AdpTot] .GatewayTot : = I ;

        // obtiennent la liste d'IP address pour GatewayList
            I : = 0 ;
            PIpAddr : = @AdapterInfo^.DHCPServer ;
            tandis que (zéro de <> de PIpAddr) faire
            commencer
                AdpRows [AdpTot] .DHCPServer [I] : = PIpAddr.IpAddress ;
                PIpAddr : = PIpAddr.Next ;
                inc. (i) ;
                si <= I de longueur (AdpRows [AdpTot] .DHCPServer) puis
                             SetLength (AdpRows [AdpTot] .DHCPServer, I * 2) ;
            extrémité ;
            AdpRows [AdpTot] .DHCPTot : = I ;

        // obtiennent la liste d'IP address pour PrimaryWINSServer
            I : = 0 ;
            PIpAddr : = @AdapterInfo^.PrimaryWINSServer ;
            tandis que (zéro de <> de PIpAddr) faire
            commencer
                AdpRows [AdpTot] .PrimWINSServer [I] : = PIpAddr.IpAddress ;
                PIpAddr : = PIpAddr.Next ;
                inc. (i) ;
                si <= I de longueur (AdpRows [AdpTot] .PrimWINSServer) puis
                             SetLength (AdpRows [AdpTot] .PrimWINSServer, I * 2) ;
            extrémité ;
            AdpRows [AdpTot] .PrimWINSTot : = I ;

       // obtiennent la liste d'IP address pour SecondaryWINSServer
            I : = 0 ;
            PIpAddr : = @AdapterInfo^.SecondaryWINSServer ;
            tandis que (zéro de <> de PIpAddr) faire
            commencer
                AdpRows [AdpTot] .SecWINSServer [I] : = PIpAddr.IpAddress ;
                PIpAddr : = PIpAddr.Next ;
                inc. (i) ;
                si <= I de longueur (AdpRows [AdpTot] .SecWINSServer) puis
                             SetLength (AdpRows [AdpTot] .SecWINSServer, I * 2) ;
            extrémité ;
            AdpRows [AdpTot] .SecWINSTot : = I ;

            AdpRows [AdpTot] .LeaseObtained : = AdapterInfo^.LeaseObtained ;
            AdpRows [AdpTot] .LeaseExpires : = AdapterInfo^.LeaseExpires ;

            inc. (AdpTot) ;
            si <= AdpTot de longueur (AdpRows) alors
                            SetLength (AdpRows, AdpTot * 2) ;  // plus de mémoire
            AdapterInfo : = AdapterInfo^.Next ;
         extrémité ;
         SetLength (AdpRows, AdpTot) ;
      extrémité ;
  finalement
      FreeMem (pBuf) ;
  extrémité ;
extrémité ;

procédé Get_AdaptersInfo (liste : TStrings) ;
variété
  AdpTot : nombre entier ;
  AdpRows : TAdaptorRows ;
  Erreur : DWORD ;
  I : nombre entier ;
  //J : nombre entier ;  jpt - voir ci-dessous
  //S : corde ;        identification
commencer
  sinon assigné (liste) SORTIR alors ;
  List.Clear ;
  SetLength (AdpRows, 0) ;
  AdpTot : = 0 ;
  Erreur : = IpHlpAdaptersInfo (AdpTot, AdpRows) ;
  si (<> 0 d'erreur) puis
      List.Add (SysErrorMessage (GetLastError))
  autrement si AdpTot = 0 puis
      List.Add (« non entries.")
  autrement
  commencer
      pour I : = 0 à Pred (AdpTot) font
      commencer
        avec AdpRows [I] faire
        commencer
            //List.Add (AdapterName + « | » + description) ; jpt de // : non utile
            List.Add (format (« %8.8x | %6s | %16s | %2d | %16s | %16s | %16s »,
                [Index, AdaptTypes [aType], MacAddress, DHCPEnabled,
                GatewayList [0], DHCPServer [0], PrimWINSServer [0]])) ;
            {si jpt de // du <> 0 d'IPAddressTot puis : non utile
            commencer
                S : = '' ;
                pour J : = 0 à Pred (IPAddressTot) font
                        S : = S + IPAddressList [J] + « / » + IPMaskList [J] + «  |  » ;
                List.Add (IntToStr (IPAddressTot) + « IP Addresse :  » + S) ;
            extrémité ;
            List.Add ('') ; }
        extrémité ;
      extrémité ;
  extrémité ;
  SetLength (AdpRows, 0) ;
extrémité ;

//-----------------------------------------------------------------------------
{obtenir l'IP indiqué de temps et de hopcount de voyage aller-retour}
fonction Get_RTTAndHopCount (IPAddr : DWORD ; MaxHops : Longint ; RTT de variété : Longint ;
  variété HopCount : Longint) : nombre entier ;
commencer
  sinon GetRTTAndHopCount (IPAddr, @HopCount, MaxHops, @RTT) puis
  commencer
    Résultat : = GetLastError ;
    RTT : = -1 ; Destination de // inaccessible, BAD_HOST_NAME, etc….
    HopCount : = -1 ;
  extrémité
  autrement
    Résultat : = NO_ERROR ;
extrémité ;

//-----------------------------------------------------------------------------
{l'Arp-table énumère des relations entre l'IP à distance et le MAC-address à distance.
 NOTE : ce sont les entrées cachées ; quand il n'y a plus de trafic de réseau à a
 le noeud, entrée est supprimé après quelques minutes.
}
procédé Get_ARPTable (liste : TStrings) ;
variété
  IPNetRow : TMibIPNetRow ;
  TableSize : DWORD ;
  NumEntries : DWORD ;
  ErrorCode : DWORD ;
  i : nombre entier ;
  pBuf : PChar ;
commencer
  sinon assigné (liste) SORTIR alors ;
  List.Clear ;
  de // appel d'abord : obtenir la longueur de table
  TableSize : = 0 ;
  ErrorCode : = GetIPNetTable (zéro, @TableSize, faux) ;   // Angus
  //
  si ErrorCode = puis ERROR_NO_DATA
  commencer
    List.Add (« Arp-cachette empty.") ;
    SORTIE ;
  extrémité ;
  // obtiennent la table
  GetMem (pBuf, TableSize) ;
  NumEntries : = 0 ;
  essai
  ErrorCode : = GetIpNetTable (PTMIBIPNetTable (pBuf), @TableSize, faux) ;
  si ErrorCode = puis NO_ERROR
  commencer
    NumEntries : = PTMIBIPNetTable (pBuf) ^.dwNumEntries ;
    si NumEntries > 0 puis paranoïas de // heurtant, mais vous ne savent jamais…
    commencer
      inc. (pBuf, SizeOf (DWORD)) ; // obtiennent la taille passée de table
      pour I : = 1 à NumEntries font
      commencer
        IPNetRow : = ^ de PTMIBIPNetRow (PBuf) ;
        avec IPNetRow faire
          List.Add (format (« %8x | %12s | %16s | %10s »,
                           [dwIndex, MacAddr2Str (le bPhysAddr, dwPhysAddrLen),
                           IPAddr2Str (dwAddr), ARPEntryType [dwType]
                           ]));
        inc. (pBuf, SizeOf (IPNetRow)) ;
      extrémité ;
    extrémité
    autrement
      List.Add (« Arp-cachette empty.") ;
  extrémité
  autrement
    List.Add (SysErrorMessage (ErrorCode)) ;

  // nous indicateur de restauration de _must_ !
  finalement
      décembre (pBuf, SizeOf (DWORD) + NumEntries * SizeOf (IPNetRow)) ;
      FreeMem (pBuf) ;
  extrémité ;
extrémité ;


//------------------------------------------------------------------------------
procédé Get_TCPTable (liste : TStrings) ;
variété
  TCPRow : TMIBTCPRow ;
  i,
    NumEntries : nombre entier ;
  TableSize : DWORD ;
  ErrorCode : DWORD ;
  DestIP : corde ;
  pBuf : PChar ;
commencer
  sinon assigné (liste) SORTIR alors ;
  List.Clear ;
  RecentIPs.Clear ;
  de // appel d'abord : obtenir la taille de la table
  TableSize : = 0 ;
  NumEntries : = 0 ;
  ErrorCode : = GetTCPTable (zéro, @TableSize, faux) ;  // Angus
  si <> ERROR_INSUFFICIENT_BUFFER d'Errorcode alors
    SORTIE ;

  // obtiennent la capacité de la mémoire required, appel encore
  GetMem (pBuf, TableSize) ;
  // obtiennent la table
  ErrorCode : = GetTCPTable (PTMIBTCPTable (pBuf), @TableSize, faux) ;
  si ErrorCode = puis NO_ERROR
  commencer

    NumEntries : = PTMIBTCPTable (pBuf) ^.dwNumEntries ;
    si NumEntries > 0 puis
    commencer
      inc. (pBuf, SizeOf (DWORD)) ; // obtiennent la taille passée de table
      pour I : = 1 à NumEntries font
      commencer
        TCPRow : = ^ de PTMIBTCPRow (pBuf) ; // obtiennent le prochain disque
        avec TCPRow faire
        commencer
          si dwRemoteAddr = 0 puis
            dwRemotePort : = 0 ;
          DestIP : = IPAddr2Str (dwRemoteAddr) ;
          List.Add (
            Format (« %15s : %-7s | %15s : %-7s | %-16s »,
            [IpAddr2Str (dwLocalAddr),
            Port2Svc (Port2Wrd (dwLocalPort)),
              DestIP,
              Port2Svc (Port2Wrd (dwRemotePort)),
              TCPConnState [dwState]
              ])) ;
         //
            si (pas (dwRemoteAddr = 0))
            et (RecentIps.IndexOf (DestIP) = -1) puis
               RecentIPs.Add (DestIP) ;
        extrémité ;
        inc. (pBuf, SizeOf (TMIBTCPRow)) ;
      extrémité ;
    extrémité ;
  extrémité
  autrement
    List.Add (SyserrorMessage (ErrorCode)) ;
  décembre (pBuf, SizeOf (DWORD) + NumEntries * SizeOf (TMibTCPRow)) ;
  FreeMem (pBuf) ;
extrémité ;

//------------------------------------------------------------------------------
procédé Get_TCPStatistics (liste : TStrings) ;
variété
  TCPStats : TMibTCPStats ;
  ErrorCode : DWORD ;
commencer
  sinon assigné (liste) SORTIR alors ;
  List.Clear ;
  sinon LoadIpHlp sortent alors ;
  ErrorCode : = GetTCPStatistics (@TCPStats) ;
  si ErrorCode = puis NO_ERROR
    avec TCPStats faire
    commencer
      List.Add (« algorithme de retransmission :  » + TCPToAlgo [dwRTOAlgorithm]) ;
      List.Add (« temps mort minimum :  » + IntToStr (dwRTOMin) + « Mme ") ;
      List.Add (« temps mort maximum :  » + IntToStr (dwRTOMax) + « Mme ") ;
      List.Add (« maximum Pend.Connections :  » + IntToStr (dwRTOAlgorithm)) ;
      List.Add (le « Active s'ouvre :  » + IntToStr (dwActiveOpens)) ;
      List.Add (le « passif s'ouvre :  » + IntToStr (dwPassiveOpens)) ;
      List.Add (« a échoué des tentatives ouvertes :  » + IntToStr (dwAttemptFails)) ;
      List.Add (« conn. établies. Remise :  » + IntToStr (dwEstabResets)) ;
      List.Add (« conn. établies courantes. :  » + IntToStr (dwCurrEstab)) ;
      List.Add (les « segments ont reçu :  » + IntToStr (dwInSegs)) ;
      List.Add (les « segments ont envoyé :  » + IntToStr (dwOutSegs)) ;
      List.Add (les « segments ont retransmis :  » + IntToStr (dwReTransSegs)) ;
      List.Add (« erreurs entrantes :  » + IntToStr (dwInErrs)) ;
      List.Add (« remises sortantes :  » + IntToStr (dwOutRsts)) ;
      List.Add (« raccordements cumulatifs :  » + IntToStr (dwNumConns)) ;
    extrémité
  autrement
    List.Add (SyserrorMessage (ErrorCode)) ;
extrémité ;

fonction IpHlpTCPStatistics (variété TCPStats : TMibTCPStats) : nombre entier ;
commencer
    résultat : = ERROR_NOT_SUPPORTED ;
    sinon LoadIpHlp sortent alors ;
    résultat : = GetTCPStatistics (@TCPStats) ;
extrémité ;

//------------------------------------------------------------------------------
procédé Get_UDPTable (liste : TStrings) ;
variété
  UDPRow : TMIBUDPRow ;
  i,
    NumEntries : nombre entier ;
  TableSize : DWORD ;
  ErrorCode : DWORD ;
  pBuf : PChar ;
commencer
  sinon assigné (liste) SORTIR alors ;
  List.Clear ;

  de // appel d'abord : obtenir la taille de la table
  TableSize : = 0 ;
  NumEntries : = 0 ;
  ErrorCode : = GetUDPTable (zéro, @TableSize, faux) ;
  si <> ERROR_INSUFFICIENT_BUFFER d'Errorcode alors
    SORTIE ;

  // obtiennent la taille required de la mémoire, appel encore
  GetMem (pBuf, TableSize) ;

  // obtiennent la table
  ErrorCode : = GetUDPTable (PTMIBUDPTable (pBuf), @TableSize, faux) ;
  si ErrorCode = puis NO_ERROR
  commencer
    NumEntries : = PTMIBUDPTable (pBuf) ^.dwNumEntries ;
    si NumEntries > 0 puis
    commencer
      inc. (pBuf, SizeOf (DWORD)) ; // obtiennent la taille passée de table
      pour I : = 1 à NumEntries font
      commencer
        UDPRow : = ^ de PTMIBUDPRow (pBuf) ; // obtiennent le prochain disque
        avec UDPRow faire
          List.Add (format (« %15s : %-6s »,
            [IpAddr2Str (dwLocalAddr),
            Port2Svc (Port2Wrd (dwLocalPort))
              ])) ;
        inc. (pBuf, SizeOf (TMIBUDPRow)) ;
      extrémité ;
    extrémité
    autrement
      List.Add (« non entries.") ;
  extrémité
  autrement
    List.Add (SyserrorMessage (ErrorCode)) ;
  décembre (pBuf, SizeOf (DWORD) + NumEntries * SizeOf (TMibUDPRow)) ;
  FreeMem (pBuf) ;
extrémité ;

//------------------------------------------------------------------------------
procédé Get_IPAddrTable (liste : TStrings) ;
variété
  IPAddrRow : TMibIPAddrRow ;
  TableSize : DWORD ;
  ErrorCode : DWORD ;
  i : nombre entier ;
  pBuf : PChar ;
  NumEntries : DWORD ;
commencer
  sinon assigné (liste) SORTIR alors ;
  List.Clear ;
  TableSize : = 0 ; ;
  NumEntries : = 0 ;
  de // appel d'abord : obtenir la longueur de table
  ErrorCode : = GetIpAddrTable (zéro, @TableSize, vrai) ;  // Angus
  si <> ERROR_INSUFFICIENT_BUFFER d'Errorcode alors
    SORTIE ;

  GetMem (pBuf, TableSize) ;
  // obtiennent la table
  ErrorCode : = GetIpAddrTable (PTMibIPAddrTable (pBuf), @TableSize, vrai) ;
  si ErrorCode = puis NO_ERROR
  commencer
    NumEntries : = PTMibIPAddrTable (pBuf) ^.dwNumEntries ;
    si NumEntries > 0 puis
    commencer
      inc. (pBuf, SizeOf (DWORD)) ;
      pour I : = 1 à NumEntries font
      commencer
        IPAddrRow : = ^ de PTMIBIPAddrRow (pBuf) ;
        avec IPAddrRow faire
          List.Add (format (« %8.8x | %15s | %15s | %15s | %8.8d »,
            [dwIndex,
            IPAddr2Str (dwAddr),
              IPAddr2Str (dwMask),
              IPAddr2Str (dwBCastAddr),
              dwReasmSize
              ])) ;
        inc. (pBuf, SizeOf (TMIBIPAddrRow)) ;
      extrémité ;
    extrémité
    autrement
      List.Add (« non entries.") ;
  extrémité
  autrement
    List.Add (SysErrorMessage (ErrorCode)) ;

  // nous devons reconstituer l'indicateur !
  décembre (pBuf, SizeOf (DWORD) + NumEntries * SizeOf (IPAddrRow)) ;
  FreeMem (pBuf) ;
extrémité ;

//-----------------------------------------------------------------------------
{obtient des entrées dans la table de cheminement ; équivalent à la « copie d'itinéraire »}
procédé Get_IPForwardTable (liste : TStrings) ;
variété
  IPForwRow : TMibIPForwardRow ;
  TableSize : DWORD ;
  ErrorCode : DWORD ;
  i : nombre entier ;
  pBuf : PChar ;
  NumEntries : DWORD ;
commencer

  sinon assigné (liste) SORTIR alors ;
  List.Clear ;
  TableSize : = 0 ;

  de // appel d'abord : obtenir la longueur de table
  NumEntries : = 0 ;
  ErrorCode : = GetIpForwardTable (zéro, @TableSize, vrai) ;
  si <> ERROR_INSUFFICIENT_BUFFER d'Errorcode alors
    SORTIE ;

  // obtiennent la table
  GetMem (pBuf, TableSize) ;
  ErrorCode : = GetIpForwardTable (PTMibIPForwardTable (pBuf), @TableSize, vrai) ;
  si ErrorCode = puis NO_ERROR
  commencer
    NumEntries : = PTMibIPForwardTable (pBuf) ^.dwNumEntries ;
    si NumEntries > 0 puis
    commencer
      inc. (pBuf, SizeOf (DWORD)) ;
      pour I : = 1 à NumEntries font
      commencer
        IPForwRow : = ^ de PTMibIPForwardRow (pBuf) ;
        avec IPForwRow faire
        commencer
          si (dwForwardType < 1)
          ou (dwForwardType > 4) puis
                   dwForwardType : = 1 ;   // Angus, tiennent compte de la mauvaise valeur
          List.Add (format (
            « %15s | %15s | %15s | %8.8x | %7s |   %5.5d |  %7s |   %2.2d »,
            [IPAddr2Str (dwForwardDest),
            IPAddr2Str (dwForwardMask),
              IPAddr2Str (dwForwardNextHop),
              dwForwardIFIndex,
              IPForwTypes [dwForwardType],
              dwForwardNextHopAS,
              IPForwProtos [dwForwardProto],
              dwForwardMetric1
              ])) ;
        extrémité ;       
        inc. (pBuf, SizeOf (TMibIPForwardRow)) ;
      extrémité ;
    extrémité
    autrement
      List.Add (« non entries.") ;
  extrémité
  autrement
    List.Add (SysErrorMessage (ErrorCode)) ;
  décembre (pBuf, SizeOf (DWORD) + NumEntries * SizeOf (TMibIPForwardRow)) ;
  FreeMem (pBuf) ;
extrémité ;

//------------------------------------------------------------------------------
procédé Get_IPStatistics (liste : TStrings) ;
variété
  IPStats : TMibIPStats ;
  ErrorCode : nombre entier ;
commencer
  sinon assigné (liste) SORTIR alors ;
  sinon LoadIpHlp sortent alors ;
  ErrorCode : = GetIPStatistics (@IPStats) ;
  si ErrorCode = puis NO_ERROR
  commencer
    List.Clear ;
    avec IPStats faire
    commencer
      si dwForwarding = 1 alors
        List.add (le « expédition a permis :  » + « oui ")
      autrement
        List.add (le « expédition a permis :  » + « aucun ") ;
      List.add (« défaut TTL :  » + inttostr (dwDefaultTTL)) ;
      List.add (les « datagrammes ont reçu :  » + inttostr (dwInReceives)) ;
      List.add (« erreurs d'en-tête (dedans) :  » + inttostr (dwInHdrErrors)) ;
      List.add (« erreurs d'adresse (dedans) :  » + inttostr (dwInAddrErrors)) ;
      List.add (les « datagrammes ont expédié :  » + inttostr (dwForwDatagrams)) ;   // Angus
      List.add (« protocoles inconnus (dedans) :  » + inttostr (dwInUnknownProtos)) ;
      List.add (les « datagrammes ont jeté :  » + inttostr (dwInDiscards)) ;
      List.add (les « datagrammes ont livré :  » + inttostr (dwInDelivers)) ;
      List.add (« demandes dehors :  » + inttostr (dwOutRequests)) ;
      List.add (les « cheminements ont jeté :  » + inttostr (dwRoutingDiscards)) ;
      List.add (« aucuns itinéraires (dehors) :  » + inttostr (dwOutNoRoutes)) ;
      List.add (« rassembler les temps morts :  » + inttostr (dwReasmTimeOut)) ;
      List.add (« rassembler les demandes :  » + inttostr (dwReasmReqds)) ;
      List.add (« remontages de Succesfull :  » + inttostr (dwReasmOKs)) ;
      List.add (« a échoué des remontages :  » + inttostr (dwReasmFails)) ;
      List.add (« fragmentations réussies :  » + inttostr (dwFragOKs)) ;
      List.add (« a échoué des fragmentations :  » + inttostr (dwFragFails)) ;
      List.add (les « datagrammes ont réduit en fragments :  » + inttostr (dwFRagCreates)) ;
      List.add (« nombre des interfaces :  » + inttostr (dwNumIf)) ;
      List.add (« nombre des IP address :  » + inttostr (dwNumAddr)) ;
      List.add (« itinéraires dans RoutingTable :  » + inttostr (dwNumRoutes)) ;
    extrémité ;
  extrémité
  autrement
    List.Add (SysErrorMessage (ErrorCode)) ;
extrémité ;

fonction IpHlpIPStatistics (variété IPStats : TMibIPStats) : nombre entier ;      // Angus
commencer
    résultat : = ERROR_NOT_SUPPORTED ;
    sinon LoadIpHlp sortent alors ;
    résultat : = GetIPStatistics (@IPStats) ;
extrémité ;

//------------------------------------------------------------------------------
procédé Get_UdpStatistics (liste : TStrings) ;
variété
  UdpStats : TMibUDPStats ;
  ErrorCode : nombre entier ;
commencer
  sinon assigné (liste) SORTIR alors ;
  ErrorCode : = GetUDPStatistics (@UdpStats) ;
  si ErrorCode = puis NO_ERROR
  commencer
    List.Clear ;
    avec UDPStats faire
    commencer
      List.add (« datagrammes (dedans) :  » + inttostr (dwInDatagrams)) ;
      List.add (« datagrammes (dehors) :  » + inttostr (dwOutDatagrams)) ;
      List.add (« aucuns ports :  » + inttostr (dwNoPorts)) ;
      List.add (« erreurs (dedans) :  » + inttostr (dwInErrors)) ;
      List.add (le « UDP écoutent des ports :  » + inttostr (dwNumAddrs)) ;
    extrémité ;
  extrémité
  autrement
    List.Add (SysErrorMessage (ErrorCode)) ;
extrémité ;

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
fonction IpHlpUdpStatistics (UdpStats : TMibUDPStats) : nombre entier ;     // Angus
commencer
    résultat : = ERROR_NOT_SUPPORTED ;
    sinon LoadIpHlp sortent alors ;
    résultat : = GetUDPStatistics (@UdpStats) ;
extrémité ;

//------------------------------------------------------------------------------
procédé Get_ICMPStats (ICMPIn, ICMPOut : TStrings) ;
variété
  ErrorCode : DWORD ;
  ICMPStats : PTMibICMPInfo ;
commencer
  si (ICMPIn = zéro) ou (ICMPOut = zéro) SORTIR alors ;
  ICMPIn.Clear ;
  ICMPOut.Clear ;
  Nouveau (ICMPStats) ;
  ErrorCode : = GetICMPStatistics (ICMPStats) ;
  si ErrorCode = puis NO_ERROR
  commencer
    avec ICMPStats.InStats faire
    commencer
      ICMPIn.Add (les « messages ont reçu :  » + IntToStr (dwMsgs)) ;
      ICMPIn.Add (« erreurs :  » + IntToStr (dwErrors)) ;
      ICMPIn.Add (« DEST. Inaccessible :  » + IntToStr (dwDestUnreachs)) ;
      ICMPIn.Add (le « temps a dépassé :  » + IntToStr (dwTimeEcxcds)) ;
      ICMPIn.Add (« param. Problèmes :  » + IntToStr (dwParmProbs)) ;
      ICMPIn.Add (la « source éteignent :  » + IntToStr (dwSrcQuenchs)) ;
      ICMPIn.Add (« réoriente :  » + IntToStr (dwRedirects)) ;
      ICMPIn.Add (« demandes d'écho :  » + IntToStr (dwEchos)) ;
      ICMPIn.Add (« réponses d'écho :  » + IntToStr (dwEchoReps)) ;
      ICMPIn.Add (« demandes d'horodateur :  » + IntToStr (dwTimeStamps)) ;
      ICMPIn.Add (« réponses d'horodateur :  » + IntToStr (dwTimeStampReps)) ;
      ICMPIn.Add (« Addr. Demandes de masques :  » + IntToStr (dwAddrMasks)) ;
      ICMPIn.Add (« Addr. Réponses de masque :  » + IntToStr (dwAddrReps)) ;
    extrémité ;
     //
    avec ICMPStats.OutStats faire
    commencer
      ICMPOut.Add (les « messages ont envoyé :  » + IntToStr (dwMsgs)) ;
      ICMPOut.Add (« erreurs :  » + IntToStr (dwErrors)) ;
      ICMPOut.Add (« DEST. Inaccessible :  » + IntToStr (dwDestUnreachs)) ;
      ICMPOut.Add (le « temps a dépassé :  » + IntToStr (dwTimeEcxcds)) ;
      ICMPOut.Add (« param. Problèmes :  » + IntToStr (dwParmProbs)) ;
      ICMPOut.Add (la « source éteignent :  » + IntToStr (dwSrcQuenchs)) ;
      ICMPOut.Add (« réoriente :  » + IntToStr (dwRedirects)) ;
      ICMPOut.Add (« demandes d'écho :  » + IntToStr (dwEchos)) ;
      ICMPOut.Add (« réponses d'écho :  » + IntToStr (dwEchoReps)) ;
      ICMPOut.Add (« demandes d'horodateur :  » + IntToStr (dwTimeStamps)) ;
      ICMPOut.Add (« réponses d'horodateur :  » + IntToStr (dwTimeStampReps)) ;
      ICMPOut.Add (« Addr. Demandes de masques :  » + IntToStr (dwAddrMasks)) ;
      ICMPOut.Add (« Addr. Réponses de masque :  » + IntToStr (dwAddrReps)) ;
    extrémité ;
  extrémité
  autrement
    IcmpIn.Add (SysErrorMessage (ErrorCode)) ;
  Disposer (ICMPStats) ;
extrémité ;

//------------------------------------------------------------------------------
procédé Get_RecentDestIPs (liste : TStrings) ;
commencer
  si assigné (liste) alors
    List.Assign (RecentIPs)
extrémité ;

initialisation

  RecentIPs : = TStringList.Create ;

achèvement

  RecentIPs.Free ;

end.
class= de

Réponse : Comment employer une unité

Il n'est pas aussi facile que vous pensez. En fait, vous ne pouvez pas arrêter le paquet d'ICMP au niveau d'application. Vous devrez probablement écrire un conducteur de réseau (il ne peut pas être fait à Delphes, vous aurez besoin de C/C++ et de kit de développement de conducteur).

Ou vous pouvez employer un tiers conducteur, comme le renifleur de paquet SDK :
http://www.microolap.com/products/network/pssdk/

Également vous pouvez employer une utilité libre, comme l'intercepteur d'ICMP :
http://www.sabronet.com/icmpinterceptor/icmpinterceptor.html
Autres solutions  
  •  MS Excel 2007 et pdf - l'exportation vers le pdf prend de longues heures !
  •  Dans le Perl, comment j'ajoute une valeur à la liste, puis le contrôle pour voir si la valeur existent avant d'ajouter une nouvelle valeur
  •  Comment fais j'initialiser de la HP BL460c G6 de san et de la HP XP 240000
  •  Comment fais j'employer une clef de permis de volume sur un ordinateur de HP avec du CD de restauration
  •  Emplacement primaire de deux SCCM dans l'annuaire actif
  •  L'initiateur et la HP D2D de l'iSCSI R2 du serveur 2008 de Windows GERCENT l'issue
  •  Stocker le dossier dans le mysql using connector.net et le champ de goutte
  •  Carte vidéo d'USB - bit 32 sur le matériel travaillant au niveau du bit 64 ?
  •  asp.net que j'essaye de convertir une forme de HTML en forme d'aspx ou ? ce qui jamais. Aide du besoin sur la façon dont à à elle.
  •  Winzip 12 issues de secours du travail ?
  •  
    programming4us programming4us