Cuestión : Cómo utilizar una unidad

Cómo utilizar la necesidad de la unidad IPHelper.
I de saber si hay alguien que silba como una bala mi computer.

I han escrito un pequeño código, PERO no estoy seguro si es el usage.
Can alguien agrego mi código para formarlo un poco. el

type
TIcmpMessage = el
private
icmpstate de la clase (TObject): TMibICMPInfo; getMessage del
function: TMibICMPInfo; el
public
constructor crea (icmpMessage: TMibICMPInfo); virtual; el
destructor destruye; invalidación; icmpMessage del
property: TMibICMPInfo leyó getMessage;
protected
end;


constructor TIcmpMessage.Create (icmpMessage: TMibICMPInfo);
end del
begin
…;
destructor TIcmpMessage.Destroy; el
begin
heredó;
end;

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

procedure TForm1.Timer1Timer (remitente: TObject);
showmessage del
begin
… (el “some_one pingponging en su computadora ");
end del
…;
class= > " claro " del
> del " codeSnippet " del class= del
class= " lineNumbers " del
class= del
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 notpretty IPHelper " del class= " del id= " codeSnippet821926 del
 128
Agregar:  ICMP - estadísticas
Agregar:  Números de acceso bien conocidos
Agregar:  Lista de RecentIP
Agregar:  Actualización del contador de tiempo

dirkcl v1.2
----
Arreglo:  Actualización correcta del IP reciente
AGREGAR:  los códigos del ICMP-error tradujeron

v1.3 - 18 de septiembre de 2001
----
  Angus Robertson, Magenta Systems Ltd, Inglaterra
     [email protected], http://www.magsys.co.uk/delphi/
  Lentamente convirtiendo procs en las funciones que se pueden utilizar por otros programas,
     el IE Get_ se convierte en IpHlp
  Las mejoras primarias son que el servidor de DNS actual ahora está demostrado, también
     octetos de in/out para cada interfaz (adaptador del aka)
  Todas las funciones se cargan dinámicamente así que el programa se puede utilizar en W95/NT4
  Probado con Delphi 6 en el Windows 2000 y XP

v1.4 - 28 de febrero de 2002 - Angus
----
  Escape de memoria importante fijo en IpHlpIfTable (excepto en vez de finalmente)
  Escape de memoria importante fijo en Get_AdaptersInfo (indicador incrementado del almacenador intermediario)
  IpHlpAdaptersInfo creado que vuelve TAdaptorRows


  Nota: La dirección dinámica del DNS de las vueltas de IpHlpNetworkParams (y la otra materia)
  Nota: IpHlpIfEntry vuelve los octetos in/out para un adaptador de red

v1.5 - 5 de octubre de 2003
----
  Juan Pedro Turchi “del sur de Francia” 
  Cosmético (más legible) y de diapositivo suplementario de iana.org en “WellKnownPorts”

}
*)

interfaz

aplicaciones
  Windows, mensajes, SysUtils, clases, diálogos, IpHlpApi;

const
  NULL_IP = “0. 0. 0. 0”;

//------conversion de los números de acceso bien conocidos para mantener nombres----------------

tipo
  TWellKnownPort = expediente
    Prt: DWORD;
    Srv: secuencia [20];
  extremo;


const
    // solamente la mayoría de los servicios “populares”…
  WellKnownPorts: arsenal [1..32] de TWellKnownPort
  = (
// (Prt: 0; Srv:   “RESRVED "), {reservado}
    (Prt: 7; Srv:   “ECO "), {silbido de bala}
    (Prt: 9; Srv:   “DESCARTE "),
    (Prt: 13; Srv:  “D3IA "),
    (Prt: 17; Srv:  “QOTD "), {cotización del día}
    (Prt: 19; Srv:  “CHARGEN "), {generador de carácter}
    (Prt: 20; Srv:  “FTPDATA "), {File Transfer Protocol - datas}
    (Prt: 21; Srv:  “FTPCTRL "), {File Transfer Protocol - control}
    (Prt: 22; Srv:  “SSH "),
    (Prt: 23; Srv:  “Telnet "),
    (Prt: 25; Srv:  “Smtp "), {Simple Mail Transfer Protocol}
    (Prt: 37; Srv:  “TIEMPO "), {protocolo del tiempo}
    (Prt: 43; Srv:  “WHOIS "), {el WHO ES servicio}
    (Prt: 53; Srv:  “DNS "), {servicio del Domain Name}
    (Prt: 67; Srv:  “BOOTPS "), {servidor del BOOTP}
    (Prt: 68; Srv:  “BOOTPC "), {cliente del BOOTP}
    (Prt: 69; Srv:  “TFTP "), {ftp trivial}
    (Prt: 70; Srv:  “GOPHER "), {Gopher}
    (Prt: 79; Srv:  “DEDO "), {dedo}
    (Prt: 80; Srv:  “HTTP "), {HTTP}
    (Prt: 88; Srv:  “KERBROS "), {Kerberos}
    (Prt: 109; Srv: “POP2 "), {versión 2 del Post Office Protocol}
    (Prt: 110; Srv: “POP3 "), {versión 3 del Post Office Protocol}
    (Prt: 111; Srv: “SUN_RPC "), {Remote Procedure Call del SOL}
    (Prt: 119; Srv: “NNTP "), {Network News Transfer Protocol}
    (Prt: 123; Srv: “NTP "), {Network Time Protocol}
    (Prt: 135; Srv: “DCOMRPC "), {servicio de localización}
    (Prt: 137; Srv: “NBNAME "), {servicio conocido de NETBIOS}
    (Prt: 138; Srv: “NBDGRAM "), {servicio de datagrama de NETBIOS}
    (Prt: 139; Srv: “NBSESS "), {servicio de sesión de NETBIOS}
    (Prt: 143; Srv: “IMAP "), {protocolo de acceso del mensaje de Internet}
    (Prt: 161; Srv: “SNMP "), {Netw simple. Protocolo de la gerencia}
    (Prt: 169; Srv: “ENVIAR ")
    );


//-----------conversion de los códigos de error del ICMP a las secuencias--------------------------
             {tomado de www.sockets.com/ms_icmp.c}

const
  ICMP_ERROR_BASE = 11000;
  IcmpErr: arsenal [1..22] de secuencia =
  (
   “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 de valores enumerados diversos a las secuencias------------------

  ARPEntryType: arsenal [1..4] de secuencia = (“otro”, “inválido”,
    “Dinámico”, “parásitos atmosféricos”
    );
  TCPConnState:
    arsenal [1..12] de secuencia =
    (“se cerró”, “escuchando”, “syn_sent”,
    el “syn_rcvd”, “estableció”, “fin_wait1”,
    “fin_wait2”, “close_wait”, “cerrándose”,
    “last_ack”, “time_wait”, “delete_tcb”
    );

  TCPToAlgo: arsenal [1..4] de secuencia =
    (“Const.Timeout”, “MIL-STD-1778”,
    “Van Jacobson”, “otro ");

  IPForwTypes: arsenal [1..4] de secuencia =
    (“otro”, “inválido”, “local”, “telecontrol ");

  IPForwProtos: arsenal [1..18] de secuencia =
    (“OTRO”, “LOCAL”, “NETMGMT”, “ICMP”, “EGP”,
    “GGP”, “HELICÓPTERO”, “RASGÓN”, “IS_IS”, “ES_IS”,
    “CISCO”, “BBN”, “OSPF”, “BGP”, “BOOTP”,
    “AUTO_STAT”, “PARÁSITOS ATMOSFÉRICOS”, “NOT_DOD ");

tipo

// para IpHlpNetworkParams
  TNetworkParams = expediente
    Hostname: secuencia;
    Domain Name: secuencia;
    CurrentDnsServer: secuencia;
    DnsServerTot: número entero;
    DnsServerNames: arsenal [0..9] de secuencia;
    NodeType: UINT;
    ScopeID: secuencia;
    EnableRouting: UINT;
    EnableProxy: UINT;
    EnableDNS: UINT;
  extremo;

  TIfRows = arsenal de TMibIfRow; arsenal dinámico de // de filas

// para IpHlpAdaptersInfo
  TAdaptorInfo = expediente
    AdapterName: secuencia;
    Descripción: secuencia;
    MacAddress: secuencia;
    Índice: DWORD;
    aType: UINT;
    DHCPEnabled: UINT;
    CurrIPAddress: secuencia;
    CurrIPMask: secuencia;
    IPAddressTot: número entero;
    IPAddressList: arsenal de secuencia;
    IPMaskList: arsenal de secuencia;
    GatewayTot: número entero;
    GatewayList: arsenal de secuencia;
    DHCPTot: número entero;
    DHCPServer: arsenal de secuencia;
    HaveWINS: BOOL;
    PrimWINSTot: número entero;
    PrimWINSServer: arsenal de secuencia;
    SecWINSTot: número entero;
    SecWINSServer: arsenal de secuencia;
    LeaseObtained: LongInt; // UNIX mide el tiempo, los segundos desde 1970
    LeaseExpires: LongInt;   // UNIX mide el tiempo, los segundos desde 1970
  extremo;

  TAdaptorRows = arsenal de TAdaptorInfo;


materia de //---------------exported-----------------------------------------------

función IpHlpAdaptersInfo (var AdpTot: número entero; var AdpRows: TAdaptorRows): número entero;
procedimiento Get_AdaptersInfo (lista: TStrings);
función IpHlpNetworkParams (var NetworkParams: TNetworkParams): número entero;
procedimiento Get_NetworkParams (lista: TStrings);
procedimiento Get_ARPTable (lista: TStrings);
procedimiento Get_TCPTable (lista: TStrings);
procedimiento Get_TCPStatistics (lista: TStrings);
función IpHlpTCPStatistics (var TCPStats: TMibTCPStats): número entero;
procedimiento Get_UDPTable (lista: TStrings);
procedimiento Get_UDPStatistics (lista: TStrings);
función IpHlpUdpStatistics (UdpStats: TMibUDPStats): número entero;
procedimiento Get_IPAddrTable (lista: TStrings);
procedimiento Get_IPForwardTable (lista: TStrings);
procedimiento Get_IPStatistics (lista: TStrings);
función IpHlpIPStatistics (var IPStats: TMibIPStats): número entero;
función Get_RTTAndHopCount (IPAddr: DWORD; MaxHops: Longint;
  RTT del var: longint; var HopCount: longint): número entero;
procedimiento Get_ICMPStats (ICMPIn, ICMPOut: TStrings);
función IpHlpIfTable (var IfTot: número entero; var IfRows: TIfRows): número entero;
procedimiento Get_IfTable (lista: TStrings);
función IpHlpIfEntry (índice: número entero; var IfRow: TMibIfRow): número entero;
procedimiento Get_RecentDestIPs (lista: TStrings);

utils de la conversión de //
función MacAddr2Str (MacAddr: TMacAddress; tamaño: número entero): secuencia;
función IpAddr2Str (IPAddr: DWORD): secuencia;
función Str2IpAddr (IPStr: secuencia): DWORD;
función Port2Str (nwoPort: DWORD): secuencia;
función Port2Wrd (nwoPort: DWORD): DWORD;
función Port2Svc (puerto: DWORD): secuencia;
función ICMPErr2Str (ICMPErrCode: DWORD): secuencia;

puesta en práctica

var
  RecentIPs: TStringList;

utilidades de //--------------General-----------------------------------------------

{los extractos después “símbolo” de la secuencia, entonces comen la secuencia}
función NextToken (var s: secuencia; Separador: carbón de leña): secuencia;
var
  Sep_Pos: octeto;
comenzar
  Resultado: = '';
  si las longitudes > 0 entonces comienzan
    Sep_Pos: = posición (separador, s);
    si Sep_Pos > 0 entonces comienza
      Resultado: = copia (s, 1, Pred (Sep_Pos));
      Cancelación (s, _Pos de los 1, y de septiembre);
    extremo
    comenzar
      Resultado: = s;
      s: = '';
    extremo;
  extremo;
extremo;

//------------------------------------------------------------------------------
{MAC-address numérico de los conciertos a la secuencia ww-xx-yy-zz}
función MacAddr2Str (MacAddr: TMacAddress; tamaño: número entero): secuencia;
var
  i: número entero;
comenzar
  si tamaño = 0 entonces
  comenzar
    Resultado: = “00-00-00-00-00-00”;
    SALIDA;
  extremo
  resultado otro: = '';
  //
  para i: = 1 al tamaño hace
    Resultado: = resultado + IntToHex (MacAddr [i], 2) + “-”;
  Cancelación (resultado, longitud (resultado), 1);
extremo;

//------------------------------------------------------------------------------
{IP address de los convertidos en la orden DWORD del octeto de la red a punteado - secuencia decimal}
función IpAddr2Str (IPAddr: DWORD): secuencia;
var
  i: número entero;
comenzar
  Resultado: = '';
  para i: = 1 a 4 hace
  comenzar
    Resultado: = resultado + formato (“%3d. ”, [IPAddr y $FF]);
    IPAddr: = shr 8 de IPAddr;
  extremo;
  Cancelación (resultado, longitud (resultado), 1);
extremo;

//------------------------------------------------------------------------------
{convertidos punteados - IP address decimal a la orden DWORD del octeto de la red}
función Str2IpAddr (IPStr: secuencia): DWORD;
var
  i: número entero;
  Numérico: DWORD;
comenzar
  Resultado: = 0;
  para i: = 1 a 4 hace
  intento
    Numérico: = (StrToInt (NextToken (IPStr, “."))) shl 24;
    Resultado: = (shr del resultado 8) o numérico;
  excepto
    Resultado: = 0;
  extremo;

extremo;

//------------------------------------------------------------------------------
{número de acceso de los convertidos en orden del octeto de la red a DWORD}
función Port2Wrd (nwoPort: DWORD): DWORD;
comenzar
  Resultado: = intercambio (PALABRA (nwoPort));
extremo;

//------------------------------------------------------------------------------
{número de acceso de los convertidos en orden del octeto de la red a la secuencia}
función Port2Str (nwoPort: DWORD): secuencia;
comenzar
  Resultado: = IntToStr (Port2Wrd (nwoPort));
extremo;

//------------------------------------------------------------------------------
{números de acceso bien conocidos de los convertidos a la identificación de servicio}
función Port2Svc (puerto: DWORD): secuencia;
var
  i: número entero;
comenzar
  Resultado: = formato (“%4d”, [puerto]); // en caso de que puerto no encontrado
  para i: = bajo (WellKnownPorts) al colmo (WellKnownPorts) hacer
    si puerto = WellKnownPorts [i]. Prt entonces
    comenzar
      Resultado: = WellKnownPorts [i]. Srv;
      ROTURA;
    extremo;
extremo;

//-----------------------------------------------------------------------------
{parámetros de red generales, fijos}

procedimiento Get_NetworkParams (lista: TStrings);
var
    NetworkParams: TNetworkParams;
    I, ErrorCode: número entero;
comenzar
    si no asignado (lista) entonces SALIR;
    List.Clear;
    ErrorCode: = IpHlpNetworkParams (NetworkParams);
    si <> 0 de ErrorCode entonces
    comenzar
        List.Add (SysErrorMessage (ErrorCode));
        salida;
    extremo;
    con NetworkParams hacer
    comenzar
        List.Add (“HOSTNAME: ” + hostname);
        List.Add (“DOMINIO: ” + Domain Name);
        List.Add (“TIPO de NODO de NETBIOS: ” + NETBIOSTypes [NodeType]);
        List.Add (“ALCANCE del DHCP: ” + ScopeID);
        List.Add (la “ENCAMINAMIENTO PERMITIÓ: ” + IntToStr (EnableRouting));
        List.Add (el “PODER PERMITIÓ: ” + IntToStr (EnableProxy));
        List.Add (el “DNS PERMITIÓ: ” + IntToStr (EnableDNS));
        si <> 0 de DnsServerTot entonces
        comenzar
            para I: = 0 a Pred (DnsServerTot) hace
                List.Add (“ADDR del SERVIDOR de DNS: ” + DnsServerNames [I]);
        extremo;
    extremo;
extremo;

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
función IpHlpNetworkParams (var NetworkParams: TNetworkParams): número entero;
var
  FixedInfo: PTFixedInfo;         // Angus
  InfoSize: Longint;
  PDnsServer: PTIP_ADDR_STRING;   // Angus
comenzar
    InfoSize: = 0;   // Angus
    resultado: = ERROR_NOT_SUPPORTED;
    si no LoadIpHlp entonces sale;
    resultado: = GetNetworkParams (la nada, @InfoSize);  // Angus
    si el <> ERROR_BUFFER_OVERFLOW del resultado entonces sale; // Angus
    GetMem (FixedInfo, InfoSize);                    // Angus
    intento
    resultado: = GetNetworkParams (FixedInfo, @InfoSize);   // Angus
    si el <> ERROR_SUCCESS del resultado entonces sale;
    NetworkParams.DnsServerTot: = 0;
    con FixedInfo^ hacer
    comenzar
        NetworkParams.HostName: = ajuste (hostname);
        NetworkParams.DomainName: = ajuste (Domain Name);
        NetworkParams.ScopeId: = ajuste (ScopeID);
        NetworkParams.NodeType: = NodeType;
        NetworkParams.EnableRouting: = EnableRouting;
        NetworkParams.EnableProxy: = EnableProxy;
        NetworkParams.EnableDNS: = EnableDNS;
        NetworkParams.DnsServerNames [0]: = DNSServerList.IPAddress;  // Angus
        si 0] <> de NetworkParams.DnsServerNames ['' entonces
                                        NetworkParams.DnsServerTot: = 1;
        PDnsServer: = DnsServerList.Next;
        mientras que hace la nada del <> de PDnsServer
        comenzar
            NetworkParams.DnsServerNames [NetworkParams.DnsServerTot]: =
                                        PDnsServer^.IPAddress;  // Angus
            inc. (NetworkParams.DnsServerTot);
            si >= de NetworkParams.DnsServerTot
                            La longitud (NetworkParams.DnsServerNames) entonces sale;
            PDnsServer: = PDnsServer.Next;
        extremo;
    extremo;
    finalmente
       FreeMem (FixedInfo);                     // Angus
    extremo;
extremo;

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

función ICMPErr2Str (ICMPErrCode: DWORD): secuencia;
comenzar
   Resultado: = “UnknownError: ” + IntToStr (ICMPErrCode);
   diciembre (ICMPErrCode, ICMP_ERROR_BASE);
   si ICMPErrCode adentro [punto bajo (ICMpErr). Alto (ICMPErr)] entonces
     Resultado: = ICMPErr [ICMPErrCode];
extremo;


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

// incluye los octetos in/out para cada adaptador

función IpHlpIfTable (var IfTot: número entero; var IfRows: TIfRows): número entero;
var
  I,
  TableSize: número entero;
  pBuf, pNext: PChar;
comenzar
  resultado: = ERROR_NOT_SUPPORTED;
  si no LoadIpHlp entonces sale;
  SetLength (IfRows, 0);
  IfTot: = 0; // Angus
  TableSize: = 0;
   de // llamada primero: conseguir memsize necesario
  resultado: = GetIfTable (la nada, @TableSize, falso);  // Angus
  si el <> ERROR_INSUFFICIENT_BUFFER del resultado entonces sale;
  GetMem (pBuf, TableSize);
  intento
      FillChar (pBuf^, TableSize, #0);  almacenador intermediario claro de //, puesto que no lo hace W98

   // consigue el indicador de la tabla
      resultado: = GetIfTable (PTMibIfTable (pBuf), @TableSize, falso);
      si el <> NO_ERROR del resultado entonces sale;
      IfTot: = PTMibIfTable (pBuf) ^.dwNumEntries;
      si IfTot = 0 entonces sale;
      SetLength (IfRows, IfTot);
      pNext: = pBuf + SizeOf (IfTot);
      para i: = 0 a Pred (IfTot) hace
      comenzar
         IfRows [i]: = ^ de PTMibIfRow (pNext);
         inc. (pNext, SizeOf (TMibIfRow)) ;
      extremo;
  finalmente
      FreeMem (pBuf);
  extremo;
extremo;

procedimiento Get_IfTable (lista: TStrings);
var
  IfRows: TIfRows;
  Error, I: número entero;
  NumEntries: número entero;
  sDescr, sIfName: secuencia;
comenzar
  si no asignado (lista) entonces SALIR;
  List.Clear;
  SetLength (IfRows, 0);
  Error: = IpHlpIfTable (NumEntries, IfRows);
  si (<> 0 del error) entonces
      List.Add (SysErrorMessage (GetLastError))
  si NumEntries = 0 entonces
      List.Add (“no entries.")
  
  comenzar
      para I: = 0 a Pred (NumEntries) hace
      comenzar
          con IfRows [I] hacer
          comenzar
             si wszName [1] = #0 entonces
                 sIfName: = ''
             
                 sIfName: = WideCharToString (@wszName);  convertido Unicode de // a la secuencia
             sIfName: = ajuste (sIfName);
             sDescr: = bDescr;
             sDescr: = ajuste (sDescr);
             List.Add (formato (
               “%0.8x |%3d | %16s |%8d |%12d |%2d |%2d |%10d |%10d | %-s| %-s”,
               [dwIndex, dwType, MacAddr2Str (TMacAddress (bPhysAddr),
               dwPhysAddrLen), dwMTU, dwSpeed, dwAdminStatus,
               el dwOPerStatus, Int64 (dwInOctets), Int64 (dwOutOctets), contadores de // es de 32 bits
               el sIfName, el sDescr]) // Angus, agregaron in/out
               );
          extremo;
      extremo;
  extremo;
  SetLength (IfRows, 0);  // libera memoria
extremo;

función IpHlpIfEntry (índice: número entero; var IfRow: TMibIfRow): número entero;
comenzar
  resultado: = ERROR_NOT_SUPPORTED;
  si no LoadIpHlp entonces sale;
  FillChar (IfRow, SizeOf (TMibIfRow), #0);  almacenador intermediario claro de //, puesto que no lo hace W98
  IfRow.dwIndex: = índice;
  resultado: = GetIfEntry (@IfRow);
extremo;

//-----------------------------------------------------------------------------
{Info en los adaptadores instalados}

función IpHlpAdaptersInfo (var AdpTot: número entero; var AdpRows: TAdaptorRows): número entero;
var
  BufLen: DWORD;
  AdapterInfo: PTIP_ADAPTER_INFO;
  PIpAddr: PTIP_ADDR_STRING;
  PBuf: PCHAR;
  I: número entero;
comenzar
  SetLength (AdpRows, 4);
  AdpTot: = 0;
  BufLen: = 0;
  resultado: = GetAdaptersInfo (la nada, @BufLen);
  si (<> ERROR_INSUFFICIENT_BUFFER del resultado) y (resultado = NO_ERROR) entonces salir;
  GetMem (pBuf, BufLen);
  intento
      FillChar (pBuf^, BufLen, #0);  almacenador intermediario claro de //
      resultado: = GetAdaptersInfo (PTIP_ADAPTER_INFO (PBuf), @BufLen);
      si resultado = NO_ERROR entonces
      comenzar
         AdapterInfo: = PTIP_ADAPTER_INFO (PBuf);
         mientras que (nada del <> de AdapterInfo) hacer
         comenzar
            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: = ajuste (secuencia (AdapterInfo^.AdapterName));
            AdpRows [AdpTot]. Descripción: = ajuste (secuencia (AdapterInfo^.Description));
            AdpRows [AdpTot] .MacAddress: = MacAddr2Str (TMacAddress (
                                 AdapterInfo^.Address), AdapterInfo^.AddressLength);
            AdpRows [AdpTot]. Índice: = AdapterInfo^.Index;
            AdpRows [AdpTot] .aType: = AdapterInfo^.aType;
            AdpRows [AdpTot] .DHCPEnabled: = AdapterInfo^.DHCPEnabled;
            si nada del <> de AdapterInfo^.CurrentIPAddress entonces
            comenzar
                AdpRows [AdpTot] .CurrIPAddress: = AdapterInfo^.CurrentIPAddress.IpAddress;
                AdpRows [AdpTot] .CurrIPMask: = AdapterInfo^.CurrentIPAddress.IpMask;
            extremo;

        // consigue la lista de IP address y de máscaras para IPAddressList
            I: = 0;
            PIpAddr: = @AdapterInfo^.IPAddressList;
            mientras que (nada del <> de PIpAddr) hacer
            comenzar
                AdpRows [AdpTot] .IPAddressList [I]: = PIpAddr.IpAddress;
                AdpRows [AdpTot] .IPMaskList [I]: = PIpAddr.IpMask;
                PIpAddr: = PIpAddr.Next;
                inc. (i);
                si <= I de la longitud (AdpRows [AdpTot] .IPAddressList) entonces
                comenzar
                     SetLength (AdpRows [AdpTot] .IPAddressList, I * 2);
                     SetLength (AdpRows [AdpTot] .IPMaskList, I * 2);
                extremo;
            extremo;
            AdpRows [AdpTot] .IPAddressTot: = I;

        // consigue la lista de IP address para GatewayList
            I: = 0;
            PIpAddr: = @AdapterInfo^.GatewayList;
            mientras que (nada del <> de PIpAddr) hacer
            comenzar
                AdpRows [AdpTot] .GatewayList [I]: = PIpAddr.IpAddress;
                PIpAddr: = PIpAddr.Next;
                inc. (i);
                si <= I de la longitud (AdpRows [AdpTot] .GatewayList) entonces
                             SetLength (AdpRows [AdpTot] .GatewayList, I * 2);
            extremo;
            AdpRows [AdpTot] .GatewayTot: = I;

        // consigue la lista de IP address para GatewayList
            I: = 0;
            PIpAddr: = @AdapterInfo^.DHCPServer;
            mientras que (nada del <> de PIpAddr) hacer
            comenzar
                AdpRows [AdpTot] .DHCPServer [I]: = PIpAddr.IpAddress;
                PIpAddr: = PIpAddr.Next;
                inc. (i);
                si <= I de la longitud (AdpRows [AdpTot] .DHCPServer) entonces
                             SetLength (AdpRows [AdpTot] .DHCPServer, I * 2);
            extremo;
            AdpRows [AdpTot] .DHCPTot: = I;

        // consigue la lista de IP address para PrimaryWINSServer
            I: = 0;
            PIpAddr: = @AdapterInfo^.PrimaryWINSServer;
            mientras que (nada del <> de PIpAddr) hacer
            comenzar
                AdpRows [AdpTot] .PrimWINSServer [I]: = PIpAddr.IpAddress;
                PIpAddr: = PIpAddr.Next;
                inc. (i);
                si <= I de la longitud (AdpRows [AdpTot] .PrimWINSServer) entonces
                             SetLength (AdpRows [AdpTot] .PrimWINSServer, I * 2);
            extremo;
            AdpRows [AdpTot] .PrimWINSTot: = I;

       // consigue la lista de IP address para SecondaryWINSServer
            I: = 0;
            PIpAddr: = @AdapterInfo^.SecondaryWINSServer;
            mientras que (nada del <> de PIpAddr) hacer
            comenzar
                AdpRows [AdpTot] .SecWINSServer [I]: = PIpAddr.IpAddress;
                PIpAddr: = PIpAddr.Next;
                inc. (i);
                si <= I de la longitud (AdpRows [AdpTot] .SecWINSServer) entonces
                             SetLength (AdpRows [AdpTot] .SecWINSServer, I * 2);
            extremo;
            AdpRows [AdpTot] .SecWINSTot: = I;

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

            inc. (AdpTot);
            si <= AdpTot de la longitud (AdpRows) entonces
                            SetLength (AdpRows, AdpTot * 2);  // más memoria
            AdapterInfo: = AdapterInfo^.Next;
         extremo;
         SetLength (AdpRows, AdpTot);
      extremo;
  finalmente
      FreeMem (pBuf);
  extremo;
extremo;

procedimiento Get_AdaptersInfo (lista: TStrings);
var
  AdpTot: número entero;
  AdpRows: TAdaptorRows;
  Error: DWORD;
  I: número entero;
  //J: número entero;  jpt - ver abajo
  //S: secuencia;        identificación
comenzar
  si no asignado (lista) entonces SALIR;
  List.Clear;
  SetLength (AdpRows, 0);
  AdpTot: = 0;
  Error: = IpHlpAdaptersInfo (AdpTot, AdpRows);
  si (<> 0 del error) entonces
      List.Add (SysErrorMessage (GetLastError))
  si AdpTot = 0 entonces
      List.Add (“no entries.")
  
  comenzar
      para I: = 0 a Pred (AdpTot) hace
      comenzar
        con AdpRows [I] hacer
        comenzar
            //List.Add (AdapterName + “|” + descripción); jpt de //: no útil
            List.Add (formato (“%8.8x | %6s | %16s | %2d | %16s | %16s | %16s”,
                [Índice, AdaptTypes [aType], MacAddress, DHCPEnabled,
                GatewayList [0], DHCPServer [0], PrimWINSServer [0]]));
            {si jpt de // del <> 0 de IPAddressTot entonces: no útil
            comenzar
                S: = '';
                para J: = 0 a Pred (IPAddressTot) hace
                        S: = S + IPAddressList [J] + “/” + IPMaskList [J] + “ | ”;
                List.Add (IntToStr (IPAddressTot) + “IP Addresse: ” + S);
            extremo;
            List.Add (''); }
        extremo;
      extremo;
  extremo;
  SetLength (AdpRows, 0);
extremo;

//-----------------------------------------------------------------------------
{conseguir el IP indicado del tiempo y del hopcount del viaje de ida y vuelta}
función Get_RTTAndHopCount (IPAddr: DWORD; MaxHops: Longint; RTT del var: Longint;
  var HopCount: Longint): número entero;
comenzar
  si no GetRTTAndHopCount (IPAddr, @HopCount, MaxHops, @RTT) entonces
  comenzar
    Resultado: = GetLastError;
    RTT: = -1; Destinación de // inalcanzable, BAD_HOST_NAME, etc….
    HopCount: = -1;
  extremo
  
    Resultado: = NO_ERROR;
extremo;

//-----------------------------------------------------------------------------
{la ARP-tabla enumera relaciones entre el IP alejado y el MAC-address alejado.
 NOTA: éstas son entradas depositadas; cuando no hay tráfico de red a a
 el nodo, entrada se suprime después de algunos minutos.
}
procedimiento Get_ARPTable (lista: TStrings);
var
  IPNetRow: TMibIPNetRow;
  TableSize: DWORD;
  NumEntries: DWORD;
  ErrorCode: DWORD;
  i: número entero;
  pBuf: PChar;
comenzar
  si no asignado (lista) entonces SALIR;
  List.Clear;
  de // llamada primero: conseguir la longitud de la tabla
  TableSize: = 0;
  ErrorCode: = GetIPNetTable (la nada, @TableSize, falso);   // Angus
  //
  si ErrorCode = ERROR_NO_DATA después
  comenzar
    List.Add (“ARP-escondrijo empty.");
    SALIDA;
  extremo;
  // consigue la tabla
  GetMem (pBuf, TableSize);
  NumEntries: = 0;
  intento
  ErrorCode: = GetIpNetTable (PTMIBIPNetTable (pBuf), @TableSize, falso);
  si ErrorCode = NO_ERROR después
  comenzar
    NumEntries: = PTMIBIPNetTable (pBuf) ^.dwNumEntries;
    si NumEntries > 0 entonces paranoias de // que pegan, pero usted nunca sabe…
    comenzar
      inc. (pBuf, SizeOf (DWORD)); // consigue último tamaño de la tabla
      para i: = 1 a NumEntries hace
      comenzar
        IPNetRow: = ^ de PTMIBIPNetRow (PBuf);
        con IPNetRow hacer
          List.Add (formato (“%8x | %12s | %16s | %10s”,
                           [dwIndex, MacAddr2Str (el bPhysAddr, dwPhysAddrLen),
                           IPAddr2Str (dwAddr), ARPEntryType [dwType]
                           ]));
        inc. (pBuf, SizeOf (IPNetRow));
      extremo;
    extremo
    
      List.Add (“ARP-escondrijo empty.");
  extremo
  
    List.Add (SysErrorMessage (ErrorCode));

  ¡// nosotros indicador del restablecimiento del _must_!
  finalmente
      diciembre (pBuf, SizeOf (DWORD) + NumEntries * SizeOf (IPNetRow));
      FreeMem (pBuf);
  extremo;
extremo;


//------------------------------------------------------------------------------
procedimiento Get_TCPTable (lista: TStrings);
var
  TCPRow: TMIBTCPRow;
  i,
    NumEntries: número entero;
  TableSize: DWORD;
  ErrorCode: DWORD;
  DestIP: secuencia;
  pBuf: PChar;
comenzar
  si no asignado (lista) entonces SALIR;
  List.Clear;
  RecentIPs.Clear;
  de // llamada primero: conseguir el tamaño de la tabla
  TableSize: = 0;
  NumEntries: = 0;
  ErrorCode: = GetTCPTable (la nada, @TableSize, falso);  // Angus
  si <> ERROR_INSUFFICIENT_BUFFER de Errorcode entonces
    SALIDA;

  // consigue el tamaño de la memoria required, llamada otra vez
  GetMem (pBuf, TableSize);
  // consigue la tabla
  ErrorCode: = GetTCPTable (PTMIBTCPTable (pBuf), @TableSize, falso);
  si ErrorCode = NO_ERROR después
  comenzar

    NumEntries: = PTMIBTCPTable (pBuf) ^.dwNumEntries;
    si NumEntries > 0 entonces
    comenzar
      inc. (pBuf, SizeOf (DWORD)); // consigue último tamaño de la tabla
      para i: = 1 a NumEntries hace
      comenzar
        TCPRow: = ^ de PTMIBTCPRow (pBuf); // consigue el expediente siguiente
        con TCPRow hacer
        comenzar
          si dwRemoteAddr = 0 entonces
            dwRemotePort: = 0;
          DestIP: = IPAddr2Str (dwRemoteAddr);
          List.Add (
            Formato (“%15s: %-7s | %15s: %-7s | %-16s”,
            [IpAddr2Str (dwLocalAddr),
            Port2Svc (Port2Wrd (dwLocalPort)),
              DestIP,
              Port2Svc (Port2Wrd (dwRemotePort)),
              TCPConnState [dwState]
              ]));
         //
            si (no (dwRemoteAddr = 0))
            y (RecentIps.IndexOf (DestIP) = -1) entonces
               RecentIPs.Add (DestIP);
        extremo;
        inc. (pBuf, SizeOf (TMIBTCPRow));
      extremo;
    extremo;
  extremo
  
    List.Add (SyserrorMessage (ErrorCode));
  diciembre (pBuf, SizeOf (DWORD) + NumEntries * SizeOf (TMibTCPRow));
  FreeMem (pBuf);
extremo;

//------------------------------------------------------------------------------
procedimiento Get_TCPStatistics (lista: TStrings);
var
  TCPStats: TMibTCPStats;
  ErrorCode: DWORD;
comenzar
  si no asignado (lista) entonces SALIR;
  List.Clear;
  si no LoadIpHlp entonces sale;
  ErrorCode: = GetTCPStatistics (@TCPStats);
  si ErrorCode = NO_ERROR después
    con TCPStats hacer
    comenzar
      List.Add (“algoritmo de la retransmisión: ” + TCPToAlgo [dwRTOAlgorithm]);
      List.Add (“descanso mínimo: ” + IntToStr (dwRTOMin) + “ms ");
      List.Add (“descanso máximo: ” + IntToStr (dwRTOMax) + “ms ");
      List.Add (“máximo Pend.Connections: ” + IntToStr (dwRTOAlgorithm));
      List.Add (el “Active se abre: ” + IntToStr (dwActiveOpens));
      List.Add (la “voz pasiva se abre: ” + IntToStr (dwPassiveOpens));
      List.Add (“falló tentativas abiertas: ” + IntToStr (dwAttemptFails));
      List.Add (“conec establecidas. Reajuste: ” + IntToStr (dwEstabResets));
      List.Add (“conec establecidas actuales.: ” + IntToStr (dwCurrEstab));
      List.Add (los “segmentos recibieron: ” + IntToStr (dwInSegs));
      List.Add (los “segmentos enviaron: ” + IntToStr (dwOutSegs));
      List.Add (los “segmentos retransmitieron: ” + IntToStr (dwReTransSegs));
      List.Add (“errores entrantes: ” + IntToStr (dwInErrs));
      List.Add (“reajustes salientes: ” + IntToStr (dwOutRsts));
      List.Add (“conexiones acumulativas: ” + IntToStr (dwNumConns));
    extremo
  
    List.Add (SyserrorMessage (ErrorCode));
extremo;

función IpHlpTCPStatistics (var TCPStats: TMibTCPStats): número entero;
comenzar
    resultado: = ERROR_NOT_SUPPORTED;
    si no LoadIpHlp entonces sale;
    resultado: = GetTCPStatistics (@TCPStats);
extremo;

//------------------------------------------------------------------------------
procedimiento Get_UDPTable (lista: TStrings);
var
  UDPRow: TMIBUDPRow;
  i,
    NumEntries: número entero;
  TableSize: DWORD;
  ErrorCode: DWORD;
  pBuf: PChar;
comenzar
  si no asignado (lista) entonces SALIR;
  List.Clear;

  de // llamada primero: conseguir el tamaño de la tabla
  TableSize: = 0;
  NumEntries: = 0;
  ErrorCode: = GetUDPTable (la nada, @TableSize, falso);
  si <> ERROR_INSUFFICIENT_BUFFER de Errorcode entonces
    SALIDA;

  // consigue el tamaño required de la memoria, llamada otra vez
  GetMem (pBuf, TableSize);

  // consigue la tabla
  ErrorCode: = GetUDPTable (PTMIBUDPTable (pBuf), @TableSize, falso);
  si ErrorCode = NO_ERROR después
  comenzar
    NumEntries: = PTMIBUDPTable (pBuf) ^.dwNumEntries;
    si NumEntries > 0 entonces
    comenzar
      inc. (pBuf, SizeOf (DWORD)); // consigue último tamaño de la tabla
      para i: = 1 a NumEntries hace
      comenzar
        UDPRow: = ^ de PTMIBUDPRow (pBuf); // consigue el expediente siguiente
        con UDPRow hacer
          List.Add (formato (“%15s: %-6s”,
            [IpAddr2Str (dwLocalAddr),
            Port2Svc (Port2Wrd (dwLocalPort))
              ]));
        inc. (pBuf, SizeOf (TMIBUDPRow));
      extremo;
    extremo
    
      List.Add (“no entries.");
  extremo
  
    List.Add (SyserrorMessage (ErrorCode));
  diciembre (pBuf, SizeOf (DWORD) + NumEntries * SizeOf (TMibUDPRow));
  FreeMem (pBuf);
extremo;

//------------------------------------------------------------------------------
procedimiento Get_IPAddrTable (lista: TStrings);
var
  IPAddrRow: TMibIPAddrRow;
  TableSize: DWORD;
  ErrorCode: DWORD;
  i: número entero;
  pBuf: PChar;
  NumEntries: DWORD;
comenzar
  si no asignado (lista) entonces SALIR;
  List.Clear;
  TableSize: = 0; ;
  NumEntries: = 0;
  de // llamada primero: conseguir la longitud de la tabla
  ErrorCode: = GetIpAddrTable (la nada, @TableSize, verdad);  // Angus
  si <> ERROR_INSUFFICIENT_BUFFER de Errorcode entonces
    SALIDA;

  GetMem (pBuf, TableSize);
  // consigue la tabla
  ErrorCode: = GetIpAddrTable (PTMibIPAddrTable (pBuf), @TableSize, verdad);
  si ErrorCode = NO_ERROR después
  comenzar
    NumEntries: = PTMibIPAddrTable (pBuf) ^.dwNumEntries;
    si NumEntries > 0 entonces
    comenzar
      inc. (pBuf, SizeOf (DWORD));
      para i: = 1 a NumEntries hace
      comenzar
        IPAddrRow: = ^ de PTMIBIPAddrRow (pBuf);
        con IPAddrRow hacer
          List.Add (formato (“%8.8x | %15s | %15s | %15s | %8.8d”,
            [dwIndex,
            IPAddr2Str (dwAddr),
              IPAddr2Str (dwMask),
              IPAddr2Str (dwBCastAddr),
              dwReasmSize
              ]));
        inc. (pBuf, SizeOf (TMIBIPAddrRow));
      extremo;
    extremo
    
      List.Add (“no entries.");
  extremo
  
    List.Add (SysErrorMessage (ErrorCode));

  ¡// debemos restaurar el indicador!
  diciembre (pBuf, SizeOf (DWORD) + NumEntries * SizeOf (IPAddrRow));
  FreeMem (pBuf);
extremo;

//-----------------------------------------------------------------------------
{consigue entradas en tabla de encaminamiento; equivalente a la “impresión de la ruta”}
procedimiento Get_IPForwardTable (lista: TStrings);
var
  IPForwRow: TMibIPForwardRow;
  TableSize: DWORD;
  ErrorCode: DWORD;
  i: número entero;
  pBuf: PChar;
  NumEntries: DWORD;
comenzar

  si no asignado (lista) entonces SALIR;
  List.Clear;
  TableSize: = 0;

  de // llamada primero: conseguir la longitud de la tabla
  NumEntries: = 0;
  ErrorCode: = GetIpForwardTable (la nada, @TableSize, verdad);
  si <> ERROR_INSUFFICIENT_BUFFER de Errorcode entonces
    SALIDA;

  // consigue la tabla
  GetMem (pBuf, TableSize);
  ErrorCode: = GetIpForwardTable (PTMibIPForwardTable (pBuf), @TableSize, verdad);
  si ErrorCode = NO_ERROR después
  comenzar
    NumEntries: = PTMibIPForwardTable (pBuf) ^.dwNumEntries;
    si NumEntries > 0 entonces
    comenzar
      inc. (pBuf, SizeOf (DWORD));
      para i: = 1 a NumEntries hace
      comenzar
        IPForwRow: = ^ de PTMibIPForwardRow (pBuf);
        con IPForwRow hacer
        comenzar
          si (dwForwardType < 1)
          o (dwForwardType > 4) entonces
                   dwForwardType: = 1;   // Angus, permite mán valor
          List.Add (formato (
            “%15s | %15s | %15s | %8.8x | %7s |   %5.5d |  %7s |   %2.2d”,
            [IPAddr2Str (más dwForwardDest),
            IPAddr2Str (dwForwardMask),
              IPAddr2Str (dwForwardNextHop),
              dwForwardIFIndex,
              IPForwTypes [dwForwardType],
              dwForwardNextHopAS,
              IPForwProtos [dwForwardProto],
              dwForwardMetric1
              ]));
        extremo;       
        inc. (pBuf, SizeOf (TMibIPForwardRow));
      extremo;
    extremo
    
      List.Add (“no entries.");
  extremo
  
    List.Add (SysErrorMessage (ErrorCode));
  diciembre (pBuf, SizeOf (DWORD) + NumEntries * SizeOf (TMibIPForwardRow));
  FreeMem (pBuf);
extremo;

//------------------------------------------------------------------------------
procedimiento Get_IPStatistics (lista: TStrings);
var
  IPStats: TMibIPStats;
  ErrorCode: número entero;
comenzar
  si no asignado (lista) entonces SALIR;
  si no LoadIpHlp entonces sale;
  ErrorCode: = GetIPStatistics (@IPStats);
  si ErrorCode = NO_ERROR después
  comenzar
    List.Clear;
    con IPStats hacer
    comenzar
      si dwForwarding = 1 entonces
        List.add (la “expedición permitió: ” + “sí ")
      
        List.add (la “expedición permitió: ” + “ningún ");
      List.add (“defecto TTL: ” + inttostr (dwDefaultTTL));
      List.add (los “datagramas recibieron: ” + inttostr (dwInReceives));
      List.add (“errores del jefe (adentro): ” + inttostr (dwInHdrErrors));
      List.add (“errores de dirección (adentro): ” + inttostr (dwInAddrErrors));
      List.add (los “datagramas remitieron: ” + inttostr (dwForwDatagrams));   // Angus
      List.add (“protocolos desconocidos (adentro): ” + inttostr (dwInUnknownProtos));
      List.add (los “datagramas desecharon: ” + inttostr (dwInDiscards));
      List.add (los “datagramas entregaron: ” + inttostr (dwInDelivers));
      List.add (“peticiones hacia fuera: ” + inttostr (dwOutRequests));
      List.add (las “encaminamientos desecharon: ” + inttostr (dwRoutingDiscards));
      List.add (“ningunas rutas (hacia fuera): ” + inttostr (dwOutNoRoutes));
      List.add (“volver a montar los descansos: ” + inttostr (dwReasmTimeOut));
      List.add (“volver a montar las peticiones: ” + inttostr (dwReasmReqds));
      List.add (“nuevos ensambles de Succesfull: ” + inttostr (dwReasmOKs));
      List.add (“falló nuevos ensambles: ” + inttostr (dwReasmFails));
      List.add (“fragmentaciones acertadas: ” + inttostr (dwFragOKs));
      List.add (“falló fragmentaciones: ” + inttostr (dwFragFails));
      List.add (los “datagramas hicieron fragmentos: ” + inttostr (dwFRagCreates));
      List.add (“número de interfaces: ” + inttostr (dwNumIf));
      List.add (“número de IP address: ” + inttostr (dwNumAddr));
      List.add (“rutas en RoutingTable: ” + inttostr (dwNumRoutes));
    extremo;
  extremo
  
    List.Add (SysErrorMessage (ErrorCode));
extremo;

función IpHlpIPStatistics (var IPStats: TMibIPStats): número entero;      // Angus
comenzar
    resultado: = ERROR_NOT_SUPPORTED;
    si no LoadIpHlp entonces sale;
    resultado: = GetIPStatistics (@IPStats);
extremo;

//------------------------------------------------------------------------------
procedimiento Get_UdpStatistics (lista: TStrings);
var
  UdpStats: TMibUDPStats;
  ErrorCode: número entero;
comenzar
  si no asignado (lista) entonces SALIR;
  ErrorCode: = GetUDPStatistics (@UdpStats);
  si ErrorCode = NO_ERROR después
  comenzar
    List.Clear;
    con UDPStats hacer
    comenzar
      List.add (“datagramas (adentro): ” + inttostr (dwInDatagrams));
      List.add (“datagramas (hacia fuera): ” + inttostr (dwOutDatagrams));
      List.add (“ningunos puertos: ” + inttostr (dwNoPorts));
      List.add (“errores (adentro): ” + inttostr (dwInErrors));
      List.add (el “UDP escucha los puertos: ” + inttostr (dwNumAddrs));
    extremo;
  extremo
  
    List.Add (SysErrorMessage (ErrorCode));
extremo;

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
función IpHlpUdpStatistics (UdpStats: TMibUDPStats): número entero;     // Angus
comenzar
    resultado: = ERROR_NOT_SUPPORTED;
    si no LoadIpHlp entonces sale;
    resultado: = GetUDPStatistics (@UdpStats);
extremo;

//------------------------------------------------------------------------------
procedimiento Get_ICMPStats (ICMPIn, ICMPOut: TStrings);
var
  ErrorCode: DWORD;
  ICMPStats: PTMibICMPInfo;
comenzar
  si (ICMPIn = nada) o (ICMPOut = nada) entonces SALIR;
  ICMPIn.Clear;
  ICMPOut.Clear;
  Nuevo (ICMPStats);
  ErrorCode: = GetICMPStatistics (ICMPStats);
  si ErrorCode = NO_ERROR después
  comenzar
    con ICMPStats.InStats hacer
    comenzar
      ICMPIn.Add (los “mensajes recibieron: ” + IntToStr (dwMsgs));
      ICMPIn.Add (“errores: ” + IntToStr (dwErrors));
      ICMPIn.Add (“Dest. Inalcanzable: ” + IntToStr (dwDestUnreachs));
      ICMPIn.Add (el “tiempo se excedió: ” + IntToStr (dwTimeEcxcds));
      ICMPIn.Add (“Param. Problemas: ” + IntToStr (dwParmProbs));
      ICMPIn.Add (la “fuente apaga: ” + IntToStr (dwSrcQuenchs));
      ICMPIn.Add (“vuelve a dirigir: ” + IntToStr (dwRedirects));
      ICMPIn.Add (“peticiones del eco: ” + IntToStr (dwEchos));
      ICMPIn.Add (“contestaciones del eco: ” + IntToStr (dwEchoReps));
      ICMPIn.Add (“peticiones del reloj fechador: ” + IntToStr (dwTimeStamps));
      ICMPIn.Add (“contestaciones del reloj fechador: ” + IntToStr (dwTimeStampReps));
      ICMPIn.Add (“Addr. Peticiones de las máscaras: ” + IntToStr (dwAddrMasks));
      ICMPIn.Add (“Addr. Contestaciones de la máscara: ” + IntToStr (dwAddrReps));
    extremo;
     //
    con ICMPStats.OutStats hacer
    comenzar
      ICMPOut.Add (los “mensajes enviaron: ” + IntToStr (dwMsgs));
      ICMPOut.Add (“errores: ” + IntToStr (dwErrors));
      ICMPOut.Add (“Dest. Inalcanzable: ” + IntToStr (dwDestUnreachs));
      ICMPOut.Add (el “tiempo se excedió: ” + IntToStr (dwTimeEcxcds));
      ICMPOut.Add (“Param. Problemas: ” + IntToStr (dwParmProbs));
      ICMPOut.Add (la “fuente apaga: ” + IntToStr (dwSrcQuenchs));
      ICMPOut.Add (“vuelve a dirigir: ” + IntToStr (dwRedirects));
      ICMPOut.Add (“peticiones del eco: ” + IntToStr (dwEchos));
      ICMPOut.Add (“contestaciones del eco: ” + IntToStr (dwEchoReps));
      ICMPOut.Add (“peticiones del reloj fechador: ” + IntToStr (dwTimeStamps));
      ICMPOut.Add (“contestaciones del reloj fechador: ” + IntToStr (dwTimeStampReps));
      ICMPOut.Add (“Addr. Peticiones de las máscaras: ” + IntToStr (dwAddrMasks));
      ICMPOut.Add (“Addr. Contestaciones de la máscara: ” + IntToStr (dwAddrReps));
    extremo;
  extremo
  
    IcmpIn.Add (SysErrorMessage (ErrorCode));
  Disponer (ICMPStats);
extremo;

//------------------------------------------------------------------------------
procedimiento Get_RecentDestIPs (lista: TStrings);
comenzar
  si entonces está asignado (lista)
    List.Assign (RecentIPs)
extremo;

inicialización

  RecentIPs: = TStringList.Create;

acabamiento

  RecentIPs.Free;

end.
class= del

Respuesta : Cómo utilizar una unidad

No es tan fácil como usted piensa. Realmente, usted no puede interceptar el paquete del ICMP en el nivel del uso. Usted necesitará probablemente escribir un conductor de la red (no puede ser hecho en Delphi, usted necesitará C/C++ y el kit del desarrollo del conductor).

O usted puede utilizar un conductor de tercera persona, como el succionador de paquete SDK:
http://www.microolap.com/products/network/pssdk/

También usted puede utilizar una utilidad libre, como el interceptor del ICMP:
http://www.sabronet.com/icmpinterceptor/icmpinterceptor.html
Otras soluciones  
 
programming4us programming4us