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

admin

程序很简单，windows环境下的，客户端和服务器程序都在本机运行，在客户端输入发送给服务器的字符串，服务器收到字符串后会打印出来，同时与"abc"比较，与"abc"相同就会返给客户端，输入的是正确的，不同会告诉客户端输入时错误的。
) [# G8 p! `3 g: S" L& S1 z客户端程序：client.cpp
5 H; t( D5 ?" m, a: i! ~

1. #include <winsock2.h>
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   4 [8 j5 j/ F7 T5 f! `: {' E
4. 
   
5. #define DEFAULT_PORT       5150
   
6. #define DEFAULT_BUFFER     2048
   
7. 
   
8. char  szServer[128],
   
9.      szMessage[1024];
   & I" Q# c; N. A% H' X1 x; [
10. int  iPort    = DEFAULT_PORT;
    
11. 
    
12. int main()
      d& Y2 V' Y/ P# x, X. `8 @' Z' l
13. {
    . B7 P" c. z) n: _5 P: C
14.    WSADATA      wsd;
    . }- K  |/ _4 `; K/ e% G( F
15.    SOCKET       sClient;
    
16.    char         szBuffer[DEFAULT_BUFFER];
    % z7 m6 P1 x5 B4 n
17.    int          ret;
    / W& q* F6 t/ v9 h
18.     struct sockaddr_in server;
    $ d. \: `1 i4 S, W' v, R
19.     struct hostent    *host = NULL;
    4 w8 U# d8 d  g
20.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    ( ^; A; n5 X" [3 D, P$ @
21.     {
    ) E7 h5 N  i* [6 g! j2 b
22.        printf("Failed to load Winsock library!\n");
    
23.        return 1;
    2 y6 }, w5 H( D2 R. x$ D/ P
24.     }
    ) z! k1 A8 X, {( P+ j6 G: n6 P
25.    printf("Enter a string to send to server:\n");
    ) ?+ m) N1 I: s! Y) ~0 E# T( r7 c9 r
26.    gets(szMessage);
    
27.     // Create the socket, and attempt to connect to the server
    + m# [  t0 o& B& i! R: \# V* f9 b
28.     sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    % @9 a: p* X! W1 k+ _
29.     if (sClient == INVALID_SOCKET)
    
30.     {
    
31.        printf("socket() failed: %d\n", WSAGetLastError());
    
32.        return 1;
    : s: R7 B+ X1 ^9 F) T$ Y7 ?- C
33.     }
    ; X: G3 {( X" X' L  W  g5 z, t
34.    server.sin_family = AF_INET;
      |) I7 f4 e$ S
35.    server.sin_port = htons(iPort);
    ( U; z  X) i$ x2 }
36.    server.sin_addr.s_addr = inet_addr("127.0.0.1");
    $ F2 E4 H/ ], {& F3 q" ~7 _) x. q
37. 
    . k, n1 f! s" e6 l
38.     if (connect(sClient, (struct sockaddr *)&server,
    
39.        sizeof(server)) == SOCKET_ERROR)
    
40.     {
    
41.        printf("connect() failed: %d\n", WSAGetLastError());
    ) q9 P1 P7 @% ]$ i
42.        return 1;
    
43.     }
    ! F- E" Q7 Y: ~% D) B. j& W
44.     // Send and receive data
    ) M& a: q! i% l0 U
45.     ret = send(sClient, szMessage, strlen(szMessage), 0);
    & o% K+ @+ ~7 b. H$ K3 z- _
46.     if (ret == SOCKET_ERROR)
    / l1 J  m. [+ T7 l$ {% F
47.     {
    
48.        printf("send() failed: %d\n", WSAGetLastError());
    
49.     }
    
50.     else{
    
51.        printf("Send '%s' \n", szMessage);
    # J* z4 M2 H) r5 J0 z
52.        ret = recv(sClient, szBuffer, DEFAULT_BUFFER, 0);
    
53.        if (ret == SOCKET_ERROR){
    
54.          printf("recv() failed: %d\n", WSAGetLastError());
    3 O$ \& M) A, W
55.        }
    
56.        else{
    : {; H3 H" s0 ^! i8 a! V1 U3 O  z
57.          szBuffer[ret] = '\0';
    9 A$ S6 Q& N' n8 v5 }7 \
58.          printf("RECV: '%s'\n",szBuffer);
    , t3 z; I2 S% `
59.        }
    , I! e4 D8 }. m( z
60.     }
    
61.    closesocket(sClient);
    4 B# R- Q$ e. T3 H) B/ D7 z: {
62. 
    
63.    WSACleanup();
    7 {6 v6 b: y2 R/ I
64.     return 0;
    : ^. a9 u" k. I* P3 q+ j7 ~6 g! i# o
65. }

复制代码

服务器程序:server.cpp
' C6 C4 D# _" G& N1 g5 \

1. #include <winsock2.h>
   % r9 A& z* ]9 r) q2 L; F6 {: H' o, J2 V2 |
2. #include <stdio.h>
   
3. #include <stdlib.h>
   & S% h! k9 {: N+ D8 {. V" e( o1 D' r
4. 
   
5. #define DEFAULT_PORT       5150
   
6. #define DEFAULT_BUFFER     4096
   
7. 
   " J4 f: ~/ y$ X; ^* X( O6 T% D
8. int   iPort     = DEFAULT_PORT;
   % U' K/ Y8 B& l( }3 P) n
9. char   szAddress[128];
   6 M9 A5 y" g# O" a6 s
10. 
    ' ~; w# @: z9 h# _$ T! G- {
11. DWORD WINAPI ClientThread(LPVOID lpParam)
    5 r! Q2 Y( ^" z8 ?! v* i
12. {
    : T. r7 W; b, @* G
13.    SOCKET       sock=(SOCKET)lpParam;
    ! P" U% @& b4 s$ U' B4 N4 N, n3 ?
14.    char         szBuff[DEFAULT_BUFFER];
    " N: P0 [5 B# }7 m7 Z
15.    int          ret;
    & ~& J: N2 ]- r" \% b; r: }! {( w. ^
16. 
    2 z7 z7 p/ b8 P) q# p
17.    while(1)
    
18.     {
    
19.        ret = recv(sock, szBuff, DEFAULT_BUFFER, 0);
    
20.        if (ret == 0)
    5 e) g0 N1 ?0 R0 k8 C* ]6 A$ N
21.            break;
    
22.        else if (ret == SOCKET_ERROR)
    
23.        {
    % d2 s1 u) v2 }( V% L
24.            printf("recv() failed: %d\n", WSAGetLastError());
    - M; f& o0 t9 j' |6 V
25.            break;
    4 u8 _2 [4 G1 P7 \  s
26.        }
    ' O" @+ e! S+ g, @
27.        szBuff[ret] = '\0';
    
28.        printf("RECV: '%s'\n", szBuff);
    0 T) I( y6 T* b
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);
    & m2 K% \* f, Q
34.        }
    6 b. S& _# H8 d. y
35.        ret = send(sock, szBuff, strlen(szBuff), 0);
    - t/ P7 ]6 \3 A" |1 T
36.        if (ret == SOCKET_ERROR){
    + I8 U/ v8 V' X' h6 e' g( ^
37.          printf("send() failed: %d\n", WSAGetLastError());
    : ]  L2 r+ g, |1 g7 Y
38.        }
    + P8 Z( _+ z0 d8 W
39.     }
    
40.     return 0;
    2 m" \  ^4 x' j4 v8 G% H" u9 v% u$ \- Q
41. }
    
42. 
    
43. int main()
    
44. {
    
45.    WSADATA      wsd;
    1 J5 F9 A! G* M+ }) r
46.    SOCKET       sListen,
    3 j2 Q/ ?2 k4 t6 F/ T: m
47.                  sClient;
    % ]5 b8 `. d# D; h7 U0 L
48.    int          iAddrSize;
    
49.    HANDLE       hThread;
    
50.    DWORD        dwThreadId;
    
51.     struct sockaddr_in local,
    7 {7 e3 B3 m$ T+ F2 W) J$ w# x
52.                       client;
    ! F% w6 [2 b4 ?% W+ a
53. 
    
54.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    $ ]( c% L7 ^4 U+ s$ k9 k3 V
55.     {
    
56.        printf("Failed to load Winsock!\n");
    
57.        return 1;
    
58.     }
    
59.     // Create our listening socket
    + E6 o+ w( G$ A+ y0 |2 T: G: w
60.     sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
    9 E( I" M2 h* w2 S& q0 S3 ]" Q
61.     if (sListen == SOCKET_ERROR)
    
62.     {
    
63.        printf("socket() failed: %d\n", WSAGetLastError());
    + u, h5 i! p4 X$ k9 Z  U% {0 c% Q( L7 H
64.        return 1;
    
65.     }
    
66.    local.sin_addr.s_addr = htonl(INADDR_ANY);
    
67.    local.sin_family = AF_INET;
    
68.    local.sin_port = htons(iPort);
    
69. 
    / b: z/ @$ p6 `$ G
70.     if (bind(sListen, (struct sockaddr *)&local,
    
71.            sizeof(local)) == SOCKET_ERROR)
    
72.     {
    
73.        printf("bind() failed: %d\n", WSAGetLastError());
    ' R" e9 m: w' {
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.
    
79.     while (1)
    7 ]6 r% w( j$ x+ m: S8 x/ P
80.     {
    8 K2 _3 Y4 ]& z& W! i
81.        iAddrSize = sizeof(client);
    - _, H) Z$ M. G: r. `
82.        sClient = accept(sListen, (struct sockaddr *)&client,
    * v8 s4 E7 L1 I5 u6 l" j
83.                        &iAddrSize);      
    / M  o; o& K( p5 q
84.        if (sClient == INVALID_SOCKET)
    ) ]# b3 W, C4 C! |
85.        {      
    
86.            printf("accept() failed: %d\n", WSAGetLastError());
    # {" g, I7 n. {6 t: |% ]2 N- ~
87.            break;
    
88.        }
    
89.        printf("Accepted client: %s:%d\n",
    
90.            inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    : {5 ^& N: ?9 L- ~6 c1 w7 p1 P
91. 
    
92.        hThread = CreateThread(NULL, 0, ClientThread,
    . i* @- H% G- M% z3 q* {. B$ ^
93.                    (LPVOID)sClient, 0, &dwThreadId);
    
94.        if (hThread == NULL)
    8 E. `% Q+ H) _' g8 q0 t
95.        {
    1 S/ ^* H5 n8 A5 k* ?& V8 p* u( ?
96.            printf("CreateThread() failed: %d\n", GetLastError());
    
97.            break;
    6 _1 l8 k; m5 M- g5 {6 O
98.        }
    ) ?& v# k' s) P
99.        CloseHandle(hThread);
    ( M8 I' F; Q5 N4 O
100.     }
     
101.    closesocket(sListen);
     3 V" Q6 \, V; U* }% t
102.    
     8 i8 K7 R" ?- j# y
103.    WSACleanup();
       l" |% g1 C! g' \9 n9 l$ [4 x3 p
104.     return 0;
     $ t( G8 ?+ L5 x0 {
105. }

复制代码

! i( G" p' x8 N

- K- X7 ?1 j8 |1 v  `

6 a7 n3 `- i/ K8 J: ~& s7 N( E

admin

1. 作为服务器，你要绑定【bind】到本地的IP地址上进行监听【listen】，但是你的机器上可能有多块网卡，也就有多个IP地址，这时候你要选择绑定在哪个IP上面，如果指定为INADDR_ANY，那么系统将绑定默认的网卡【即IP地址】。
   4 \* f4 x* t0 @3 c
2. 
   4 k1 e4 _/ b) v% \
3. 作为客户端，你要连接【connect】到远端的服务器，也是要指定远端服务器的（ip, port）对。
   
4. 当然，在这种情况下，不可能将IP地址指定为INADDR_ANY，系统会疯掉的。
   . j% S( F/ n- G4 S+ u) R
5. 
   
6. Server：
   / t  Q( v& S" J  F$ X# n. b5 P! p
7. #include <winsock2.h>
   9 Y4 Q9 u$ j9 ^5 r
8. #pragma comment(lib, "WS2_32.lib")
   
9. 
   
10. #include <stdio.h>
    2 ]) {% N, _+ }* c  F2 c
11. void main()
    
12. {
    + z: Z. M* o9 V6 o7 b: c) s
13.     WORD wVersionRequested;//版本号
    0 w2 n8 h: \! h/ c7 J3 C
14.     WSADATA wsaData;
    
15.     int err;
    2 A& `" E) \5 s- Y
16. 
    
17.     wVersionRequested = MAKEWORD(2, 2);//2.2版本的套接字
    , G: y8 K9 P+ ~. L3 }! y4 _" t/ q
18.     //加载套接字库,如果失败返回
    
19.     err = WSAStartup(wVersionRequested, &wsaData);
    
20.     if (err != 0)
    
21.     {
    
22.         return;
    ' V2 n/ g' m' E5 l. C
23.     }
    
24. 
    ( _, \7 Y2 O9 |- e) a6 l0 d
25.     //判断高低字节是不是2,如果不是2.2的版本则退出
    # S0 a# ^- ^4 Y  e2 [
26.     if (LOBYTE(wsaData.wVersion) != 2 ||
    
27.          
      |4 Y) F: @4 h- O, G
28.         HIBYTE(wsaData.wVersion) != 2)
    
29.          
    7 }8 F; S+ }, S1 S5 T
30.     {
    ! |# f5 y6 C; e1 ?) Z
31.         return;
    
32.     }
    ! R1 |9 b6 D  w5 v
33.      
    
34.          //创建流式套接字,基于TCP(SOCK_STREAM)
    
35. 
    
36.          SOCKET socSrv = socket(AF_INET, SOCK_STREAM, 0);
    5 u# c7 T) [$ L2 ^1 f, w2 E1 D
37. 
    
38.          //Socket地址结构体的创建
    
39. 
    , a% E4 Q. E) ?/ a' ~/ ?1 w
40.          SOCKADDR_IN addrSrv;
    
41. 
    
42.          addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);//转换Unsigned long型为网络字节序格
    
43.          addrSrv.sin_family = AF_INET;//指定地址簇
    ; e0 D% |' a  e1 y7 m, l6 J
44.          addrSrv.sin_port = htons(6000);
    4 h% m2 \- K0 [
45.         //指定端口号,除sin_family参数外,其它参数都是网络字节序,因此需要转换
    5 v0 b* B' @, Y( U; Z. L
46. 
    # G1 O- d; [$ z. p4 m4 v" L
47.          //将套接字绑定到一个端口号和本地地址上
    
48.          bind(socSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));//必须用sizeof，strlen不行
    
49. 
    
50.          listen(socSrv, 5);
    , _  D! t7 V/ _# f, F3 R3 V
51.          
    
52.          SOCKADDR_IN addrClient;//字义用来接收客户端Socket的结构体
    
53. 
    
54.          int len = sizeof(SOCKADDR);//初始化参数,这个参数必须进行初始化，sizeof
    ! K' L6 T7 r( M. ~* N* _6 V- m
55. 
    
56.          //循环等待接受客户端发送请求
    + A4 Y0 ^( t4 d3 b* K
57. 
    . Y: O) {. l" x5 w" E
58.          while (1)
    ; |- j9 a0 n' Q% g7 a4 a) j% f7 B
59.          {
    
60.                    //等待客户请求到来；当请求到来后，接受连接请求，
    
61. 
    ; [5 H/ [, Z4 n# M% J
62.                    //返回一个新的对应于此次连接的套接字（accept）。
    
63.                    //此时程序在此发生阻塞
    ; x7 G  o/ C# w* Y; K
64. 
    
65.                    SOCKET sockConn = accept(socSrv, (SOCKADDR*)&addrClient, &len);
    
66. 
    9 W6 p4 V9 \6 @: K6 J
67.                    char sendBuf[100];
    / B. X+ f* M3 x4 R. \& r5 {& z( M
68. 
    $ w$ N8 L) g9 o  \1 B& q, k
69.                    sprintf(sendBuf, "Welcome %s to JoyChou",
    
70. 
    5 }8 K; W# W8 g4 g
71.                             inet_ntoa(addrClient.sin_addr));//格式化输出
    4 n; a  O; b! x8 [( p) u
72. 
    
73.                    //用返回的套接字和客户端进行通信
    
74. 
    / u( @0 O/ I7 c
75.                    send(sockConn, sendBuf, strlen(sendBuf)+1, 0);//多发送一个字节
    
76. 
    6 f4 T5 ]. _; u4 O  G$ s
77.                    //接收数据
    
78. 
    ; ?; q. k3 D, z& a( p# H( l% F
79.                    char recvBuf[100];
    
80. 
    
81.                    recv(sockConn, recvBuf, 100, 0);
    % ]" H& s7 E9 C9 J) y# f  o2 d
82. 
    
83.                    printf("%s\n", recvBuf);
    7 Q5 p; V0 R. \+ Y0 O
84.                    closesocket(sockConn);
    
85. 
    
86.          }
    
87. }
      T) V( U) p& q! Q# d
88. 
    / f" o# N$ k1 j2 g
89. 
    
90. Client：
    
91. 
    + D9 {; ~) t6 B# z5 l
92. #include <winsock2.H>
    
93. #pragma comment(lib, "Ws2_32.lib")
    
94. #include <stdio.h>
    8 S8 d6 f' c0 `1 V1 u+ h+ s
95. #include <string.h>
    
96. 
    
97. void main()
    
98. {   
    
99.     WORD wVersionRequested;
    4 n0 ^2 W* [9 \8 u; Y3 y  L
100.     WSADATA wsaData;
     - h0 e* P$ h/ P  y, F/ K5 H
101.     int err;
     
102.      
     % d: S; N4 x7 `3 I$ m& ~2 d( D
103.     wVersionRequested = MAKEWORD( 2, 2 );
     
104.      
     
105.     err = WSAStartup( wVersionRequested, &wsaData );
     2 P3 }5 O; T0 a4 }8 V" v) D
106.     if ( err != 0 ) {
     8 h: o* Q1 }/ r0 ]
107.          
     $ c% c  @" h, G' Z
108.         return;
     
109.     }
     
110.      
     1 d8 i$ z  {- a/ M) W- p+ B
111.      
     
112.     if ( LOBYTE( wsaData.wVersion ) != 2 ||
     4 Z6 c0 h( i( ?1 q, q" E& R9 D# d
113.         HIBYTE( wsaData.wVersion ) != 2 )
     
114.     {
     ' P1 n  m( \' P
115.          
     / j4 k: m' Q% C, S# V& q0 Q5 R0 `
116.         WSACleanup( );
     . e! Z- M' y# z( {( [; c# H* y
117.         return;
     0 t3 l8 v- g& |8 ~0 a/ r8 e$ v
118.     }
     % ?6 q0 X5 X5 S
119.     SOCKET socketClient = socket(AF_INET, SOCK_STREAM, 0);
     
120.     SOCKADDR_IN addrSrv;
     + I3 @, T% `$ W2 G) x
121.     addrSrv.sin_family = AF_INET;
     
122.     addrSrv.sin_port = htons(6000);
     & x9 v* I6 C3 F4 _. G+ U6 j7 B
123.     addrSrv.sin_addr.S_un.S_addr = inet_addr("192.168.1.101");//服务器端的IP地址
     $ K0 ~, y2 i. r- O: t& W
124.      
     ; n9 y) {5 Q0 G/ P: B; L! _
125.     connect(socketClient, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
     
126.     char recvBuf[256];
     * d* M; B' T5 e8 u# _3 ^
127.     char sendBuf[] = "This is Joychou";
     ' D: ?- I* u# K% p  Q/ L5 A
128.     recv(socketClient, recvBuf, 256, 0);
     
129.     printf("%s\n", recvBuf);
     , |2 ~8 G8 n) c, U3 L- n/ {; Y
130.     send(socketClient, sendBuf, strlen(sendBuf) + 1, 0);
     
131.     closesocket(socketClient);
     
132.     WSACleanup();
     
133.      
     
134. }

复制代码