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

admin

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

1. #include <winsock2.h>
   & @+ _& K7 K3 X$ D* g- B: y5 Z
2. #include <stdio.h>
     U9 f1 Q) E! f- V7 T! u0 x
3. #include <stdlib.h>
   + `; `- K/ O3 J) _* M- E- X/ f% n) O
4. 
   3 c  ^2 p& E( p. A  z
5. #define DEFAULT_PORT       5150
   
6. #define DEFAULT_BUFFER     2048
   
7. 
   : H; @  U! n( m6 J
8. char  szServer[128],
   : l9 q( T  y. k4 Z
9.      szMessage[1024];
   7 G) `# A2 r5 u( E( g" M, ]2 l4 o5 b
10. int  iPort    = DEFAULT_PORT;
    * `# V0 w+ G8 g" x9 A* a
11. 
    
12. int main()
    
13. {
    
14.    WSADATA      wsd;
    2 W: E6 l) f6 X1 x2 F! u
15.    SOCKET       sClient;
    
16.    char         szBuffer[DEFAULT_BUFFER];
    * X" n# N% o% `* Z. C( g
17.    int          ret;
    
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;
    
24.     }
    
25.    printf("Enter a string to send to server:\n");
    
26.    gets(szMessage);
    $ U4 s4 U$ i4 O8 z  h; F
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)
    
30.     {
    + T( `! r0 s0 o" C* @$ A
31.        printf("socket() failed: %d\n", WSAGetLastError());
    9 N  s1 u0 Q5 B1 e2 u! P- s3 X
32.        return 1;
    5 V8 T6 ?0 L% A5 C2 j$ A
33.     }
    
34.    server.sin_family = AF_INET;
    
35.    server.sin_port = htons(iPort);
    3 @9 g3 v8 X0 X' ~/ l9 U
36.    server.sin_addr.s_addr = inet_addr("127.0.0.1");
    6 x7 e( T) X+ K4 U+ a: Q
37. 
    4 @0 z: G+ F+ K' s5 m
38.     if (connect(sClient, (struct sockaddr *)&server,
    2 G! \: i: L, ^$ h9 s
39.        sizeof(server)) == SOCKET_ERROR)
    
40.     {
      F4 G+ x5 [; n1 m) O
41.        printf("connect() failed: %d\n", WSAGetLastError());
    
42.        return 1;
    & O/ P/ w6 c) U. p. u
43.     }
    & z0 p0 k& W; W) r' g* L1 q! B
44.     // Send and receive data
    
45.     ret = send(sClient, szMessage, strlen(szMessage), 0);
    
46.     if (ret == SOCKET_ERROR)
    $ b+ n. |/ m: C8 C" \# n: J2 D
47.     {
    ) s4 l' [! a/ B% @
48.        printf("send() failed: %d\n", WSAGetLastError());
    1 O- O3 M5 H: n) l9 w8 q
49.     }
    2 x- [2 v- P4 r3 m# ?: Q" j
50.     else{
    9 y7 }1 A. V% }2 w! D
51.        printf("Send '%s' \n", szMessage);
    ; Q, I  x0 Z( Y, r. c
52.        ret = recv(sClient, szBuffer, DEFAULT_BUFFER, 0);
    
53.        if (ret == SOCKET_ERROR){
    6 {) }2 r% s% v6 N' D5 q# M
54.          printf("recv() failed: %d\n", WSAGetLastError());
    $ q% A) e& f) X% l" B6 i  n
55.        }
    
56.        else{
    7 W7 z# r1 j5 L: _4 L" J2 c% @- C
57.          szBuffer[ret] = '\0';
    6 I% K5 S' l; J& l! u9 e: t# J: Q
58.          printf("RECV: '%s'\n",szBuffer);
    
59.        }
    
60.     }
    ; \1 n3 {3 |% C% c9 M
61.    closesocket(sClient);
    # ~$ i2 X/ s9 r# ^
62. 
    
63.    WSACleanup();
    # t/ H4 ~2 {7 y5 M; I
64.     return 0;
    * D" E' q8 e5 ~0 ]& d
65. }

复制代码

服务器程序:server.cpp

1. #include <winsock2.h>
   8 u, `8 B: K  Y  q! k* C
2. #include <stdio.h>
   : k  @) p4 `0 n9 n1 I3 c
3. #include <stdlib.h>
   
4. 
   
5. #define DEFAULT_PORT       5150
   
6. #define DEFAULT_BUFFER     4096
   / {' Z( ?# W" [; ~7 ^! Q
7. 
   9 J, I3 B1 t/ D; c) \
8. int   iPort     = DEFAULT_PORT;
   - ^" {  x; k6 V$ f5 `
9. char   szAddress[128];
   ! q* h+ i; d+ t+ b0 `: S: W( Y3 I! y
10. 
    
11. DWORD WINAPI ClientThread(LPVOID lpParam)
    ) J4 q0 b% m& u* m% H8 |
12. {
    
13.    SOCKET       sock=(SOCKET)lpParam;
    5 B7 w8 k6 {' F: K. g
14.    char         szBuff[DEFAULT_BUFFER];
    
15.    int          ret;
      {% b# G6 K+ Q/ n1 ^+ n
16. 
    
17.    while(1)
    2 g- x* G' y* z+ {' s1 h4 B
18.     {
    
19.        ret = recv(sock, szBuff, DEFAULT_BUFFER, 0);
    
20.        if (ret == 0)
    , [# m# O. K7 B! x, R
21.            break;
    
22.        else if (ret == SOCKET_ERROR)
    
23.        {
    : X9 w6 H( p7 J5 @
24.            printf("recv() failed: %d\n", WSAGetLastError());
    
25.            break;
    
26.        }
      j1 A+ d  A0 C
27.        szBuff[ret] = '\0';
    ! S* U" D% w" S7 Q5 X8 |/ `
28.        printf("RECV: '%s'\n", szBuff);
    
29.       if(strcmp(szBuff,"abc")==0){
    
30.          memcpy(szBuff,"Send the correct string!",25);
    ! Q' Y0 u7 I2 r
31.        }
      t: m8 T3 `" C6 ?7 d
32.        else{
    ( A2 g$ T1 ?) Z9 r  }
33.          memcpy(szBuff,"Send the wrong string!",23);
    1 P& j  F3 I, N% [
34.        }
    
35.        ret = send(sock, szBuff, strlen(szBuff), 0);
    
36.        if (ret == SOCKET_ERROR){
    ! M+ {4 m' E, r
37.          printf("send() failed: %d\n", WSAGetLastError());
    
38.        }
    
39.     }
    ; h* M: K$ ?! O8 o
40.     return 0;
    : I( l) ?6 E9 Q! o. v# Q4 @
41. }
      Q* J" U7 w: h8 |. m6 l) X
42. 
    ' f' s9 U! s% `% O
43. int main()
    
44. {
    
45.    WSADATA      wsd;
    & c; }0 `. r, u) G! C( Z; p
46.    SOCKET       sListen,
    4 t( t$ Z" Q8 Z6 S; [4 n# n) z
47.                  sClient;
    
48.    int          iAddrSize;
    . ^# O: }: ?3 \3 C! k
49.    HANDLE       hThread;
    
50.    DWORD        dwThreadId;
    
51.     struct sockaddr_in local,
    / F3 V; K0 d( I  x2 @
52.                       client;
    
53. 
    / l7 q4 _7 p' c/ @: K( e4 s; r
54.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    7 O2 q( ~& W* U7 Z, e+ ?
55.     {
    
56.        printf("Failed to load Winsock!\n");
    5 R1 R% l2 M5 o2 a) T
57.        return 1;
    2 x* f5 N7 g9 M" l% S& Q" n. Y
58.     }
    % j9 o9 m# t6 K6 U% e% I3 x7 k  V
59.     // Create our listening socket
    
60.     sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
    
61.     if (sListen == SOCKET_ERROR)
    $ b, \1 _  B+ C" ~! \- Q, {; P$ p
62.     {
    5 |3 j5 a+ k' Y/ B0 J& u7 s
63.        printf("socket() failed: %d\n", WSAGetLastError());
    
64.        return 1;
    - X! W& r6 R- b" {$ H: _
65.     }
    
66.    local.sin_addr.s_addr = htonl(INADDR_ANY);
    
67.    local.sin_family = AF_INET;
    3 Y+ }: A- F6 u3 Y
68.    local.sin_port = htons(iPort);
    / _4 \. g# |# }. e" F+ m2 ~
69. 
    
70.     if (bind(sListen, (struct sockaddr *)&local,
    
71.            sizeof(local)) == SOCKET_ERROR)
    6 ~' E& J1 j( H/ l
72.     {
    7 a. A: a" G  U1 k% u7 D
73.        printf("bind() failed: %d\n", WSAGetLastError());
    2 B. w+ u1 O2 X5 G( o( P
74.        return 1;
    
75.     }
    
76.    listen(sListen, 8);
    
77.     // In a continous loop, wait for incoming clients. Once one
    
78.     // is detected, create a thread and pass the handle off to it.
    0 p/ M% ?+ j4 d; E2 L; y2 V5 H
79.     while (1)
      I. e' w9 T! w: X# d
80.     {
    
81.        iAddrSize = sizeof(client);
    
82.        sClient = accept(sListen, (struct sockaddr *)&client,
    # N0 W) `4 q0 |6 F: E
83.                        &iAddrSize);      
    
84.        if (sClient == INVALID_SOCKET)
    
85.        {      
    
86.            printf("accept() failed: %d\n", WSAGetLastError());
    
87.            break;
    , s* U8 Z# }+ D- D; |9 u
88.        }
    
89.        printf("Accepted client: %s:%d\n",
    . j" |  ^  n+ |; m) ~: Y& J
90.            inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    # x9 Z% G' x+ I. a
91. 
    
92.        hThread = CreateThread(NULL, 0, ClientThread,
    
93.                    (LPVOID)sClient, 0, &dwThreadId);
    - F& ^5 b+ b# e  {1 ?
94.        if (hThread == NULL)
    
95.        {
    
96.            printf("CreateThread() failed: %d\n", GetLastError());
    
97.            break;
    
98.        }
    9 w0 j& c. |3 I9 M
99.        CloseHandle(hThread);
    0 l4 u" H  P) @9 \
100.     }
     
101.    closesocket(sListen);
     
102.    
     4 h$ }. H" ^) Z& u
103.    WSACleanup();
     
104.     return 0;
     6 B, H* E' _5 r2 e7 r! C
105. }

复制代码

8 |: a5 S+ f4 p


0 `  T. {$ b4 g4 Y! r5 l& c
" j. G0 a; G3 u& _

admin

1. 作为服务器，你要绑定【bind】到本地的IP地址上进行监听【listen】，但是你的机器上可能有多块网卡，也就有多个IP地址，这时候你要选择绑定在哪个IP上面，如果指定为INADDR_ANY，那么系统将绑定默认的网卡【即IP地址】。
   
2. 
   
3. 作为客户端，你要连接【connect】到远端的服务器，也是要指定远端服务器的（ip, port）对。
   
4. 当然，在这种情况下，不可能将IP地址指定为INADDR_ANY，系统会疯掉的。
   * ^4 b% L- E5 a. R+ o
5. 
   $ M! y* j) V' I1 F
6. Server：
   4 @8 T% X  {4 x! l
7. #include <winsock2.h>
   * J, x! O& \7 y: J
8. #pragma comment(lib, "WS2_32.lib")
   : t- k5 R' K. Q: D+ [
9. 
   
10. #include <stdio.h>
    
11. void main()
    
12. {
    
13.     WORD wVersionRequested;//版本号
    " m3 h% c" @4 ]# U" a
14.     WSADATA wsaData;
    
15.     int err;
    
16. 
    
17.     wVersionRequested = MAKEWORD(2, 2);//2.2版本的套接字
    ; d! o# S- P) P: H& _8 k4 N' ^8 k
18.     //加载套接字库,如果失败返回
    * z; X1 V! Q8 w  V9 F0 F
19.     err = WSAStartup(wVersionRequested, &wsaData);
    % a1 ~) R6 l4 j
20.     if (err != 0)
    
21.     {
    
22.         return;
    9 V& _0 ^3 R$ \8 p
23.     }
    6 m( v/ q, v7 b% m+ E& q7 ?
24. 
    
25.     //判断高低字节是不是2,如果不是2.2的版本则退出
    
26.     if (LOBYTE(wsaData.wVersion) != 2 ||
    / M# t* A* t: i3 N
27.          
    ) C" i$ y; _- |. v4 W# P4 A# O
28.         HIBYTE(wsaData.wVersion) != 2)
    
29.          
    , `. j. u4 g8 D
30.     {
    
31.         return;
    1 k; Y$ B) j  ^0 p& v
32.     }
    
33.      
    
34.          //创建流式套接字,基于TCP(SOCK_STREAM)
    
35. 
    ! k8 U7 o4 Q* w" U) K& Q! q
36.          SOCKET socSrv = socket(AF_INET, SOCK_STREAM, 0);
    
37. 
    
38.          //Socket地址结构体的创建
    
39. 
    ( Y: H$ n4 v" p9 u5 v. D
40.          SOCKADDR_IN addrSrv;
    
41. 
    4 i1 Y! E$ s( r2 e; W2 h% y1 I. ?2 ~
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);
    , R' D% \/ D4 j2 j
45.         //指定端口号,除sin_family参数外,其它参数都是网络字节序,因此需要转换
    ( n4 ~$ P& C9 t. W. N1 a% _# z
46. 
    
47.          //将套接字绑定到一个端口号和本地地址上
    7 v' }/ F1 m. |  E  a* A2 S
48.          bind(socSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));//必须用sizeof，strlen不行
    
49. 
    
50.          listen(socSrv, 5);
    
51.          
    : O3 {4 U" y; A7 q( F- S& e- h
52.          SOCKADDR_IN addrClient;//字义用来接收客户端Socket的结构体
    
53. 
    ' Y7 J) T3 N3 e) K
54.          int len = sizeof(SOCKADDR);//初始化参数,这个参数必须进行初始化，sizeof
    5 P/ k( O) \3 p, a) h% e; K
55. 
    9 {) }) v  n2 t* r
56.          //循环等待接受客户端发送请求
    ; Z$ t0 a5 {6 i' \6 i
57. 
    
58.          while (1)
    " e* q7 V- ?( p+ d
59.          {
    
60.                    //等待客户请求到来；当请求到来后，接受连接请求，
    7 v) s: a% P& \7 Q
61. 
    6 y& v: t, ~5 `
62.                    //返回一个新的对应于此次连接的套接字（accept）。
    
63.                    //此时程序在此发生阻塞
    ! _8 C/ x' ?, ]" j4 `2 Z
64. 
    ) b( c' v' C0 V. e7 t6 @0 Y
65.                    SOCKET sockConn = accept(socSrv, (SOCKADDR*)&addrClient, &len);
    
66. 
    
67.                    char sendBuf[100];
    3 I$ K0 t, C0 c
68. 
    5 z) K3 ^: J8 `& J6 @: n& ?/ V0 H
69.                    sprintf(sendBuf, "Welcome %s to JoyChou",
    
70. 
    
71.                             inet_ntoa(addrClient.sin_addr));//格式化输出
    
72. 
    9 N  d3 x; l9 W
73.                    //用返回的套接字和客户端进行通信
    ' a8 r. g7 B1 R% s& O4 R5 i
74. 
    
75.                    send(sockConn, sendBuf, strlen(sendBuf)+1, 0);//多发送一个字节
    ; a* D6 m  |# k9 J! ^, V
76. 
    ) e! O# a4 z  {0 i; k
77.                    //接收数据
    3 H( @0 {: T) U7 Z4 K$ z6 [
78. 
      L4 p. P6 T0 N; u9 g* Z
79.                    char recvBuf[100];
    ; l3 `9 n, c* o9 X1 r- D4 K9 h
80. 
    ( P5 i4 I* f' `) L
81.                    recv(sockConn, recvBuf, 100, 0);
    + `% ]7 c4 N% I- L& w
82. 
    1 ^( U. |% p3 C" y* Z
83.                    printf("%s\n", recvBuf);
    " g* Q2 r* k' ~9 b
84.                    closesocket(sockConn);
    
85. 
    
86.          }
    
87. }
    * @$ w% D5 n) F6 v+ p; O; v
88. 
    
89. 
    : j5 M4 R9 Z3 Q9 }. T' R
90. Client：
    
91. 
    2 t6 \: V4 x& K9 c( ~
92. #include <winsock2.H>
    7 V8 m2 K& h: B" f
93. #pragma comment(lib, "Ws2_32.lib")
    % ~( n6 t4 n$ F6 ?. [9 m6 B
94. #include <stdio.h>
    8 c$ |, R9 C- T
95. #include <string.h>
    
96. 
    7 n9 g6 D, i. _- |; v. ]
97. void main()
    
98. {   
    
99.     WORD wVersionRequested;
    
100.     WSADATA wsaData;
     ' x3 ]& c! W2 J4 y9 I8 B
101.     int err;
     
102.      
     ( T. u+ Q8 x2 {
103.     wVersionRequested = MAKEWORD( 2, 2 );
     
104.      
     . h( G2 v9 c$ Q1 Y7 f
105.     err = WSAStartup( wVersionRequested, &wsaData );
     0 O! {5 ?0 }" Q3 a4 e2 N
106.     if ( err != 0 ) {
     
107.          
     6 T* E5 x% [5 k  H
108.         return;
     # {2 b6 X! {0 }9 y
109.     }
     
110.      
     : S& x+ N/ c4 n8 J: @
111.      
     ! b. a& m4 k6 e! a6 T4 o2 J' B$ z
112.     if ( LOBYTE( wsaData.wVersion ) != 2 ||
     / W0 y3 b0 C8 T0 f! f9 c: A
113.         HIBYTE( wsaData.wVersion ) != 2 )
     * m# e' x, H' _% c2 m. I
114.     {
     
115.          
     
116.         WSACleanup( );
     2 }; V9 `  I2 J. i  _! h# o
117.         return;
     
118.     }
       [. H' W8 Q( `! \+ L6 |
119.     SOCKET socketClient = socket(AF_INET, SOCK_STREAM, 0);
     
120.     SOCKADDR_IN addrSrv;
     6 U9 b8 }8 |; h% X
121.     addrSrv.sin_family = AF_INET;
     ' s/ T5 E- `( O% G9 h& c, A: H9 A4 m
122.     addrSrv.sin_port = htons(6000);
     
123.     addrSrv.sin_addr.S_un.S_addr = inet_addr("192.168.1.101");//服务器端的IP地址
     
124.      
     
125.     connect(socketClient, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
     
126.     char recvBuf[256];
     " S. \! m0 N- s) W( k
127.     char sendBuf[] = "This is Joychou";
     5 f! [6 W& f7 C* U* @
128.     recv(socketClient, recvBuf, 256, 0);
     ( Z# U5 Q2 R: q  C
129.     printf("%s\n", recvBuf);
     
130.     send(socketClient, sendBuf, strlen(sendBuf) + 1, 0);
     
131.     closesocket(socketClient);
     
132.     WSACleanup();
     
133.      
     0 `, _+ e( {5 X& L3 z  d" w
134. }

复制代码

8 X; i( i7 A! |6 @
. ~8 e3 s  o2 y