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

admin

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

1. #include <winsock2.h>
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   " n* Y2 p* o3 Z4 }
4. 
   2 [8 O4 ?6 a3 K+ G# T5 E9 n
5. #define DEFAULT_PORT       5150
     e+ w. O9 {# y' t, s5 x; a0 U9 t: h
6. #define DEFAULT_BUFFER     2048
   ! z+ n+ p) u5 ~; X% c8 z
7. 
   : v/ M8 I1 L( X5 W. o
8. char  szServer[128],
   
9.      szMessage[1024];
   8 h1 w% ~( L6 K5 t* Y& ?4 B
10. int  iPort    = DEFAULT_PORT;
      e" E2 m" R# T6 ?+ F& p- L( Q( q
11. 
    
12. int main()
    
13. {
    & g  C' ]; l, |& \2 I1 o
14.    WSADATA      wsd;
    
15.    SOCKET       sClient;
    
16.    char         szBuffer[DEFAULT_BUFFER];
    
17.    int          ret;
    2 ^, Q, Z3 B' D0 }1 d
18.     struct sockaddr_in server;
    ) w' l4 U6 k/ C# f7 S2 ]
19.     struct hostent    *host = NULL;
    
20.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    
21.     {
    % S& u. \% _0 u3 B
22.        printf("Failed to load Winsock library!\n");
    
23.        return 1;
    4 q1 b' x8 i& E. s
24.     }
    
25.    printf("Enter a string to send to server:\n");
    ' M! Q& K: Q0 k
26.    gets(szMessage);
    
27.     // Create the socket, and attempt to connect to the server
    
28.     sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
      ?3 |; K) A% d3 s; k
29.     if (sClient == INVALID_SOCKET)
    ! D9 P' U1 T7 F
30.     {
    6 u6 [* ^; z' l  H! r; F8 l! K
31.        printf("socket() failed: %d\n", WSAGetLastError());
    
32.        return 1;
    
33.     }
    
34.    server.sin_family = AF_INET;
    4 Z6 Z+ z8 @0 B0 u0 @; `
35.    server.sin_port = htons(iPort);
    $ }/ K! E$ c) z' g* `
36.    server.sin_addr.s_addr = inet_addr("127.0.0.1");
    , @4 `& g- w8 b; u3 w) D% v, v& |
37. 
    9 @! u6 t- o0 {( n# Z4 W% t
38.     if (connect(sClient, (struct sockaddr *)&server,
    
39.        sizeof(server)) == SOCKET_ERROR)
    
40.     {
    
41.        printf("connect() failed: %d\n", WSAGetLastError());
    
42.        return 1;
    
43.     }
      n# q& z  C- L# p" J; g
44.     // Send and receive data
    % [* d6 X" }& ^
45.     ret = send(sClient, szMessage, strlen(szMessage), 0);
    
46.     if (ret == SOCKET_ERROR)
    
47.     {
    
48.        printf("send() failed: %d\n", WSAGetLastError());
    
49.     }
    
50.     else{
    
51.        printf("Send '%s' \n", szMessage);
    8 f' l! C4 v: x' o  q! d4 v
52.        ret = recv(sClient, szBuffer, DEFAULT_BUFFER, 0);
    
53.        if (ret == SOCKET_ERROR){
    2 Z1 V/ y5 C1 u0 k+ k$ z
54.          printf("recv() failed: %d\n", WSAGetLastError());
    
55.        }
    % f: M* X# c! d& j
56.        else{
    : [4 R. N0 L( C0 b" g
57.          szBuffer[ret] = '\0';
    
58.          printf("RECV: '%s'\n",szBuffer);
    
59.        }
    
60.     }
    / t& T& t) U( P: Y% ^+ M
61.    closesocket(sClient);
    
62. 
    ) R/ H. [2 A" B' V, c- W; i
63.    WSACleanup();
    2 a. R! K6 Q/ Q3 x# Z0 l/ T) ~
64.     return 0;
    
65. }

复制代码

服务器程序:server.cpp
; d0 w: ?  Q; G3 {& {( ~

1. #include <winsock2.h>
   & G) G8 ^% w+ h7 R
2. #include <stdio.h>
   3 o- t3 U# v4 ^" |6 o
3. #include <stdlib.h>
   : F6 ]0 F$ i! A: K  M. F
4. 
   % P) v/ K1 c* i$ q. C5 e! J- J
5. #define DEFAULT_PORT       5150
   
6. #define DEFAULT_BUFFER     4096
   & I- r2 t5 x' O/ }3 @
7. 
   
8. int   iPort     = DEFAULT_PORT;
   . M1 T; H+ C% ~
9. char   szAddress[128];
   ) U$ e- A. y" d
10. 
    5 s2 W" s8 m( y& c1 R
11. DWORD WINAPI ClientThread(LPVOID lpParam)
    % d0 W2 X+ O( I7 a9 k$ K0 Z
12. {
    : q. M# o2 W- G" \, n) y( S- `
13.    SOCKET       sock=(SOCKET)lpParam;
    
14.    char         szBuff[DEFAULT_BUFFER];
    + g' @1 C) h& ^0 I6 N* ]0 \
15.    int          ret;
    
16. 
    
17.    while(1)
    
18.     {
    
19.        ret = recv(sock, szBuff, DEFAULT_BUFFER, 0);
    
20.        if (ret == 0)
    
21.            break;
    , a. _+ m* B+ h: f6 N
22.        else if (ret == SOCKET_ERROR)
    
23.        {
    / [- r' i! D% ^2 L2 A
24.            printf("recv() failed: %d\n", WSAGetLastError());
    
25.            break;
    
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);
    0 w7 L: X6 d: q1 v* X
31.        }
    $ l$ p! d/ \8 f! n
32.        else{
    $ K; d% q/ g3 m- i; U0 t
33.          memcpy(szBuff,"Send the wrong string!",23);
    8 |: `+ H. C! ?" p* S% r
34.        }
    1 e( d% L# _' s) {; `2 W
35.        ret = send(sock, szBuff, strlen(szBuff), 0);
    # H5 e! l6 i4 n8 r9 i
36.        if (ret == SOCKET_ERROR){
    
37.          printf("send() failed: %d\n", WSAGetLastError());
    
38.        }
    
39.     }
    4 X- c: W8 I1 u7 J
40.     return 0;
    
41. }
    + Q. U" O+ x0 p$ ?7 _( h
42. 
    8 r  x6 z1 g3 m3 T
43. int main()
    
44. {
    4 Z8 u1 B, k- K  v" o1 v
45.    WSADATA      wsd;
    4 r. h/ c/ ~! F& {* B
46.    SOCKET       sListen,
    
47.                  sClient;
    . s! j& {6 P% p- E5 S# ^/ e
48.    int          iAddrSize;
    
49.    HANDLE       hThread;
    
50.    DWORD        dwThreadId;
    9 T( g' Y3 ]1 X& ~' C
51.     struct sockaddr_in local,
    % O' {) {# a1 l% y
52.                       client;
    $ D7 b2 x3 X, ^# y
53. 
    6 \' d. L* N9 Q2 w: z
54.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    
55.     {
    % M, y. Z8 `9 V" D
56.        printf("Failed to load Winsock!\n");
    
57.        return 1;
    & J$ q9 R" V0 @& \1 C* b
58.     }
    
59.     // Create our listening socket
    * ]" P$ u+ @! R( K8 c! E$ t% d, |
60.     sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
    
61.     if (sListen == SOCKET_ERROR)
    8 d# r. Q/ _6 N1 b. d) G
62.     {
    
63.        printf("socket() failed: %d\n", WSAGetLastError());
    
64.        return 1;
    7 i' h% }& ^/ M$ K$ n. M: e
65.     }
    / A3 w; T7 b, U) J) _2 r  _
66.    local.sin_addr.s_addr = htonl(INADDR_ANY);
    
67.    local.sin_family = AF_INET;
    2 Z# a0 @0 r3 l, y: ?+ W2 m
68.    local.sin_port = htons(iPort);
    0 `1 }) K9 V7 [3 @4 V0 {$ z
69. 
    ( m" S! u8 h4 H( Q
70.     if (bind(sListen, (struct sockaddr *)&local,
    . X4 R0 K: B: t, k+ |2 o/ b
71.            sizeof(local)) == SOCKET_ERROR)
    
72.     {
    
73.        printf("bind() failed: %d\n", WSAGetLastError());
    
74.        return 1;
    : U+ _, b' ?% r. B
75.     }
    
76.    listen(sListen, 8);
    * C- h# ]2 ^( P- o: F
77.     // In a continous loop, wait for incoming clients. Once one
    * q4 {, Y; r+ e; Y
78.     // is detected, create a thread and pass the handle off to it.
    
79.     while (1)
    5 z! I$ H6 m- M' \5 g, p! J
80.     {
    
81.        iAddrSize = sizeof(client);
    7 F- K1 _5 E! G0 S4 {: `: e
82.        sClient = accept(sListen, (struct sockaddr *)&client,
    , y9 M2 V( A9 j5 y
83.                        &iAddrSize);      
    * n, P1 U2 A# W, V2 j' d
84.        if (sClient == INVALID_SOCKET)
    ( [& e0 {! L  w3 ?, q9 C( s6 B1 `
85.        {      
    
86.            printf("accept() failed: %d\n", WSAGetLastError());
    6 S( X$ y0 `' `- m: m4 s
87.            break;
    
88.        }
    . a* l" I/ Q8 H2 n1 n
89.        printf("Accepted client: %s:%d\n",
    
90.            inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    
91. 
    
92.        hThread = CreateThread(NULL, 0, ClientThread,
    
93.                    (LPVOID)sClient, 0, &dwThreadId);
    " {  q* t! I& F' j% |
94.        if (hThread == NULL)
    
95.        {
    
96.            printf("CreateThread() failed: %d\n", GetLastError());
    & E8 U6 p$ a# k! ]5 @5 o
97.            break;
    
98.        }
    
99.        CloseHandle(hThread);
    1 a( O" `3 Q! _8 S% n$ k- |5 u6 n
100.     }
     . J6 @9 H3 o/ J- n  t6 @# ?; m
101.    closesocket(sListen);
     
102.    
     
103.    WSACleanup();
     + m2 h% v5 E* A9 O9 U; N! T2 c' Y
104.     return 0;
     ; A0 d" t" g. t* y: J; w
105. }

复制代码

  ?( E+ k: T- U: d

8 I% q6 O$ \+ ~1 E8 R& p3 b
* p3 d6 D( J3 t/ k; e; l

admin

1. 作为服务器，你要绑定【bind】到本地的IP地址上进行监听【listen】，但是你的机器上可能有多块网卡，也就有多个IP地址，这时候你要选择绑定在哪个IP上面，如果指定为INADDR_ANY，那么系统将绑定默认的网卡【即IP地址】。
   ' @2 c, O' P) ?. @7 I, i+ ^
2. 
   
3. 作为客户端，你要连接【connect】到远端的服务器，也是要指定远端服务器的（ip, port）对。
   
4. 当然，在这种情况下，不可能将IP地址指定为INADDR_ANY，系统会疯掉的。
   
5. 
   
6. Server：
   
7. #include <winsock2.h>
   ' p' c" b% e0 r6 ~' e. C3 k1 p+ L
8. #pragma comment(lib, "WS2_32.lib")
   
9. 
   
10. #include <stdio.h>
    
11. void main()
    " V( E; _0 K, [2 F
12. {
    
13.     WORD wVersionRequested;//版本号
    
14.     WSADATA wsaData;
    2 H+ J7 H+ q6 E* A' r" }( T
15.     int err;
    " F% c' }: }& a2 e6 ^
16. 
    
17.     wVersionRequested = MAKEWORD(2, 2);//2.2版本的套接字
    
18.     //加载套接字库,如果失败返回
    
19.     err = WSAStartup(wVersionRequested, &wsaData);
    
20.     if (err != 0)
    7 g$ o6 j2 ~' Q0 @. M
21.     {
    
22.         return;
    
23.     }
    7 N/ z2 d0 O4 ^6 Q0 T. q& D
24. 
    0 z" L) Z" B  {! F) {  B3 n
25.     //判断高低字节是不是2,如果不是2.2的版本则退出
    
26.     if (LOBYTE(wsaData.wVersion) != 2 ||
    8 ?! V) e5 j. B+ M" b- e
27.          
    
28.         HIBYTE(wsaData.wVersion) != 2)
    
29.          
    
30.     {
    2 V0 C! `- I0 m; F9 j( D$ V3 s4 y
31.         return;
    . O9 v3 E6 f# v& O; U
32.     }
    9 z- G% H% C4 e; N3 C- h# c# a% S( p
33.      
    ) W/ S% a/ a" M) y
34.          //创建流式套接字,基于TCP(SOCK_STREAM)
    
35. 
    
36.          SOCKET socSrv = socket(AF_INET, SOCK_STREAM, 0);
    1 m- p2 r, A+ E
37. 
    2 `0 K% r( F" q; a2 k2 u& }
38.          //Socket地址结构体的创建
    
39. 
    
40.          SOCKADDR_IN addrSrv;
    . l0 w$ X+ G; v5 @
41. 
    8 d" [8 s7 ~# t% H6 ~; j# U/ N
42.          addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);//转换Unsigned long型为网络字节序格
      m! h: d, I# U- P+ n3 m
43.          addrSrv.sin_family = AF_INET;//指定地址簇
      K! G* |5 p' ]- I, U) f
44.          addrSrv.sin_port = htons(6000);
    & \" G  S- K2 `# ?" V
45.         //指定端口号,除sin_family参数外,其它参数都是网络字节序,因此需要转换
    
46. 
    
47.          //将套接字绑定到一个端口号和本地地址上
    
48.          bind(socSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));//必须用sizeof，strlen不行
    
49. 
    & t# ^, l5 R: e- j* |( }
50.          listen(socSrv, 5);
    2 Y# |$ P& \0 q0 L$ a4 A+ |3 W6 F
51.          
    2 P" C- [  O- n  \* H' V( D
52.          SOCKADDR_IN addrClient;//字义用来接收客户端Socket的结构体
    
53. 
    
54.          int len = sizeof(SOCKADDR);//初始化参数,这个参数必须进行初始化，sizeof
    
55. 
    % H5 W3 z- T* B
56.          //循环等待接受客户端发送请求
    % l8 w7 ~2 K" z, U2 o+ j+ H( o
57. 
    0 V# [$ E' u$ o  G+ m! b" g: [
58.          while (1)
    ; l/ d% ^) e- [
59.          {
    
60.                    //等待客户请求到来；当请求到来后，接受连接请求，
    
61. 
    
62.                    //返回一个新的对应于此次连接的套接字（accept）。
    + N& E) {; F& S; ^, K0 R+ B7 V
63.                    //此时程序在此发生阻塞
    & ?, F  p: Q: g
64. 
    + J; X* l6 ]4 k) v
65.                    SOCKET sockConn = accept(socSrv, (SOCKADDR*)&addrClient, &len);
    
66. 
    & ]0 ^7 d# o) B
67.                    char sendBuf[100];
    * i% e" `% q2 q( k& F3 f2 F
68. 
    . Y- p/ j% U5 @) e5 V  i
69.                    sprintf(sendBuf, "Welcome %s to JoyChou",
    8 n; o4 H2 a, `* E
70. 
    
71.                             inet_ntoa(addrClient.sin_addr));//格式化输出
    
72. 
    
73.                    //用返回的套接字和客户端进行通信
    1 g* F' x" g3 E( g
74. 
    : I) N& M# F7 _
75.                    send(sockConn, sendBuf, strlen(sendBuf)+1, 0);//多发送一个字节
    
76. 
    
77.                    //接收数据
    
78. 
    ) u  }7 c; w" }( H
79.                    char recvBuf[100];
    2 X6 B3 L4 G* _# L( F
80. 
      c! e# F8 V) W2 W2 V/ J
81.                    recv(sockConn, recvBuf, 100, 0);
    3 J6 _0 H4 e/ q2 a1 m' D. h8 y+ _
82. 
    
83.                    printf("%s\n", recvBuf);
    . I5 Z$ l3 w% K# h6 @! w
84.                    closesocket(sockConn);
    
85. 
    
86.          }
    
87. }
    : g; f1 T; H# y$ f. S1 ^
88. 
    9 |; x, E! F8 U. z9 m+ n! V% W
89. 
    . Y# [6 C3 \$ r) i
90. Client：
    8 h: V8 Z/ |* B: J; G
91. 
    2 Q+ ^8 B  J6 B7 }6 o2 n
92. #include <winsock2.H>
    
93. #pragma comment(lib, "Ws2_32.lib")
    
94. #include <stdio.h>
    1 Y+ G5 N8 k4 d0 l
95. #include <string.h>
    / ]3 ^9 Y# a/ {) E: r; e
96. 
    
97. void main()
    3 ^6 S0 K9 D9 {0 k" }
98. {   
    # ?3 G- ^: n6 n- }/ S6 d3 n
99.     WORD wVersionRequested;
    5 v( r: s+ ?6 `+ \+ ?! w
100.     WSADATA wsaData;
     ; E. L4 o% K* d0 C. ^$ q
101.     int err;
     / ]; z) }. O: c8 l0 I
102.      
     
103.     wVersionRequested = MAKEWORD( 2, 2 );
     1 w$ s7 T+ ]2 O. O6 b+ m
104.      
     4 a+ K4 a& s6 d- }: K1 z6 x
105.     err = WSAStartup( wVersionRequested, &wsaData );
     
106.     if ( err != 0 ) {
     ! q) Q. u: u* \. S) b: `0 O+ v7 K
107.          
     
108.         return;
     
109.     }
     . Q/ k9 f7 W3 ?
110.      
     $ v! v7 ~  _1 [, r1 j
111.      
     
112.     if ( LOBYTE( wsaData.wVersion ) != 2 ||
     9 `2 T% m$ n+ @/ U
113.         HIBYTE( wsaData.wVersion ) != 2 )
     5 Q* |$ t. I( M5 |( F5 i! |" G: f+ B
114.     {
     2 v# K2 h& y$ [# p
115.          
     8 X) A1 p# p5 L, c
116.         WSACleanup( );
     
117.         return;
     
118.     }
     
119.     SOCKET socketClient = socket(AF_INET, SOCK_STREAM, 0);
     " }8 r4 J% Y! N
120.     SOCKADDR_IN addrSrv;
     $ P: q( p$ x" Y* i
121.     addrSrv.sin_family = AF_INET;
     
122.     addrSrv.sin_port = htons(6000);
     1 q* L, b9 _4 [+ j1 O9 o
123.     addrSrv.sin_addr.S_un.S_addr = inet_addr("192.168.1.101");//服务器端的IP地址
     / l; E: L. S( O7 M  R  N- p
124.      
     & ^8 q  N1 \0 ^
125.     connect(socketClient, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
     - a. S7 O$ a" L- i' w( s. m. }
126.     char recvBuf[256];
     
127.     char sendBuf[] = "This is Joychou";
     
128.     recv(socketClient, recvBuf, 256, 0);
     $ F+ o/ Q- P! L% v, \' P
129.     printf("%s\n", recvBuf);
     
130.     send(socketClient, sendBuf, strlen(sendBuf) + 1, 0);
     
131.     closesocket(socketClient);
     
132.     WSACleanup();
     
133.      
     
134. }

复制代码