《Windows网络编程》附书代码（简单服务器与客户端）

  1 // 程序清单6-1 回应服务器代码
  2 //  编译命令Compile：cl -o Server Server.c ws2_32.lib
  3 //
  4 //  命令行选项：
  5 //  server [-p:x] [-i:IP] [-o]
  6 //  -p:x 监听的端口号
  7 //  -i:str 监听的网卡
  8 //  -o 只接收，不回显数据
  9 //
 10
 11
 12
 13 #include  < winsock2.h >
 14 #include  < stdio.h >
 15 #include  < stdlib.h >
 16
 17 #pragma  comment(lib,  " Ws2_32.lib  " )
 18
 19 #define  DEFAULT_PORT 5150
 20 #define  DEFAULT_BUFFER 4096
 21
 22 int  iPort  =  DEFAULT_PORT;  //  监听客户端的端口
 23 BOOL bInterface  =  FALSE,  //  在指定网卡上监听
 24 bRecvOnly  =  FALSE;  //  只接收，不回显
 25 char  szAddress[ 128 ];
 26
 27
 28
 29 void  usage() ;
 30 void  ValidateArgs( int  argc,  char   ** argv) ;
 31 DWORD WINAPI ClientThread(LPVOID lpParam) ;
 32
 33
 34 //  函数：main
 35 //  说明：执行主线程、初始化Winsock、解释命令行参数、创建监听套接字、捆绑到本地地址、
 36 // 等待
 37 //  客户端连接
 38 int  main( int  argc,  char   ** argv)
 39 {
 40    WSADATA wsd;
 41
 42    SOCKET sListen,sClient;
 43
 44    int iAddrSize;
 45
 46
 47    HANDLE hThread;
 48
 49    DWORD dwThreadId;
 50
 51    struct sockaddr_in local, client;
 52
 53    int i = 0 ;
 54
 55    printf("程序开始:\n");
 56
 57//    ValidateArgs(argc, argv);
 58
 59    if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
 60    {
 61        printf("Failed to load Winsock!\n");
 62        return 1;
 63    }
 64    // 创建监听套接字
 65    sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
 66
 67    if (sListen == SOCKET_ERROR)
 68    {
 69        printf("socket() failed: %d\n", WSAGetLastError());
 70        return 1;
 71    }
 72    // 选择本地网络接口卡，并且捆绑到它上面
 73    if (bInterface)
 74    {
 75        local.sin_addr.s_addr = inet_addr(szAddress);
 76        if (local.sin_addr.s_addr == INADDR_NONE)
 77            usage();
 78    }
 79    else
 80        local.sin_addr.s_addr = htonl(INADDR_ANY);
 81
 82
 83    local.sin_family = AF_INET;
 84    local.sin_port = htons(iPort);
 85    if (bind(sListen, (struct sockaddr *)&local,sizeof(local)) == SOCKET_ERROR)
 86    {
 87        printf("bind() failed: %d\n", WSAGetLastError());
 88        return 1;
 89    }
 90    listen(sListen, 8);
 91
 92    // 循环等待进入的客户端连接，一旦检查到连接，创建线程并且传递句柄
 93    printf("主程序循环前:\n");
 94    while (1)
 95    {
 96        printf("主程序第%d循环\n",i);
 97
 98        iAddrSize = sizeof(client);
 99
100        sClient = accept(sListen, (struct sockaddr *)&client,&iAddrSize);   //会挂起，直到有连接
101
102        if (sClient == INVALID_SOCKET)
103        {
104            printf("accept() failed: %d\n", WSAGetLastError());
105            break;
106        }
107        printf("Accepted client: %s:%d\n",inet_ntoa(client.sin_addr), ntohs(client.sin_port));
108
109        hThread = CreateThread(NULL, 0, ClientThread,(LPVOID)sClient, 0, &dwThreadId);  //创建处理纯种
110
111        if (hThread == NULL)
112        {
113            printf("CreateThread() failed: %d\n", GetLastError());
114            break;
115        }
116        CloseHandle(hThread);
117
118        i++ ;
119    }
120    closesocket(sListen);
121
122
123    WSACleanup();
124
125    printf("程序结束:\n");
126
127    return 0;
128}
129
130
131 //  函数：ClientThread
132 //  说明：函数以线程方式调用，并且处理给定客户端连接，传递参数为从accept()调用中返回
133 // 的套接
134 //  字句柄，该函数从客户端读取数据，并且将读到的数据写回去
135 DWORD WINAPI ClientThread(LPVOID lpParam)
136 {
137    SOCKET sock=(SOCKET)lpParam;
138    char szBuff[DEFAULT_BUFFER];
139    int ret,
140        nLeft,
141        idx;
142
143    printf("Client开始:\n");
144
145    while(1)
146    {
147        // 阻塞recv()调用
148
149        printf("recv开始:\n");
150
151        ret = recv(sock, szBuff, DEFAULT_BUFFER, 0);
152        if (ret == 0) // 常规关闭
153            break;
154        else if (ret == SOCKET_ERROR)
155        {
156            printf("recv() failed: %d\n", WSAGetLastError());
157            break;
158        }
159        szBuff[ret] = '\0';
160        printf("RECV: '%s'\n", szBuff);
161        //
162        // 选择回显数据
163        if (!bRecvOnly)
164        {
165            nLeft = ret;
166            idx = 0;
167            // 确保写所有数据
168            while(nLeft > 0)
169            {
170                ret = send(sock, &szBuff[idx], nLeft, 0);
171                if (ret == 0)
172                    break;
173                else if (ret == SOCKET_ERROR)
174                    
175                {
176                    printf("send() failed: %d\n",
177                        WSAGetLastError());
178                    break;
179                }
180                nLeft -= ret;
181                idx += ret;
182            }
183        }
184
185    }
186
187    printf("Client结束:\n");
188
189    return 0;
190}
191
192
193
194 //  监听客户端的网卡
195 //  函数：usage
196 //  说明：打印使用信息，并且退出
197
198
199 void  usage()
200 {
201    printf("usage: server [-p:x] [-i:IP] [-o]\n\n");
202    printf(" -p:x 监听的端口号\n");
203    printf(" -i:str 监听的网卡\n");
204    printf(" -o 只接收，不回显数据\n\n");
205    ExitProcess(1);
206}
207 //  函数：ValidateArgs
208 //  说明：解释命令行参数，设置指示操作如何进行的全局变量
209 void  ValidateArgs( int  argc,  char   ** argv)
210 {
211    int i;
212
213
214    printf("解释命令行参数程序开始:\n");
215    for(i = 1; i < argc; i++)
216    {
217        if ((argv[i][0] == '-') || (argv[i][0] == '/'))
218        {
219            switch (tolower(argv[i][1]))
220            {
221            case 'p':
222                iPort = atoi(&argv[i][3]);
223                break;
224            case 'i':
225                
226                    bInterface = TRUE;
227                if (strlen(argv[i]) > 3)
228                    strcpy(szAddress, &argv[i][3]);
229                break;
230            case 'o':
231                bRecvOnly = TRUE;
232                break;
233            default:
234                usage();
235                break;
236            }
237        }
238    }
239    printf("解释命令行参数程序结束:\n");
240}
241
242
243
244
245

  1
  2 /**/ /*
  3
  4程序清单6-2 是客户端代码，客户端建立一个套接字，并对投入应用的服务器名进行解析，然后
  5与服务器建立连接。连接一旦建成，就可发送大量的消息了。每次发送数据之后，客户端都会等待服
  6务器发回的回应。客户端把得自套接字的数据打印出来。
  7回应客户端和服务器不能完全说明TCP 协议的流式传输。这是因为读取操作是在写操作之后进行
  8的，至少客户端这一端是这样的。当然，对服务器来说，还有另一种方式。因此，服务器每次调用读
  9取函数，一般都会返回客户端发出的整条消息。但不要误会，如果客户端的消息大到超过了TCP 的最
 10大传输单元，在线上，它会被分成几个小的数据包，这种情况下，接收端需要多次执行接收调用，才
 11能收完整条消息。为了更好地说明流式传输，运行客户端和服务器时带上-O 选项即可。这样，客户端
 12便只管发送数据，接收端只管读取数据。
 13
 14          
 15            
 16服务器如下执行：
 17server -p:5150 -o
 18而客户端如下执行：
 19client -p:5150 -s:IP -n:10 -o
 20大家最可能见到的是客户端进行了10 次send 调用，而服务器在一次或两次recv 调用中，就读
 21取了10 条消息。
 22
 23
 24*/
 25
 26
 27
 28 // 程序清单6-2 回应客户端代码
 29
 30
 31 //  说明：回显客户端，连接TCP 服务器，发送数据，并且读服务器返回的数据
 32 //  编译命令：cl -o Client Client.c ws2_32.lib
 33 //
 34 //  命令行参数：
 35 //  client [-p:x] [-s:IP] [-n:x] [-o]
 36 //  -p:x 发送的远程端口
 37 //  -s:IP 服务器IP 地址或主机名
 38 //  -n:x 发送消息次数
 39 //  -o 只发送消息，不接收
 40 //
 41
 42 #include  < winsock2.h >
 43 #include  < stdio.h >
 44 #include  < stdlib.h >
 45
 46 #pragma  comment(lib,  " Ws2_32.lib  " )
 47
 48 #define  DEFAULT_COUNT 1000
 49 #define  DEFAULT_PORT 5150
 50 #define  DEFAULT_BUFFER 2048
 51 #define  DEFAULT_MESSAGE "This is a test of the emergency \
 52 broadcasting system "
 53
 54
 55 char  szServer[ 128 ],  //  连接的服务器
 56
 57 szMessage[ 1024 ];  //  发送给服务器的消息
 58
 59 int  iPort  =  DEFAULT_PORT;  //  连接到服务器的端口
 60
 61 DWORD dwCount  =  DEFAULT_COUNT;  //  发送消息次数
 62
 63 BOOL bSendOnly  =  FALSE;  //  只发送数据，不接收
 64
 65
 66   void  usage() ;
 67   void  ValidateArgs( int  argc,  char   ** argv) ;
 68
 69 //  函数：main
 70 //  说明：执行主线程，初始化Winsock，解释命令行参数，创建套接字，连接服务器，然后发送
 71 // 和接
 72 //  收数据
 73 int  main( int  argc,  char   ** argv)
 74 {
 75    WSADATA wsd;
 76    SOCKET sClient;
 77    char szBuffer[DEFAULT_BUFFER];
 78    int ret,i;
 79
 80    struct sockaddr_in server;
 81
 82    struct hostent *host = NULL;
 83
 84    // 解释命令行并且载入Winsock
 85    ValidateArgs(argc, argv);
 86
 87    if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
 88    {
 89        printf("Failed to load Winsock library!\n");
 90        return 1;
 91    }
 92    strcpy(szMessage, DEFAULT_MESSAGE);
 93    // 创建套接字，并且尝试连接服务器
 94    sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 95    if (sClient == INVALID_SOCKET)
 96    {
 97        printf("socket() failed: %d\n", WSAGetLastError());
 98        return 1;
 99    }
100    server.sin_family = AF_INET;
101    server.sin_port = htons(iPort);
102    server.sin_addr.s_addr = inet_addr(szServer);
103    
104        // 如果提供的服务器地址不是形如"aaa.bbb.ccc.ddd"，则为主机名，尝试解析它
105        if (server.sin_addr.s_addr == INADDR_NONE)
106        {
107            host = gethostbyname(szServer);
108            if (host == NULL)
109            {
110                printf("Unable to resolve server: %s\n", szServer);
111                return 1;
112            }
113
114            CopyMemory(&server.sin_addr, host->h_addr_list[0],
115                host->h_length);
116        }
117        if (connect(sClient, (struct sockaddr *)&server,sizeof(server)) == SOCKET_ERROR)
118        {
119            printf("connect() failed: %d\n", WSAGetLastError());
120            return 1;
121        }
122
123        // 发送和接收数据
124        for(i = 0; i < dwCount; i++)
125        {
126            ret = send(sClient, szMessage, strlen(szMessage), 0);
127            if (ret == 0)
128                break;
129            else if (ret == SOCKET_ERROR)
130            {
131                printf("send() failed: %d\n", WSAGetLastError());
132                break;
133            }
134            printf("Send %d bytes\n", ret);
135            if (!bSendOnly)
136            {
137                ret = recv(sClient, szBuffer, DEFAULT_BUFFER, 0);
138                if (ret == 0) // Graceful close
139                    break;
140                else if (ret == SOCKET_ERROR)
141                {
142                    printf("recv() failed: %d\n", WSAGetLastError());
143                    break;
144                }
145                szBuffer[ret] = '\0';
146                printf("RECV [%d bytes]: '%s'\n", ret, szBuffer);
147            }
148        }
149        closesocket(sClient);
150        WSACleanup();
151        return 0;
152}
153
154
155
156
157   void  usage()
158 {
159    printf("usage: client [-p:x] [-s:IP] [-n:x] [-o]\n\n");
160    printf(" -p:x Remote port to send to\n");
161    printf(" -s:IP Server's IP address or hostname\n");
162    printf(" -n:x Number of times to send message\n");
163    printf(" -o Send messages only; don't receive\n");
164    ExitProcess(1);
165}
166
167
168 //  函数：ValidateArgs
169 //  说明：解释命令行参数，设置全局变量
170 void  ValidateArgs( int  argc,  char   ** argv)
171 {
172    int i;
173    for(i = 1; i < argc; i++)
174    {
175        if ((argv[i][0] == '-') || (argv[i][0] == '/'))
176        {
177            switch (tolower(argv[i][1]))
178            {
179            case 'p': // Remote port
180                if (strlen(argv[i]) > 3)
181                    iPort = atoi(&argv[i][3]);
182                break;
183                
184            case 's': // Server
185                if (strlen(argv[i]) > 3)
186                    strcpy(szServer, &argv[i][3]);
187                break;
188            case 'n': // Number of times to send message
189                if (strlen(argv[i]) > 3)
190                    dwCount = atol(&argv[i][3]);
191                break;
192            case 'o': // Only send message; don't receive
193                bSendOnly = TRUE;
194                break;
195            default:
196                usage();
197                break;
198            }
199        }
200    }
201}
202