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

admin

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

1. #include <winsock2.h>
   " G, S* t+ \2 k4 l# {$ }5 S; B/ n
2. #include <stdio.h>
   
3. #include <stdlib.h>
   . A* ~7 d# M! A# x
4. 
   
5. #define DEFAULT_PORT       5150
   
6. #define DEFAULT_BUFFER     2048
   
7. 
   
8. char  szServer[128],
   : D/ ^" c* _! R& s
9.      szMessage[1024];
   
10. int  iPort    = DEFAULT_PORT;
    5 a; k# Z- J7 o' t- i
11. 
    . q" C7 d3 [2 {5 M
12. int main()
    : h$ Z! G& K* }
13. {
    
14.    WSADATA      wsd;
    
15.    SOCKET       sClient;
    
16.    char         szBuffer[DEFAULT_BUFFER];
    7 t/ S3 S: u4 q, _- Y
17.    int          ret;
    3 G2 Q" W+ [+ A/ Z; Y5 f
18.     struct sockaddr_in server;
    
19.     struct hostent    *host = NULL;
    + s% ?1 D  `2 g- m+ G; A
20.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    
21.     {
    
22.        printf("Failed to load Winsock library!\n");
    % d1 l* w, K- c) E/ Z  o1 ]$ e2 m4 _
23.        return 1;
    
24.     }
    
25.    printf("Enter a string to send to server:\n");
    3 q$ u; ~% v2 |8 K, O2 F
26.    gets(szMessage);
    * D5 R  X& f  C2 Z2 q
27.     // Create the socket, and attempt to connect to the server
    5 N, @" P! W; {
28.     sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    ) Q- r/ w3 T8 L. K
29.     if (sClient == INVALID_SOCKET)
    3 z, C* p  h7 d( _+ ~3 m; K* E
30.     {
    
31.        printf("socket() failed: %d\n", WSAGetLastError());
    $ @) C. O- w/ a0 ?
32.        return 1;
    
33.     }
    : [/ b4 J/ F# k- o# `
34.    server.sin_family = AF_INET;
    
35.    server.sin_port = htons(iPort);
    
36.    server.sin_addr.s_addr = inet_addr("127.0.0.1");
    : R9 U) c, n( ~  |( {( u5 D; y
37. 
    ; E) m: S) v0 \: H1 I
38.     if (connect(sClient, (struct sockaddr *)&server,
    ( F. m" \2 C5 |! a1 G3 R7 V
39.        sizeof(server)) == SOCKET_ERROR)
    - s" r3 a( U+ n# A8 G* m9 g
40.     {
    / l3 \9 F6 ^( L* ^
41.        printf("connect() failed: %d\n", WSAGetLastError());
    
42.        return 1;
    1 F$ z0 ]) }2 R, O+ f1 J7 G
43.     }
    : G  I. z( {7 \2 I
44.     // Send and receive data
    
45.     ret = send(sClient, szMessage, strlen(szMessage), 0);
    
46.     if (ret == SOCKET_ERROR)
    
47.     {
    - X+ S6 O4 D6 l# L
48.        printf("send() failed: %d\n", WSAGetLastError());
    + a5 l% S2 p* E7 h7 I' y7 O
49.     }
    , N4 Y. \) p! A2 r6 r( W- Q
50.     else{
    . J, E: W' ^+ M. E3 \
51.        printf("Send '%s' \n", szMessage);
    ( s) j+ M, T% w' M5 L
52.        ret = recv(sClient, szBuffer, DEFAULT_BUFFER, 0);
    ! V) |, I; g7 v* }5 Q" }3 K
53.        if (ret == SOCKET_ERROR){
    
54.          printf("recv() failed: %d\n", WSAGetLastError());
    
55.        }
    
56.        else{
    % K6 l2 c( Q6 @' r5 F- I0 A2 C% Z
57.          szBuffer[ret] = '\0';
    1 [1 M( e- J; ]. C
58.          printf("RECV: '%s'\n",szBuffer);
    
59.        }
    
60.     }
    
61.    closesocket(sClient);
    6 }( a: n" s1 C# {
62. 
    
63.    WSACleanup();
    ( e" g" O6 I, I/ g: o
64.     return 0;
    
65. }

复制代码

服务器程序:server.cpp
# ^* c. @. W# j9 ^( @' i4 @

1. #include <winsock2.h>
   + |% Y+ x. F5 H, _8 D5 I
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. 
   
5. #define DEFAULT_PORT       5150
   8 B' ?; ]! ^3 U4 R1 X* e" L) q
6. #define DEFAULT_BUFFER     4096
   3 F* }5 i6 j# a0 s
7. 
   
8. int   iPort     = DEFAULT_PORT;
   ; L4 v0 v" ]+ i! {2 i* c
9. char   szAddress[128];
   0 Z, b: T0 {8 A9 s
10. 
    ) x4 s- S8 j& H+ ~8 F* O* r7 F, m9 c
11. DWORD WINAPI ClientThread(LPVOID lpParam)
    5 t# B" N9 p6 E; d& ]
12. {
    
13.    SOCKET       sock=(SOCKET)lpParam;
    
14.    char         szBuff[DEFAULT_BUFFER];
    
15.    int          ret;
    
16. 
    
17.    while(1)
    
18.     {
    , J5 c" M. S+ r1 i4 p
19.        ret = recv(sock, szBuff, DEFAULT_BUFFER, 0);
    
20.        if (ret == 0)
    : S& {9 ~- g! w6 x6 s* U6 q6 H& D
21.            break;
    
22.        else if (ret == SOCKET_ERROR)
    9 Z% G2 S3 x: U& [. i1 a
23.        {
    
24.            printf("recv() failed: %d\n", WSAGetLastError());
    
25.            break;
    , S9 B! O2 h. a0 {0 M8 B( f
26.        }
    
27.        szBuff[ret] = '\0';
    0 |+ p& H: G5 T0 g
28.        printf("RECV: '%s'\n", szBuff);
    
29.       if(strcmp(szBuff,"abc")==0){
    $ G7 z$ v* q: \; r# r- w7 J+ K' b
30.          memcpy(szBuff,"Send the correct string!",25);
    1 Z, z) H$ i7 {3 V! M" q
31.        }
    
32.        else{
    
33.          memcpy(szBuff,"Send the wrong string!",23);
    + ~6 F$ f% N: @/ S& ~7 h: ^
34.        }
    $ a3 L, u3 Q- ]% Y' E3 k: K
35.        ret = send(sock, szBuff, strlen(szBuff), 0);
    " P, A7 u1 X* W* ]
36.        if (ret == SOCKET_ERROR){
    
37.          printf("send() failed: %d\n", WSAGetLastError());
    
38.        }
    
39.     }
    . {  I9 i+ S3 t4 P. c! e
40.     return 0;
    ; d# T' M4 P# l
41. }
    
42. 
    . V" S5 j, L) N+ s* p0 e& z
43. int main()
    
44. {
    , G- J2 A. Q9 h& V# I) n1 l# c6 ~
45.    WSADATA      wsd;
    
46.    SOCKET       sListen,
    
47.                  sClient;
    ; v6 _7 y* d/ p8 w
48.    int          iAddrSize;
    % A' [9 L5 i) j* c! Q$ z
49.    HANDLE       hThread;
    ! E! P6 _' C" h% m
50.    DWORD        dwThreadId;
    
51.     struct sockaddr_in local,
    3 b* _& c) q& I* k: w
52.                       client;
    7 V, F- g- w2 ^1 ~
53. 
    5 E" y1 I2 M* M
54.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    " j! P; ^' T, Y3 a0 Z2 \, H, @. A5 X# j
55.     {
    
56.        printf("Failed to load Winsock!\n");
    : y0 w4 X4 m# o9 c+ B
57.        return 1;
    
58.     }
    % ?* N" N( w' e& _0 o8 R/ w# l
59.     // Create our listening socket
    
60.     sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
    
61.     if (sListen == SOCKET_ERROR)
    
62.     {
    4 y  Y* p7 E  s8 D; D
63.        printf("socket() failed: %d\n", WSAGetLastError());
    8 B) I- N7 o% P
64.        return 1;
    & h. c4 p) ^4 L. |
65.     }
    
66.    local.sin_addr.s_addr = htonl(INADDR_ANY);
    7 ^1 |  C9 o! s3 p/ z
67.    local.sin_family = AF_INET;
    
68.    local.sin_port = htons(iPort);
    
69. 
    
70.     if (bind(sListen, (struct sockaddr *)&local,
    ; S1 N: H: H( Y' ?1 a4 }" @7 h1 F
71.            sizeof(local)) == SOCKET_ERROR)
    
72.     {
    
73.        printf("bind() failed: %d\n", WSAGetLastError());
    6 J4 S- C, `0 {) j8 \0 E6 f
74.        return 1;
    , @; ~4 w! l! H7 N# a5 \
75.     }
    5 W/ Z3 V0 J' @, c
76.    listen(sListen, 8);
    
77.     // In a continous loop, wait for incoming clients. Once one
    ( a3 ^! N. b+ {: [5 ~, L& D
78.     // is detected, create a thread and pass the handle off to it.
    + Y% k# X' y6 O3 V0 T5 r7 w& X
79.     while (1)
    0 v" X7 \! s0 z- M# L- `3 ]" v, m
80.     {
    / _7 k% C5 E3 w5 e; h* ^* s- e
81.        iAddrSize = sizeof(client);
    ! ^3 @2 ?* x' W, b) w) }( h. r. n
82.        sClient = accept(sListen, (struct sockaddr *)&client,
    & `( u* }: g+ S* }" u2 p2 R
83.                        &iAddrSize);      
    0 _( I4 c* L& u2 r8 \  h  D
84.        if (sClient == INVALID_SOCKET)
    % O2 s4 W0 q& e
85.        {      
    & D# p1 H7 [0 ?
86.            printf("accept() failed: %d\n", WSAGetLastError());
    " J% w. j8 l8 S0 R
87.            break;
    - T2 k+ G) @# y, m1 `5 o
88.        }
    
89.        printf("Accepted client: %s:%d\n",
    # N$ O( K( J2 L- \& Y$ c8 v5 B
90.            inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    . }& o# m3 R. T
91. 
    ' _2 W2 {9 T1 O+ E* K
92.        hThread = CreateThread(NULL, 0, ClientThread,
    5 ^* X2 w) T$ I/ A  c3 E: ]  T) I6 L
93.                    (LPVOID)sClient, 0, &dwThreadId);
    
94.        if (hThread == NULL)
    " n. Z* }0 b5 |; o- k$ f1 h% g% }
95.        {
    . F7 _# T1 b7 b
96.            printf("CreateThread() failed: %d\n", GetLastError());
    / o- g+ A, m- r; _3 ^7 c. w/ m
97.            break;
    ' {9 \& [; J. u: q$ W6 L7 [0 S
98.        }
    
99.        CloseHandle(hThread);
    2 H: e& U3 _! J% y: C
100.     }
     + D. z, R& _: ?( K
101.    closesocket(sListen);
     " R- Y* F# ]. y- ?6 _$ Q! Q7 d7 N
102.    
     1 S8 F! }8 G* D: Z1 w5 ]0 E7 e
103.    WSACleanup();
     
104.     return 0;
     
105. }

复制代码

& ^# B# Y' g/ r. s& I: K4 O! J2 W

# z/ K& f4 n0 W/ K/ d- O( {& x

admin

1. 作为服务器，你要绑定【bind】到本地的IP地址上进行监听【listen】，但是你的机器上可能有多块网卡，也就有多个IP地址，这时候你要选择绑定在哪个IP上面，如果指定为INADDR_ANY，那么系统将绑定默认的网卡【即IP地址】。
   , i7 |3 ^; a! Q% H% I
2. 
   # m# }) U1 A0 c- @- F
3. 作为客户端，你要连接【connect】到远端的服务器，也是要指定远端服务器的（ip, port）对。
   
4. 当然，在这种情况下，不可能将IP地址指定为INADDR_ANY，系统会疯掉的。
   4 D  j0 R9 Z* T, Y& V& t
5. 
   
6. Server：
   6 x4 q; ~. g' X& z
7. #include <winsock2.h>
   + G. K7 B7 r$ V' [4 c
8. #pragma comment(lib, "WS2_32.lib")
   6 ~* Q: j1 E3 G
9. 
   * G7 n7 k+ q* g* ~# u* j9 M
10. #include <stdio.h>
    
11. void main()
    / k; {: ]4 i* c% V6 x
12. {
    " N5 P5 t5 t# J! c! ?" ^+ U2 A$ j
13.     WORD wVersionRequested;//版本号
    
14.     WSADATA wsaData;
    % [0 U; z9 a0 }  z2 D3 w$ O; t
15.     int err;
    
16. 
    
17.     wVersionRequested = MAKEWORD(2, 2);//2.2版本的套接字
    % m- x5 a" t0 L: T4 ~# d& D& r' z
18.     //加载套接字库,如果失败返回
    
19.     err = WSAStartup(wVersionRequested, &wsaData);
    ' R6 A: F. k2 _% K1 f5 |4 ~
20.     if (err != 0)
    
21.     {
    * z$ w# r/ O4 V/ {4 L& E
22.         return;
    
23.     }
    ) X$ B& c  N7 j5 U
24. 
    
25.     //判断高低字节是不是2,如果不是2.2的版本则退出
    
26.     if (LOBYTE(wsaData.wVersion) != 2 ||
    $ D: ?5 P4 ]# ~+ A& I2 z0 K1 Q* E
27.          
    - L0 R. e/ O9 m% ^  ]& E
28.         HIBYTE(wsaData.wVersion) != 2)
    
29.          
    
30.     {
    ) ]. |4 z. @' g* N' C
31.         return;
    
32.     }
    
33.      
    
34.          //创建流式套接字,基于TCP(SOCK_STREAM)
    # Z% g& _! ~) R+ I1 J  y
35. 
    ! F' C5 Y" z2 z+ D& J
36.          SOCKET socSrv = socket(AF_INET, SOCK_STREAM, 0);
    
37. 
    & k. e( E/ e5 m0 i4 s& n% p
38.          //Socket地址结构体的创建
    8 C8 x- g, X. d* j8 B. i; s9 X1 H
39. 
    
40.          SOCKADDR_IN addrSrv;
    7 L4 Y+ W5 ^& k0 e6 p; v4 q7 u) b4 @
41. 
    # W2 Q" Q- V7 d+ K. J3 d% u
42.          addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);//转换Unsigned long型为网络字节序格
    . G' i; J2 M& N; C
43.          addrSrv.sin_family = AF_INET;//指定地址簇
    : |+ q: [) H) K. ~. ~
44.          addrSrv.sin_port = htons(6000);
    
45.         //指定端口号,除sin_family参数外,其它参数都是网络字节序,因此需要转换
    
46. 
    + a7 @+ P, v; g$ w
47.          //将套接字绑定到一个端口号和本地地址上
    ' }! E: n1 ]' I+ f7 ^& E; u
48.          bind(socSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));//必须用sizeof，strlen不行
    5 S# y1 b: B( a
49. 
    
50.          listen(socSrv, 5);
    ( u4 U0 f/ _, ^! _
51.          
    
52.          SOCKADDR_IN addrClient;//字义用来接收客户端Socket的结构体
    
53. 
    $ L1 ]* t) g5 \$ S
54.          int len = sizeof(SOCKADDR);//初始化参数,这个参数必须进行初始化，sizeof
    
55. 
    1 m- y: B2 W$ o
56.          //循环等待接受客户端发送请求
    $ {- R7 }, V( s+ D. w" E$ p# m
57. 
    
58.          while (1)
    . g, A: A: n  k8 a' n/ f  l
59.          {
    + j; Z( u" X( N" S4 F+ O; [# _2 r
60.                    //等待客户请求到来；当请求到来后，接受连接请求，
    
61. 
    
62.                    //返回一个新的对应于此次连接的套接字（accept）。
    
63.                    //此时程序在此发生阻塞
    0 C* S! t- W2 {6 _2 I1 ^
64. 
    
65.                    SOCKET sockConn = accept(socSrv, (SOCKADDR*)&addrClient, &len);
    
66. 
    
67.                    char sendBuf[100];
    8 w5 T! f. j# W1 l
68. 
    8 J' U, H: {2 X9 j
69.                    sprintf(sendBuf, "Welcome %s to JoyChou",
    ) X# ~$ _9 u+ {& g  R4 n' a2 \
70. 
    6 a# H" Q9 f% j. |4 i8 M' J
71.                             inet_ntoa(addrClient.sin_addr));//格式化输出
    * z) ?% g0 N% V( v
72. 
    9 ?+ {9 W* j& H6 A5 F! I
73.                    //用返回的套接字和客户端进行通信
    + v5 B3 `2 @: Y4 e" @
74. 
    
75.                    send(sockConn, sendBuf, strlen(sendBuf)+1, 0);//多发送一个字节
    
76. 
    
77.                    //接收数据
    
78. 
    + Z' K/ P  W; G" S) V
79.                    char recvBuf[100];
    9 A% {! Z% |2 d0 C
80. 
    $ J# A% \: |' L: B. Y2 L
81.                    recv(sockConn, recvBuf, 100, 0);
    3 n4 t3 u5 x/ k4 `$ j) g
82. 
    
83.                    printf("%s\n", recvBuf);
    * M* E. T9 t( R! l( s6 G
84.                    closesocket(sockConn);
    1 P4 \6 [1 X. E1 C0 t
85. 
    
86.          }
    8 P- a4 f9 C+ _' R
87. }
    
88. 
    
89. 
    ! C" e: z$ |5 W0 ]) L  f2 l
90. Client：
    6 I1 @: U) {$ _/ G) w
91. 
    5 X3 e* ~2 u  h5 T: K  ^1 R6 n
92. #include <winsock2.H>
    ! J1 y! q% M2 k5 q4 m6 E4 s
93. #pragma comment(lib, "Ws2_32.lib")
    
94. #include <stdio.h>
    
95. #include <string.h>
    4 F: Z1 Z) z( F4 T
96. 
    ; @9 C3 Q# B: R- `) G; e5 ]* G
97. void main()
      u  Y, Y3 i# m9 M! e
98. {   
    ' [" W# @/ Y& p- a7 q# h
99.     WORD wVersionRequested;
    2 v! S$ f8 i7 b7 c( v5 a
100.     WSADATA wsaData;
     ! x/ Y* y! Y2 T5 t, D5 u
101.     int err;
     ) \1 @% i/ a# \* l! |7 s. e6 Q
102.      
     8 k' O$ P/ {8 R# Y  @; x/ ^
103.     wVersionRequested = MAKEWORD( 2, 2 );
     
104.      
     
105.     err = WSAStartup( wVersionRequested, &wsaData );
     
106.     if ( err != 0 ) {
     
107.          
     7 N$ C1 ^8 w0 g, e3 p
108.         return;
     2 `) t  \4 S) E7 A' S
109.     }
     ) @& h. o; o; ?8 A+ G
110.      
     
111.      
     
112.     if ( LOBYTE( wsaData.wVersion ) != 2 ||
     
113.         HIBYTE( wsaData.wVersion ) != 2 )
     
114.     {
     
115.          
     0 v" C5 |9 A1 W4 N' h  i
116.         WSACleanup( );
     3 E" z: i8 M2 ~; G. g
117.         return;
     % v& R5 Q1 R# d  Q2 E/ W* i, Q
118.     }
     
119.     SOCKET socketClient = socket(AF_INET, SOCK_STREAM, 0);
     / l  C4 P- k' m% I9 R( d
120.     SOCKADDR_IN addrSrv;
     
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地址
     
124.      
       \0 v' l* z) E! @6 C
125.     connect(socketClient, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
     $ D' U3 N0 Q3 Q: u* o
126.     char recvBuf[256];
     
127.     char sendBuf[] = "This is Joychou";
     7 G# ^& Z9 B( }2 V, G3 V
128.     recv(socketClient, recvBuf, 256, 0);
     * h/ k* a3 R4 ?6 e6 E
129.     printf("%s\n", recvBuf);
     1 w+ H/ E# f2 ^8 T3 `
130.     send(socketClient, sendBuf, strlen(sendBuf) + 1, 0);
     
131.     closesocket(socketClient);
     : r  F( p7 h3 W, Y
132.     WSACleanup();
     
133.      
     
134. }

复制代码

2 y, {: T# Q+ R% h: k5 T8 R2 p
1 N/ W- Y4 ~) v- j