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

admin

程序很简单，windows环境下的，客户端和服务器程序都在本机运行，在客户端输入发送给服务器的字符串，服务器收到字符串后会打印出来，同时与"abc"比较，与"abc"相同就会返给客户端，输入的是正确的，不同会告诉客户端输入时错误的。
) E; F( I: I+ o& L客户端程序：client.cpp
+ m. ?2 W% G$ [0 D4 t! @

1. #include <winsock2.h>
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   " p1 B0 n9 b2 _& d. \
4. 
   2 G- a. k2 i: t& a
5. #define DEFAULT_PORT       5150
   2 A+ j' f' \. B
6. #define DEFAULT_BUFFER     2048
   
7. 
   5 n/ |, m+ C  @" K
8. char  szServer[128],
   & i7 s/ B* ^. V+ L7 r$ C1 N
9.      szMessage[1024];
   & ~) g* V- I0 ]4 v1 s
10. int  iPort    = DEFAULT_PORT;
    % i0 _3 D: k! T( A0 S- f& Q/ [
11. 
    
12. int main()
    
13. {
    
14.    WSADATA      wsd;
    
15.    SOCKET       sClient;
    + ]( D  E% S1 C/ D
16.    char         szBuffer[DEFAULT_BUFFER];
    
17.    int          ret;
    - z% [" j+ q6 Q8 c8 j
18.     struct sockaddr_in server;
    
19.     struct hostent    *host = NULL;
    + A, {% Z+ r. r  }
20.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    0 U( C9 Z2 r3 R8 D+ _
21.     {
    
22.        printf("Failed to load Winsock library!\n");
    
23.        return 1;
    8 M  o9 P% B5 b' ~# Y
24.     }
    
25.    printf("Enter a string to send to server:\n");
    6 B7 D4 @# D  ?) }4 r) j) p+ s% U  c
26.    gets(szMessage);
    
27.     // Create the socket, and attempt to connect to the server
    7 J3 ]: c, a. u$ g1 B
28.     sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    + Y% U3 z% v- ]. u) s
29.     if (sClient == INVALID_SOCKET)
    , l; `1 d0 J) U6 F. y8 N
30.     {
    
31.        printf("socket() failed: %d\n", WSAGetLastError());
    
32.        return 1;
    3 S  {+ K: ^4 ]+ z' R
33.     }
    
34.    server.sin_family = AF_INET;
    " O1 [9 n) e7 J- G: I2 Q
35.    server.sin_port = htons(iPort);
    
36.    server.sin_addr.s_addr = inet_addr("127.0.0.1");
    2 ]/ B9 `% f$ N" D/ H! E
37. 
    
38.     if (connect(sClient, (struct sockaddr *)&server,
    
39.        sizeof(server)) == SOCKET_ERROR)
    6 w, p/ P1 X& u' D# b
40.     {
    # i$ ?" F9 D; j( x8 B8 @. |
41.        printf("connect() failed: %d\n", WSAGetLastError());
    " Y9 t5 S. x0 M
42.        return 1;
    
43.     }
    
44.     // Send and receive data
    + A: I. t5 o: K  e* V
45.     ret = send(sClient, szMessage, strlen(szMessage), 0);
    & c, y+ z9 h' ^4 r- D( |
46.     if (ret == SOCKET_ERROR)
    
47.     {
    + w5 l# s1 ~# D% S" ]
48.        printf("send() failed: %d\n", WSAGetLastError());
    
49.     }
    : X) S3 n- i) {5 Q& w
50.     else{
    5 e: X" f. O! r% r' y* n5 L
51.        printf("Send '%s' \n", szMessage);
    - S! Q" }. J/ Q# ]
52.        ret = recv(sClient, szBuffer, DEFAULT_BUFFER, 0);
    & u0 s' A( i& U1 o1 f
53.        if (ret == SOCKET_ERROR){
    
54.          printf("recv() failed: %d\n", WSAGetLastError());
    
55.        }
    2 p1 }- N* z& B! r
56.        else{
    * f, w% e7 M6 `4 B+ b% c2 t
57.          szBuffer[ret] = '\0';
    $ ]; K% O1 @2 p" `) I
58.          printf("RECV: '%s'\n",szBuffer);
    6 E* V) S* h1 K0 G3 U$ G
59.        }
    
60.     }
    
61.    closesocket(sClient);
    : q+ ]+ {* b8 r4 s
62. 
    - n, S+ o0 D: A. S4 G8 B
63.    WSACleanup();
    
64.     return 0;
    0 n% f0 \  t$ v7 f1 Y, ], n& u* B
65. }

复制代码

服务器程序:server.cpp

1. #include <winsock2.h>
   
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;
   6 N0 w' d+ T1 R- p
9. char   szAddress[128];
   " D- {2 Z' I5 M" h  G: ^. D# a# Y2 b
10. 
    1 v7 h2 |1 m1 s  B. d* C# T8 ~3 ]
11. DWORD WINAPI ClientThread(LPVOID lpParam)
    ( |( _- y% y; [: O+ ~
12. {
    0 B7 \7 n1 o  }* q  o1 `* |
13.    SOCKET       sock=(SOCKET)lpParam;
    $ N9 N# f4 w) s0 g: W
14.    char         szBuff[DEFAULT_BUFFER];
    8 |$ P4 a& p9 \  Z& V+ h( ^/ |) Y
15.    int          ret;
    
16. 
    ) B" `, I* u- N4 \
17.    while(1)
    0 v; h8 ?1 x* ?) N' B
18.     {
    ' x4 ?$ n0 o  z& @
19.        ret = recv(sock, szBuff, DEFAULT_BUFFER, 0);
    
20.        if (ret == 0)
    
21.            break;
    
22.        else if (ret == SOCKET_ERROR)
    
23.        {
    
24.            printf("recv() failed: %d\n", WSAGetLastError());
      F) h; G+ o. z4 d  s
25.            break;
    - V6 _/ m$ w1 L# K9 W% J
26.        }
    
27.        szBuff[ret] = '\0';
    + P; A+ O$ a  w% o( `. a5 Y) r( X+ P/ x2 z
28.        printf("RECV: '%s'\n", szBuff);
    
29.       if(strcmp(szBuff,"abc")==0){
    
30.          memcpy(szBuff,"Send the correct string!",25);
    
31.        }
    6 q  }! m  a6 M* l& Q, r( {
32.        else{
    
33.          memcpy(szBuff,"Send the wrong string!",23);
    
34.        }
    
35.        ret = send(sock, szBuff, strlen(szBuff), 0);
    
36.        if (ret == SOCKET_ERROR){
    0 O5 P- L8 C/ F7 o3 j
37.          printf("send() failed: %d\n", WSAGetLastError());
    
38.        }
    
39.     }
    
40.     return 0;
    : w/ m# g& q5 N2 C! O4 k
41. }
    ( q+ d+ l+ l' f* I
42. 
    + T8 g1 ]6 ^( B' ^+ K# X
43. int main()
    
44. {
    ; d% ^1 |) T* o) {# A" N# Q6 D5 Y
45.    WSADATA      wsd;
    
46.    SOCKET       sListen,
    
47.                  sClient;
    
48.    int          iAddrSize;
    
49.    HANDLE       hThread;
    2 S8 X& ?4 j5 P- z6 o  r+ `( g
50.    DWORD        dwThreadId;
    " o6 c  c' A! @
51.     struct sockaddr_in local,
    ) h; W, o: e5 m
52.                       client;
    2 l# }; r5 X1 W7 E4 G- K- r
53. 
    . @% m7 D9 s/ I7 V+ D
54.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    9 N$ ~/ I+ z+ i' Y
55.     {
    ' o1 n! K2 `; k1 q( \
56.        printf("Failed to load Winsock!\n");
    & e. F! g& k! d) C7 B
57.        return 1;
    
58.     }
    7 ]& ?' @) }$ ]5 K1 u. m& r0 X
59.     // Create our listening socket
    
60.     sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
    , j; }# `" i# K
61.     if (sListen == SOCKET_ERROR)
    ' P- O& k9 X* v# c
62.     {
    + _6 b$ T$ E0 s  _) \
63.        printf("socket() failed: %d\n", WSAGetLastError());
    7 p; O* b0 s- s
64.        return 1;
    ' ^2 X9 S0 P% u3 m. [) W' D5 _+ D
65.     }
    
66.    local.sin_addr.s_addr = htonl(INADDR_ANY);
    # v1 ~) J' k0 I& ?2 E9 t
67.    local.sin_family = AF_INET;
    5 \6 T2 W+ [" h. F4 b
68.    local.sin_port = htons(iPort);
    
69. 
    
70.     if (bind(sListen, (struct sockaddr *)&local,
    
71.            sizeof(local)) == SOCKET_ERROR)
    ' F5 @9 H6 u" E3 r: w3 t, o) H
72.     {
    % u# \! Q' W/ _3 Y1 I
73.        printf("bind() failed: %d\n", WSAGetLastError());
    % ?  \! t' a  R4 ~
74.        return 1;
    
75.     }
    
76.    listen(sListen, 8);
    & w& G& @/ F/ u& R
77.     // In a continous loop, wait for incoming clients. Once one
    9 ]6 V5 o5 u+ U( o) E5 e
78.     // is detected, create a thread and pass the handle off to it.
    
79.     while (1)
    
80.     {
    
81.        iAddrSize = sizeof(client);
    * m. y6 J' r1 C, L/ t
82.        sClient = accept(sListen, (struct sockaddr *)&client,
    : ?2 C# h% b; p' S- w9 b( y
83.                        &iAddrSize);      
    ) }$ U' }% H( n
84.        if (sClient == INVALID_SOCKET)
    
85.        {      
    
86.            printf("accept() failed: %d\n", WSAGetLastError());
    
87.            break;
    
88.        }
    8 d' \, N0 p4 a5 q( Q$ b
89.        printf("Accepted client: %s:%d\n",
    
90.            inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    6 \% ~5 d; @' o9 {" R3 ^1 B, Q
91. 
    1 I- A4 w% ]" s, l( s' Y
92.        hThread = CreateThread(NULL, 0, ClientThread,
    
93.                    (LPVOID)sClient, 0, &dwThreadId);
    
94.        if (hThread == NULL)
    8 {) S9 _, ?; S0 v: g, h4 H
95.        {
    # R! M/ A7 Q  S  d5 {" U! @" Y
96.            printf("CreateThread() failed: %d\n", GetLastError());
    ; G% O9 c& B  ]
97.            break;
    
98.        }
    
99.        CloseHandle(hThread);
    
100.     }
     
101.    closesocket(sListen);
     
102.    
     
103.    WSACleanup();
     , Q; t) ?- Y$ R7 Q9 \
104.     return 0;
     
105. }

复制代码

' [4 M- M: S( t% o6 N) y. A5 z3 Z
! {6 D! X& ~% _2 b2 h6 S

admin

1. 作为服务器，你要绑定【bind】到本地的IP地址上进行监听【listen】，但是你的机器上可能有多块网卡，也就有多个IP地址，这时候你要选择绑定在哪个IP上面，如果指定为INADDR_ANY，那么系统将绑定默认的网卡【即IP地址】。
   
2. 
   
3. 作为客户端，你要连接【connect】到远端的服务器，也是要指定远端服务器的（ip, port）对。
   
4. 当然，在这种情况下，不可能将IP地址指定为INADDR_ANY，系统会疯掉的。
   / x" ~* {- _* W+ ]$ J) P& n
5. 
   : B- O9 ?! ?# Y0 S- f
6. Server：
   
7. #include <winsock2.h>
   
8. #pragma comment(lib, "WS2_32.lib")
   * I3 E  r! _, K# [# N8 M
9. 
   ' @. f$ {- m9 k( u7 [7 p* H
10. #include <stdio.h>
    
11. void main()
    1 \8 t7 m& R# T1 a
12. {
    - C- j$ u: Z- O; @
13.     WORD wVersionRequested;//版本号
    5 R7 i) D+ w9 |( @/ a7 ]# S
14.     WSADATA wsaData;
    * H# N! O8 J  s4 p
15.     int err;
    
16. 
    
17.     wVersionRequested = MAKEWORD(2, 2);//2.2版本的套接字
    
18.     //加载套接字库,如果失败返回
    5 Q3 l. c" b2 l) }$ G. r
19.     err = WSAStartup(wVersionRequested, &wsaData);
    
20.     if (err != 0)
    
21.     {
    
22.         return;
    8 _: z5 ~6 ~0 I7 ~$ W3 f+ |
23.     }
    
24. 
    ( S' E* q. X" `! z
25.     //判断高低字节是不是2,如果不是2.2的版本则退出
    
26.     if (LOBYTE(wsaData.wVersion) != 2 ||
    
27.          
    ; Z( f" z8 }) O8 Q7 N! d
28.         HIBYTE(wsaData.wVersion) != 2)
    
29.          
    : N( E, Z8 ?5 T9 U' n
30.     {
    
31.         return;
    
32.     }
    
33.      
    
34.          //创建流式套接字,基于TCP(SOCK_STREAM)
    ) Z. z: d0 @- R. }& k  M/ _
35. 
    - ?+ K0 q3 J, a9 r; d5 N
36.          SOCKET socSrv = socket(AF_INET, SOCK_STREAM, 0);
    
37. 
    2 I: R9 q5 x) O
38.          //Socket地址结构体的创建
    
39. 
    , i  C. H$ f3 K2 U
40.          SOCKADDR_IN addrSrv;
    4 ?9 S3 e. B$ G* ~6 E. z* n
41. 
    
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);
    4 ~" y* b+ k( {2 ^3 G
45.         //指定端口号,除sin_family参数外,其它参数都是网络字节序,因此需要转换
    " D( O" B  B3 V4 |, b4 ?6 F% e/ _  ^
46. 
    
47.          //将套接字绑定到一个端口号和本地地址上
    4 {' I% E9 m' G# W4 B" `
48.          bind(socSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));//必须用sizeof，strlen不行
    ' F% e; @* k- g8 Z  I! {
49. 
    
50.          listen(socSrv, 5);
    4 u/ R8 o; T* D9 g" e+ ]" g: U
51.          
    2 O: G2 l3 Q! D' ]1 h( j- i
52.          SOCKADDR_IN addrClient;//字义用来接收客户端Socket的结构体
    9 g% g# X+ e; j/ |
53. 
    4 A% W+ @* {2 Q' U* b8 ?5 i
54.          int len = sizeof(SOCKADDR);//初始化参数,这个参数必须进行初始化，sizeof
    6 m1 w7 g1 j8 c8 n% w# {0 ]8 y
55. 
    
56.          //循环等待接受客户端发送请求
    5 p. r2 D, i- M6 n1 M# }, u  j
57. 
    & `4 d0 x% `* t: C7 X4 S
58.          while (1)
    
59.          {
    " o; S  V. w$ i) S  O
60.                    //等待客户请求到来；当请求到来后，接受连接请求，
    0 L  q+ H* @5 `
61. 
    
62.                    //返回一个新的对应于此次连接的套接字（accept）。
    : Z/ T5 K+ x- c% T
63.                    //此时程序在此发生阻塞
    
64. 
    
65.                    SOCKET sockConn = accept(socSrv, (SOCKADDR*)&addrClient, &len);
    
66. 
    * [  U, L0 m, ?% O2 q9 G
67.                    char sendBuf[100];
    
68. 
    
69.                    sprintf(sendBuf, "Welcome %s to JoyChou",
    
70. 
    5 ]- @% d3 X/ ]& z4 l2 ]: ~
71.                             inet_ntoa(addrClient.sin_addr));//格式化输出
      v( _( c, Q. P6 m* E* b' c! @
72. 
    
73.                    //用返回的套接字和客户端进行通信
    
74. 
    
75.                    send(sockConn, sendBuf, strlen(sendBuf)+1, 0);//多发送一个字节
    
76. 
    
77.                    //接收数据
    6 r. h) {- d7 y/ G: g( I
78. 
    
79.                    char recvBuf[100];
    - H8 m: g" s+ M' o7 _! a$ O' k
80. 
    * F* v; F' r* O+ R" S/ T5 j) u
81.                    recv(sockConn, recvBuf, 100, 0);
    ( ?8 ]- j! K+ E. q& b% R5 p, k# @
82. 
    
83.                    printf("%s\n", recvBuf);
    
84.                    closesocket(sockConn);
    
85. 
    " S1 C- n" [8 D
86.          }
    
87. }
      ^& l3 ?7 E- F/ ^! |. Y  J
88. 
    
89. 
      A3 M% ]- y' U( i2 v  [
90. Client：
    + y; ~! f$ `# J$ y! g/ U$ X% p
91. 
    
92. #include <winsock2.H>
    ( l: J( V/ n+ E& O$ Y) K: d
93. #pragma comment(lib, "Ws2_32.lib")
    
94. #include <stdio.h>
    # c1 x) W' b) I/ j5 C' ~
95. #include <string.h>
    
96. 
    
97. void main()
    
98. {   
    : o( Y8 {: J; @; k% @1 \
99.     WORD wVersionRequested;
    : l/ Q' k  D: T2 i9 g
100.     WSADATA wsaData;
     $ B& c& K" A# @3 i% H/ {0 Q) I# {+ q
101.     int err;
     9 |& b" A/ K. \# k8 K% r
102.      
     7 ~9 K* \4 x; K; a1 x
103.     wVersionRequested = MAKEWORD( 2, 2 );
     " w% h8 \: c- A  u, D) `
104.      
     4 f; V- e5 m- A
105.     err = WSAStartup( wVersionRequested, &wsaData );
     
106.     if ( err != 0 ) {
     
107.          
     
108.         return;
     
109.     }
     
110.      
     9 ?  w( ?0 ~+ @2 o& r! j
111.      
     1 t) r9 h& y" {, P8 {9 d
112.     if ( LOBYTE( wsaData.wVersion ) != 2 ||
     
113.         HIBYTE( wsaData.wVersion ) != 2 )
     * I9 o5 ]  y% m) E6 L- E
114.     {
     " ?3 O/ f3 S* F2 K6 w6 E
115.          
     
116.         WSACleanup( );
     
117.         return;
     
118.     }
     
119.     SOCKET socketClient = socket(AF_INET, SOCK_STREAM, 0);
     : W' t: j8 J' N7 q9 Z4 E
120.     SOCKADDR_IN addrSrv;
     
121.     addrSrv.sin_family = AF_INET;
     
122.     addrSrv.sin_port = htons(6000);
     
123.     addrSrv.sin_addr.S_un.S_addr = inet_addr("192.168.1.101");//服务器端的IP地址
     1 w  ~& O1 s6 Q3 ?
124.      
     
125.     connect(socketClient, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
     
126.     char recvBuf[256];
     
127.     char sendBuf[] = "This is Joychou";
     
128.     recv(socketClient, recvBuf, 256, 0);
     1 ]3 n+ W3 m0 L' N
129.     printf("%s\n", recvBuf);
     8 ?4 W; V( d% g8 Z6 }
130.     send(socketClient, sendBuf, strlen(sendBuf) + 1, 0);
     
131.     closesocket(socketClient);
     6 G% o. q0 c/ }
132.     WSACleanup();
     6 K) k: k- {- y, U
133.      
     
134. }

复制代码