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:
|
" codeBody "
unit IPHelper;
(*
==========================
De functies van Delphi IPHelper
==========================
Vereiste OS: NT4/SP4 of hoger, WIN98/WIN98se
Ontwikkeld op: D6 Ent. & Prof.
Getest op: Winnen-NT4/SP6, WIN98se, WIN95/OSR1
: WIN98, W2K-SP2, 3, 4
: W2K, W2K prof., W2K server
Het waarschuwen - momenteel slechts steunen Delphi 5 en recenter tenzij int64 wordt verwijderd
(Int64 wordt slechts gebruikt aan krachtFormaat om niet ondertekende aantallen met 32 bits te tonen)
================================================================
Deze software is FREEWARE
Als deze software werkt, werd het zeker geschreven door Zeemansdolk Claessens
[email protected]
(Als het niet, ken ik om het even wat over het niet.)
================================================================
{Lijst van Moeilijke situaties & Toevoegingen
v1.1 dirkcl
Moeilijke situatie: verkeerde die errorcode in GetNetworkParams wordt gemeld ()
Moeilijke situatie: RTTI MaxHops 20 > 128
Voeg toe: ICMP - statistieken
Voeg toe: Bekende havenaantallen
Voeg toe: De lijst van RecentIP
Voeg toe: De update van de tijdopnemer
v1.2 dirkcl
Moeilijke situatie: Recente IP correcte update
VOEG toe: ICMP-fout vertaalde codes
v1.3 - 18 September 2001
Angus Robertson, Magenta Systems Ltd, Engeland
[email protected], http://www.magsys.co.uk/delphi/
Langzaam omzettend procs in functies die door andere programma's kunnen worden gebruikt,
d.w.z. wordt Get_ IpHlp
De primaire verbeteringen zijn dat de huidige DNS server nu, ook wordt getoond
in/out bytes voor elke interface (akaadapter)
Alle functies zijn dynamisch geladen zo programma kunnen op W95/NT4 worden gebruikt
Getest met Delphi 6 op Vensters 2000 en XP
v1.4 - 28 Februari 2002 - Angus
Vast belangrijk geheugenlek in IpHlpIfTable (behalve in plaats van tenslotte)
Vast belangrijk geheugenlek in Get_AdaptersInfo (verhoogde bufferwijzer)
Gecre�ërde IpHlpAdaptersInfo die TAdaptorRows terugkeert
Nota: IpHlpNetworkParams keert dynamisch DNS adres (en ander materiaal terug)
Nota: De winst van IpHlpIfEntry bytes in/out voor een netwerkadapter
v1.5 - 5 Oktober 2003
Jean-pierre Turchi „van Zuiden van Frankrijk“
(Leesbaarder) schoonheidsmiddel en toe:voegen-binnen van iana.org in „WellKnownPorts“
}
*)
interface
gebruik
Vensters, Berichten, SysUtils, Klassen, Dialogen, IpHlpApi;
const
NULL_IP = „0. 0. 0. 0“;
//------conversion van bekende havenaantallen aan de dienstnamen
type
TWellKnownPort = verslag
Prt: DWORD;
Srv: koord [20];
eind;
const
// slechts de meeste „populaire“ diensten…
WellKnownPorts: serie [1..32] van TWellKnownPort
= (
// (Prt: 0; Srv: „RESRVED“), {Gereserveerd}
(Prt: 7; Srv: „ECHO“), {pingel}
(Prt: 9; Srv: „VERWERPING“),
(Prt: 13; Srv: „DAG“),
(Prt: 17; Srv: „QOTD“), {Citaat van de Dag}
(Prt: 19; Srv: „CHARGEN“), {de Generator van het Karakter}
(Prt: 20; Srv: „FTPDATA“), {het Protocol van de Overdracht van het Dossier - datas}
(Prt: 21; Srv: „FTPCTRL“), {het Protocol van de Overdracht van het Dossier - Controle}
(Prt: 22; Srv: „SSH“),
(Prt: 23; Srv: „TELNET“),
(Prt: 25; Srv: „SMTP“), {het Eenvoudige Protocol van de Overdracht van de Post}
(Prt: 37; Srv: „TIJD“), {het Protocol van de Tijd}
(Prt: 43; Srv: „WHOIS“), {DE WGO IS DE DIENST}
(Prt: 53; Srv: „DNS“), {de Dienst van de Naam van het Domein}
(Prt: 67; Srv: „BOOTPS“), {Server BOOTP}
(Prt: 68; Srv: „BOOTPC“), {Cliënt BOOTP}
(Prt: 69; Srv: „TFTP“), {Onbelangrijk FTP}
(Prt: 70; Srv: „GOPHER“), {Gopher}
(Prt: 79; Srv: „VINGER“), {Vinger}
(Prt: 80; Srv: „HTTP“), {HTTP}
(Prt: 88; Srv: „KERBROS“), {Kerberos}
(Prt: 109; Srv: „POP2“), {Versie 2 van het Protocol van het Postkantoor}
(Prt: 110; Srv: „POP3“), {Versie 3 van het Protocol van het Postkantoor}
(Prt: 111; Srv: „SUN_RPC“), {Vraag van de Procedure van de ZON de Verre}
(Prt: 119; Srv: „NNTP“), {het Protocol van de Overdracht van het Nieuws van het Netwerk}
(Prt: 123; Srv: „NTP“), {het protocol van de Tijd van het Netwerk}
(Prt: 135; Srv: „DCOMRPC“), {de Dienst van de Plaats}
(Prt: 137; Srv: „NBNAME“), {de dienst van de Naam van NETBIOS}
(Prt: 138; Srv: „NBDGRAM“), {de Dienst van het Datagram van NETBIOS}
(Prt: 139; Srv: „NBSESS“), {de Dienst van de Zitting van NETBIOS}
(Prt: 143; Srv: „IMAP“), {het Protocol van de Toegang van het Bericht van Internet}
(Prt: 161; Srv: „SNMP“), {Eenvoudige Netw. Het Protocol van het beheer}
(Prt: 169; Srv: „VERZEND“)
);
//-----------conversion van ICMP foutencodes aan koorden
{genomen uit www.sockets.com/ms_icmp.c}
const
ICMP_ERROR_BASE = 11000;
IcmpErr: serie [1..22] van koord =
(
„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 van diverse opgesomde waarden aan koorden
ARPEntryType: serie [1..4] van koord = („andere“, „Ongeldig“,
„Dynamisch“, „Statisch“
);
TCPConnState:
serie [1..12] van koord =
(„gesloten“, „luisterend“, „syn_sent“,
„syn_rcvd“, „gevestigd“, „fin_wait1“,
„fin_wait2“, „close_wait“, „sluitend“,
„last_ack“, „time_wait“, „delete_tcb“
);
TCPToAlgo: serie [1..4] van koord =
(„Const.Timeout“, „mil-std-1778“,
„Van Jacobson“, „andere“);
IPForwTypes: serie [1..4] van koord =
(„andere“, „ongeldig“, „lokaal“, „ver“);
IPForwProtos: serie [1..18] van koord =
(„ANDERE“, „LOKAAL“, „NETMGMT“, „ICMP“, „EGP“,
„GGP“, „HELIKOPTER“, „SCHEURT“, „IS_IS“, „ES_IS“,
„CISCO“, „BBN“, „OSPF“, „BGP“, „BOOTP“,
„AUTO_STAT“, „STATISCH“, „NOT_DOD“);
type
// voor IpHlpNetworkParams
TNetworkParams = verslag
HostName: koord;
DomainName: koord;
CurrentDnsServer: koord;
DnsServerTot: geheel;
DnsServerNames: serie [0..9] van koord;
NodeType: UINT;
ScopeID: koord;
EnableRouting: UINT;
EnableProxy: UINT;
EnableDNS: UINT;
eind;
TIfRows = serie van TMibIfRow; // dynamische serie van rijen
// voor IpHlpAdaptersInfo
TAdaptorInfo = verslag
AdapterName: koord;
Beschrijving: koord;
MacAddress: koord;
Index: DWORD;
aType: UINT;
DHCPEnabled: UINT;
CurrIPAddress: koord;
CurrIPMask: koord;
IPAddressTot: geheel;
IPAddressList: serie van koord;
IPMaskList: serie van koord;
GatewayTot: geheel;
GatewayList: serie van koord;
DHCPTot: geheel;
DHCPServer: serie van koord;
HaveWINS: BOOL;
PrimWINSTot: geheel;
PrimWINSServer: serie van koord;
SecWINSTot: geheel;
SecWINSServer: serie van koord;
LeaseObtained: LongInt; // UNIX tijd, seconden sinds 1970
LeaseExpires: LongInt; // UNIX tijd, seconden sinds 1970
eind;
TAdaptorRows = serie van TAdaptorInfo;
//---------------exported materiaal
functie IpHlpAdaptersInfo (var AdpTot: geheel; var AdpRows: TAdaptorRows): geheel;
procedure Get_AdaptersInfo (Lijst: TStrings);
functie IpHlpNetworkParams (var NetworkParams: TNetworkParams): geheel;
procedure Get_NetworkParams (Lijst: TStrings);
procedure Get_ARPTable (Lijst: TStrings);
procedure Get_TCPTable (Lijst: TStrings);
procedure Get_TCPStatistics (Lijst: TStrings);
functie IpHlpTCPStatistics (var TCPStats: TMibTCPStats): geheel;
procedure Get_UDPTable (Lijst: TStrings);
procedure Get_UDPStatistics (Lijst: TStrings);
functie IpHlpUdpStatistics (UdpStats: TMibUDPStats): geheel;
procedure Get_IPAddrTable (Lijst: TStrings);
procedure Get_IPForwardTable (Lijst: TStrings);
procedure Get_IPStatistics (Lijst: TStrings);
functie IpHlpIPStatistics (var IPStats: TMibIPStats): geheel;
functie Get_RTTAndHopCount (IPAddr: DWORD; MaxHops: Longint;
var RTT: longint; var HopCount: longint): geheel;
procedure Get_ICMPStats (ICMPIn, ICMPOut: TStrings);
functie IpHlpIfTable (var IfTot: geheel; var IfRows: TIfRows): geheel;
procedure Get_IfTable (Lijst: TStrings);
functie IpHlpIfEntry (Index: geheel; var IfRow: TMibIfRow): geheel;
procedure Get_RecentDestIPs (Lijst: TStrings);
// omzetting utils
functie MacAddr2Str (MacAddr: TMacAddress; grootte: geheel): koord;
functie IpAddr2Str (IPAddr: DWORD): koord;
functie Str2IpAddr (IPStr: koord): DWORD;
functie Port2Str (nwoPort: DWORD): koord;
functie Port2Wrd (nwoPort: DWORD): DWORD;
functie Port2Svc (Haven: DWORD): koord;
functie ICMPErr2Str (ICMPErrCode: DWORD): koord;
implementatie
var
RecentIPs: TStringList;
//--------------General nut
{de uittreksels daarna „teken“ van koord, eet dan koord}
functie NextToken (var s: koord; Separator: klusje): koord;
var
Sep_Pos: byte;
begin
Resultaat: = '';
als de lengte > 0 dan begint
Sep_Pos: = pos (Separator, s);
als Sep_Pos > 0 dan begint
Resultaat: = exemplaar (s, 1, Pred (Sep_Pos));
Schrap (s, 1, Sep_Pos);
eind
anders begin
Resultaat: = s;
s: = '';
eind;
eind;
eind;
//------------------------------------------------------------------------------
{overleg numeriek MAC-Adres aan koord ww-xx-yy}
functie MacAddr2Str (MacAddr: TMacAddress; grootte: geheel): koord;
var
i: geheel;
begin
als Grootte = 0 toen
begin
Resultaat: = „00-00-00-00-00-00“;
UITGANG;
eind
anders Resultaat: = '';
//
voor I: = 1 aan Grootte
Resultaat: = Resultaat + IntToHex (MacAddr [I], 2) + „-“;
Schrap (Resultaat, Lengte (Resultaat), 1);
eind;
//------------------------------------------------------------------------------
{bekeerlingen iP-Adres in de orde DWORD van de netwerkbyte aan gestippeld - decimaal koord}
functie IpAddr2Str (IPAddr: DWORD): koord;
var
i: geheel;
begin
Resultaat: = '';
voor I: = 1 tot 4
begin
Resultaat: = Resultaat + Formaat („%3d. “, [IPAddr en $FF]);
IPAddr: = IPAddr shr 8;
eind;
Schrap (Resultaat, Lengte (Resultaat), 1);
eind;
//------------------------------------------------------------------------------
{bekeerlingen - decimaal iP-Adres aan de orde DWORD worden gestippeld die van de netwerkbyte}
functie Str2IpAddr (IPStr: koord): DWORD;
var
i: geheel;
Num: DWORD;
begin
Resultaat: = 0;
voor I: = 1 tot 4
probeer
Num: = (StrToInt (NextToken (IPStr, „.“ ))) shl 24;
Resultaat: = (Resultaat shr 8) of Num;
behalve
Resultaat: = 0;
eind;
eind;
//------------------------------------------------------------------------------
{het aantal van de bekeerlingenhaven in de orde van de netwerkbyte aan DWORD}
functie Port2Wrd (nwoPort: DWORD): DWORD;
begin
Resultaat: = Ruilmiddel (WORD (nwoPort));
eind;
//------------------------------------------------------------------------------
{het aantal van de bekeerlingenhaven in de orde van de netwerkbyte aan koord}
functie Port2Str (nwoPort: DWORD): koord;
begin
Resultaat: = IntToStr (Port2Wrd (nwoPort));
eind;
//------------------------------------------------------------------------------
{aantallen van de bekeerlingen de bekende haven aan de dienstidentiteitskaart}
functie Port2Svc (Haven: DWORD): koord;
var
i: geheel;
begin
Resultaat: = Formaat („%4d“, [Haven]); // voor het geval dat gevonden niet haven
voor I: = Laag (WellKnownPorts) aan Hoogte (WellKnownPorts)
als Haven = WellKnownPorts [I]. Prt toen
begin
Resultaat: = WellKnownPorts [I]. Srv;
ONDERBREKING;
eind;
eind;
//-----------------------------------------------------------------------------
{algemene, vaste netwerkparameters}
procedure Get_NetworkParams (Lijst: TStrings);
var
NetworkParams: TNetworkParams;
I, ErrorCode: geheel;
begin
als Toegewezen niet (Lijst) toen UITGANG;
List.Clear;
ErrorCode: = IpHlpNetworkParams (NetworkParams);
als ErrorCode <> 0 toen
begin
List.Add (SysErrorMessage (ErrorCode));
uitgang;
eind;
met NetworkParams
begin
List.Add („HOSTNAME: “ + HostName);
List.Add („DOMEIN: “ + DomainName);
List.Add („het TYPE van KNOOP van NETBIOS: “ + NETBIOSTypes [NodeType]);
List.Add (het „WERKINGSGEBIED van DHCP: “ + ScopeID);
List.Add („TOEGELATEN VERPLETTEREN: “ + IntToStr (EnableRouting));
List.Add („TOEGELATEN VOLMACHT: “ + IntToStr (EnableProxy));
List.Add („TOEGELATEN DNS: “ + IntToStr (EnableDNS));
als DnsServerTot <> 0 toen
begin
voor I: = 0 aan Pred (DnsServerTot)
List.Add („DNS SERVER ADDR: “ + DnsServerNames [I]);
eind;
eind;
eind;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
functie IpHlpNetworkParams (var NetworkParams: TNetworkParams): geheel;
var
FixedInfo: PTFixedInfo; // Angus
InfoSize: Longint;
PDnsServer: PTIP_ADDR_STRING; // Angus
begin
InfoSize: = 0; // Angus
resultaat: = ERROR_NOT_SUPPORTED;
als NIET LoadIpHlp dan weggaat;
resultaat: = GetNetworkParams (de Nul, @InfoSize); // Angus
als het resultaat <> ERROR_BUFFER_OVERFLOW dan weggaat; // Angus
GetMem (FixedInfo, InfoSize); // Angus
probeer
resultaat: = GetNetworkParams (FixedInfo, @InfoSize); // Angus
als het resultaat <> ERROR_SUCCESS dan weggaat;
NetworkParams.DnsServerTot: = 0;
met FixedInfo^
begin
NetworkParams.HostName: = versiering (HostName);
NetworkParams.DomainName: = versiering (DomainName);
NetworkParams.ScopeId: = versiering (ScopeID);
NetworkParams.NodeType: = NodeType;
NetworkParams.EnableRouting: = EnableRouting;
NetworkParams.EnableProxy: = EnableProxy;
NetworkParams.EnableDNS: = EnableDNS;
NetworkParams.DnsServerNames [0]: = DNSServerList.IPAddress; // Angus
als NetworkParams.DnsServerNames [0] <> '' toen
NetworkParams.DnsServerTot: = 1;
PDnsServer: = DnsServerList.Next;
terwijl de Nul van PDnsServer <>
begin
NetworkParams.DnsServerNames [NetworkParams.DnsServerTot]: =
PDnsServer^.IPAddress; // Angus
n.v. (NetworkParams.DnsServerTot);
als NetworkParams.DnsServerTot >=
De lengte (NetworkParams.DnsServerNames) gaat dan weg;
PDnsServer: = PDnsServer.Next;
eind;
eind;
tot slot
FreeMem (FixedInfo); // Angus
eind;
eind;
//------------------------------------------------------------------------------
functie ICMPErr2Str (ICMPErrCode: DWORD): koord;
begin
Resultaat: = „UnknownError: “ + IntToStr (ICMPErrCode);
Dec (ICMPErrCode, ICMP_ERROR_BASE);
als ICMPErrCode binnen [Laag (ICMpErr). Hoog (ICMPErr)] dan
Resultaat: = ICMPErr [ICMPErrCode];
eind;
//------------------------------------------------------------------------------
// omvat bytes in/out voor elke adapter
functie IpHlpIfTable (var IfTot: geheel; var IfRows: TIfRows): geheel;
var
I,
TableSize: geheel;
pBuf, pNext: PChar;
begin
resultaat: = ERROR_NOT_SUPPORTED;
als NIET LoadIpHlp dan weggaat;
SetLength (IfRows, 0);
IfTot: = 0; // Angus
TableSize: = 0;
// roept eerst: krijg memsize nodig
resultaat: = GetIfTable (de Nul, @TableSize, vals); // Angus
als het resultaat <> ERROR_INSUFFICIENT_BUFFER dan weggaat;
GetMem (pBuf, TableSize);
probeer
FillChar (pBuf^, TableSize, #0); // duidelijke buffer, aangezien W98 niet
// krijgt lijstwijzer
resultaat: = GetIfTable (PTMibIfTable (pBuf), @TableSize, vals);
als het resultaat <> NO_ERROR dan weggaat;
IfTot: = PTMibIfTable (pBuf) ^.dwNumEntries;
als IfTot = 0 dan weggaat;
SetLength (IfRows, IfTot);
pNext: = pBuf + SizeOf (IfTot);
voor I: = 0 aan Pred (IfTot)
begin
IfRows [I]: = PTMibIfRow (pNext) ^;
n.v. (pNext, SizeOf (TMibIfRow)) ;
eind;
tot slot
FreeMem (pBuf);
eind;
eind;
procedure Get_IfTable (Lijst: TStrings);
var
IfRows: TIfRows;
Fout, I: geheel;
NumEntries: geheel;
sDescr, sIfName: koord;
begin
als Toegewezen niet (Lijst) toen UITGANG;
List.Clear;
SetLength (IfRows, 0);
Fout: = IpHlpIfTable (NumEntries, IfRows);
als (Fout <> 0) toen
List.Add (SysErrorMessage (GetLastError))
als anders NumEntries = 0 toen
List.Add („geen ingangen.“ )
anders
begin
voor I: = 0 aan Pred (NumEntries)
begin
met IfRows [I]
begin
als wszName [1] = #0 toen
sIfName: = ''
anders
sIfName: = WideCharToString (@wszName); // zet Unicode in koord om
sIfName: = versiering (sIfName);
sDescr: = bDescr;
sDescr: = versiering (sDescr);
List.Add (Formaat (
„%0.8x |%3d | %16s |%8d |%12d |%2d |%2d |%10d |%10d | %-s| %-s“,
[dwIndex, dwType, MacAddr2Str (TMacAddress (bPhysAddr),
dwPhysAddrLen), dwMTU, dwSpeed, dwAdminStatus,
dwOPerStatus, Int64 (dwInOctets), Int64 (dwOutOctets), // tellers is met 32 bits
sIfName, sDescr]) // Angus, toegevoegde in/out
);
eind;
eind;
eind;
SetLength (IfRows, 0); // vrij geheugen
eind;
functie IpHlpIfEntry (Index: geheel; var IfRow: TMibIfRow): geheel;
begin
resultaat: = ERROR_NOT_SUPPORTED;
als NIET LoadIpHlp dan weggaat;
FillChar (IfRow, SizeOf (TMibIfRow), #0); // duidelijke buffer, aangezien W98 niet
IfRow.dwIndex: = Index;
resultaat: = GetIfEntry (@IfRow);
eind;
//-----------------------------------------------------------------------------
{Info op geïnstalleerde adapters}
functie IpHlpAdaptersInfo (var AdpTot: geheel; var AdpRows: TAdaptorRows): geheel;
var
BufLen: DWORD;
AdapterInfo: PTIP_ADAPTER_INFO;
PIpAddr: PTIP_ADDR_STRING;
PBuf: PCHAR;
I: geheel;
begin
SetLength (AdpRows, 4);
AdpTot: = 0;
BufLen: = 0;
resultaat: = GetAdaptersInfo (de Nul, @BufLen);
als (resultaat <> ERROR_INSUFFICIENT_BUFFER) en (resultaat = NO_ERROR) toen uitgang;
GetMem (pBuf, BufLen);
probeer
FillChar (pBuf^, BufLen, #0); // duidelijke buffer
resultaat: = GetAdaptersInfo (PTIP_ADAPTER_INFO (PBuf), @BufLen);
als resultaat = NO_ERROR toen
begin
AdapterInfo: = PTIP_ADAPTER_INFO (PBuf);
terwijl (de nul van AdapterInfo <>)
begin
AdpRows [AdpTot] .IPAddressTot: = 0;
SetLength ([AdpTot] .IPAddressList AdpRows, 2);
SetLength ([AdpTot] .IPMaskList AdpRows, 2);
AdpRows [AdpTot] .GatewayTot: = 0;
SetLength ([AdpTot] .GatewayList AdpRows, 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: = Versiering (koord (AdapterInfo^.AdapterName));
AdpRows [AdpTot]. Beschrijving: = Versiering (koord (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;
als Nul AdapterInfo^.CurrentIPAddress <> toen
begin
AdpRows [AdpTot] .CurrIPAddress: = AdapterInfo^.CurrentIPAddress.IpAddress;
AdpRows [AdpTot] .CurrIPMask: = AdapterInfo^.CurrentIPAddress.IpMask;
eind;
// krijgt lijst van IP adressen en maskers voor IPAddressList
I: = 0;
PIpAddr: = @AdapterInfo^.IPAddressList;
terwijl (de Nul van PIpAddr <>)
begin
.IPAddressList van AdpRows [AdpTot] [I]: = PIpAddr.IpAddress;
.IPMaskList van AdpRows [AdpTot] [I]: = PIpAddr.IpMask;
PIpAddr: = PIpAddr.Next;
n.v. (i);
als Lengte ([AdpTot] .IPAddressList AdpRows) <= I toen
begin
SetLength ([AdpTot] .IPAddressList AdpRows, I * 2);
SetLength ([AdpTot] .IPMaskList AdpRows, I * 2);
eind;
eind;
AdpRows [AdpTot] .IPAddressTot: = I;
// krijgt lijst van IP adressen voor GatewayList
I: = 0;
PIpAddr: = @AdapterInfo^.GatewayList;
terwijl (de Nul van PIpAddr <>)
begin
.GatewayList van AdpRows [AdpTot] [I]: = PIpAddr.IpAddress;
PIpAddr: = PIpAddr.Next;
n.v. (i);
als Lengte ([AdpTot] .GatewayList AdpRows) <= I toen
SetLength ([AdpTot] .GatewayList AdpRows, I * 2);
eind;
AdpRows [AdpTot] .GatewayTot: = I;
// krijgt lijst van IP adressen voor GatewayList
I: = 0;
PIpAddr: = @AdapterInfo^.DHCPServer;
terwijl (de Nul van PIpAddr <>)
begin
AdpRows [AdpTot] .DHCPServer [I]: = PIpAddr.IpAddress;
PIpAddr: = PIpAddr.Next;
n.v. (i);
als Lengte (AdpRows [AdpTot] .DHCPServer) <= I toen
SetLength (AdpRows [AdpTot] .DHCPServer, I * 2);
eind;
AdpRows [AdpTot] .DHCPTot: = I;
// krijgt lijst van IP adressen voor PrimaryWINSServer
I: = 0;
PIpAddr: = @AdapterInfo^.PrimaryWINSServer;
terwijl (de Nul van PIpAddr <>)
begin
AdpRows [AdpTot] .PrimWINSServer [I]: = PIpAddr.IpAddress;
PIpAddr: = PIpAddr.Next;
n.v. (i);
als Lengte (AdpRows [AdpTot] .PrimWINSServer) <= I toen
SetLength (AdpRows [AdpTot] .PrimWINSServer, I * 2);
eind;
AdpRows [AdpTot] .PrimWINSTot: = I;
// krijgt lijst van IP adressen voor SecondaryWINSServer
I: = 0;
PIpAddr: = @AdapterInfo^.SecondaryWINSServer;
terwijl (de Nul van PIpAddr <>)
begin
AdpRows [AdpTot] .SecWINSServer [I]: = PIpAddr.IpAddress;
PIpAddr: = PIpAddr.Next;
n.v. (i);
als Lengte (AdpRows [AdpTot] .SecWINSServer) <= I toen
SetLength (AdpRows [AdpTot] .SecWINSServer, I * 2);
eind;
AdpRows [AdpTot] .SecWINSTot: = I;
AdpRows [AdpTot] .LeaseObtained: = AdapterInfo^.LeaseObtained;
AdpRows [AdpTot] .LeaseExpires: = AdapterInfo^.LeaseExpires;
n.v. (AdpTot);
als Lengte (AdpRows) <= AdpTot toen
SetLength (AdpRows, AdpTot * 2); // meer geheugen
AdapterInfo: = AdapterInfo^.Next;
eind;
SetLength (AdpRows, AdpTot);
eind;
tot slot
FreeMem (pBuf);
eind;
eind;
procedure Get_AdaptersInfo (Lijst: TStrings);
var
AdpTot: geheel;
AdpRows: TAdaptorRows;
Fout: DWORD;
I: geheel;
//J: geheel; jpt - zie verder
//S: koord; identiteitskaart
begin
als Toegewezen niet (Lijst) toen UITGANG;
List.Clear;
SetLength (AdpRows, 0);
AdpTot: = 0;
Fout: = IpHlpAdaptersInfo (AdpTot, AdpRows);
als (Fout <> 0) toen
List.Add (SysErrorMessage (GetLastError))
als anders AdpTot = 0 toen
List.Add („geen ingangen.“ )
anders
begin
voor I: = 0 aan Pred (AdpTot)
begin
met AdpRows [I]
begin
//List.Add (AdapterName + „|“ + Beschrijving); // jpt: niet nuttig
List.Add (Formaat („%8.8x | %6s | %16s | %2d | %16s | %16s | %16s“,
[Index, AdaptTypes [aType], MacAddress, DHCPEnabled,
GatewayList [0], DHCPServer [0], PrimWINSServer [0]]));
{als IPAddressTot <> 0 toen // jpt: niet nuttig
begin
S: = '';
voor J: = 0 aan Pred (IPAddressTot)
S: = S + IPAddressList [J] + „/“ + IPMaskList [J] + „ | “;
List.Add (IntToStr (IPAddressTot) + „IP Addresse: “ + S);
eind;
List.Add (''); }
eind;
eind;
eind;
SetLength (AdpRows, 0);
eind;
//-----------------------------------------------------------------------------
{krijg ronde reistijd en hopcount aan vermelde IP}
functie Get_RTTAndHopCount (IPAddr: DWORD; MaxHops: Longint; var RTT: Longint;
var HopCount: Longint): geheel;
begin
als niet GetRTTAndHopCount (IPAddr, @HopCount, MaxHops, @RTT) toen
begin
Resultaat: = GetLastError;
RTT: = -1; // onbereikbare Bestemming, BAD_HOST_NAME, etc….
HopCount: = -1;
eind
anders
Resultaat: = NO_ERROR;
eind;
//-----------------------------------------------------------------------------
{De aRP-Lijst maakt een lijst van relaties tussen verre IP en ver MAC-Adres.
NOTA: dit zijn caching ingangen; wanneer er niet meer netwerkverkeer aan a is
de knoop, ingang wordt geschrapt na een paar notulen.
}
procedure Get_ARPTable (Lijst: TStrings);
var
IPNetRow: TMibIPNetRow;
TableSize: DWORD;
NumEntries: DWORD;
ErrorCode: DWORD;
i: geheel;
pBuf: PChar;
begin
als Toegewezen niet (Lijst) toen UITGANG;
List.Clear;
// roept eerst: krijg lijstlengte
TableSize: = 0;
ErrorCode: = GetIPNetTable (de Nul, @TableSize, vals); // Angus
//
als ErrorCode = ERROR_NO_DATA toen
begin
List.Add („leeg aRP-Geheim voorgeheugen.“ );
UITGANG;
eind;
// krijgt lijst
GetMem (pBuf, TableSize);
NumEntries: = 0;
probeer
ErrorCode: = GetIpNetTable (PTMIBIPNetTable (pBuf), @TableSize, vals);
als ErrorCode = NO_ERROR toen
begin
NumEntries: = PTMIBIPNetTable (pBuf) ^.dwNumEntries;
als NumEntries > 0 toen // paranoia het slaan, maar u nooit… het weet
begin
n.v. (pBuf, SizeOf (DWORD)); // krijgt afgelopen lijstgrootte
voor I: = 1 aan NumEntries
begin
IPNetRow: = PTMIBIPNetRow (PBuf) ^;
met IPNetRow
List.Add (Formaat („%8x | %12s | %16s | %10s“,
[dwIndex, MacAddr2Str (bPhysAddr, dwPhysAddrLen),
IPAddr2Str (dwAddr), ARPEntryType [dwType]
]));
n.v. (pBuf, SizeOf (IPNetRow));
eind;
eind
anders
List.Add („leeg aRP-Geheim voorgeheugen.“ );
eind
anders
List.Add (SysErrorMessage (ErrorCode));
// herstellen wij _must_ wijzer!
tot slot
Dec (pBuf, SizeOf (DWORD) + NumEntries * SizeOf (IPNetRow));
FreeMem (pBuf);
eind;
eind;
//------------------------------------------------------------------------------
procedure Get_TCPTable (Lijst: TStrings);
var
TCPRow: TMIBTCPRow;
i,
NumEntries: geheel;
TableSize: DWORD;
ErrorCode: DWORD;
DestIP: koord;
pBuf: PChar;
begin
als Toegewezen niet (Lijst) toen UITGANG;
List.Clear;
RecentIPs.Clear;
// roept eerst: krijg grootte van lijst
TableSize: = 0;
NumEntries: = 0;
ErrorCode: = GetTCPTable (de Nul, @TableSize, vals); // Angus
als Errorcode <> ERROR_INSUFFICIENT_BUFFER toen
UITGANG;
// wordt opnieuw vereiste geheugengrootte, vraag
GetMem (pBuf, TableSize);
// krijgt lijst
ErrorCode: = GetTCPTable (PTMIBTCPTable (pBuf), @TableSize, vals);
als ErrorCode = NO_ERROR toen
begin
NumEntries: = PTMIBTCPTable (pBuf) ^.dwNumEntries;
als NumEntries > 0 toen
begin
n.v. (pBuf, SizeOf (DWORD)); // krijgt afgelopen lijstgrootte
voor I: = 1 aan NumEntries
begin
TCPRow: = PTMIBTCPRow (pBuf) ^; // krijgt volgende verslag
met TCPRow
begin
als dwRemoteAddr = 0 toen
dwRemotePort: = 0;
DestIP: = IPAddr2Str (dwRemoteAddr);
List.Add (
Formaat („%15s: %-7s | %15s: %-7s | %-16s“,
[IpAddr2Str (dwLocalAddr),
Port2Svc (Port2Wrd (dwLocalPort)),
DestIP,
Port2Svc (Port2Wrd (dwRemotePort)),
TCPConnState [dwState]
]));
//
als (niet (dwRemoteAddr = 0))
en (RecentIps.IndexOf (DestIP) = -1) toen
RecentIPs.Add (DestIP);
eind;
n.v. (pBuf, SizeOf (TMIBTCPRow));
eind;
eind;
eind
anders
List.Add (SyserrorMessage (ErrorCode));
Dec (pBuf, SizeOf (DWORD) + NumEntries * SizeOf (TMibTCPRow));
FreeMem (pBuf);
eind;
//------------------------------------------------------------------------------
procedure Get_TCPStatistics (Lijst: TStrings);
var
TCPStats: TMibTCPStats;
ErrorCode: DWORD;
begin
als Toegewezen niet (Lijst) toen UITGANG;
List.Clear;
als NIET LoadIpHlp dan weggaat;
ErrorCode: = GetTCPStatistics (@TCPStats);
als ErrorCode = NO_ERROR toen
met TCPStats
begin
List.Add (het „algoritme van de Wederuitzending: “ + TCPToAlgo [dwRTOAlgorithm]);
List.Add („MinimumOnderbreking: “ + IntToStr (dwRTOMin) + „Mej.“);
List.Add („MaximumOnderbreking: “ + IntToStr (dwRTOMax) + „Mej.“);
List.Add („MaximumPend.Connections: “ + IntToStr (dwRTOAlgorithm));
List.Add („Actief opent: “ + IntToStr (dwActiveOpens));
List.Add (het „Passief opent: “ + IntToStr (dwPassiveOpens));
List.Add („Ontbroken Open Pogingen: “ + IntToStr (dwAttemptFails));
List.Add („Gevestigd conn. Het terugstellen: “ + IntToStr (dwEstabResets));
List.Add („Huidige Gevestigde Conn.: “ + IntToStr (dwCurrEstab));
List.Add („Ontvangen Segmenten: “ + IntToStr (dwInSegs));
List.Add („Verzonden Segmenten: “ + IntToStr (dwOutSegs));
List.Add („Opnieuw gebrachte over Segmenten: “ + IntToStr (dwReTransSegs));
List.Add („Inkomende Fouten: “ + IntToStr (dwInErrs));
List.Add (de „Uitgaande Terugstellen: “ + IntToStr (dwOutRsts));
List.Add („Cumulatieve Verbindingen: “ + IntToStr (dwNumConns));
eind
anders
List.Add (SyserrorMessage (ErrorCode));
eind;
functie IpHlpTCPStatistics (var TCPStats: TMibTCPStats): geheel;
begin
resultaat: = ERROR_NOT_SUPPORTED;
als NIET LoadIpHlp dan weggaat;
resultaat: = GetTCPStatistics (@TCPStats);
eind;
//------------------------------------------------------------------------------
procedure Get_UDPTable (Lijst: TStrings);
var
UDPRow: TMIBUDPRow;
i,
NumEntries: geheel;
TableSize: DWORD;
ErrorCode: DWORD;
pBuf: PChar;
begin
als Toegewezen niet (Lijst) toen UITGANG;
List.Clear;
// roept eerst: krijg grootte van lijst
TableSize: = 0;
NumEntries: = 0;
ErrorCode: = GetUDPTable (de Nul, @TableSize, vals);
als Errorcode <> ERROR_INSUFFICIENT_BUFFER toen
UITGANG;
// wordt opnieuw vereiste grootte van geheugen, vraag
GetMem (pBuf, TableSize);
// krijgt lijst
ErrorCode: = GetUDPTable (PTMIBUDPTable (pBuf), @TableSize, vals);
als ErrorCode = NO_ERROR toen
begin
NumEntries: = PTMIBUDPTable (pBuf) ^.dwNumEntries;
als NumEntries > 0 toen
begin
n.v. (pBuf, SizeOf (DWORD)); // krijgt afgelopen lijstgrootte
voor I: = 1 aan NumEntries
begin
UDPRow: = PTMIBUDPRow (pBuf) ^; // krijgt volgende verslag
met UDPRow
List.Add (Formaat („%15s: %-6s“,
[IpAddr2Str (dwLocalAddr),
Port2Svc (Port2Wrd (dwLocalPort))
]));
n.v. (pBuf, SizeOf (TMIBUDPRow));
eind;
eind
anders
List.Add („geen ingangen.“ );
eind
anders
List.Add (SyserrorMessage (ErrorCode));
Dec (pBuf, SizeOf (DWORD) + NumEntries * SizeOf (TMibUDPRow));
FreeMem (pBuf);
eind;
//------------------------------------------------------------------------------
procedure Get_IPAddrTable (Lijst: TStrings);
var
IPAddrRow: TMibIPAddrRow;
TableSize: DWORD;
ErrorCode: DWORD;
i: geheel;
pBuf: PChar;
NumEntries: DWORD;
begin
als Toegewezen niet (Lijst) toen UITGANG;
List.Clear;
TableSize: = 0; ;
NumEntries: = 0;
// roept eerst: krijg lijstlengte
ErrorCode: = GetIpAddrTable (de Nul, @TableSize, waar); // Angus
als Errorcode <> ERROR_INSUFFICIENT_BUFFER toen
UITGANG;
GetMem (pBuf, TableSize);
// krijgt lijst
ErrorCode: = GetIpAddrTable (PTMibIPAddrTable (pBuf), @TableSize, waar);
als ErrorCode = NO_ERROR toen
begin
NumEntries: = PTMibIPAddrTable (pBuf) ^.dwNumEntries;
als NumEntries > 0 toen
begin
n.v. (pBuf, SizeOf (DWORD));
voor I: = 1 aan NumEntries
begin
IPAddrRow: = PTMIBIPAddrRow (pBuf) ^;
met IPAddrRow
List.Add (Formaat („%8.8x | %15s | %15s | %15s | %8.8d“,
[dwIndex,
IPAddr2Str (dwAddr),
IPAddr2Str (dwMask),
IPAddr2Str (dwBCastAddr),
dwReasmSize
]));
n.v. (pBuf, SizeOf (TMIBIPAddrRow));
eind;
eind
anders
List.Add („geen ingangen.“ );
eind
anders
List.Add (SysErrorMessage (ErrorCode));
// wij wijzer moeten herstellen!
Dec (pBuf, SizeOf (DWORD) + NumEntries * SizeOf (IPAddrRow));
FreeMem (pBuf);
eind;
//-----------------------------------------------------------------------------
{krijgt ingangen in het verpletteren van lijst; equivalent aan de „Druk van de Route“}
procedure Get_IPForwardTable (Lijst: TStrings);
var
IPForwRow: TMibIPForwardRow;
TableSize: DWORD;
ErrorCode: DWORD;
i: geheel;
pBuf: PChar;
NumEntries: DWORD;
begin
als Toegewezen niet (Lijst) toen UITGANG;
List.Clear;
TableSize: = 0;
// roept eerst: krijg lijstlengte
NumEntries: = 0;
ErrorCode: = GetIpForwardTable (de Nul, @TableSize, waar);
als Errorcode <> ERROR_INSUFFICIENT_BUFFER toen
UITGANG;
// krijgt lijst
GetMem (pBuf, TableSize);
ErrorCode: = GetIpForwardTable (PTMibIPForwardTable (pBuf), @TableSize, waar);
als ErrorCode = NO_ERROR toen
begin
NumEntries: = PTMibIPForwardTable (pBuf) ^.dwNumEntries;
als NumEntries > 0 toen
begin
n.v. (pBuf, SizeOf (DWORD));
voor I: = 1 aan NumEntries
begin
IPForwRow: = PTMibIPForwardRow (pBuf) ^;
met IPForwRow
begin
als (dwForwardType < 1)
of (dwForwardType > 4) toen
dwForwardType: = 1; // Angus, staat voor slechte waarde toe
List.Add (Formaat (
„%15s | %15s | %15s | %8.8x | %7s | %5.5d | %7s | %2.2d“,
[(Het meest dwForwardDest) IPAddr2Str,
IPAddr2Str (dwForwardMask),
IPAddr2Str (dwForwardNextHop),
dwForwardIFIndex,
IPForwTypes [dwForwardType],
dwForwardNextHopAS,
IPForwProtos [dwForwardProto],
dwForwardMetric1
]));
eind;
n.v. (pBuf, SizeOf (TMibIPForwardRow));
eind;
eind
anders
List.Add („geen ingangen.“ );
eind
anders
List.Add (SysErrorMessage (ErrorCode));
Dec (pBuf, SizeOf (DWORD) + NumEntries * SizeOf (TMibIPForwardRow));
FreeMem (pBuf);
eind;
//------------------------------------------------------------------------------
procedure Get_IPStatistics (Lijst: TStrings);
var
IPStats: TMibIPStats;
ErrorCode: geheel;
begin
als Toegewezen niet (Lijst) toen UITGANG;
als NIET LoadIpHlp dan weggaat;
ErrorCode: = GetIPStatistics (@IPStats);
als ErrorCode = NO_ERROR toen
begin
List.Clear;
met IPStats
begin
als het dwForwarding = 1 toen
List.add („Toegelaten Door:sturen: “ + „ja“)
anders
List.add („Toegelaten Door:sturen: “ + „Geen“);
List.add („Gebrek TTL: “ + inttostr (dwDefaultTTL));
List.add („Ontvangen Datagrammen: “ + inttostr (dwInReceives));
List.add (de „Fouten van de Kopbal (binnen): “ + inttostr (dwInHdrErrors));
List.add (de „Fouten van het Adres (binnen): “ + inttostr (dwInAddrErrors));
List.add („Door:sturen Datagrammen: “ + inttostr (dwForwDatagrams)); // Angus
List.add („Onbekende Protocollen (binnen): “ + inttostr (dwInUnknownProtos));
List.add („Verworpen Datagrammen: “ + inttostr (dwInDiscards));
List.add („Geleverde Datagrammen: “ + inttostr (dwInDelivers));
List.add („Verzoeken uit: “ + inttostr (dwOutRequests));
List.add („Verworpen Leiden: “ + inttostr (dwRoutingDiscards));
List.add („Geen Routes (uit): “ + inttostr (dwOutNoRoutes));
List.add („breng Onderbrekingen opnieuw samen: “ + inttostr (dwReasmTimeOut));
List.add („breng Verzoeken opnieuw samen: “ + inttostr (dwReasmReqds));
List.add („Hermontages Succesfull: “ + inttostr (dwReasmOKs));
List.add („Ontbroken Hermontages: “ + inttostr (dwReasmFails));
List.add („Succesvolle Fragmentations: “ + inttostr (dwFragOKs));
List.add („Ontbroken Fragmentations: “ + inttostr (dwFragFails));
List.add („Versplinterde Datagrammen: “ + inttostr (dwFRagCreates));
List.add („Aantal Interfaces: “ + inttostr (dwNumIf));
List.add („Aantal iP-Adressen: “ + inttostr (dwNumAddr));
List.add („Routes in RoutingTable: “ + inttostr (dwNumRoutes));
eind;
eind
anders
List.Add (SysErrorMessage (ErrorCode));
eind;
functie IpHlpIPStatistics (var IPStats: TMibIPStats): geheel; // Angus
begin
resultaat: = ERROR_NOT_SUPPORTED;
als NIET LoadIpHlp dan weggaat;
resultaat: = GetIPStatistics (@IPStats);
eind;
//------------------------------------------------------------------------------
procedure Get_UdpStatistics (Lijst: TStrings);
var
UdpStats: TMibUDPStats;
ErrorCode: geheel;
begin
als Toegewezen niet (Lijst) toen UITGANG;
ErrorCode: = GetUDPStatistics (@UdpStats);
als ErrorCode = NO_ERROR toen
begin
List.Clear;
met UDPStats
begin
List.add („Datagrammen (binnen): “ + inttostr (dwInDatagrams));
List.add („Datagrammen (uit): “ + inttostr (dwOutDatagrams));
List.add („Geen Havens: “ + inttostr (dwNoPorts));
List.add („Fouten (binnen): “ + inttostr (dwInErrors));
List.add („UDP luistert Havens: “ + inttostr (dwNumAddrs));
eind;
eind
anders
List.Add (SysErrorMessage (ErrorCode));
eind;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
functie IpHlpUdpStatistics (UdpStats: TMibUDPStats): geheel; // Angus
begin
resultaat: = ERROR_NOT_SUPPORTED;
als NIET LoadIpHlp dan weggaat;
resultaat: = GetUDPStatistics (@UdpStats);
eind;
//------------------------------------------------------------------------------
procedure Get_ICMPStats (ICMPIn, ICMPOut: TStrings);
var
ErrorCode: DWORD;
ICMPStats: PTMibICMPInfo;
begin
als (ICMPIn = nul) of (ICMPOut = nul) toen UITGANG;
ICMPIn.Clear;
ICMPOut.Clear;
Nieuw (ICMPStats);
ErrorCode: = GetICMPStatistics (ICMPStats);
als ErrorCode = NO_ERROR toen
begin
met ICMPStats.InStats
begin
ICMPIn.Add („ontvangen Berichten: “ + IntToStr (dwMsgs));
ICMPIn.Add („Fouten: “ + IntToStr (dwErrors));
ICMPIn.Add („Dest. Onbereikbaar: “ + IntToStr (dwDestUnreachs));
ICMPIn.Add („Overschreden Tijd: “ + IntToStr (dwTimeEcxcds));
ICMPIn.Add („Param. Problemen: “ + IntToStr (dwParmProbs));
ICMPIn.Add (de „Bron dooft: “ + IntToStr (dwSrcQuenchs));
ICMPIn.Add („richt opnieuw: “ + IntToStr (dwRedirects));
ICMPIn.Add (de „Verzoeken van de Echo: “ + IntToStr (dwEchos));
ICMPIn.Add (de „Antwoorden van de Echo: “ + IntToStr (dwEchoReps));
ICMPIn.Add („Timestamp Verzoeken: “ + IntToStr (dwTimeStamps));
ICMPIn.Add („Timestamp Antwoorden: “ + IntToStr (dwTimeStampReps));
ICMPIn.Add („Addr. De Verzoeken van maskers: “ + IntToStr (dwAddrMasks));
ICMPIn.Add („Addr. De Antwoorden van het masker: “ + IntToStr (dwAddrReps));
eind;
//
met ICMPStats.OutStats
begin
ICMPOut.Add („verzonden Berichten: “ + IntToStr (dwMsgs));
ICMPOut.Add („Fouten: “ + IntToStr (dwErrors));
ICMPOut.Add („Dest. Onbereikbaar: “ + IntToStr (dwDestUnreachs));
ICMPOut.Add („Overschreden Tijd: “ + IntToStr (dwTimeEcxcds));
ICMPOut.Add („Param. Problemen: “ + IntToStr (dwParmProbs));
ICMPOut.Add (de „Bron dooft: “ + IntToStr (dwSrcQuenchs));
ICMPOut.Add („richt opnieuw: “ + IntToStr (dwRedirects));
ICMPOut.Add (de „Verzoeken van de Echo: “ + IntToStr (dwEchos));
ICMPOut.Add (de „Antwoorden van de Echo: “ + IntToStr (dwEchoReps));
ICMPOut.Add („Timestamp Verzoeken: “ + IntToStr (dwTimeStamps));
ICMPOut.Add („Timestamp Antwoorden: “ + IntToStr (dwTimeStampReps));
ICMPOut.Add („Addr. De Verzoeken van maskers: “ + IntToStr (dwAddrMasks));
ICMPOut.Add („Addr. De Antwoorden van het masker: “ + IntToStr (dwAddrReps));
eind;
eind
anders
IcmpIn.Add (SysErrorMessage (ErrorCode));
Schik (ICMPStats);
eind;
//------------------------------------------------------------------------------
procedure Get_RecentDestIPs (Lijst: TStrings);
begin
indien dan Toegewezen (Lijst)
List.Assign (RecentIPs)
eind;
initialisering
RecentIPs: = TStringList.Create;
voltooiing
RecentIPs.Free;
end.
|
