Windows Socket网络程序设计

原文地址：http://www.cic.tsinghua.edu.cn/jdx/book4/dlzb.htm
       Windows Sockets是Microsoft Windows的网络程序设计接口，它是从Berkeley Sockets扩展而来的。Windows Sockets在继承了Berkeley Sockets主要特征的基础上，又对它进行了重要扩充。这些扩充主要是提供了一些异步函数，并增加了符合Windows消息驱动特性的网络事件异步选择机制。这些扩充有利于应用程序开发者编制符合Windows编程模式的软件，它使在Windows下开发高性能的网络程序成为可能。

6.3.1  Socket网络程序设计原理
       Socket是BSD UNIX提供的网络应用编程接口，它采用客户／服务器的通讯机制，使网络客户方和服务器方通过Socket实现网络之间的连接和数据交换。Socket提供了一系列的系统调用，使用这些系统调用可以实现TCP, UDP,ICMP和IP等多种网络协议之间的通讯。

       Socket有三种主要类型：stream sockets, datagram sockets 和raw sockets。 Stream socket接口定义了一种可靠的面向连接的服务，它实现了无差错无重复的顺序数据传输。它通过内置的流量控制解决了数据的拥塞，应用程序可以发送任意长度的数据，将数据当作字节流。Datagram socket接口定义了一种无连接的服务，数据通过相互独立的包进行传输，包的传输是无序的，并且不保证是否出错、丢失和重复。包长度是有限的（隐含长度为8,192Bytes，最大长度可设为32,768Bytes）。Raw socket接口允许对低层协议如IP和ICMP的直接存取，它主要用于新的网络协议实现的测试等。

       下面我们通过一个面向连接的传输发生的典型情况来说明socket网络通信的实现。



服 务 器                                                              客    户

socket( )

bind( )

listen( )

accept( )

close( )

read( )

...

write( )

close( )

read( )

...

write( )

socket( )

connect( )

Connection Establishment

wait connection for client

……


































图6.3  面向连接的协议实现的Socket调用



       从图6.3可以看出，客户和服务器的关系不是对称的，服务器首先启动，然后在某一时间启动客户与服务器建立连接。服务器和客户开始都必须用调用socket()建立一个套接字（socket），然后服务器调用bind()将套接字与一个本地网络地址捆扎在一起，再用调用listen()使套接字处于一种被动的准备接收状态，同时规定它的请求队列长度，之后服务器就可以调用accept()来接收连接了。客户在建立套接字之后，便可以通过调用connect()和服务器建立连接。连接建立后，客户和服务器之间就可以通过连接发送和接收数据（调用read()和write()）。最后，待数据传送结束，双方调用close()关闭套接字。

6.3.2  WinSock对Socket的扩充
       BSD Socket支持阻塞（blocking）和非阻塞（non_blocking）两种工作方式。在阻塞方式下工作，connect()、accept()、read()和recv()等调用在执行时都处于阻塞状态直到它成功或出错返回。在非阻塞方式下工作，这些调用是立即返回的，但是它们是否完成得靠查询才能知道。对于Windows这种非抢先多任务操作系统来说，这两种工作方式都是很难以接受的，为此，WinSock在尽量与BSD Socket保持一致外，又对它作了必要的扩充。

       WinSock对BSD Socket的扩充主要是在基于消息、对网络事件的异步存取接口上。表6.2列出了WinSock扩充的函数功能。



表6.2  WinSock扩充函数功能表

函   数   名
  功    能

WSAAsyncGetHostByAddr()
 

标准Berkeley函数getXbyY的异步版本，例如：函数WSAAsyncGetHostByName()就是提供了标准Berkeley函数gethostbyname的一种基于消息的异步实现。

WSAAsyncGetHostByName()

WSAAsyncGetProtoByName()

WSAAsyncGetProtoByNumber()

WSAAsyncGetServByName()

WSAAsyncGetServByPort()

WSAAsyncSelect()
函数select()的异步版本

WSACancelAsyncRequest()
取消函数WSAAsyncGetXByY执行中的实例

WSACancelBlockingCall()
取消一个执行中的“阻塞”API调用

WSACleanup()
终止使用隐含的Windows Sockets DLL

WSAGetLastError()
获取Windows Sockets API的最近错误号

WSAIsBlocking()
检测隐含的Windows Sockets DLL是否阻塞了一个当前线索的调用

WSASetBlockingHook()
设置应用程序自己的“阻塞”处理函数

WSASetLastError()
设置Windows Sockets API的最近错误号

WSAStartup()
初始化隐含的Windows Sockets DLL

WSAUnhookBlockingHook()
恢复原来的“阻塞”处理函数




       从表6.2可以看出，WinSock的扩充功能可以分为如下几类：

       (1) 异步选择机制

       异步选择函数WSAAsyncSelect()允许应用程序提名一个或多个感兴趣的网络事件，所有非阻塞的网络I/O例程（如send()和recv()），不管它是已经使用还是即将使用，都可作为WSAAsyncSelect()函数选择的候选。当被提名的网络事件发生时，Windows应用程序的窗口函数将收到一个消息，消息附带的参数指示被提名过的某一网络事件。



       (2) 异步请求例程

       异步请求例程允许应用程序用异步方式获取请求的信息，如WSAAsyncGetXByY()类函数允许用户请求异步服务，这些功能在使用标准Berkeley函数时是阻塞的。函数WSACancelAsyncRequest()允许用户终止一个正在执行的异步请求。

       (3) 阻塞处理方法

       WinSock在调用处于阻塞时进入一个叫“Hook”的例程，它负责处理Windows消息，使得Windows的消息循环能够继续。WinSock还提供了两个函数（WSASetBlockingHook()和WSAUnhookBlockingHook()）让用户能够设置和取消自己的阻塞处理例程。另外，函数WSAIsBlocking()可以检测调用是否阻塞，函数WSACancelBlockingCall()可以取消一个阻塞的调用。

       (4) 出错处理

       为了和以后的多线索环境（如Windows/NT）兼容，WinSock提供了两个出错处理函数WSAGetLastError()和WSASetLastError()来获取和设置本线索的最近错误号。

       (5) 启动与终止

       WinSock的应用程序在使用上述WinSock函数前，必须先调用WSAStartup()函数对Windows Sockets DLL进行初始化，以协商WinSock的版本支持，并分配必要的资源。在应用程序退出之前，应该先调用函数WSACleanup()终止对Windows Sockets DLL的使用，并释放资源，以利下一次使用。

       在这些函数中，实现Windows网络实时通信的关键是异步选择函数WSAAsyncSelect()的使用，其原型如下：

int PASCAL FAR WSAAsyncSelect(SOCTET s, HWND hWnd, unsigned int wMsg, long lEvent);

它请求Windows Sockets DLL在检测到在套接字s上发生的lEvent事件时，向窗口hWnd发送一个消息wMsg。它自动地设置套接字s处于非阻塞工作方式。参数lEvent由表6.3所列事件的一个或多个组成。例如，我们要在套接字s读准备好或写准备好时接到通知，可以使用下面的语句：

rc = WSAAsyncSelect(s, hWnd, wMsg, FD_READ | FD_WRITE);

当套接字s上被提名的一个网络事件发生时，窗口hWnd将收到消息wMsg，变量lParam的低字指示网络发生的事件，高字指示错误码。应用程序就可以通过这些信息来决定自己的下一步动作。



表6.3  异步选择网络事件表

值
含                 义

FD_READ
希望在套接字s收到数据（即读准备好）时接到通知

FD_WRITE
希望在套接字s可发送数据（即写准备好）时接到通知

FD_OOB
希望在套接字s上有带外数据到达时接到通知

FD_ACCEPT
希望在套接字s上有外部连接到来时接到通知

FD_CONNECT
希望在套接字s连接建立完成时接到通知

FD_CLOSE
希望在套接字s关闭时接到通知




6.3.3  网络程序示例Echo
       本章的例子是一个简单的点对点网络实时通信程序Echo。实例分两部分：客户程序wecho.c与服务器程序wechos.c。其工作过程是：服务器首先启动，它创建套接字之后等待客户的连接；客户在启动后，创建套接字，然后和服务器建立连接；连接建立后，客户接收键盘输入，然后将数据发送到服务器，服务器收到数据后，只是简单地发送回来，客户将收到的数据在窗口中显示；如此循环，当客户接收到的输入数据是字母“Q”时，它关闭连接和套接字后退出，服务器在用户关闭窗口时关闭套接字。

6.3.3.1  网络客户程序
       首先介绍客户程序，该源文件取名为wecho.c，其内容在下面列出。为了方便读者，在程序中关键部分采用中文注释的形式给出说明，读者可照这些注释加强对本节内容的理解。



/* This is a Sample for WinSock. It uses WinSock routine to communicate with Server through a port -- USERPORT.

Usage: wecho servername */



#include <winsock.h>

#include <windows.h>

#include <stdio.h>

#include <ctype.h>

#include <memory.h>

#include <string.h>

#include "wecho.h"



HANDLE       hInst, AsyncHnd;

char server_address[256] = {0};

char buffer[MAXGETHOSTSTRUCT];

char FAR *        lpBuffer = &buffer[0];   

SOCKET         s = 0;

int                        connected = 0;    

struct sockaddr_in dst_addr;

struct hostent    *hostaddr;  

struct hostent      hostnm;

unsigned short    port = USERPORT;    // 用户端口号，应大于1024。客户和服务器的端口号必须相同。

int  sock_type = SOCK_STREAM;   

BOOL     InitWindow(HANDLE);

long FAR PASCAL ClientProc(HWND, unsigned, UINT, LONG);

VOID           AlertUser(HWND, LPSTR);

BOOL          Client(HWND);

BOOL                 set_select(HWND, long);      

BOOL          make_skt(HWND);

BOOL          connect_skt(HWND);

BOOL          send_pkt(HWND, int);    

int                     receive_pkt(HWND);

VOID           close_skt(VOID);

void                     DisplayInfo(HWND, int);



/****************************************************************************/

int PASCAL

WinMain( HANDLE hInstance, HANDLE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)

{

         HWND  hWnd;

         MSG     msg;



         lstrcpy((LPSTR) server_address, lpCmdLine);

                

         if (!hPrevInstance)

                   if (!InitWindow(hInstance))

                           return (NULL);

         hInst = hInstance;



         hWnd = CreateWindow("ClientClass", "Windows ECHO Client", WS_OVERLAPPEDWINDOW,

                        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,

                        NULL, NULL, hInstance, NULL);



         if (!hWnd)

                   return (NULL);



         ShowWindow(hWnd, nCmdShow);

         UpdateWindow(hWnd);



         EnableMenuItem(GetMenu(hWnd), IDM_STOP, MF_DISABLED | MF_GRAYED);

         PostMessage(hWnd, WM_USER,(WPARAM) 0, (LPARAM) 0);

                  

         while (GetMessage(&msg, NULL, NULL, NULL)) {

                  TranslateMessage(&msg);

                   DispatchMessage(&msg);

         }

         return (msg.wParam);

}



BOOL

InitWindow( HANDLE hInstance )

{

         WNDCLASSWndClass;



         WndClass.style = CS_HREDRAW | CS_VREDRAW;

         WndClass.lpfnWndProc = ClientProc;

         WndClass.cbClsExtra = 0;

         WndClass.cbWndExtra = 0;

         WndClass.hInstance = hInstance;

         WndClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);

         WndClass.hCursor = LoadCursor(NULL, IDC_ARROW);

         WndClass.hbrBackground = COLOR_WINDOW + 1;

         WndClass.lpszMenuName = (LPSTR) "ClientMenu";

         WndClass.lpszClassName = (LPSTR) "ClientClass";



         return (RegisterClass((PWNDCLASS) & WndClass));

}



long FAR PASCAL

ClientProc( HWND hWnd, unsigned message, UINT wParam, LONG lParam)

{

         int                 length;

         WSADATA       wsaData;

         int     Status;

         LPSTR               msgstr;



         switch (message) {     

                   case WM_USER:// 用户初始化消息。启动Windows Sockets DLL，协商版本支持。

                         Status = WSAStartup(0x101, &wsaData);

                         if (Status != 0) {

                                  AlertUser(hWnd, "WSAStartup() failed \n");

                                  PostQuitMessage(0);

                         }



                      if (LOBYTE(wsaData.wVersion) != 1 ||          HIBYTE(wsaData.wVersion) != 1) {

                                     AlertUser(hWnd, "WSAStartup() Version not match\n");

                                     WSACleanup();

                                 PostQuitMessage(0);

                         }

     

                            //通过主机名异步获取主机信息。   

                       AsyncHnd = WSAAsyncGetHostByName(hWnd, UM_REQ,

                               server_address, buffer, MAXGETHOSTSTRUCT);

                            break;

                                    

                  case WM_COMMAND:

                            switch (wParam) {

                                 case IDM_START:  

                                               if (!Client(hWnd)) {

                                                        AlertUser(hWnd, "Start Failed");     

                                                    EnableMenuItem(GetMenu(hWnd), IDM_START, MF_ENABLED);

                                                        EnableMenuItem(GetMenu(hWnd),IDM_STOP,

                                                                                    MF_DISABLED|MF_GRAYED);

                                     }

                                     else {

                                               EnableMenuItem(GetMenu(hWnd), IDM_START,

                                                                 MF_DISABLED | MF_GRAYED);

                                               EnableMenuItem(GetMenu(hWnd), IDM_STOP, MF_ENABLED);

                                     }

                                     break;



                            case IDM_STOP:       

                                     WSACleanup();  //退出前注销对Windows Sockets DLL的使用。

                                     PostQuitMessage(0);

                                     break;

                            }

                            break;



                   case WM_CHAR:

                            if (wParam == 'q' | wParam == 'Q') {

                                     PostMessage(hWnd, WM_COMMAND, (WPARAM)IDM_STOP, (LPARAM)0);

                                     break;

                            }

                           PostMessage(hWnd, UM_SOCK,(WPARAM)wParam, (LPARAM)FD_USERWRITE);

                            break;

                  

                  case UM_REQ:  //异步请求完成消息，结果在缓冲区中。

                         if (WSAGETASYNCERROR(lParam)) {

                                 AlertUser(hWnd, "WSAAsyncGetHostByName ERROR \n");

                                 WSACleanup();

                                 PostQuitMessage(0);

                        }

                        memcpy(&hostnm, lpBuffer, sizeof(struct hostent));

                            break;

                                    

                   case UM_SOCK: //异步选择消息。

                            switch (lParam) {

                                     case FD_CONNECT:  //连接建立完成，置标志。

                                               connected = 1;

                                               break;

                                                       

                                     case FD_READ: //数据读准备好，读数据并显示。

                                            if ((length = receive_pkt(hWnd)) == 0)

                                            {

                                                     AlertUser(hWnd, "Receive Packet Failed");

                                                     close_skt();

                                                        break;

                                            }

                                            DisplayInfo(hWnd, length);

                                               break;

                                                       

                                     case FD_WRITE: //写准备好。

                                               break;

                                                       

                                     case FD_USERWRITE: //用户写数据消息，发送数据。

                                               if (!connected) {

                                                        AlertUser(hWnd, "Connection not created");

                                                     break;

                                           }      

                                              length = 1;   

                                               buffer[0] = (char)wParam;

                                         if (!(send_pkt(hWnd, length))) {

                                                    AlertUser(hWnd, "Packet Send Failed");

                                                     close_skt();

                                                     break;

                                           }      

                                               break;

                                                       

                                     case FD_CLOSE: //连接关闭，置标志。

                                               connected = 0;

                                               if (WSAAsyncSelect(s,hWnd,0,0) == SOCKET_ERROR)

                                                        AlertUser(hWnd, "WSAAsyncSelect Failed");

                                                    AlertUser(hWnd, "Socket has been closed");

                                                    EnableMenuItem(GetMenu(hWnd),IDM_START, F_ENABLED);

                                                        EnableMenuItem(GetMenu(hWnd), IDM_STOP, MF_DISABLED |

                                                                                   MF_GRAYED);

                                                        break;

                                                       

                                     default:

                                            if (WSAGETSELECTERROR(lParam) != 0) {

                                                       AlertUser(hWnd, "Socket Report Failure");

                                                     close_skt();

                                                     break;

                                           }    

                                           sprintf(msgstr, "lParam = 0x%lx, wParam = 0x%x",lParam,wParam);

                                           AlertUser(hWnd, msgstr);   

                                           break;

                                     }   

                                     break;

                                                    

                  case WM_DESTROY:

                            close_skt();

                        WSACleanup();  //退出前注销对Windows Sockets DLL的使用。

                        PostQuitMessage(0);

                         break;



                  default:

                        return (DefWindowProc(hWnd, message, wParam, lParam));

        }

        return (NULL);

}

 

VOID         //报警子程序。

AlertUser( HWND hWnd, LPSTR lpszWarning )

{

         MessageBox(hWnd, lpszWarning, "Windows Client", MB_OK | MB_ICONEXCLAMATION);

}



/****************************************************************************/

BOOL        //客户程序创建套接字并建立连接。

Client( HWND hWnd )

{

       EnableMenuItem(GetMenu(hWnd), IDM_START, MF_ENABLED);

      EnableMenuItem(GetMenu(hWnd), IDM_STOP, MF_ENABLED);

                  

         if (!make_skt(hWnd)) {         //创建套接字。

                   close_skt();

                   return(FALSE);

         }

 

    if (!set_select(hWnd, FD_CONNECT | FD_READ | FD_WRITE)) {//异步选择网络事件。

              close_skt();

               return(FALSE);

     }

   

         if (!connect_skt(hWnd)) {     //建立连接。

              close_skt();

              return(FALSE);

    }

    return(TRUE);

}



/****************************************************************************/

int     //接收数据子程序。

receive_pkt(HWND hWnd)

{

       int     errno, length, len;



         length = 1024;  

    if ((len = recv(s, lpBuffer, length, 0)) == SOCKET_ERROR) {  //接收网络数据。

                   errno = WSAGetLastError(); 

                   if (errno==WSAEWOULDBLOCK)

                            return(TRUE);

                   AlertUser(hWnd, "Received Failed");

                close_skt();

                   return(FALSE);

       }      

    

         length = len;   

    if (length == 0) {

              AlertUser(hWnd, "Connection was Closed");

              close_skt();

    }

    return(length);

}



BOOL        //异步选择子程序。

set_select( HWND hWnd, long lEvent)

{

      if (WSAAsyncSelect(s, hWnd, UM_SOCK, lEvent) == SOCKET_ERROR) {

                  AlertUser(hWnd, "WSAAsyncSelect Failed");

                  return (FALSE);

      }

    return (TRUE);

}     



BOOL        //创建套接字子程序。

make_skt( HWND hWnd )

{

    if ((s = socket(AF_INET, sock_type, 0)) == INVALID_SOCKET) {

              AlertUser(hWnd, "Socket Failed");

                   return (FALSE);

    }

    return (TRUE);

}



BOOL        //建立连接子程序。

connect_skt( HWND hWnd )

{    

         int errno;   

                  

    memset((void *) &dst_addr, sizeof(dst_addr), 0);

    dst_addr.sin_family = AF_INET;

    dst_addr.sin_port = htons(port);

      dst_addr.sin_addr.s_addr = *((unsigned long *)hostnm.h_addr_list[0]);



       if (connect(s, (struct sockaddr *) & dst_addr, sizeof(dst_addr)) == SOCKET_ERROR) {

              errno = WSAGetLastError();

                   if (errno != WSAEWOULDBLOCK) {

                        AlertUser(hWnd, "Connect Failed");

                        close_skt();

                        return (FALSE);

                   }

       }

      return (TRUE);

}



BOOL        //发送数据子程序。

send_pkt( HWND hWnd, int len)

{

         int length;

                  

    if ((length = send(s, lpBuffer, len, 0)) == SOCKET_ERROR) {

               AlertUser(hWnd, "Send Failed");

                   close_skt();

                   return (FALSE);

      }   

      else if (length != len) {

              AlertUser(hWnd, "Send Length NOT Match!");

                   close_skt();

                   return(FALSE);

      }

     return (TRUE);

}



VOID         //关闭套接字子程序。

close_skt()

{

       if (s) {

              (VOID) closesocket(s);

                   s = 0;

      }

}



void  //显示接收数据子程序。

DisplayInfo(HWND hWnd, int len)

{

         HDC dc;

      int  l;

      char line[16];

      static int col = 0, row = 0;



         buffer[len] = 0;

         if (dc = GetDC(hWnd)) {

            l = wsprintf((LPSTR) line, "%s", lpBuffer);

             TextOut(dc, 10*col, 16*row, (LPSTR) line, l);

                   ReleaseDC(hWnd, dc);

      }

      col += len;

      if (col > 40) {

             col = 0;

                   row ++;

      }

}

6.3.3.2  网络服务器程序
       下面我们介绍服务器程序，源文件取名为wechos.c，其内容如下：



#include <winsock.h>

/* This is a Sample for WinSock. It uses WinSock routine as a server to communicate with Client through a port -- USERPORT.

Usage: wechos.exe */



#include <stdio.h>

#include <ctype.h>

#include <memory.h>

#include <string.h>

#include "wechos.h"



#define MAX_LENGTH      1024



HANDLE          hInst;

char       buffer[MAX_LENGTH];

char FAR *        lpBuffer = &buffer[0];

int                        length=0;

SOCKET s = 0, oldskt;

struct sockaddr_in dst_addr;

unsigned short    port = USERPORT;

int     sock_type = SOCK_STREAM;  



BOOL                 InitWindow(HANDLE);

long FAR PASCAL ServerProc(HWND, unsigned, UINT, LONG);

VOID           AlertUser(HWND, LPSTR);

BOOL           Server(HWND);

BOOL                 set_select(HWND, long);      

BOOL           make_skt(HWND);

BOOL           accept_skt(HWND);

BOOL           send_pkt(HWND, int);    

BOOL                 receive_pkt(HWND, int *);

VOID           close_skt(SOCKET);



/****************************************************************************/

int PASCAL

WinMain( HANDLE hInstance, HANDLE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)

{

         HWND  hWnd;

         MSG     msg;



         if (!hPrevInstance)  {

                   if (!InitWindow(hInstance))

                            return (NULL);

         }

         else return(NULL);                         // Don't allow another SERVER is executing



         hInst = hInstance;



      hWnd = CreateWindow("ServerClass", "Windows ECHO Server", WS_OVERLAPPEDWINDOW,

                        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,

                        NULL, NULL, hInstance, NULL);



      if (!hWnd)

               return (NULL);



        ShowWindow(hWnd, nCmdShow);

      UpdateWindow(hWnd);

    PostMessage(hWnd, WM_USER,(WPARAM) 0, (LPARAM) 0);

                  

         while (GetMessage(&msg, NULL, NULL, NULL)) {

TranslateMessage(&msg);

DispatchMessage(&msg);

    }



    return (msg.wParam);

}



BOOL

InitWindow( HANDLE hInstance )

{

         WNDCLASS WndClass;



         WndClass.style = CS_HREDRAW | CS_VREDRAW;

         WndClass.lpfnWndProc = ServerProc;

         WndClass.cbClsExtra = 0;

         WndClass.cbWndExtra = 0;

         WndClass.hInstance = hInstance;

         WndClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);

         WndClass.hCursor = LoadCursor(NULL, IDC_ARROW);

         WndClass.hbrBackground = COLOR_WINDOW + 1;

         WndClass.lpszMenuName = (LPSTR) "ServerMenu";

         WndClass.lpszClassName = (LPSTR) "ServerClass";



         return (RegisterClass((PWNDCLASS) & WndClass));

}



long FAR PASCAL

ServerProc( HWND hWnd, unsigned message, UINT wParam, LONG lParam)

{

         WSADATA  wsaData;

         int Status;



         switch (message) {     

                   case WM_USER:         //用户消息，初始化Windows Sockets DLL，协商版本支持。

                            Status = WSAStartup(0x101, &wsaData);

                            if (Status != 0) {

                             AlertUser(hWnd, "WSAStartup() failed \n");

                              PostQuitMessage(0);

                            }



                            if (LOBYTE(wsaData.wVersion) != 1 ||          HIBYTE(wsaData.wVersion) != 1) {

                                     AlertUser(hWnd, "WSAStartup() Version not match\n");

                                     WSACleanup();

                                 PostQuitMessage(0);

                         }

   

                            if (!Server(hWnd)) {

                              AlertUser(hWnd, "Start Failed");     

                              EnableMenuItem(GetMenu(hWnd), IDM_START, MF_ENABLED);

                                     EnableMenuItem(GetMenu(hWnd), IDM_EXIT, MF_DISABLED | MF_GRAYED);

                            }

                            break;

                                    

                   case WM_COMMAND:

                            switch (wParam) {

                                     case IDM_START:

                                         if (!Server(hWnd)) {

                                                       AlertUser(hWnd, "Start Failed");     

                                                        EnableMenuItem(GetMenu(hWnd), DM_START,MF_ENABLED);

                                                        EnableMenuItem(GetMenu(hWnd), IDM_EXIT,

                                                                                    MF_DISABLED | MF_GRAYED);

                                               }

                                               break;



                            case IDM_EXIT:

                                     WSACleanup();           //退出前注销对Windows Sockets DLL的使用。

                                     PostQuitMessage(0);

                               break;

                   }

                   break;



                   case UM_SOCK:         //异步选择消息。

                            switch  (lParam)        {

                                     case FD_ACCEPT:      //接收套接字上的连接。

                                               if (!accept_skt(hWnd)) {

                                                   AlertUser(hWnd,"Accept socket Failed");

                                                   break;

                                               }

                                               set_select(hWnd, FD_READ);

                                               break;

                                                       

                                     case FD_READ: //数据读准备好，接收网络数据。

                                               length = 1024;

                                           if (!receive_pkt(hWnd, &length)) {

                                               AlertUser(hWnd, "Receive Packet Failed");

                                               break;

                                               }

                                               set_select(hWnd, FD_WRITE);

                                               break;

        

                                     case FD_WRITE: //写准备好，发送数据。

                                          if (!(send_pkt(hWnd, length))) {

                                                        AlertUser(hWnd, "Send Packet Failed");

                                                        break;

                                            }      

                                 set_select(hWnd, FD_READ);

                                               break;



                                     case FD_CLOSE:         //连接关闭。

                                               if (WSAAsyncSelect(s,hWnd,0,0) == SOCKET_ERROR)

                                                   AlertUser(hWnd, "WSAAsyncSelect Failed");

                                               AlertUser(hWnd, "Socket has been closed");

                                               EnableMenuItem(GetMenu(hWnd), IDM_START,MF_ENABLED);

                                               break;

                                    

                            default:

                                  if (WSAGETSELECTERROR(lParam) != 0) {

                                           AlertUser(hWnd, "Socket Report Failure");

                                            close_skt(s);

                                               s = oldskt;

                                            EnableMenuItem(GetMenu(hWnd),IDM_START, F_ENABLED);

                                   }    

                                   break;

                   }   

                   break;

                                                      

                   case WM_DESTROY:

                            WSACleanup();  //退出前注销对Windows Sockets DLL的使用。

                            PostQuitMessage(0);

                            break;



                   default:

                            return (DefWindowProc(hWnd, message, wParam, lParam));

         }

         return (NULL);

}

 

VOID         //报警子程序。

AlertUser( HWND hWnd, LPSTR lpszWarning )

{

         MessageBox(hWnd, lpszWarning, "Windows Server", MB_OK| MB_ICONEXCLAMATION);

}



/****************************************************************************/

BOOL        //服务器程序创建套接字，并注册FD_ACCEPT网络事件。

Server( HWND hWnd )

{

      EnableMenuItem(GetMenu(hWnd), IDM_START,MF_DISABLED | MF_GRAYED);

      EnableMenuItem(GetMenu(hWnd), IDM_EXIT, MF_ENABLED);

                  

         if (!make_skt(hWnd))

                   return(FALSE);

 

      if (!set_select(hWnd, FD_ACCEPT))

                 return(FALSE);

      return(TRUE);

}



/****************************************************************************/

BOOL       //接收数据子程序。

receive_pkt(HWND hWnd, int *len)

{

       int     length, errno;



         length = *len;  

      if ((length = recv(s, lpBuffer, length, 0)) == SOCKET_ERROR) {

                   errno = WSAGetLastError(); 

                   if (errno != WSAEWOULDBLOCK)

                       return(FALSE);

    }      

         *len = length;   

         return(TRUE);

}



BOOL        //异步选择子程序。

set_select( HWND hWnd, long lEvent)

{

         if (WSAAsyncSelect(s, hWnd, UM_SOCK, lEvent) == SOCKET_ERROR) {

              AlertUser(hWnd, "WSAAsyncSelect Failed");

                   return (FALSE);

      }

      return (TRUE);

}     

  

BOOL        //创建套接字子程序。  

make_skt(HWND hWnd)

{

         SOCKADDR_IN   sin;

      unsigned long on=1;



      s = socket (AF_INET, SOCK_STREAM, 0);  //创建套接字。

    if (s == INVALID_SOCKET) {

              AlertUser(hWnd, "Socket Failed");

            PostQuitMessage(0);

                   return(FALSE);

      }



      sin.sin_family = AF_INET;

      sin.sin_addr.s_addr = 0;

      sin.sin_port = htons (port);

      if (bind (s, (LPSOCKADDR) &sin, sizeof (sin))) {  //建立本地连接。

              close_skt(s);

              PostQuitMessage(0);

              return(FALSE);

      }

   

         if (listen (s, 1)) return(FALSE);      //将套接字变为被动套接字，等待接收连接。

         return(TRUE);

}



BOOL        //接收套接字上连接。

accept_skt(HWND hWnd)

{

      SOCKET newskt;     

      struct sockaddr tcpaddr;

      int len;

    

         len = sizeof(struct sockaddr); 

      newskt = accept (s, (struct sockaddr far *)&tcpaddr, (int far *)&len);

      if (newskt == INVALID_SOCKET)

              return(FALSE);

      else {

                   oldskt = s;           //保存监听套接字。

              s = newskt;         //使用接收套接字用于数据传输。

      }

      return(TRUE);

}



BOOL        //发送数据子程序。

send_pkt( HWND hWnd, int len)

{

         if (send(s, lpBuffer, len, 0) == SOCKET_ERROR)

              return (FALSE);

       return (TRUE);

}



VOID         //关闭套接字子程序。

close_skt(SOCKET skt)

{

    (VOID) closesocket(skt);

}



       客户／服务器工作模式是Socket网络程序典型的模式，通过对这一实例程序的理解，我们可以基本掌握Windows Sockets网络程序设计的基本原理及实现方法。用户可以将此程序作为范例，通过对它们进行修改和扩充，设计出符合自己要求的应用程序。