Cuestión : fuente de fltdefs.h, usada por Russell (rllibby)

http://www.ndis.com/papers/winpktfilter.htm#W2KPktFilterInterface
La fuente era quita en acoplamiento de los papeles de la NDIS;
¿Dónde podría encontrarla? El acoplamiento.

Y también estoy pidiendo;
¿Qué
convertir para funcionar un cortafuego en panorama o 7 de delphi7/9?
Donde está la fuente el acoplamiento.

Gracias.
         
           
             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:

           
           
          ¿estaba la conversión //This de delphi de fltdefs.h, pero donde es la fuente?

fltdefs de la unidad;
////////////////////////////////////////////////////////////////////////////////
//
Conversión   de // Delphi de fltdefs.h para el uso con el IPHLPAPI.DLL
//
////////////////////////////////////////////////////////////////////////////////
interfaz

aplicaciones
  Windows;

const
  IPHLPAPI          =  “IPHLPAPI.DLL”;

Arsenal del octeto de //
tipo
  TByteArray        =  arsenal [0. Pred (MaxInt)] del octeto;
  PByteArray        =  ^TByteArray;

Tipos de datos de //
tipo
  FILTER_HANDLE     =  indicador;
  PFILTER_HANDLE    =  ^FILTER_HANDLE;
  INTERFACE_HANDLE  =  indicador;
  PINTERFACE_HANDLE =  ^INTERFACE_HANDLE;

Enumeración de // GlobalFilter
const
  GF_FRAGMENTS      =  2;
  GF_STRONGHOST     =  8;
  GF_FRAGCACHE      =  9;

tipo
  GLOBAL_FILTER     =  número entero;
  PGLOBAL_FILTER    =  ^GLOBAL_FILTER;

Enumeración de // PFAddressType
const
  PF_IPV4           =  0;
  PF_IPV6           =  1;

tipo
  PFADDRESSTYPE     =  número entero;
  PPFADDRESSTYPE    =  ^PFADDRESSTYPE;

Enumeración de // PFForwardAction
const
  PF_ACTION_FORWARD =  0;
  PF_ACTION_DROP    =  1;

tipo
  PFFORWARD_ACTION  =  número entero;
  PPFFORWARD_ACTION =  ^PPFFORWARD_ACTION;

Enumeración de // PFFrameType
const
  PFFT_FILTER       =  1;
  PFFT_FRAG         =  2;
  PFFT_SPOOF        =  3;

tipo
  PFFRAMETYPE       =  número entero;
  PPFFRAMETYPE      =  ^PFFRAMETYPE;

tipo
  _PF_FILTER_DESCRIPTOR   =  expediente lleno
     dwFilterFlags:       DWORD;
     dwRule:              DWORD;
     pfatType:            PFADDRESSTYPE;
     SrcAddr:             PByteArray;
     SrcMask:             PByteArray;
     DstAddr:             PByteArray;
     DstMask:             PByteArray;
     dwProtocol:          DWORD;
     fLateBound:          DWORD;
     wSrcPort:            Palabra;
     wDstPort:            Palabra;
     wSrcPortHighRange:   Palabra;
     wDstPortHighRange:   Palabra;
  extremo;
  PF_FILTER_DESCRIPTOR    =  _PF_FILTER_DESCRIPTOR;
  PPF_FILTER_DESCRIPTOR   =  ^PF_FILTER_DESCRIPTOR;

tipo
  _PF_FILTER_STATS        =  expediente lleno
     dwNumPacketsFiltered: DWORD;
     Info:                PF_FILTER_DESCRIPTOR;
  extremo;
  PF_FILTER_STATS         =  _PF_FILTER_STATS;
  PPF_FILTER_STATS        =  ^PF_FILTER_STATS;

tipo
  _PF_INTERFACE_STATS     =  expediente lleno
     pvDriverContext:     Indicador;
     dwFlags:             DWORD;
     dwInDrops:           DWORD;
     dwOutDrops:          DWORD;
     eaInAction:          PFFORWARD_ACTION;
     eaOutAction:         PFFORWARD_ACTION;
     dwNumInFilters:      DWORD;
     dwNumOutFilters:     DWORD;
     dwFrag:              DWORD;
     dwSpoof:             DWORD;
     dwReserved1:         DWORD;
     dwReserved2:         DWORD;
     liSyn:               LARGE_INTEGER;
     liTotalLogged:       LARGE_INTEGER;
     dwLostLogEntries:    DWORD;
     FilterInfo:          Arsenal [0..0] de PF_FILTER_STATS;
  extremo;
  PF_INTERFACE_STATS      =  _PF_INTERFACE_STATS;
  PPF_INTERFACE_STATS     =  ^PF_INTERFACE_STATS;

tipo
  _PF_LATEBIND_INFO       =  expediente lleno
     SrcAddr:             PByteArray;
     DstAddr:             PByteArray;
     Máscara:                PByteArray;
  extremo;
  PF_LATEBIND_INFO        =  _PF_LATEBIND_INFO;
  PPF_LATEBIND_INFO       =  ^PF_LATEBIND_INFO;

tipo
  _PFLOGFRAME             =  expediente lleno
     Reloj fechador:           LARGE_INTEGER;
     pfeTypeOfFrame:      PFFRAMETYPE;
     dwTotalSizeUsed:     DWORD;
     dwFilterRule:        DWORD;
     wSizeOfAdditionalData: Palabra;
     wSizeOfIpHeader:     Palabra;
     dwInterfaceName:     DWORD;
     dwIPIndex:           DWORD;
     bPacketData:         Arsenal [0..0] del octeto;
  extremo;
  PFLOGFRAME              =  _PFLOGFRAME;
  PPFLOGFRAME             =  ^PFLOGFRAME;

const
  FILTER_PROTO_ANY        =  $00;
  FILTER_PROTO_ICMP       =  $01;
  FILTER_PROTO_TCP        =  $06;
  FILTER_PROTO_UDP        =  $11;
  FILTER_TCPUDP_PORT_ANY  =  $00;

const
  FILTER_ICMP_TYPE_ANY    =  $FF;
  FILTER_ICMP_CODE_ANY    =  $FF;

const
  FD_FLAGS_NOSYN          =  $01;
  FD_FLAGS_ALLFLAGS       =  FD_FLAGS_NOSYN;

const
  LB_SRC_ADDR_USE_SRCADDR_FLAG  =  $00000001;
  LB_SRC_ADDR_USE_DSTADDR_FLAG  =  $00000002;
  LB_DST_ADDR_USE_SRCADDR_FLAG  =  $00000004;
  LB_DST_ADDR_USE_DSTADDR_FLAG  =  $00000008;
  LB_SRC_MASK_LATE_FLAG         =  $00000010;
  LB_DST_MASK_LATE_FLAG         =  $00000020;

const
  ERROR_BASE                    =  23000;
  PFERROR_NO_PF_INTERFACE       =  (ERROR_BASE + 0); // nunca volvió.
  PFERROR_NO_FILTERS_GIVEN      =  (ERROR_BASE + 1);
  PFERROR_BUFFER_TOO_SMALL      =  (ERROR_BASE + 2);
  ERROR_IPV6_NOT_IMPLEMENTED    =  (ERROR_BASE + 3);

////////////////////////////////////////////////////////////////////////////////
//
Funciones del filtro de // exportadas por IPHLPAPI
//
////////////////////////////////////////////////////////////////////////////////
función   PfCreateInterface (
           dwName:           DWORD;
           inacción:         PFFORWARD_ACTION;
           outAction:        PFFORWARD_ACTION;
           bUseLog:          BOOL;
           bMustBeUnique:    BOOL;
           ppInterface del var:  INTERFACE_HANDLE): DWORD;
           stdcall; nombre externo “_PfCreateInterface@24” de IPHLPAPI;

función   PfDeleteInterface (
           pInterface:       INTERFACE_HANDLE): DWORD;
           stdcall; nombre externo “_PfDeleteInterface@4” de IPHLPAPI;

función   PfAddFiltersToInterface (
           ih:               INTERFACE_HANDLE;
           cInFilters:       DWORD;
           pfiltIn:          PPF_FILTER_DESCRIPTOR;
           cOutFilters:      DWORD;
           pfiltOut:         PPF_FILTER_DESCRIPTOR;
           pfHandle:         PFILTER_HANDLE): DWORD;
           stdcall; nombre externo “_PfAddFiltersToInterface@24” de IPHLPAPI;

función   PfRemoveFiltersFromInterface (
           ih:               INTERFACE_HANDLE;
           cInFilters:       DWORD;
           pfiltIn:          PPF_FILTER_DESCRIPTOR;
           cOutFilters:      DWORD;
           pfiltOut:         PPF_FILTER_DESCRIPTOR): DWORD;
           stdcall; nombre externo “_PfRemoveFiltersFromInterface@20” de IPHLPAPI;

función   PfRemoveFilterHandles (
           pInterface:       INTERFACE_HANDLE;
           cFilters:         DWORD;
           pvHandles:        PFILTER_HANDLE): DWORD;
           stdcall; nombre externo “_PfRemoveFilterHandles@12” de IPHLPAPI;

función   PfUnBindInterface (
           pInterface:       INTERFACE_HANDLE): DWORD;
           stdcall; nombre externo “_PfUnBindInterface@4” de IPHLPAPI;

función   PfBindInterfaceToIndex (
           pInterface:       INTERFACE_HANDLE;
           dwIndex:          DWORD;
           pfatLinkType:     PFADDRESSTYPE;
           LinkIPAddress:    PByteArray): DWORD;
           stdcall; nombre externo “_PfBindInterfaceToIndex@16” de IPHLPAPI;

función   PfBindInterfaceToIPAddress (
           pInterface:       INTERFACE_HANDLE;
           pfatLinkType:     PFADDRESSTYPE;
           IP address:        PByteArray): DWORD;
           stdcall; nombre externo “_PfBindInterfaceToIPAddress@12” de IPHLPAPI;

función   PfRebindFilters (
           pInterface:       INTERFACE_HANDLE;
           pLateBindInfo:    PPF_LATEBIND_INFO): DWORD;
           stdcall; nombre externo “_PfRebindFilters@8” de IPHLPAPI;

función   PfAddGlobalFilterToInterface (
           pInterface:       INTERFACE_HANDLE;
           gfFilter:         GLOBAL_FILTER): DWORD;
           stdcall; nombre externo “_PfAddGlobalFilterToInterface@8” de IPHLPAPI;

función   PfRemoveGlobalFilterFromInterface (
           pInterface:       INTERFACE_HANDLE;
           gfFilter:         GLOBAL_FILTER): DWORD;
           stdcall; nombre externo “_PfRemoveGlobalFilterFromInterface@8” de IPHLPAPI;

////////////////////////////////////////////////////////////////////////////////
//
APIs del registro de //. Observar que hay a lo más un registro y debe ser creado
// antes de cualquier interfaz que lo necesita se crea. No hay manera de fijar a
registro de // sobre un interfaz existente. El registro se puede aplicar a lo que sea de
// los interfaces.
//
///////////////////////////////////////////////////////////////////////
función   PfMakeLog (
           hEvent:           Manilla en forma de T): DWORD;
           stdcall; nombre externo “_PfMakeLog@4” de IPHLPAPI;

función   PfSetLogBuffer (
           pbBuffer:         PByteArray;
           dwSize:           DWORD;
           dwThreshold:      DWORD;
           dwEntries:        DWORD;
           pdwLoggedEntries: PDWORD;
           pdwLostEntries:   PDWORD;
           pdwSizeUsed:      PDWORD): DWORD;
           stdcall; nombre externo “_PfSetLogBuffer@28” de IPHLPAPI;

función   PfDeleteLog (
           ): DWORD;
           stdcall; nombre externo “_PfDeleteLog@0” de IPHLPAPI;

////////////////////////////////////////////////////////////////////////////////
//
// consigue estadísticas. Observar pdwBufferSize en un parámetro de IN/OUT. Si
Se vuelve // ERROR_INSUFFICIENT_BUFFER, las estadísticas comunes es
// disponible y la cuenta de octeto correcta es adentro *pdwBufferSize. Si solamente
las estadísticas del interfaz de // son necesarias, proporcionan un almacenador intermediario del tamaño
// PF_INTERFACE_STATS solamente. Si las descripciones del filtro también se necesitan,
// entonces suministra un almacenador intermediario grande, o utiliza la cuenta vuelta de la primera llamada
// para asignar un almacenador intermediario del suficiente tamaño. Observar eso para un interfaz compartido,
// que esta segunda llamada puede fallar con ERROR_INSUFFICIENT_BUFFER. Esto puede suceder
// si los otros compartidores agregan los filtros en el interino. Esto no debe suceder para
// un interfaz ÚNICO.
//
////////////////////////////////////////////////////////////////////////////////
función   PfGetInterfaceStatistics (
           pInterface:       INTERFACE_HANDLE;
           ppfStats:         PPF_INTERFACE_STATS;
           pdwBufferSize:    PDWORD;
           fResetCounters:   BOOL): DWORD;
           stdcall; nombre externo “_PfGetInterfaceStatistics@16” de IPHLPAPI;

////////////////////////////////////////////////////////////////////////////////
//
Prueba de // un paquete. Esta llamada evaluará el paquete contra dado
los interfaces de // y vuelven la acción de filtración.
//
////////////////////////////////////////////////////////////////////////////////
función   PfTestPacket (
           pInInterface:     INTERFACE_HANDLE;
           pOutInterface:    INTERFACE_HANDLE;
           cBytes:           DWORD;
           pbPacket:         PByteArray;
           ppAction:         PPFFORWARD_ACTION): DWORD;
           stdcall; nombre externo “_PfTestPacket@20” de IPHLPAPI;

puesta en práctica

extremo. 
           
         
Respuesta : fuente de fltdefs.h, usada por Russell (rllibby)

El DNS está situado en su regulador del dominio para la gente en su dominio (red). Quienquiera anfitriones su external DNS si su ISP o algo como soluciones de red usted tendría que descubrir.

Si usted cambia OWA sin la puesta al día de los expedientes del DNS sin embargo sus usuarios no podrán encontrar OWA pues el DNS es cómo las computadoras encuentran la materia en el Internet.

Gracias

Otras soluciones
Cómo fijar un número de líneas en un informe
Cómo fijar extremo del aeropuerto como servidor del DHCP en el LAN con SonicWall
Ediciones del enlace hipertexto
Agregar la fecha a MySQL
Pares de las preguntas de Apple
El DNS reverso no empareja la bandera del smtp
¿Cómo puedo funcionar conmigo PC en modo seguro?
HISTOGRAMA CON EL CP Y EL ANÁLISIS DE CPK
reglas no corrientes de la perspectiva
volver un valor