class= " lineNumbers " 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 :
|
class= de
>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.
|
