一个简单的C语言的socket服务器和客户端程序

admin

程序很简单，windows环境下的，客户端和服务器程序都在本机运行，在客户端输入发送给服务器的字符串，服务器收到字符串后会打印出来，同时与"abc"比较，与"abc"相同就会返给客户端，输入的是正确的，不同会告诉客户端输入时错误的。
; T4 _7 x" U+ n' h客户端程序：client.cpp
/ |  a- s0 k. L( [0 f; Y1 L

1. #include <winsock2.h>
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. 
   $ ]- k4 ~/ }4 O6 Q) n
5. #define DEFAULT_PORT       5150
   
6. #define DEFAULT_BUFFER     2048
   
7. 
   ; Z! I- |! q) `+ V
8. char  szServer[128],
   
9.      szMessage[1024];
   1 x! y' Y( _, E( l# n# A% R1 G4 i$ n
10. int  iPort    = DEFAULT_PORT;
    
11. 
    & O0 s# Y6 i2 i# \0 N
12. int main()
    
13. {
    
14.    WSADATA      wsd;
    
15.    SOCKET       sClient;
    ! u) Z7 ~; E# H- B  d
16.    char         szBuffer[DEFAULT_BUFFER];
    
17.    int          ret;
    # A. {, G/ X) R
18.     struct sockaddr_in server;
    ! b, H3 L9 P( ?- z/ }) O7 m
19.     struct hostent    *host = NULL;
    
20.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    * M' p6 V9 }8 g: D
21.     {
    
22.        printf("Failed to load Winsock library!\n");
    
23.        return 1;
    6 _# W) o% J. w# V; h
24.     }
    
25.    printf("Enter a string to send to server:\n");
    
26.    gets(szMessage);
    # c+ c( Z9 ]: u- u3 v0 y
27.     // Create the socket, and attempt to connect to the server
    5 M+ w& S' |0 C( @+ v
28.     sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    
29.     if (sClient == INVALID_SOCKET)
    ; Z% k/ A) D! ^" F# ]8 C/ Q
30.     {
    0 v- |6 q" L$ N$ e: h8 u
31.        printf("socket() failed: %d\n", WSAGetLastError());
    
32.        return 1;
    
33.     }
    ' J! @# A2 a2 y, Z2 f
34.    server.sin_family = AF_INET;
    ' i% O, Y2 {+ B# w& L9 I
35.    server.sin_port = htons(iPort);
    & R8 O4 ^+ f. C/ @( ~" }7 h& S) j5 e
36.    server.sin_addr.s_addr = inet_addr("127.0.0.1");
    ( c0 E: Y# E, w3 M9 C& p& v
37. 
    
38.     if (connect(sClient, (struct sockaddr *)&server,
    & K+ g4 j7 i' z
39.        sizeof(server)) == SOCKET_ERROR)
    % Y* z5 R4 k. \2 B
40.     {
    
41.        printf("connect() failed: %d\n", WSAGetLastError());
    9 H1 k& z: H( ~, s# H9 O+ P9 F
42.        return 1;
    % ~6 H- p2 z: _/ l$ |& o
43.     }
    
44.     // Send and receive data
    * l+ ^* W2 j. I4 L
45.     ret = send(sClient, szMessage, strlen(szMessage), 0);
    $ x0 K0 b" n, A* o* A( o" C3 Y4 c
46.     if (ret == SOCKET_ERROR)
    # O  _9 ]8 Z. d5 U6 A* G! V7 m
47.     {
    ' {& K5 b- Y6 }! x) c. G3 B0 g# y
48.        printf("send() failed: %d\n", WSAGetLastError());
    
49.     }
    , O4 s, c# a  o; e- K
50.     else{
    9 L9 j, L$ y# U+ m3 q0 T3 O
51.        printf("Send '%s' \n", szMessage);
    : n5 F8 h3 a. P
52.        ret = recv(sClient, szBuffer, DEFAULT_BUFFER, 0);
    : X" O; b- [: x! O* B
53.        if (ret == SOCKET_ERROR){
    % e! j% }$ ^6 a. L3 @6 A! L
54.          printf("recv() failed: %d\n", WSAGetLastError());
    
55.        }
    
56.        else{
    
57.          szBuffer[ret] = '\0';
    
58.          printf("RECV: '%s'\n",szBuffer);
    
59.        }
    
60.     }
    
61.    closesocket(sClient);
    
62. 
    ! |5 f% [" c1 C1 y6 K
63.    WSACleanup();
    
64.     return 0;
    
65. }

复制代码

服务器程序:server.cpp

1. #include <winsock2.h>
   
2. #include <stdio.h>
   , I' l% f! \# w: h. h* L
3. #include <stdlib.h>
   6 o8 S" N6 @% N9 h# T
4. 
   ( s/ Z3 H" E9 t) ]* c4 S" C
5. #define DEFAULT_PORT       5150
   
6. #define DEFAULT_BUFFER     4096
   
7. 
   + \" n: Q0 A6 Q- v( J
8. int   iPort     = DEFAULT_PORT;
   
9. char   szAddress[128];
   
10. 
    
11. DWORD WINAPI ClientThread(LPVOID lpParam)
    
12. {
    $ K* R( t- `2 O0 D4 u7 a
13.    SOCKET       sock=(SOCKET)lpParam;
    # T4 G' g6 \1 j( Q# _
14.    char         szBuff[DEFAULT_BUFFER];
    2 q9 v% {9 _' y
15.    int          ret;
    
16. 
    
17.    while(1)
    " R/ G& n. ?7 l1 E' }: ^
18.     {
    
19.        ret = recv(sock, szBuff, DEFAULT_BUFFER, 0);
    1 |, D3 a$ y, c1 ~3 h; I
20.        if (ret == 0)
    / g; @6 k+ e, M0 m9 ~
21.            break;
    * K  r. F; P) v! Z; o1 U
22.        else if (ret == SOCKET_ERROR)
    & U7 U0 K" @% ?2 t+ N
23.        {
    
24.            printf("recv() failed: %d\n", WSAGetLastError());
    
25.            break;
    
26.        }
    
27.        szBuff[ret] = '\0';
    
28.        printf("RECV: '%s'\n", szBuff);
    
29.       if(strcmp(szBuff,"abc")==0){
    % i! h0 `" o6 |+ Z$ f! \5 P( O
30.          memcpy(szBuff,"Send the correct string!",25);
    
31.        }
    
32.        else{
    
33.          memcpy(szBuff,"Send the wrong string!",23);
    3 r" W+ P: n0 p5 z! L' `; U5 h
34.        }
    
35.        ret = send(sock, szBuff, strlen(szBuff), 0);
    
36.        if (ret == SOCKET_ERROR){
    
37.          printf("send() failed: %d\n", WSAGetLastError());
    2 o8 x5 @, H' R1 ^
38.        }
    5 o9 s( s3 ^$ c  |
39.     }
    1 V$ B4 Y& Y( u: M$ W; a# R) v; R
40.     return 0;
    / g+ w/ @: G$ v. w
41. }
    , e- g  B) V- v  J
42. 
    
43. int main()
    
44. {
    
45.    WSADATA      wsd;
    
46.    SOCKET       sListen,
    ; u( I( m4 K7 s2 r$ o# i8 \# R3 A
47.                  sClient;
    ) ]7 a7 P8 v6 U* k
48.    int          iAddrSize;
    ( d3 i3 R3 m# |8 T" C. j- ?0 k" s
49.    HANDLE       hThread;
    # z4 l. X3 a5 q; q1 w
50.    DWORD        dwThreadId;
    
51.     struct sockaddr_in local,
    + n$ h) O* \2 {, t
52.                       client;
    5 R3 [& Y5 y1 I) H  [* F* B
53. 
    
54.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    * d3 g* C0 E4 \
55.     {
    + j: {  g0 t! L, }" m* o4 J- d
56.        printf("Failed to load Winsock!\n");
    
57.        return 1;
    
58.     }
    2 X/ X, w8 Y, Y; v6 t; f
59.     // Create our listening socket
    ! X" @& O' q& J% t
60.     sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
    
61.     if (sListen == SOCKET_ERROR)
    & N4 L& g$ k" f+ z% H0 {* B
62.     {
    - F* v7 |% j& f' V+ `$ p. }+ y
63.        printf("socket() failed: %d\n", WSAGetLastError());
    
64.        return 1;
    & p4 Q) w7 p- ~5 W6 C
65.     }
    
66.    local.sin_addr.s_addr = htonl(INADDR_ANY);
    
67.    local.sin_family = AF_INET;
    
68.    local.sin_port = htons(iPort);
    / r7 o2 C6 J5 p( K+ k' a
69. 
    2 E+ c) n- w* J. Y7 R& b! g5 U
70.     if (bind(sListen, (struct sockaddr *)&local,
    - h( L6 O' P' C
71.            sizeof(local)) == SOCKET_ERROR)
      i3 C0 s2 @. J) f' s$ m' F" G
72.     {
    ( i1 E8 P1 q/ [
73.        printf("bind() failed: %d\n", WSAGetLastError());
    # J$ k$ `7 Y6 Z
74.        return 1;
    2 L2 f  V' q* Y( _% N* I
75.     }
    , Z" m2 C( S3 B
76.    listen(sListen, 8);
    9 t" h1 [' o- w& X
77.     // In a continous loop, wait for incoming clients. Once one
    + b1 |4 d5 ~8 k1 X1 h
78.     // is detected, create a thread and pass the handle off to it.
    % x0 V' m+ ~- b7 i0 L' X
79.     while (1)
    , L+ g8 C9 I! c' m' z
80.     {
    9 Y( g) V1 _. k1 Q: O( x: g* S
81.        iAddrSize = sizeof(client);
    / ]% Z& c0 O) {. _( }( b# d% R6 {
82.        sClient = accept(sListen, (struct sockaddr *)&client,
    $ v6 a7 Q5 r/ i/ s  I' {
83.                        &iAddrSize);      
    / n3 c1 U' {6 v& V5 P
84.        if (sClient == INVALID_SOCKET)
    " |! n0 I% X0 X/ U; u5 u
85.        {      
    
86.            printf("accept() failed: %d\n", WSAGetLastError());
    7 O8 [! H  X' A# s
87.            break;
    
88.        }
    # J0 R$ ?' q8 @# E  ^$ {* _9 D# P: B
89.        printf("Accepted client: %s:%d\n",
    
90.            inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    
91. 
    7 j- a9 q8 @9 O$ K7 `% E4 {4 K
92.        hThread = CreateThread(NULL, 0, ClientThread,
    " @7 k, y  D1 q5 r
93.                    (LPVOID)sClient, 0, &dwThreadId);
    
94.        if (hThread == NULL)
    ( o' X: X& F9 E- l) I
95.        {
    % F( N7 c1 F" W
96.            printf("CreateThread() failed: %d\n", GetLastError());
    
97.            break;
    
98.        }
    8 E: w$ e" ~4 @0 s. f
99.        CloseHandle(hThread);
    # t' Q# o' P3 _  b0 C) ]8 ?
100.     }
     
101.    closesocket(sListen);
     2 i" p  w0 L/ j' G7 b! ?
102.    
     
103.    WSACleanup();
     
104.     return 0;
     , L1 j, D( d  H" w
105. }

复制代码

2 ?' g1 Y4 p' W3 c

admin

1. 作为服务器，你要绑定【bind】到本地的IP地址上进行监听【listen】，但是你的机器上可能有多块网卡，也就有多个IP地址，这时候你要选择绑定在哪个IP上面，如果指定为INADDR_ANY，那么系统将绑定默认的网卡【即IP地址】。
   1 |( d$ [6 P, G6 W6 o5 g- r3 b1 f# M
2. 
   ) _7 b- x6 D- p& D' f( d
3. 作为客户端，你要连接【connect】到远端的服务器，也是要指定远端服务器的（ip, port）对。
   
4. 当然，在这种情况下，不可能将IP地址指定为INADDR_ANY，系统会疯掉的。
   
5. 
   
6. Server：
   
7. #include <winsock2.h>
   + T+ d( a' s1 C- ?( |: z" U- o) @
8. #pragma comment(lib, "WS2_32.lib")
   
9. 
   
10. #include <stdio.h>
    
11. void main()
    6 e2 S! v6 L$ B4 X
12. {
    2 |' ]% [! R- N, T& ^
13.     WORD wVersionRequested;//版本号
    
14.     WSADATA wsaData;
    
15.     int err;
    $ j& ]0 V2 G6 J3 Q. J
16. 
    
17.     wVersionRequested = MAKEWORD(2, 2);//2.2版本的套接字
    
18.     //加载套接字库,如果失败返回
    
19.     err = WSAStartup(wVersionRequested, &wsaData);
    
20.     if (err != 0)
    
21.     {
    ) k. Q7 Q$ U. e' f! o/ o: K
22.         return;
    . @" t2 Q# @7 k9 y4 t: z7 A) c
23.     }
    
24. 
    $ [( X( I" S6 j$ \: H
25.     //判断高低字节是不是2,如果不是2.2的版本则退出
    ! t( a3 J  V! `$ H% r: [" Y
26.     if (LOBYTE(wsaData.wVersion) != 2 ||
    
27.          
    
28.         HIBYTE(wsaData.wVersion) != 2)
    ) ^' a4 s. X4 a
29.          
    
30.     {
    " m2 q, b! P' c. L' W% C1 g4 W
31.         return;
    7 I3 |+ f2 \; J
32.     }
    
33.      
    
34.          //创建流式套接字,基于TCP(SOCK_STREAM)
    
35. 
    
36.          SOCKET socSrv = socket(AF_INET, SOCK_STREAM, 0);
    
37. 
    
38.          //Socket地址结构体的创建
    
39. 
    3 v% b; p5 i$ K2 T, ]
40.          SOCKADDR_IN addrSrv;
    
41. 
    # K. ]8 h4 f  P' Y
42.          addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);//转换Unsigned long型为网络字节序格
    
43.          addrSrv.sin_family = AF_INET;//指定地址簇
    0 G$ p7 p, t# }
44.          addrSrv.sin_port = htons(6000);
    5 j* ?8 F  R1 k  U
45.         //指定端口号,除sin_family参数外,其它参数都是网络字节序,因此需要转换
    
46. 
    
47.          //将套接字绑定到一个端口号和本地地址上
    9 X: q; k, k! B: w9 j9 k# B
48.          bind(socSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));//必须用sizeof，strlen不行
      S/ ~: S/ s, T# z' O6 k: v
49. 
    
50.          listen(socSrv, 5);
    " U+ N; g' @# q4 Y1 l
51.          
    ! k' C* k. W8 Y& p2 {: d1 I; c
52.          SOCKADDR_IN addrClient;//字义用来接收客户端Socket的结构体
    
53. 
    
54.          int len = sizeof(SOCKADDR);//初始化参数,这个参数必须进行初始化，sizeof
    ( H) o9 S. ~- I! w: B- n
55. 
    
56.          //循环等待接受客户端发送请求
    6 u: M! F1 h% n
57. 
    
58.          while (1)
    
59.          {
    
60.                    //等待客户请求到来；当请求到来后，接受连接请求，
    
61. 
    . ~3 \" Q/ U* }
62.                    //返回一个新的对应于此次连接的套接字（accept）。
    + K( c0 m' y' |. L5 h
63.                    //此时程序在此发生阻塞
    
64. 
    ) B! P1 v! o! e, U) ]8 m0 f
65.                    SOCKET sockConn = accept(socSrv, (SOCKADDR*)&addrClient, &len);
    ' u; w; L  w$ ?, H. |( C6 k% t4 D
66. 
    ' w7 f1 _  H7 Z+ a1 S1 R
67.                    char sendBuf[100];
    
68. 
    # o# o6 n+ D" s# m
69.                    sprintf(sendBuf, "Welcome %s to JoyChou",
    7 X+ U: ~, C/ [% R
70. 
    
71.                             inet_ntoa(addrClient.sin_addr));//格式化输出
    
72. 
    
73.                    //用返回的套接字和客户端进行通信
    ; R# a% T0 |0 p9 r7 l" o8 K1 c
74. 
    7 {6 b0 g, q3 D5 k: b3 @
75.                    send(sockConn, sendBuf, strlen(sendBuf)+1, 0);//多发送一个字节
    
76. 
    0 @4 g: P0 r# t+ P. x
77.                    //接收数据
    # K( G. F6 F  R* H7 u4 l6 E
78. 
    " p' G1 J! k, L) n( U
79.                    char recvBuf[100];
    
80. 
    
81.                    recv(sockConn, recvBuf, 100, 0);
    
82. 
    ' ]+ r- g, n) u' N
83.                    printf("%s\n", recvBuf);
    
84.                    closesocket(sockConn);
    . k: T1 @8 \8 T( V4 Y  |& Y+ v# T
85. 
    
86.          }
    ' j- i1 R# c- t3 L
87. }
    
88. 
    
89. 
    / a# z  E. r7 X. f9 O5 g  r: ]- z
90. Client：
    , p, v  B& Y8 Z2 N0 U4 W
91. 
    7 a1 z, H( J/ ~
92. #include <winsock2.H>
    9 F6 L1 b( i3 Y6 ^
93. #pragma comment(lib, "Ws2_32.lib")
    ( J# c! W/ D" E/ v
94. #include <stdio.h>
    * u+ k  B/ Q) c) B8 N% R
95. #include <string.h>
    6 ]. j  B+ u. C, ]6 p2 J$ _
96. 
    6 v+ {' ~$ v0 e7 V8 v" Y/ ~" Z
97. void main()
      b4 ?" Q& k" Q( Z! W
98. {   
    
99.     WORD wVersionRequested;
    & i/ i. L( p; e3 e$ v( a
100.     WSADATA wsaData;
     - Z! K  U8 u# V) Z
101.     int err;
     # _( [- W3 w8 b  ?4 n4 d% d9 V
102.      
     5 c+ v8 ~. H* N3 p' k6 x
103.     wVersionRequested = MAKEWORD( 2, 2 );
     
104.      
     / e( [* Z* U) F3 n
105.     err = WSAStartup( wVersionRequested, &wsaData );
     : ]9 ?. k9 n0 `& @& c4 x
106.     if ( err != 0 ) {
     
107.          
     % O! O3 X4 H) a4 R% P" C1 N
108.         return;
     
109.     }
     
110.      
     
111.      
     ' [) v; {/ G! `$ J3 [! ?9 ]
112.     if ( LOBYTE( wsaData.wVersion ) != 2 ||
     
113.         HIBYTE( wsaData.wVersion ) != 2 )
     
114.     {
     7 x7 ?" P% k8 E0 L3 k# n
115.          
     
116.         WSACleanup( );
     8 {8 h8 m6 v3 @5 Z6 u$ C$ Q9 l
117.         return;
     
118.     }
     
119.     SOCKET socketClient = socket(AF_INET, SOCK_STREAM, 0);
     
120.     SOCKADDR_IN addrSrv;
     3 K1 Z# m7 E3 i& r
121.     addrSrv.sin_family = AF_INET;
     
122.     addrSrv.sin_port = htons(6000);
     2 Z5 I9 W3 s& c( n4 y) s
123.     addrSrv.sin_addr.S_un.S_addr = inet_addr("192.168.1.101");//服务器端的IP地址
     
124.      
     
125.     connect(socketClient, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
     
126.     char recvBuf[256];
     
127.     char sendBuf[] = "This is Joychou";
     
128.     recv(socketClient, recvBuf, 256, 0);
     
129.     printf("%s\n", recvBuf);
     
130.     send(socketClient, sendBuf, strlen(sendBuf) + 1, 0);
     8 ~" f" s  u4 S; B8 |, _+ j
131.     closesocket(socketClient);
     . l, s. h, Z. R: s$ f. M
132.     WSACleanup();
     2 ?2 B, |: Y) e
133.      
     
134. }

复制代码

+ _$ c( S; b' \4 U( a1 V# l