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

admin

程序很简单，windows环境下的，客户端和服务器程序都在本机运行，在客户端输入发送给服务器的字符串，服务器收到字符串后会打印出来，同时与"abc"比较，与"abc"相同就会返给客户端，输入的是正确的，不同会告诉客户端输入时错误的。
% V( W- T! A( N! |客户端程序：client.cpp
$ Q% Q; x. w0 ^( k& \% ~/ O9 V, S" ^

1. #include <winsock2.h>
   , Y; [6 {6 @5 {! c! F" \
2. #include <stdio.h>
   ' _# C; }9 F* O1 p6 [
3. #include <stdlib.h>
   
4. 
   
5. #define DEFAULT_PORT       5150
   
6. #define DEFAULT_BUFFER     2048
     E- C: {! Z$ H6 ]: V. r
7. 
   3 t7 A9 K! j. m$ ~
8. char  szServer[128],
   9 z" }. i$ e2 |" C8 {4 A
9.      szMessage[1024];
   4 d* E( X/ E1 z; V
10. int  iPort    = DEFAULT_PORT;
    
11. 
    , P! U; U6 z+ h$ ?
12. int main()
    
13. {
    5 ]$ e) Z7 }9 H9 P+ N$ x
14.    WSADATA      wsd;
    & Z8 n2 k' p2 X8 i
15.    SOCKET       sClient;
    
16.    char         szBuffer[DEFAULT_BUFFER];
    
17.    int          ret;
    
18.     struct sockaddr_in server;
    6 U$ x# q( f& y, s
19.     struct hostent    *host = NULL;
    8 `1 v! S8 n9 z' V% Q+ J! h: C
20.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    
21.     {
    % I0 I* e# p* R" U) m) M# c! Z' _
22.        printf("Failed to load Winsock library!\n");
    
23.        return 1;
    
24.     }
    ' E4 i7 A  L" E1 S# Y
25.    printf("Enter a string to send to server:\n");
    
26.    gets(szMessage);
    
27.     // Create the socket, and attempt to connect to the server
      Q( a% d  J+ X
28.     sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    ' V6 |/ }: N8 M, V. |
29.     if (sClient == INVALID_SOCKET)
    
30.     {
    
31.        printf("socket() failed: %d\n", WSAGetLastError());
    7 m  c3 W( n5 A7 V
32.        return 1;
    ! y( Q: B, g0 ?
33.     }
    
34.    server.sin_family = AF_INET;
    5 [, [5 |$ I- q2 a" F7 A
35.    server.sin_port = htons(iPort);
    
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)
    
40.     {
    ; m+ ]3 C, [& Q) E/ B7 Y5 l8 G0 r4 ]
41.        printf("connect() failed: %d\n", WSAGetLastError());
    2 ~8 I) ^$ C2 v+ y  ^
42.        return 1;
    ; p, P. U0 c$ ~) {* m4 P  R. w/ j
43.     }
    3 c0 s; H0 U4 k( b" D! m, [
44.     // Send and receive data
    
45.     ret = send(sClient, szMessage, strlen(szMessage), 0);
    6 {7 K+ P1 C0 n
46.     if (ret == SOCKET_ERROR)
    
47.     {
    1 [: A2 ?. J. Z
48.        printf("send() failed: %d\n", WSAGetLastError());
    . x$ Q  L# i$ z# h% [
49.     }
    8 T1 A- y9 i) M" k
50.     else{
    
51.        printf("Send '%s' \n", szMessage);
      n8 z% g  k1 }, R
52.        ret = recv(sClient, szBuffer, DEFAULT_BUFFER, 0);
    
53.        if (ret == SOCKET_ERROR){
    
54.          printf("recv() failed: %d\n", WSAGetLastError());
    
55.        }
    
56.        else{
    ; W7 T: W) X3 o8 H1 O' g$ R9 X
57.          szBuffer[ret] = '\0';
    5 a% \4 V9 P0 D/ q: m% ^
58.          printf("RECV: '%s'\n",szBuffer);
    6 t; f. `5 f; s, S* D! A
59.        }
    
60.     }
    ! o+ `: b$ _6 E5 {
61.    closesocket(sClient);
    
62. 
    & h5 e, U0 _6 Q: s. y" {* Y
63.    WSACleanup();
    
64.     return 0;
    
65. }

复制代码

服务器程序:server.cpp

1. #include <winsock2.h>
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   9 C% ^2 [# w- g
4. 
   
5. #define DEFAULT_PORT       5150
   
6. #define DEFAULT_BUFFER     4096
   ! u  B) _: V6 U  m
7. 
   ! S0 b. O+ Y3 n  l6 z
8. int   iPort     = DEFAULT_PORT;
   # @3 ~+ e) \# E6 i6 h
9. char   szAddress[128];
     f8 C: w  }/ K
10. 
    7 V* N5 g0 K8 F( A' a5 y
11. DWORD WINAPI ClientThread(LPVOID lpParam)
    - K( Y- d* `/ b7 M) y2 T
12. {
    
13.    SOCKET       sock=(SOCKET)lpParam;
    
14.    char         szBuff[DEFAULT_BUFFER];
    $ `7 v- _! z( b; }% @
15.    int          ret;
    8 M% W4 O) ?, f
16. 
    
17.    while(1)
    
18.     {
    + ?( J; e+ F( k. j
19.        ret = recv(sock, szBuff, DEFAULT_BUFFER, 0);
    9 o4 q5 u/ h3 {( K
20.        if (ret == 0)
    3 D0 X9 h5 J7 N  p9 |
21.            break;
    
22.        else if (ret == SOCKET_ERROR)
    2 h2 k* ]- g, p) I+ Q, [4 {' P
23.        {
    
24.            printf("recv() failed: %d\n", WSAGetLastError());
    
25.            break;
    ) R# l6 h2 ]5 _0 |* \2 O
26.        }
    
27.        szBuff[ret] = '\0';
    
28.        printf("RECV: '%s'\n", szBuff);
    
29.       if(strcmp(szBuff,"abc")==0){
    
30.          memcpy(szBuff,"Send the correct string!",25);
    
31.        }
    
32.        else{
    
33.          memcpy(szBuff,"Send the wrong string!",23);
    1 {+ d' t  X+ k/ U9 u, t' E
34.        }
    & }% K9 G0 b1 Q1 T; D. z$ ?9 y
35.        ret = send(sock, szBuff, strlen(szBuff), 0);
    
36.        if (ret == SOCKET_ERROR){
    % ]% d( h# F# H% _
37.          printf("send() failed: %d\n", WSAGetLastError());
    3 m/ \1 G& V% n! R4 u& A
38.        }
    8 k: `: K! |6 U) q
39.     }
    ! U3 z% K1 P. m( S
40.     return 0;
    
41. }
    9 d& S9 w; G! Y" i* F: T6 E& z4 i
42. 
    ' W" E$ h; a* S7 y
43. int main()
    
44. {
    ! f5 O  D5 U& Y& E$ I% ^5 [# m
45.    WSADATA      wsd;
    : h0 J# x2 O# o/ q
46.    SOCKET       sListen,
    
47.                  sClient;
    
48.    int          iAddrSize;
    6 K* p; `( [( |$ F. k, |
49.    HANDLE       hThread;
    
50.    DWORD        dwThreadId;
    # U" `/ `6 o! Z: h5 |' w
51.     struct sockaddr_in local,
    
52.                       client;
    
53. 
    ) I1 S! P9 g$ p" q9 x
54.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    
55.     {
    
56.        printf("Failed to load Winsock!\n");
    . p( E* Y' I# ?+ N& I
57.        return 1;
    
58.     }
    
59.     // Create our listening socket
    " ]' }& f$ R' J# e/ m9 V
60.     sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
    $ [( E& Y! s$ p7 \3 B
61.     if (sListen == SOCKET_ERROR)
    
62.     {
    5 V. {) t) U! L( h3 n7 u' U6 s6 J
63.        printf("socket() failed: %d\n", WSAGetLastError());
    
64.        return 1;
    
65.     }
    5 b; o$ t5 [, O
66.    local.sin_addr.s_addr = htonl(INADDR_ANY);
    
67.    local.sin_family = AF_INET;
    / w) |9 r- V" X* e  S0 K5 D
68.    local.sin_port = htons(iPort);
    6 V) Z! m$ l/ `. p: \# W7 r. \: T) t! W
69. 
    9 X) l" W. h- _# |: j2 m
70.     if (bind(sListen, (struct sockaddr *)&local,
    
71.            sizeof(local)) == SOCKET_ERROR)
    
72.     {
    3 K4 ]) p  k1 f: I' J) @
73.        printf("bind() failed: %d\n", WSAGetLastError());
    
74.        return 1;
    6 ^" `4 O( `& q
75.     }
    6 ]. g9 [3 ?# R- h0 w
76.    listen(sListen, 8);
    4 T- T0 b  W4 y& c8 z) Q6 e
77.     // In a continous loop, wait for incoming clients. Once one
    
78.     // is detected, create a thread and pass the handle off to it.
    ) \' }$ _- c& p5 G8 I, t
79.     while (1)
    4 f& G+ ]2 `8 s. I/ Z! U
80.     {
    . K1 V9 c6 ^* M, e3 e
81.        iAddrSize = sizeof(client);
    9 `2 G$ `9 N) ?9 K+ P
82.        sClient = accept(sListen, (struct sockaddr *)&client,
    
83.                        &iAddrSize);      
    
84.        if (sClient == INVALID_SOCKET)
    % g3 ^( m$ o5 B- o; t0 a7 S6 M
85.        {      
    
86.            printf("accept() failed: %d\n", WSAGetLastError());
    - V5 `. _8 r5 `9 Q
87.            break;
    $ i; ~/ G) }/ ^
88.        }
    + E( ~, M8 ^; |* l( n( I  t
89.        printf("Accepted client: %s:%d\n",
    + Y* p2 Z% f+ ]8 L' b; P3 z2 s7 n
90.            inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    
91. 
    
92.        hThread = CreateThread(NULL, 0, ClientThread,
    * r+ W" |- i& ~. d
93.                    (LPVOID)sClient, 0, &dwThreadId);
    ) |4 ?0 A, g5 I
94.        if (hThread == NULL)
    
95.        {
    
96.            printf("CreateThread() failed: %d\n", GetLastError());
    2 S# q/ l4 f" L- T/ T3 u
97.            break;
    8 {, W4 V6 ]3 [5 S8 T0 h2 |
98.        }
    
99.        CloseHandle(hThread);
    
100.     }
     / ~# r( B. \" b4 ^
101.    closesocket(sListen);
     " ~0 P3 k) p! G
102.    
     + ?% i( l8 A! w/ x  N3 g2 n6 ~
103.    WSACleanup();
     8 [& ^+ m, x2 |; c' j
104.     return 0;
     # g- c  g7 B5 `$ R9 D; G% _& s2 W
105. }

复制代码

! ~: e6 Y4 d. m& U6 A

admin

1. 作为服务器，你要绑定【bind】到本地的IP地址上进行监听【listen】，但是你的机器上可能有多块网卡，也就有多个IP地址，这时候你要选择绑定在哪个IP上面，如果指定为INADDR_ANY，那么系统将绑定默认的网卡【即IP地址】。
   
2. 
   , W, }9 j% h, y8 u2 e4 D, j4 Y( C
3. 作为客户端，你要连接【connect】到远端的服务器，也是要指定远端服务器的（ip, port）对。
   
4. 当然，在这种情况下，不可能将IP地址指定为INADDR_ANY，系统会疯掉的。
   & J2 z0 V& L2 i1 c* |
5. 
   0 d. S" {. }, D5 e! ?: d
6. Server：
   . E5 n: A9 u! c2 X" R* G0 i
7. #include <winsock2.h>
   
8. #pragma comment(lib, "WS2_32.lib")
   % K" \  b( H8 m( ?9 F" D% O9 _( u
9. 
   
10. #include <stdio.h>
    + `! I0 `. `1 A7 w6 v9 g
11. void main()
    
12. {
    
13.     WORD wVersionRequested;//版本号
    
14.     WSADATA wsaData;
    
15.     int err;
    * l9 l) c0 l1 J$ I1 J
16. 
    0 L+ D3 _5 ]* z* e* e
17.     wVersionRequested = MAKEWORD(2, 2);//2.2版本的套接字
    
18.     //加载套接字库,如果失败返回
    $ X0 }4 P  @0 K+ P) G1 X' h
19.     err = WSAStartup(wVersionRequested, &wsaData);
    
20.     if (err != 0)
    1 ^5 h) h5 {  ~) @: b; |% {' _% x
21.     {
    
22.         return;
    
23.     }
    ) i. u. |* T, Q, c. o
24. 
    ! f6 Z% F6 E: R- y7 r
25.     //判断高低字节是不是2,如果不是2.2的版本则退出
    0 Z2 _; `+ e2 f  `) O6 s
26.     if (LOBYTE(wsaData.wVersion) != 2 ||
    ) }$ m8 D2 P# ]/ n4 M
27.          
    8 Q& e9 Z. \! j( I- [
28.         HIBYTE(wsaData.wVersion) != 2)
    ) h6 n# S. A$ s5 n, B
29.          
    
30.     {
    
31.         return;
    
32.     }
    
33.      
    
34.          //创建流式套接字,基于TCP(SOCK_STREAM)
    
35. 
    
36.          SOCKET socSrv = socket(AF_INET, SOCK_STREAM, 0);
    3 T7 A5 ^) s9 J2 d) j8 }. N
37. 
    $ b, H: c, m3 ^8 [$ m6 U) d$ W3 p
38.          //Socket地址结构体的创建
    
39. 
    + @- y* Z7 [& C
40.          SOCKADDR_IN addrSrv;
    
41. 
    . d( }: ]: h, m( 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);
    
45.         //指定端口号,除sin_family参数外,其它参数都是网络字节序,因此需要转换
    " w6 b7 G) }( @
46. 
    . p! V0 W- l, J  h
47.          //将套接字绑定到一个端口号和本地地址上
    6 z3 p: \! y9 Y3 `$ ^+ @
48.          bind(socSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));//必须用sizeof，strlen不行
    4 Y# l% @8 I" u  [/ w+ L+ ^
49. 
    
50.          listen(socSrv, 5);
    
51.          
    4 [0 x5 N8 w8 N. G
52.          SOCKADDR_IN addrClient;//字义用来接收客户端Socket的结构体
    + L  ^" J7 y7 r/ ~$ z
53. 
    
54.          int len = sizeof(SOCKADDR);//初始化参数,这个参数必须进行初始化，sizeof
    5 ?  F/ n- L& x+ _1 P! K5 h: ~
55. 
    $ @# P) b  \+ k: S/ z
56.          //循环等待接受客户端发送请求
    
57. 
    
58.          while (1)
    2 T- x8 l4 Y, ^- J' N. F/ R2 K
59.          {
    
60.                    //等待客户请求到来；当请求到来后，接受连接请求，
    
61. 
    
62.                    //返回一个新的对应于此次连接的套接字（accept）。
    , ?8 M, a9 R. O# d4 @  h% b
63.                    //此时程序在此发生阻塞
    
64. 
    ) G) N/ U, n8 y, x
65.                    SOCKET sockConn = accept(socSrv, (SOCKADDR*)&addrClient, &len);
    
66. 
    2 E" S& l& \" Y! B
67.                    char sendBuf[100];
    $ F" l9 p$ T% U$ S: B) m: M
68. 
    
69.                    sprintf(sendBuf, "Welcome %s to JoyChou",
    0 S, C+ Z+ P7 f$ `" Z! N2 v' m0 r3 g
70. 
    $ R9 _4 e- A  u7 |- `
71.                             inet_ntoa(addrClient.sin_addr));//格式化输出
    
72. 
      G; v: R4 M. m$ N) z/ R; y
73.                    //用返回的套接字和客户端进行通信
    5 T& w$ u/ T2 ^: M) K$ U
74. 
    
75.                    send(sockConn, sendBuf, strlen(sendBuf)+1, 0);//多发送一个字节
    
76. 
    
77.                    //接收数据
    8 v: ?* d& Q- x4 H( M3 F
78. 
    ( C# n# L7 H8 \2 P1 k
79.                    char recvBuf[100];
    
80. 
    2 F) d# w- A5 t( z
81.                    recv(sockConn, recvBuf, 100, 0);
    
82. 
    4 X% Z7 x( V" U3 E
83.                    printf("%s\n", recvBuf);
      E) p# \; G- \
84.                    closesocket(sockConn);
    
85. 
    8 D" a+ w5 Z, b5 V! y. [( |
86.          }
    
87. }
    
88. 
    
89. 
    . M% \" _! B& v7 R2 Z
90. Client：
    
91. 
    
92. #include <winsock2.H>
    / h! ?- c0 a$ ]" S, L0 B5 O8 i
93. #pragma comment(lib, "Ws2_32.lib")
    
94. #include <stdio.h>
    3 b2 R, |+ s8 P5 R5 ^1 {
95. #include <string.h>
    " n& w7 W0 t: v/ }9 ?
96. 
    9 x* `, V1 f* H- Z1 I
97. void main()
    
98. {   
    $ q* b, m+ J% d' O1 Z; J
99.     WORD wVersionRequested;
    
100.     WSADATA wsaData;
     
101.     int err;
     " b+ ^0 \4 e& p. h0 U2 c( ^0 x
102.      
     - ^% [: s; Y" G( V9 Y2 b
103.     wVersionRequested = MAKEWORD( 2, 2 );
     6 W  X5 M4 a; e+ R1 s
104.      
     
105.     err = WSAStartup( wVersionRequested, &wsaData );
     
106.     if ( err != 0 ) {
     # L% z3 u! C, e* T. @
107.          
     
108.         return;
     3 p6 X& p- U! r
109.     }
     
110.      
     
111.      
     / g) ?2 {3 e! k0 v% |6 B
112.     if ( LOBYTE( wsaData.wVersion ) != 2 ||
     8 b! K5 W' J' ~* d3 E* g
113.         HIBYTE( wsaData.wVersion ) != 2 )
     5 ^  P3 {# p0 I
114.     {
     
115.          
     
116.         WSACleanup( );
     8 D7 f/ b% I& B7 ?* i+ I
117.         return;
     
118.     }
     ( i5 o( \: s, p. O/ k' J* O
119.     SOCKET socketClient = socket(AF_INET, SOCK_STREAM, 0);
     
120.     SOCKADDR_IN addrSrv;
     - x" l) ]0 r# [# p* W
121.     addrSrv.sin_family = AF_INET;
     2 d3 Z8 [5 J% R) R* J5 F) G
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));
     5 @! m% l6 @- H$ |
126.     char recvBuf[256];
     
127.     char sendBuf[] = "This is Joychou";
     ) e$ E* R7 g' N9 n4 M4 _4 j  Q  d
128.     recv(socketClient, recvBuf, 256, 0);
       q" x. a# y' d1 z) N4 |. _& Q+ Z% S7 ^
129.     printf("%s\n", recvBuf);
     
130.     send(socketClient, sendBuf, strlen(sendBuf) + 1, 0);
     0 t7 E+ ~* c. Q" T1 _. `. S
131.     closesocket(socketClient);
     2 i5 g( z% }5 T) y" d
132.     WSACleanup();
     ! G& G: Y  p+ W; a' y" p4 L
133.      
     6 {7 z9 q( s5 R4 Y
134. }

复制代码

5 q: P8 R( H+ n8 w