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

admin

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

1. #include <winsock2.h>
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   $ a# q! ^0 J' B1 Y
4. 
   ) M3 \+ I; Y3 I, o" K# C/ `8 Q
5. #define DEFAULT_PORT       5150
   ' X8 B$ e0 ^' N
6. #define DEFAULT_BUFFER     2048
   3 N7 M& j) D2 K; c! c5 y$ o# l$ ^1 |
7. 
   
8. char  szServer[128],
   
9.      szMessage[1024];
   8 E; c& c+ D$ {; v0 E
10. int  iPort    = DEFAULT_PORT;
    
11. 
    7 r/ a1 P2 O* V- o9 J; d5 _
12. int main()
    4 e, _- I( v7 `; L
13. {
    
14.    WSADATA      wsd;
    - y6 `- ~5 e5 x
15.    SOCKET       sClient;
    9 ~1 l1 w1 F& [
16.    char         szBuffer[DEFAULT_BUFFER];
    
17.    int          ret;
    
18.     struct sockaddr_in server;
    7 H0 H2 G) t. R8 {
19.     struct hostent    *host = NULL;
    
20.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    
21.     {
    
22.        printf("Failed to load Winsock library!\n");
    2 j* G% k+ `: P$ L( M" W% ~$ P) a
23.        return 1;
    7 b6 w0 s% x5 |* K
24.     }
    
25.    printf("Enter a string to send to server:\n");
    . w2 i5 D( }- i, A, G8 a9 ^% }
26.    gets(szMessage);
    " g5 \1 D, ?- o( e3 P% l7 _" G) E
27.     // Create the socket, and attempt to connect to the server
    
28.     sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    8 Y2 l: \, M5 O! D
29.     if (sClient == INVALID_SOCKET)
    ) c6 n/ }+ \, X1 v, |
30.     {
    % P8 q% }8 U9 f$ j2 q  C. `5 J
31.        printf("socket() failed: %d\n", WSAGetLastError());
    # ?" u3 U; F8 d: u2 L3 b8 k
32.        return 1;
    
33.     }
    5 N% x: F) M: ]  t3 \) d: K4 i
34.    server.sin_family = AF_INET;
    # k% ?* S6 T  {* `! E; i8 o6 H
35.    server.sin_port = htons(iPort);
    % G( a) B9 m: X6 L& T; Y* B' [9 i5 j
36.    server.sin_addr.s_addr = inet_addr("127.0.0.1");
    
37. 
    
38.     if (connect(sClient, (struct sockaddr *)&server,
    2 B% d1 t& ?6 B9 c9 `
39.        sizeof(server)) == SOCKET_ERROR)
    ) }6 |  X  ~2 t$ R  n
40.     {
    % h0 V8 J) s: N& W& C. a
41.        printf("connect() failed: %d\n", WSAGetLastError());
    
42.        return 1;
    
43.     }
    
44.     // Send and receive data
    6 R& U% W" g: Q3 a1 P/ Y& r
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);
    
52.        ret = recv(sClient, szBuffer, DEFAULT_BUFFER, 0);
    % h  x+ q' E. @+ @
53.        if (ret == SOCKET_ERROR){
    
54.          printf("recv() failed: %d\n", WSAGetLastError());
    
55.        }
    
56.        else{
    
57.          szBuffer[ret] = '\0';
    - ]8 y' ?/ s1 O# M6 Q& |
58.          printf("RECV: '%s'\n",szBuffer);
    
59.        }
    - V& z9 ?8 k9 U
60.     }
    ! n' B4 i1 `( q% g/ ], Y3 J( J
61.    closesocket(sClient);
    
62. 
    
63.    WSACleanup();
    - |" d5 w" k- d
64.     return 0;
    * _  V3 t1 I& {9 M
65. }

复制代码

服务器程序:server.cpp

1. #include <winsock2.h>
   6 a" D" P5 z( S0 o- y6 N* W
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. 
   
5. #define DEFAULT_PORT       5150
   
6. #define DEFAULT_BUFFER     4096
   
7. 
   
8. int   iPort     = DEFAULT_PORT;
   
9. char   szAddress[128];
   & P* p2 C! ]& e4 q" R" [$ Q7 e5 O# k0 Z
10. 
    
11. DWORD WINAPI ClientThread(LPVOID lpParam)
    
12. {
    
13.    SOCKET       sock=(SOCKET)lpParam;
    / g2 |+ Z% q8 R. y7 v- A
14.    char         szBuff[DEFAULT_BUFFER];
    
15.    int          ret;
    
16. 
    " i; t# `$ O/ [" k7 m
17.    while(1)
    8 Z$ j. Q; L4 ^' k6 S' c$ C
18.     {
    , e1 t3 p4 `: _! ?0 r  w
19.        ret = recv(sock, szBuff, DEFAULT_BUFFER, 0);
    
20.        if (ret == 0)
    
21.            break;
    
22.        else if (ret == SOCKET_ERROR)
    
23.        {
    ; w( E  b- y2 \1 A& s
24.            printf("recv() failed: %d\n", WSAGetLastError());
    
25.            break;
    
26.        }
    & x! }$ K" o- O5 U1 A
27.        szBuff[ret] = '\0';
    
28.        printf("RECV: '%s'\n", szBuff);
    
29.       if(strcmp(szBuff,"abc")==0){
    1 g6 I8 e; v9 l' ?& D, a" F
30.          memcpy(szBuff,"Send the correct string!",25);
    
31.        }
    
32.        else{
    5 z3 W7 u& c  N* R  V
33.          memcpy(szBuff,"Send the wrong string!",23);
    
34.        }
    
35.        ret = send(sock, szBuff, strlen(szBuff), 0);
    2 O- k% \0 I# ?; _$ W/ c0 Y1 \
36.        if (ret == SOCKET_ERROR){
    # Z* S& a7 d: s5 v
37.          printf("send() failed: %d\n", WSAGetLastError());
    
38.        }
    6 A; E5 F3 U1 Y! d
39.     }
    1 P4 p. X& }# S- U
40.     return 0;
    
41. }
    
42. 
    ! {/ Z% W7 o" D
43. int main()
    8 ~2 H1 t& A! I7 V0 [* j
44. {
    
45.    WSADATA      wsd;
    ; J. R, {9 z  j
46.    SOCKET       sListen,
    
47.                  sClient;
    * Y, X- G( r7 b
48.    int          iAddrSize;
    
49.    HANDLE       hThread;
    
50.    DWORD        dwThreadId;
    
51.     struct sockaddr_in local,
    * x0 m/ ?: J$ _6 H' x
52.                       client;
    # U3 _4 q. Y9 c2 b( p* A
53. 
    
54.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    
55.     {
    ! r6 b5 b' {1 v: J2 k9 r% T6 a4 A/ _
56.        printf("Failed to load Winsock!\n");
    
57.        return 1;
    # a+ P9 w; {$ I6 i% k/ F
58.     }
    9 I6 n) H: s$ Y8 a2 ~; u0 m. f
59.     // Create our listening socket
    
60.     sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
    
61.     if (sListen == SOCKET_ERROR)
    
62.     {
    
63.        printf("socket() failed: %d\n", WSAGetLastError());
    4 Q5 Q: |0 G5 \. I3 H
64.        return 1;
    
65.     }
    
66.    local.sin_addr.s_addr = htonl(INADDR_ANY);
    2 t" ~* f4 |, [, Z2 c3 |
67.    local.sin_family = AF_INET;
    ) u9 ?% j9 Y0 P
68.    local.sin_port = htons(iPort);
    
69. 
    4 _8 ~1 T5 G( @$ f' V
70.     if (bind(sListen, (struct sockaddr *)&local,
    . Y( t! e' Z9 B# O# a
71.            sizeof(local)) == SOCKET_ERROR)
    
72.     {
    
73.        printf("bind() failed: %d\n", WSAGetLastError());
    ) Z4 j$ B5 n2 a' |+ X3 N8 x
74.        return 1;
    
75.     }
    $ K$ e7 Z( d) L# U
76.    listen(sListen, 8);
    2 L  w; L: R9 j( D4 q
77.     // In a continous loop, wait for incoming clients. Once one
    5 N" e# y4 ~" b' Q
78.     // is detected, create a thread and pass the handle off to it.
    
79.     while (1)
    . }  U+ u( P  W" f; p: D' }
80.     {
    1 R3 Z- J8 B' K) ?* X, p& M& E
81.        iAddrSize = sizeof(client);
    
82.        sClient = accept(sListen, (struct sockaddr *)&client,
    - Z, f( l- S5 {& T" _
83.                        &iAddrSize);      
    
84.        if (sClient == INVALID_SOCKET)
    : j7 ]# V- ?& ~% h
85.        {      
    ( ^  q% W3 `9 Q6 N* H% s  K
86.            printf("accept() failed: %d\n", WSAGetLastError());
    & y. s; @! r# F. c' V
87.            break;
    ! Y! Y8 J0 p) U0 T; T3 U. Q
88.        }
    
89.        printf("Accepted client: %s:%d\n",
    # ?; ~. q/ k# j/ Y# G
90.            inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    6 e- E- v6 ]& m7 F" ~
91. 
    7 C8 ]( E" o  G6 g
92.        hThread = CreateThread(NULL, 0, ClientThread,
    
93.                    (LPVOID)sClient, 0, &dwThreadId);
    8 Z) }  x) u. c0 b
94.        if (hThread == NULL)
      ^. s) l+ M0 m) e4 {8 ?4 y) b
95.        {
    ; }0 q2 Y7 f3 u# D
96.            printf("CreateThread() failed: %d\n", GetLastError());
    
97.            break;
    " z4 p7 m/ L: Z% z) [% Q
98.        }
      C: {4 @; t/ M) A$ B7 q
99.        CloseHandle(hThread);
    # I8 |0 F3 D0 L
100.     }
     
101.    closesocket(sListen);
     % t: z; V$ S% M, F
102.    
     
103.    WSACleanup();
     % U! L5 R7 p3 s- p- b8 K; A
104.     return 0;
     
105. }

复制代码

. g. o& [! F+ P9 ~( g5 }4 o


7 M, Q- X4 l. B

admin

1. 作为服务器，你要绑定【bind】到本地的IP地址上进行监听【listen】，但是你的机器上可能有多块网卡，也就有多个IP地址，这时候你要选择绑定在哪个IP上面，如果指定为INADDR_ANY，那么系统将绑定默认的网卡【即IP地址】。
   
2. 
   
3. 作为客户端，你要连接【connect】到远端的服务器，也是要指定远端服务器的（ip, port）对。
   / ~$ j# G" i& Q" _% D" d. {5 I2 ^% w9 k
4. 当然，在这种情况下，不可能将IP地址指定为INADDR_ANY，系统会疯掉的。
   / {1 z: M# y& S0 F$ j
5. 
   8 B* L* W6 B4 Q$ C4 |
6. Server：
   
7. #include <winsock2.h>
     H& [" }" M5 z& K$ p9 N4 E
8. #pragma comment(lib, "WS2_32.lib")
   
9. 
   
10. #include <stdio.h>
    
11. void main()
    ! ]% w  Q3 P( D6 X; a, ^+ Z
12. {
    
13.     WORD wVersionRequested;//版本号
    
14.     WSADATA wsaData;
    
15.     int err;
    
16. 
      A& s! V# h9 W1 u6 `2 U4 r
17.     wVersionRequested = MAKEWORD(2, 2);//2.2版本的套接字
    
18.     //加载套接字库,如果失败返回
    
19.     err = WSAStartup(wVersionRequested, &wsaData);
    * w" |! q" f% K& {, c! c5 E
20.     if (err != 0)
    0 ]. b' V, S/ F
21.     {
    & v" e, L- S. J# ?9 y* Z2 J
22.         return;
    1 d  q) y: W, p* {, `0 |& j/ t2 ]$ [/ y
23.     }
    
24. 
    
25.     //判断高低字节是不是2,如果不是2.2的版本则退出
    
26.     if (LOBYTE(wsaData.wVersion) != 2 ||
    
27.          
    2 g% E  K$ s9 n' v  o
28.         HIBYTE(wsaData.wVersion) != 2)
    % `, K& O6 k4 z8 r
29.          
    
30.     {
    / S( L/ j5 O) F. b2 v
31.         return;
    . R$ b4 L2 P1 O. T, Q  l4 x
32.     }
    
33.      
    * a; \1 H! @4 O
34.          //创建流式套接字,基于TCP(SOCK_STREAM)
    
35. 
    8 e  j$ ^+ _7 R. d
36.          SOCKET socSrv = socket(AF_INET, SOCK_STREAM, 0);
    
37. 
    
38.          //Socket地址结构体的创建
    ! S& t) n  s* p5 o$ u6 r2 l
39. 
    / f* m" d: D/ N9 S
40.          SOCKADDR_IN addrSrv;
    
41. 
    % w" f8 p) M6 [0 J' e+ O
42.          addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);//转换Unsigned long型为网络字节序格
    8 ~; d* b7 I+ r
43.          addrSrv.sin_family = AF_INET;//指定地址簇
    
44.          addrSrv.sin_port = htons(6000);
    
45.         //指定端口号,除sin_family参数外,其它参数都是网络字节序,因此需要转换
    % `* I8 l5 o* l( Z9 A7 ]
46. 
    7 k5 ?! t  o8 w/ Y2 n) d
47.          //将套接字绑定到一个端口号和本地地址上
    
48.          bind(socSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));//必须用sizeof，strlen不行
    + x8 t+ E* _5 M5 y9 e. I! }0 J3 s0 H
49. 
    & ?. `1 C4 Z8 c9 E. T
50.          listen(socSrv, 5);
    7 g% h7 v" W. r  w/ f# h" o5 P
51.          
    7 k/ P& T) s/ N) g6 x5 ~, M4 [
52.          SOCKADDR_IN addrClient;//字义用来接收客户端Socket的结构体
    
53. 
      h. ~6 |7 ]& a/ V
54.          int len = sizeof(SOCKADDR);//初始化参数,这个参数必须进行初始化，sizeof
    & i' d2 ~: h! I- t' H. @
55. 
    
56.          //循环等待接受客户端发送请求
      {" X* \- y9 w5 {
57. 
    * p# J7 R% m# z2 Q1 S" E+ Q/ [
58.          while (1)
    
59.          {
    
60.                    //等待客户请求到来；当请求到来后，接受连接请求，
    
61. 
    1 D& L& |1 ^! ^5 s$ r6 u6 a$ L
62.                    //返回一个新的对应于此次连接的套接字（accept）。
    ) B! @7 h0 i% G$ i
63.                    //此时程序在此发生阻塞
    
64. 
    2 V, s9 {) u/ V5 a' e- y6 J0 H
65.                    SOCKET sockConn = accept(socSrv, (SOCKADDR*)&addrClient, &len);
    
66. 
    
67.                    char sendBuf[100];
    : [" Q$ H9 {# ?" R1 W, s% b
68. 
    
69.                    sprintf(sendBuf, "Welcome %s to JoyChou",
    - d4 c5 b$ m. U. k/ t
70. 
    8 A7 }+ F! S6 ^
71.                             inet_ntoa(addrClient.sin_addr));//格式化输出
    9 x9 f, l5 n  i! h9 p/ g
72. 
    ( N6 W" `3 U: m
73.                    //用返回的套接字和客户端进行通信
    
74. 
    ) i1 P6 o" {- l/ |
75.                    send(sockConn, sendBuf, strlen(sendBuf)+1, 0);//多发送一个字节
    2 m+ V. K, k& f7 c2 F
76. 
    
77.                    //接收数据
    ( r- y' D  U& F5 e. O
78. 
    ( n- Y4 r. I( Q- {# n% V5 Q# A9 o
79.                    char recvBuf[100];
    , o+ d/ v) S3 R% I
80. 
    ; _  o- \+ m" r
81.                    recv(sockConn, recvBuf, 100, 0);
    
82. 
    $ |4 Q/ K* x& c: W+ R( V& W$ j# S
83.                    printf("%s\n", recvBuf);
    
84.                    closesocket(sockConn);
    . X5 T0 O$ |8 W: k3 A' O/ ?
85. 
    5 F: O/ b9 |+ }( j9 _& L
86.          }
    9 o7 m2 y! r. Z. Q4 p: f) |1 g
87. }
    5 Y3 j  J9 R0 ]3 a. l7 t; ^
88. 
    ' c  j, k+ p; ~6 h% N% q
89. 
    
90. Client：
    
91. 
    4 F, y1 M% Z8 F. ^, W" L% j
92. #include <winsock2.H>
    ! b- V3 p4 a8 R) d3 I8 y% [
93. #pragma comment(lib, "Ws2_32.lib")
    6 f7 K' B. h  Q
94. #include <stdio.h>
    ( _: s# ?; l0 X8 ]& y
95. #include <string.h>
    
96. 
    2 p/ B  L7 b5 y4 Y; U
97. void main()
    & J- |2 l" C& J/ k( k$ X# E
98. {   
    
99.     WORD wVersionRequested;
    : C9 A# [) d8 u% v, d4 l
100.     WSADATA wsaData;
       m. `: u2 U) ]+ u- `( d
101.     int err;
     ) m2 U# \2 m/ ^0 u6 b& Q
102.      
     
103.     wVersionRequested = MAKEWORD( 2, 2 );
     : v* Y4 V' i2 l0 V$ i& n# K
104.      
     
105.     err = WSAStartup( wVersionRequested, &wsaData );
     
106.     if ( err != 0 ) {
     
107.          
     
108.         return;
     
109.     }
     1 l, G/ S& ]. Z, P& z6 }
110.      
     " }( F3 p4 X& Z- L: {* a" r
111.      
     
112.     if ( LOBYTE( wsaData.wVersion ) != 2 ||
     
113.         HIBYTE( wsaData.wVersion ) != 2 )
     
114.     {
     
115.          
     
116.         WSACleanup( );
     
117.         return;
     
118.     }
     9 ~" F5 H* ?; B6 V; x) m6 U
119.     SOCKET socketClient = socket(AF_INET, SOCK_STREAM, 0);
       N1 v5 {% U$ ]( V: H
120.     SOCKADDR_IN addrSrv;
     
121.     addrSrv.sin_family = AF_INET;
     
122.     addrSrv.sin_port = htons(6000);
     2 w0 P* k# F0 _$ b3 u( j$ m6 J
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];
     ! I6 j. w, e' ]$ R2 A" ^- |( }- E
127.     char sendBuf[] = "This is Joychou";
     
128.     recv(socketClient, recvBuf, 256, 0);
     
129.     printf("%s\n", recvBuf);
     
130.     send(socketClient, sendBuf, strlen(sendBuf) + 1, 0);
     $ e- W$ |* b( i. `  F, I1 N$ g
131.     closesocket(socketClient);
     ) k! E! S3 q0 d2 @% ]
132.     WSACleanup();
     
133.      
     
134. }

复制代码