Вопрос : Как использовать блок

Как использовать потребность блока IPHelper.
I знать если кто-то pinging, то мое computer.

I напишите малое Кодего, НО я не уверен если это будет правильно usage.
Can кто-то, то добавляю мое Кодего для того чтобы сформировать его little.

type
TIcmpMessage =
private
icmpstate типа (TObject): TMibICMPInfo; getMessage
function: TMibICMPInfo;
public
constructor создается (icmpMessage: TMibICMPInfo); фактически;
destructor разрушает; преодоление автоматического действия; icmpMessage
property: TMibICMPInfo прочитало getMessage;
protected
end;


constructor TIcmpMessage.Create (icmpMessage: TMibICMPInfo);
end
begin
…;
destructor TIcmpMessage.Destroy;
begin
унаследовало;
end;

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

procedure TForm1.Timer1Timer (прислужник: TObject);
showmessage
begin
… («some_one pingponging на вашем компьютере ");
end
…;
class= " ясное " >
> " codeSnippet " class=
class= " lineNumbers "
class=
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 IPHelper " class= " id= " codeSnippet821926
 128
Добавьте:  ICMP - статистик
Добавьте:  Известные номера порта
Добавьте:  Список RecentIP
Добавьте:  Уточнение отметчика времени

dirkcl v1.2
----
Починка:  Уточнение недавнего IP правильно
ДОБАВЬТЕ:  Кодие ICMP-ошибки перевели

v1.3 - 18-ое сентября 2001
----
  Angus Robertson, Magenta системы Ltd, Англи
     [email protected], http://www.magsys.co.uk/delphi/
  Медленно преобразовывающ procs в функции могут быть использованы другими программами,
     ie Get_ будет IpHlp
  Главным образом улучшения что в настоящее время сервер DNS теперь показан, также
     байты in/out для каждой поверхности стыка (переходника aka)
  Все функции динамический, нагружены поэтому программу можно использовать на W95/NT4
  Испытано с Делфи 6 на Windows 2000 и XP

v1.4 - 28-ое февраля 2002 - Angus
----
  Фикчированная главная утечка памяти в IpHlpIfTable (за исключением вместо окончательно)
  Фикчированная главная утечка памяти в Get_AdaptersInfo (инкрементированном указателе буфера)
  Созданное IpHlpAdaptersInfo возвращает TAdaptorRows


  Примечание: Адрес DNS возвращений IpHlpNetworkParams динамический (и другое вещество)
  Примечание: IpHlpIfEntry возвращает байты in/out для переходники сети

v1.5 - 5-ое октября 2003
----
  Jean-Pierre Turchi «от юга Франци» 
  Косметическо (четко) и add-in от iana.org в «WellKnownPorts»

}
*)

поверхность стыка

пользы
  Windows, сообщения, SysUtils, типы, диалоги, IpHlpApi;

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

//------conversion известных номеров порта для того чтобы обслуживать имена----------------

тип
  TWellKnownPort = показатель
    Prt: DWORD;
    Srv: шнур [20];
  конец;


const
    // только большинств «популярные» обслуживания…
  WellKnownPorts: блок [1..32] TWellKnownPort
  = (
// (Prt: 0; Srv:   «RESRVED "), {сдержанное}
    (Prt: 7; Srv:   «ОТГОЛОСОК "), {Пинг}
    (Prt: 9; Srv:   «СБРАСЫВАНИЕ "),
    (Prt: 13; Srv:  «ДНЕВНОЕ ВРЕМЯ "),
    (Prt: 17; Srv:  «QOTD "), {цитата дня}
    (Prt: 19; Srv:  «CHARGEN "), {генератор знаков}
    (Prt: 20; Srv:  «FTPDATA "), {протокол перехода архива - datas}
    (Prt: 21; Srv:  «FTPCTRL "), {протокол перехода архива - управление}
    (Prt: 22; Srv:  «SSH "),
    (Prt: 23; Srv:  «TELNET "),
    (Prt: 25; Srv:  «SMTP "), {просто протокол перевода по почте}
    (Prt: 37; Srv:  «ВРЕМЯ "), {протокол времени}
    (Prt: 43; Srv:  «WHOIS "), {ВОЗ БУДЕТ обслуживанием}
    (Prt: 53; Srv:  «DNS "), {обслуживание домена названное}
    (Prt: 67; Srv:  «BOOTPS "), {сервер BOOTP}
    (Prt: 68; Srv:  «BOOTPC "), {клиент BOOTP}
    (Prt: 69; Srv:  «TFTP "), {тривиальный FTP}
    (Prt: 70; Srv:  «СУСЛИК "), {суслик}
    (Prt: 79; Srv:  «ПЕРСТ "), {перст}
    (Prt: 80; Srv:  «HTTP "), {HTTP}
    (Prt: 88; Srv:  «KERBROS "), {Керберос}
    (Prt: 109; Srv: «POP2 "), {2-ой вариант протокола почтамта}
    (Prt: 110; Srv: «POP3 "), {вариант 3 протокола почтамта}
    (Prt: 111; Srv: «SUN_RPC "), {звонок дистанционной процедуре по СОЛНЦА}
    (Prt: 119; Srv: «NNTP "), {протокол перехода новостей}
    (Prt: 123; Srv: «NTP "), {протокол времени сети}
    (Prt: 135; Srv: «DCOMRPC "), {обслуживание положения}
    (Prt: 137; Srv: «NBNAME "), {обслуживание NETBIOS названное}
    (Prt: 138; Srv: «NBDGRAM "), {обслуживание датаграммы NETBIOS}
    (Prt: 139; Srv: «NBSESS "), {обслуживание встречи NETBIOS}
    (Prt: 143; Srv: «IMAP "), {протокол доступа сообщения интернета}
    (Prt: 161; Srv: «SNMP "), {просто Netw. Протокол управления}
    (Prt: 169; Srv: «ПОШЛИТЕ ")
    );


//-----------conversion Кодих ошибки ICMP к шнурам--------------------------
             {принято от www.sockets.com/ms_icmp.c}

const
  ICMP_ERROR_BASE = 11000;
  IcmpErr: блок [1..22] шнура =
  (
   «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 разнообразных перечисленных значений к шнурам------------------

  ARPEntryType: блок [1..4] шнура = («другое», «инвалидно»,
    «Динамическо», «Static»
    );
  TCPConnState:
    блок [1..12] шнура =
    («закрыл», «слушающ», «syn_sent»,
    «syn_rcvd», «установило», «fin_wait1»,
    «fin_wait2», «close_wait», «закрывающ»,
    «last_ack», «time_wait», «delete_tcb»
    );

  TCPToAlgo: блок [1..4] шнура =
    («Const.Timeout», «MIL-STD-1778»,
    «Van Jacobson», «другое ");

  IPForwTypes: блок [1..4] шнура =
    («другое», «инвалидно», «local», «remote ");

  IPForwProtos: блок [1..18] шнура =
    («ДРУГОЕ», «LOCAL», «NETMGMT», «ICMP», «EGP»,
    «GGP», «ВЕРТОЛЕТ», «СУЛОЙ», «IS_IS», «ES_IS»,
    «CISCO», «BBN», «OSPF», «BGP», «BOOTP»,
    «AUTO_STAT», «STATIC», «NOT_DOD ");

тип

// для IpHlpNetworkParams
  TNetworkParams = показатель
    Именя ведущего: шнур;
    DomainName: шнур;
    CurrentDnsServer: шнур;
    DnsServerTot: интежер;
    DnsServerNames: блок [0..9] шнура;
    NodeType: UINT;
    ScopeID: шнур;
    EnableRouting: UINT;
    EnableProxy: UINT;
    EnableDNS: UINT;
  конец;

  TIfRows = блок TMibIfRow; блок // динамический рядков

// для IpHlpAdaptersInfo
  TAdaptorInfo = показатель
    AdapterName: шнур;
    Описание: шнур;
    MacAddress: шнур;
    Индекс: DWORD;
    aType: UINT;
    DHCPEnabled: UINT;
    CurrIPAddress: шнур;
    CurrIPMask: шнур;
    IPAddressTot: интежер;
    IPAddressList: блок шнура;
    IPMaskList: блок шнура;
    GatewayTot: интежер;
    GatewayList: блок шнура;
    DHCPTot: интежер;
    DHCPServer: блок шнура;
    HaveWINS: BOOL;
    PrimWINSTot: интежер;
    PrimWINSServer: блок шнура;
    SecWINSTot: интежер;
    SecWINSServer: блок шнура;
    LeaseObtained: LongInt; Время // UNIX, секунды с 1970
    LeaseExpires: LongInt;   Время // UNIX, секунды с 1970
  конец;

  TAdaptorRows = блок TAdaptorInfo;


вещество //---------------exported-----------------------------------------------

функция IpHlpAdaptersInfo (var AdpTot: интежер; var AdpRows: TAdaptorRows): интежер;
процедура Get_AdaptersInfo (список: TStrings);
функция IpHlpNetworkParams (var NetworkParams: TNetworkParams): интежер;
процедура Get_NetworkParams (список: TStrings);
процедура Get_ARPTable (список: TStrings);
процедура Get_TCPTable (список: TStrings);
процедура Get_TCPStatistics (список: TStrings);
функция IpHlpTCPStatistics (var TCPStats: TMibTCPStats): интежер;
процедура Get_UDPTable (список: TStrings);
процедура Get_UDPStatistics (список: TStrings);
функция IpHlpUdpStatistics (UdpStats: TMibUDPStats): интежер;
процедура Get_IPAddrTable (список: TStrings);
процедура Get_IPForwardTable (список: TStrings);
процедура Get_IPStatistics (список: TStrings);
функция IpHlpIPStatistics (var IPStats: TMibIPStats): интежер;
функция Get_RTTAndHopCount (IPAddr: DWORD; MaxHops: Longint;
  RTT var: longint; var HopCount: longint): интежер;
процедура Get_ICMPStats (ICMPIn, ICMPOut: TStrings);
функция IpHlpIfTable (var IfTot: интежер; var IfRows: TIfRows): интежер;
процедура Get_IfTable (список: TStrings);
функция IpHlpIfEntry (индекс: интежер; var IfRow: TMibIfRow): интежер;
процедура Get_RecentDestIPs (список: TStrings);

utils преобразования //
функция MacAddr2Str (MacAddr: TMacAddress; размер: интежер): шнур;
функция IpAddr2Str (IPAddr: DWORD): шнур;
функция Str2IpAddr (IPStr: шнур): DWORD;
функция Port2Str (nwoPort: DWORD): шнур;
функция Port2Wrd (nwoPort: DWORD): DWORD;
функция Port2Svc (порт: DWORD): шнур;
функция ICMPErr2Str (ICMPErrCode: DWORD): шнур;

вставка

var
  RecentIPs: TStringList;

общие назначения //--------------General-----------------------------------------------

{выдержки затем «знак внимания» от шнура, после этого едят шнур}
функция NextToken (var s: шнур; Сепаратор: чарс): шнур;
var
  Sep_Pos: байт;
начните
  Результат: = '';
  если длины > 0 после этого начинают
    Sep_Pos: = pos (сепаратор, s);
    если Sep_Pos > 0 после этого начинает
      Результат: = экземпляр (s, 1, Pred (Sep_Pos));
      Delete (s, 1, Sep_Pos);
    конец
    еще начните
      Результат: = s;
      s: = '';
    конец;
  конец;
конец;

//------------------------------------------------------------------------------
{MAC-address согласий численный к шнуру ww-xx-yy-zz}
функция MacAddr2Str (MacAddr: TMacAddress; размер: интежер): шнур;
var
  iий: интежер;
начните
  если размер = 0 после этого
  начните
    Результат: = «00-00-00-00-00-00»;
    ВЫХОД;
  конец
  другой результат: = '';
  //
  для I: = 1 к размеру делает
    Результат: = результат + IntToHex (MacAddr [I], 2) + «-»;
  Delete (результат, длина (результат), 1);
конец;

//------------------------------------------------------------------------------
{IP-address новообращенных в заказе DWORD байта сети к поставлено точки - десятичный шнур}
функция IpAddr2Str (IPAddr: DWORD): шнур;
var
  iий: интежер;
начните
  Результат: = '';
  для I: = от 1 до 4 делают
  начните
    Результат: = результат + форма («%3d. », [IPAddr и $FF]);
    IPAddr: = shr 8 IPAddr;
  конец;
  Delete (результат, длина (результат), 1);
конец;

//------------------------------------------------------------------------------
{новообращенные поставленные точки - десятичный IP-address к заказу DWORD байта сети}
функция Str2IpAddr (IPStr: шнур): DWORD;
var
  iий: интежер;
  Num: DWORD;
начните
  Результат: = 0;
  для I: = от 1 до 4 делают
  попытка
    Num: = (StrToInt (NextToken (IPStr, «."))) shl 24;
    Результат: = (shr результата 8) или Num;
  за исключением
    Результат: = 0;
  конец;

конец;

//------------------------------------------------------------------------------
{номер порта новообращенных в заказе байта сети к DWORD}
функция Port2Wrd (nwoPort: DWORD): DWORD;
начните
  Результат: = обмен (СЛОВО (nwoPort));
конец;

//------------------------------------------------------------------------------
{номер порта новообращенных в заказе байта сети к шнуру}
функция Port2Str (nwoPort: DWORD): шнур;
начните
  Результат: = IntToStr (Port2Wrd (nwoPort));
конец;

//------------------------------------------------------------------------------
{номера порта новообращенных известные к удостоверению личности обслуживания}
функция Port2Svc (порт: DWORD): шнур;
var
  iий: интежер;
начните
  Результат: = форма («%4d», [порт]); // в случае если ый порт
  для I: = низко (WellKnownPorts) к максимуму (WellKnownPorts) сделайте
    если порт = WellKnownPorts, то [I]. Prt после этого
    начните
      Результат: = WellKnownPorts [I]. Srv;
      ПРОЛОМ;
    конец;
конец;

//-----------------------------------------------------------------------------
{вообще, фикчированные параметры сети}

процедура Get_NetworkParams (список: TStrings);
var
    NetworkParams: TNetworkParams;
    Iий, ErrorCode: интежер;
начните
    если задано (список) после этого ВЫХОДИТЕ;
    List.Clear;
    ErrorCode: = IpHlpNetworkParams (NetworkParams);
    если <> 0 ErrorCode после этого
    начните
        List.Add (SysErrorMessage (ErrorCode));
        выход;
    конец;
    с NetworkParams сделайте
    начните
        List.Add («ИМЕНЯ ВЕДУЩЕГО: » + именя ведущего);
        List.Add («ДОМЕН: » + DomainName);
        List.Add («ТИП УЗЛА NETBIOS: » + NETBIOSTypes [NodeType]);
        List.Add («ОБЪЕМ DHCP: » + ScopeID);
        List.Add («ТРАССА ПОЗВОЛИЛА: » + IntToStr (EnableRouting));
        List.Add («ПОЛНОМОЧИЕ ПОЗВОЛИЛО: » + IntToStr (EnableProxy));
        List.Add («DNS ПОЗВОЛИЛ: » + IntToStr (EnableDNS));
        если <> 0 DnsServerTot после этого
        начните
            для I: = 0 к Pred (DnsServerTot) делает
                List.Add («ADDR СЕРВЕРА DNS: » + DnsServerNames [I]);
        конец;
    конец;
конец;

// ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **
функция IpHlpNetworkParams (var NetworkParams: TNetworkParams): интежер;
var
  FixedInfo: PTFixedInfo;         // Angus
  InfoSize: Longint;
  PDnsServer: PTIP_ADDR_STRING;   // Angus
начните
    InfoSize: = 0;   // Angus
    результат: = ERROR_NOT_SUPPORTED;
    если НЕ LoadIpHlp после этого выходит;
    результат: = GetNetworkParams (ноли, @InfoSize);  // Angus
    если <> ERROR_BUFFER_OVERFLOW результата после этого выходит; // Angus
    GetMem (FixedInfo, InfoSize);                    // Angus
    попытка
    результат: = GetNetworkParams (FixedInfo, @InfoSize);   // Angus
    если <> ERROR_SUCCESS результата после этого выходит;
    NetworkParams.DnsServerTot: = 0;
    с FixedInfo^ сделайте
    начните
        NetworkParams.HostName: = уравновешивание (именя ведущего);
        NetworkParams.DomainName: = уравновешивание (DomainName);
        NetworkParams.ScopeId: = уравновешивание (ScopeID);
        NetworkParams.NodeType: = NodeType;
        NetworkParams.EnableRouting: = EnableRouting;
        NetworkParams.EnableProxy: = EnableProxy;
        NetworkParams.EnableDNS: = EnableDNS;
        NetworkParams.DnsServerNames [0]: = DNSServerList.IPAddress;  // Angus
        если 0] <> NetworkParams.DnsServerNames ['' после этого
                                        NetworkParams.DnsServerTot: = 1;
        PDnsServer: = DnsServerList.Next;
        пока ноли <> PDnsServer делают
        начните
            NetworkParams.DnsServerNames [NetworkParams.DnsServerTot]: =
                                        PDnsServer^.IPAddress;  // Angus
            inc (NetworkParams.DnsServerTot);
            если >= NetworkParams.DnsServerTot
                            Длина (NetworkParams.DnsServerNames) после этого выходит;
            PDnsServer: = PDnsServer.Next;
        конец;
    конец;
    окончательно
       FreeMem (FixedInfo);                     // Angus
    конец;
конец;

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

функция ICMPErr2Str (ICMPErrCode: DWORD): шнур;
начните
   Результат: = «UnknownError: » + IntToStr (ICMPErrCode);
   декабрь (ICMPErrCode, ICMP_ERROR_BASE);
   если ICMPErrCode внутри, то [низкий уровень (ICMpErr). Высоко (ICMPErr)] после этого
     Результат: = ICMPErr [ICMPErrCode];
конец;


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

// вклюает байты in/out для каждого переходники

функция IpHlpIfTable (var IfTot: интежер; var IfRows: TIfRows): интежер;
var
  Iий,
  TableSize: интежер;
  pBuf, pNext: PChar;
начните
  результат: = ERROR_NOT_SUPPORTED;
  если НЕ LoadIpHlp после этого выходит;
  SetLength (IfRows, 0);
  IfTot: = 0; // Angus
  TableSize: = 0;
   // звонок сперва: получите memsize необходимое
  результат: = GetIfTable (ноли, @TableSize, ложно);  // Angus
  если <> ERROR_INSUFFICIENT_BUFFER результата после этого выходит;
  GetMem (pBuf, TableSize);
  попытка
      FillChar (pBuf^, TableSize, #0);  буфер // ясный, в виду того что W98 не делает

   // получает указатель таблицы
      результат: = GetIfTable (PTMibIfTable (pBuf), @TableSize, ложно);
      если <> NO_ERROR результата после этого выходит;
      IfTot: = PTMibIfTable (pBuf) ^.dwNumEntries;
      если IfTot = 0 после этого выходит;
      SetLength (IfRows, IfTot);
      pNext: = pBuf + SizeOf (IfTot);
      для I: = 0 к Pred (IfTot) делает
      начните
         IfRows [I]: = ^ PTMibIfRow (pNext);
         inc (pNext, SizeOf (TMibIfRow)) ;
      конец;
  окончательно
      FreeMem (pBuf);
  конец;
конец;

процедура Get_IfTable (список: TStrings);
var
  IfRows: TIfRows;
  Ошибка, I: интежер;
  NumEntries: интежер;
  sDescr, sIfName: шнур;
начните
  если задано (список) после этого ВЫХОДИТЕ;
  List.Clear;
  SetLength (IfRows, 0);
  Ошибка: = IpHlpIfTable (NumEntries, IfRows);
  если (<> 0 ошибки) после этого
      List.Add (SysErrorMessage (GetLastError))
  еще если NumEntries = 0 после этого
      List.Add («нет entries.")
  еще
  начните
      для I: = 0 к Pred (NumEntries) делает
      начните
          с IfRows [I] сделайте
          начните
             если wszName [1] = #0 после этого
                 sIfName: = ''
             еще
                 sIfName: = WideCharToString (@wszName);  новообращенный Unicode // к шнуру
             sIfName: = уравновешивание (sIfName);
             sDescr: = bDescr;
             sDescr: = уравновешивание (sDescr);
             List.Add (форма (
               «%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), счетчики // трицатидвухразрядно
               sIfName, sDescr]) // Angus, добавили in/out
               );
          конец;
      конец;
  конец;
  SetLength (IfRows, 0);  // освобождает память
конец;

функция IpHlpIfEntry (индекс: интежер; var IfRow: TMibIfRow): интежер;
начните
  результат: = ERROR_NOT_SUPPORTED;
  если НЕ LoadIpHlp после этого выходит;
  FillChar (IfRow, SizeOf (TMibIfRow), #0);  буфер // ясный, в виду того что W98 не делает
  IfRow.dwIndex: = индекс;
  результат: = GetIfEntry (@IfRow);
конец;

//-----------------------------------------------------------------------------
{Info на установленных переходниках}

функция IpHlpAdaptersInfo (var AdpTot: интежер; var AdpRows: TAdaptorRows): интежер;
var
  BufLen: DWORD;
  AdapterInfo: PTIP_ADAPTER_INFO;
  PIpAddr: PTIP_ADDR_STRING;
  PBuf: PCHAR;
  Iий: интежер;
начните
  SetLength (AdpRows, 4);
  AdpTot: = 0;
  BufLen: = 0;
  результат: = GetAdaptersInfo (ноли, @BufLen);
  если (<> ERROR_INSUFFICIENT_BUFFER результата) и (результат = NO_ERROR) после этого выходите;
  GetMem (pBuf, BufLen);
  попытка
      FillChar (pBuf^, BufLen, #0);  буфер // ясный
      результат: = GetAdaptersInfo (PTIP_ADAPTER_INFO (PBuf), @BufLen);
      если результат = NO_ERROR после этого
      начните
         AdapterInfo: = PTIP_ADAPTER_INFO (PBuf);
         пока (ноли <> AdapterInfo) сделайте
         начните
            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: = уравновешивание (шнур (AdapterInfo^.AdapterName));
            AdpRows [AdpTot]. Описание: = уравновешивание (шнур (AdapterInfo^.Description));
            AdpRows [AdpTot] .MacAddress: = MacAddr2Str (TMacAddress (
                                 AdapterInfo^.Address), AdapterInfo^.AddressLength);
            AdpRows [AdpTot]. Индекс: = AdapterInfo^.Index;
            AdpRows [AdpTot] .aType: = AdapterInfo^.aType;
            AdpRows [AdpTot] .DHCPEnabled: = AdapterInfo^.DHCPEnabled;
            если ноли <> AdapterInfo^.CurrentIPAddress после этого
            начните
                AdpRows [AdpTot] .CurrIPAddress: = AdapterInfo^.CurrentIPAddress.IpAddress;
                AdpRows [AdpTot] .CurrIPMask: = AdapterInfo^.CurrentIPAddress.IpMask;
            конец;

        // получает список адресов и маск IP для IPAddressList
            Iий: = 0;
            PIpAddr: = @AdapterInfo^.IPAddressList;
            пока (ноли <> PIpAddr) сделайте
            начните
                AdpRows [AdpTot] .IPAddressList [I]: = PIpAddr.IpAddress;
                AdpRows [AdpTot] .IPMaskList [I]: = PIpAddr.IpMask;
                PIpAddr: = PIpAddr.Next;
                inc (I);
                если <= iий длины (AdpRows [AdpTot] .IPAddressList) после этого
                начните
                     SetLength (AdpRows [AdpTot] .IPAddressList, I * 2);
                     SetLength (AdpRows [AdpTot] .IPMaskList, I * 2);
                конец;
            конец;
            AdpRows [AdpTot] .IPAddressTot: = I;

        // получает список адресов IP для GatewayList
            Iий: = 0;
            PIpAddr: = @AdapterInfo^.GatewayList;
            пока (ноли <> PIpAddr) сделайте
            начните
                AdpRows [AdpTot] .GatewayList [I]: = PIpAddr.IpAddress;
                PIpAddr: = PIpAddr.Next;
                inc (I);
                если <= iий длины (AdpRows [AdpTot] .GatewayList) после этого
                             SetLength (AdpRows [AdpTot] .GatewayList, I * 2);
            конец;
            AdpRows [AdpTot] .GatewayTot: = I;

        // получает список адресов IP для GatewayList
            Iий: = 0;
            PIpAddr: = @AdapterInfo^.DHCPServer;
            пока (ноли <> PIpAddr) сделайте
            начните
                AdpRows [AdpTot] .DHCPServer [I]: = PIpAddr.IpAddress;
                PIpAddr: = PIpAddr.Next;
                inc (I);
                если <= iий длины (AdpRows [AdpTot] .DHCPServer) после этого
                             SetLength (AdpRows [AdpTot] .DHCPServer, I * 2);
            конец;
            AdpRows [AdpTot] .DHCPTot: = I;

        // получает список адресов IP для PrimaryWINSServer
            Iий: = 0;
            PIpAddr: = @AdapterInfo^.PrimaryWINSServer;
            пока (ноли <> PIpAddr) сделайте
            начните
                AdpRows [AdpTot] .PrimWINSServer [I]: = PIpAddr.IpAddress;
                PIpAddr: = PIpAddr.Next;
                inc (I);
                если <= iий длины (AdpRows [AdpTot] .PrimWINSServer) после этого
                             SetLength (AdpRows [AdpTot] .PrimWINSServer, I * 2);
            конец;
            AdpRows [AdpTot] .PrimWINSTot: = I;

       // получает список адресов IP для SecondaryWINSServer
            Iий: = 0;
            PIpAddr: = @AdapterInfo^.SecondaryWINSServer;
            пока (ноли <> PIpAddr) сделайте
            начните
                AdpRows [AdpTot] .SecWINSServer [I]: = PIpAddr.IpAddress;
                PIpAddr: = PIpAddr.Next;
                inc (I);
                если <= iий длины (AdpRows [AdpTot] .SecWINSServer) после этого
                             SetLength (AdpRows [AdpTot] .SecWINSServer, I * 2);
            конец;
            AdpRows [AdpTot] .SecWINSTot: = I;

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

            inc (AdpTot);
            если <= AdpTot длины (AdpRows) после этого
                            SetLength (AdpRows, AdpTot * 2);  // больше памяти
            AdapterInfo: = AdapterInfo^.Next;
         конец;
         SetLength (AdpRows, AdpTot);
      конец;
  окончательно
      FreeMem (pBuf);
  конец;
конец;

процедура Get_AdaptersInfo (список: TStrings);
var
  AdpTot: интежер;
  AdpRows: TAdaptorRows;
  Ошибка: DWORD;
  Iий: интежер;
  //J: интежер;  jpt - см. ниже
  //S: шнур;        удостоверение личности
начните
  если задано (список) после этого ВЫХОДИТЕ;
  List.Clear;
  SetLength (AdpRows, 0);
  AdpTot: = 0;
  Ошибка: = IpHlpAdaptersInfo (AdpTot, AdpRows);
  если (<> 0 ошибки) после этого
      List.Add (SysErrorMessage (GetLastError))
  еще если AdpTot = 0 после этого
      List.Add («нет entries.")
  еще
  начните
      для I: = 0 к Pred (AdpTot) делает
      начните
        с AdpRows [I] сделайте
        начните
            //List.Add (AdapterName + «|» + описание); jpt //: полезно
            List.Add (форма («%8.8x | %6s | %16s | %2d | %16s | %16s | %16s»,
                [Индекс, AdaptTypes [aType], MacAddress, DHCPEnabled,
                GatewayList [0], DHCPServer [0], PrimWINSServer [0]]));
            {если jpt // <> 0 IPAddressTot после этого:, то полезно
            начните
                S: = '';
                для j: = 0 к Pred (IPAddressTot) делает
                        S: = s + IPAddressList [j] + «/» + IPMaskList [j] + « | »;
                List.Add (IntToStr (IPAddressTot) + «IP Addresse: » + s);
            конец;
            List.Add (''); }
        конец;
      конец;
  конец;
  SetLength (AdpRows, 0);
конец;

//-----------------------------------------------------------------------------
{получите IP времени и hopcount поездка туда и обратно показанный}
функция Get_RTTAndHopCount (IPAddr: DWORD; MaxHops: Longint; RTT var: Longint;
  var HopCount: Longint): интежер;
начните
  если не GetRTTAndHopCount (IPAddr, @HopCount, MaxHops, @RTT) после этого
  начните
    Результат: = GetLastError;
    RTT: = -1; Назначение // unreachable, BAD_HOST_NAME, etc…
    HopCount: = -1;
  конец
  еще
    Результат: = NO_ERROR;
конец;

//-----------------------------------------------------------------------------
{ARP-таблица перечисляет отношения между дистанционным IP и дистанционным MAC-address.
 ПРИМЕЧАНИЕ: эти будут спрятанные в тайнике входы; когда не будет больше движения сети к a
 узел, вход уничтожен после немного минут.
}
процедура Get_ARPTable (список: TStrings);
var
  IPNetRow: TMibIPNetRow;
  TableSize: DWORD;
  NumEntries: DWORD;
  ErrorCode: DWORD;
  iий: интежер;
  pBuf: PChar;
начните
  если задано (список) после этого ВЫХОДИТЕ;
  List.Clear;
  // звонок сперва: получите длину таблицы
  TableSize: = 0;
  ErrorCode: = GetIPNetTable (ноли, @TableSize, ложно);   // Angus
  //
  если ErrorCode = ERROR_NO_DATA после этого
  начните
    List.Add («ARP-тайник empty.");
    ВЫХОД;
  конец;
  // получает таблицу
  GetMem (pBuf, TableSize);
  NumEntries: = 0;
  попытка
  ErrorCode: = GetIpNetTable (PTMIBIPNetTable (pBuf), @TableSize, ложно);
  если ErrorCode = NO_ERROR после этого
  начните
    NumEntries: = PTMIBIPNetTable (pBuf) ^.dwNumEntries;
    если NumEntries > 0 после этого параной // поражая, но вы никогда не знаете…, то
    начните
      inc (pBuf, SizeOf (DWORD)); // получает прошлый размер таблицы
      для I: = 1 к NumEntries делает
      начните
        IPNetRow: = ^ PTMIBIPNetRow (PBuf);
        с IPNetRow сделайте
          List.Add (форма («%8x | %12s | %16s | %10s»,
                           [dwIndex, MacAddr2Str (bPhysAddr, dwPhysAddrLen),
                           IPAddr2Str (dwAddr), ARPEntryType [dwType]
                           ]));
        inc (pBuf, SizeOf (IPNetRow));
      конец;
    конец
    еще
      List.Add («ARP-тайник empty.");
  конец
  еще
    List.Add (SysErrorMessage (ErrorCode));

  // мы указатель восстановления _must_!
  окончательно
      декабрь (pBuf, SizeOf (DWORD) + NumEntries * SizeOf (IPNetRow));
      FreeMem (pBuf);
  конец;
конец;


//------------------------------------------------------------------------------
процедура Get_TCPTable (список: TStrings);
var
  TCPRow: TMIBTCPRow;
  iий,
    NumEntries: интежер;
  TableSize: DWORD;
  ErrorCode: DWORD;
  DestIP: шнур;
  pBuf: PChar;
начните
  если задано (список) после этого ВЫХОДИТЕ;
  List.Clear;
  RecentIPs.Clear;
  // звонок сперва: получите размер таблицы
  TableSize: = 0;
  NumEntries: = 0;
  ErrorCode: = GetTCPTable (ноли, @TableSize, ложно);  // Angus
  если <> ERROR_INSUFFICIENT_BUFFER Errorcode после этого
    ВЫХОД;

  // получает необходимый размер запоминающего устройства, звонок снова
  GetMem (pBuf, TableSize);
  // получает таблицу
  ErrorCode: = GetTCPTable (PTMIBTCPTable (pBuf), @TableSize, ложно);
  если ErrorCode = NO_ERROR после этого
  начните

    NumEntries: = PTMIBTCPTable (pBuf) ^.dwNumEntries;
    если NumEntries > 0 после этого
    начните
      inc (pBuf, SizeOf (DWORD)); // получает прошлый размер таблицы
      для I: = 1 к NumEntries делает
      начните
        TCPRow: = ^ PTMIBTCPRow (pBuf); // получает следующий показатель
        с TCPRow сделайте
        начните
          если dwRemoteAddr = 0 после этого
            dwRemotePort: = 0;
          DestIP: = IPAddr2Str (dwRemoteAddr);
          List.Add (
            Форма («%15s: %-7s | %15s: %-7s | %-16s»,
            [IpAddr2Str (dwLocalAddr),
            Port2Svc (Port2Wrd (dwLocalPort)),
              DestIP,
              Port2Svc (Port2Wrd (dwRemotePort)),
              TCPConnState [dwState]
              ]));
         //
            если (не, то (dwRemoteAddr = 0))
            и (RecentIps.IndexOf (DestIP) = -1) после этого
               RecentIPs.Add (DestIP);
        конец;
        inc (pBuf, SizeOf (TMIBTCPRow));
      конец;
    конец;
  конец
  еще
    List.Add (SyserrorMessage (ErrorCode));
  декабрь (pBuf, SizeOf (DWORD) + NumEntries * SizeOf (TMibTCPRow));
  FreeMem (pBuf);
конец;

//------------------------------------------------------------------------------
процедура Get_TCPStatistics (список: TStrings);
var
  TCPStats: TMibTCPStats;
  ErrorCode: DWORD;
начните
  если задано (список) после этого ВЫХОДИТЕ;
  List.Clear;
  если НЕ LoadIpHlp после этого выходит;
  ErrorCode: = GetTCPStatistics (@TCPStats);
  если ErrorCode = NO_ERROR после этого
    с TCPStats сделайте
    начните
      List.Add («алгоритм ретрансляции: » + TCPToAlgo [dwRTOAlgorithm]);
      List.Add («минимальный перерыв: » + IntToStr (dwRTOMin) + «госпожа ");
      List.Add («максимальный перерыв: » + IntToStr (dwRTOMax) + «госпожа ");
      List.Add («максимум Pend.Connections: » + IntToStr (dwRTOAlgorithm));
      List.Add («Active раскрывает: » + IntToStr (dwActiveOpens));
      List.Add («Passive раскрывает: » + IntToStr (dwPassiveOpens));
      List.Add («потерпел неудачу открытые попытки: » + IntToStr (dwAttemptFails));
      List.Add («установленный conn. Возврат: » + IntToStr (dwEstabResets));
      List.Add («в настоящее время установленный Conn.: » + IntToStr (dwCurrEstab));
      List.Add («этапы получили: » + IntToStr (dwInSegs));
      List.Add («этапы послали: » + IntToStr (dwOutSegs));
      List.Add («этапы ретранслировали: » + IntToStr (dwReTransSegs));
      List.Add («входящие ошибки: » + IntToStr (dwInErrs));
      List.Add («общительные возвраты: » + IntToStr (dwOutRsts));
      List.Add («кумулятивные соединения: » + IntToStr (dwNumConns));
    конец
  еще
    List.Add (SyserrorMessage (ErrorCode));
конец;

функция IpHlpTCPStatistics (var TCPStats: TMibTCPStats): интежер;
начните
    результат: = ERROR_NOT_SUPPORTED;
    если НЕ LoadIpHlp после этого выходит;
    результат: = GetTCPStatistics (@TCPStats);
конец;

//------------------------------------------------------------------------------
процедура Get_UDPTable (список: TStrings);
var
  UDPRow: TMIBUDPRow;
  iий,
    NumEntries: интежер;
  TableSize: DWORD;
  ErrorCode: DWORD;
  pBuf: PChar;
начните
  если задано (список) после этого ВЫХОДИТЕ;
  List.Clear;

  // звонок сперва: получите размер таблицы
  TableSize: = 0;
  NumEntries: = 0;
  ErrorCode: = GetUDPTable (ноли, @TableSize, ложно);
  если <> ERROR_INSUFFICIENT_BUFFER Errorcode после этого
    ВЫХОД;

  // получает необходимый размер памяти, звонока снова
  GetMem (pBuf, TableSize);

  // получает таблицу
  ErrorCode: = GetUDPTable (PTMIBUDPTable (pBuf), @TableSize, ложно);
  если ErrorCode = NO_ERROR после этого
  начните
    NumEntries: = PTMIBUDPTable (pBuf) ^.dwNumEntries;
    если NumEntries > 0 после этого
    начните
      inc (pBuf, SizeOf (DWORD)); // получает прошлый размер таблицы
      для I: = 1 к NumEntries делает
      начните
        UDPRow: = ^ PTMIBUDPRow (pBuf); // получает следующий показатель
        с UDPRow сделайте
          List.Add (форма («%15s: %-6s»,
            [IpAddr2Str (dwLocalAddr),
            Port2Svc (Port2Wrd (dwLocalPort))
              ]));
        inc (pBuf, SizeOf (TMIBUDPRow));
      конец;
    конец
    еще
      List.Add («нет entries.");
  конец
  еще
    List.Add (SyserrorMessage (ErrorCode));
  декабрь (pBuf, SizeOf (DWORD) + NumEntries * SizeOf (TMibUDPRow));
  FreeMem (pBuf);
конец;

//------------------------------------------------------------------------------
процедура Get_IPAddrTable (список: TStrings);
var
  IPAddrRow: TMibIPAddrRow;
  TableSize: DWORD;
  ErrorCode: DWORD;
  iий: интежер;
  pBuf: PChar;
  NumEntries: DWORD;
начните
  если задано (список) после этого ВЫХОДИТЕ;
  List.Clear;
  TableSize: = 0; ;
  NumEntries: = 0;
  // звонок сперва: получите длину таблицы
  ErrorCode: = GetIpAddrTable (ноли, @TableSize, поистине);  // Angus
  если <> ERROR_INSUFFICIENT_BUFFER Errorcode после этого
    ВЫХОД;

  GetMem (pBuf, TableSize);
  // получает таблицу
  ErrorCode: = GetIpAddrTable (PTMibIPAddrTable (pBuf), @TableSize, поистине);
  если ErrorCode = NO_ERROR после этого
  начните
    NumEntries: = PTMibIPAddrTable (pBuf) ^.dwNumEntries;
    если NumEntries > 0 после этого
    начните
      inc (pBuf, SizeOf (DWORD));
      для I: = 1 к NumEntries делает
      начните
        IPAddrRow: = ^ PTMIBIPAddrRow (pBuf);
        с IPAddrRow сделайте
          List.Add (форма («%8.8x | %15s | %15s | %15s | %8.8d»,
            [dwIndex,
            IPAddr2Str (dwAddr),
              IPAddr2Str (dwMask),
              IPAddr2Str (dwBCastAddr),
              dwReasmSize
              ]));
        inc (pBuf, SizeOf (TMIBIPAddrRow));
      конец;
    конец
    еще
      List.Add («нет entries.");
  конец
  еще
    List.Add (SysErrorMessage (ErrorCode));

  // мы должны восстановить указатель!
  декабрь (pBuf, SizeOf (DWORD) + NumEntries * SizeOf (IPAddrRow));
  FreeMem (pBuf);
конец;

//-----------------------------------------------------------------------------
{получает входы в таблицу маршрутизации; эквивалент к «печати трассы»}
процедура Get_IPForwardTable (список: TStrings);
var
  IPForwRow: TMibIPForwardRow;
  TableSize: DWORD;
  ErrorCode: DWORD;
  iий: интежер;
  pBuf: PChar;
  NumEntries: DWORD;
начните

  если задано (список) после этого ВЫХОДИТЕ;
  List.Clear;
  TableSize: = 0;

  // звонок сперва: получите длину таблицы
  NumEntries: = 0;
  ErrorCode: = GetIpForwardTable (ноли, @TableSize, поистине);
  если <> ERROR_INSUFFICIENT_BUFFER Errorcode после этого
    ВЫХОД;

  // получает таблицу
  GetMem (pBuf, TableSize);
  ErrorCode: = GetIpForwardTable (PTMibIPForwardTable (pBuf), @TableSize, поистине);
  если ErrorCode = NO_ERROR после этого
  начните
    NumEntries: = PTMibIPForwardTable (pBuf) ^.dwNumEntries;
    если NumEntries > 0 после этого
    начните
      inc (pBuf, SizeOf (DWORD));
      для I: = 1 к NumEntries делает
      начните
        IPForwRow: = ^ PTMibIPForwardRow (pBuf);
        с IPForwRow сделайте
        начните
          если (dwForwardType < 1)
          или (dwForwardType > 4) после этого
                   dwForwardType: = 1;   // Angus, прибавлять на плохое значение
          List.Add (форма (
            «%15s | %15s | %15s | %8.8x | %7s |   %5.5d |  %7s |   %2.2d»,
            [IPAddr2Str (dwForwardDest),
            IPAddr2Str (dwForwardMask),
              IPAddr2Str (dwForwardNextHop),
              dwForwardIFIndex,
              IPForwTypes [dwForwardType],
              dwForwardNextHopAS,
              IPForwProtos [dwForwardProto],
              dwForwardMetric1
              ]));
        конец;       
        inc (pBuf, SizeOf (TMibIPForwardRow));
      конец;
    конец
    еще
      List.Add («нет entries.");
  конец
  еще
    List.Add (SysErrorMessage (ErrorCode));
  декабрь (pBuf, SizeOf (DWORD) + NumEntries * SizeOf (TMibIPForwardRow));
  FreeMem (pBuf);
конец;

//------------------------------------------------------------------------------
процедура Get_IPStatistics (список: TStrings);
var
  IPStats: TMibIPStats;
  ErrorCode: интежер;
начните
  если задано (список) после этого ВЫХОДИТЕ;
  если НЕ LoadIpHlp после этого выходит;
  ErrorCode: = GetIPStatistics (@IPStats);
  если ErrorCode = NO_ERROR после этого
  начните
    List.Clear;
    с IPStats сделайте
    начните
      если dwForwarding = 1 после этого
        List.add («препровождение позволило: » + «да ")
      еще
        List.add («препровождение позволило: » + «никак ");
      List.add («невыполнение обязательства TTL: » + inttostr (dwDefaultTTL));
      List.add («датаграммы получили: » + inttostr (dwInReceives));
      List.add («ошибки коллектора (внутри): » + inttostr (dwInHdrErrors));
      List.add («ошибки адреса (внутри): » + inttostr (dwInAddrErrors));
      List.add («датаграммы препровождали: » + inttostr (dwForwDatagrams));   // Angus
      List.add («неизвестные протоколы (внутри): » + inttostr (dwInUnknownProtos));
      List.add («датаграммы сбросили: » + inttostr (dwInDiscards));
      List.add («датаграммы поставили: » + inttostr (dwInDelivers));
      List.add («запросы вне: » + inttostr (dwOutRequests));
      List.add («трассы сбросили: » + inttostr (dwRoutingDiscards));
      List.add («отсутствие трасс (вне): » + inttostr (dwOutNoRoutes));
      List.add («Reassemble перерывы: » + inttostr (dwReasmTimeOut));
      List.add («Reassemble запросы: » + inttostr (dwReasmReqds));
      List.add («разборки Succesfull: » + inttostr (dwReasmOKs));
      List.add («потерпел неудачу разборки: » + inttostr (dwReasmFails));
      List.add («успешно разртвы: » + inttostr (dwFragOKs));
      List.add («потерпел неудачу разртвы: » + inttostr (dwFragFails));
      List.add («датаграммы разделили: » + inttostr (dwFRagCreates));
      List.add («номер поверхностей стыка: » + inttostr (dwNumIf));
      List.add («номер IP-addresses: » + inttostr (dwNumAddr));
      List.add («трассы в RoutingTable: » + inttostr (dwNumRoutes));
    конец;
  конец
  еще
    List.Add (SysErrorMessage (ErrorCode));
конец;

функция IpHlpIPStatistics (var IPStats: TMibIPStats): интежер;      // Angus
начните
    результат: = ERROR_NOT_SUPPORTED;
    если НЕ LoadIpHlp после этого выходит;
    результат: = GetIPStatistics (@IPStats);
конец;

//------------------------------------------------------------------------------
процедура Get_UdpStatistics (список: TStrings);
var
  UdpStats: TMibUDPStats;
  ErrorCode: интежер;
начните
  если задано (список) после этого ВЫХОДИТЕ;
  ErrorCode: = GetUDPStatistics (@UdpStats);
  если ErrorCode = NO_ERROR после этого
  начните
    List.Clear;
    с UDPStats сделайте
    начните
      List.add («датаграммы (внутри): » + inttostr (dwInDatagrams));
      List.add («датаграммы (вне): » + inttostr (dwOutDatagrams));
      List.add («отсутствие портов: » + inttostr (dwNoPorts));
      List.add («ошибки (внутри): » + inttostr (dwInErrors));
      List.add («UDP слушает порты: » + inttostr (dwNumAddrs));
    конец;
  конец
  еще
    List.Add (SysErrorMessage (ErrorCode));
конец;

// ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **
функция IpHlpUdpStatistics (UdpStats: TMibUDPStats): интежер;     // Angus
начните
    результат: = ERROR_NOT_SUPPORTED;
    если НЕ LoadIpHlp после этого выходит;
    результат: = GetUDPStatistics (@UdpStats);
конец;

//------------------------------------------------------------------------------
процедура Get_ICMPStats (ICMPIn, ICMPOut: TStrings);
var
  ErrorCode: DWORD;
  ICMPStats: PTMibICMPInfo;
начните
  если (ICMPIn = ноли) или (ICMPOut = ноли) после этого ВЫХОДИТЕ;
  ICMPIn.Clear;
  ICMPOut.Clear;
  Ново (ICMPStats);
  ErrorCode: = GetICMPStatistics (ICMPStats);
  если ErrorCode = NO_ERROR после этого
  начните
    с ICMPStats.InStats сделайте
    начните
      ICMPIn.Add («сообщения получили: » + IntToStr (dwMsgs));
      ICMPIn.Add («ошибки: » + IntToStr (dwErrors));
      ICMPIn.Add («Dest. Unreachable: » + IntToStr (dwDestUnreachs));
      ICMPIn.Add («время превысило: » + IntToStr (dwTimeEcxcds));
      ICMPIn.Add («Param. Проблемы: » + IntToStr (dwParmProbs));
      ICMPIn.Add («источник гасит: » + IntToStr (dwSrcQuenchs));
      ICMPIn.Add («перенаправляет: » + IntToStr (dwRedirects));
      ICMPIn.Add («запросы отголоска: » + IntToStr (dwEchos));
      ICMPIn.Add («ответы отголоска: » + IntToStr (dwEchoReps));
      ICMPIn.Add («запросы фиксации времени: » + IntToStr (dwTimeStamps));
      ICMPIn.Add («ответы фиксации времени: » + IntToStr (dwTimeStampReps));
      ICMPIn.Add («Addr. Запросы маск: » + IntToStr (dwAddrMasks));
      ICMPIn.Add («Addr. Ответы маски: » + IntToStr (dwAddrReps));
    конец;
     //
    с ICMPStats.OutStats сделайте
    начните
      ICMPOut.Add («сообщения послали: » + IntToStr (dwMsgs));
      ICMPOut.Add («ошибки: » + IntToStr (dwErrors));
      ICMPOut.Add («Dest. Unreachable: » + IntToStr (dwDestUnreachs));
      ICMPOut.Add («время превысило: » + IntToStr (dwTimeEcxcds));
      ICMPOut.Add («Param. Проблемы: » + IntToStr (dwParmProbs));
      ICMPOut.Add («источник гасит: » + IntToStr (dwSrcQuenchs));
      ICMPOut.Add («перенаправляет: » + IntToStr (dwRedirects));
      ICMPOut.Add («запросы отголоска: » + IntToStr (dwEchos));
      ICMPOut.Add («ответы отголоска: » + IntToStr (dwEchoReps));
      ICMPOut.Add («запросы фиксации времени: » + IntToStr (dwTimeStamps));
      ICMPOut.Add («ответы фиксации времени: » + IntToStr (dwTimeStampReps));
      ICMPOut.Add («Addr. Запросы маск: » + IntToStr (dwAddrMasks));
      ICMPOut.Add («Addr. Ответы маски: » + IntToStr (dwAddrReps));
    конец;
  конец
  еще
    IcmpIn.Add (SysErrorMessage (ErrorCode));
  Размещайте (ICMPStats);
конец;

//------------------------------------------------------------------------------
процедура Get_RecentDestIPs (список: TStrings);
начните
  если задано (список) после этого
    List.Assign (RecentIPs)
конец;

начинание

  RecentIPs: = TStringList.Create;

окочание

  RecentIPs.Free;

end.
class=

Ответ : Как использовать блок

Не как легко по мере того как вы думаете. Фактическ, вы не можете перехватить пакет icmp на уровне применения. Вероятно вам будет нужно написать водителю сети (их нельзя сделать в Делфи, вам будет нужен C/C++ и набор развития водителя).

Или вы можете использовать третья сторона водителя, как ищейка SDK пакета:
http://www.microolap.com/products/network/pssdk/

Также вы можете использовать свободно общее назначение, как перехватчик ICMP:
http://www.sabronet.com/icmpinterceptor/icmpinterceptor.html
Другие решения  
  •  Как я добавляю кнопки на форме PDF для того чтобы добавить/извлекаю рядки данных?
  •  Шнур ошибки в блоке задвижки?
  •  сколько вариант сервера SQL на одной машине
  •  Внешний вид 2007 не может архивный файл открытой сети сохраненный
  •  Активно директория DNS записывает вопрос
  •  Отчет о доступа 2010 экспорта к CSV с коллекторами?
  •  Прокладчик OCE 9400 не начинает
  •  как добавить десятичное место в формуле в отчете о кристалла seagate
  •  Windows XP и Мичрософт Оутлоок и проблемы установителя Windows
  •  VB6 к VS2010 - консультации тренировки?
  •  
    programming4us programming4us