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

admin

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

1. #include <winsock2.h>
   & f  f% Q7 \1 u4 N* [
2. #include <stdio.h>
   ) L, V) g$ M/ D8 j! F+ F
3. #include <stdlib.h>
   
4. 
   : C% i/ K- U/ W6 E& F9 S
5. #define DEFAULT_PORT       5150
   
6. #define DEFAULT_BUFFER     2048
   
7. 
   " C0 ~1 y' p& J" a
8. char  szServer[128],
   
9.      szMessage[1024];
   * p9 R# r1 c1 C5 M7 Z
10. int  iPort    = DEFAULT_PORT;
    9 r, h2 ]9 \" O" h9 U! j- a, j0 h; Q
11. 
    2 x9 Q5 m; I3 P& G- R' _
12. int main()
    / t- Y4 A7 m: k( S4 {$ t' ]/ t8 @
13. {
    
14.    WSADATA      wsd;
    2 I) ~) {# {; p' e0 N
15.    SOCKET       sClient;
    
16.    char         szBuffer[DEFAULT_BUFFER];
    % U1 w# P0 I$ P$ v) V. Z
17.    int          ret;
    9 {9 S+ W* K$ g& J6 A0 G
18.     struct sockaddr_in server;
    ! ^# s7 R" k+ n. F; J) g
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;
    
24.     }
    
25.    printf("Enter a string to send to server:\n");
    ' C+ V; P$ z; Z0 ?7 g+ {4 v
26.    gets(szMessage);
    
27.     // Create the socket, and attempt to connect to the server
    
28.     sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    
29.     if (sClient == INVALID_SOCKET)
    & J2 B: J& ~9 P; h( {* M6 V
30.     {
    
31.        printf("socket() failed: %d\n", WSAGetLastError());
    # ^) W0 e! D% ]2 ?' Z2 |2 F
32.        return 1;
    + @; H* L1 V# u6 k9 ]. \" |
33.     }
    ! q" I. t$ e4 I' p! N0 B
34.    server.sin_family = AF_INET;
    2 \) K" Z$ y  u' Z' @- {
35.    server.sin_port = htons(iPort);
    & d) h+ ^; m" @8 b% j
36.    server.sin_addr.s_addr = inet_addr("127.0.0.1");
    . B3 h0 G4 N8 `5 y
37. 
    
38.     if (connect(sClient, (struct sockaddr *)&server,
    # v$ _: M! b7 L: H0 g- @/ q# S; z
39.        sizeof(server)) == SOCKET_ERROR)
    
40.     {
    : B+ _1 i" c$ f3 u! U1 Y
41.        printf("connect() failed: %d\n", WSAGetLastError());
    
42.        return 1;
    " `  W" Z" J# b0 J
43.     }
    
44.     // Send and receive data
    
45.     ret = send(sClient, szMessage, strlen(szMessage), 0);
    7 n. k1 Z" u) N# {' j3 v) I& `" ]
46.     if (ret == SOCKET_ERROR)
    ) F/ ^1 L: l8 t7 d
47.     {
    
48.        printf("send() failed: %d\n", WSAGetLastError());
    # x; b% _* [( H
49.     }
    
50.     else{
    
51.        printf("Send '%s' \n", szMessage);
    
52.        ret = recv(sClient, szBuffer, DEFAULT_BUFFER, 0);
    
53.        if (ret == SOCKET_ERROR){
    6 G- y3 Z' ?$ `% q
54.          printf("recv() failed: %d\n", WSAGetLastError());
    
55.        }
    
56.        else{
    
57.          szBuffer[ret] = '\0';
    
58.          printf("RECV: '%s'\n",szBuffer);
    
59.        }
    
60.     }
    9 o% R8 m! R1 U: ^7 m; z# t  E4 G% S) L
61.    closesocket(sClient);
    $ F( Y+ q: l3 v" l  O
62. 
    
63.    WSACleanup();
    " F( Q" G. ?1 U: D& E) `3 c
64.     return 0;
    
65. }

复制代码

服务器程序:server.cpp
5 l7 [% `! T1 K6 l, x; C: L! _& `

1. #include <winsock2.h>
   9 X0 u) }* I; g
2. #include <stdio.h>
   
3. #include <stdlib.h>
   ! G5 k9 W/ Z* I7 m4 T3 Q( m
4. 
   * ]" h4 H+ X* o+ r
5. #define DEFAULT_PORT       5150
   
6. #define DEFAULT_BUFFER     4096
   ) h! c, _: t0 f, G6 V) C5 U  s0 _
7. 
   
8. int   iPort     = DEFAULT_PORT;
   7 r5 [- W) I* x8 I: R9 {: h
9. char   szAddress[128];
   
10. 
    . t2 ^" a0 I7 z6 E1 E
11. DWORD WINAPI ClientThread(LPVOID lpParam)
    / l& |$ ^' E6 M
12. {
    
13.    SOCKET       sock=(SOCKET)lpParam;
    
14.    char         szBuff[DEFAULT_BUFFER];
    
15.    int          ret;
    / h- q: Z# m, }
16. 
    
17.    while(1)
    % a" B3 z3 q! [; S' j. r# v
18.     {
    
19.        ret = recv(sock, szBuff, DEFAULT_BUFFER, 0);
    $ |6 X7 z5 c2 _3 E
20.        if (ret == 0)
    * d* a4 V, U1 b- [( x  U
21.            break;
    " R" x, P5 U& U$ X) D5 ^
22.        else if (ret == SOCKET_ERROR)
    
23.        {
    
24.            printf("recv() failed: %d\n", WSAGetLastError());
    6 l# f7 _, n% {
25.            break;
    
26.        }
    
27.        szBuff[ret] = '\0';
    
28.        printf("RECV: '%s'\n", szBuff);
    
29.       if(strcmp(szBuff,"abc")==0){
    9 Q' a" q+ p+ ]8 P$ [8 y
30.          memcpy(szBuff,"Send the correct string!",25);
    
31.        }
      w& r8 B- M" \7 d
32.        else{
    
33.          memcpy(szBuff,"Send the wrong string!",23);
    5 O) N7 V) n! V. P) p
34.        }
    
35.        ret = send(sock, szBuff, strlen(szBuff), 0);
    " L, n# A& [) C+ }* C
36.        if (ret == SOCKET_ERROR){
    $ [: ~, k, ?6 x1 |4 Q) X+ q9 I  d
37.          printf("send() failed: %d\n", WSAGetLastError());
    
38.        }
    
39.     }
    
40.     return 0;
    
41. }
    * B) k, _( h* }8 P: A8 Q
42. 
    
43. int main()
    ) C$ a/ O7 d0 Y$ J  O
44. {
    4 A, x& s% Q2 R" _5 u1 _* U% u& H
45.    WSADATA      wsd;
    - w- ^9 `* a7 B* e: G
46.    SOCKET       sListen,
    ; f9 d% q: C; Z- N/ f! q
47.                  sClient;
    ) Z) Z7 D/ c  D% C* @' @
48.    int          iAddrSize;
    ; Y* R+ W* a% z4 a+ ?
49.    HANDLE       hThread;
    0 w$ ?1 m# R+ f& _5 z/ X7 Y5 E5 \
50.    DWORD        dwThreadId;
    0 S7 [, `" _' w/ M+ v& r; F# w
51.     struct sockaddr_in local,
    # Y3 @/ H5 V; t6 d( y( y
52.                       client;
    
53. 
    
54.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    
55.     {
    
56.        printf("Failed to load Winsock!\n");
    
57.        return 1;
    ! p4 ?) G/ I% T
58.     }
    5 [$ E5 s# s. `. ~
59.     // Create our listening socket
    
60.     sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
    
61.     if (sListen == SOCKET_ERROR)
    
62.     {
    9 H# T) x' _7 T' O$ g7 M
63.        printf("socket() failed: %d\n", WSAGetLastError());
    
64.        return 1;
    5 c3 i+ z* t: S  p% b( G
65.     }
    
66.    local.sin_addr.s_addr = htonl(INADDR_ANY);
    . c/ W, O7 A, ^% Y6 w0 W; K
67.    local.sin_family = AF_INET;
    . G3 R, z. G5 Y& y
68.    local.sin_port = htons(iPort);
    ) H& t. {; Z# [' Q6 a; n
69. 
    # N0 r( j! `  T6 ~/ Y; |& H. a
70.     if (bind(sListen, (struct sockaddr *)&local,
    ( }) Z' g, ]) M; j7 g$ s. N* ^
71.            sizeof(local)) == SOCKET_ERROR)
    
72.     {
    " k1 A7 Q8 q2 c* Y- Z
73.        printf("bind() failed: %d\n", WSAGetLastError());
    
74.        return 1;
    
75.     }
    
76.    listen(sListen, 8);
    
77.     // In a continous loop, wait for incoming clients. Once one
    9 |* e1 ?9 b6 p9 l% v0 J
78.     // is detected, create a thread and pass the handle off to it.
    
79.     while (1)
    4 m$ g$ |- K# l! g" G, S1 T+ O" m
80.     {
    / V& ?1 I4 ^& o# \" X  H
81.        iAddrSize = sizeof(client);
    7 n+ O8 N7 L+ `' a$ F
82.        sClient = accept(sListen, (struct sockaddr *)&client,
    
83.                        &iAddrSize);      
    & F5 V# R; Q5 H" S/ N7 |) o6 r* A7 v) ?
84.        if (sClient == INVALID_SOCKET)
      L8 M- c8 b) t
85.        {      
    
86.            printf("accept() failed: %d\n", WSAGetLastError());
    # x) y3 \8 k* Z, m, {4 T2 b
87.            break;
    # O" H3 Q; `- a* v1 P
88.        }
    
89.        printf("Accepted client: %s:%d\n",
    
90.            inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    1 d/ Q8 Q0 |# ~
91. 
    0 r3 r5 v! g: J  u1 m" F! l
92.        hThread = CreateThread(NULL, 0, ClientThread,
    3 M. O- F& L/ p& ~+ H
93.                    (LPVOID)sClient, 0, &dwThreadId);
    
94.        if (hThread == NULL)
    % Y5 b  R8 s3 J" q7 x
95.        {
    ! q' k  `6 h6 A9 Q/ A' m
96.            printf("CreateThread() failed: %d\n", GetLastError());
      J, @: `2 l$ U! C0 ^
97.            break;
    
98.        }
    0 P" U. o2 t* l( `+ e
99.        CloseHandle(hThread);
    . x$ H3 X: g) l4 M0 [- G7 y$ K# D
100.     }
     
101.    closesocket(sListen);
     % o) E2 u" W- ~9 _, V/ o5 Y! s
102.    
     8 l8 G8 t' S( A. Z* w
103.    WSACleanup();
     & M& y' Z- D8 P6 V3 L
104.     return 0;
     7 P+ `0 Z1 O0 }2 |9 [
105. }

复制代码

2 W" ^! @1 g/ ^! K1 ?

. r; V) T" U8 s, N7 Y7 i

admin

1. 作为服务器，你要绑定【bind】到本地的IP地址上进行监听【listen】，但是你的机器上可能有多块网卡，也就有多个IP地址，这时候你要选择绑定在哪个IP上面，如果指定为INADDR_ANY，那么系统将绑定默认的网卡【即IP地址】。
   6 G6 g4 z( _2 w+ b( B- r
2. 
   
3. 作为客户端，你要连接【connect】到远端的服务器，也是要指定远端服务器的（ip, port）对。
   $ R5 {; `" G5 B8 q  t* K6 W1 ]+ f0 }
4. 当然，在这种情况下，不可能将IP地址指定为INADDR_ANY，系统会疯掉的。
   
5. 
   
6. Server：
   
7. #include <winsock2.h>
   
8. #pragma comment(lib, "WS2_32.lib")
   
9. 
   $ |9 a2 a% ^9 O
10. #include <stdio.h>
    $ Z( D" D0 A2 |; z5 z! e4 ], e
11. void main()
    
12. {
    1 F! m7 D( i- P7 s
13.     WORD wVersionRequested;//版本号
    
14.     WSADATA wsaData;
    
15.     int err;
    : `/ \1 s6 Y- F) ^5 o' K. C
16. 
    , q) Z+ y. s* \9 ~; K5 |& q
17.     wVersionRequested = MAKEWORD(2, 2);//2.2版本的套接字
    
18.     //加载套接字库,如果失败返回
    
19.     err = WSAStartup(wVersionRequested, &wsaData);
    
20.     if (err != 0)
    
21.     {
    
22.         return;
    6 L3 I: H: p0 S
23.     }
    
24. 
    # Y" k) r9 S, N8 b$ v4 O
25.     //判断高低字节是不是2,如果不是2.2的版本则退出
    
26.     if (LOBYTE(wsaData.wVersion) != 2 ||
    
27.          
    % V- g3 W$ q& _1 _: R4 g9 I
28.         HIBYTE(wsaData.wVersion) != 2)
    
29.          
    
30.     {
    5 Q" G6 @$ [, r2 k5 _
31.         return;
    . I) q( @  q' P. t5 K+ h# F
32.     }
    ( Q  {: `8 l, t8 a2 H
33.      
    ( U9 q8 T3 Q' \3 E( R! R
34.          //创建流式套接字,基于TCP(SOCK_STREAM)
    
35. 
    
36.          SOCKET socSrv = socket(AF_INET, SOCK_STREAM, 0);
    ' d2 E* n+ x6 Q7 X
37. 
    
38.          //Socket地址结构体的创建
    7 m% V" L2 ~/ c/ N, v) g5 z5 h
39. 
    
40.          SOCKADDR_IN addrSrv;
    
41. 
    
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);
    
45.         //指定端口号,除sin_family参数外,其它参数都是网络字节序,因此需要转换
    1 m" v1 b. T, \% W
46. 
    # M/ X  q2 N1 f$ q
47.          //将套接字绑定到一个端口号和本地地址上
    
48.          bind(socSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));//必须用sizeof，strlen不行
    
49. 
    
50.          listen(socSrv, 5);
    
51.          
    ! h; Z, m, s0 m  p
52.          SOCKADDR_IN addrClient;//字义用来接收客户端Socket的结构体
    
53. 
    - P+ @5 J7 v  p; S
54.          int len = sizeof(SOCKADDR);//初始化参数,这个参数必须进行初始化，sizeof
    
55. 
    
56.          //循环等待接受客户端发送请求
    
57. 
    
58.          while (1)
    # u/ s7 i: w) D9 h+ H. v( F" T
59.          {
    ) U5 S! B0 r, c, u7 L
60.                    //等待客户请求到来；当请求到来后，接受连接请求，
    1 N5 m6 H- ^/ I6 N
61. 
    
62.                    //返回一个新的对应于此次连接的套接字（accept）。
    7 _& V1 f' y/ ^2 t' ]
63.                    //此时程序在此发生阻塞
    * [6 Y7 W3 i! `/ ^& ^$ q
64. 
    
65.                    SOCKET sockConn = accept(socSrv, (SOCKADDR*)&addrClient, &len);
    
66. 
    & U% @. {, |! T/ b5 }( v
67.                    char sendBuf[100];
    
68. 
    8 q3 \% O! c$ q6 D
69.                    sprintf(sendBuf, "Welcome %s to JoyChou",
    4 N9 H7 T8 F9 ~0 n
70. 
    
71.                             inet_ntoa(addrClient.sin_addr));//格式化输出
    
72. 
    
73.                    //用返回的套接字和客户端进行通信
    
74. 
    : _* @3 x. Z6 ~6 `5 f
75.                    send(sockConn, sendBuf, strlen(sendBuf)+1, 0);//多发送一个字节
    8 k& A( v6 q" B+ V
76. 
    
77.                    //接收数据
    . j& R, J4 E* ]
78. 
    
79.                    char recvBuf[100];
    , P6 `. Z5 \) Q7 N; O' F
80. 
    % g) n" i3 Q! d6 G- s8 Y. Y
81.                    recv(sockConn, recvBuf, 100, 0);
    
82. 
    4 h7 Y/ d' |0 S
83.                    printf("%s\n", recvBuf);
    
84.                    closesocket(sockConn);
    
85. 
    3 l* Y, G: A) x9 n5 Q/ ]
86.          }
    5 n! P6 d' |) E. A$ k& i
87. }
    + V* A7 ]9 ^! }$ }* V2 y& g
88. 
    
89. 
    , b! k' X. |  z7 Z& \( a0 f
90. Client：
    ) Y, T6 l/ U9 y" ]
91. 
    
92. #include <winsock2.H>
    
93. #pragma comment(lib, "Ws2_32.lib")
    8 u5 y# n5 j0 }) o7 V, R
94. #include <stdio.h>
    9 [$ _, k) F# ~) y. S* ?( P: `
95. #include <string.h>
    
96. 
    
97. void main()
    
98. {   
    ' r& x  c% I5 K7 E+ b; g1 q: d
99.     WORD wVersionRequested;
    1 r' g+ d9 x) o  ~+ H9 S
100.     WSADATA wsaData;
     9 R# o0 v1 v( j" S
101.     int err;
     
102.      
     
103.     wVersionRequested = MAKEWORD( 2, 2 );
     
104.      
     
105.     err = WSAStartup( wVersionRequested, &wsaData );
     6 U3 v; s; ~! O
106.     if ( err != 0 ) {
     
107.          
     
108.         return;
       r! {* r: `: E# U
109.     }
     2 p0 A- |& A) O) P$ a
110.      
     & @1 f" b; G' f, e: A
111.      
     2 D7 `7 u6 W0 m
112.     if ( LOBYTE( wsaData.wVersion ) != 2 ||
     ) Q5 [6 G  |* Y0 f. q% l
113.         HIBYTE( wsaData.wVersion ) != 2 )
     
114.     {
     
115.          
     0 x0 f" @1 U- [3 K- ?0 x, t0 @3 d
116.         WSACleanup( );
     " p* d( I! C0 A2 P, o$ P  s: p
117.         return;
     
118.     }
     
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);
     0 A0 y7 X( D. @0 v$ G5 e
123.     addrSrv.sin_addr.S_un.S_addr = inet_addr("192.168.1.101");//服务器端的IP地址
     
124.      
     9 }; o2 L* J9 u  Q7 J! Y% P
125.     connect(socketClient, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
     
126.     char recvBuf[256];
     7 a6 k: g; h: U- S4 I: P5 _* d
127.     char sendBuf[] = "This is Joychou";
       W; v, d3 p6 C; a" _- M; S% ~
128.     recv(socketClient, recvBuf, 256, 0);
     0 w" A' ~$ y" C9 t/ b% S8 F
129.     printf("%s\n", recvBuf);
     $ S: J- W& h/ ^0 a0 _
130.     send(socketClient, sendBuf, strlen(sendBuf) + 1, 0);
     / h' T. ^$ f8 @0 ]/ C' O
131.     closesocket(socketClient);
     7 j2 D+ D, S: [
132.     WSACleanup();
     1 H: o, y; D  ^
133.      
     
134. }

复制代码

% e0 @2 }0 P1 r* |8 N6 P
7 n5 J: t4 K# L2 I9 s, g