WinSocket 的API使用

来源：互联网发布：森海塞尔ie80淘宝编辑：程序博客网时间：2024/04/25 18:32

本篇将通过一次Socket通信操作来对ServerSocket和ClientSocket这两个控件的源码进行一次阅读，希望能理出一个脉络来，以供大家参考。其实说得确切一点，应该是对Scktcomp这个单元进行解读，但由于这个单元的代码太多了，所以不可能面面俱到，我试图以非阻塞式的通信来一步步说明它们是怎么样封装WinSock的API的，至于阻塞式的，在ServerSocket和ClientSocket并不常用，所以这一篇就不打算说了，可能源码中会有一些忽略掉，以后有时间来补一篇阻塞式的阅读吧。虽然现在Delphi已经用Indy控件替换了SS和CS等网络控件，但毕竟这两个控件是对Socket函数进行封装，学习它怎么样封装也好吧。

在这之前，须对WinSock有一个大概的了解，但也仅止大概，对Socket编程有一个总体的掌握行了，毕竟那不是我的能力所及。想要系统一点的学习Socket，可以去网上下WinSocket的中文文档以及参考MSDN。

Socket中分服务端和客户端，它们是怎么样互交的呢，请下面图例：

图3-1就是我们所说的UDP协议，而图3-2就是TCP协议，如果是用纯API编写，大概程序流程就是那上面那样子，这里将说的是图3-2的面向连接的Socket的应用，因为SS和CS就是封装这种形式的Socket编程的。

以下是说明这个过程中各个函数的声明

在开始使用WinSock的Api的时候，必须加载WinSock Dll的相应版本，这时用到的函数是：

int WSAStartup (

 WORD wVersionRequested,

  LPWSADATA lpWSAData

);

wVersionRequested

指定用到的WinSock的最低版本，高字节指定副版本，低字节指定主版本，关于WinSock的版本，详见MSDN。

lpWSAData结构类型，系统把加载进去的版本信息添加到这个结构中。

该函数成功返回0，不成功则返回几个错误代码之一

这个函数和WSACleanup对应，查看MSDN

从MSDN列出一个例子：

WORD wVersionRequested;

WSADATA wsaData;

int err;

wVersionRequested = MAKEWORD( 2, 2 );

err = WSAStartup( wVersionRequested, &wsaData );

if ( err != 0 ) {

/* Tell the user that we could not find a usable */

/* WinSock DLL. */

return;

}

调用上面的函数之后，就可以用下面的函数来创建一个Socket了，Socket是WinSock定义的数据类型（整数），相当于句柄，用于标识系统中的每一个Socket连接

SOCKET socket (

 int af,

  int type,

  int protocol

);

Af协议标志，Internet协议族的标志是PINET。

Type 协议类型志，SOCISTREAM表明是面向连接的字节流类型，SOCIDGRAM表明是面向无连接的数据报类型。

Protocol Socket采用的协议类型，如果采用IPPROTO_TCP常数就是采用了TCP协议。

如果调用失败，会返回INVALID_SOCKET值，正常的Socket取值范围是1～INVALID_SOCKET-1;

下面的函数将Socket与特定的主机进行绑定：

int bind (

 SOCKET s,

  const struct sockaddr FAR*  name,

  int namelen

);

S就是一个Socket，由Socket()函数返回得到的。

Name是sockaddr结构的变量

Namelen是Name结构的长度。

如果函数调用成功，将返回0，如果不成功，将返回SOCKET_ERROR，可以从WSAGetLastError函数获得错误代码。.

现在说sockaddr这个结构，在Winsock中其实有两个功能相似的结构，它们是：

struct sockaddr {

u_short sa_family;

char sa_data[14];

};

struct sockaddr_in {

short sin_family;

u_short sin_port;

struct in_addr sin_addr;

char sin_zero[8];

};

这两个结构在Delphi中被声明为一个变体记录，这两个指定通信的本地主机地址，本地协议端口，另外还有通信过程中使用的协议类型。

其中：sin_family规定了哪个协议用来实现套按字连接。WinSock必须设置常数AF_INET

sin_port;：WinSock应用程序使用的端口号

sin_addr：这个是32位IP地址

sin_zero[8];这个保留，没有使用。

Server端必须调用Bind()函数，设计时可以将地址设定为INADDR_ANY，这样WinSock会自动加入机器正确的地址.

以下是客户端向服务端连接时调用的函数

int connect (

 SOCKET s,

  const struct sockaddr FAR*  name,

  int namelen

);

函数里的参数和bind()一个，不多说了，函数成功时返回0，否则返回SOCKET_ERROR。

服务端在Bind之后，调用下面函数进行监视。

int listen (

 SOCKET s,

  int backlog

);

其中backlog是可以建立的最大连接数，如果值设为SOMAXCONN，将由Socket的服务提供商设定一个合理的值，这个值不确定。

函数成功时返回0，否则返回SOCKET_ERROR。

当客户端连接服务端，服务端调用下面函数接收客户的请求，并向客户机发送应答信息

SOCKET accept (

 SOCKET s,

  struct sockaddr FAR* addr,

  int FAR* addrlen

);

其中中addr是用来保存客户机地址信息的指针

Addrlen是addr的长度一般是Sizeof(addr)

如果函数成功，则返回一个Socket，这个Socket才是与客户实际通信的套接字，原来的那个Socket继续监视其他客户端的连接

以下几个是用个服务机和客户机通信的函数，

int send (SOCKET s,const char FAR * buf, int len,int flags );

在面向连接的情况下发送数据

int recv (SOCKET s, char FAR* buf, int len, int flags );

在面向连接的情况下接收数据

另外还有sendto和recvfrom用于无连接情况，具体查MSDN

其中Buf是发送或接收的缓冲区，Len是缓冲区的大小，Flags是网络呼叫产生方式标志，值可以为0，MSG_DONTROUTE或 MSG_OOB用途具体看MSDN。

通信完毕后，需要关闭Socket，函数声明如下：

int closesocket (

 SOCKET s

);

在程序的最后，需要调用下面的函数，结束WinSock DLL

int WSACleanup (void);

函数成功时返回0，否则返回SOCKET_ERROR。

下面开始TServerSockett和TClientSocket的原代码阅读：

不过在分析之前，先要明白，对于WinSock的封装其实是由ScktComp单元的几个类一起完成的，它们的关系是：

TServerSocket继承于TCustomServerSocket

TCustomServerSocket继承于TCustomSocket

TCustomSocket继承于TAbstractSocket而TAbstractSockeet的上级则是TComponent了

TClientSocket继承于TCustomSocket

另外还有几个类：

TServerWinSocket和TClientWinSocket以及TServerClientWinSocket继承TCustomSocket

它们才是真正封装Socket的类。作为上面提到的类的成员存在

此外还有几个用于阻塞式传输的类。这里就忽略不讲了，以后有机会再补上来吧。

以ServerSocket和ClientSocket的一次操作流程来跟踪它们的源代码，看看他们是怎么样封WinSocket的。以非阻塞方式来例子。

1． ServerSocket要创建，构造函数如下：

（11）

constructor TServerSocket.Create(AOwner: TComponent);

begin

inherited Create(AOwner);

FServerSocket := TServerWinSocket.Create(INVALID_SOCKET);

InitSocket(FServerSocket);

FServerSocket.ThreadCacheSize := 10;

end;

inherited Create(AOwner);是继承自TComponent的构造函数。

接下来创建它的一个成员，这是一个TServerWinSocket的对象，这个才是真正封装SocketApi的类，等一个讨论它。事实上这个构造函数继承自它的父类TCustomServerSocket

接下来调用InitSocket(FServerSocket);这是ServerSocket的祖先类TAbstractSocket的一个方法，传入参数是成员FserverSocket完成的功能是将ServerSocket的事件指针指向TServerWinSocket的事件，使其能处理Socket触发的事件。

最后，设置FServerSocket允许连接的线程数，这里为10。

好，现在回过头来看看FServerSocket := TServerWinSocket.Create(INVALID_SOCKET);做了什么：

（111）

constructor TServerWinSocket.Create(ASocket: TSocket);

begin

FConnections := TList.Create;

FActiveThreads := TList.Create;

FListLock := TCriticalSection.Create;

inherited Create(ASocket);

FAsyncStyles := [asAccept];

end;

首先创建两个TList对象，一个是FConnections，代表各个处理客户连接的Socket，它对应于属性：property Connections[Index: Integer]: TCustomWinSocket，你可以通过这个属性对各个客户连接进行操作。FActiveThreads 管理由Connections 数组确定的的客户端连接线程TServerClientThread，它对应的属性是ActiveThreads，这个是只读属性，返回当前正在使用的TServerClientThread对象的个数。接下来创建互斥量对象，用于线程同步的处理。

到这里又调用其父类的构造函数，传递的参数就是ServerSocket给的值INVALID_SOCKET，（想想上面提到的这个值的意义）

好，再继续跟踪，到其父类的构造函数去看一下，我们这时应该保留一个问题，按照WinSock的编程模式，刚开始应该是初始化Winsock.DLL，并调用绑定监听函数，这些API是什么在地方被调用呢？

（1111）

constructor TCustomWinSocket.Create(ASocket: TSocket);

begin

inherited Create;

Startup;

FSocketLock := TCriticalSection.Create;

FASyncStyles := [asRead, asWrite, asConnect, asClose];

FSocket := ASocket;

FAddr.sin_family := PF_INET;

FAddr.sin_addr.s_addr := INADDR_ANY;

FAddr.sin_port := 0;

FConnected := FSocket <> INVALID_SOCKET;

end;

首先调用TObject的构造函数，

再调用Sartup;分析完这个函数再看里面的代码，这里可以猜测它里面会调用WSAStartup函数。

接下来看到从ServerSocket传过来的参数指定给了TCustomWinSocket的成员，还有下面几个成员的设置，可以肯定，这里是对Socket进行初始化，结合开头所讲的知识，再看看源代码。应该不难理解了吧。

再看看Startup的源码：

（11111）

procedure Startup;

var

ErrorCode: Integer;

begin

ErrorCode := WSAStartup($0101, WSAData);

if ErrorCode <> 0 then

raise ESocketError.CreateResFmt(@sWindowsSocketError,

[SysErrorMessage(ErrorCode), ErrorCode, 'WSAStartup']);

end;

这是一个全局函数，看到其中一行重要的代码了，

ErrorCode := WSAStartup($0101, WSAData);WinSock就是在这里被初始化的。

而在服务端没有建立监听之时，Socket就在上面被默认设置了。

好，现在ServerSocket的成员FserverSocket的创建就完成了，再回到最上面，

FServerSocket := TServerWinSocket.Create(INVALID_SOCKET);之后，便是

InitSocket(FServerSocket);了，看看它的代码：

（12）

procedure TAbstractSocket.InitSocket(Socket: TCustomWinSocket);

begin

Socket.OnSocketEvent := DoEvent;

Socket.OnErrorEvent := DoError;

end;

正好和上面所说的一样，现在可以认为当Socket发生了事件（比如连接，接收等）之后，就是调用了DoEvent了，错误发生了也一样。不妨看看DoEvent代码：

（121）

procedure TAbstractSocket.DoEvent(Sender: TObject; Socket: TCustomWinSocket;

SocketEvent: TSocketEvent);

begin

Event(Socket, SocketEvent);

end;

里面是调用Event，再看看Event的声明：

procedure Event(Socket: TCustomWinSocket; SocketEvent: TSocketEvent);virtual; abstract;

这是一个抽象函数，由此可以知道，TAbstractSocket是一个抽象的类，它只是封装了一般的操作，具体地都留到了它的子类中去了，所以它的子类一定覆盖了这个Event方法，而DoEvent中调用的Event实际上就是调用它子类的Event方法，这个就是典型的模板模式。

好，看看它的子类有没有覆盖这个方法，果然在TCustomSocket中看到了这个方法，并实现了它，看看它的源代码：

（1211）

procedure TCustomSocket.Event(Socket: TCustomWinSocket; SocketEvent: TSocketEvent);

begin

case SocketEvent of

seLookup: if Assigned(FOnLookup) then FOnLookup(Self, Socket);

seConnecting: if Assigned(FOnConnecting) then FOnConnecting(Self, Socket);

seConnect:

begin

FActive := True;

if Assigned(FOnConnect) then FOnConnect(Self, Socket);

end;

seListen:

begin

FActive := True;

if Assigned(FOnListen) then FOnListen(Self, Socket);

end;

seDisconnect:

begin

FActive := False;

if Assigned(FOnDisconnect) then FOnDisconnect(Self, Socket);

end;

seAccept: if Assigned(FOnAccept) then FOnAccept(Self, Socket);

seRead: if Assigned(FOnRead) then FOnRead(Self, Socket);

seWrite: if Assigned(FOnWrite) then FOnWrite(Self, Socket);

end;

其中FonAccept等这些都是TCusotmSocket的成员，都是TSocketNotifyEvent类型的，TCustomSocket还通过下面这些属性，使该类拥有了这些事件处理的能力：

property OnLookup: TSocketNotifyEvent read FOnLookup write FOnLookup;

property OnConnecting: TSocketNotifyEvent read FOnConnecting write FOnConnecting;

property OnConnect: TSocketNotifyEvent read FOnConnect write FOnConnect;

property OnDisconnect: TSocketNotifyEvent read FOnDisconnect write FOnDisconnect;

property OnListen: TSocketNotifyEvent read FOnListen write FOnListen;

property OnAccept: TSocketNotifyEvent read FOnAccept write FOnAccept;

property OnRead: TSocketNotifyEvent read FOnRead write FOnRead;

property OnWrite: TSocketNotifyEvent read FOnWrite write FOnWrite;

而上面的Event实现，我们可以看到它是根据SocketEvent的类型来调用相应的事件指针的，而它的子类ServerSocket和ClientSocket也拥有了这些事件的处理能力，到这里我们终于明白了，它们的事件是怎么样出来的，但如果想得知这些事件是怎么触发的，还要看这一句：Socket.OnSocketEvent，OnSocketEvent到后面再说，这里先略。

错误处理事件原理上也是一样，到后面再说。

好了，到这里第一步解读完毕，我们所知道的ServerSocket创建之后所完成事件就是初始化Socket DLL，并指定好事件处理的方法指针和错误处理的方法指针。我们接下来看第二步。

2．我们创建完ServerSocket后，下步要做什么呢，当然是指定端口啦，然后Open开始监视啦，这个过程会触发一些事件，我们正好看看这些事件是怎么样发生的。

由于这一次操作是非阻塞方式的，所以ServerType默认为stNonBlocking，我们开始设置Port，这个属性的声明在哪里，这个属性一直到跟踪祖先类AbstractSocket中去，因为无论客户端和服务端都是要设置端口的，所以理所当然要封装到最高层的类去了，以让它的子类拥有这些属性：

property Port: Integer read FPort write SetPort;

再看看SetPort方法：

（21）

procedure TAbstractSocket.SetPort(Value: Integer);

begin

if FPort <> Value then

begin

if not (csLoading in ComponentState) and FActive then

raise ESocketError.CreateRes(@sCantChangeWhileActive);

FPort := Value;

end;

if not (csLoading in ComponentState) and FActive then

raise ESocketError.CreateRes(@sCantChangeWhileActive);

这一句是防止你在运行时改变端口，最后才将值赋给FPort。

好了，设置后Port后，就要Open了，开始监视客户端了。

监视有两个方式，一种是直接设Active属性为True，一种直接调用Open方法。

其中Open方法如下：

procedure TAbstractSocket.Open;

begin

Active := True;

end;

它还是用到了属性Active，所以我们可以集中来讨论Active属性。

property Active: Boolean read FActive write SetActive;

看看SetActive：

（22）

procedure TAbstractSocket.SetActive(Value: Boolean);

begin

if Value <> FActive then

begin

if (csDesigning in ComponentState) or (csLoading in ComponentState) then

FActive := Value;

if not (csLoading in ComponentState) then

DoActivate(Value);

end;

我们可以这样认为，当设计时就直接设FActive，当运行时，就调用DoActivate(Value);

而TAbstractSocket覆盖了Loaded方法，则当窗体开始运行，从Form文件中开始流入时，也调用了DoActive方法。

再看DoActive了:

（221）

procedure DoActivate(Value: Boolean); virtual; abstract;又是一种抽象方法，得到它的子类去看了，在它的子类TCustomServerSocket找到这个方法：

procedure TCustomServerSocket.DoActivate(Value: Boolean);

begin

if (Value <> FServerSocket.Connected) and not (csDesigning in ComponentState) then

begin

if FServerSocket.Connected then

FServerSocket.Disconnect(FServerSocket.SocketHandle)

else FServerSocket.Listen(FHost, FAddress, FService, FPort, SOMAXCONN);

end;

可以这样理解，不在设计时，当Value不等它的成员FServerSocket.Connected时（我们可先认为这个表示当前的监听状态），而如果此时FServerSocket.Connected为True，则表示Value为False,，那么这时要断开连接，调用FServerSocket.Disconnect(FServerSocket.SocketHandle)

很多时候ServerSocket都是调用它的成员FServerSocket来完成操作的，这一点我已经看到了，下面还有更多这样的情况。否则，则Value为True，调用

FServerSocket.Listen(FHost, FAddress, FService, FPort, SOMAXCONN);来开始进行监视。好的，现在我们就要打开FServerSocket的源码，看看它是怎么样完成断开连接和开始连接的了。

先看开始监听的：

（2211）

procedure TServerWinSocket.Listen(var Name, Address, Service: string; Port: Word;

QueueSize: Integer);

begin

inherited Listen(Name, Address, Service, Port, QueueSize, ServerType = stThreadBlocking);

if FConnected and (ServerType = stThreadBlocking) then

FServerAcceptThread := TServerAcceptThread.Create(False, Self);

end;

这里调用其父类的Listen方法，如果它是阻塞方式的，则还要生成一个线程类，由于我用的非阻塞方式，所以暂不去理它，看看他的父类的Listen方法：

（22111）

procedure TCustomWinSocket.Listen(const Name, Address, Service: string; Port: Word;

QueueSize: Integer; Block: Boolean);

begin

if FConnected then raise ESocketError.CreateRes(@sCannotListenOnOpen);

FSocket := socket(PF_INET, SOCK_STREAM, IPPROTO_IP);

if FSocket = INVALID_SOCKET then raise ESocketError.CreateRes(@sCannotCreateSocket);

try

Event(Self, seLookUp);

if Block then

begin

FAddr := InitSocket(Name, Address, Service, Port, False);

DoListen(QueueSize);

end else

AsyncInitSocket(Name, Address, Service, Port, QueueSize, False);

except

Disconnect(FSocket);

raise;

end;

这里第一句重要函数出现了：

FSocket := socket(PF_INET, SOCK_STREAM, IPPROTO_IP);

记得上面Fsockeet曾被赋过值吗，是INVALID_SOCKET;，而这里终于被替回了一个可用的套接字了。

第二个重要的函数：Event(Self, seLookUp);可以先猜测这个方法最终于会调用事件指针，等一下再看。

接下来判断Block的值，回头看看这一句：

inherited Listen(Name, Address, Service, Port, QueueSize, ServerType = stThreadBlocking);

如果为阻塞方式，则为True，否则为False，非阻塞为这时为False，调用下方法：

AsyncInitSocket(Name, Address, Service, Port, QueueSize, False);

好了，再看一下Even吧：

（221111）

procedure TCustomWinSocket.Event(Socket: TCustomWinSocket; SocketEvent: TSocketEvent);

begin

if Assigned(FOnSocketEvent) then FOnSocketEvent(Self, Socket, SocketEvent);

end;

不出所料，调用事件指针了，这时ServerSocket的事件就会触发了，回过头去看看，

seLookup: if Assigned(FOnLookup) then FOnLookup(Self, Socket);

这里CustomSocket的OnLookup事件发生，但ServerSocket并没有显化它，ClientSocket就有这个事件。

按我们所设的方式，接下来要调用如下函数了（另外一些方法以后再说）：

AsyncInitSocket(Name, Address, Service, Port, QueueSize, False);

这函数很大，但所用到的技巧也非常精彩，得好好分析它：

（221112）

procedure TCustomWinSocket.AsyncInitSocket(const Name, Address,

Service: string; Port: Word; QueueSize: Integer; Client: Boolean);

var

ErrorCode: Integer;

begin

try

case FLookupState of

lsIdle:

begin

if not Client then

begin

FLookupState := lsLookupAddress;

FAddr.sin_addr.S_addr := INADDR_ANY;

//下面的情况到客户端时才会用到

end else if Name <> '' then

begin

if FGetHostData = nil then

FGetHostData := AllocMem(MAXGETHOSTSTRUCT);

FLookupHandle := WSAAsyncGetHostByName(Handle, CM_LOOKUPCOMPLETE,

PChar(Name), FGetHostData, MAXGETHOSTSTRUCT);

CheckSocketResult(Ord(FLookupHandle = 0), 'WSAASyncGetHostByName');

FService := Service;

FPort := Port;

FQueueSize := QueueSize;

FClient := Client;

FLookupState := lsLookupAddress;

Exit;

end else if Address <> '' then

begin

FLookupState := lsLookupAddress;

FAddr.sin_addr.S_addr := inet_addr(PChar(Address));

end else

begin

ErrorCode := 1110;

Error(Self, eeLookup, ErrorCode);

Disconnect(FSocket);

if ErrorCode <> 0 then

raise ESocketError.CreateRes(@sNoAddress);

Exit;

end;

lsLookupAddress:

begin

if Service <> '' then

begin

if FGetHostData = nil then

FGetHostData := AllocMem(MAXGETHOSTSTRUCT);

FLookupHandle := WSAASyncGetServByName(Handle, CM_LOOKUPCOMPLETE,

PChar(Service), 'tcp' , FGetHostData, MAXGETHOSTSTRUCT);

CheckSocketResult(Ord(FLookupHandle = 0), 'WSAASyncGetServByName');

FLookupState := lsLookupService;

Exit;

end else

begin

FLookupState := lsLookupService;

FAddr.sin_port := htons(Port);

end;

lsLookupService:

begin

FLookupState := lsIdle;

if Client then

DoOpen

else DoListen(QueueSize);

end;

if FLookupState <> lsIdle then

ASyncInitSocket(Name, Address, Service, Port, QueueSize, Client);//递归

except

Disconnect(FSocket);

raise;

end;

它从判断FLookupState的状态来执行相应的操作，而最后每一步都会执行到，它是怎么做到的呢，答案就是最后的这两句：

if FLookupState <> lsIdle then

ASyncInitSocket(Name, Address, Service, Port, QueueSize, Client);

我们先从头来看吧：

首先，FLookupState的状态行为lsIdle，则执行isIdle这一大块，判断Client的值，这里是服务端，所以应该为False（从调用该方法的函数也可得知），所以只执行了这一块：

FLookupState := lsLookupAddress;

FAddr.sin_addr.S_addr := INADDR_ANY;

其余都是对于客户端的来作的，所以以后再讨论它（由此也可以知道该函数的重要性了）。

还记得INADDR_ANY的意义吗，它会使得WinSock自动加入正确的地址。

好，方法执行到最后的这几句：

if FLookupState <> lsIdle then

ASyncInitSocket(Name, Address, Service, Port, QueueSize, Client);

这时FLookupState已经为lsLookupAddress了，所以又会调用ASyncInitSocket方法，它就是这样递归调用本身，直到所有操作都完毕，这样的设计思维实在是太精巧了。

第一递归之后，它又执行了那一块呢，当然是lsLookupAddress:这一块啦，看看代码，知道它会先判断函数的参数Service是否为空，我们前面没有对该传递过来的这个参数并没有同值，所以为空，便执行了这两句：

FLookupState := lsLookupService;

FAddr.sin_port := htons(Port);

可知，它对结构的端口值了，又进行第二次递归，这里应该是执行lsLookupService:这一块，并调用了这个方法DoListen(QueueSize);开始监听：

FLookupState := lsIdle;

if Client then

DoOpen

else DoListen(QueueSize);

我们看到FLookupState已经又回到了IsIdle，所以就不再递归了。

最好，我们得来看看DoListen这个方法，这个大概就是万事具务，只欠东风的东风了，我们猜测它会在这里调用Bind和Listen等API，并触发Oolisten事件：

（2211121）

procedure TCustomWinSocket.DoListen(QueueSize: Integer);

begin

CheckSocketResult(bind(FSocket, FAddr, SizeOf(FAddr)), 'bind');

DoSetASyncStyles;

if QueueSize > SOMAXCONN then QueueSize := SOMAXCONN;

Event(Self, seListen);

CheckSocketResult(Winsock.listen(FSocket, QueueSize), 'listen');

FLookupState := lsIdle;

FConnected := True;

end;

哈，一切都明朗了，所有API都在这里调用了，事件也触发了。现在就等客户来连接了

只是还没有完，还有一个DoSetASyncStyles方法，坚持走下去吧，会到挑花园的：

（22111211）

procedure TCustomWinSocket.DoSetAsyncStyles;

var

Msg: Integer;

Wnd: HWnd;

Blocking: Longint;

begin

Msg := 0;

Wnd := 0;

if FAsyncStyles <> [] then

begin

Msg := CM_SOCKETMESSAGE;

Wnd := Handle;

end;

WSAAsyncSelect(FSocket, Wnd, Msg, Longint(Byte(FAsyncStyles)));

if FASyncStyles = [] then

begin

Blocking := 0;

ioctlsocket(FSocket, FIONBIO, Blocking);

end;

有两个情况，当FAsyncStyles有元素时和没有元素时，从上面的代码中我们看到它是有元素的。则：

Msg := CM_SOCKETMESSAGE;

Wnd := Handle;

第一句应该是指针Socket消息了，用于与客户端的读写事件的触发的吧。而第二句，则我仔细看了，Handle是TCustomWinSocket的一个属性：

property Handle: HWnd read GetHandle;

再看看GetHandle方法

function TCustomWinSocket.GetHandle: HWnd;

begin

if FHandle = 0 then

FHandle := AllocateHwnd(WndProc);

Result := FHandle;

end;

我们记得上面并没有对FHandle进行赋值，所以它应该为0，则调用了AllocateHwnd，这个方法产生一个不可见的窗口用于接收消息，窗口过程就是WndProc，在CustomWinSocket有声明：

procedure TCustomWinSocket.WndProc(var Message: TMessage);

begin

try

Dispatch(Message);

except

if Assigned(ApplicationHandleException) then

ApplicationHandleException(Self);

end;

可以知道，他调用Object的Dispatch(Message);进行消息分配，而我们看到类中有消息函数的声明：

procedure CMSocketMessage(var Message: TCMSocketMessage); message CM_SOCKETMESSAGE;

当事件发生时就会调用这些消息处理函数了。而这些消息是从那里发生的呢，得回过头去看看DoSetAsyncStyles方法，其中有这一个SocketAPI：

WSAAsyncSelect(FSocket, Wnd, Msg, Longint(Byte(FAsyncStyles)));

就是通过它，当有网络消息发生的时候，才会触发上面事件的，而Longint(Byte(FAsyncStyles)

则指定允许触发哪些事件。（具体的还是看看MSDN的说明吧）

呼还没有完吗，其实差不多了，我们现在知道了当有客户端连接或读写，是通过什么方式来让服务端知道并触发相应的事件的，说到底还是用了WinSock的API，只不过Delphi用自己的事件处理方式将那些Socket异步消息转化成自己的事件了，这个过程是非常精彩的，很值得我们学习。

但现在只剩下最一步了，TCustomWinSocket消息处理方法中，如何转化为事件，并传递到ServerSocket去的呢，答案只有在源代码中找了：

procedure TCustomWinSocket.CMSocketMessage(var Message: TCMSocketMessage);

function CheckError: Boolean;

var

ErrorEvent: TErrorEvent;

ErrorCode: Integer;

begin

if Message.SelectError <> 0 then

begin

Result := False;

ErrorCode := Message.SelectError;

case Message.SelectEvent of

FD_CONNECT: ErrorEvent := eeConnect;

FD_CLOSE: ErrorEvent := eeDisconnect;

FD_READ: ErrorEvent := eeReceive;

FD_WRITE: ErrorEvent := eeSend;

FD_ACCEPT: ErrorEvent := eeAccept;

else

ErrorEvent := eeGeneral;

end;

Error(Self, ErrorEvent, ErrorCode);

if ErrorCode <> 0 then

raise ESocketError.CreateResFmt(@sASyncSocketError, [ErrorCode]);

end else Result := True;

end;

begin

with Message do

if CheckError then

case SelectEvent of

FD_CONNECT: Connect(Socket);

FD_CLOSE: Disconnect(Socket);

FD_READ: Read(Socket);

FD_WRITE: Write(Socket);

FD_ACCEPT: Accept(Socket);//这个很特殊

end;

呵，又是一个大函数，不过理解起来倒是容易多了，先检查有没有错误，如果有就调用Error(Self, ErrorEvent, ErrorCode);如果没有，就根据相应标识，调用相就的函数，其实我们已经可以确定，像Read这些内部一定会调用Event，再由Event调用

FOnSocketEvent(Self, Socket, SocketEvent);，这样才能使得ServerSocket这些外部的类获得事件（上面已经说到它们是怎么把事件关联起来的了）。

而源代码中确实也是这样的，这里只列出一个read，其他的一样：

procedure TCustomWinSocket.Read(Socket: TSocket);

begin

if (FSocket = INVALID_SOCKET) or (Socket <> FSocket) then Exit;

Event(Self, seRead);

end;

procedure TCustomWinSocket.Event(Socket: TCustomWinSocket; SocketEvent: TSocketEvent);

begin

if Assigned(FOnSocketEvent) then FOnSocketEvent(Self, Socket, SocketEvent);

end;

完了吧，可惜还没有，回到上面的函数去，发现还有一个方法没有分析：

FServerSocket.Disconnect(FServerSocket.SocketHandle)可是按我们流程，还不会调用到它，所以这里暂不提它。

好了，第二步就这样结束了，再说下去，我自己也晕了。不过我们知道了这一步所完成的任务：连接一个监听的套接字，并设定好了事件方法指针，在适当的时机会调用适当的事件处理函数。真的得谢谢Delphi为我们做了这么多的事，使我们在使用的时候感觉到是如此的简单。

3．程序执行到这里，得看看ClientSocket吧，有了上面的分析，下面的分析都会简单得多：

constructor TClientSocket.Create(AOwner: TComponent);

begin

inherited Create(AOwner);

FClientSocket := TClientWinSocket.Create(INVALID_SOCKET);

InitSocket(FClientSocket);

end;

没有什么值得讨论的FClientSocket也是继承父类的构造方法，上面已经说过了。

接设置Port，Address等，都是到祖先类设置，没有什么好说的，最后一句是

Active:=true;

上面的讨论已经知道，它最后会调用ClientSocket的覆盖方法：

procedure TClientSocket.DoActivate(Value: Boolean);

begin

if (Value <> FClientSocket.Connected) and not (csDesigning in ComponentState) then

begin

if FClientSocket.Connected then

FClientSocket.Disconnect(FClientSocket.FSocket)

else FClientSocket.Open(FHost, FAddress, FService, FPort, ClientType = ctBlocking);

end;

这里的Value为True，则调用

FClientSocket.Open(FHost, FAddress, FService, FPort, ClientType = ctBlocking);

去看看吧：

procedure TCustomWinSocket.Open(const Name, Address, Service: string; Port: Word; Block: Boolean);

begin

if FConnected then raise ESocketError.CreateRes(@sSocketAlreadyOpen);

FSocket := socket(PF_INET, SOCK_STREAM, IPPROTO_IP);

if FSocket = INVALID_SOCKET then raise ESocketError.CreateRes(@sCannotCreateSocket);

try

Event(Self, seLookUp);

if Block then

begin

FAddr := InitSocket(Name, Address, Service, Port, True);

DoOpen;

end else

AsyncInitSocket(Name, Address, Service, Port, 0, True);

except

Disconnect(FSocket);

raise;

end;

没什么特别之处，以我们设置的方式，也一样调用AsyncInitSocket，同样也是完成Socket的设置

再回去看看第2步中的代码吧，而它的Client参数是设为True，所以最后的一定会调用：

DoOpen：

procedure TCustomWinSocket.DoOpen;

begin

DoSetASyncStyles;

Event(Self, seConnecting);

CheckSocketResult(WinSock.connect(FSocket, FAddr, SizeOf(FAddr)), 'connect');

FLookupState := lsIdle;

if not (asConnect in FAsyncStyles) then

begin

FConnected := FSocket <> INVALID_SOCKET;

Event(Self, seConnect);

end;

和上面说到的Dolisten简直像极了，这里也没有必多说了。我们已经可以向更加简单的第四步进发了。

4． ClientSocket向服务端连接后，WinSock会向服务端发送一个事件，，而上面已经过了事件获取函数：CMSocketMessage

其中的消息标识码是：FD_ACCEPT，所以会调用Accept(Socket);函数，这个与其他的事件方法不同，我们来看看它的源码就知道了：

procedure TCustomWinSocket.Accept(Socket: TSocket);

begin

end;

Socket的父类将这个方法设为虚方法，并什么事也不做，可知它的子类ServerWinSocket一定覆盖了这个方法，并可能要做一些线程分配方面的工作，但这又是一个大函数了，又要花一大篇来分析了，但离胜利之地已经不远了，这一步完成，其他就全部都是小菜一碟了。

（41）

procedure TServerWinSocket.Accept(Socket: TSocket);

var

ClientSocket: TServerClientWinSocket;

ClientWinSocket: TSocket;

Addr: TSockAddrIn;

Len: Integer;

OldOpenType, NewOpenType: Integer;

begin

Len := SizeOf(OldOpenType);

//得到与指定套接口相关的属性选项。

if getsockopt(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, PChar(@OldOpenType),

Len) = 0 then

try

if FServerType = stThreadBlocking then

begin

NewOpenType := SO_SYNCHRONOUS_NONALERT;

//设置与指定套接口相关的属性选项。

setsockopt(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, PChar(@NewOpenType), Len);

end;

Len := SizeOf(Addr);

调用SocketAPI，返回一个新的套接字与客户端进行通信

ClientWinSocket := WinSock.accept(Socket, @Addr, @Len);

if ClientWinSocket <> INVALID_SOCKET then

begin

ClientSocket := GetClientSocket(ClientWinSocket);

if Assigned(FOnSocketEvent) then

FOnSocketEvent(Self, ClientSocket, seAccept);

if FServerType = stThreadBlocking then

begin

ClientSocket.ASyncStyles := [];

GetServerThread(ClientSocket);

end;

finally

Len := SizeOf(OldOpenType);

setsockopt(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, PChar(@OldOpenType), Len);

end;

我们只针对我们非阻塞模式来看几个重要的语句，上面已经用蓝色标识出来了。首先：

ClientWinSocket := WinSock.accept(Socket, @Addr, @Len);

调用WinSock的API，Accept得到一个与客户端进行通信的Socket，而原来的Socket则继续监听。

ClientSocket := GetClientSocket(ClientWinSocket);

ClientSocket是一个TServerClientWinSocket类的对象，这个对象就是代表与客户端通信的Socket类，那么GetClientSocket必定是以参数WinSocket创建了一个TServerClientWinSocket对象，看代码去：

（411）

function TServerWinSocket.GetClientSocket(Socket: TSocket): TServerClientWinSocket;

begin

Result := nil;

if Assigned(FOnGetSocket) then FOnGetSocket(Self, Socket, Result);

if Result = nil then

Result := TServerClientWinSocket.Create(Socket, Self);

end;

果然其中创建了这个类的对象，不但传入了上面的WinSocket，还传递了ServerWinSocket自己，继续吧，不要言累：

（4111）

constructor TServerClientWinSocket.Create(Socket: TSocket; ServerWinSocket: TServerWinSocket);

begin

FServerWinSocket := ServerWinSocket;

if Assigned(FServerWinSocket) then

begin

FServerWinSocket.AddClient(Self);

if FServerWinSocket.AsyncStyles <> [] then

begin

OnSocketEvent := FServerWinSocket.ClientEvent;

OnErrorEvent := FServerWinSocket.ClientError;

end;

inherited Create(Socket);

if FServerWinSocket.ASyncStyles <> [] then DoSetAsyncStyles;

if FConnected then Event(Self, seConnect);

end;

这里两个重要的语句已经标出来了，第一句，它调用了传进来的ServerWinSocket的方法AddClient，看看这个怎么实现的：

（41111）

procedure TServerWinSocket.AddClient(AClient: TServerClientWinSocket);

begin

FListLock.Enter;

try

if FConnections.IndexOf(AClient) < 0 then

FConnections.Add(AClient);

finally

FListLock.Leave;

end;

哈，这个方法的意思已经很明显了，他就是把这个与客户端的通信的Socket加入了一个列表中，这个列表已经在前面看到创建了的，便于以后维护。

上面函数接下的另一句inherited Create(Socket);则是其父类TCustomWinSocket的构造函数了，上面我们已经分析过了，就是将这个与客户端的连接的Socket赋给成员FSocket。

最后我们得回过头到Accept方法再去看最后一个重要语句：

FOnSocketEvent(Self, ClientSocket, seAccept);

OnAccept终于发生了，我们可以在这里事件中向客户端发送一些信息！

5．分析到这里，接下来就是WinSock的事了，客户端和服务端开始通信，于是它向这些类发送消息，然后传递事件处理函数，就可以进行非阻塞的数据传输，而那些数据传递函数最终也都是调用Socket的API，所以我想也不要多说了，看看源代码吧。大概的脉络其实在第2步中说得也差不多了。

执行到最后，会设Active为False，回顾上面的代码，则会调用Socket的父类：

TCustomWinSocket.Disconnect，不过ServerSokcet又覆盖了这个方法，它所完成的功能只是释放掉所有的线程，最后还是会调用父类的这个方法。

（51）

procedure TCustomWinSocket.Disconnect(Socket: TSocket);

begin

Lock;

try

if FLookupHandle <> 0 then

CheckSocketResult(WSACancelASyncRequest(FLookupHandle), 'WSACancelASyncRequest');

FLookupHandle := 0;

if (Socket = INVALID_SOCKET) or (Socket <> FSocket) then exit;

Event(Self, seDisconnect);

CheckSocketResult(closesocket(FSocket), 'closesocket');

FSocket := INVALID_SOCKET;

FAddr.sin_family := PF_INET;

FAddr.sin_addr.s_addr := INADDR_ANY;

FAddr.sin_port := 0;

FConnected := False;

FreeAndNil(FSendStream);

finally

Unlock;

end;

CheckSocketResult(closesocket(FSocket), 'closesocket');这一句即完成了Socket的关闭了。

通信完后，两个类都要释放了，在析构函数中做一些收尾的工作，大想也可以猜它要做什么了。

先来看看ServerSocket的析构函数：

（52）

destructor TCustomServerSocket.Destroy;

begin

FServerSocket.Free;

inherited Destroy;//这是TComponent的析构函数

end;

先释放FServerSocket，再调用父类的析构函数，一个个来看。它到底做了些什么收尾的工作。

（521）

destructor TServerWinSocket.Destroy;

begin

inherited Destroy;

FConnections.Free;

FActiveThreads.Free;

FListLock.Free;

end;

没有什么可说的，再追上去：

（5211）

destructor TCustomWinSocket.Destroy;

begin

FOnSocketEvent := nil; { disable events }

if FConnected and (FSocket <> INVALID_SOCKET) then

Disconnect(FSocket);

//释放由AllocateHWnd.生成的窗口。

if FHandle <> 0 then DeallocateHWnd(FHandle);

FSocketLock.Free;

Cleanup;

FreeMem(FGetHostData);

FGetHostData := nil;

inherited Destroy;//这是TObject的析构函数

end;

看下去：

procedure Cleanup;

var

ErrorCode: Integer;

begin

ErrorCode := WSACleanup;

if ErrorCode <> 0 then

raise ESocketError.CreateResFmt(@sWindowsSocketError,

[SysErrorMessage(ErrorCode), ErrorCode, 'WSACleanup']);

end;

总算是最后了，看到SocketAPI的调用了吗。

那么ClientSocket的呢：

（53）

destructor TClientSocket.Destroy;

begin

FClientSocket.Free;

inherited Destroy; //这是TComponent的析构函数

end;

我们已经很有经验了，看FClientSocket的析构函数去，但ClientSocket没有构析函数，他的父类才有，即我们说到的TCustomWinSocket，那么一切都结束了。

这一大块，非阻塞式的一次操作就这样结束了。请各位对着源代码看吧，多跟踪一下，也许发现的东西比我还多。如果下次有机会，我会进行一次阻塞式的代码阅读的。