Pergunta : fonte de fltdefs.h, usada por Russell (rllibby)

http://www.ndis.com/papers/winpktfilter.htm#W2KPktFilterInterface
A fonte era remove na ligação dos papéis da NDIS;
Onde poderia eu a encontrar? A ligação.

E eu igualmente estou pedindo;
Que

devo eu converter para funcionar um guarda-fogo no vista ou 7 de delphi7/9?
Onde está a fonte a ligação.

Obrigado.

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:



//This era a conversão de delphi de fltdefs.h, mas onde é a fonte?

fltdefs da unidade;
////////////////////////////////////////////////////////////////////////////////
//
Conversão   de // Delphi de fltdefs.h para o uso com o IPHLPAPI.DLL
//
////////////////////////////////////////////////////////////////////////////////
relação

usos
  Windows;

const
  IPHLPAPI          =  “IPHLPAPI.DLL”;

Disposição do byte de //
tipo
  TByteArray        =  disposição [0. Pred (MaxInt)] do byte;
  PByteArray        =  ^TByteArray;

Tipos de dados de //
tipo
  FILTER_HANDLE     =  ponteiro;
  PFILTER_HANDLE    =  ^FILTER_HANDLE;
  INTERFACE_HANDLE  =  ponteiro;
  PINTERFACE_HANDLE =  ^INTERFACE_HANDLE;

Enumeração de // GlobalFilter
const
  GF_FRAGMENTS      =  2;
  GF_STRONGHOST     =  8;
  GF_FRAGCACHE      =  9;

tipo
  GLOBAL_FILTER     =  inteiro;
  PGLOBAL_FILTER    =  ^GLOBAL_FILTER;

Enumeração de // PFAddressType
const
  PF_IPV4           =  0;
  PF_IPV6           =  1;

tipo
  PFADDRESSTYPE     =  inteiro;
  PPFADDRESSTYPE    =  ^PFADDRESSTYPE;

Enumeração de // PFForwardAction
const
  PF_ACTION_FORWARD =  0;
  PF_ACTION_DROP    =  1;

tipo
  PFFORWARD_ACTION  =  inteiro;
  PPFFORWARD_ACTION =  ^PPFFORWARD_ACTION;

Enumeração de // PFFrameType
const
  PFFT_FILTER       =  1;
  PFFT_FRAG         =  2;
  PFFT_SPOOF        =  3;

tipo
  PFFRAMETYPE       =  inteiro;
  PPFFRAMETYPE      =  ^PFFRAMETYPE;

tipo
  _PF_FILTER_DESCRIPTOR   =  registro embalado
     dwFilterFlags:       DWORD;
     dwRule:              DWORD;
     pfatType:            PFADDRESSTYPE;
     SrcAddr:             PByteArray;
     SrcMask:             PByteArray;
     DstAddr:             PByteArray;
     DstMask:             PByteArray;
     dwProtocol:          DWORD;
     fLateBound:          DWORD;
     wSrcPort:            Palavra;
     wDstPort:            Palavra;
     wSrcPortHighRange:   Palavra;
     wDstPortHighRange:   Palavra;
  extremidade;
  PF_FILTER_DESCRIPTOR    =  _PF_FILTER_DESCRIPTOR;
  PPF_FILTER_DESCRIPTOR   =  ^PF_FILTER_DESCRIPTOR;

tipo
  _PF_FILTER_STATS        =  registro embalado
     dwNumPacketsFiltered: DWORD;
     informação:                PF_FILTER_DESCRIPTOR;
  extremidade;
  PF_FILTER_STATS         =  _PF_FILTER_STATS;
  PPF_FILTER_STATS        =  ^PF_FILTER_STATS;

tipo
  _PF_INTERFACE_STATS     =  registro embalado
     pvDriverContext:     Ponteiro;
     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:          Disposição [0..0] de PF_FILTER_STATS;
  extremidade;
  PF_INTERFACE_STATS      =  _PF_INTERFACE_STATS;
  PPF_INTERFACE_STATS     =  ^PF_INTERFACE_STATS;

tipo
  _PF_LATEBIND_INFO       =  registro embalado
     SrcAddr:             PByteArray;
     DstAddr:             PByteArray;
     Máscara:                PByteArray;
  extremidade;
  PF_LATEBIND_INFO        =  _PF_LATEBIND_INFO;
  PPF_LATEBIND_INFO       =  ^PF_LATEBIND_INFO;

tipo
  _PFLOGFRAME             =  registro embalado
     Timestamp:           LARGE_INTEGER;
     pfeTypeOfFrame:      PFFRAMETYPE;
     dwTotalSizeUsed:     DWORD;
     dwFilterRule:        DWORD;
     wSizeOfAdditionalData: Palavra;
     wSizeOfIpHeader:     Palavra;
     dwInterfaceName:     DWORD;
     dwIPIndex:           DWORD;
     bPacketData:         Disposição [0..0] de byte;
  extremidade;
  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 retornou.
  PFERROR_NO_FILTERS_GIVEN      =  (ERROR_BASE + 1);
  PFERROR_BUFFER_TOO_SMALL      =  (ERROR_BASE + 2);
  ERROR_IPV6_NOT_IMPLEMENTED    =  (ERROR_BASE + 3);

////////////////////////////////////////////////////////////////////////////////
//
Funções do filtro de // exportadas por IPHLPAPI
//
////////////////////////////////////////////////////////////////////////////////
função   PfCreateInterface (
           dwName:           DWORD;
           inércia:         PFFORWARD_ACTION;
           outAction:        PFFORWARD_ACTION;
           bUseLog:          BOOL;
           bMustBeUnique:    BOOL;
           ppInterface do var:  INTERFACE_HANDLE): DWORD;
           stdcall; nome externo “_PfCreateInterface@24” de IPHLPAPI;

função   PfDeleteInterface (
           pInterface:       INTERFACE_HANDLE): DWORD;
           stdcall; nome externo “_PfDeleteInterface@4” de IPHLPAPI;

função   PfAddFiltersToInterface (
           ih:               INTERFACE_HANDLE;
           cInFilters:       DWORD;
           pfiltIn:          PPF_FILTER_DESCRIPTOR;
           cOutFilters:      DWORD;
           pfiltOut:         PPF_FILTER_DESCRIPTOR;
           pfHandle:         PFILTER_HANDLE): DWORD;
           stdcall; nome externo “_PfAddFiltersToInterface@24” de IPHLPAPI;

função   PfRemoveFiltersFromInterface (
           ih:               INTERFACE_HANDLE;
           cInFilters:       DWORD;
           pfiltIn:          PPF_FILTER_DESCRIPTOR;
           cOutFilters:      DWORD;
           pfiltOut:         PPF_FILTER_DESCRIPTOR): DWORD;
           stdcall; nome externo “_PfRemoveFiltersFromInterface@20” de IPHLPAPI;

função   PfRemoveFilterHandles (
           pInterface:       INTERFACE_HANDLE;
           cFilters:         DWORD;
           pvHandles:        PFILTER_HANDLE): DWORD;
           stdcall; nome externo “_PfRemoveFilterHandles@12” de IPHLPAPI;

função   PfUnBindInterface (
           pInterface:       INTERFACE_HANDLE): DWORD;
           stdcall; nome externo “_PfUnBindInterface@4” de IPHLPAPI;

função   PfBindInterfaceToIndex (
           pInterface:       INTERFACE_HANDLE;
           dwIndex:          DWORD;
           pfatLinkType:     PFADDRESSTYPE;
           LinkIPAddress:    PByteArray): DWORD;
           stdcall; nome externo “_PfBindInterfaceToIndex@16” de IPHLPAPI;

função   PfBindInterfaceToIPAddress (
           pInterface:       INTERFACE_HANDLE;
           pfatLinkType:     PFADDRESSTYPE;
           IP address:        PByteArray): DWORD;
           stdcall; nome externo “_PfBindInterfaceToIPAddress@12” de IPHLPAPI;

função   PfRebindFilters (
           pInterface:       INTERFACE_HANDLE;
           pLateBindInfo:    PPF_LATEBIND_INFO): DWORD;
           stdcall; nome externo “_PfRebindFilters@8” de IPHLPAPI;

função   PfAddGlobalFilterToInterface (
           pInterface:       INTERFACE_HANDLE;
           gfFilter:         GLOBAL_FILTER): DWORD;
           stdcall; nome externo “_PfAddGlobalFilterToInterface@8” de IPHLPAPI;

função   PfRemoveGlobalFilterFromInterface (
           pInterface:       INTERFACE_HANDLE;
           gfFilter:         GLOBAL_FILTER): DWORD;
           stdcall; nome externo “_PfRemoveGlobalFilterFromInterface@8” de IPHLPAPI;

////////////////////////////////////////////////////////////////////////////////
//
APIs do registro de //. Anotar que há no máximo um registro e deve ser criado
// antes de toda a relação que precisa o é criado. Não há nenhuma maneira de ajustar a
registro de // em uma relação existente. O registro pode ser aplicado a alguns ou a tudo de
// as relações.
//
///////////////////////////////////////////////////////////////////////
função   PfMakeLog (
           hEvent:           THandle): DWORD;
           stdcall; nome externo “_PfMakeLog@4” de IPHLPAPI;

função   PfSetLogBuffer (
           pbBuffer:         PByteArray;
           dwSize:           DWORD;
           dwThreshold:      DWORD;
           dwEntries:        DWORD;
           pdwLoggedEntries: PDWORD;
           pdwLostEntries:   PDWORD;
           pdwSizeUsed:      PDWORD): DWORD;
           stdcall; nome externo “_PfSetLogBuffer@28” de IPHLPAPI;

função   PfDeleteLog (
           ): DWORD;
           stdcall; nome externo “_PfDeleteLog@0” de IPHLPAPI;

////////////////////////////////////////////////////////////////////////////////
//
// começ estatísticas. Anotar pdwBufferSize em um parâmetro de IN/OUT. Se
// ERROR_INSUFFICIENT_BUFFER é retornado, as estatísticas comuns é
// disponível e a contagem de byte correta são *pdwBufferSize dentro. Se somente
as estatísticas da relação de // são necessários, fornecem um amortecedor do tamanho
// PF_INTERFACE_STATS somente. Se as descrições do filtro são igualmente necessários,
// fornece então um grande amortecedor, ou usa a contagem retornada da primeira chamada
// para alocar um amortecedor do suficiente tamanho. Anotar isso para uma relação compartilhada,
// que esta segunda chamada pode falhar com ERROR_INSUFFICIENT_BUFFER. Isto pode acontecer
// se os outros sharers adicionam filtros no ínterim. Isto não deve acontecer para
// uma relação ORIGINAL.
//
////////////////////////////////////////////////////////////////////////////////
função   PfGetInterfaceStatistics (
           pInterface:       INTERFACE_HANDLE;
           ppfStats:         PPF_INTERFACE_STATS;
           pdwBufferSize:    PDWORD;
           fResetCounters:   BOOL): DWORD;
           stdcall; nome externo “_PfGetInterfaceStatistics@16” de IPHLPAPI;

////////////////////////////////////////////////////////////////////////////////
//
Teste de // um pacote. Esta chamada avaliará o pacote de encontro ao dado
as relações de // e retornam a ação de filtração.
//
////////////////////////////////////////////////////////////////////////////////
função   PfTestPacket (
           pInInterface:     INTERFACE_HANDLE;
           pOutInterface:    INTERFACE_HANDLE;
           cBytes:           DWORD;
           pbPacket:         PByteArray;
           ppAction:         PPFFORWARD_ACTION): DWORD;
           stdcall; nome externo “_PfTestPacket@20” de IPHLPAPI;

execução

extremidade.

Resposta : fonte de fltdefs.h, usada por Russell (rllibby)

O DNS é ficado situado em seu controlador do domínio para povos em seu domínio (rede). Whomever anfitriões seu external DNS se seu ISP ou algo como soluções de rede você teriam que encontrar.

Se você muda OWA sem atualizar os registros do DNS embora seus usuários serão incapazes de encontrar OWA porque o DNS é como os computadores encontram o material no Internet.

Obrigado

Outras soluções

Perguntas da entrevista do certificado de Shell da festança

lima de .vmdk

Como encontrar a contagem da fileira em Oracle DataReader em ASP.NET?

Excitador do bluetooth BCM2045 do inspiron 1720 de Dell para o profissional de Windows Xp.

Como conseguir o lightbox mostrar sobre a bandeira instantânea?

Fora do escritório o assistente que não trabalha w/Forwarding configurou

Redistribuindo o RASGO em subnets non-contiguous do OSPF.

líquidos de corpo após a sessão da natação

SQL0952N

Criando um vbscript para a chave do registro - IRPStackSize