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

admin

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

1. #include <winsock2.h>
   7 ^/ U9 B' W  Q0 |7 x0 M
2. #include <stdio.h>
   
3. #include <stdlib.h>
   2 P/ |. X7 Q- e  X1 P! O
4. 
   + g5 u8 q6 l5 l; K/ \" E5 V
5. #define DEFAULT_PORT       5150
   
6. #define DEFAULT_BUFFER     2048
   + Z  D6 k7 M$ p7 U1 p
7. 
   7 S' k2 ?" S% k  ^& u
8. char  szServer[128],
   # b6 D& V1 a- G5 ^5 Q2 x2 i
9.      szMessage[1024];
   " v' g5 S8 v4 O9 b0 x) i* R+ e" Z
10. int  iPort    = DEFAULT_PORT;
    
11. 
    ( N1 w% U( m7 i  o7 x( ]
12. int main()
    
13. {
    * l4 V: }5 G: C! G
14.    WSADATA      wsd;
    
15.    SOCKET       sClient;
    + P( X/ c. U, {  g7 v" _7 W
16.    char         szBuffer[DEFAULT_BUFFER];
    # y- F' k$ k" i3 H, w
17.    int          ret;
    
18.     struct sockaddr_in server;
    
19.     struct hostent    *host = NULL;
    
20.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    & T2 L* {  n1 n* f
21.     {
    / O1 o6 R1 ^+ p; H
22.        printf("Failed to load Winsock library!\n");
    * C) ^% {5 C% ~2 o0 ]6 T) k4 y( }+ S
23.        return 1;
    
24.     }
    ! T4 k# @" Z. M2 @3 N$ s/ B
25.    printf("Enter a string to send to server:\n");
    
26.    gets(szMessage);
    
27.     // Create the socket, and attempt to connect to the server
    
28.     sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    4 C8 P: `! _$ @8 T
29.     if (sClient == INVALID_SOCKET)
    0 }  \8 _. ]- C3 m
30.     {
    & g- a: b" F) i9 F# g) N4 k- ]
31.        printf("socket() failed: %d\n", WSAGetLastError());
    ) U" q0 g) p' v& H% Y& k3 l: l. ?
32.        return 1;
    0 p: ^! u, f5 l) D" e& z
33.     }
    5 V9 L8 f( {# @
34.    server.sin_family = AF_INET;
    : J: J  H" u6 Q6 c4 Z+ C/ U8 O
35.    server.sin_port = htons(iPort);
    ' Y- P( c. j! V* T" U% r  o  `$ L4 d
36.    server.sin_addr.s_addr = inet_addr("127.0.0.1");
    
37. 
    
38.     if (connect(sClient, (struct sockaddr *)&server,
    
39.        sizeof(server)) == SOCKET_ERROR)
    / b- t# Y5 X, d' E+ F
40.     {
    
41.        printf("connect() failed: %d\n", WSAGetLastError());
    
42.        return 1;
    
43.     }
    ; ?! ~; H* Y4 W* G) ?
44.     // Send and receive data
    ) |% x9 v2 S5 }1 W; p) N
45.     ret = send(sClient, szMessage, strlen(szMessage), 0);
    " L# i: P9 B( ~
46.     if (ret == SOCKET_ERROR)
    
47.     {
    
48.        printf("send() failed: %d\n", WSAGetLastError());
    
49.     }
    $ @8 ~* Y0 @7 Y6 Q$ T. s6 b
50.     else{
    " S8 E) h7 A6 W( ^( }& q
51.        printf("Send '%s' \n", szMessage);
    ! a4 A; ?( l8 J0 V; n8 T
52.        ret = recv(sClient, szBuffer, DEFAULT_BUFFER, 0);
    
53.        if (ret == SOCKET_ERROR){
    
54.          printf("recv() failed: %d\n", WSAGetLastError());
    + |" r$ u" `1 ?/ h% j
55.        }
    & s5 E; Q" S3 `
56.        else{
    - z# m6 _2 V9 }* i$ C
57.          szBuffer[ret] = '\0';
    
58.          printf("RECV: '%s'\n",szBuffer);
    
59.        }
    + P+ i6 r* K# q* L( L
60.     }
    ( Y+ ]& i- Q- ^! w, _
61.    closesocket(sClient);
    ) Z( {; c$ [- G1 m
62. 
    ' Q$ I( W9 f8 U+ M7 D+ _1 G$ w  s
63.    WSACleanup();
    5 c0 p# U' q$ E1 ~/ X/ l" D
64.     return 0;
    
65. }

复制代码

服务器程序:server.cpp
. N( ~; O5 z4 s/ L; e; K2 @

1. #include <winsock2.h>
   5 c: G! J4 q# y! R. ^* |5 X
2. #include <stdio.h>
   1 N5 w1 E5 |- O$ F
3. #include <stdlib.h>
   
4. 
   " p" ^4 ?+ x" R" k
5. #define DEFAULT_PORT       5150
   
6. #define DEFAULT_BUFFER     4096
   
7. 
   9 j" T2 _6 h) M, F
8. int   iPort     = DEFAULT_PORT;
   
9. char   szAddress[128];
   # G& H7 {0 g& ^2 e" C3 D  i
10. 
    
11. DWORD WINAPI ClientThread(LPVOID lpParam)
    ! R$ O2 Z9 f' g- q
12. {
    2 i! b: j3 H0 f% f) y) \. b
13.    SOCKET       sock=(SOCKET)lpParam;
    
14.    char         szBuff[DEFAULT_BUFFER];
    
15.    int          ret;
    ; \+ D: L2 d- I; I; _% T% m
16. 
    2 N  K4 o& q  p! R" p* a
17.    while(1)
    
18.     {
    
19.        ret = recv(sock, szBuff, DEFAULT_BUFFER, 0);
    
20.        if (ret == 0)
    . `1 p  d9 p4 f  V
21.            break;
    
22.        else if (ret == SOCKET_ERROR)
    
23.        {
    % e! c- G) ^3 W2 x; {8 w
24.            printf("recv() failed: %d\n", WSAGetLastError());
    
25.            break;
      M/ G* I: g, H1 X+ X. q
26.        }
    , k% B. N0 m! x7 C1 _: r1 t; [* d
27.        szBuff[ret] = '\0';
    
28.        printf("RECV: '%s'\n", szBuff);
    " j+ D4 ?& y, k7 q
29.       if(strcmp(szBuff,"abc")==0){
    
30.          memcpy(szBuff,"Send the correct string!",25);
    
31.        }
    % _: L/ y! v8 R" z& O0 T
32.        else{
    
33.          memcpy(szBuff,"Send the wrong string!",23);
    8 |! z2 e8 B+ k9 l- [' r
34.        }
    
35.        ret = send(sock, szBuff, strlen(szBuff), 0);
    9 f8 T; w& B2 ]- d7 F' O) o
36.        if (ret == SOCKET_ERROR){
    . J8 n5 E+ w  F2 m# c3 H7 l8 V
37.          printf("send() failed: %d\n", WSAGetLastError());
    ( \# e4 O) ~  }& n
38.        }
    
39.     }
    
40.     return 0;
    
41. }
    
42. 
    
43. int main()
    # t1 M# W8 b# Q7 M: N' [8 Q
44. {
    
45.    WSADATA      wsd;
    0 C# W4 b9 w6 s
46.    SOCKET       sListen,
    3 g# ?8 u) F  ?- X8 F; ~$ T
47.                  sClient;
    
48.    int          iAddrSize;
    9 M- t& B8 V: y7 t% t+ [
49.    HANDLE       hThread;
    ( R5 j# K9 d. R
50.    DWORD        dwThreadId;
    
51.     struct sockaddr_in local,
    
52.                       client;
    
53. 
    : o+ `& I3 d/ y% U* F; R
54.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    
55.     {
    ! S& P3 S+ V: ]* A) v
56.        printf("Failed to load Winsock!\n");
    , c; F2 }% v+ p$ n3 h. X$ R
57.        return 1;
    
58.     }
    
59.     // Create our listening socket
    
60.     sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
    
61.     if (sListen == SOCKET_ERROR)
    8 d( m9 v( v5 F1 n2 b& [0 f1 a
62.     {
    : Q. `# q6 K) \9 C& W
63.        printf("socket() failed: %d\n", WSAGetLastError());
    
64.        return 1;
    8 I$ q( k: }! [2 l6 k. M" c
65.     }
    0 _: P+ Z; m: t: X
66.    local.sin_addr.s_addr = htonl(INADDR_ANY);
    
67.    local.sin_family = AF_INET;
    
68.    local.sin_port = htons(iPort);
    
69. 
    , ?, }! c8 q1 e- @, g' M$ o
70.     if (bind(sListen, (struct sockaddr *)&local,
    
71.            sizeof(local)) == SOCKET_ERROR)
    
72.     {
    5 t6 p7 E# O0 {( m
73.        printf("bind() failed: %d\n", WSAGetLastError());
    3 p( l( H7 ~5 B- ~0 r) p2 I0 S
74.        return 1;
    / e# Y- f6 s# R  x7 ^
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.
    
79.     while (1)
      N& a' k- Y1 }5 t2 i, G  U, N
80.     {
    
81.        iAddrSize = sizeof(client);
    
82.        sClient = accept(sListen, (struct sockaddr *)&client,
    
83.                        &iAddrSize);      
    
84.        if (sClient == INVALID_SOCKET)
    # ?' ~/ M7 P+ q$ Y9 v" V
85.        {      
    3 a$ P+ a7 E+ h6 Z# Z
86.            printf("accept() failed: %d\n", WSAGetLastError());
    
87.            break;
      G/ _! C! U5 m$ Z) S, M, F
88.        }
      E$ S6 q  ~! R* T1 c$ |1 E, ]
89.        printf("Accepted client: %s:%d\n",
    
90.            inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    
91. 
    7 ]: ^5 p1 ^# d1 L. r: `
92.        hThread = CreateThread(NULL, 0, ClientThread,
    
93.                    (LPVOID)sClient, 0, &dwThreadId);
    5 F$ ~" \4 a- Y6 U# N8 F. K
94.        if (hThread == NULL)
    5 G  @4 h2 d! y7 L* g5 D4 C
95.        {
    5 v; L: G  X6 T# z- Z5 A$ |, K
96.            printf("CreateThread() failed: %d\n", GetLastError());
    , r% B, v+ Y4 y2 W
97.            break;
    0 B/ R) X8 N8 ]# o
98.        }
    . I% B) a$ N, C5 n" r
99.        CloseHandle(hThread);
    
100.     }
     # X- [) G$ ^+ c3 Z
101.    closesocket(sListen);
     
102.    
     0 l6 _1 V4 p% d4 S  Z+ {9 y
103.    WSACleanup();
     . g% r' J- x$ z& P  b3 o
104.     return 0;
     1 A  j9 ?4 z: \0 d/ ]5 \, T
105. }

复制代码

) _+ r- K; L% w

admin

1. 作为服务器，你要绑定【bind】到本地的IP地址上进行监听【listen】，但是你的机器上可能有多块网卡，也就有多个IP地址，这时候你要选择绑定在哪个IP上面，如果指定为INADDR_ANY，那么系统将绑定默认的网卡【即IP地址】。
   2 ~+ p' E  V, l$ K5 ]0 B1 f4 D
2. 
     t+ g5 b( f! [. B8 t
3. 作为客户端，你要连接【connect】到远端的服务器，也是要指定远端服务器的（ip, port）对。
   ) L* ^# Y2 U4 q2 T
4. 当然，在这种情况下，不可能将IP地址指定为INADDR_ANY，系统会疯掉的。
   
5. 
   
6. Server：
   
7. #include <winsock2.h>
   
8. #pragma comment(lib, "WS2_32.lib")
   9 a6 x/ p$ S: A9 O; X" U  L- l% I
9. 
   , e& z" O9 ]2 T( N  Y) Y' k) b* b
10. #include <stdio.h>
    
11. void main()
    # U' ?6 Z- `$ [6 ]0 ^0 J7 G# {# c
12. {
    ( b+ G" [, B$ v2 @
13.     WORD wVersionRequested;//版本号
    8 }4 E! G$ ?1 d2 g( w
14.     WSADATA wsaData;
    
15.     int err;
    / i5 r/ @: @8 z% |9 e  B" m4 {! w
16. 
    + m1 Q0 o) \: ~- f' h# b
17.     wVersionRequested = MAKEWORD(2, 2);//2.2版本的套接字
    
18.     //加载套接字库,如果失败返回
    
19.     err = WSAStartup(wVersionRequested, &wsaData);
    
20.     if (err != 0)
    
21.     {
    ) Y# U9 i- A9 S; r+ m
22.         return;
    3 b+ g( @5 O9 b
23.     }
    
24. 
    : m% j3 t" j+ ^; w! ?
25.     //判断高低字节是不是2,如果不是2.2的版本则退出
    
26.     if (LOBYTE(wsaData.wVersion) != 2 ||
    ' G0 G8 z7 b5 C9 n
27.          
    % o* j" V$ ^( E8 Y# L/ h. N# s
28.         HIBYTE(wsaData.wVersion) != 2)
    2 H# B1 {7 X3 z1 E* U
29.          
    
30.     {
    
31.         return;
    ' L3 P, w+ M2 r$ g* b: R, C0 n* Z+ @
32.     }
    ' t# D5 \. f: [6 L% W) q' S- h+ q
33.      
    . t/ W! v1 s4 l! j- m1 j* T
34.          //创建流式套接字,基于TCP(SOCK_STREAM)
    7 P& r& v8 d: ?" g( L1 h  w9 b
35. 
    3 h4 r! E! T4 `* c
36.          SOCKET socSrv = socket(AF_INET, SOCK_STREAM, 0);
    
37. 
      Z+ z. p/ g- `5 t. p" p- n
38.          //Socket地址结构体的创建
    . {5 h$ n5 ~. V
39. 
    
40.          SOCKADDR_IN addrSrv;
    ! x5 S2 u; A) X4 F5 N
41. 
    5 J9 l9 `+ V+ c% g; Q# R
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);
    & I& }2 Z! k* j- J
45.         //指定端口号,除sin_family参数外,其它参数都是网络字节序,因此需要转换
    
46. 
    
47.          //将套接字绑定到一个端口号和本地地址上
    * s& E# y: i9 i$ d) ?0 F4 w$ E
48.          bind(socSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));//必须用sizeof，strlen不行
    * T& C* v. S, l9 E
49. 
    4 \; }4 x$ K/ I! S
50.          listen(socSrv, 5);
    3 D% ~/ w' p! g) J1 [
51.          
    , q( Z& V: Z6 E) \: [" J
52.          SOCKADDR_IN addrClient;//字义用来接收客户端Socket的结构体
    
53. 
    ) X' k' C1 {- Y. m. Q* o
54.          int len = sizeof(SOCKADDR);//初始化参数,这个参数必须进行初始化，sizeof
    % ~' }" }. M3 X- r0 q7 r. k
55. 
    / ?& I' W0 k. S) K
56.          //循环等待接受客户端发送请求
    # R1 ]8 o8 O6 h- a: b- \3 P
57. 
    4 U+ [! N" y& x" ?
58.          while (1)
    ! c) Y1 z" l. w8 D4 I
59.          {
    & h0 }. d5 y5 D
60.                    //等待客户请求到来；当请求到来后，接受连接请求，
    
61. 
    
62.                    //返回一个新的对应于此次连接的套接字（accept）。
    ( G' {0 R/ ~9 r
63.                    //此时程序在此发生阻塞
    
64. 
    6 _7 {+ C" x0 R& U% `7 \+ V
65.                    SOCKET sockConn = accept(socSrv, (SOCKADDR*)&addrClient, &len);
    
66. 
    
67.                    char sendBuf[100];
    
68. 
    
69.                    sprintf(sendBuf, "Welcome %s to JoyChou",
    
70. 
    / G' M' E$ o& E
71.                             inet_ntoa(addrClient.sin_addr));//格式化输出
    
72. 
    
73.                    //用返回的套接字和客户端进行通信
    ) V7 T8 x8 {# b7 Z% C
74. 
    9 T) I5 o) K0 `
75.                    send(sockConn, sendBuf, strlen(sendBuf)+1, 0);//多发送一个字节
    # s% b, v; n* h' F2 V$ m# h$ |
76. 
    7 q: b6 k9 n/ f, H" D* M: a- [
77.                    //接收数据
    1 B0 W: k0 U3 V
78. 
    
79.                    char recvBuf[100];
    % e" t3 L$ L- e; m* Z' k: g
80. 
    
81.                    recv(sockConn, recvBuf, 100, 0);
    % L4 ^8 V% S4 J8 t* Q
82. 
    
83.                    printf("%s\n", recvBuf);
    8 g3 Z9 d0 u5 p. z" G: s: ^
84.                    closesocket(sockConn);
    
85. 
    2 i5 ]; b5 f; j
86.          }
    3 Q8 ?; h( \# u/ D6 |! c
87. }
    1 X4 S% Q0 a5 K5 f. t  N
88. 
    
89. 
    ' K! R, z) r; x7 f$ A0 e
90. Client：
    
91. 
    
92. #include <winsock2.H>
    9 ]0 W9 e) p# A& L; U3 v3 z
93. #pragma comment(lib, "Ws2_32.lib")
    
94. #include <stdio.h>
    
95. #include <string.h>
    
96. 
    
97. void main()
    
98. {   
    1 Y& W1 N5 B( e$ T' X; u
99.     WORD wVersionRequested;
    ; g5 P+ P' Q. G( k4 C
100.     WSADATA wsaData;
     
101.     int err;
     
102.      
     + I; ]4 s, `; ^# T3 Z8 ~6 e" P
103.     wVersionRequested = MAKEWORD( 2, 2 );
     % ]$ `7 s9 B+ E5 k7 S
104.      
     " [1 P* h2 G5 C. y, [
105.     err = WSAStartup( wVersionRequested, &wsaData );
     ( b( s4 f* V6 P- r$ Q" B, H
106.     if ( err != 0 ) {
     / Y4 z9 ?3 h1 B/ E7 H
107.          
     6 i2 N! _, `7 x5 W0 s( Q
108.         return;
     9 k7 k/ G# \4 N% F7 h+ |
109.     }
     
110.      
     
111.      
     
112.     if ( LOBYTE( wsaData.wVersion ) != 2 ||
     
113.         HIBYTE( wsaData.wVersion ) != 2 )
     , A  h. m  ^) s1 m  r
114.     {
     4 \& M2 F) Q7 v9 x  n& F
115.          
     
116.         WSACleanup( );
     
117.         return;
     & R7 I+ _" p3 j% C/ v
118.     }
     
119.     SOCKET socketClient = socket(AF_INET, SOCK_STREAM, 0);
     
120.     SOCKADDR_IN addrSrv;
     
121.     addrSrv.sin_family = AF_INET;
     9 `9 _: V1 {+ K2 b  X$ w; B) h
122.     addrSrv.sin_port = htons(6000);
     . g* h. q3 Q& M4 _# g+ m4 x
123.     addrSrv.sin_addr.S_un.S_addr = inet_addr("192.168.1.101");//服务器端的IP地址
     / _7 Z0 c7 b6 Z3 _! x$ U
124.      
     + P+ @* \' K! u. _% v6 f- h7 B% i
125.     connect(socketClient, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
     
126.     char recvBuf[256];
     6 D; |  i. S* P, v* K7 J# p
127.     char sendBuf[] = "This is Joychou";
     ) F+ S4 Z; }6 `& t
128.     recv(socketClient, recvBuf, 256, 0);
     6 u/ e' G4 J3 a0 R; W  i
129.     printf("%s\n", recvBuf);
     + \. C' z$ l- T: a' C
130.     send(socketClient, sendBuf, strlen(sendBuf) + 1, 0);
     # I1 M4 b: r( W$ x3 C) }; ?! r! R- y/ R
131.     closesocket(socketClient);
     " m% \1 [$ M4 v" ]4 K$ D  v" p3 O
132.     WSACleanup();
     
133.      
     
134. }

复制代码

7 S7 X7 H8 y+ T. a6 I& z
. ?2 U  T; \4 L% d0 l