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

admin

程序很简单，windows环境下的，客户端和服务器程序都在本机运行，在客户端输入发送给服务器的字符串，服务器收到字符串后会打印出来，同时与"abc"比较，与"abc"相同就会返给客户端，输入的是正确的，不同会告诉客户端输入时错误的。
& H% v  Z5 J$ p( j' E/ ]0 L/ @8 l客户端程序：client.cpp

1. #include <winsock2.h>
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   4 t9 l$ \* Z( \' U; e" k
4. 
   . W4 j8 K* d6 _
5. #define DEFAULT_PORT       5150
   " I% r! B" G5 }! Y, Q
6. #define DEFAULT_BUFFER     2048
   
7. 
   5 n/ W/ r! P/ u2 Q8 g) {9 k. t
8. char  szServer[128],
   
9.      szMessage[1024];
   6 f, X, Y7 {4 v) D: J* K
10. int  iPort    = DEFAULT_PORT;
    
11. 
    
12. int main()
    
13. {
    
14.    WSADATA      wsd;
    5 n# O* I; S) p! ^
15.    SOCKET       sClient;
    
16.    char         szBuffer[DEFAULT_BUFFER];
    
17.    int          ret;
    8 O( ?3 ]* Z! D  j) o
18.     struct sockaddr_in server;
    
19.     struct hostent    *host = NULL;
    
20.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    
21.     {
    8 [# C! j$ m0 N) q) d
22.        printf("Failed to load Winsock library!\n");
    - z. ]4 H+ B7 Q) j3 f) W
23.        return 1;
    9 ]" a/ K6 d/ p7 F) ?
24.     }
    2 f  H7 |$ Z: U; ~2 n
25.    printf("Enter a string to send to server:\n");
    6 {5 M2 p! }* R' l3 c2 I# u
26.    gets(szMessage);
    
27.     // Create the socket, and attempt to connect to the server
    " a. K% o# C6 F8 Y  e; Q5 k! n6 I
28.     sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    2 r$ X, K/ ]5 P) E1 Z9 q1 f
29.     if (sClient == INVALID_SOCKET)
    8 l; S+ C4 k; \2 A! {( K
30.     {
    / @7 J; \; H: E
31.        printf("socket() failed: %d\n", WSAGetLastError());
    6 d/ f  f: ^' s7 o! O0 ~% X' l
32.        return 1;
      d. P, j5 e* [* U+ ]
33.     }
    
34.    server.sin_family = AF_INET;
    * v' a/ ^+ r6 t% O7 v* h( w: k
35.    server.sin_port = htons(iPort);
    - r& |/ `+ ^) C/ C
36.    server.sin_addr.s_addr = inet_addr("127.0.0.1");
    1 M: S+ y% a3 n' K
37. 
    - `5 J/ v' K9 G3 n) R
38.     if (connect(sClient, (struct sockaddr *)&server,
    1 L; b/ W( d/ e$ p+ d! A, u, J4 T
39.        sizeof(server)) == SOCKET_ERROR)
    $ l) O) M) K+ M9 \! F1 c2 Z
40.     {
    % H5 r) }& ?5 ^* i2 x
41.        printf("connect() failed: %d\n", WSAGetLastError());
    
42.        return 1;
      H6 |  [0 N; ^& H# M; [
43.     }
    ) F- Y. k  y3 \" l! W
44.     // Send and receive data
    
45.     ret = send(sClient, szMessage, strlen(szMessage), 0);
    4 I" S7 Z% L, S- P2 g  l2 [2 h( ^9 T; U
46.     if (ret == SOCKET_ERROR)
    ( f* p: H7 z) d: Y( W7 L+ ?' ^% I
47.     {
    " k8 J# I$ ]. @0 i
48.        printf("send() failed: %d\n", WSAGetLastError());
    
49.     }
    + j; o9 y. H1 C# ]/ ?4 I
50.     else{
    1 r4 p& D, B/ @4 D0 O% s
51.        printf("Send '%s' \n", szMessage);
    0 V( {+ ~+ ?. c5 ~9 N0 C8 W" m
52.        ret = recv(sClient, szBuffer, DEFAULT_BUFFER, 0);
    
53.        if (ret == SOCKET_ERROR){
    
54.          printf("recv() failed: %d\n", WSAGetLastError());
    1 ~! A  e) R; j+ F! b
55.        }
    
56.        else{
    
57.          szBuffer[ret] = '\0';
    , b% N0 y/ Q2 o8 `
58.          printf("RECV: '%s'\n",szBuffer);
    
59.        }
    6 F; {8 w5 V' D* [/ S  ~+ h
60.     }
    3 j6 I0 U4 q5 k
61.    closesocket(sClient);
    
62. 
    5 h/ l& [* ?9 G' |
63.    WSACleanup();
    ' g; j: Q" b8 t2 l# o
64.     return 0;
    
65. }

复制代码

服务器程序:server.cpp

1. #include <winsock2.h>
   & @% O: A6 m, c! Z: b1 `. J" a
2. #include <stdio.h>
   3 l  b" p0 A* w  \5 _! V
3. #include <stdlib.h>
   " N8 M8 ?) o: F9 l
4. 
   
5. #define DEFAULT_PORT       5150
   
6. #define DEFAULT_BUFFER     4096
   ( m: z" f9 q9 Z8 h. c) P. w: @$ r
7. 
   
8. int   iPort     = DEFAULT_PORT;
   9 M! D! J8 i* E$ B
9. char   szAddress[128];
   
10. 
    
11. DWORD WINAPI ClientThread(LPVOID lpParam)
    
12. {
    
13.    SOCKET       sock=(SOCKET)lpParam;
    
14.    char         szBuff[DEFAULT_BUFFER];
    ' h1 O1 v+ {, b4 K( d: p; R) R% `
15.    int          ret;
    
16. 
    # J3 `& |2 x  d: o+ r  n' j% N
17.    while(1)
    
18.     {
    ) I& i% N7 q+ Q2 }: W
19.        ret = recv(sock, szBuff, DEFAULT_BUFFER, 0);
    
20.        if (ret == 0)
    
21.            break;
    
22.        else if (ret == SOCKET_ERROR)
    3 T6 M0 C: \6 R. Q, x! m
23.        {
    + A+ n% m7 i% _: T% j& m% N7 C
24.            printf("recv() failed: %d\n", WSAGetLastError());
    6 l0 o& y8 K/ K" y
25.            break;
    
26.        }
    
27.        szBuff[ret] = '\0';
    
28.        printf("RECV: '%s'\n", szBuff);
    
29.       if(strcmp(szBuff,"abc")==0){
    0 e2 ?7 d2 z8 Z9 o- ~$ |
30.          memcpy(szBuff,"Send the correct string!",25);
    
31.        }
    - d- E+ U7 h6 C: Y5 i
32.        else{
    
33.          memcpy(szBuff,"Send the wrong string!",23);
    ( K$ o1 Q- g" ]: K  G" r
34.        }
    2 M3 s* m8 T1 s9 [" s
35.        ret = send(sock, szBuff, strlen(szBuff), 0);
    
36.        if (ret == SOCKET_ERROR){
    % P* P% n& R* m3 i- t
37.          printf("send() failed: %d\n", WSAGetLastError());
    4 I( w) {! g7 p6 K6 k5 V
38.        }
    
39.     }
    # c( j! _! k+ W/ F. e
40.     return 0;
    8 v6 ^% A( h+ }; j5 f0 |* ?! e
41. }
    1 k2 F' P0 O3 v- {% L
42. 
    
43. int main()
    $ ~' J- w: P' c5 ?4 T! m
44. {
    ! P: R, p! y  f& E4 M  h% a& C
45.    WSADATA      wsd;
    
46.    SOCKET       sListen,
    . \& N  y+ o) p% l( a
47.                  sClient;
    
48.    int          iAddrSize;
    
49.    HANDLE       hThread;
    
50.    DWORD        dwThreadId;
    & M1 I) i0 G4 Q, }9 F! v4 W6 Z3 u; w
51.     struct sockaddr_in local,
    
52.                       client;
    
53. 
    
54.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    $ l* E( m7 [: u6 L
55.     {
    
56.        printf("Failed to load Winsock!\n");
    # G/ [: H+ K$ l8 k6 g1 I2 ?
57.        return 1;
    9 D( w% U% P4 H
58.     }
    
59.     // Create our listening socket
    $ W0 M8 a* x) L2 w5 J; J
60.     sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
    ' Z, [7 s0 m" |1 e# C4 r6 n4 v
61.     if (sListen == SOCKET_ERROR)
    
62.     {
    
63.        printf("socket() failed: %d\n", WSAGetLastError());
    
64.        return 1;
    
65.     }
    
66.    local.sin_addr.s_addr = htonl(INADDR_ANY);
    9 _. Z: ^3 E* W0 M" ~' N7 u
67.    local.sin_family = AF_INET;
    6 k2 Y4 n: ^4 |/ [" R
68.    local.sin_port = htons(iPort);
    ( `7 a6 T7 e: L  z
69. 
    & [+ w; b+ x4 b/ h( s
70.     if (bind(sListen, (struct sockaddr *)&local,
    & }" j# r) }/ O. m: R: N) l
71.            sizeof(local)) == SOCKET_ERROR)
    
72.     {
    
73.        printf("bind() failed: %d\n", WSAGetLastError());
    ; |. U$ H* p( x
74.        return 1;
    " U9 z# m: }, N* d$ \! I
75.     }
    9 e* T* u& j2 ^1 L1 @
76.    listen(sListen, 8);
    
77.     // In a continous loop, wait for incoming clients. Once one
    4 Y4 c! Q. i  e3 R1 r  I6 z9 q
78.     // is detected, create a thread and pass the handle off to it.
    
79.     while (1)
    
80.     {
    
81.        iAddrSize = sizeof(client);
    / K1 Z7 R( q, ~  X! G
82.        sClient = accept(sListen, (struct sockaddr *)&client,
    . q2 y( z9 j* J1 Y6 j
83.                        &iAddrSize);      
    ! _* _( |8 k* O- X- Q' b; \- Q4 T
84.        if (sClient == INVALID_SOCKET)
    
85.        {      
    
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));
    . G( |- h' M3 o1 M- U; |3 _5 b
91. 
    : ~0 D* H! e% A5 L( S
92.        hThread = CreateThread(NULL, 0, ClientThread,
    " w0 x1 ?* I' k; {& U' H  B+ i! @
93.                    (LPVOID)sClient, 0, &dwThreadId);
    6 v9 m7 Z2 W) \1 `4 E2 N
94.        if (hThread == NULL)
    
95.        {
    
96.            printf("CreateThread() failed: %d\n", GetLastError());
    
97.            break;
    
98.        }
    5 \' c& D- Z6 g" \# t% [$ s
99.        CloseHandle(hThread);
    
100.     }
     : ^# w* o- P% Q2 |1 K
101.    closesocket(sListen);
     
102.    
     ( y& }9 i9 g; S6 N$ p
103.    WSACleanup();
     
104.     return 0;
     . p- y# O- |3 Y) ~# f1 {- b1 V$ w% D
105. }

复制代码

8 r9 f- F5 k9 X

) t) ?, [5 x' G

3 G: Z# g) p5 t3 {

admin

1. 作为服务器，你要绑定【bind】到本地的IP地址上进行监听【listen】，但是你的机器上可能有多块网卡，也就有多个IP地址，这时候你要选择绑定在哪个IP上面，如果指定为INADDR_ANY，那么系统将绑定默认的网卡【即IP地址】。
   
2. 
   
3. 作为客户端，你要连接【connect】到远端的服务器，也是要指定远端服务器的（ip, port）对。
   & C6 K, C2 \+ M7 G
4. 当然，在这种情况下，不可能将IP地址指定为INADDR_ANY，系统会疯掉的。
   & z7 x/ Y6 b+ R6 F; o/ \+ S! ~
5. 
   
6. Server：
   ! q9 N% `; f' H( z) x! F
7. #include <winsock2.h>
   
8. #pragma comment(lib, "WS2_32.lib")
   
9. 
   
10. #include <stdio.h>
    9 i6 ]2 |4 g7 _  C, b8 x
11. void main()
    
12. {
    
13.     WORD wVersionRequested;//版本号
    
14.     WSADATA wsaData;
    
15.     int err;
    
16. 
    
17.     wVersionRequested = MAKEWORD(2, 2);//2.2版本的套接字
    
18.     //加载套接字库,如果失败返回
    ! c7 i( E! q" J7 m' A; ?: o4 ?
19.     err = WSAStartup(wVersionRequested, &wsaData);
    / W8 V( ]  b. h, c8 G# M
20.     if (err != 0)
    
21.     {
    
22.         return;
    
23.     }
    
24. 
    
25.     //判断高低字节是不是2,如果不是2.2的版本则退出
    3 u% E# H! Z& v5 h1 G; ?, J' Y
26.     if (LOBYTE(wsaData.wVersion) != 2 ||
    - o. o) R9 C8 T: A8 S, e
27.          
    
28.         HIBYTE(wsaData.wVersion) != 2)
    3 O1 j5 h/ x' S! d! L& J# J  z) i
29.          
    3 K9 v, s7 @; t7 `- T0 o+ d% Y; @0 K
30.     {
    3 T8 \4 i; ?4 z9 Q4 r& d  N
31.         return;
    
32.     }
    ! C. ]& i. q0 V* t( F
33.      
    
34.          //创建流式套接字,基于TCP(SOCK_STREAM)
    
35. 
    & U& q1 ?! I# a& d" D
36.          SOCKET socSrv = socket(AF_INET, SOCK_STREAM, 0);
    * _3 D2 l8 E7 E$ j# r1 ?- u" n
37. 
    
38.          //Socket地址结构体的创建
    1 b; g6 |. I; S2 l+ c
39. 
    
40.          SOCKADDR_IN addrSrv;
    ( [; N  Q) ]& w/ C. j# r: F
41. 
    5 y# }) i" v0 b: k# N1 J
42.          addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);//转换Unsigned long型为网络字节序格
    0 t9 e9 N# k) ~5 L. x2 o
43.          addrSrv.sin_family = AF_INET;//指定地址簇
    - c7 F% U% U5 J9 i4 m2 Z1 A
44.          addrSrv.sin_port = htons(6000);
    7 `5 H3 G7 @* q# o7 O. q6 u: W+ F
45.         //指定端口号,除sin_family参数外,其它参数都是网络字节序,因此需要转换
    " l' Q9 S( W, ^0 O3 x+ A
46. 
    5 G4 H2 K+ v7 ]- K; M
47.          //将套接字绑定到一个端口号和本地地址上
    # G2 E% d* c1 |1 t+ f
48.          bind(socSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));//必须用sizeof，strlen不行
    
49. 
    3 l( i& R; A4 ?9 k
50.          listen(socSrv, 5);
    * Y) h' g" a& g' |% b* T3 n5 a' r
51.          
    
52.          SOCKADDR_IN addrClient;//字义用来接收客户端Socket的结构体
    * `8 _& ?1 e' R7 m# n% c
53. 
    
54.          int len = sizeof(SOCKADDR);//初始化参数,这个参数必须进行初始化，sizeof
    1 _. G2 y' A9 B, N: u
55. 
    
56.          //循环等待接受客户端发送请求
    ( F. W. x+ z* l: w' i2 u
57. 
    
58.          while (1)
    
59.          {
    ! n! ~& g" B& n; ~
60.                    //等待客户请求到来；当请求到来后，接受连接请求，
    
61. 
    
62.                    //返回一个新的对应于此次连接的套接字（accept）。
    
63.                    //此时程序在此发生阻塞
    
64. 
    8 Q8 B1 Y/ i) D6 U; }
65.                    SOCKET sockConn = accept(socSrv, (SOCKADDR*)&addrClient, &len);
    
66. 
    
67.                    char sendBuf[100];
    2 {( G& v% e) \1 s5 j& d7 |. ^4 v
68. 
    
69.                    sprintf(sendBuf, "Welcome %s to JoyChou",
    & ?, C: }- B) t# v8 g0 P
70. 
    
71.                             inet_ntoa(addrClient.sin_addr));//格式化输出
    
72. 
    % c, }2 Q! ~9 j7 }: G* H% x) `; p
73.                    //用返回的套接字和客户端进行通信
    
74. 
    
75.                    send(sockConn, sendBuf, strlen(sendBuf)+1, 0);//多发送一个字节
    ! G, s! p6 o& T8 J0 r0 I
76. 
    
77.                    //接收数据
    ( q5 s+ [  B7 }5 B8 h
78. 
    
79.                    char recvBuf[100];
    
80. 
    % n# K- R& V+ i9 F  W3 I' u/ n7 M
81.                    recv(sockConn, recvBuf, 100, 0);
    
82. 
    
83.                    printf("%s\n", recvBuf);
    ' H# P9 o8 o5 |- M+ d: f/ i# K# b" p
84.                    closesocket(sockConn);
    
85. 
    % h  U3 d3 d& B0 O2 C
86.          }
    7 S' k) Z/ n7 y6 h# B  x( O
87. }
    1 e9 v% h3 q% a3 i& O5 m
88. 
    / V, `. A* P  y$ t1 Z9 z6 z" z6 W1 {
89. 
    , X$ Y6 s; A( \- k% Y; s% P
90. Client：
    0 p4 w% g' t' N% r5 e
91. 
    : l3 x* y7 ]; A! Q
92. #include <winsock2.H>
    5 f, h- k* i- T  @
93. #pragma comment(lib, "Ws2_32.lib")
    ! v4 n0 j5 Y$ v6 w, h
94. #include <stdio.h>
    * ~* U' Y8 I5 A; d) T$ ]2 |, m
95. #include <string.h>
    
96. 
    / w" q3 B7 a, o" S2 f  _
97. void main()
    
98. {   
    
99.     WORD wVersionRequested;
    
100.     WSADATA wsaData;
     
101.     int err;
     ' |+ E6 W/ t! h* c6 N
102.      
     
103.     wVersionRequested = MAKEWORD( 2, 2 );
     # c8 C" r4 F, |$ ^
104.      
     
105.     err = WSAStartup( wVersionRequested, &wsaData );
     ; e$ W8 c$ S" _$ c0 g5 O
106.     if ( err != 0 ) {
     : d# \2 P2 |0 N
107.          
     
108.         return;
     
109.     }
       D# k6 ]. n$ \7 q9 i& b) `' T
110.      
     
111.      
     
112.     if ( LOBYTE( wsaData.wVersion ) != 2 ||
     
113.         HIBYTE( wsaData.wVersion ) != 2 )
     
114.     {
     
115.          
     * a8 k6 j& X9 |* ~2 ^
116.         WSACleanup( );
     
117.         return;
       B/ l1 W* C* N2 ^6 G; B
118.     }
     
119.     SOCKET socketClient = socket(AF_INET, SOCK_STREAM, 0);
     - K! r9 a' A, l1 E8 C( [( h
120.     SOCKADDR_IN addrSrv;
     
121.     addrSrv.sin_family = AF_INET;
     
122.     addrSrv.sin_port = htons(6000);
     & P! ~$ D1 b$ S
123.     addrSrv.sin_addr.S_un.S_addr = inet_addr("192.168.1.101");//服务器端的IP地址
     * A' ]1 h, F: r  \; x- K9 d8 W
124.      
     
125.     connect(socketClient, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
     $ k- a1 M& `! e0 H/ J
126.     char recvBuf[256];
     
127.     char sendBuf[] = "This is Joychou";
     % @# x  A! D% `/ N- G7 p" ]
128.     recv(socketClient, recvBuf, 256, 0);
     
129.     printf("%s\n", recvBuf);
     
130.     send(socketClient, sendBuf, strlen(sendBuf) + 1, 0);
     ) G3 q; z( q2 U5 m6 C
131.     closesocket(socketClient);
     % h. Y4 `* m/ u6 j. w1 Y- m
132.     WSACleanup();
     
133.      
     8 W5 E& t, I# {8 H
134. }

复制代码