服务器客户端

服务器：

1. 
   
2. #include "winsock2.h"  
3. #pragma comment(lib, "ws2_32.lib")  
4. #include <iostream>  
5. using namespace std;  
6. 
   
7. int main(int argc, char* argv[])  
8. {  
9.     const int BUF_SIZE = 64;  
10.     WSADATA         wsd;            //WSADATA变量  
11.     SOCKET          sServer;        //服务器套接字  
12.     SOCKET          sClient;        //客户端套接字  
13.     SOCKADDR_IN     addrServ;;      //服务器地址  
14.     char            buf[BUF_SIZE];  //接收数据缓冲区  
15.     char            sendBuf[BUF_SIZE];//返回给客户端得数据  
16.     int             retVal;         //返回值  
17. 
    
18.     //初始化套结字动态库  
19.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)  
20.     {  
21.         cout << "WSAStartup failed!" << endl;  
22.         return 1;  
23.     }  
24.       
25.     //创建套接字  
26.     sServer = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);      
27.     if(INVALID_SOCKET == sServer)  
28.     {  
29.         cout << "socket failed!" << endl;  
30.         WSACleanup();//释放套接字资源;  
31.         return  -1;  
32.     }  
33.       
34.     //服务器套接字地址   
35.     addrServ.sin_family = AF_INET;  
36.     addrServ.sin_port = htons(4999);  
37.     addrServ.sin_addr.s_addr = INADDR_ANY;      
38.   
39.     //绑定套接字  
40.     retVal = bind(sServer, (LPSOCKADDR)&addrServ, sizeof(SOCKADDR_IN));  
41.     if(SOCKET_ERROR == retVal)  
42.     {     
43.         cout << "bind failed!" << endl;  
44.         closesocket(sServer);   //关闭套接字  
45.         WSACleanup();           //释放套接字资源;  
46.         return -1;  
47.     }  
48.       
49.     //开始监听   
50.     retVal = listen(sServer, 1);  
51.     if(SOCKET_ERROR == retVal)  
52.     {  
53.         cout << "listen failed!" << endl;         
54.         closesocket(sServer);   //关闭套接字  
55.         WSACleanup();           //释放套接字资源;  
56.         return -1;  
57.     }  
58.       
59.     //接受客户端请求  
60.     sockaddr_in addrClient;  
61.     int addrClientlen = sizeof(addrClient);  
62.     sClient = accept(sServer,(sockaddr FAR*)&addrClient, &addrClientlen);  
63.     if(INVALID_SOCKET == sClient)  
64.     {  
65.         cout << "accept failed!" << endl;         
66.         closesocket(sServer);   //关闭套接字  
67.         WSACleanup();           //释放套接字资源;  
68.         return -1;  
69.     }  
70.       
71.     while(true)  
72.     {  
73.         //接收客户端数据  
74.         ZeroMemory(buf, BUF_SIZE);  
75.         retVal = recv(sClient, buf, BUF_SIZE, 0);  
76.         if (SOCKET_ERROR == retVal)  
77.         {  
78.             cout << "recv failed!" << endl;       
79.             closesocket(sServer);   //关闭套接字  
80.             closesocket(sClient);   //关闭套接字       
81.             WSACleanup();           //释放套接字资源;  
82.             return -1;  
83.         }  
84.         cout << "客户端发送的数据: " << buf <<endl;  
85.           
86.         cout << "向客户端发送数据: " ;  
87.         cin >> sendBuf;  
88.           
89.         send(sClient, sendBuf, strlen(sendBuf), 0);  
90.     }  
91.       
92.     //退出  
93.     closesocket(sServer);   //关闭套接字  
94.     closesocket(sClient);   //关闭套接字  
95.     WSACleanup();           //释放套接字资源;  
96.       
97.     return 0;  
98. }  

客户端：

1. #include "winsock2.h"  
2. #include <iostream>  
3. #pragma comment(lib, "ws2_32.lib")  
4. using namespace std;  
5. 
   
6. BOOL RecvLine(SOCKET s, char* buf); //读取一行数据  
7.   
8. int main(int argc, char* argv[])  
9. {  
10.    const int BUF_SIZE = 64;  
11.   
12.    WSADATA wsd; //WSADATA变量  
13.    SOCKET sHost; //服务器套接字  
14.    SOCKADDR_IN servAddr; //服务器地址  
15.    char buf[BUF_SIZE]; //接收数据缓冲区  
16.    char bufRecv[BUF_SIZE];  
17.    int retVal; //返回值  
18. 
    
19.    //初始化套结字动态库  
20.    if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)  
21.    {  
22.       cout << "WSAStartup failed!" << endl;  
23.       return -1;  
24.    }  
25. 
    
26.    //创建套接字  
27.    sHost = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);  
28.    if(INVALID_SOCKET == sHost)  
29.    {  
30.       cout << "socket failed!" << endl;  
31.       WSACleanup();//释放套接字资源  
32.       return  -1;  
33.    }  
34.   
35.    //设置服务器地址  
36.    servAddr.sin_family =AF_INET;  
37.    servAddr.sin_addr.s_addr = inet_addr("127.0.0.1");  
38.    servAddr.sin_port = htons((short)4999);  
39.    int nServAddlen  = sizeof(servAddr);  
40.   
41.    //连接服务器  
42.    retVal=connect(sHost,(LPSOCKADDR)&servAddr, sizeof(servAddr));  
43.    if(SOCKET_ERROR == retVal)  
44.    {  
45.        cout << "connect failed!" << endl;  
46.        closesocket(sHost); //关闭套接字  
47.        WSACleanup(); //释放套接字资源  
48.        return -1;  
49.    }  
50.    while(true)  
51.   {  
52.     //向服务器发送数据  
53.     ZeroMemory(buf, BUF_SIZE);  
54.     cout << " 向服务器发送数据:  ";  
55.     cin >> buf;  
56.     retVal = send(sHost, buf, strlen(buf), 0);  
57.     if (SOCKET_ERROR == retVal)  
58.     {  
59.         cout << "send failed!" << endl;  
60.         closesocket(sHost); //关闭套接字  
61.         WSACleanup(); //释放套接字资源  
62.         return -1;  
63.     }  
64.      //RecvLine(sHost, bufRecv);  
65.     ZeroMemory(bufRecv, BUF_SIZE);  
66.     recv(sHost, bufRecv,BUF_SIZE , 0); // 接收服务器端的数据， 只接收5个字符  
67.     cout << endl <<"从服务器接收数据："<< bufRecv;  
68.     cout<<"\n";  
69.   }  
70. 
    
71.    //退出  
72.    closesocket(sHost); //关闭套接字  
73.    WSACleanup(); //释放套接字资源  
74.    return 0;  
75. }