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

admin

程序很简单，windows环境下的，客户端和服务器程序都在本机运行，在客户端输入发送给服务器的字符串，服务器收到字符串后会打印出来，同时与"abc"比较，与"abc"相同就会返给客户端，输入的是正确的，不同会告诉客户端输入时错误的。
/ E3 O0 E+ h1 N客户端程序：client.cpp

1. #include <winsock2.h>
   
2. #include <stdio.h>
   1 t' d9 `) n$ p
3. #include <stdlib.h>
   4 L4 U, S& ^# j! V. i( Q- U1 i
4. 
   - ]$ t! y) l5 J8 D0 @
5. #define DEFAULT_PORT       5150
   
6. #define DEFAULT_BUFFER     2048
   : L" O3 t) \/ r
7. 
   
8. char  szServer[128],
   3 _0 d  b" P5 O2 `" e
9.      szMessage[1024];
   
10. int  iPort    = DEFAULT_PORT;
    
11. 
    6 k5 W/ w6 \; x8 o
12. int main()
    
13. {
    
14.    WSADATA      wsd;
    
15.    SOCKET       sClient;
    
16.    char         szBuffer[DEFAULT_BUFFER];
    ! }& ?* R+ P( J# m
17.    int          ret;
    " W0 a$ _, F: r/ z7 I) Q$ e1 p
18.     struct sockaddr_in server;
    
19.     struct hostent    *host = NULL;
    
20.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    ' e# s* R( P$ G& z1 C6 x8 f7 o
21.     {
    
22.        printf("Failed to load Winsock library!\n");
    
23.        return 1;
    1 n7 b' D6 s7 m9 s1 n- T8 t
24.     }
    0 `6 T; V7 _3 ]6 V% K! E. ]( a/ o
25.    printf("Enter a string to send to server:\n");
    
26.    gets(szMessage);
      o. o4 @% D. e6 w+ R4 w
27.     // Create the socket, and attempt to connect to the server
    
28.     sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    
29.     if (sClient == INVALID_SOCKET)
    7 h  k8 w2 W) W: W( r* o; A3 d( X
30.     {
    " ^  l8 j6 @0 ]3 X. {( p* i0 I
31.        printf("socket() failed: %d\n", WSAGetLastError());
    / W, a0 l0 p9 z" P3 p8 s- T. X* f
32.        return 1;
    - J& l. ~5 [& V- J
33.     }
    
34.    server.sin_family = AF_INET;
    
35.    server.sin_port = htons(iPort);
    
36.    server.sin_addr.s_addr = inet_addr("127.0.0.1");
    1 F5 @, p) E( i3 e# W
37. 
    
38.     if (connect(sClient, (struct sockaddr *)&server,
    
39.        sizeof(server)) == SOCKET_ERROR)
    ; R- c; `$ u7 S& Q/ O
40.     {
    
41.        printf("connect() failed: %d\n", WSAGetLastError());
    , S$ i$ Q6 n! F% p- B9 o3 W
42.        return 1;
    
43.     }
    1 j- M, @' O8 t  j0 k
44.     // Send and receive data
    2 ?# y; R! f  p3 {
45.     ret = send(sClient, szMessage, strlen(szMessage), 0);
    
46.     if (ret == SOCKET_ERROR)
    4 q* T4 o/ a" C& f' k' u
47.     {
    
48.        printf("send() failed: %d\n", WSAGetLastError());
    4 K1 k: v: t( H3 l' `) S
49.     }
    
50.     else{
    ; a$ }6 p5 S/ K1 [2 \/ [
51.        printf("Send '%s' \n", szMessage);
    4 m( }5 V! P! N
52.        ret = recv(sClient, szBuffer, DEFAULT_BUFFER, 0);
    + f# Z) E& ?/ t3 I5 i, B1 F. Y" X
53.        if (ret == SOCKET_ERROR){
    # X5 C; |8 I% n6 m
54.          printf("recv() failed: %d\n", WSAGetLastError());
    8 T0 v$ F! R' Q0 h% g4 U
55.        }
    / [9 a+ h  G$ ?8 O. Q# @0 {
56.        else{
    0 U) j4 o% y: m3 l3 h
57.          szBuffer[ret] = '\0';
    
58.          printf("RECV: '%s'\n",szBuffer);
    
59.        }
    / Q3 X  B6 c+ P" y) R& _- m( |
60.     }
    2 x  G8 \: ?# o# _' H3 D9 l
61.    closesocket(sClient);
    # P7 J* ?3 R' A
62. 
    - |6 A$ I4 {4 u" Z7 }) S. Y
63.    WSACleanup();
    7 }# V: A$ V7 h4 {2 _! ?
64.     return 0;
    
65. }

复制代码

服务器程序:server.cpp
/ f* S/ X* M+ D# ^" ^# y

1. #include <winsock2.h>
   
2. #include <stdio.h>
   / A# S4 N/ @0 E+ ?' G$ I* Q/ \
3. #include <stdlib.h>
   
4. 
   
5. #define DEFAULT_PORT       5150
   
6. #define DEFAULT_BUFFER     4096
   # a7 X; L# x6 m
7. 
   1 C; s! @1 _" B7 s% [
8. int   iPort     = DEFAULT_PORT;
   9 N( F6 |6 \, W0 t8 c
9. char   szAddress[128];
   
10. 
    
11. DWORD WINAPI ClientThread(LPVOID lpParam)
    
12. {
    
13.    SOCKET       sock=(SOCKET)lpParam;
    
14.    char         szBuff[DEFAULT_BUFFER];
    
15.    int          ret;
      u8 j% C- D5 N$ G( I0 D; x
16. 
    
17.    while(1)
    0 ?# L: D% s; ?( x9 y
18.     {
    $ O( |* ^1 _2 G1 i
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());
    ! ~% _6 x; d1 U
25.            break;
    
26.        }
    
27.        szBuff[ret] = '\0';
    4 l' _+ j, H% P% n) q1 r
28.        printf("RECV: '%s'\n", szBuff);
    9 e0 [1 {# t7 Y& b! c
29.       if(strcmp(szBuff,"abc")==0){
    
30.          memcpy(szBuff,"Send the correct string!",25);
    
31.        }
    0 b, \% s! y" Y8 q4 o7 p9 Q2 ^. K: _
32.        else{
    
33.          memcpy(szBuff,"Send the wrong string!",23);
    
34.        }
      V! w( G1 t; C" ?4 Y
35.        ret = send(sock, szBuff, strlen(szBuff), 0);
    
36.        if (ret == SOCKET_ERROR){
    
37.          printf("send() failed: %d\n", WSAGetLastError());
    ; R5 G! z% R: ~2 Z3 l4 t
38.        }
    / C8 }* r6 c& c" S! V" F
39.     }
    * r+ f) w: Q) b
40.     return 0;
    
41. }
    
42. 
    
43. int main()
    : V9 J- t9 j" F6 u& S
44. {
    9 l1 W2 H4 I% R5 E
45.    WSADATA      wsd;
    
46.    SOCKET       sListen,
    4 O8 @  m" A/ l, V' w9 @  B/ T
47.                  sClient;
    7 o9 \3 J3 s( ]0 y
48.    int          iAddrSize;
    
49.    HANDLE       hThread;
    
50.    DWORD        dwThreadId;
    3 U, j* _6 r7 \9 X3 ^( y$ j
51.     struct sockaddr_in local,
    & U6 e- ^- G" C& N& u% E$ S) F
52.                       client;
    
53. 
    2 _2 z0 y8 ^1 a( p4 t) l' ]1 R8 g1 p
54.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    ; f+ ]! ^" O. @0 h
55.     {
    
56.        printf("Failed to load Winsock!\n");
    , W9 c8 p! }' s9 e+ ~0 v3 y# G$ s/ }
57.        return 1;
    + j5 \( f( d6 K( O% s& J9 y5 ?
58.     }
    
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());
      s: `( s( p) c5 o" G9 s5 a
64.        return 1;
    1 m: `8 E( n4 W9 B% b% }4 z
65.     }
    0 G: ?' G/ X# e( B8 a
66.    local.sin_addr.s_addr = htonl(INADDR_ANY);
    / ], J) Y# r& {! O0 ?
67.    local.sin_family = AF_INET;
    
68.    local.sin_port = htons(iPort);
    1 q- @' e; l, A! E8 q, v
69. 
    9 p( |# g9 u6 e2 ]
70.     if (bind(sListen, (struct sockaddr *)&local,
    
71.            sizeof(local)) == SOCKET_ERROR)
    , C9 @' ]. c6 a, s# p  M
72.     {
    
73.        printf("bind() failed: %d\n", WSAGetLastError());
    * w8 g; z8 i) b6 U* {& f
74.        return 1;
    & V9 t. ~% t- ?, z+ D' L8 c
75.     }
    ! ^/ m: R6 e% J1 D% @! w
76.    listen(sListen, 8);
    * r3 _7 l: P8 G* ^* U3 K/ r# d" U
77.     // In a continous loop, wait for incoming clients. Once one
    ! k' w$ |* Y9 p$ `: B0 }4 _- r# L
78.     // is detected, create a thread and pass the handle off to it.
    $ `! B5 i( S1 `/ r9 ?4 r# O
79.     while (1)
    , y  y$ E0 W8 T( T1 e
80.     {
    
81.        iAddrSize = sizeof(client);
    
82.        sClient = accept(sListen, (struct sockaddr *)&client,
    
83.                        &iAddrSize);      
    
84.        if (sClient == INVALID_SOCKET)
    
85.        {      
    6 f& O# |$ {" @9 n( B  Q: {
86.            printf("accept() failed: %d\n", WSAGetLastError());
    . l8 J9 A  K! R
87.            break;
    * g+ c; k8 J' f' _
88.        }
    ( |! g6 T8 \" v+ M
89.        printf("Accepted client: %s:%d\n",
    
90.            inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    7 \5 {$ K. [1 O0 N# W# L
91. 
    
92.        hThread = CreateThread(NULL, 0, ClientThread,
    
93.                    (LPVOID)sClient, 0, &dwThreadId);
    2 L, _! j* Y  j4 f; ~0 L1 v
94.        if (hThread == NULL)
    & C. T! W" A. K* H3 X
95.        {
    
96.            printf("CreateThread() failed: %d\n", GetLastError());
    
97.            break;
    
98.        }
    
99.        CloseHandle(hThread);
    ) g  V  g5 T# Z
100.     }
     
101.    closesocket(sListen);
     % |/ b+ D1 F! _% `
102.    
     
103.    WSACleanup();
     
104.     return 0;
     ) `4 o0 p  L# N* V( _9 W
105. }

复制代码

) n+ f- |# o0 i- b/ `; G( {+ L

; K  s6 ]% b0 X( N! H2 t

admin

1. 作为服务器，你要绑定【bind】到本地的IP地址上进行监听【listen】，但是你的机器上可能有多块网卡，也就有多个IP地址，这时候你要选择绑定在哪个IP上面，如果指定为INADDR_ANY，那么系统将绑定默认的网卡【即IP地址】。
   
2. 
   
3. 作为客户端，你要连接【connect】到远端的服务器，也是要指定远端服务器的（ip, port）对。
   
4. 当然，在这种情况下，不可能将IP地址指定为INADDR_ANY，系统会疯掉的。
   
5. 
   : i2 n; Z$ B2 V  P7 ]8 R( U0 l
6. Server：
   
7. #include <winsock2.h>
   
8. #pragma comment(lib, "WS2_32.lib")
   * _& B  @* o* z2 L; z" ~4 O8 O
9. 
   ; t: l! C9 k; f) i: }: \
10. #include <stdio.h>
    
11. void main()
    
12. {
    . p) W0 `: ^2 R1 k) R# g/ k8 i& Q
13.     WORD wVersionRequested;//版本号
    
14.     WSADATA wsaData;
    
15.     int err;
    3 m8 r/ D: {0 I3 J/ z  _9 L# D
16. 
    ) X. R; O0 q5 g" k( y8 m  v1 l4 l
17.     wVersionRequested = MAKEWORD(2, 2);//2.2版本的套接字
    
18.     //加载套接字库,如果失败返回
    
19.     err = WSAStartup(wVersionRequested, &wsaData);
    4 d+ R3 z1 y+ D; Q% D- t1 C
20.     if (err != 0)
    
21.     {
    ( e7 s! k5 t$ t! G
22.         return;
    
23.     }
    
24. 
    $ P& i  y" O' @0 Z2 g
25.     //判断高低字节是不是2,如果不是2.2的版本则退出
    ( k# c0 r5 R+ M6 ~7 m
26.     if (LOBYTE(wsaData.wVersion) != 2 ||
    # R' H9 O$ v. t3 X1 x
27.          
    0 X; G  y4 O# v
28.         HIBYTE(wsaData.wVersion) != 2)
    / D8 G5 W. S; z1 i+ E$ a
29.          
    9 o# p% N5 R9 {! |
30.     {
    ! v" ?! l4 F% N9 [1 d" Q( P2 v' s6 O
31.         return;
    
32.     }
    
33.      
    ( V  @  D* `0 g
34.          //创建流式套接字,基于TCP(SOCK_STREAM)
    
35. 
    - I) }( V+ |2 J4 i, l
36.          SOCKET socSrv = socket(AF_INET, SOCK_STREAM, 0);
    
37. 
    
38.          //Socket地址结构体的创建
    / M! {  Q* _2 N) E. |- ?0 ?
39. 
    
40.          SOCKADDR_IN addrSrv;
    
41. 
    
42.          addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);//转换Unsigned long型为网络字节序格
    
43.          addrSrv.sin_family = AF_INET;//指定地址簇
    ' p3 \' k" U: W7 n0 L- u
44.          addrSrv.sin_port = htons(6000);
    : W; g* C. p# ~$ Q4 M* A
45.         //指定端口号,除sin_family参数外,其它参数都是网络字节序,因此需要转换
    
46. 
    7 H0 ~( B8 E3 A% \! d% e
47.          //将套接字绑定到一个端口号和本地地址上
    
48.          bind(socSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));//必须用sizeof，strlen不行
    * W8 J- N. ^: t9 A4 F" P+ ?
49. 
    1 E- C; E2 r9 b* J1 o
50.          listen(socSrv, 5);
    8 `' B* a- E- s
51.          
    + _$ t3 I2 H8 J5 U5 w  J. V
52.          SOCKADDR_IN addrClient;//字义用来接收客户端Socket的结构体
    & R" o% Z. q7 C% i( A# U4 v. N- }
53. 
    3 f# W) Q- d( d3 X) _4 K
54.          int len = sizeof(SOCKADDR);//初始化参数,这个参数必须进行初始化，sizeof
    : R) M( D/ E  d5 ~
55. 
    8 f. A. D; s5 ]9 b4 Y: H0 Q
56.          //循环等待接受客户端发送请求
    & w0 j! E% C$ U; V
57. 
    
58.          while (1)
    & a" L: O9 @& R4 k! A) ]& w
59.          {
    7 @6 W2 K- q* {) Q) Q
60.                    //等待客户请求到来；当请求到来后，接受连接请求，
    + f1 f# L- g' _7 _
61. 
    
62.                    //返回一个新的对应于此次连接的套接字（accept）。
    9 W$ e; O) @% n; s+ z& h0 \" l
63.                    //此时程序在此发生阻塞
    
64. 
    
65.                    SOCKET sockConn = accept(socSrv, (SOCKADDR*)&addrClient, &len);
    
66. 
    
67.                    char sendBuf[100];
    
68. 
    
69.                    sprintf(sendBuf, "Welcome %s to JoyChou",
    5 N. T; I6 Y8 r" O: Y
70. 
    4 G: E) A+ q1 J& \5 z
71.                             inet_ntoa(addrClient.sin_addr));//格式化输出
    
72. 
    ; `6 ^2 ]9 g$ O  B
73.                    //用返回的套接字和客户端进行通信
    
74. 
    / h7 Z. F3 N% g' }1 o$ E& P
75.                    send(sockConn, sendBuf, strlen(sendBuf)+1, 0);//多发送一个字节
    8 U' I4 v8 w4 u; D2 _
76. 
    0 f$ C4 R# H' k
77.                    //接收数据
    : H, [3 W- x/ }6 U
78. 
    ; ^9 x$ L0 @( v+ Y& s- C+ V5 \
79.                    char recvBuf[100];
    , K0 n1 r# l0 \
80. 
    # `; G, t+ U* E4 o
81.                    recv(sockConn, recvBuf, 100, 0);
    ( D$ K* u. z4 ^9 c& r8 z
82. 
    
83.                    printf("%s\n", recvBuf);
    9 ^0 D9 @. d7 E( K& T4 R% o- o! \, @
84.                    closesocket(sockConn);
    
85. 
    ) q3 N" S! B2 N- S# |) g- F
86.          }
      l  E. e$ E' w8 B6 o
87. }
    8 C8 s! O* ~" C: k5 Y8 G3 J( `
88. 
    
89. 
    $ n1 n' z' w5 ^4 w; }
90. Client：
    
91. 
    + N/ {# S6 S( t4 ]9 ]
92. #include <winsock2.H>
    
93. #pragma comment(lib, "Ws2_32.lib")
    
94. #include <stdio.h>
    
95. #include <string.h>
    & d5 M: v) b0 L% ?: x- A2 R- c+ u
96. 
    
97. void main()
    % H; Y" m: ?* ~; Y7 Q0 u/ `
98. {   
    
99.     WORD wVersionRequested;
    
100.     WSADATA wsaData;
     3 Z% z) x4 h( H/ g$ O2 B
101.     int err;
     ' e! [% x9 ?( A" g# y, B- n
102.      
     & C" |, E9 T8 J# b
103.     wVersionRequested = MAKEWORD( 2, 2 );
     
104.      
     
105.     err = WSAStartup( wVersionRequested, &wsaData );
     
106.     if ( err != 0 ) {
     
107.          
     
108.         return;
       S0 E# k( I) P, z' a$ ]/ O
109.     }
     5 e! E( V: `6 d' G) E
110.      
     ! G3 H: B4 v! o% \( H! D- t5 k
111.      
     
112.     if ( LOBYTE( wsaData.wVersion ) != 2 ||
     
113.         HIBYTE( wsaData.wVersion ) != 2 )
     
114.     {
     , t& l  @: G# Q" n2 r* w
115.          
     
116.         WSACleanup( );
     
117.         return;
     ; |( v1 G; K% v1 q) E) n  y4 j
118.     }
     , B# G9 ]% T6 ]% j8 n3 a, {
119.     SOCKET socketClient = socket(AF_INET, SOCK_STREAM, 0);
     
120.     SOCKADDR_IN addrSrv;
     . ~7 G/ V; h3 ^, r( b
121.     addrSrv.sin_family = AF_INET;
     % Q3 K7 m! G1 Z7 j- o" m
122.     addrSrv.sin_port = htons(6000);
     
123.     addrSrv.sin_addr.S_un.S_addr = inet_addr("192.168.1.101");//服务器端的IP地址
     ) f4 L2 c' Z6 J. N2 V* L
124.      
     8 n* ]: \& R5 b; j
125.     connect(socketClient, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
     
126.     char recvBuf[256];
     
127.     char sendBuf[] = "This is Joychou";
     2 ]" M( G( y! N0 ?% H" G
128.     recv(socketClient, recvBuf, 256, 0);
     
129.     printf("%s\n", recvBuf);
     
130.     send(socketClient, sendBuf, strlen(sendBuf) + 1, 0);
     
131.     closesocket(socketClient);
     ( ~% _! K' w" T7 g
132.     WSACleanup();
     
133.      
     
134. }

复制代码

/ k$ l3 U: Z1 n' a4 l; M/ b
4 t4 r4 S& j7 _4 G9 u. ~8 M