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

admin

程序很简单，windows环境下的，客户端和服务器程序都在本机运行，在客户端输入发送给服务器的字符串，服务器收到字符串后会打印出来，同时与"abc"比较，与"abc"相同就会返给客户端，输入的是正确的，不同会告诉客户端输入时错误的。
客户端程序：client.cpp

1. #include <winsock2.h>
   
2. #include <stdio.h>
   6 x; S9 l- s6 ^. P5 W! e2 G2 V
3. #include <stdlib.h>
   
4. 
   ' u6 k' {2 s- {1 N8 A; C' S* I
5. #define DEFAULT_PORT       5150
   
6. #define DEFAULT_BUFFER     2048
   
7. 
   # a2 Q+ O% \4 B' A: `* l
8. char  szServer[128],
   1 ~! _' G4 Z/ G1 Y8 Z* R$ i
9.      szMessage[1024];
   ) U7 }+ U! G6 K) `* {. Z
10. int  iPort    = DEFAULT_PORT;
    5 N) A% p8 n! V. x; ^1 C
11. 
    
12. int main()
    $ [1 q, s% @+ ^4 z' R0 L  y* @
13. {
    
14.    WSADATA      wsd;
    ; }, p( [8 L# l6 C1 r$ |2 H
15.    SOCKET       sClient;
    
16.    char         szBuffer[DEFAULT_BUFFER];
    
17.    int          ret;
    - z; [0 ]/ y- i( i5 D& }3 R
18.     struct sockaddr_in server;
    
19.     struct hostent    *host = NULL;
    
20.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    
21.     {
    
22.        printf("Failed to load Winsock library!\n");
    
23.        return 1;
    - W" W; {, Z( u3 w! s5 a
24.     }
    , e6 d0 l, {- u+ B; y
25.    printf("Enter a string to send to server:\n");
    
26.    gets(szMessage);
    2 `3 d) y$ p' d
27.     // Create the socket, and attempt to connect to the server
    % ^8 a6 S- ?3 {3 T% Y
28.     sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    3 s  a/ J# ?% G  h* K
29.     if (sClient == INVALID_SOCKET)
    
30.     {
    
31.        printf("socket() failed: %d\n", WSAGetLastError());
    
32.        return 1;
    
33.     }
    
34.    server.sin_family = AF_INET;
    # M& Y! l$ \4 H: e& B: M$ L
35.    server.sin_port = htons(iPort);
    - V; A( [/ B9 c
36.    server.sin_addr.s_addr = inet_addr("127.0.0.1");
    
37. 
    % T4 Q) `$ F8 c
38.     if (connect(sClient, (struct sockaddr *)&server,
    
39.        sizeof(server)) == SOCKET_ERROR)
    
40.     {
    
41.        printf("connect() failed: %d\n", WSAGetLastError());
    
42.        return 1;
    
43.     }
    $ D! z& D- G7 @$ f- g
44.     // Send and receive data
    - R1 N# A5 Y8 {
45.     ret = send(sClient, szMessage, strlen(szMessage), 0);
    ( U, W$ l& G$ M- g, C- M3 ^
46.     if (ret == SOCKET_ERROR)
    
47.     {
    
48.        printf("send() failed: %d\n", WSAGetLastError());
    % o; A# w# f9 o6 d
49.     }
    ! k; x* h" J, W9 h2 ]
50.     else{
    
51.        printf("Send '%s' \n", szMessage);
    5 ]& |& W  b5 t$ i% d6 L
52.        ret = recv(sClient, szBuffer, DEFAULT_BUFFER, 0);
    
53.        if (ret == SOCKET_ERROR){
    3 j6 ^7 e& R0 A* W" c
54.          printf("recv() failed: %d\n", WSAGetLastError());
    ' M- _* r9 R, b+ P- V5 H
55.        }
    ( z6 g$ _0 P7 K8 n2 d* G
56.        else{
    - }. Z" `+ a4 X% l' [- K
57.          szBuffer[ret] = '\0';
    
58.          printf("RECV: '%s'\n",szBuffer);
    
59.        }
    
60.     }
    
61.    closesocket(sClient);
    
62. 
    
63.    WSACleanup();
    
64.     return 0;
    4 C: A# `: ]8 i1 Y0 Q+ d$ g
65. }

复制代码

服务器程序:server.cpp

1. #include <winsock2.h>
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   $ H5 W1 k2 |* L' p. V
4. 
   9 T! D3 q; Z: J  i3 x( }) X8 s' a8 j
5. #define DEFAULT_PORT       5150
   # O3 a/ ?. C# I4 ~2 O2 Y( ~
6. #define DEFAULT_BUFFER     4096
   
7. 
   1 z, A& t" s% r4 [+ Q$ Q7 O0 h: R
8. int   iPort     = DEFAULT_PORT;
   0 k- h% \$ i, s$ X  Z! W
9. char   szAddress[128];
   ' k  A* `1 ?" s$ C- L& i& Y5 Q
10. 
    
11. DWORD WINAPI ClientThread(LPVOID lpParam)
    ' P$ m1 F1 c. w7 P1 J  m
12. {
    ( I' `% m( Y& [6 m- T8 f
13.    SOCKET       sock=(SOCKET)lpParam;
    1 }" d. x; d! Q; H7 q; A
14.    char         szBuff[DEFAULT_BUFFER];
    
15.    int          ret;
    
16. 
    3 f2 C% |! r% c7 I. r+ ]
17.    while(1)
    $ N8 Z" A3 m7 ^* N
18.     {
    2 p0 j! k. ]% r; f4 R3 A
19.        ret = recv(sock, szBuff, DEFAULT_BUFFER, 0);
    , a7 v5 z  k" [* l/ n$ ?
20.        if (ret == 0)
    
21.            break;
    
22.        else if (ret == SOCKET_ERROR)
    
23.        {
    
24.            printf("recv() failed: %d\n", WSAGetLastError());
    " w& s- V! [) ~& ?+ L6 @1 C( f
25.            break;
    
26.        }
    3 e9 u7 s% h* c- a! b* s0 A
27.        szBuff[ret] = '\0';
    
28.        printf("RECV: '%s'\n", szBuff);
    
29.       if(strcmp(szBuff,"abc")==0){
    - M+ [, c2 F* B$ `
30.          memcpy(szBuff,"Send the correct string!",25);
    5 e, u5 T  g4 s$ ~! ^4 Q: x
31.        }
    1 z8 N* ?6 E$ y5 v$ e. i3 K% X1 Q
32.        else{
    
33.          memcpy(szBuff,"Send the wrong string!",23);
    ! a  i: I6 d: K; `1 N) d5 n
34.        }
    
35.        ret = send(sock, szBuff, strlen(szBuff), 0);
    7 \; \5 I$ D8 D& s2 K3 K% }4 M
36.        if (ret == SOCKET_ERROR){
    
37.          printf("send() failed: %d\n", WSAGetLastError());
    ) x8 I1 Z; }) i1 y* x6 b0 V/ w
38.        }
    
39.     }
    $ a& j* S/ ^) q
40.     return 0;
    : a! E) x; b, c, k& g% ~: P
41. }
    - {' t2 {0 D) b: B
42. 
    
43. int main()
    
44. {
    
45.    WSADATA      wsd;
    
46.    SOCKET       sListen,
    7 h* I/ u) ]$ d* j8 ~6 j
47.                  sClient;
    
48.    int          iAddrSize;
    
49.    HANDLE       hThread;
    $ `2 x- G# d* |! f3 g; I9 a
50.    DWORD        dwThreadId;
    
51.     struct sockaddr_in local,
    
52.                       client;
    
53. 
    " o: b+ J$ r: ?8 ~5 @% Z- E
54.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    & I# y) X: H2 r# E
55.     {
    
56.        printf("Failed to load Winsock!\n");
    * G/ V/ R2 k# J2 e
57.        return 1;
    
58.     }
    3 Y% S: C: ]$ }" c8 ], g
59.     // Create our listening socket
    
60.     sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
    4 Y8 ?- N# q+ y7 \9 ?
61.     if (sListen == SOCKET_ERROR)
    
62.     {
    
63.        printf("socket() failed: %d\n", WSAGetLastError());
    - y" U; g( r# [6 d& e3 e4 E9 u( M
64.        return 1;
    4 `8 k" |6 z# Q+ T! [, ^
65.     }
    
66.    local.sin_addr.s_addr = htonl(INADDR_ANY);
    % l1 T/ @" @4 h0 G8 H. T* ]
67.    local.sin_family = AF_INET;
    
68.    local.sin_port = htons(iPort);
    , r( z* l7 O1 m6 ]4 p) ]
69. 
    
70.     if (bind(sListen, (struct sockaddr *)&local,
    5 R4 ]. ~" ?$ D1 n+ y
71.            sizeof(local)) == SOCKET_ERROR)
    6 h# I7 g1 |; i2 \) E) G( u) p
72.     {
    " P/ v$ p8 X0 M1 a# {9 q/ n: j/ y
73.        printf("bind() failed: %d\n", WSAGetLastError());
    
74.        return 1;
    
75.     }
    
76.    listen(sListen, 8);
    / X( S3 W# y. }9 t2 ^
77.     // In a continous loop, wait for incoming clients. Once one
    
78.     // is detected, create a thread and pass the handle off to it.
    3 s  G/ `9 N' ~: K: M6 z$ n5 m
79.     while (1)
    $ r2 d' n  H; C% \4 t- b0 C
80.     {
    
81.        iAddrSize = sizeof(client);
    
82.        sClient = accept(sListen, (struct sockaddr *)&client,
    
83.                        &iAddrSize);      
    
84.        if (sClient == INVALID_SOCKET)
    ' u; j" L* |6 k
85.        {      
    ) h  _/ m$ c. M: ^. P
86.            printf("accept() failed: %d\n", WSAGetLastError());
    
87.            break;
    
88.        }
    
89.        printf("Accepted client: %s:%d\n",
    
90.            inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    " E3 f  F4 ], Y
91. 
    
92.        hThread = CreateThread(NULL, 0, ClientThread,
    / X. b% ~; ^8 E+ ?7 p
93.                    (LPVOID)sClient, 0, &dwThreadId);
    / K6 E* L3 i1 q5 _. m6 x+ P, y; f
94.        if (hThread == NULL)
    8 q( U: [: ~3 E4 j2 q; k
95.        {
    
96.            printf("CreateThread() failed: %d\n", GetLastError());
    2 G& N; ]8 s- E- b# w
97.            break;
    , y" H$ v3 ~8 c
98.        }
    ! p2 j' V7 j. K* v( g. O
99.        CloseHandle(hThread);
    
100.     }
     / r* S8 Q+ k! D7 L4 P# q" ?5 g  D6 T
101.    closesocket(sListen);
     
102.    
     
103.    WSACleanup();
     ) Z9 C7 U7 o! }0 m. d1 G/ r
104.     return 0;
     
105. }

复制代码

) }4 P5 Z- X. K8 M9 m# i9 D

- x( M* R) V' ]- k  [2 D
7 Q0 v2 b, I; l2 Y! `1 G: b# h

admin

1. 作为服务器，你要绑定【bind】到本地的IP地址上进行监听【listen】，但是你的机器上可能有多块网卡，也就有多个IP地址，这时候你要选择绑定在哪个IP上面，如果指定为INADDR_ANY，那么系统将绑定默认的网卡【即IP地址】。
   
2. 
   
3. 作为客户端，你要连接【connect】到远端的服务器，也是要指定远端服务器的（ip, port）对。
   
4. 当然，在这种情况下，不可能将IP地址指定为INADDR_ANY，系统会疯掉的。
   
5. 
   # @4 j9 ?& }& ?. t. @6 J
6. Server：
   , M) h/ ~! v/ K0 z
7. #include <winsock2.h>
   
8. #pragma comment(lib, "WS2_32.lib")
   
9. 
   7 |# e# Z1 C5 ^# K3 T# o& j4 L' X
10. #include <stdio.h>
    ! |1 {4 q- \, U: r, t! D) u
11. void main()
    8 H- H8 J4 Z/ f! y+ ~7 s3 p
12. {
    8 F2 y+ R* n& F; [( c7 `1 d
13.     WORD wVersionRequested;//版本号
    
14.     WSADATA wsaData;
    5 n: n3 K; H& G; U0 j9 h$ ^+ e
15.     int err;
    
16. 
    
17.     wVersionRequested = MAKEWORD(2, 2);//2.2版本的套接字
    
18.     //加载套接字库,如果失败返回
    + {8 V6 Y8 J  {% z+ `/ e
19.     err = WSAStartup(wVersionRequested, &wsaData);
    
20.     if (err != 0)
      Y* V  v2 g6 D2 S& {" A  I" F
21.     {
    5 V, e6 i4 C" \2 a/ V4 f3 b
22.         return;
    
23.     }
    + F$ K& A3 t2 y2 d7 E* u* `
24. 
    2 y: \2 U9 u3 h7 b! _3 Y
25.     //判断高低字节是不是2,如果不是2.2的版本则退出
    ; \2 Q+ ~% v" u- U3 O5 s0 D& A: V
26.     if (LOBYTE(wsaData.wVersion) != 2 ||
    
27.          
    3 y, m6 n7 n1 o+ B
28.         HIBYTE(wsaData.wVersion) != 2)
    . s2 i* S, M5 ?
29.          
    3 X. l9 G* }' u6 |( z# R
30.     {
    
31.         return;
    
32.     }
    - `" e5 C  R2 P1 Z. g2 I
33.      
    
34.          //创建流式套接字,基于TCP(SOCK_STREAM)
      B1 C1 L: q$ i; Y( x. C
35. 
    
36.          SOCKET socSrv = socket(AF_INET, SOCK_STREAM, 0);
    
37. 
      Y4 \# ]% d1 ^" I! G2 L: ~& M! D
38.          //Socket地址结构体的创建
    ' B/ _" n$ E# Z6 F
39. 
    $ i+ b$ c8 a9 N( f
40.          SOCKADDR_IN addrSrv;
    6 a" b; F5 I8 A# ?/ |5 V. G
41. 
    ) F5 w* @% o* H) x; x
42.          addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);//转换Unsigned long型为网络字节序格
    
43.          addrSrv.sin_family = AF_INET;//指定地址簇
    
44.          addrSrv.sin_port = htons(6000);
    0 U; {- |% [1 F3 [/ w5 x/ t" T* L
45.         //指定端口号,除sin_family参数外,其它参数都是网络字节序,因此需要转换
    
46. 
    
47.          //将套接字绑定到一个端口号和本地地址上
    
48.          bind(socSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));//必须用sizeof，strlen不行
    
49. 
    
50.          listen(socSrv, 5);
    
51.          
    9 ?9 }, o- w" p3 m- a8 e
52.          SOCKADDR_IN addrClient;//字义用来接收客户端Socket的结构体
    
53. 
    ) s$ k) w, z8 H. e, y# d( M
54.          int len = sizeof(SOCKADDR);//初始化参数,这个参数必须进行初始化，sizeof
    
55. 
    ( H# h9 o: d+ P
56.          //循环等待接受客户端发送请求
    8 S: Y+ I% e' {1 Z! k
57. 
    
58.          while (1)
    2 Z" U6 u/ V8 I; {8 S
59.          {
    
60.                    //等待客户请求到来；当请求到来后，接受连接请求，
    
61. 
    
62.                    //返回一个新的对应于此次连接的套接字（accept）。
    
63.                    //此时程序在此发生阻塞
    / C9 C- Q/ u7 H. C+ p
64. 
    
65.                    SOCKET sockConn = accept(socSrv, (SOCKADDR*)&addrClient, &len);
    & ]) V4 J1 r( F4 g8 u4 j$ g0 r. x- k
66. 
    - e) ]% f. Y- z2 V; r
67.                    char sendBuf[100];
    : X7 G1 x% v4 ]% H6 V1 V/ G& z# G! X
68. 
    ! _' |  |7 }$ `6 a1 l/ i2 ~
69.                    sprintf(sendBuf, "Welcome %s to JoyChou",
    
70. 
    ) c  B" D- W, b8 ]8 a$ P4 {0 K- N& V
71.                             inet_ntoa(addrClient.sin_addr));//格式化输出
    0 R, F' J$ z, S8 Z
72. 
    . @. D0 F" n( y
73.                    //用返回的套接字和客户端进行通信
    
74. 
    
75.                    send(sockConn, sendBuf, strlen(sendBuf)+1, 0);//多发送一个字节
    & v( X) v) g6 q, k
76. 
    
77.                    //接收数据
    . x- s$ p. r. t6 e8 A
78. 
    , Z; A+ A3 r1 L! b% R; o) \
79.                    char recvBuf[100];
    ! O  X, X$ ?0 w. q' ?7 b" G
80. 
    
81.                    recv(sockConn, recvBuf, 100, 0);
    / X8 x! B+ Q; {$ V0 z/ Y4 S
82. 
    . r  M! v! K# \$ O$ ?) k
83.                    printf("%s\n", recvBuf);
    
84.                    closesocket(sockConn);
    ) P1 L1 w, W( D0 e
85. 
    
86.          }
    
87. }
    # \7 k( G3 O0 ]7 i
88. 
    
89. 
    ' j; d' @% R% ^8 @8 ?; V- h
90. Client：
    - {' K/ d1 y4 o9 Q2 A
91. 
    ) x9 d  k& e3 e+ `& [( @
92. #include <winsock2.H>
    7 v" s; }- e( ^' ^
93. #pragma comment(lib, "Ws2_32.lib")
    
94. #include <stdio.h>
    5 T0 @' l) G( G* F* @2 p
95. #include <string.h>
      q& T' [$ C' U0 h
96. 
    
97. void main()
    2 Q9 r, X# I7 Y# T9 i) P
98. {   
    
99.     WORD wVersionRequested;
    ) E- q" \, d, M: S: n
100.     WSADATA wsaData;
     " \6 ]5 a7 \  \/ M/ e
101.     int err;
     
102.      
     
103.     wVersionRequested = MAKEWORD( 2, 2 );
     5 ^- K; i& W$ _+ h- }! X  m
104.      
     ! x! L( w  L, H% z7 `. W2 f9 I
105.     err = WSAStartup( wVersionRequested, &wsaData );
     . w& t  O' q4 H% r
106.     if ( err != 0 ) {
     
107.          
     " V# @+ H' r  u. T, A
108.         return;
     
109.     }
     0 L, O# t" }0 g6 _3 U7 S& g+ L
110.      
     
111.      
     + i0 C; {1 ^6 m; ]2 J9 M8 X
112.     if ( LOBYTE( wsaData.wVersion ) != 2 ||
     1 Y- c# m" n% e" D4 R( ]" J1 M
113.         HIBYTE( wsaData.wVersion ) != 2 )
     * x+ c/ x, M) R+ v7 E
114.     {
     
115.          
     
116.         WSACleanup( );
     # R& j8 H! D6 n6 R4 l- \2 k7 @( g
117.         return;
     
118.     }
     - D6 B/ K4 X3 K5 X( Z
119.     SOCKET socketClient = socket(AF_INET, SOCK_STREAM, 0);
     
120.     SOCKADDR_IN addrSrv;
     
121.     addrSrv.sin_family = AF_INET;
     
122.     addrSrv.sin_port = htons(6000);
       f% b' L: G" g: Z! K" [' S
123.     addrSrv.sin_addr.S_un.S_addr = inet_addr("192.168.1.101");//服务器端的IP地址
     
124.      
     6 b# [  J8 o1 D
125.     connect(socketClient, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
     
126.     char recvBuf[256];
     
127.     char sendBuf[] = "This is Joychou";
     
128.     recv(socketClient, recvBuf, 256, 0);
     # A; |( r# P$ ]% `- O
129.     printf("%s\n", recvBuf);
     ' B8 ?, z% O0 h% ]# m/ c# P, Z3 N
130.     send(socketClient, sendBuf, strlen(sendBuf) + 1, 0);
     
131.     closesocket(socketClient);
     % ^. b2 `6 y; t( @" D
132.     WSACleanup();
     
133.      
     
134. }

复制代码

! J. {+ n* x# V0 ^3 h
2 P6 h8 r8 k: h! r