Questione : fonte di fltdefs.h, usata da Russell (rllibby)

http://www.ndis.com/papers/winpktfilter.htm#W2KPktFilterInterface
La fonte era rimuove nel collegamento delle carte di NDIS;
Dove potrei trovarlo?  Il collegamento.

Ed inoltre sto chiedendo;
Che cosa
convertire per allontanarmi una parete refrattaria nel vista o 7 da delphi7/9?
Dove è la fonte  il collegamento.

Grazie. 
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 la conversione di Delfi di fltdefs.h, ma dove è la fonte?

fltdefs dell'unità;
////////////////////////////////////////////////////////////////////////////////
//
Conversione   di // Delfi di fltdefs.h per uso con il IPHLPAPI.DLL
//
////////////////////////////////////////////////////////////////////////////////
interfaccia

usi
  Windows;

const
  IPHLPAPI          =  “IPHLPAPI.DLL„;

Allineamento di byte di //
tipo
  TByteArray        =  allineamento [0. Pred (MaxInt)] del byte;
  PByteArray        =  ^TByteArray;

Tipi di dati di //
tipo
  FILTER_HANDLE     =  indicatore;
  PFILTER_HANDLE    =  ^FILTER_HANDLE;
  INTERFACE_HANDLE  =  indicatore;
  PINTERFACE_HANDLE =  ^INTERFACE_HANDLE;

Enumerazione di // GlobalFilter
const
  GF_FRAGMENTS      =  2;
  GF_STRONGHOST     =  8;
  GF_FRAGCACHE      =  9;

tipo
  GLOBAL_FILTER     =  numero intero;
  PGLOBAL_FILTER    =  ^GLOBAL_FILTER;

Enumerazione di // PFAddressType
const
  PF_IPV4           =  0;
  PF_IPV6           =  1;

tipo
  PFADDRESSTYPE     =  numero intero;
  PPFADDRESSTYPE    =  ^PFADDRESSTYPE;

Enumerazione di // PFForwardAction
const
  PF_ACTION_FORWARD =  0;
  PF_ACTION_DROP    =  1;

tipo
  PFFORWARD_ACTION  =  numero intero;
  PPFFORWARD_ACTION =  ^PPFFORWARD_ACTION;

Enumerazione di // PFFrameType
const
  PFFT_FILTER       =  1;
  PFFT_FRAG         =  2;
  PFFT_SPOOF        =  3;

tipo
  PFFRAMETYPE       =  numero intero;
  PPFFRAMETYPE      =  ^PFFRAMETYPE;

tipo
  _PF_FILTER_DESCRIPTOR   =  annotazione imballata
     dwFilterFlags:       DWORD;
     dwRule:              DWORD;
     pfatType:            PFADDRESSTYPE;
     SrcAddr:             PByteArray;
     SrcMask:             PByteArray;
     DstAddr:             PByteArray;
     DstMask:             PByteArray;
     dwProtocol:          DWORD;
     fLateBound:          DWORD;
     wSrcPort:            Parola;
     wDstPort:            Parola;
     wSrcPortHighRange:   Parola;
     wDstPortHighRange:   Parola;
  estremità;
  PF_FILTER_DESCRIPTOR    =  _PF_FILTER_DESCRIPTOR;
  PPF_FILTER_DESCRIPTOR   =  ^PF_FILTER_DESCRIPTOR;

tipo
  _PF_FILTER_STATS        =  annotazione imballata
     dwNumPacketsFiltered: DWORD;
     Info:                PF_FILTER_DESCRIPTOR;
  estremità;
  PF_FILTER_STATS         =  _PF_FILTER_STATS;
  PPF_FILTER_STATS        =  ^PF_FILTER_STATS;

tipo
  _PF_INTERFACE_STATS     =  annotazione imballata
     pvDriverContext:     Indicatore;
     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:          Allineamento [0..0] di PF_FILTER_STATS;
  estremità;
  PF_INTERFACE_STATS      =  _PF_INTERFACE_STATS;
  PPF_INTERFACE_STATS     =  ^PF_INTERFACE_STATS;

tipo
  _PF_LATEBIND_INFO       =  annotazione imballata
     SrcAddr:             PByteArray;
     DstAddr:             PByteArray;
     Mascherina:                PByteArray;
  estremità;
  PF_LATEBIND_INFO        =  _PF_LATEBIND_INFO;
  PPF_LATEBIND_INFO       =  ^PF_LATEBIND_INFO;

tipo
  _PFLOGFRAME             =  annotazione imballata
     Timestamp:           LARGE_INTEGER;
     pfeTypeOfFrame:      PFFRAMETYPE;
     dwTotalSizeUsed:     DWORD;
     dwFilterRule:        DWORD;
     wSizeOfAdditionalData: Parola;
     wSizeOfIpHeader:     Parola;
     dwInterfaceName:     DWORD;
     dwIPIndex:           DWORD;
     bPacketData:         Allineamento [0..0] del byte;
  estremità;
  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); // non ha rinviato mai.
  PFERROR_NO_FILTERS_GIVEN      =  (ERROR_BASE + 1);
  PFERROR_BUFFER_TOO_SMALL      =  (ERROR_BASE + 2);
  ERROR_IPV6_NOT_IMPLEMENTED    =  (ERROR_BASE + 3);

////////////////////////////////////////////////////////////////////////////////
//
Funzioni del filtro da // esportarici da IPHLPAPI
//
////////////////////////////////////////////////////////////////////////////////
funzione   PfCreateInterface (
           dwName:           DWORD;
           inerzia:         PFFORWARD_ACTION;
           outAction:        PFFORWARD_ACTION;
           bUseLog:          BOOL;
           bMustBeUnique:    BOOL;
           ppInterface di varietà:  INTERFACE_HANDLE): DWORD;
           stdcall; nome esterno “_PfCreateInterface@24„ di IPHLPAPI;

funzione   PfDeleteInterface (
           pInterface:       INTERFACE_HANDLE): DWORD;
           stdcall; nome esterno “_PfDeleteInterface@4„ di IPHLPAPI;

funzione   PfAddFiltersToInterface (
           ih:               INTERFACE_HANDLE;
           cInFilters:       DWORD;
           pfiltIn:          PPF_FILTER_DESCRIPTOR;
           cOutFilters:      DWORD;
           pfiltOut:         PPF_FILTER_DESCRIPTOR;
           pfHandle:         PFILTER_HANDLE): DWORD;
           stdcall; nome esterno “_PfAddFiltersToInterface@24„ di IPHLPAPI;

funzione   PfRemoveFiltersFromInterface (
           ih:               INTERFACE_HANDLE;
           cInFilters:       DWORD;
           pfiltIn:          PPF_FILTER_DESCRIPTOR;
           cOutFilters:      DWORD;
           pfiltOut:         PPF_FILTER_DESCRIPTOR): DWORD;
           stdcall; nome esterno “_PfRemoveFiltersFromInterface@20„ di IPHLPAPI;

funzione   PfRemoveFilterHandles (
           pInterface:       INTERFACE_HANDLE;
           cFilters:         DWORD;
           pvHandles:        PFILTER_HANDLE): DWORD;
           stdcall; nome esterno “_PfRemoveFilterHandles@12„ di IPHLPAPI;

funzione   PfUnBindInterface (
           pInterface:       INTERFACE_HANDLE): DWORD;
           stdcall; nome esterno “_PfUnBindInterface@4„ di IPHLPAPI;

funzione   PfBindInterfaceToIndex (
           pInterface:       INTERFACE_HANDLE;
           dwIndex:          DWORD;
           pfatLinkType:     PFADDRESSTYPE;
           LinkIPAddress:    PByteArray): DWORD;
           stdcall; nome esterno “_PfBindInterfaceToIndex@16„ di IPHLPAPI;

funzione   PfBindInterfaceToIPAddress (
           pInterface:       INTERFACE_HANDLE;
           pfatLinkType:     PFADDRESSTYPE;
           IP address:        PByteArray): DWORD;
           stdcall; nome esterno “_PfBindInterfaceToIPAddress@12„ di IPHLPAPI;

funzione   PfRebindFilters (
           pInterface:       INTERFACE_HANDLE;
           pLateBindInfo:    PPF_LATEBIND_INFO): DWORD;
           stdcall; nome esterno “_PfRebindFilters@8„ di IPHLPAPI;

funzione   PfAddGlobalFilterToInterface (
           pInterface:       INTERFACE_HANDLE;
           gfFilter:         GLOBAL_FILTER): DWORD;
           stdcall; nome esterno “_PfAddGlobalFilterToInterface@8„ di IPHLPAPI;

funzione   PfRemoveGlobalFilterFromInterface (
           pInterface:       INTERFACE_HANDLE;
           gfFilter:         GLOBAL_FILTER): DWORD;
           stdcall; nome esterno “_PfRemoveGlobalFilterFromInterface@8„ di IPHLPAPI;

////////////////////////////////////////////////////////////////////////////////
//
Api del ceppo di //. Si noti che ci è al massimo un ceppo e deve essere generato
// prima di tutta l'interfaccia che lo ha bisogno è generato. Non ci è senso regolare la a
ceppo di // su un'interfaccia attuale. Il ceppo può applicarsi a c'è ne o a tutti di
// le interfacce.
//
///////////////////////////////////////////////////////////////////////
funzione   PfMakeLog (
           hEvent:           Manico a t): DWORD;
           stdcall; nome esterno “_PfMakeLog@4„ di IPHLPAPI;

funzione   PfSetLogBuffer (
           pbBuffer:         PByteArray;
           dwSize:           DWORD;
           dwThreshold:      DWORD;
           dwEntries:        DWORD;
           pdwLoggedEntries: PDWORD;
           pdwLostEntries:   PDWORD;
           pdwSizeUsed:      PDWORD): DWORD;
           stdcall; nome esterno “_PfSetLogBuffer@28„ di IPHLPAPI;

funzione   PfDeleteLog (
           ): DWORD;
           stdcall; nome esterno “_PfDeleteLog@0„ di IPHLPAPI;

////////////////////////////////////////////////////////////////////////////////
//
// ottiene le statistiche. Notare pdwBufferSize in un parametro di IN/OUT. Se
// ERROR_INSUFFICIENT_BUFFER è restituito, le statistiche comuni è
// disponibile ed il numero di byte corretto è dentro *pdwBufferSize. Se soltanto
le statistiche dell'interfaccia di // sono necessarie, forniscono un amplificatore del formato
// PF_INTERFACE_STATS soltanto. Se le descrizioni del filtro inoltre sono necessarie,
// allora fornisce un grande amplificatore, o usa il conteggio restituito dalla prima chiamata
// per assegnare un amplificatore del formato sufficiente. Si noti che per un'interfaccia comune,
// che questa seconda chiamata può venire a mancare con ERROR_INSUFFICIENT_BUFFER. Ciò può accadere
// se gli altri condivisori aggiungono i filtri nell'interim. Ciò non dovrebbe accadere per
// un'interfaccia UNICA.
//
////////////////////////////////////////////////////////////////////////////////
funzione   PfGetInterfaceStatistics (
           pInterface:       INTERFACE_HANDLE;
           ppfStats:         PPF_INTERFACE_STATS;
           pdwBufferSize:    PDWORD;
           fResetCounters:   BOOL): DWORD;
           stdcall; nome esterno “_PfGetInterfaceStatistics@16„ di IPHLPAPI;

////////////////////////////////////////////////////////////////////////////////
//
Prova di // un pacchetto. Questa chiamata confronterà il pacchetto con dato
le interfacce di // e restituiscono l'azione di filtrazione.
//
////////////////////////////////////////////////////////////////////////////////
funzione   PfTestPacket (
           pInInterface:     INTERFACE_HANDLE;
           pOutInterface:    INTERFACE_HANDLE;
           cBytes:           DWORD;
           pbPacket:         PByteArray;
           ppAction:         PPFFORWARD_ACTION): DWORD;
           stdcall; nome esterno “_PfTestPacket@20„ di IPHLPAPI;

esecuzione

estremità.

Risposta : fonte di fltdefs.h, usata da Russell (rllibby)

Il DNS è situato nel vostro regolatore di dominio per la gente sul vostro dominio (rete).  Whomever ospiti il vostro external DNS se il vostro ISP o qualcosa come le soluzioni di rete voi dovrebbe scoprire.

Se cambiate OWA senza aggiornare le annotazioni di DNS comunque i vostri utenti non potranno trovare OWA poichè il DNS è come i calcolatori trovano il roba sul Internet.  

Grazie
Altre soluzioni  
 
programming4us programming4us