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

admin

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

1. #include <winsock2.h>
   & ^- D  ^1 D1 N) m0 W( @# h1 ?0 `, E
2. #include <stdio.h>
   
3. #include <stdlib.h>
   : E% l3 O6 C# W% p- W
4. 
   
5. #define DEFAULT_PORT       5150
   0 B* r, W( U) O# k! {
6. #define DEFAULT_BUFFER     2048
   ( w" z+ H0 S% @% {$ H) h$ R
7. 
   ; z" e$ k* T! J( j
8. char  szServer[128],
   9 O( V5 W) S9 T: K- e
9.      szMessage[1024];
   3 k/ g) g/ b: M: O! \7 C
10. int  iPort    = DEFAULT_PORT;
    # W, a. @* ^. t! T% C- t% D
11. 
    + M1 I' g, ?' F" ]1 `8 c/ T
12. int main()
    6 {4 @* ~0 _0 h$ k
13. {
    
14.    WSADATA      wsd;
    ) a( @# [" K( W/ }/ K8 s
15.    SOCKET       sClient;
    
16.    char         szBuffer[DEFAULT_BUFFER];
    5 B. O8 p# H( ~8 f/ Q1 |
17.    int          ret;
    
18.     struct sockaddr_in server;
    6 v6 G3 d9 W6 j: V3 {9 z. a
19.     struct hostent    *host = NULL;
    2 z3 t1 i9 r0 u& u2 d1 V4 s8 ~% h
20.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    
21.     {
    5 B" R" G/ W. Y, y% |0 ]
22.        printf("Failed to load Winsock library!\n");
    & `+ y! U2 S1 e" g
23.        return 1;
    
24.     }
    , h# @' Z: `6 g5 d8 n
25.    printf("Enter a string to send to server:\n");
    
26.    gets(szMessage);
    / Y& z. L% x* e3 W! C/ B
27.     // Create the socket, and attempt to connect to the server
    
28.     sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    " _0 Q3 v. Z+ r! _
29.     if (sClient == INVALID_SOCKET)
    
30.     {
    
31.        printf("socket() failed: %d\n", WSAGetLastError());
    
32.        return 1;
    % t! p8 [- [5 `4 d1 S6 s
33.     }
    4 d0 f+ j% C( v# o
34.    server.sin_family = AF_INET;
    
35.    server.sin_port = htons(iPort);
    5 Y6 M. S0 k( p% a' b! Q
36.    server.sin_addr.s_addr = inet_addr("127.0.0.1");
    ! I  X$ z6 o* [
37. 
    
38.     if (connect(sClient, (struct sockaddr *)&server,
    
39.        sizeof(server)) == SOCKET_ERROR)
    . @. \( C/ g  D7 B! V+ @* I+ y4 D
40.     {
    
41.        printf("connect() failed: %d\n", WSAGetLastError());
    
42.        return 1;
    
43.     }
    3 m$ B2 r! n1 g3 c, F; a. j# U
44.     // Send and receive data
    / V0 s4 Z0 `. D7 R6 a
45.     ret = send(sClient, szMessage, strlen(szMessage), 0);
    * l  k% j! M. {3 a' c
46.     if (ret == SOCKET_ERROR)
    ( Z- v& F  J! z" i7 u$ N3 \  p: l9 u
47.     {
    " F4 n1 }" J4 D0 X
48.        printf("send() failed: %d\n", WSAGetLastError());
    " N0 q4 q: X4 i1 \$ ^7 m: e
49.     }
    
50.     else{
    7 F  H/ h* e. F1 W- F4 Y$ R* n; K
51.        printf("Send '%s' \n", szMessage);
    
52.        ret = recv(sClient, szBuffer, DEFAULT_BUFFER, 0);
    ) H5 X# v3 U+ w' }+ D8 [: z
53.        if (ret == SOCKET_ERROR){
    
54.          printf("recv() failed: %d\n", WSAGetLastError());
    ( q0 M- G9 y* ]. U& |/ p
55.        }
    
56.        else{
    
57.          szBuffer[ret] = '\0';
    ! |6 F" ]8 H' f! `+ M" @7 M
58.          printf("RECV: '%s'\n",szBuffer);
    % j! ~' v. z' \
59.        }
    ' l1 D. ~, ~( R
60.     }
    
61.    closesocket(sClient);
    ) i) o1 I$ a$ [2 I/ ]
62. 
    % z4 Y1 h7 m1 S1 {3 Y
63.    WSACleanup();
    4 n' b4 W; L  ?: l: V" D
64.     return 0;
    
65. }

复制代码

服务器程序:server.cpp
% F, X7 D/ k8 D* h9 m

1. #include <winsock2.h>
   
2. #include <stdio.h>
   ( ^" D5 Y- e8 ^' I% {: q# I
3. #include <stdlib.h>
   5 L9 {$ a/ P0 G9 G* m
4. 
   
5. #define DEFAULT_PORT       5150
   
6. #define DEFAULT_BUFFER     4096
   
7. 
   
8. int   iPort     = DEFAULT_PORT;
   3 F, V3 q" n# ~( `. Y4 v9 L' ?4 F
9. char   szAddress[128];
   
10. 
    
11. DWORD WINAPI ClientThread(LPVOID lpParam)
    : S% i% f! C9 J8 Z& B) c. B- Z
12. {
    $ |! E, j9 b6 L6 A
13.    SOCKET       sock=(SOCKET)lpParam;
    
14.    char         szBuff[DEFAULT_BUFFER];
    
15.    int          ret;
    
16. 
    ! V9 l' C2 A2 c. f; ^7 `" v
17.    while(1)
      @: R& w1 g9 S# y
18.     {
    ! S7 w7 _* |1 Q/ o% r( N. E
19.        ret = recv(sock, szBuff, DEFAULT_BUFFER, 0);
    + `# d0 Q* J3 |* ]' i
20.        if (ret == 0)
    
21.            break;
    
22.        else if (ret == SOCKET_ERROR)
    
23.        {
    4 S* @) ^5 k3 F
24.            printf("recv() failed: %d\n", WSAGetLastError());
    
25.            break;
    * Y7 P, S% V/ k! \; e( [7 y0 ?
26.        }
    
27.        szBuff[ret] = '\0';
    
28.        printf("RECV: '%s'\n", szBuff);
    4 V6 k* @. M# X( Y" x$ v1 ^2 F
29.       if(strcmp(szBuff,"abc")==0){
    * l: w4 I$ j. n+ A4 ?# y- t: b6 H
30.          memcpy(szBuff,"Send the correct string!",25);
    
31.        }
    
32.        else{
    " `- ]: {& x( ?0 U
33.          memcpy(szBuff,"Send the wrong string!",23);
    
34.        }
    ( ?5 A5 Y! K( S) v4 c! L( }
35.        ret = send(sock, szBuff, strlen(szBuff), 0);
      m# B. _6 m9 i6 H; T
36.        if (ret == SOCKET_ERROR){
    ( c6 e1 K& Z* h% |/ M
37.          printf("send() failed: %d\n", WSAGetLastError());
    
38.        }
    , ]# E7 `; p: k, E( f( I: Z& X
39.     }
    
40.     return 0;
    5 G; t# }( D0 a1 o4 v
41. }
    4 v$ h' s) F1 q
42. 
    # X9 r# `& d; D& n( g& Q
43. int main()
    
44. {
    
45.    WSADATA      wsd;
    6 s2 j5 l' f* `
46.    SOCKET       sListen,
    0 i4 X# z* p# r/ v" g# c+ _
47.                  sClient;
    
48.    int          iAddrSize;
    ( S+ E6 \2 j8 }8 r9 v0 H7 J: b+ _' H. l+ l
49.    HANDLE       hThread;
    * z- N/ Q+ ~$ F2 Y, C6 N" f2 U
50.    DWORD        dwThreadId;
    $ F* d- v0 Z% Y7 c! ~
51.     struct sockaddr_in local,
    7 l& E. C1 B- A  y9 E+ [8 x
52.                       client;
    
53. 
    % H5 m9 @* u# n; F# |. Q
54.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    
55.     {
    7 N# ?9 ~3 W2 X! ~# p
56.        printf("Failed to load Winsock!\n");
    
57.        return 1;
    + O5 _6 d* _6 ]/ ]& g
58.     }
    0 F& b3 E; f9 R( ]9 f" U1 _$ E
59.     // Create our listening socket
    6 e2 p+ X8 H9 @& w" o. j- w) f
60.     sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
    + D# h( x7 ^1 B8 z; Z6 b0 u
61.     if (sListen == SOCKET_ERROR)
    / B, i2 `$ X0 o1 [4 S- w+ M
62.     {
    
63.        printf("socket() failed: %d\n", WSAGetLastError());
    
64.        return 1;
    8 x1 ~+ P" |5 l0 B: Y6 J/ x
65.     }
    
66.    local.sin_addr.s_addr = htonl(INADDR_ANY);
    ) y  h8 \: D$ x! x, L; x- ]& ?
67.    local.sin_family = AF_INET;
    " [, B3 e2 L6 I. ?7 v/ b0 |/ N
68.    local.sin_port = htons(iPort);
    
69. 
    
70.     if (bind(sListen, (struct sockaddr *)&local,
    
71.            sizeof(local)) == SOCKET_ERROR)
    
72.     {
    
73.        printf("bind() failed: %d\n", WSAGetLastError());
    4 D8 H( M; R" ?
74.        return 1;
    % O* E$ H& p* A6 I8 a- d8 p
75.     }
    , g7 w' m# ]2 F% F1 r
76.    listen(sListen, 8);
    $ v2 m" x# {8 ^" ]7 i
77.     // In a continous loop, wait for incoming clients. Once one
    * A9 g- ~2 B. G
78.     // is detected, create a thread and pass the handle off to it.
    
79.     while (1)
    - Y% S% X8 M6 |' r
80.     {
    ! v, S$ T9 Y3 \0 X1 F
81.        iAddrSize = sizeof(client);
    
82.        sClient = accept(sListen, (struct sockaddr *)&client,
    7 i# `% {2 x: D+ g
83.                        &iAddrSize);      
    
84.        if (sClient == INVALID_SOCKET)
    & m2 Q7 ^, C3 h: [) F; h
85.        {      
    - ?. T+ W: R$ H& U% I' d% s1 U
86.            printf("accept() failed: %d\n", WSAGetLastError());
    
87.            break;
    
88.        }
    
89.        printf("Accepted client: %s:%d\n",
    ; Z8 V- Y3 e2 j* l$ j# P
90.            inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    
91. 
    # T# t) \. |/ C' X
92.        hThread = CreateThread(NULL, 0, ClientThread,
    
93.                    (LPVOID)sClient, 0, &dwThreadId);
    
94.        if (hThread == NULL)
    1 U+ n- f: k* ]; q
95.        {
    - W# \& E7 P. V* G
96.            printf("CreateThread() failed: %d\n", GetLastError());
    
97.            break;
    1 ]# n- L, V. e8 a4 T" J; Q
98.        }
    
99.        CloseHandle(hThread);
    # l6 ?, z$ y/ D* C0 ?
100.     }
     
101.    closesocket(sListen);
     * {/ K7 M4 `# K1 x6 H; V. W+ [
102.    
     5 w' a: D2 K; X, @$ [! u' ?
103.    WSACleanup();
     
104.     return 0;
     $ o9 ^0 V5 E' |4 `7 g' P
105. }

复制代码

- Z! Q  }2 Q& M" E
- z+ H/ J+ M! W3 ^! n

admin

1. 作为服务器，你要绑定【bind】到本地的IP地址上进行监听【listen】，但是你的机器上可能有多块网卡，也就有多个IP地址，这时候你要选择绑定在哪个IP上面，如果指定为INADDR_ANY，那么系统将绑定默认的网卡【即IP地址】。
   4 N# s4 ^9 o, ?3 h, Y; {9 h
2. 
   
3. 作为客户端，你要连接【connect】到远端的服务器，也是要指定远端服务器的（ip, port）对。
   
4. 当然，在这种情况下，不可能将IP地址指定为INADDR_ANY，系统会疯掉的。
   
5. 
   0 `% A0 i( [  V2 m8 ^) ?& J2 s
6. Server：
   
7. #include <winsock2.h>
   5 Q% c+ z1 U' z' {: P/ C
8. #pragma comment(lib, "WS2_32.lib")
   0 [1 \" K3 l  n' r% O5 U$ H% [/ h% B
9. 
   . O* u! o1 M; G) q8 e6 r
10. #include <stdio.h>
    7 |* z6 G! N7 R) S
11. void main()
    
12. {
    4 X# j5 r2 n7 E. J$ u% ^8 p
13.     WORD wVersionRequested;//版本号
    
14.     WSADATA wsaData;
    3 @8 P" z& E( Z3 x
15.     int err;
    
16. 
    $ Z7 Y+ o( U- O/ \
17.     wVersionRequested = MAKEWORD(2, 2);//2.2版本的套接字
    : r# Q" o$ T, b. T( \: J6 N2 Y
18.     //加载套接字库,如果失败返回
    
19.     err = WSAStartup(wVersionRequested, &wsaData);
    
20.     if (err != 0)
    
21.     {
    . }, A4 ~& ]9 b* @) B  z
22.         return;
    
23.     }
    
24. 
    
25.     //判断高低字节是不是2,如果不是2.2的版本则退出
    4 N5 v3 a# n* r3 I8 d
26.     if (LOBYTE(wsaData.wVersion) != 2 ||
    
27.          
    ; D2 C' C3 S/ M" h$ _1 Z& C( `
28.         HIBYTE(wsaData.wVersion) != 2)
    
29.          
    9 p+ c- c" @+ H
30.     {
    5 ^( x/ c$ f6 p3 H( x: G& J
31.         return;
    # d+ ]- q6 L: O: Y
32.     }
    8 K* D& |" r+ {# g9 N7 {
33.      
    
34.          //创建流式套接字,基于TCP(SOCK_STREAM)
    3 T# N5 w+ o1 M" @; j
35. 
    1 C- |' N6 U9 w; t& E& ]
36.          SOCKET socSrv = socket(AF_INET, SOCK_STREAM, 0);
    
37. 
    
38.          //Socket地址结构体的创建
    
39. 
    
40.          SOCKADDR_IN addrSrv;
    
41. 
    
42.          addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);//转换Unsigned long型为网络字节序格
    8 _( b3 ^! J, u. D1 \6 ]
43.          addrSrv.sin_family = AF_INET;//指定地址簇
    
44.          addrSrv.sin_port = htons(6000);
    - `) r% Y  j) N
45.         //指定端口号,除sin_family参数外,其它参数都是网络字节序,因此需要转换
    
46. 
    
47.          //将套接字绑定到一个端口号和本地地址上
    
48.          bind(socSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));//必须用sizeof，strlen不行
    9 \: |7 l$ B2 L, E: `2 _  x1 H
49. 
    * b) w1 L' ?% U9 Z' \' E7 A0 e
50.          listen(socSrv, 5);
    & J# V. N$ O6 c+ n
51.          
    
52.          SOCKADDR_IN addrClient;//字义用来接收客户端Socket的结构体
    
53. 
    
54.          int len = sizeof(SOCKADDR);//初始化参数,这个参数必须进行初始化，sizeof
    
55. 
    6 p" Q0 M3 N; N' e6 m" i9 D
56.          //循环等待接受客户端发送请求
    # G  m. A$ J. i) a0 Z8 M
57. 
    6 c. A9 s9 @2 R3 D0 W8 f2 s
58.          while (1)
    
59.          {
    / N1 t: J2 r1 v+ p0 T6 g
60.                    //等待客户请求到来；当请求到来后，接受连接请求，
    : k7 H3 F# H. |! ^. m
61. 
    
62.                    //返回一个新的对应于此次连接的套接字（accept）。
    0 r$ p6 c) `( @$ c) G* N, b1 W
63.                    //此时程序在此发生阻塞
    
64. 
    / e. b" F, ]$ m* Q. M! `
65.                    SOCKET sockConn = accept(socSrv, (SOCKADDR*)&addrClient, &len);
    * M' L. ^) [) C: v& g) J  V( e9 E0 d- l
66. 
    
67.                    char sendBuf[100];
      S+ W" \  x' H. H- a# p
68. 
    2 C6 i. y  @5 I
69.                    sprintf(sendBuf, "Welcome %s to JoyChou",
    
70. 
    8 A4 d9 r; a: T& T! P3 A9 S
71.                             inet_ntoa(addrClient.sin_addr));//格式化输出
    
72. 
    / y8 v" K# b8 |$ X- I  M2 v& n- u
73.                    //用返回的套接字和客户端进行通信
    
74. 
    
75.                    send(sockConn, sendBuf, strlen(sendBuf)+1, 0);//多发送一个字节
    3 {; s" w2 c/ w% _7 i- \+ @
76. 
    & j1 S9 X+ V( l: W
77.                    //接收数据
    
78. 
    
79.                    char recvBuf[100];
    ) T% J% j' n3 Y9 {  {9 i
80. 
    
81.                    recv(sockConn, recvBuf, 100, 0);
    
82. 
    ) r( v4 ?- V$ u# u
83.                    printf("%s\n", recvBuf);
    
84.                    closesocket(sockConn);
    4 k2 `* K6 J% O' h9 i
85. 
    ( h5 n: N9 m, Y
86.          }
    - n) S) p( D+ P2 t* G: H
87. }
    . c  j1 M% f# _0 e, j
88. 
    6 T: w6 ]: R4 H" p) B% `0 V) j
89. 
    
90. Client：
    - f" \4 M: o1 s9 S0 ^
91. 
    
92. #include <winsock2.H>
    ! O  F* O  {$ {) k
93. #pragma comment(lib, "Ws2_32.lib")
    " }3 S' H2 |4 x* Y, p, p6 f8 R
94. #include <stdio.h>
    
95. #include <string.h>
    
96. 
    4 K& A8 D- r1 x
97. void main()
    
98. {   
    
99.     WORD wVersionRequested;
      G! i$ T1 f! x- s% u  ?/ @
100.     WSADATA wsaData;
     ( D7 V* Q1 U' A+ p6 K
101.     int err;
     ! G' E) Y5 Y" E! C
102.      
     
103.     wVersionRequested = MAKEWORD( 2, 2 );
     ; M0 g$ L8 g! l( N0 g  n7 |
104.      
     
105.     err = WSAStartup( wVersionRequested, &wsaData );
     - _1 C7 i. l3 o* o
106.     if ( err != 0 ) {
     
107.          
     
108.         return;
     
109.     }
     * x# U7 @5 m4 T/ T; j+ j
110.      
     
111.      
     
112.     if ( LOBYTE( wsaData.wVersion ) != 2 ||
     
113.         HIBYTE( wsaData.wVersion ) != 2 )
     
114.     {
     : N. J# i& D& \, g1 B( R; `
115.          
     " q) t. C1 g0 E+ K
116.         WSACleanup( );
     - @- A) n. m; B) H
117.         return;
     - I6 u0 y6 l3 p1 [( w+ U
118.     }
     
119.     SOCKET socketClient = socket(AF_INET, SOCK_STREAM, 0);
     
120.     SOCKADDR_IN addrSrv;
     : z. s- X- n. ~( C8 ?1 l
121.     addrSrv.sin_family = AF_INET;
     
122.     addrSrv.sin_port = htons(6000);
     
123.     addrSrv.sin_addr.S_un.S_addr = inet_addr("192.168.1.101");//服务器端的IP地址
     + B9 _6 o6 O: x9 @9 b+ D
124.      
     
125.     connect(socketClient, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
     # @( [9 c. y' |/ u0 B
126.     char recvBuf[256];
     
127.     char sendBuf[] = "This is Joychou";
     
128.     recv(socketClient, recvBuf, 256, 0);
     # f1 O* R. _% `# d9 G& p, f' _; O) m
129.     printf("%s\n", recvBuf);
     ( p% m" |2 C2 u
130.     send(socketClient, sendBuf, strlen(sendBuf) + 1, 0);
     
131.     closesocket(socketClient);
     - w  k( I3 r5 y$ P. e
132.     WSACleanup();
     7 A8 O* \! H" d' e- t& A& J
133.      
     7 j. g6 i* K6 ~& {+ j1 E, K
134. }

复制代码