IOCP扩展方法AcceptEx, DisconnectEx, GetAcceptExSockaddr用法示例

这篇文章记录了我刚接触IOCP模型时的理解，对于初学者，应该算不错的调试程序，仅有一个400多行代码的dpr文件，可以直接用WriteLn输出信息，前提是会用delphi建立Console Application，当然你也可以很容易的就改成了C控制台程序或是其它语言。附加代码中有详细的注释，如果你已有IOCP经验，那么请不用在此浪费时间，这个示例不适合你。示例仅展示了IOCP中AcceptEx, DisconnectEx, GetAcceptExSockaddr等的用法。在文章最后有推荐的两个连接，对于想深入研究IOCP与TCP的可以去看看，可人感觉值得去看。文中错误或是不合理的地方敬请原谅，如果方便还请指出，深表感谢！

刚接触IOCP时，因为要弄清里面的复杂关系，最直接的方法当然就是断点调试与信息输出了，所以我选用了控制台程序。具体的原理在文章末尾的第一个连接中讲得很详细,扩展的方法可以到MSDN上查。示例中仅用了一个工作线程和10个连接，个人觉得这样方便调试与查看输出信息，省去了多线程与数据池的干扰，当然在实际应用中会涉及线程池、消息队列、内存管理等等，不在这个示例展示范围。下面我只记录了我碰到的问题：

问题一：AcceptEx成功，但有客户端连接时，GetQueuedCompletionStatus却不返回，后来把ListenSocket用CreateIoCompletionPort绑定到完在端口之后问题不再出现，因为之前用WSAAccept,就没有把ListenSocket绑定。

问题二：10014错误，在一开始时，gOverls用了array[0..ACCEPT_COUNT - 1] of TIOCPRecord,用这样的类型时，AcceptEx是成功的，也能接收几个连接，但是测试的连接不完全能连上，后来改用array[0..ACCEPT_COUNT - 1] of PIOCPRecord,用New分配内存时，测试连接能全部连上，分析原因，可能是栈内存与堆内存的区别。另外一次出现10014是把TWSABUF中的u_long类型改为int64类型后出现这个错。

问题三：首次GetQueuedCompletionStatus的完键不是预期的那个，即soAccept时的那个完成键并不是想要的那个，连接后正常。我一开始AcceptEx时就已经把每一个待接收的Socket绑定到了完成端口，因为连接非法时不想在DisconnectEx那里判断。

问题四：要说一下TAcceptEx与TGetAcceptExSockaddrs中的dwReceiveDataLength参数，这个初始值如果不是0，那么当IOCP接到一个连接时并不立即返回，而是收到客户端的数据时才返回。这会导致DOS攻击的大量连接耗尽预设等待的Socket连接，即AcceptEx投递的连接资源，如果设置为0，那么有连接时GetQueuedCompletionStatus就回立即返回，至于是否非法那就仁者见人智者见智了，比如心跳包的检测。使用AcceptEx时，一定要保证IOCP中有空闲的Socket接收客户端。

问题五：ERROR_IO_PENDING（997），当WSAGetLastError返回这个值时表示已经进入处理中，但并没有处理完。

问题六：GetQueuedCompletionStatus返回soWrite状态时，buffer的数据不一写就发送完了，没有发送完的数据继续WSASend。

下图是我写完这个示例后对IOCP中那几个API关系的理解，注意图中的箭头方向，PostQueuedCompletionStatus，AcceptEx,WSARecv, WSASend, DisconnectEx都是向IOCP内部投递数据，投递完后立即返回，这并不意味着投递的数据就会立即被处理，可以理解为进入一个等待处理队列，这几个方法可以投递多个数据不阻塞。PostQueuedCompletionStatus一般用于结束工作线程时使用，也就是GetQueuedCompletionStatus会得到PostQueuedCompletionStatus的状态信息。所有IOCP内部处理完的数据都会通过GetQueuedCompletionStatus这个方法反回，比如收到客户端请求后，发送数据到客户端后。这是一个阻塞的方法，当然可以设置超时。每一个工作线程也就通过GetQueuedCompletionStatus这个方法来处理消息，具体可以看后面的附加代码。

附加IOCPsever.dpr与WinSock2.pas：

  1 program IOCPServer;
  2 
  3 {$APPTYPE CONSOLE}
  4 
  5 uses
  6   SysUtils,  windows,
  7   WinSock2 in 'winsock2.pas';
  8 
  9 const
 10   WINSOCK_VERSION = $0202;
 11   LISTEN_PORT = 6553;                   //监听端口
 12   MAX_BUFFSIZE = 4096;                 //数据buffer
 13   ACCEPT_COUNT = 10;                   //接收连接数
 14   SHUTDOWN_FLAG = $FFFFFFFF;    //退出标记
 15 
 16   SO_UPDATE_ACCEPT_CONTEXT = $700B;
 17   TF_REUSE_SOCKET          = $02;
 18   IOC_IN               =$80000000;
 19   IOC_VENDOR           =$18000000;
 20   IOC_OUT              =$40000000;
 21   SIO_KEEPALIVE_VALS   =IOC_IN or IOC_VENDOR or 4;
 22 
 23   WSAID_GETACCEPTEXSOCKADDRS: System.TGuid = (D1:$b5367df2;D2:$cbac;D3:$11cf;D4:($95,$ca,$00,$80,$5f,$48,$a1,$92));
 24   WSAID_ACCEPTEX: System.TGuid = (D1:$b5367df1;D2:$cbac;D3:$11cf;D4:($95,$ca,$00,$80,$5f,$48,$a1,$92));
 25   WSAID_CONNECTEX: System.TGuid = (D1:$25a207b9;D2:$ddf3;D3:$4660;D4:($8e,$e9,$76,$e5,$8c,$74,$06,$3e));
 26   WSAID_DISCONNECTEX: System.TGuid = (D1:$7fda2e11;D2:$8630;D3:$436f;D4:($a0,$31,$f5,$36,$a6,$ee,$c1,$57));
 27 
 28 type
 29   TAcceptEx = function(sListenSocket, sAcceptSocket: TSocket;
 30          lpOutputBuffer: Pointer; dwReceiveDataLength, dwLocalAddressLength,
 31          dwRemoteAddressLength: LongWord; var lpdwBytesReceived: LongWord;
 32          lpOverlapped: POverlapped): BOOL; stdcall;
 33 
 34   TGetAcceptExSockaddrs = procedure(lpOutputBuffer: Pointer;
 35          dwReceiveDataLength, dwLocalAddressLength, dwRemoteAddressLength: DWORD;
 36          var LocalSockaddr: PSockAddr; var LocalSockaddrLength: Integer;
 37          var RemoteSockaddr: PSockAddr; var RemoteSockaddrLength: Integer);stdcall;
 38 
 39   TConnectEx = function(const s : TSocket; const name: PSOCKADDR; const
 40       namelen: Integer; lpSendBuffer : Pointer; dwSendDataLength : DWORD; var
 41       lpdwBytesSent : LongWord; lpOverlapped : POverlapped): BOOL; stdcall;
 42 
 43   TDisconnectEx = function(const hSocket : TSocket; lpOverlapped: POverlapped;
 44      const dwFlags : LongWord; const dwReserved : LongWord) : BOOL; stdcall;
 45 
 46   PTCPKeepAlive = ^TTCPKeepAlive;
 47   TTCPKeepAlive = packed record
 48     KeepOn: integer;
 49     KeepTime: integer;
 50     KeepInterval: integer;
 51   end;
 52 
 53   TSockOperate = (soAccept, soDisconnect, soRead, soWrite);
 54   PIOCPRecord = ^TIOCPRecord;
 55   TIOCPRecord = packed record
 56     Ovelpd: TOverlapped;
 57     WsaBuf: TWsaBuf;
 58     Buffer: array [0..MAX_BUFFSIZE - 1] of AnsiChar;
 59     operate: TSockOperate;
 60     sock: TSocket;
 61   end;
 62 
 63 var
 64   gListen: TSocket;
 65   gOverls: array[0..ACCEPT_COUNT - 1] of PIOCPRecord;
 66   gIOCP: THandle = 0;
 67   gWorker: THandle;
 68   gFunAcceptEx: TAcceptEx = nil;
 69   gFunGetAcceptEx: TGetAcceptExSockaddrs = nil;
 70   gFunConnectEx: TConnectEx = nil;
 71   gFunDisconnectEx: TDisconnectEx = nil;
 72 
 73 //加载扩展函数
 74 function LoadFunEx(ASock: TSocket): Boolean;
 75 var
 76   tag: LongWord;
 77 begin
 78   Result := False;
 79   if ASock = INVALID_SOCKET then Exit;
 80   try
 81     tag := 0;
 82     if SOCKET_ERROR = WSAIoctl(ASock, SIO_GET_EXTENSION_FUNCTION_POINTER,
 83                                @WSAID_ACCEPTEX, SizeOf(WSAID_ACCEPTEX),
 84                                @@gFunAcceptEx, SizeOf(Pointer), @tag, nil, nil)then
 85     begin
 86       gFunAcceptEx := nil;
 87       Exit;
 88     end;
 89 
 90     tag := 0;
 91     if SOCKET_ERROR = WSAIoctl(ASock, SIO_GET_EXTENSION_FUNCTION_POINTER,
 92                                @WSAID_GETACCEPTEXSOCKADDRS, SizeOf(WSAID_GETACCEPTEXSOCKADDRS),
 93                                @@gFunGetAcceptEx, SizeOf(Pointer), @tag, nil, nil)then
 94     begin
 95       gFunGetAcceptEx := nil;
 96       Exit;
 97     end;
 98 
 99     if SOCKET_ERROR = WSAIoctl(ASock, SIO_GET_EXTENSION_FUNCTION_POINTER,
100                                @WSAID_CONNECTEX,  SizeOf(WSAID_CONNECTEX),
101                                @@gFunConnectEx,  SizeOf(Pointer), @tag, nil,  nil)then
102     begin
103       gFunConnectEx := nil;
104       Exit;
105     end;
106 
107     if SOCKET_ERROR = WSAIoctl(ASock, SIO_GET_EXTENSION_FUNCTION_POINTER,
108                                @WSAID_DISCONNECTEX,  SizeOf(WSAID_DISCONNECTEX),
109                                @@gFunDisconnectEx,  SizeOf(Pointer), @tag, nil,  nil)then
110     begin
111       gFunDisconnectEx := nil;
112       Exit;
113     end; 
114     Result := True;
115   except
116   end;
117 end;
118 
119 //判断socket是否有效
120 function IsSocketAlive(ASock: TSocket): Boolean;
121 var
122   tmp: LongWord;
123 begin
124   Result := WinSock2.send(ASock, tmp, 0, 0) <> -1;
125 end;
126 
127 //设置心跳
128 procedure SetKeepLive(ASock: TSocket);
129 var
130   opt: Integer;
131   dwFlags: DWORD;
132   inKeepAlive, OutKeepAlive: TTCPKeepAlive;
133 begin
134   if ASock <> INVALID_SOCKET then
135   begin
136     opt := 1;
137     inKeepAlive.KeepOn := 1;
138     inKeepAlive.KeepTime := 5000;
139     inKeepAlive.KeepInterval := 1;
140 
141     if (SetSockOpt(ASock, SOL_SOCKET, SO_KEEPALIVE, @opt, SizeOf(opt)) = SOCKET_ERROR)
142     or (WSAIoctl(ASock, SIO_KEEPALIVE_VALS, @inKeepAlive,SizeOf(TTCPKeepAlive),
143         @outKeepAlive, SizeOf(TTCPKeepAlive), @dwFlags, nil, nil) = SOCKET_ERROR) then
144       WriteLn('设置心跳错误 socket: ' + Inttostr(ASock) + 'Error: ' + Inttostr(WSAGetLastError) );
145   end;
146 end;
147 
148 //关闭socket
149 procedure FunCloseSocket(ASock: TSocket);
150 var
151   Linger: TLinger;
152 begin
153   if ASock <> INVALID_SOCKET then
154   begin
155     FillChar(Linger, SizeOf(TLinger), 0);
156     setsockopt(ASock, SOL_SOCKET, SO_LINGER, @Linger, Sizeof(Linger));
157     closesocket(ASock);
158   end;
159 end;
160 
161 procedure ResetData(PData: PIOCPRecord);
162 var
163   sock: TSocket;
164 begin
165   if Assigned(PData) then
166   begin
167     sock := PData.sock;
168     FillChar(PData^, SizeOf(TIOCPRecord), 0);
169     PData^.WsaBuf.len := MAX_BUFFSIZE;
170     PData^.WsaBuf.buf := @(PData^.Buffer[0]);
171     PData.sock := sock;
172   end;
173 end;
174 
175 //投递一个接收socket
176 function PostAccept(PAccept: PIOCPRecord): Boolean;
177 var
178   dwBytes: LongWord;
179 begin
180   Result := False;
181   if Assigned(PAccept) and (PAccept^.sock <> INVALID_SOCKET)  then
182   begin
183     ResetData(PAccept);
184     PAccept^.operate := soAccept;
185     dwBytes := 0;
186     Result := gFunAcceptEx(gListen, PAccept^.sock, PAccept^.Wsabuf.buf, 0,
187                            SizeOf(TSockAddrIn) + 16, SizeOf(TSockAddrIn) + 16,
188                            dwBytes, @(PAccept^.Ovelpd))
189       or (ERROR_IO_PENDING = WSAGetLastError);
190   end;
191 end;
192 
193 //投递一个断开socket
194 function PostDisconnect(PData: PIOCPRecord): Boolean;
195 begin
196   Result := False;
197   if Assigned(PData) and (PData^.sock <> INVALID_SOCKET)  then
198   begin
199     ResetData(PData);
200     PData^.operate := soDisconnect;
201     WinSock2.shutdown(PData^.sock, SD_BOTH);
202     Result := gFunDisconnectEx(PData^.sock, @(PData^.Ovelpd), TF_REUSE_SOCKET, 0)
203        or (ERROR_IO_PENDING = WSAGetLastError);
204     if Result then
205       WriteLn('客户端断开：socket ' + Inttostr(PData^.sock))
206     else
207       WriteLn('客户端断开错误：socket ' + Inttostr(PData^.sock) + ' WSAError: ' + Inttostr(WSAGetLastError));
208   end;
209 end;
210 
211 //投递接收数据缓冲
212 function PostRecv(PData: PIOCPRecord): Boolean;
213 var
214   dwBuff, dwRecv: LongWord;
215 begin
216   Result := False;
217   if Assigned(PData) and (PData^.sock <> INVALID_SOCKET)  then
218   begin
219     ResetData(PData);
220     PData^.operate := soRead;
221     dwBuff := 0;
222     dwRecv := 0;
223     Result := (WSARecv(PData^.sock, @(PData^.WsaBuf), 1, @dwBuff, @dwRecv, @(PData^.Ovelpd), nil) <> SOCKET_ERROR)
224        or (ERROR_IO_PENDING = WSAGetLastError);
225   end;
226 end;
227 
228 procedure WriteError(AInfo: String);
229 begin
230   WriteLn(AInfo + ' WSAError: ' + Inttostr(WSAGetLastError));
231 end;
232 
233 //工作线程
234 function WorkProc(PValue: Pointer): Integer;stdcall;
235 var
236   data: PIOCPRecord;
237   workCount, dwSend, dwFlags: Cardinal;
238   sock: TSocket;
239   str: AnsiString;
240   remoteAddr, localAddr: PSockAddrin;
241   remoteLen, localLen, opt: Integer;
242 begin
243   Result := 0;
244   while true do
245   begin
246     data := nil;
247     workCount := 0;
248     sock := 0;
249     if not GetQueuedCompletionStatus(gIOCP, workCount, Cardinal(sock), POVerlapped(data), INFINITE) then
250     begin //有可能是客服端断开
251       if Assigned(data) then
252         PostDisconnect(data);
253       Continue;
254     end;
255     WriteLn('Worker GetQueued socket:' + inttostr(sock));
256     if Cardinal(data) = SHUTDOWN_FLAG then Break; // 有退出
257     if not Assigned(data) then continue;
258 
259     case data^.operate of
260       soAccept:
261       begin
262         gFunGetAcceptEx(Data^.WsaBuf.buf, 0, SizeOf(TSockAddrIn) + 16, SizeOf(TSockAddrIn) + 16,
263                  PSockAddr(localAddr), localLen, PSockAddr(remoteAddr), remoteLen);
264         WriteLn('接入IP: ' + inet_ntoa(remoteAddr^.sin_addr) + ' Port: ' + Inttostr(ntohs(remoteAddr^.sin_port)));
265         SetSockOpt(data^.sock, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT, PAnsiChar(@(gListen)), SizeOf(gListen));
266         SetKeepLive(data^.sock);
267           
268         if PostRecv(data) then
269           WriteLn('Accept 数据 socket: ' + Inttostr(data^.sock))
270         else
271           WriteError('Accept 错误 socket: ' + inttostr(data^.sock));
272       end;
273       soDisconnect:
274       begin
275         if PostAccept(data) then
276           WriteLn('投递Acceptex socket: ' + Inttostr(data^.sock))
277         else
278           WriteError('Disconnectex投递错误 socket: ' + Inttostr(data^.sock));
279       end;
280       soWrite:
281       begin
282         if workCount = 0 then
283           PostDisconnect(data)
284         else begin
285           data^.WsaBuf.len := data^.WsaBuf.len - workCount;
286           if data^.WsaBuf.len <= 0 then
287           begin
288             WriteLn('服务器回复数据完成 socket: ' + inttostr(data^.sock));
289             PostRecv(data);
290             continue;
291           end;
292           dwSend := 0;
293           dwFlags := 0;
294           FillChar(data^.Ovelpd, Sizeof(data^.Ovelpd), 0);
295           if (WSASend(data^.sock, @(data^.WsaBuf), 1, @dwSend, dwFlags, @data^.Ovelpd, nil)<>SOCKET_ERROR)
296           or (ERROR_IO_PENDING = WSAGetLastError) then
297             WriteLn('发送数据 socket: ' + Inttostr(data^.sock))
298           else begin
299             WriteError('发送数据错误 socket: ' + Inttostr(data^.sock));
300           end;
301 
302           if dwSend = SOCKET_ERROR then//客户端断开
303             PostDisconnect(data)
304         end;
305       end;
306       soRead:
307       begin
308         if workCount = 0 then
309           PostDisconnect(data)
310         else begin
311           sock := data^.sock;
312           SetLength(str, workCount);
313           Move(data^.Buffer[0], str[1], workCount);
314           WriteLn('接收数据 socket: ' + Inttostr(sock) + ' str: ' + str);
315           str := '服务器回复：' + str;
316           
317           dwSend := 0;
318           dwFlags := 0;
319           FillChar(data^, SizeOf(TIOCPRecord), 0);
320           data^.WsaBuf.len := Length(str);
321           data^.WsaBuf.buf := @(data^.Buffer[0]);
322           data^.operate := soWrite;
323           data^.sock := sock;
324           Move(str[1], data^.Buffer[0], data^.WsaBuf.len);
325           if not ( (WSASend(sock, @(data^.WsaBuf), 1, @dwSend, dwFlags, @(data^.Ovelpd), nil) <> SOCKET_ERROR)
326                    or (WSAGetlastError =  ERROR_IO_PENDING) ) then
327           begin
328             WriteLn('服务器回复数据失败 socket: ' + Inttostr(sock));
329             PostRecv(data);
330           end
331           else
332             WriteLn('服务器回复数据 socket: ' + Inttostr(sock));
333         end;
334       end;
335     end; // end of case
336   end;// end of while
337 end;
338 
339 var
340   threadID: Cardinal;
341   i: Integer;
342   need: Boolean;
343   WSData: TWSAData;
344   addr: TSockAddr;
345   console: array[0..255] of AnsiChar;
346   label exitLabel;
347 begin
348 
349   try
350     need := True;
351 
352     WriteLn('初始化网络环境');
353     if WSAStartup(WINSOCK_VERSION, WSData) <> 0 then goto exitLabel;
354 
355     WriteLn('创建完成端口');
356     gIOCP := CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0, 0, 0);
357     if gIOCP = 0 then  goto exitLabel;
358 
359     WriteLn('创建监听Socket');
360     gListen := WSASocket(PF_INET, SOCK_STREAM, 0, nil, 0, WSA_FLAG_OVERLAPPED);
361     if gListen = INVALID_SOCKET then goto exitLabel;
362 
363     WriteLn('加载扩展函数');
364     if not LoadFunEx(gListen) then goto exitLabel;
365 
366     WriteLn('邦定监听Socket 与IOCP ['  + inttostr(gListen) + '][' + inttostr(gIOCP) + ']');
367     if CreateIoCompletionPort(gListen, gIOCP, gListen, 0) = 0 then goto exitLabel;
368 
369     WriteLn('邦定监听Socket 与IP');
370     FillChar(Addr, SizeOf(TSockAddrIn), 0);
371     Addr.sin_family := AF_INET;
372     Addr.sin_port := htons(LISTEN_PORT);
373     Addr.sin_addr.S_addr := htonl(INADDR_ANY);
374     //Addr.sin_addr.S_addr := inet_addr('0.0.0.0');
375     if WinSock2.bind(gListen, @Addr, SizeOf(TSockAddr)) <> 0 then goto exitLabel;
376 
377     WriteLn('开始监听Socket');
378     if WinSock2.listen(gListen, SOMAXCONN) <> 0 then goto exitLabel;
379 
380     WriteLn('投递接收Socket');
381     FillChar(gOverls[0], SizeOf(gOverls), 0);
382     for i := 0 to ACCEPT_COUNT - 1 do
383     begin
384       New(gOverls[i]);
385       gOverls[i]^.sock := WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, nil, 0, WSA_FLAG_OVERLAPPED);
386       if gOverls[i]^.sock = INVALID_SOCKET then goto exitLabel;
387       if CreateIoCompletionPort(gOverls[i]^.sock, gIOCP, gOverls[i]^.sock, 0) = 0 then goto exitLabel;
388       if PostAccept(gOverls[i]) then
389         WriteLn('投递Socket：' + Inttostr(gOverls[i]^.sock))
390       else goto exitLabel;
391     end;
392 
393     //处理完端口请求
394     WriteLn('创建工作线程 ');
395     gWorker := BeginThread(nil, 0, @WorkProc, nil, 0, threadID);
396     if gWorker = 0 then goto exitLabel;
397 
398     WriteLn('键入exit退出 ');
399     while True do
400     begin
401       ReadLn(console);
402       if console = 'exit' then
403         Break;
404       console := '';
405     end;
406      
407     WriteLn('投递完成端口结束标记, 退出工作线程');
408     if not PostQueuedCompletionStatus(gIOCP, 0, 0, Pointer(SHUTDOWN_FLAG)) then
409     begin
410       WriteLn('投递完成端口结束标记错误:' + inttostr(GetLastError));
411       TerminateThread(gWorker, 0);
412     end;
413 
414     WriteLn('关闭工作线程句柄');
415     CloseHandle(gWorker);
416 
417     WriteLn('释放socket资源');
418     for i := 0 to ACCEPT_COUNT - 1 do
419       Dispose(gOverls[i]);
420     FillChar(gOverls[0], SizeOf(gOverls), 0);
421 
422     WriteLn('关闭监听端口');
423     FunCloseSocket(gListen);
424 
425     WriteLn('关闭完成端口');
426     CloseHandle(gIOCP);
427 
428     WriteLn('释放网络环境');
429     WSACleanup;
430 
431     need := false;
432     
433     exitLabel:
434       if need then
435         WriteLn('运行错误：' + Inttostr(WSAGetLastError));
436 
437   except
438     on e:Exception do
439       WriteLn(e.Message);
440   end;
441 
442 end.

IOCPServer.dpr

   1 {*******************************************************}
   2 {                                                       }
   3 {       Windows Sockets API v. 2.20 Header File         }
   4 {                                                       }
   5 {        Prerelease 16.09.96                                 }
   6 {                                                       }
   7 {       Base:      WinSock2.h from Winsock SDK 1.6 BETA    }
   8 {               Delphi 2 RTL Windows32 API Interface    } 
   9 {                                                       }
  10 {       (c) 1996 by Artur Grajek 'AHS'                  }
  11 {    email: c51725ag@juggernaut.eti.pg.gda.pl              }
  12 {                                                       }
  13 {*******************************************************}
  14 {$MINENUMSIZE 4} { Force 4 bytes enumeration size}
  15 
  16 unit WinSock2;
  17 
  18 interface
  19 
  20 uses Windows;
  21 
  22 type
  23   u_char = Char;
  24   u_short = Word;
  25   u_int = Integer;
  26   u_long = Longint;
  27   pu_long = ^u_long;
  28   pu_short = ^u_short;
  29 
  30 { The new type to be used in all
  31   instances which refer to sockets. }
  32   TSocket = u_int;
  33 
  34 const
  35   FD_SETSIZE     =   64;
  36 
  37 type
  38   PFDSet = ^TFDSet;
  39   TFDSet = packed record
  40     fd_count: u_int;
  41     fd_array: array[0..FD_SETSIZE-1] of TSocket;
  42   end;
  43 
  44   PTimeVal = ^TTimeVal;
  45   TTimeVal = packed record
  46     tv_sec: Longint;
  47     tv_usec: Longint;
  48   end;
  49 
  50 const
  51   IOCPARM_MASK = $7f;
  52   IOC_VOID     = $20000000;
  53   IOC_OUT      = $40000000;
  54   IOC_IN       = $80000000;
  55   IOC_INOUT    = (IOC_IN or IOC_OUT);
  56 
  57   FIONREAD     = IOC_OUT or { get # bytes to read }
  58     ((Longint(SizeOf(Longint)) and IOCPARM_MASK) shl 16) or
  59     (Longint(Byte('f')) shl 8) or 127;
  60   FIONBIO      = IOC_IN or { set/clear non-blocking i/o }
  61     ((Longint(SizeOf(Longint)) and IOCPARM_MASK) shl 16) or
  62     (Longint(Byte('f')) shl 8) or 126;
  63   FIOASYNC     = IOC_IN or { set/clear async i/o }
  64     ((Longint(SizeOf(Longint)) and IOCPARM_MASK) shl 16) or
  65     (Longint(Byte('f')) shl 8) or 125;
  66 
  67 
  68 const
  69 
  70 { Protocols }
  71 
  72   IPPROTO_IP     =   0;        { Dummy                    }
  73   IPPROTO_ICMP   =   1;        { Internet Control Message Protocol }
  74   IPPROTO_IGMP   =   2;        { Internet Group Management Protocol}
  75   IPPROTO_GGP    =   3;        { Gateway                           }
  76   IPPROTO_TCP    =   6;        { TCP                       }
  77   IPPROTO_PUP    =   12;    { PUP                    }
  78   IPPROTO_UDP    =   17;    { User Datagram Protocol        }
  79   IPPROTO_IDP    =   22;    { XNS IDP                }
  80   IPPROTO_ND     =   77;    { UNOFFICIAL Net Disk Protocol    }
  81 
  82   IPPROTO_RAW    =   255;
  83   IPPROTO_MAX    =   256;
  84 
  85 { Port/socket numbers: network standard functions}
  86 
  87   IPPORT_ECHO    =   7;
  88   IPPORT_DISCARD =   9;
  89   IPPORT_SYSTAT  =   11;
  90   IPPORT_DAYTIME =   13;
  91   IPPORT_NETSTAT =   15;
  92   IPPORT_FTP     =   21;
  93   IPPORT_TELNET  =   23;
  94   IPPORT_SMTP    =   25;
  95   IPPORT_TIMESERVER  =  37;
  96   IPPORT_NAMESERVER  =  42;
  97   IPPORT_WHOIS       =  43;
  98   IPPORT_MTP         =  57;
  99 
 100 { Port/socket numbers: host specific functions }
 101 
 102   IPPORT_TFTP        =  69;
 103   IPPORT_RJE         =  77;
 104   IPPORT_FINGER      =  79;
 105   IPPORT_TTYLINK     =  87;
 106   IPPORT_SUPDUP      =  95;
 107 
 108 { UNIX TCP sockets }
 109   
 110   IPPORT_EXECSERVER  =  512;
 111   IPPORT_LOGINSERVER =  513;
 112   IPPORT_CMDSERVER   =  514;
 113   IPPORT_EFSSERVER   =  520;
 114   
 115 { UNIX UDP sockets }
 116 
 117   IPPORT_BIFFUDP     =  512;
 118   IPPORT_WHOSERVER   =  513;
 119   IPPORT_ROUTESERVER =  520;
 120   
 121 { Ports < IPPORT_RESERVED are reserved for
 122   privileged processes (e.g. root). }
 123 
 124   IPPORT_RESERVED    =  1024;
 125   
 126 { Link numbers }
 127 
 128   IMPLINK_IP         =  155;
 129   IMPLINK_LOWEXPER   =  156;
 130   IMPLINK_HIGHEXPER  =  158;
 131 
 132 type
 133   SunB = packed record
 134     s_b1, s_b2, s_b3, s_b4: u_char;
 135   end;
 136 
 137   SunW = packed record
 138     s_w1, s_w2: u_short;
 139   end;
 140 
 141   PInAddr = ^TInAddr;
 142   TInAddr = packed record
 143     case integer of
 144       0: (S_un_b: SunB);
 145       1: (S_un_w: SunW);
 146       2: (S_addr: u_long);
 147   end;
 148 
 149   PSockAddrIn = ^TSockAddrIn;
 150   TSockAddrIn = packed record
 151     case Integer of
 152       0: (sin_family: u_short;
 153           sin_port: u_short;
 154           sin_addr: TInAddr;
 155           sin_zero: array[0..7] of Char);
 156       1: (sa_family: u_short;
 157           sa_data: array[0..13] of Char)
 158   end;
 159 type
 160   PHostEnt = ^THostEnt;
 161   THostEnt = packed record
 162     h_name: PChar;
 163     h_aliases: ^PChar;
 164     h_addrtype: Smallint;
 165     h_length: Smallint;
 166     case integer of
 167      0: (h_addr_list: ^PChar);
 168      1: (h_addr: ^PInAddr);
 169   end;
 170 
 171   PNetEnt = ^TNetEnt;
 172   TNetEnt = packed record
 173     n_name: PChar;
 174     n_aliases: ^PChar;
 175     n_addrtype: Smallint;
 176     n_net: u_long;
 177   end;
 178 
 179   PServEnt = ^TServEnt;
 180   TServEnt = packed record
 181     s_name: PChar;
 182     s_aliases: ^PChar;
 183     s_port: Smallint;
 184     s_proto: PChar;
 185   end;
 186 
 187   PProtoEnt = ^TProtoEnt;
 188   TProtoEnt = packed record
 189     p_name: PChar;
 190     p_aliases: ^Pchar;
 191     p_proto: Smallint;
 192   end;
 193 
 194 const
 195   INADDR_ANY       = $00000000;
 196   INADDR_LOOPBACK  = $7F000001;
 197   INADDR_BROADCAST = $FFFFFFFF;
 198   INADDR_NONE      = $FFFFFFFF;
 199   
 200   ADDR_ANY         = INADDR_ANY;
 201 
 202 const
 203   WSADESCRIPTION_LEN     =   256;
 204   WSASYS_STATUS_LEN      =   128;
 205 
 206 type
 207   PWSAData = ^TWSAData;
 208   TWSAData = packed record
 209     wVersion: Word;
 210     wHighVersion: Word;
 211     szDescription: array[0..WSADESCRIPTION_LEN] of Char;
 212     szSystemStatus: array[0..WSASYS_STATUS_LEN] of Char;
 213     iMaxSockets: Word;
 214     iMaxUdpDg: Word;
 215     lpVendorInfo: PChar;
 216   end;
 217 
 218   PTransmitFileBuffers = ^TTransmitFileBuffers;
 219   TTransmitFileBuffers = packed record
 220       Head: Pointer;
 221       HeadLength: DWORD;
 222       Tail: Pointer;
 223       TailLength: DWORD;
 224   end;
 225 
 226 const
 227 
 228 { Options for use with [gs]etsockopt at the IP level. }
 229 
 230   IP_OPTIONS          = 1;
 231   IP_MULTICAST_IF     = 2;           { set/get IP multicast interface   }
 232   IP_MULTICAST_TTL    = 3;           { set/get IP multicast timetolive  }
 233   IP_MULTICAST_LOOP   = 4;           { set/get IP multicast loopback    }
 234   IP_ADD_MEMBERSHIP   = 5;           { add  an IP group membership      }
 235   IP_DROP_MEMBERSHIP  = 6;           { drop an IP group membership      }
 236 
 237   IP_DEFAULT_MULTICAST_TTL   = 1;    { normally limit m'casts to 1 hop  }
 238   IP_DEFAULT_MULTICAST_LOOP  = 1;    { normally hear sends if a member  }
 239   IP_MAX_MEMBERSHIPS         = 20;   { per socket; must fit in one mbuf }
 240 
 241 { This is used instead of -1, since the
 242   TSocket type is unsigned.}
 243 
 244   INVALID_SOCKET        = TSocket(NOT(0));
 245   SOCKET_ERROR        = -1;
 246 
 247 { The  following  may  be used in place of the address family, socket type, or
 248   protocol  in  a  call  to WSASocket to indicate that the corresponding value
 249   should  be taken from the supplied WSAPROTOCOL_INFO structure instead of the
 250   parameter itself.
 251  }
 252 
 253   FROM_PROTOCOL_INFO    = -1;
 254 
 255 { Types }
 256 
 257   SOCK_STREAM     = 1;               { stream socket }
 258   SOCK_DGRAM      = 2;               { datagram socket }
 259   SOCK_RAW        = 3;               { raw-protocol interface }
 260   SOCK_RDM        = 4;               { reliably-delivered message }
 261   SOCK_SEQPACKET  = 5;               { sequenced packet stream }
 262 
 263 { Option flags per-socket. }
 264 
 265   SO_DEBUG        = $0001;          { turn on debugging info recording }
 266   SO_ACCEPTCONN   = $0002;          { socket has had listen() }
 267   SO_REUSEADDR    = $0004;          { allow local address reuse }
 268   SO_KEEPALIVE    = $0008;          { keep connections alive }
 269   SO_DONTROUTE    = $0010;          { just use interface addresses }
 270   SO_BROADCAST    = $0020;          { permit sending of broadcast msgs }
 271   SO_USELOOPBACK  = $0040;          { bypass hardware when possible }
 272   SO_LINGER       = $0080;          { linger on close if data present }
 273   SO_OOBINLINE    = $0100;          { leave received OOB data in line }
 274 
 275   SO_DONTLINGER  =   $ff7f;
 276 
 277 { Additional options. }
 278 
 279   SO_SNDBUF       = $1001;          { send buffer size }
 280   SO_RCVBUF       = $1002;          { receive buffer size }
 281   SO_SNDLOWAT     = $1003;          { send low-water mark }
 282   SO_RCVLOWAT     = $1004;          { receive low-water mark }
 283   SO_SNDTIMEO     = $1005;          { send timeout }
 284   SO_RCVTIMEO     = $1006;          { receive timeout }
 285   SO_ERROR        = $1007;          { get error status and clear }
 286   SO_TYPE         = $1008;          { get socket type }
 287 
 288 { Options for connect and disconnect data and options.  Used only by
 289   non-TCP/IP transports such as DECNet, OSI TP4, etc. }
 290 
 291   SO_CONNDATA     = $7000;
 292   SO_CONNOPT      = $7001;
 293   SO_DISCDATA     = $7002;
 294   SO_DISCOPT      = $7003;
 295   SO_CONNDATALEN  = $7004;
 296   SO_CONNOPTLEN   = $7005;
 297   SO_DISCDATALEN  = $7006;
 298   SO_DISCOPTLEN   = $7007;
 299 
 300 { WinSock 2 extension -- new options }
 301  
 302   SO_GROUP_ID       = $2001; { ID of a socket group}
 303   SO_GROUP_PRIORITY = $2002; { the relative priority within a group}
 304   SO_MAX_MSG_SIZE   = $2003; { maximum message size }
 305   SO_PROTOCOL_INFOA = $2004; { WSAPROTOCOL_INFOA structure }
 306   SO_PROTOCOL_INFOW = $2005; { WSAPROTOCOL_INFOW structure }
 307 
 308 {$IFDEF UNICODE }
 309   SO_PROTOCOL_INFO  = SO_PROTOCOL_INFOW;
 310 {$ELSE }
 311   SO_PROTOCOL_INFO  = SO_PROTOCOL_INFOA;
 312 {$ENDIF UNICODE }
 313   PVD_CONFIG        = $3001; {configuration info for service provider }
 314 
 315 { Option for opening sockets for synchronous access. }
 316 
 317   SO_OPENTYPE     = $7008;
 318 
 319   SO_SYNCHRONOUS_ALERT    = $10;
 320   SO_SYNCHRONOUS_NONALERT = $20;
 321 
 322 { Other NT-specific options. }
 323 
 324   SO_MAXDG        = $7009;
 325   SO_MAXPATHDG    = $700A;
 326 
 327 { TCP options. }
 328 
 329   TCP_NODELAY     = $0001;
 330   TCP_BSDURGENT   = $7000;
 331 
 332 { Address families. }
 333 
 334   AF_UNSPEC       = 0;               { unspecified }
 335   AF_UNIX         = 1;               { local to host (pipes, portals) }
 336   AF_INET         = 2;               { internetwork: UDP, TCP, etc. }
 337   AF_IMPLINK      = 3;               { arpanet imp addresses }
 338   AF_PUP          = 4;               { pup protocols: e.g. BSP }
 339   AF_CHAOS        = 5;               { mit CHAOS protocols }
 340   AF_IPX          = 6;               { IPX and SPX }
 341   AF_NS           = 6;               { XEROX NS protocols }
 342   AF_ISO          = 7;               { ISO protocols }
 343   AF_OSI          = AF_ISO;          { OSI is ISO }
 344   AF_ECMA         = 8;               { european computer manufacturers }
 345   AF_DATAKIT      = 9;               { datakit protocols }
 346   AF_CCITT        = 10;              { CCITT protocols, X.25 etc }
 347   AF_SNA          = 11;              { IBM SNA }
 348   AF_DECnet       = 12;              { DECnet }
 349   AF_DLI          = 13;              { Direct data link interface }
 350   AF_LAT          = 14;              { LAT }
 351   AF_HYLINK       = 15;              { NSC Hyperchannel }
 352   AF_APPLETALK    = 16;              { AppleTalk }
 353   AF_NETBIOS      = 17;              { NetBios-style addresses }
 354   AF_VOICEVIEW    = 18;              { VoiceView }
 355   AF_FIREFOX      = 19;              { FireFox }
 356   AF_UNKNOWN1     = 20;              { Somebody is using this! }
 357   AF_BAN          = 21;              { Banyan }
 358   AF_ATM          = 22;              { Native ATM Services }
 359   AF_INET6        = 23;              { Internetwork Version 6 }
 360 
 361   AF_MAX          = 24;
 362 
 363 type
 364   { Structure used by kernel to store most addresses. }
 365 
 366   PSockAddr = ^TSockAddr;
 367   TSockAddr = TSockAddrIn;
 368 
 369   { Structure used by kernel to pass protocol information in raw sockets. }
 370   PSockProto = ^TSockProto;
 371   TSockProto = packed record
 372     sp_family: u_short;
 373     sp_protocol: u_short;
 374   end;
 375 
 376 const
 377 { Protocol families, same as address families for now. }
 378 
 379   PF_UNSPEC       = AF_UNSPEC;
 380   PF_UNIX         = AF_UNIX;
 381   PF_INET         = AF_INET;
 382   PF_IMPLINK      = AF_IMPLINK;
 383   PF_PUP          = AF_PUP;
 384   PF_CHAOS        = AF_CHAOS;
 385   PF_NS           = AF_NS;
 386   PF_IPX          = AF_IPX;
 387   PF_ISO          = AF_ISO;
 388   PF_OSI          = AF_OSI;
 389   PF_ECMA         = AF_ECMA;
 390   PF_DATAKIT      = AF_DATAKIT;
 391   PF_CCITT        = AF_CCITT;
 392   PF_SNA          = AF_SNA;
 393   PF_DECnet       = AF_DECnet;
 394   PF_DLI          = AF_DLI;
 395   PF_LAT          = AF_LAT;
 396   PF_HYLINK       = AF_HYLINK;
 397   PF_APPLETALK    = AF_APPLETALK;
 398   PF_VOICEVIEW    = AF_VOICEVIEW;
 399   PF_FIREFOX      = AF_FIREFOX;
 400   PF_UNKNOWN1     = AF_UNKNOWN1;
 401   PF_BAN          = AF_BAN;
 402   PF_ATM          = AF_ATM;
 403   PF_INET6        = AF_INET6;
 404 
 405   PF_MAX          = AF_MAX;
 406 
 407 type
 408 { Structure used for manipulating linger option. }
 409   PLinger = ^TLinger;
 410   TLinger = packed record
 411     l_onoff: u_short;
 412     l_linger: u_short;
 413   end;
 414 
 415 const
 416 { Level number for (get/set)sockopt() to apply to socket itself. }
 417 
 418   SOL_SOCKET      = $ffff;          {options for socket level }
 419 
 420 { Maximum queue length specifiable by listen. }
 421 
 422   SOMAXCONN       = $7fffffff;      { AHS - by硂 5 !?????? }
 423 
 424   MSG_OOB         = $1;             {process out-of-band data }
 425   MSG_PEEK        = $2;             {peek at incoming message }
 426   MSG_DONTROUTE   = $4;             {send without using routing tables }
 427 
 428   MSG_MAXIOVLEN   = 16;
 429 
 430   MSG_PARTIAL     = $8000;          {partial send or recv for message xport }
 431 
 432 { WinSock 2 extension -- new flags for WSASend(), WSASendTo(), WSARecv() and
 433   WSARecvFrom() }
 434 
 435   MSG_INTERRUPT   = $10;            {send/recv in the interrupt context}
 436 
 437 { Define constant based on rfc883, used by gethostbyxxxx() calls. }
 438 
 439   MAXGETHOSTSTRUCT        = 1024;
 440 
 441 { Define flags to be used with the WSAAsyncSelect() call. }
 442 
 443   FD_READ         = $01;
 444   FD_WRITE        = $02;
 445   FD_OOB          = $04;
 446   FD_ACCEPT       = $08;
 447   FD_CONNECT      = $10;
 448   FD_CLOSE        = $20;
 449   FD_QOS          = $40;
 450   FD_GROUP_QOS    = $80;
 451   FD_MAX_EVENTS    = 8;
 452   FD_ALL_EVENTS    = $100; { AHS - trudno powiedzie? ile powinno by?}
 453 
 454 { All Windows Sockets error constants are biased by WSABASEERR from the "normal" }
 455 
 456   WSABASEERR              = 10000;
 457 
 458 { Windows Sockets definitions of regular Microsoft C error constants }
 459 
 460   WSAEINTR                = (WSABASEERR+4);
 461   WSAEBADF                = (WSABASEERR+9);
 462   WSAEACCES               = (WSABASEERR+13);
 463   WSAEFAULT               = (WSABASEERR+14);
 464   WSAEINVAL               = (WSABASEERR+22);
 465   WSAEMFILE               = (WSABASEERR+24);
 466 
 467 { Windows Sockets definitions of regular Berkeley error constants }
 468 
 469   WSAEWOULDBLOCK          = (WSABASEERR+35);
 470   WSAEINPROGRESS          = (WSABASEERR+36);
 471   WSAEALREADY             = (WSABASEERR+37);
 472   WSAENOTSOCK             = (WSABASEERR+38);
 473   WSAEDESTADDRREQ         = (WSABASEERR+39);
 474   WSAEMSGSIZE             = (WSABASEERR+40);
 475   WSAEPROTOTYPE           = (WSABASEERR+41);
 476   WSAENOPROTOOPT          = (WSABASEERR+42);
 477   WSAEPROTONOSUPPORT      = (WSABASEERR+43);
 478   WSAESOCKTNOSUPPORT      = (WSABASEERR+44);
 479   WSAEOPNOTSUPP           = (WSABASEERR+45);
 480   WSAEPFNOSUPPORT         = (WSABASEERR+46);
 481   WSAEAFNOSUPPORT         = (WSABASEERR+47);
 482   WSAEADDRINUSE           = (WSABASEERR+48);
 483   WSAEADDRNOTAVAIL        = (WSABASEERR+49);
 484   WSAENETDOWN             = (WSABASEERR+50);
 485   WSAENETUNREACH          = (WSABASEERR+51);
 486   WSAENETRESET            = (WSABASEERR+52);
 487   WSAECONNABORTED         = (WSABASEERR+53);
 488   WSAECONNRESET           = (WSABASEERR+54);
 489   WSAENOBUFS              = (WSABASEERR+55);
 490   WSAEISCONN              = (WSABASEERR+56);
 491   WSAENOTCONN             = (WSABASEERR+57);
 492   WSAESHUTDOWN            = (WSABASEERR+58);
 493   WSAETOOMANYREFS         = (WSABASEERR+59);
 494   WSAETIMEDOUT            = (WSABASEERR+60);
 495   WSAECONNREFUSED         = (WSABASEERR+61);
 496   WSAELOOP                = (WSABASEERR+62);
 497   WSAENAMETOOLONG         = (WSABASEERR+63);
 498   WSAEHOSTDOWN            = (WSABASEERR+64);
 499   WSAEHOSTUNREACH         = (WSABASEERR+65);
 500   WSAENOTEMPTY            = (WSABASEERR+66);
 501   WSAEPROCLIM             = (WSABASEERR+67);
 502   WSAEUSERS               = (WSABASEERR+68);
 503   WSAEDQUOT               = (WSABASEERR+69);
 504   WSAESTALE               = (WSABASEERR+70);
 505   WSAEREMOTE              = (WSABASEERR+71);
 506 
 507 { Extended Windows Sockets error constant definitions }
 508 
 509   WSASYSNOTREADY          = (WSABASEERR+91);
 510   WSAVERNOTSUPPORTED      = (WSABASEERR+92);
 511   WSANOTINITIALISED       = (WSABASEERR+93);
 512   WSAEDISCON              = (WSABASEERR+101);
 513   WSAENOMORE              = (WSABASEERR+102);
 514   WSAECANCELLED           = (WSABASEERR+103);
 515   WSAEEINVALIDPROCTABLE   = (WSABASEERR+104);
 516   WSAEINVALIDPROVIDER     = (WSABASEERR+105);
 517   WSAEPROVIDERFAILEDINIT  = (WSABASEERR+106);
 518   WSASYSCALLFAILURE       = (WSABASEERR+107);
 519   WSASERVICE_NOT_FOUND    = (WSABASEERR+108);
 520   WSATYPE_NOT_FOUND       = (WSABASEERR+109);
 521   WSA_E_NO_MORE           = (WSABASEERR+110);
 522   WSA_E_CANCELLED         = (WSABASEERR+111);
 523   WSAEREFUSED             = (WSABASEERR+112);
 524 
 525 { Error return codes from gethostbyname() and gethostbyaddr()
 526   (when using the resolver). Note that these errors are
 527   retrieved via WSAGetLastError() and must therefore follow
 528   the rules for avoiding *****es with error numbers from
 529   specific implementations or language run-time systems.
 530   For this reason the codes are based at WSABASEERR+1001.
 531   Note also that [WSA]NO_ADDRESS is defined only for
 532   compatibility purposes. }
 533 
 534 { Authoritative Answer: Host not found }
 535 
 536   WSAHOST_NOT_FOUND       = (WSABASEERR+1001);
 537   HOST_NOT_FOUND          = WSAHOST_NOT_FOUND;
 538 
 539 { Non-Authoritative: Host not found, or SERVERFAIL }
 540 
 541   WSATRY_AGAIN            = (WSABASEERR+1002);
 542   TRY_AGAIN               = WSATRY_AGAIN;
 543 
 544 { Non recoverable errors, FORMERR, REFUSED, NOTIMP }
 545 
 546   WSANO_RECOVERY          = (WSABASEERR+1003);
 547   NO_RECOVERY             = WSANO_RECOVERY;
 548 
 549 { Valid name, no data record of requested type }
 550 
 551   WSANO_DATA              = (WSABASEERR+1004);
 552   NO_DATA                 = WSANO_DATA;
 553 
 554 { no address, look for MX record }
 555 
 556   WSANO_ADDRESS           = WSANO_DATA;
 557   NO_ADDRESS              = WSANO_ADDRESS;
 558 
 559 { Windows Sockets errors redefined as regular Berkeley error constants.
 560   These are commented out in Windows NT to avoid conflicts with errno.h.
 561   Use the WSA constants instead. }
 562 
 563   EWOULDBLOCK        =  WSAEWOULDBLOCK;
 564   EINPROGRESS        =  WSAEINPROGRESS;
 565   EALREADY           =  WSAEALREADY;
 566   ENOTSOCK           =  WSAENOTSOCK;
 567   EDESTADDRREQ       =  WSAEDESTADDRREQ;
 568   EMSGSIZE           =  WSAEMSGSIZE;
 569   EPROTOTYPE         =  WSAEPROTOTYPE;
 570   ENOPROTOOPT        =  WSAENOPROTOOPT;
 571   EPROTONOSUPPORT    =  WSAEPROTONOSUPPORT;
 572   ESOCKTNOSUPPORT    =  WSAESOCKTNOSUPPORT;
 573   EOPNOTSUPP         =  WSAEOPNOTSUPP;
 574   EPFNOSUPPORT       =  WSAEPFNOSUPPORT;
 575   EAFNOSUPPORT       =  WSAEAFNOSUPPORT;
 576   EADDRINUSE         =  WSAEADDRINUSE;
 577   EADDRNOTAVAIL      =  WSAEADDRNOTAVAIL;
 578   ENETDOWN           =  WSAENETDOWN;
 579   ENETUNREACH        =  WSAENETUNREACH;
 580   ENETRESET          =  WSAENETRESET;
 581   ECONNABORTED       =  WSAECONNABORTED;
 582   ECONNRESET         =  WSAECONNRESET;
 583   ENOBUFS            =  WSAENOBUFS;
 584   EISCONN            =  WSAEISCONN;
 585   ENOTCONN           =  WSAENOTCONN;
 586   ESHUTDOWN          =  WSAESHUTDOWN;
 587   ETOOMANYREFS       =  WSAETOOMANYREFS;
 588   ETIMEDOUT          =  WSAETIMEDOUT;
 589   ECONNREFUSED       =  WSAECONNREFUSED;
 590   ELOOP              =  WSAELOOP;
 591   ENAMETOOLONG       =  WSAENAMETOOLONG;
 592   EHOSTDOWN          =  WSAEHOSTDOWN;
 593   EHOSTUNREACH       =  WSAEHOSTUNREACH;
 594   ENOTEMPTY          =  WSAENOTEMPTY;
 595   EPROCLIM           =  WSAEPROCLIM;
 596   EUSERS             =  WSAEUSERS;
 597   EDQUOT             =  WSAEDQUOT;
 598   ESTALE             =  WSAESTALE;
 599   EREMOTE            =  WSAEREMOTE;
 600 
 601 { AHS }
 602 { WinSock 2 extension -- new error codes and type definition }
 603 
 604 type
 605   WSAEVENT                = THANDLE;
 606   LPHANDLE                = PHANDLE;
 607   LPWSAEVENT              = LPHANDLE;
 608   WSAOVERLAPPED           = TOVERLAPPED;
 609   LPWSAOVERLAPPED         = POverlapped;
 610 
 611 const
 612 
 613   WSA_IO_PENDING          = ERROR_IO_PENDING;
 614   WSA_IO_INCOMPLETE       = ERROR_IO_INCOMPLETE;
 615   WSA_INVALID_HANDLE      = ERROR_INVALID_HANDLE;
 616   WSA_INVALID_PARAMETER   = ERROR_INVALID_PARAMETER;
 617   WSA_NOT_ENOUGH_MEMORY   = ERROR_NOT_ENOUGH_MEMORY;
 618   WSA_OPERATION_ABORTED   = ERROR_OPERATION_ABORTED;
 619 
 620   WSA_INVALID_EVENT       = WSAEVENT(NiL);
 621   WSA_MAXIMUM_WAIT_EVENTS = MAXIMUM_WAIT_OBJECTS;
 622   WSA_WAIT_FAILED         = DWORD($FFFFFFFF); { ahs }
 623   WSA_WAIT_EVENT_0        = WAIT_OBJECT_0;
 624   WSA_WAIT_IO_COMPLETION  = WAIT_IO_COMPLETION;
 625   WSA_WAIT_TIMEOUT        = WAIT_TIMEOUT;
 626   WSA_INFINITE            = INFINITE;
 627 
 628 
 629 { WinSock 2 extension -- WSABUF and QOS struct }
 630 
 631 type
 632 
 633 PWSABUF = ^TWSABUF;
 634 TWSABUF = packed record
 635   len                : u_long;     { the length of the buffer }
 636   buf                : Pointer; //PChar;     { the pointer to the buffer }
 637 end;
 638 
 639 GUARANTEE = (
 640     BestEffortService,
 641     ControlledLoadService,
 642     PredictiveService,
 643     GuaranteedDelayService,
 644     GuaranteedService
 645 );
 646 
 647 PFlowspec = ^TFlowspec;
 648 TFlowspec = packed record
 649   TokenRate             : LongInt;        { In Bytes/sec }
 650   TokenBucketSize       : LongInt;        { In Bytes }
 651   PeakBandwidth         : LongInt;        { In Bytes/sec }
 652   Latency               : LongInt;        { In microseconds }
 653   DelayVariation        : LongInt;        { In microseconds }
 654   LevelOfGuarantee      : Guarantee;      { Guaranteed, Predictive }
 655                                           { or Best Effort       }
 656   CostOfCall            : LongInt;        { Reserved for future use, }
 657                                           { must be set to 0 now   }
 658   NetworkAvailability   : LongInt;        { read-only:         }
 659                                           {   1 if accessible, }
 660                                           {   0 if not         }
 661 end;
 662 
 663 PQOS = ^TQualityOfService;
 664 TQualityOfService = packed record
 665   SendingFlowspec       :TFlowspec;    { the flow spec for data sending }
 666   ReceivingFlowspec     :TFlowspec;    { the flow spec for data receiving }
 667   ProviderSpecific      :TWSABuf;      { additional provider specific stuff }
 668 end;
 669 
 670 const
 671 
 672 { WinSock 2 extension -- manifest constants for return values of the
 673   condition function}
 674 
 675   CF_ACCEPT       = $0000;
 676   CF_REJECT       = $0001;
 677   CF_DEFER        = $0002;
 678 
 679 {WinSock 2 extension -- manifest constants for shutdown() }
 680 
 681   SD_RECEIVE      = $00;
 682   SD_SEND         = $01;
 683   SD_BOTH         = $02;
 684 
 685 { WinSock 2 extension -- data type and manifest constants for socket groups }
 686 type
 687 
 688   TGroup            = u_int;
 689   PGroup           = ^TGroup;
 690 
 691 const
 692   
 693   SG_UNCONSTRAINED_GROUP   = $01;
 694   SG_CONSTRAINED_GROUP     = $02;
 695 
 696 { WinSock 2 extension -- data type for WSAEnumNetworkEvents() }
 697 
 698 type
 699 
 700 PWSANETWORKEVENTS = ^TWSANETWORKEVENTS;
 701 TWSANETWORKEVENTS = packed record
 702   lNetworkEvents           :u_long;
 703   iErrorCode               : array [0..FD_MAX_EVENTS-1] of u_int;
 704 end;
 705 
 706 {WinSock 2 extension -- WSAPROTOCOL_INFO structure and associated
 707  manifest constants}
 708 
 709 PGUID = ^TGUID;
 710 TGUID = packed record
 711   Data1              :u_long;
 712   Data2              :u_short;
 713   Data3              :u_short;
 714   Data4              : array [0..8-1] of u_char;
 715 end;
 716 
 717 const
 718 
 719   MAX_PROTOCOL_CHAIN  = 7;
 720 
 721   BASE_PROTOCOL       = 1;
 722   LAYERED_PROTOCOL    = 0;
 723 
 724 type
 725 
 726 PWSAPROTOCOLCHAIN = ^TWSAPROTOCOLCHAIN;
 727 TWSAPROTOCOLCHAIN = packed record
 728   ChainLen        : Integer;            { the length of the chain,     }
 729                                         { length = 0 means layered protocol, }
 730                                         { length = 1 means base protocol, }
 731                                         { length > 1 means protocol chain }
 732   ChainEntries : array[0..MAX_PROTOCOL_CHAIN-1] of DWORD; { a list of dwCatalogEntryIds }
 733 end;
 734 
 735 const
 736 
 737   WSAPROTOCOL_LEN    = 255;
 738 
 739 type
 740   
 741 PWSAPROTOCOL_INFOA = ^TWSAPROTOCOL_INFOA;
 742 TWSAPROTOCOL_INFOA = packed record
 743   dwServiceFlags1           : DWORD;
 744   dwServiceFlags2           : DWORD;
 745   dwServiceFlags3           : DWORD;
 746   dwServiceFlags4           : DWORD;
 747   dwProviderFlags           : DWORD;
 748   ProviderId                : TGUID;
 749   dwCatalogEntryId          : DWORD;
 750   ProtocolChain             : TWSAPROTOCOLCHAIN;
 751   iVersion                  : u_int;
 752   iAddressFamily            : u_int;
 753   iMaxSockAddr              : u_int;
 754   iMinSockAddr              : u_int;
 755   iSocketType               : u_int;
 756   iProtocol                 : u_int;
 757   iProtocolMaxOffset        : u_int;
 758   iNetworkByteOrder         : u_int;
 759   iSecurityScheme           : u_int;
 760   dwMessageSize            : DWORD;
 761   dwProviderReserved       : DWORD;
 762   szProtocol               : array [0..WSAPROTOCOL_LEN+1-1] of u_char;
 763 end;
 764 
 765 PWSAPROTOCOL_INFOW = ^TWSAPROTOCOL_INFOW;
 766 TWSAPROTOCOL_INFOW = packed record
 767   dwServiceFlags1           : DWORD;
 768   dwServiceFlags2           : DWORD;
 769   dwServiceFlags3           : DWORD;
 770   dwServiceFlags4           : DWORD;
 771   dwProviderFlags           : DWORD;
 772   ProviderId                : TGUID;
 773   dwCatalogEntryId          : DWORD;
 774   ProtocolChain             : TWSAPROTOCOLCHAIN;
 775   iVersion                  : u_int;
 776   iAddressFamily            : u_int;
 777   iMaxSockAddr              : u_int;
 778   iMinSockAddr              : u_int;
 779   iSocketType               : u_int;
 780   iProtocol                 : u_int;
 781   iProtocolMaxOffset        : u_int;
 782   iNetworkByteOrder         : u_int;
 783   iSecurityScheme           : u_int;
 784   dwMessageSize            : DWORD;
 785   dwProviderReserved       : DWORD;
 786   szProtocol               : array [0..WSAPROTOCOL_LEN+1-1] of WCHAR;
 787 end;
 788 
 789 {$ifdef UNICODE}
 790 
 791 TWSAPROTOCOL_INFO   = TWSAPROTOCOL_INFOW ;
 792 PWSAPROTOCOL_INFO =  PWSAPROTOCOL_INFOW ;
 793 
 794 {$else}
 795 
 796 TWSAPROTOCOL_INFO   = TWSAPROTOCOL_INFOA ;
 797 PWSAPROTOCOL_INFO =  PWSAPROTOCOL_INFOA ;
 798 
 799 {$endif UNICODE}
 800 
 801 const
 802 { Flag bit definitions for dwProviderFlags }
 803 
 804   PFL_MULTIPLE_PROTO_ENTRIES          =$00000001;
 805   PFL_RECOMMENDED_PROTO_ENTRY         =$00000002;
 806   PFL_HIDDEN                          =$00000004;
 807   PFL_MATCHES_PROTOCOL_ZERO           =$00000008;
 808 
 809 { Flag bit definitions for dwServiceFlags1 }
 810   XP1_CONNECTIONLESS                  =$00000001;
 811   XP1_GUARANTEED_DELIVERY             =$00000002;
 812   XP1_GUARANTEED_ORDER                =$00000004;
 813   XP1_MESSAGE_ORIENTED                =$00000008;
 814   XP1_PSEUDO_STREAM                   =$00000010;
 815   XP1_GRACEFUL_CLOSE                  =$00000020;
 816   XP1_EXPEDITED_DATA                  =$00000040;
 817   XP1_CONNECT_DATA                    =$00000080;
 818   XP1_DISCONNECT_DATA                 =$00000100;
 819   XP1_SUPPORT_BROADCAST               =$00000200;
 820   XP1_SUPPORT_MULTIPOINT              =$00000400;
 821   XP1_MULTIPOINT_CONTROL_PLANE        =$00000800;
 822   XP1_MULTIPOINT_DATA_PLANE           =$00001000;
 823   XP1_QOS_SUPPORTED                   =$00002000;
 824   XP1_INTERRUPT                       =$00004000;
 825   XP1_UNI_SEND                        =$00008000;
 826   XP1_UNI_RECV                        =$00010000;
 827   XP1_IFS_HANDLES                     =$00020000;
 828   XP1_PARTIAL_MESSAGE                 =$00040000;
 829 
 830   BIGENDIAN                           =$0000;
 831   LITTLEENDIAN                        =$0001;
 832 
 833   SECURITY_PROTOCOL_NONE              =$0000;
 834 
 835 { WinSock 2 extension -- manifest constants for WSAJoinLeaf() }
 836 
 837   JL_SENDER_ONLY    =$01;
 838   JL_RECEIVER_ONLY  =$02;
 839   JL_BOTH           =$04;
 840 
 841 { WinSock 2 extension -- manifest constants for WSASocket() }
 842 
 843   WSA_FLAG_OVERLAPPED           =$01;
 844   WSA_FLAG_MULTIPOINT_C_ROOT    =$02;
 845   WSA_FLAG_MULTIPOINT_C_LEAF    =$04;
 846   WSA_FLAG_MULTIPOINT_D_ROOT    =$08;
 847   WSA_FLAG_MULTIPOINT_D_LEAF    =$10;
 848 
 849 { WinSock 2 extension -- manifest constants for WSAIoctl() }
 850 
 851   IOC_UNIX                      =$00000000;
 852   IOC_WS2                       =$08000000;
 853   IOC_PROTOCOL                  =$10000000;
 854   IOC_VENDOR                    =$18000000;
 855 
 856   SIO_ASSOCIATE_HANDLE           = IOC_IN or IOC_WS2 or 1;
 857   SIO_ENABLE_CIRCULAR_QUEUEING   = IOC_VOID or IOC_WS2 or 2;
 858   SIO_FIND_ROUTE                 = IOC_OUT or IOC_WS2 or 3;
 859   SIO_FLUSH                      = IOC_VOID or IOC_WS2 or 4;
 860   SIO_GET_BROADCAST_ADDRESS      = IOC_OUT or IOC_WS2 or 5;
 861   SIO_GET_EXTENSION_FUNCTION_POINTER  = IOC_INOUT or IOC_WS2 or 6;
 862   SIO_GET_QOS                    = IOC_INOUT or IOC_WS2 or 7;
 863   SIO_GET_GROUP_QOS              = IOC_INOUT or IOC_WS2 or 8;
 864   SIO_MULTIPOINT_LOOPBACK        = IOC_IN or IOC_WS2 or 9;
 865   SIO_MULTICAST_SCOPE            = IOC_IN or IOC_WS2 or 10;
 866   SIO_SET_QOS                    = IOC_IN or IOC_WS2 or 11;
 867   SIO_SET_GROUP_QOS              = IOC_IN or IOC_WS2 or 12;
 868   SIO_TRANSLATE_HANDLE           = IOC_INOUT or IOC_WS2 or 13;
 869 
 870 { WinSock 2 extension -- manifest constants for SIO_TRANSLATE_HANDLE ioctl }
 871 
 872   TH_NETDEV        = $00000001;
 873   TH_TAPI          = $00000002;
 874 
 875 {  Microsoft Windows Extended data types required for the functions to
 876    convert   back  and  forth  between  binary  and  string  forms  of
 877    addresses. }
 878 
 879 type
 880 
 881   SOCKADDR     = TSockAddr; { AHS ?}
 882 {  PSOCKADDR    = PSockaddr;}
 883   LPSOCKADDR   = PSockaddr;
 884 
 885 { Manifest constants and type definitions related to name resolution and
 886   registration (RNR) API }
 887 
 888 PBLOB = ^TBLOB;
 889 TBLOB = packed record
 890     cbSize    :ULONG;
 891     pBlobData :^byte;
 892 end;
 893 
 894 { Service Install Flags }
 895 
 896 const
 897 
 898   SERVICE_MULTIPLE       =$00000001;
 899 
 900 { Name Spaces }
 901 
 902   NS_ALL                      = 0;
 903 
 904   NS_SAP                      = 1;
 905   NS_NDS                      = 2;
 906   NS_PEER_BROWSE              = 3;
 907 
 908   NS_TCPIP_LOCAL              = 10;
 909   NS_TCPIP_HOSTS              = 11;
 910   NS_DNS                      = 12;
 911   NS_NETBT                    = 13;
 912   NS_WINS                     = 14;
 913 
 914   NS_NBP                      = 20;
 915 
 916   NS_MS                       = 30;
 917   NS_STDA                     = 31;
 918   NS_NTDS                     = 32;
 919 
 920   NS_X500                     = 40;
 921   NS_NIS                      = 41;
 922   NS_NISPLUS                  = 42;
 923 
 924   NS_WRQ                      = 50;
 925 
 926 
 927 {  Resolution flags for WSAGetAddressByName().
 928    Note these are also used by the 1.1 API GetAddressByName, so
 929    leave them around. }
 930 
 931   RES_UNUSED_1                =$00000001;
 932   RES_FLUSH_CACHE             =$00000002;
 933   RES_SERVICE                 =$00000004;
 934 
 935 
 936 { Well known value names for Service Types }
 937 
 938   SERVICE_TYPE_VALUE_IPXPORTA     ='IpxSocket';
 939   SERVICE_TYPE_VALUE_IPXPORTW     = 'IpxSocket';
 940   SERVICE_TYPE_VALUE_SAPIDA       = 'SapId';
 941   SERVICE_TYPE_VALUE_SAPIDW       ='SapId';
 942 
 943   SERVICE_TYPE_VALUE_TCPPORTA     = 'TcpPort';
 944   SERVICE_TYPE_VALUE_TCPPORTW     ='TcpPort';
 945 
 946   SERVICE_TYPE_VALUE_UDPPORTA     = 'UdpPort';
 947   SERVICE_TYPE_VALUE_UDPPORTW     ='UdpPort';
 948 
 949   SERVICE_TYPE_VALUE_OBJECTIDA    = 'ObjectId';
 950   SERVICE_TYPE_VALUE_OBJECTIDW    ='ObjectId';
 951 
 952 {$ifdef UNICODE}
 953 
 954   SERVICE_TYPE_VALUE_SAPID        =SERVICE_TYPE_VALUE_SAPIDW;
 955   SERVICE_TYPE_VALUE_TCPPORT      =SERVICE_TYPE_VALUE_TCPPORTW;
 956   SERVICE_TYPE_VALUE_UDPPORT      =SERVICE_TYPE_VALUE_UDPPORTW;
 957   SERVICE_TYPE_VALUE_OBJECTID     =SERVICE_TYPE_VALUE_OBJECTIDW;
 958 
 959 {$else} { not UNICODE }
 960 
 961   SERVICE_TYPE_VALUE_SAPID        =SERVICE_TYPE_VALUE_SAPIDA;
 962   SERVICE_TYPE_VALUE_TCPPORT      =SERVICE_TYPE_VALUE_TCPPORTA;
 963   SERVICE_TYPE_VALUE_UDPPORT      =SERVICE_TYPE_VALUE_UDPPORTA;
 964   SERVICE_TYPE_VALUE_OBJECTID     =SERVICE_TYPE_VALUE_OBJECTIDA;
 965 
 966 {$endif}
 967 
 968 { SockAddr Information }
 969 type
 970 
 971 PSOCKET_ADDRESS = ^TSOCKET_ADDRESS;
 972 TSOCKET_ADDRESS = packed record
 973     lpSockaddr        :  PSOCKADDR ;
 974     iSockaddrLength   : u_int;
 975 end;
 976 
 977 { CSAddr Information }
 978 
 979 PCSADDR_INFO = ^TCSADDR_INFO;
 980 TCSADDR_INFO = packed record
 981     LocalAddr         :TSOCKET_ADDRESS;
 982     RemoteAddr        :TSOCKET_ADDRESS;
 983     iSocketType       :u_int;
 984     iProtocol         :u_int;
 985 end;
 986 
 987 
 988 { Address Family/Protocol Tuples }
 989 
 990 PAFPROTOCOLS = ^TAFPROTOCOLS;
 991 TAFPROTOCOLS = packed record
 992   iAddressFamily      :u_int;
 993   iProtocol           :u_int;
 994 end;
 995 
 996 { Client Query API Typedefs }
 997 
 998 { The comparators }
 999 
1000 PWSAEcomparator = ^TWSAEcomparator;
1001 TWSAEcomparator = (
1002     COMP_EQUAL,
1003     COMP_NOTLESS
1004 );
1005 
1006 PWSAVersion = ^TWSAVersion;
1007 TWSAVersion = packed record
1008     dwVersion        : Dword;
1009     ecHow            : TWSAEComparator;
1010 end;
1011 
1012 PWSAQuerySetA = ^TWSAQuerySetA;
1013 TWSAQuerySetA = packed record
1014     dwSize                  : DWord;
1015     lpszServiceInstanceName : PChar;
1016     lpServiceClassId        : PGUID;
1017     lpVersion               : PWSAVERSION;
1018     lpszComment             : PChar;
1019     dwNameSpace             : DWord;
1020     lpNSProviderId          : PGUID;
1021     lpszContext             : PChar;
1022     dwNumberOfProtocols     : DWORD;
1023     lpafpProtocols          : PAFPROTOCOLS;
1024     lpszQueryString         : PChar;
1025     dwNumberOfCsAddrs       : Dword;
1026     lpcsaBuffer             : PCSADDR_INFO;
1027     dwOutputFlags           : DWord;
1028     lpBlob                  : PBLOB;
1029 end;
1030 
1031 PWSAQuerySetW = ^TWSAQuerySetW;
1032 TWSAQuerySetW = packed record
1033     dwSize                  : DWord;
1034     lpszServiceInstanceName : PWideChar;                        //MIO, antes WideChar
1035     lpServiceClassId        : PGUID;
1036     lpVersion               : PWSAVERSION;
1037     lpszComment             : PWideChar;                         //MIO, antes WideChar
1038     dwNameSpace             : DWord;
1039     lpNSProviderId          : PGUID;
1040     lpszContext             : PWideChar;                         //MIO, antes WideChar
1041     dwNumberOfProtocols     : DWORD;
1042     lpafpProtocols          : PAFPROTOCOLS;
1043     lpszQueryString         : PWideChar;                        //MIO, antes WideChar
1044     dwNumberOfCsAddrs       : Dword;
1045     lpcsaBuffer             : PCSADDR_INFO;
1046     dwOutputFlags           : DWord;
1047     lpBlob                  : PBLOB;
1048 end;
1049 
1050 {$ifdef UNICODE}
1051 
1052   WSAQUERYSET              = TWSAQUERYSETW;
1053   PWSAQUERYSET             = PWSAQUERYSETW;
1054 
1055 {$else}
1056 
1057   WSAQUERYSET              = TWSAQUERYSETA;
1058   PWSAQUERYSET             = PWSAQUERYSETA;
1059 
1060 {$endif }
1061 
1062 const
1063 
1064   LUP_DEEP                = $0001;
1065   LUP_CONTAINERS          = $0002;
1066   LUP_NOCONTAINERS        = $0004;
1067   LUP_NEAREST             = $0008;
1068   LUP_RETURN_NAME         = $0010;
1069   LUP_RETURN_TYPE         = $0020;
1070   LUP_RETURN_VERSION      = $0040;
1071   LUP_RETURN_COMMENT      = $0080;
1072   LUP_RETURN_ADDR         = $0100;
1073   LUP_RETURN_BLOB         = $0200;
1074   LUP_RETURN_ALIASES      = $0400;
1075   LUP_RETURN_QUERY_STRING = $0800;
1076   LUP_RETURN_ALL          = $0FF0;
1077   LUP_RES_SERVICE         = $8000;
1078 
1079   LUP_FLUSHCACHE       = $1000;
1080   LUP_FLUSHPREVIOUS    = $2000;
1081 
1082 
1083 { Return flags }
1084 
1085   RESULT_IS_ALIAS      = $0001;
1086 
1087 { Service Address Registration and Deregistration Data Types. }
1088 
1089 type
1090 
1091 PWSAESETSERVICEOP = ^TWSAESETSERVICEOP;
1092 TWSAESETSERVICEOP = (
1093     RNRSERVICE_REGISTER,
1094     RNRSERVICE_DEREGISTER,
1095     RNRSERVICE_DELETE
1096 );
1097 
1098 { Service Installation/Removal Data Types. }
1099 
1100 PWSANSClassInfoA = ^TWSANSClassInfoA;
1101 TWSANSClassInfoA = packed record
1102   lpszName         : PChar;
1103   dwNameSpace      : Dword;
1104   dwValueType      : Dword;
1105   dwValueSize      : Dword;
1106   lpValue          : Pointer;
1107  end;
1108 
1109 PWSANSClassInfoW = ^TWSANSClassInfoW;
1110 TWSANSClassInfoW = packed record
1111   lpszName         : WideChar;
1112   dwNameSpace      : Dword;
1113   dwValueType      : Dword;
1114   dwValueSize      : Dword;
1115   lpValue          : Pointer;
1116  end;
1117 
1118 {$ifdef UNICODE }
1119 
1120   TWSANSCLASSINFO   = TWSANSCLASSINFOW;
1121   PWSANSCLASSINFO  = PWSANSCLASSINFOW;
1122 
1123 {$else}
1124 
1125   TWSANSCLASSINFO   = TWSANSCLASSINFOA;
1126   PWSANSCLASSINFO  = PWSANSCLASSINFOA;
1127 
1128 {$endif  UNICODE}
1129 
1130 PWSAServiceClassInfoA = ^TWSAServiceClassInfoA;
1131 TWSAServiceClassInfoA = packed record
1132     lpServiceClassId      : PGUID;
1133     lpszServiceClassName  : PChar;
1134     dwCount               : DWord;
1135     lpClassInfos          : PWSANSCLASSINFOA;
1136 end;
1137 
1138 PWSAServiceClassInfoW = ^TWSAServiceClassInfoW;
1139 TWSAServiceClassInfoW = packed record
1140     lpServiceClassId      : PGUID;
1141     lpszServiceClassName  : WideChar;
1142     dwCount               : DWord;
1143     lpClassInfos          : PWSANSCLASSINFOW;
1144 end;
1145 
1146 {$ifdef UNICODE}
1147 
1148   TWSASERVICECLASSINFO         = TWSASERVICECLASSINFOW;
1149   PWSASERVICECLASSINFO        = PWSASERVICECLASSINFOW;
1150 
1151 {$else}
1152 
1153   TWSASERVICECLASSINFO         = TWSASERVICECLASSINFOA;
1154   PWSASERVICECLASSINFO        = PWSASERVICECLASSINFOA;
1155 
1156 {$endif  UNICODE}
1157 
1158 PWSANAMESPACE_INFOA = ^TWSANAMESPACE_INFOA;
1159 TWSANAMESPACE_INFOA = packed record
1160     NSProviderId      : TGUID;
1161     dwNameSpace       : DWord;
1162     fActive           : BOOL;
1163     dwVersion         : DWord;
1164     lpszIdentifier    : PChar;
1165 end;
1166 
1167 PWSANAMESPACE_INFOW = ^TWSANAMESPACE_INFOW;
1168 TWSANAMESPACE_INFOW = packed record
1169     NSProviderId      : TGUID;
1170     dwNameSpace       : DWord;
1171     fActive           : BOOL;
1172     dwVersion         : DWord;
1173     lpszIdentifier    : WideChar;
1174 end;
1175 
1176 {$ifdef UNICODE}
1177 
1178   TWSANAMESPACE_INFO     = TWSANAMESPACE_INFOW;
1179   PWSANAMESPACE_INFO     = PWSANAMESPACE_INFOW;
1180 
1181 {$else}
1182 
1183   TWSANAMESPACE_INFO     = TWSANAMESPACE_INFOA;
1184   PWSANAMESPACE_INFO     = PWSANAMESPACE_INFOA;
1185 
1186 {$endif  UNICODE}
1187 
1188 { AHS END }
1189 
1190 { Socket function prototypes }
1191 
1192 // Using "var addr:TSockAddr" in accept makes impossible to compile for IPv6
1193 function accept(s: TSocket; addr: PSockAddr; var addrlen: Integer): TSocket; stdcall;
1194 // Using "var addr:TSockAddr" in bind makes impossible to compile for IPv6
1195 function bind(s: TSocket; addr: PSockAddr; namelen: Integer): Integer; stdcall;
1196 function closesocket(s: TSocket): Integer; stdcall;
1197 // Using "var addr:TSockAddr" in connect makes impossible to compile for IPv6
1198 function connect(s: TSocket; name: PSockAddr; namelen: Integer): Integer; stdcall;
1199 function ioctlsocket(s: TSocket; cmd: Longint; var arg: u_long): Integer; stdcall;
1200 function getpeername(s: TSocket; var name: TSockAddr; var namelen: Integer): Integer; stdcall;
1201 // Using "var addr:TSockAddr" in getsockname makes impossible to compile for IPv6
1202 function getsockname(s: TSocket; name: PSockAddr; var namelen: Integer): Integer; stdcall;
1203 function getsockopt(s: TSocket; level, optname: Integer; optval: PChar; var optlen: Integer): Integer; stdcall;
1204 function htonl(hostlong: u_long): u_long; stdcall;
1205 function htons(hostshort: u_short): u_short; stdcall;
1206 function inet_addr(cp: PChar): u_long; stdcall; {PInAddr;}  { TInAddr }
1207 function inet_ntoa(inaddr: TInAddr): PChar; stdcall;
1208 function listen(s: TSocket; backlog: Integer): Integer; stdcall;
1209 function ntohl(netlong: u_long): u_long; stdcall;
1210 function ntohs(netshort: u_short): u_short; stdcall;
1211 function recv(s: TSocket; var Buf; len, flags: Integer): Integer; stdcall;
1212 // Using "var from: TSockAddr" in recvfrom makes impossible to compile for IPv6
1213 function recvfrom(s: TSocket; var Buf; len, flags: Integer;
1214   from: PSockAddr; var fromlen: Integer): Integer; stdcall;
1215 function select(nfds: Integer; readfds, writefds, exceptfds: PFDSet;
1216   timeout: PTimeVal): Longint; stdcall;
1217 function send(s: TSocket; var Buf; len, flags: Integer): Integer; stdcall;
1218 // Using "var addrto: TSockAddr" in sendto makes impossible to compile for IPv6
1219 function sendto(s: TSocket; var Buf; len, flags: Integer; addrto: PSockAddr;
1220   tolen: Integer): Integer; stdcall;
1221 function setsockopt(s: TSocket; level, optname: Integer; optval: PChar;
1222   optlen: Integer): Integer; stdcall;
1223 function shutdown(s: TSocket; how: Integer): Integer; stdcall;
1224 function socket(af, struct, protocol: Integer): TSocket; stdcall;
1225 function gethostbyaddr(addr: Pointer; len, struct: Integer): PHostEnt; stdcall;
1226 function gethostbyname(name: PChar): PHostEnt; stdcall;
1227 function gethostname(name: PChar; len: Integer): Integer; stdcall;
1228 function getservbyport(port: Integer; proto: PChar): PServEnt; stdcall;
1229 function getservbyname(name, proto: PChar): PServEnt; stdcall;
1230 function getprotobynumber(proto: Integer): PProtoEnt; stdcall;
1231 function getprotobyname(name: PChar): PProtoEnt; stdcall;
1232 function WSAStartup(wVersionRequired: word; var WSData: TWSAData): Integer; stdcall;
1233 function WSACleanup: Integer; stdcall;
1234 procedure WSASetLastError(iError: Integer); stdcall;
1235 function WSAGetLastError: Integer; stdcall;
1236 function WSAIsBlocking: BOOL; stdcall;
1237 function WSAUnhookBlockingHook: Integer; stdcall;
1238 function WSASetBlockingHook(lpBlockFunc: TFarProc): TFarProc; stdcall;
1239 function WSACancelBlockingCall: Integer; stdcall;
1240 function WSAAsyncGetServByName(HWindow: HWND; wMsg: u_int;
1241   name, proto, buf: PChar; buflen: Integer): THandle; stdcall;
1242 function WSAAsyncGetServByPort( HWindow: HWND; wMsg, port: u_int;
1243   proto, buf: PChar; buflen: Integer): THandle; stdcall;
1244 function WSAAsyncGetProtoByName(HWindow: HWND; wMsg: u_int;
1245   name, buf: PChar; buflen: Integer): THandle; stdcall;
1246 function WSAAsyncGetProtoByNumber(HWindow: HWND; wMsg: u_int; number: Integer;
1247   buf: PChar; buflen: Integer): THandle; stdcall;
1248 function WSAAsyncGetHostByName(HWindow: HWND; wMsg: u_int;
1249   name, buf: PChar; buflen: Integer): THandle; stdcall;
1250 function WSAAsyncGetHostByAddr(HWindow: HWND; wMsg: u_int; addr: PChar;
1251   len, struct: Integer; buf: PChar; buflen: Integer): THandle; stdcall;
1252 function WSACancelAsyncRequest(hAsyncTaskHandle: THandle): Integer; stdcall;
1253 function WSAAsyncSelect(s: TSocket; HWindow: HWND; wMsg: u_int; lEvent: Longint): Integer; stdcall;
1254 
1255 { WinSock 2 extensions -- data types for the condition function in
1256   WSAAccept() and overlapped I/O completion routine. }
1257 
1258 type
1259 
1260 PCONDITIONPROC = function ( lpCallerId:PWSABUF; lpCallerData:PWSABUF;
1261     lpSQOS:PQOS; lpGQOS:PQOS; lpCalleeId:PWSABUF;lpCalleeData:PWSABUF;
1262     g:PGroup; dwCallbackData:DWord) :u_int; stdcall;
1263 
1264 PWSAOVERLAPPED_COMPLETION_ROUTINE = procedure ( dwError :Dword;
1265     cbTransferred: DWORD; lpOverlapped: LPWSAOVERLAPPED; dwFlags: Dword
1266     ); stdcall;
1267 
1268 { WinSock 2 API new function prototypes }
1269 
1270 function WSAAccept( s: TSOCKET; addr: psockaddr; addrlen: PINT;
1271     lpfnCondition: PCONDITIONPROC; dwCallbackData: DWORD): TSOCKET; stdcall;
1272 function WSACloseEvent( hEvent: WSAEVENT ):BOOL; stdcall;
1273 function WSAConnect(s: TSOCKET; name: psockaddr;namelen: u_int;
1274     lpCallerData: PWSABUF; lpCalleeData: PWSABUF; lpSQOS: PQOS;
1275     lpGQOS: PQOS) : u_int; stdcall;
1276 function WSACreateEvent:WSAEVENT; stdcall;
1277 
1278 {$IFDEF UNICODE}
1279 function WSADuplicateSocket(s: TSocket; dwProcessId: DWORD;
1280    lpProtocolInfo: PWSAPROTOCOL_INFOW): u_int; stdcall;
1281 {$ELSE}
1282 function WSADuplicateSocket(s: TSocket; dwProcessId: DWORD;
1283    lpProtocolInfo: PWSAPROTOCOL_INFOA): u_int; stdcall;
1284 {$ENDIF} {UNICODE}
1285 
1286 function WSAEnumNetworkEvents( s: TSocket; hEventObject: WSAEVENT;
1287    lpNetworkEvents: PWSANETWORKEVENTS): u_int; stdcall;
1288 
1289 {$IFDEF UNICODE}
1290 function WSAEnumProtocols( lpiProtocols: PInt;
1291    lpProtocolBuffer: PWSAPROTOCOL_INFOW; lpdwBufferLength: PDWORD
1292    ): u_int; stdcall;
1293 {$ELSE}
1294 function WSAEnumProtocols( lpiProtocols: PInt;
1295    lpProtocolBuffer: PWSAPROTOCOL_INFOA; lpdwBufferLength: PDWORD
1296    ): u_int; stdcall;
1297 {$ENDIF} {UNICODE}
1298 
1299 function WSAEventSelect(s: TSOCKET; hEventObject: WSAEVENT;
1300     lNetworkEvents: u_long): u_int; stdcall;
1301 function WSAGetOverlappedResult( s: TSocket; lpOverlapped: LPWSAOVERLAPPED;
1302     lpcbTransfer: PDWORD; fWait: BOOL; lpdwFlags: PDWORD): BOOL; stdcall;
1303 function WSAGetQOSByName( s: TSocket; lpQOSName: PWSABUF;
1304     lpQOS: PQOS): BOOL; stdcall;
1305 function WSAHtonl( s: TSocket; hostlong: u_long; lpnetlong: pu_long)
1306     : u_int; stdcall;
1307 function WSAHtons( s: TSocket; hostshort: u_short; lpnetshort: pu_short)
1308     : u_int; stdcall;
1309 function WSAIoctl( s: TSocket; dwIoControlCode: DWORD; lpvInBuffer: Pointer;
1310     cbInBuffer: DWORD; lpvOutBuffer: Pointer; cbOutBuffer: DWORD;
1311     lpcbBytesReturned: PDWORD; lpOverlapped: LPWSAOVERLAPPED;
1312     lpCompletionRoutine: PWSAOVERLAPPED_COMPLETION_ROUTINE): u_int; stdcall;
1313 function WSAJoinLeaf( s: TSocket; name: psockaddr; namelen: u_int;
1314     lpCallerData: PWSABUF; lpCalleeData: PWSABUF; lpSQOS: PQOS; lpGQOS: PQOS;
1315     dwFlags: DWORD): TSocket; stdcall;
1316 function WSANtohl( s: TSocket; netlong: u_long; lphostlong: pu_long)
1317     : u_int; stdcall;
1318 function WSANtohs( s: TSocket; netshort: u_short; lphostshort: pu_short)
1319     : u_int; stdcall;
1320 function WSARecv( s: TSocket; lpBuffers: PWSABUF; dwBufferCount: DWORD;
1321     lpNumberOfBytesRecvd: PDWORD; lpFlags: PDWORD;lpOverlapped: LPWSAOVERLAPPED;
1322     lpCompletionRoutine: PWSAOVERLAPPED_COMPLETION_ROUTINE): u_int; stdcall;
1323 function WSARecvDisconnect( s: TSocket; lpInboundDisconnectData: PWSABUF)
1324     : u_int; stdcall;
1325 function WSARecvFrom( s: TSocket; lpBuffers: PWSABUF; dwBufferCount: DWORD;
1326     lpNumberOfBytesRecvd: PDWORD; lpFlags: PDWORD; lpFrom: psockaddr;
1327     lpFromlen: PInt; lpOverlapped: LPWSAOVERLAPPED;
1328     lpCompletionRoutine: PWSAOVERLAPPED_COMPLETION_ROUTINE): u_int; stdcall;
1329 function WSAResetEvent( hEvent: WSAEVENT): BOOL; stdcall;
1330 function WSASend( s: TSocket; lpBuffers: PWSABUF; dwBufferCount: DWORD;
1331     lpNumberOfBytesSent: PDWORD; dwFlags: DWORD; lpOverlapped: LPWSAOVERLAPPED;
1332     lpCompletionRoutine: PWSAOVERLAPPED_COMPLETION_ROUTINE): u_int; stdcall;
1333 function WSASendDisconnect( s: TSocket; lpOutboundDisconnectData: PWSABUF)
1334     : u_int; stdcall;
1335 function WSASendTo(s: TSocket; lpBuffers: PWSABUF; dwBufferCount: DWORD;
1336     lpNumberOfBytesSent: PDWORD;dwFlags: DWORD; lpTo: psockaddr; iTolen: u_int;
1337     lpOverlapped: LPWSAOVERLAPPED;
1338     lpCompletionRoutine: PWSAOVERLAPPED_COMPLETION_ROUTINE): u_int; stdcall;
1339 function WSASetEvent( hEvent: WSAEVENT): BOOL; stdcall;
1340 {$IFDEF UNICODE}
1341 function WSASocket( af: u_int; atype: u_int; protocol: u_int;
1342     lpProtocolInfo: PWSAPROTOCOL_INFOW; g: TGroup; dwFlags: Dword)
1343     : TSocket; stdcall;
1344 {$ELSE}
1345 function WSASocket( af: u_int; atype: u_int; protocol: u_int;
1346     lpProtocolInfo: PWSAPROTOCOL_INFOA; g: TGroup; dwFlags: Dword)
1347     : TSocket; stdcall;
1348 {$ENDIF} { UNICODE}
1349 function WSAWaitForMultipleEvents( cEvents: DWORD; lphEvents: LPWSAEVENT;
1350     fWaitAll: BOOL; dwTimeout: DWORD; fAlertable: BOOL): DWORD; stdcall;
1351 {$IFDEF UNICODE}
1352 function WSAAddressToString( lpsaAddress: PSOCKADDR; dwAddressLength: DWORD;
1353     lpProtocolInfo: PWSAPROTOCOL_INFOW; lpszAddressString: WideChar;
1354     lpdwAddressStringLength: PDWORD): u_int; stdcall;
1355 {$ELSE}
1356 function WSAAddressToString( lpsaAddress: PSOCKADDR; dwAddressLength: DWORD;
1357     lpProtocolInfo: PWSAPROTOCOL_INFOA; lpszAddressString: PChar;
1358     lpdwAddressStringLength: PDWORD): u_int; stdcall;
1359 {$ENDIF} { UNICODE}
1360 
1361 {$IFDEF UNICODE}
1362 function WSAStringToAddress( AddressString: WideChar; AddressFamily: u_int;
1363     lpProtocolInfo: PWSAPROTOCOL_INFOW; lpAddress: PSOCKADDR;
1364     lpAddressLength: PInt): u_int; stdcall;
1365 {$ELSE}
1366 function WSAStringToAddress( AddressString: PChar; AddressFamily: u_int;
1367     lpProtocolInfo: PWSAPROTOCOL_INFOA; lpAddress: PSOCKADDR;
1368     lpAddressLength: PInt): u_int; stdcall;
1369 {$ENDIF} { UNICODE}
1370 
1371 { Registration and Name Resolution API functions }
1372 
1373 {$IFDEF UNICODE}
1374 function WSALookupServiceBegin( lpqsRestrictions: PWSAQUERYSETW;
1375     dwControlFlags: DWORD; lphLookup: LPHANDLE): u_int; stdcall;
1376 {$ELSE}
1377 function WSALookupServiceBegin( lpqsRestrictions: PWSAQUERYSETA;
1378     dwControlFlags: DWORD; lphLookup: LPHANDLE): u_int; stdcall;
1379 {$ENDIF} { UNICODE}
1380 
1381 {$IFDEF UNICODE}
1382 function WSALookupServiceNext( hLookup: THANDLE; dwControlFlags: DWORD;
1383     lpdwBufferLength: PDWORD; lpqsResults: PWSAQUERYSETW): u_int; stdcall;
1384 {$ELSE}
1385 function WSALookupServiceNext( hLookup: THANDLE; dwControlFlags: DWORD;
1386     lpdwBufferLength: PDWORD; lpqsResults: PWSAQUERYSETA): LongInt; stdcall;
1387 {$ENDIF} { UNICODE}
1388 
1389 function WSALookupServiceEnd( hLookup: THandle): u_int; stdcall;
1390 
1391 {$IFDEF UNICODE}
1392 function WSAInstallServiceClass( lpServiceClassInfo: PWSASERVICECLASSINFOW
1393     ): u_int; stdcall;
1394 {$ELSE}
1395 function WSAInstallServiceClass( lpServiceClassInfo: PWSASERVICECLASSINFOA
1396     ): u_int; stdcall;
1397 {$ENDIF} { UNICODE}
1398 
1399 function WSARemoveServiceClass(lpServiceClassId: PGUID): u_int; stdcall;
1400 
1401 {$IFDEF UNICODE}
1402 function WSAGetServiceClassInfo( lpProviderId: PGUID; lpServiceClassId: PGUID;
1403     lpdwBufSize: PDWORD; lpServiceClassInfo: PWSASERVICECLASSINFOW)
1404     : u_int; stdcall;
1405 {$ELSE}
1406 function WSAGetServiceClassInfo( lpProviderId: PGUID; lpServiceClassId: PGUID;
1407     lpdwBufSize: PDWORD; lpServiceClassInfo: PWSASERVICECLASSINFOA)
1408     : u_int; stdcall;
1409 {$ENDIF} { UNICODE}
1410 
1411 {$IFDEF UNICODE}
1412 function WSAEnumNameSpaceProviders( lpdwBufferLength: PDWORD;
1413     lpnspBuffer: PWSANAMESPACE_INFOW):u_int; stdcall;
1414 {$ELSE}
1415 function WSAEnumNameSpaceProviders( lpdwBufferLength: PDWORD;
1416     lpnspBuffer: PWSANAMESPACE_INFOA):u_int; stdcall;
1417 {$ENDIF} { UNICODE}
1418 
1419 {$IFDEF UNICODE}
1420 function WSAGetServiceClassNameByClassId( lpServiceClassId: PGUID;
1421     lpszServiceClassName: WideChar; lpdwBufferLength: PDWORD): u_int; stdcall;
1422 {$ELSE}
1423 function WSAGetServiceClassNameByClassId( lpServiceClassId: PGUID;
1424     lpszServiceClassName: PChar; lpdwBufferLength: PDWORD): u_int; stdcall;
1425 {$ENDIF} { UNICODE}
1426 
1427 {$IFDEF UNICODE}
1428 function WSASetService( lpqsRegInfo: PWSAQUERYSETW;
1429     essoperation: TWSAESETSERVICEOP; dwControlFlags: DWORD):u_int; stdcall;
1430 {$ELSE}
1431 function WSASetService( lpqsRegInfo: PWSAQUERYSETA;
1432     essoperation: TWSAESETSERVICEOP; dwControlFlags: DWORD):u_int; stdcall;
1433 {$ENDIF} { UNICODE}
1434 
1435 function WSARecvEx(s: TSocket; var buf; len: Integer; var flags: Integer): Integer; stdcall;
1436 
1437 function TransmitFile(hSocket: TSocket; hFile: THandle; nNumberOfBytesToWrite: DWORD;
1438   nNumberOfBytesPerSend: DWORD; lpOverlapped: POverlapped;
1439   lpTransmitBuffers: PTransmitFileBuffers; dwReserved: DWORD): BOOL; stdcall;
1440 
1441 function WSAMakeASyncReply(Buflen, Error: Word): Longint;
1442 function WSAMakeSelectReply(Event, Error: Word): Longint;
1443 function WSAGetAsyncBuflen(Param: Longint): Word;
1444 function WSAGetAsyncError(Param: Longint): Word;
1445 function WSAGetSelectEvent(Param: Longint): Word;
1446 function WSAGetSelectError(Param: Longint): Word;
1447 
1448 implementation
1449 
1450 const
1451   winsocket = 'ws2_32.dll';
1452 
1453 function WSAMakeASyncReply;
1454 begin
1455   WSAMakeASyncReply:= MakeLong(Buflen, Error);
1456 end;
1457 
1458 function WSAMakeSelectReply;
1459 begin
1460   WSAMakeSelectReply:= MakeLong(Event, Error);
1461 end;
1462 
1463 function WSAGetAsyncBuflen;
1464 begin
1465   WSAGetAsyncBuflen:= LOWORD(Param);
1466 end;
1467 
1468 function WSAGetAsyncError;
1469 begin
1470   WSAGetAsyncError:= HIWORD(Param);
1471 end;
1472 
1473 function WSAGetSelectEvent;
1474 begin
1475   WSAGetSelectEvent:= LOWORD(Param);
1476 end;
1477 
1478 function WSAGetSelectError;
1479 begin
1480   WSAGetSelectError:= HIWORD(Param);
1481 end;
1482 
1483 function accept;
1484          external    winsocket name 'accept';
1485 function bind;
1486          external    winsocket name 'bind';
1487 function closesocket;
1488          external    winsocket name 'closesocket';
1489 function connect;
1490          external    winsocket name 'connect';
1491 function getpeername;
1492          external    winsocket name 'getpeername';
1493 function getsockname;
1494          external    winsocket name 'getsockname';
1495 function getsockopt;
1496          external    winsocket name 'getsockopt';
1497 function htonl;
1498          external    winsocket name 'htonl';
1499 function htons;
1500          external    winsocket name 'htons';
1501 function inet_addr;
1502          external    winsocket name 'inet_addr';
1503 function inet_ntoa;
1504          external    winsocket name 'inet_ntoa';
1505 function ioctlsocket;
1506          external    winsocket name 'ioctlsocket';
1507 function listen;
1508          external    winsocket name 'listen';
1509 function ntohl;
1510          external    winsocket name 'ntohl';
1511 function ntohs;
1512          external    winsocket name 'ntohs';
1513 function recv;
1514          external    winsocket name 'recv';
1515 function recvfrom;
1516          external    winsocket name 'recvfrom';
1517 function select;
1518          external    winsocket name 'select';
1519 function send;
1520          external    winsocket name 'send';
1521 function sendto;
1522          external    winsocket name 'sendto';
1523 function setsockopt;
1524          external    winsocket name 'setsockopt';
1525 function shutdown;
1526          external    winsocket name 'shutdown';
1527 function socket;
1528          external    winsocket name 'socket';
1529 
1530 function gethostbyaddr;
1531          external    winsocket name 'gethostbyaddr';
1532 function gethostbyname;
1533          external    winsocket name 'gethostbyname';
1534 function getprotobyname;
1535          external    winsocket name 'getprotobyname';
1536 function getprotobynumber;
1537          external    winsocket name 'getprotobynumber';
1538 function getservbyname;
1539          external    winsocket name 'getservbyname';
1540 function getservbyport;
1541          external    winsocket name 'getservbyport';
1542 function gethostname;
1543          external    winsocket name 'gethostname';
1544 
1545 function WSAAsyncSelect;
1546          external    winsocket name 'WSAAsyncSelect';
1547 function WSARecvEx;
1548          external    winsocket name 'WSARecvEx';
1549 function WSAAsyncGetHostByAddr;
1550          external winsocket name 'WSAAsyncGetHostByAddr';
1551 function WSAAsyncGetHostByName;
1552          external winsocket name 'WSAAsyncGetHostByName';
1553 function WSAAsyncGetProtoByNumber;
1554          external winsocket name 'WSAAsyncGetProtoByNumber';
1555 function WSAAsyncGetprotoByName;
1556          external winsocket name 'WSAAsyncGetprotoByName';
1557 function WSAAsyncGetServByPort;
1558          external winsocket name 'WSAAsyncGetServByPort';
1559 function WSAAsyncGetServByName;
1560          external winsocket name 'WSAAsyncGetServByName';
1561 function WSACancelAsyncRequest;
1562          external winsocket name 'WSACancelAsyncRequest';
1563 function WSASetBlockingHook;
1564          external    winsocket name 'WSASetBlockingHook';
1565 function WSAUnhookBlockingHook;
1566          external winsocket name 'WSAUnhookBlockingHook';
1567 function WSAGetLastError;
1568          external    winsocket name 'WSAGetLastError';
1569 procedure WSASetLastError;
1570          external    winsocket name 'WSASetLastError';
1571 function WSACancelBlockingCall;
1572          external winsocket name 'WSACancelBlockingCall';
1573 function WSAIsBlocking;
1574          external     winsocket name 'WSAIsBlocking';
1575 function WSAStartup;
1576          external     winsocket name 'WSAStartup';
1577 function WSACleanup;
1578          external     winsocket name 'WSACleanup';
1579 
1580 {$IFDEF UNICODE}
1581 function WSASetService;
1582          external     winsocket name 'WSASetServiceW';
1583 function WSAGetServiceClassNameByClassId;
1584          external     winsocket name 'WSAGetServiceClassNameByClassIdW';
1585 function WSAEnumNameSpaceProviders;
1586          external     winsocket name 'WSAEnumNameSpaceProvidersW';
1587 function WSAGetServiceClassInfo;
1588          external     winsocket name 'WSAGetServiceClassInfoW';
1589 function WSAInstallServiceClass;
1590          external     winsocket name 'WSAInstallServiceClassW';
1591 function WSALookupServiceNext;
1592          external     winsocket name 'WSALookupServiceNextW';
1593 function WSALookupServiceBegin;
1594          external     winsocket name 'WSALookupServiceBeginW';
1595 function WSAStringToAddress;
1596          external     winsocket name 'WSAStringToAddressW';
1597 function WSAAddressToString;
1598          external     winsocket name 'WSAAddressToStringW';
1599 function WSASocket;
1600          external     winsocket name 'WSASocketW';
1601 function WSAEnumProtocols;
1602          external     winsocket name 'WSAEnumProtocolsW';
1603 function WSADuplicateSocket;
1604          external     winsocket name 'WSADuplicateSocketW';
1605 {$ELSE}
1606 function WSASetService;
1607          external     winsocket name 'WSASetServiceA';
1608 function WSAGetServiceClassNameByClassId;
1609          external     winsocket name 'WSAGetServiceClassNameByClassIdA';
1610 function WSAEnumNameSpaceProviders;
1611          external     winsocket name 'WSAEnumNameSpaceProvidersA';
1612 function WSAGetServiceClassInfo;
1613          external     winsocket name 'WSAGetServiceClassInfoA';
1614 function WSAInstallServiceClass;
1615          external     winsocket name 'WSAInstallServiceClassA';
1616 function WSALookupServiceNext;
1617          external     winsocket name 'WSALookupServiceNextA';
1618 function WSALookupServiceBegin;
1619          external     winsocket name 'WSALookupServiceBeginA';
1620 function WSAStringToAddress;
1621          external     winsocket name 'WSAStringToAddressA';
1622 function WSAAddressToString;
1623          external     winsocket name 'WSAAddressToStringA';
1624 function WSASocket;
1625          external     winsocket name 'WSASocketA';
1626 function WSAEnumProtocols;
1627          external     winsocket name 'WSAEnumProtocolsA';
1628 function WSADuplicateSocket;
1629          external     winsocket name 'WSADuplicateSocketA';
1630 {$ENDIF} { UNICODE}
1631 
1632 
1633 function WSALookupServiceEnd;
1634          external     winsocket name 'WSALookupServiceEnd';
1635 function WSARemoveServiceClass;
1636          external     winsocket name 'WSARemoveServiceClass';
1637 function WSAWaitForMultipleEvents;
1638          external     winsocket name 'WSAWaitForMultipleEvents';
1639 function WSASetEvent;
1640          external     winsocket name 'WSASetEvent';
1641 function WSASendTo;
1642          external     winsocket name 'WSASendTo';
1643 function WSASendDisconnect;
1644          external     winsocket name 'WSASendDisconnect';
1645 function WSASend;
1646          external     winsocket name 'WSASend';
1647 function WSAResetEvent;
1648          external     winsocket name 'WSAResetEvent';
1649 function WSARecvFrom;
1650          external     winsocket name 'WSARecvFrom';
1651 function WSARecvDisconnect;
1652          external     winsocket name 'WSARecvDisconnect';
1653 function WSARecv;
1654          external     winsocket name 'WSARecv';
1655 function WSAIoctl;
1656          external     winsocket name 'WSAIoctl';
1657 function WSAJoinLeaf;
1658          external     winsocket name 'WSAJoinLeaf';
1659 function WSANtohl;
1660          external     winsocket name 'WSANtohl';
1661 function WSANtohs;
1662          external     winsocket name 'WSANtohs';
1663 function WSAHtons;
1664          external     winsocket name 'WSAHtons';
1665 function WSAHtonl;
1666          external     winsocket name 'WSAHtonl';
1667 function WSAGetQOSByName;
1668          external     winsocket name 'WSAGetQOSByName';
1669 function WSAGetOverlappedResult;
1670          external     winsocket name 'WSAGetOverlappedResult';
1671 function WSAEventSelect;
1672          external     winsocket name 'WSAEventSelect';
1673 function WSAEnumNetworkEvents;
1674          external     winsocket name 'WSAEnumNetworkEvents';
1675 function WSACreateEvent;
1676          external     winsocket name 'WSACreateEvent';
1677 function WSAConnect;
1678          external     winsocket name 'WSAConnect';
1679 function WSACloseEvent;
1680          external     winsocket name 'WSACloseEvent';
1681 function WSAAccept;
1682          external     winsocket name 'WSAAccept';
1683 
1684 function TransmitFile;
1685          external     winsocket name 'TransmitFile';
1686 
1687 end.

winsock2.pas

参考资料：

【完成端口详解】http://blog.csdn.net/piggyxp/article/details/6922277

【TCP的那些事】http://coolshell.cn/articles/11564.html

posted @ 2015-01-01 23:34 伯通心智阅读(2852) 评论(0) 收藏举报

刷新页面返回顶部

伯通心智

三千年读史，不外功名利禄；九万里悟道，终归歌酒田园 WeChat: botongxinzhi

IOCP扩展方法AcceptEx, DisconnectEx, GetAcceptExSockaddr用法示例