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

admin

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

1. #include <winsock2.h>
   . E! |- B$ ^  \! A( ^
2. #include <stdio.h>
   * ]7 B) _# W- y) z8 J, i( m6 B
3. #include <stdlib.h>
   
4. 
   . s' x. f3 ]2 p/ y
5. #define DEFAULT_PORT       5150
   
6. #define DEFAULT_BUFFER     2048
   5 r+ O/ x1 U: |" e' D1 a. d2 U
7. 
   
8. char  szServer[128],
   
9.      szMessage[1024];
   0 g  U; q2 G1 v) G3 ]9 V% _0 {/ M
10. int  iPort    = DEFAULT_PORT;
    # r2 _: P3 ^' b
11. 
    1 a7 o1 m) T4 k& ~" a8 U/ R
12. int main()
    
13. {
    
14.    WSADATA      wsd;
    
15.    SOCKET       sClient;
    
16.    char         szBuffer[DEFAULT_BUFFER];
    % `. b9 R1 }0 d8 c" `4 T
17.    int          ret;
    7 r- B/ Y, _# \' d
18.     struct sockaddr_in server;
    - j7 z2 {  v  y0 h
19.     struct hostent    *host = NULL;
    8 O% v0 B/ Y# \3 c' q7 _: \) ~
20.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    
21.     {
    
22.        printf("Failed to load Winsock library!\n");
    + ^$ [; `* b' h1 c
23.        return 1;
    2 C. ?1 d/ Z7 y' u1 d3 Q6 j# F4 k
24.     }
    
25.    printf("Enter a string to send to server:\n");
    
26.    gets(szMessage);
    
27.     // Create the socket, and attempt to connect to the server
    
28.     sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    , p; ?2 x4 H5 p$ T$ O, j
29.     if (sClient == INVALID_SOCKET)
    , r% g% p1 |3 f4 |! }. r7 [
30.     {
    
31.        printf("socket() failed: %d\n", WSAGetLastError());
    - d5 r$ H0 d; d2 C
32.        return 1;
    % ~' W; \0 k8 f, y) B0 j( n
33.     }
    1 a4 F1 g$ U9 t' E$ I
34.    server.sin_family = AF_INET;
    
35.    server.sin_port = htons(iPort);
    
36.    server.sin_addr.s_addr = inet_addr("127.0.0.1");
    ( F3 a4 d% k8 _/ v5 E
37. 
    # g, y: R9 K; `: ?( s( n
38.     if (connect(sClient, (struct sockaddr *)&server,
    8 F1 C7 x( [6 x7 d
39.        sizeof(server)) == SOCKET_ERROR)
    
40.     {
    
41.        printf("connect() failed: %d\n", WSAGetLastError());
    8 W1 }$ D; T5 i
42.        return 1;
    
43.     }
      m; W6 D: T7 d
44.     // Send and receive data
    ) ~; O% t$ w' f
45.     ret = send(sClient, szMessage, strlen(szMessage), 0);
    / h: o  v5 N0 \( s
46.     if (ret == SOCKET_ERROR)
    ; ^$ a5 I9 z* e+ ]% Y" Z0 A$ K2 z
47.     {
    
48.        printf("send() failed: %d\n", WSAGetLastError());
    . l3 y: b  F) I! f8 R) `) D
49.     }
    ; [8 U% D7 N- \! }% {9 x
50.     else{
    & ~8 n8 k1 d- {/ C/ l0 |6 {$ \
51.        printf("Send '%s' \n", szMessage);
    6 S7 s9 |" K) D
52.        ret = recv(sClient, szBuffer, DEFAULT_BUFFER, 0);
    
53.        if (ret == SOCKET_ERROR){
    " ?7 v/ [% Y, X" n  ?
54.          printf("recv() failed: %d\n", WSAGetLastError());
    
55.        }
    ; w( M/ P& n9 ]  K' w% d( Z
56.        else{
    
57.          szBuffer[ret] = '\0';
    0 d5 {1 m5 z. c7 T# ~4 r* V6 l
58.          printf("RECV: '%s'\n",szBuffer);
    & R3 t5 Z' V; s. v0 p6 k& H$ [
59.        }
    
60.     }
    & \# R; k& D7 t: v" T- j
61.    closesocket(sClient);
    
62. 
    ) A* [/ e9 U: x
63.    WSACleanup();
    ! V8 z6 K: I) Z  j
64.     return 0;
    ' ^: d$ D' Y& E2 f/ S
65. }

复制代码

服务器程序:server.cpp
1 T' _4 _5 W3 l$ x/ P+ |

1. #include <winsock2.h>
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   : g0 v/ ?2 r6 q$ L5 _
4. 
   ! Q. G' ^; Z% V" s# z! ]
5. #define DEFAULT_PORT       5150
   ( ?- E, G. @0 m# n7 A
6. #define DEFAULT_BUFFER     4096
   , S1 s( ]+ ~6 Q% E
7. 
   
8. int   iPort     = DEFAULT_PORT;
   5 u; O1 }) \1 d6 u
9. char   szAddress[128];
   ) @+ f: A9 |5 r$ n  I
10. 
    + V1 R8 w. B4 d9 `
11. DWORD WINAPI ClientThread(LPVOID lpParam)
    + ~7 _% i' X$ j3 z: H1 W/ b
12. {
    
13.    SOCKET       sock=(SOCKET)lpParam;
    + [. P# e2 i( f# c+ k5 I
14.    char         szBuff[DEFAULT_BUFFER];
    
15.    int          ret;
    : i/ t6 A5 ]. v6 g. C
16. 
    / v9 E0 v( a2 s/ X5 `0 L
17.    while(1)
    
18.     {
    ( _) f' u: S9 q& x, w
19.        ret = recv(sock, szBuff, DEFAULT_BUFFER, 0);
    
20.        if (ret == 0)
    2 x% u) S4 ^- _" d
21.            break;
    
22.        else if (ret == SOCKET_ERROR)
    6 L# `! U6 h5 m+ P. o6 @8 O
23.        {
    8 J/ h) }9 l" P) r& G( q4 \# [
24.            printf("recv() failed: %d\n", WSAGetLastError());
    
25.            break;
    # P3 @9 R' v% ]+ p: |! e- ]. I
26.        }
    / G4 z7 p0 @- l) t' T1 s
27.        szBuff[ret] = '\0';
    6 a! X- z% w9 N) M) d
28.        printf("RECV: '%s'\n", szBuff);
    * {2 g  R1 z- l/ U# B. Y+ W
29.       if(strcmp(szBuff,"abc")==0){
    , A; }9 o" x+ L' N
30.          memcpy(szBuff,"Send the correct string!",25);
    4 r6 o1 Z% f2 Q0 R
31.        }
    / ]$ U& f2 E* K- p
32.        else{
    + X# N9 [. x- {+ x! |6 N. U
33.          memcpy(szBuff,"Send the wrong string!",23);
    : |% W" P% O" d' E- y
34.        }
    
35.        ret = send(sock, szBuff, strlen(szBuff), 0);
    
36.        if (ret == SOCKET_ERROR){
    , H' n' @0 G" [: I. [
37.          printf("send() failed: %d\n", WSAGetLastError());
    " g/ W0 F! _" L* B4 Q1 z" R5 |
38.        }
    
39.     }
    2 K* Q5 V0 G0 j3 \, H8 ?/ v5 Q
40.     return 0;
    - z; |/ n  f/ _, T( C$ p8 E" A
41. }
    
42. 
    
43. int main()
    
44. {
    
45.    WSADATA      wsd;
    
46.    SOCKET       sListen,
    3 K+ E* h+ t9 f1 c6 G3 v$ ~
47.                  sClient;
    
48.    int          iAddrSize;
    9 M# a* I) \9 [4 o9 c. l
49.    HANDLE       hThread;
    
50.    DWORD        dwThreadId;
    
51.     struct sockaddr_in local,
    + A8 {$ K; z' o3 _5 l
52.                       client;
    5 D- v  D& V6 w: q
53. 
    " b7 ^! ]. j/ c& H1 G
54.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    2 R% ]' \1 \1 u8 ~. d2 e' _3 U, f) w
55.     {
    6 ]3 I  Y8 |' z( h
56.        printf("Failed to load Winsock!\n");
    
57.        return 1;
    5 B+ R3 V0 b8 _# {, u- T1 R8 k
58.     }
    0 ]$ F7 }( ]; j' u+ E' Q
59.     // Create our listening socket
    
60.     sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
    
61.     if (sListen == SOCKET_ERROR)
    * A+ A+ }$ ~' S! s# R
62.     {
    & d. c% z" u7 b3 d! @( n
63.        printf("socket() failed: %d\n", WSAGetLastError());
      @0 A  ^$ x3 }- G% C# x
64.        return 1;
    ' K6 `$ _+ E5 ~0 F6 }( s
65.     }
    
66.    local.sin_addr.s_addr = htonl(INADDR_ANY);
    - V! p0 D! E; I6 l: h
67.    local.sin_family = AF_INET;
    
68.    local.sin_port = htons(iPort);
    * X( n( @6 d+ O2 h
69. 
    ( F) e- [/ Z4 M, h+ y
70.     if (bind(sListen, (struct sockaddr *)&local,
    
71.            sizeof(local)) == SOCKET_ERROR)
    0 b& H, Q2 u& L5 n: a. o1 y  I
72.     {
    + ], X5 w  Q& @% D
73.        printf("bind() failed: %d\n", WSAGetLastError());
    - h4 \+ T' i! A
74.        return 1;
    % U8 C4 K% \% J, ^
75.     }
    
76.    listen(sListen, 8);
    9 i: f% {3 g' Y  Q: [' E
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)
    
80.     {
    
81.        iAddrSize = sizeof(client);
    
82.        sClient = accept(sListen, (struct sockaddr *)&client,
    
83.                        &iAddrSize);      
    
84.        if (sClient == INVALID_SOCKET)
    ) E7 s% U, k' |, \( C2 N4 s9 }3 r
85.        {      
    . a3 n1 s" V4 D, ~: z) g4 B
86.            printf("accept() failed: %d\n", WSAGetLastError());
    , f' K1 z% H" O4 c* @8 U- e
87.            break;
    
88.        }
    
89.        printf("Accepted client: %s:%d\n",
    
90.            inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    9 e6 j9 `$ i' f
91. 
    
92.        hThread = CreateThread(NULL, 0, ClientThread,
    
93.                    (LPVOID)sClient, 0, &dwThreadId);
    ( x; v  _& B% d5 M$ L- O, K! c
94.        if (hThread == NULL)
    
95.        {
    . ^+ Y0 @% W, G
96.            printf("CreateThread() failed: %d\n", GetLastError());
    
97.            break;
    & i' z5 O( v4 i+ {3 m
98.        }
    
99.        CloseHandle(hThread);
    
100.     }
     4 e; ]0 E  P5 O1 C. l
101.    closesocket(sListen);
     
102.    
     
103.    WSACleanup();
     
104.     return 0;
     : p0 E1 C+ b: q( S2 U3 ~
105. }

复制代码

2 l& B7 ]4 C. g3 \



' T9 r: c5 ~/ a: s

admin

1. 作为服务器，你要绑定【bind】到本地的IP地址上进行监听【listen】，但是你的机器上可能有多块网卡，也就有多个IP地址，这时候你要选择绑定在哪个IP上面，如果指定为INADDR_ANY，那么系统将绑定默认的网卡【即IP地址】。
   ! p% E' Q+ M7 H
2. 
   
3. 作为客户端，你要连接【connect】到远端的服务器，也是要指定远端服务器的（ip, port）对。
   3 b4 |: a! u4 x1 u6 Q; o* Q* z& b; m/ {
4. 当然，在这种情况下，不可能将IP地址指定为INADDR_ANY，系统会疯掉的。
   
5. 
   
6. Server：
   ) g, P8 y% C5 n. G8 G
7. #include <winsock2.h>
   . [; G% v+ K  s
8. #pragma comment(lib, "WS2_32.lib")
   
9. 
   ' {7 l! R% b% w$ _+ j& q# o
10. #include <stdio.h>
    + o  I1 @+ M7 N/ l9 J
11. void main()
    
12. {
    
13.     WORD wVersionRequested;//版本号
    " q2 o% S7 Y: q9 z
14.     WSADATA wsaData;
    
15.     int err;
    $ d3 h6 k4 |# R0 E  Y7 f
16. 
    , q6 d4 h9 i: ^2 h* L9 m
17.     wVersionRequested = MAKEWORD(2, 2);//2.2版本的套接字
    
18.     //加载套接字库,如果失败返回
    : B; |& t: T0 {' q1 Q! ^
19.     err = WSAStartup(wVersionRequested, &wsaData);
    ; S, s" e$ u* d4 {
20.     if (err != 0)
    
21.     {
      a# w4 n/ T* |0 V- x5 _
22.         return;
    
23.     }
    
24. 
    
25.     //判断高低字节是不是2,如果不是2.2的版本则退出
    ' ~7 g* e# K) o! V" f
26.     if (LOBYTE(wsaData.wVersion) != 2 ||
    . f$ x, T. r1 z' a' R
27.          
    
28.         HIBYTE(wsaData.wVersion) != 2)
    
29.          
    
30.     {
    & q7 j) ?- q: M- }( p7 D
31.         return;
    5 J1 I; Y& l; l- K( l& K  a
32.     }
    ' W/ u; H& P- x; c7 }( I/ s% [
33.      
    . U* `9 p; f3 F" U" [) o
34.          //创建流式套接字,基于TCP(SOCK_STREAM)
    ) a- r& F: f: }
35. 
    
36.          SOCKET socSrv = socket(AF_INET, SOCK_STREAM, 0);
    
37. 
    
38.          //Socket地址结构体的创建
    
39. 
      N; }7 u/ n- {/ Z/ V9 h( o
40.          SOCKADDR_IN addrSrv;
    ! E6 F" p6 A/ \# `: o0 k& R
41. 
    - c5 o! W! X5 D9 u1 [2 x
42.          addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);//转换Unsigned long型为网络字节序格
    0 `# f* i& d, Y& x
43.          addrSrv.sin_family = AF_INET;//指定地址簇
    + B& c, Y9 l$ H4 g' l+ l  |$ f
44.          addrSrv.sin_port = htons(6000);
    
45.         //指定端口号,除sin_family参数外,其它参数都是网络字节序,因此需要转换
    
46. 
    
47.          //将套接字绑定到一个端口号和本地地址上
    
48.          bind(socSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));//必须用sizeof，strlen不行
    7 F& n# H6 _4 l3 _& V8 N
49. 
    3 a6 T4 o/ n) x
50.          listen(socSrv, 5);
    : T, g& b6 n# b$ X
51.          
    
52.          SOCKADDR_IN addrClient;//字义用来接收客户端Socket的结构体
    
53. 
    , n; z' f/ a; v: D
54.          int len = sizeof(SOCKADDR);//初始化参数,这个参数必须进行初始化，sizeof
    " f" [8 S, Q1 c- p. @# N
55. 
    
56.          //循环等待接受客户端发送请求
    
57. 
    
58.          while (1)
    
59.          {
    : e9 I! k1 D5 m: i  i) y8 C  U
60.                    //等待客户请求到来；当请求到来后，接受连接请求，
    . T* E6 T* r! |& I0 B1 V6 `
61. 
    
62.                    //返回一个新的对应于此次连接的套接字（accept）。
    
63.                    //此时程序在此发生阻塞
    5 J5 [' t5 E. Z6 ~8 [
64. 
    * L6 X. P3 J0 i5 j+ [& J4 I' Z
65.                    SOCKET sockConn = accept(socSrv, (SOCKADDR*)&addrClient, &len);
    ! J- W- S0 I2 K' l' n
66. 
    
67.                    char sendBuf[100];
    . Y# m7 @7 B. I2 x0 G( k# U
68. 
    
69.                    sprintf(sendBuf, "Welcome %s to JoyChou",
    1 K1 B! ?  i& B
70. 
    
71.                             inet_ntoa(addrClient.sin_addr));//格式化输出
    
72. 
    5 H9 z) k% G7 {4 s# O% u
73.                    //用返回的套接字和客户端进行通信
    " g" F1 t( U% L0 p
74. 
    
75.                    send(sockConn, sendBuf, strlen(sendBuf)+1, 0);//多发送一个字节
    + e$ x( Y# Q. ]
76. 
    
77.                    //接收数据
    ; [8 _) y; n. z$ v
78. 
    
79.                    char recvBuf[100];
    
80. 
    
81.                    recv(sockConn, recvBuf, 100, 0);
      E1 r. Y: L! k8 q: K1 f0 e' M0 K9 m
82. 
    
83.                    printf("%s\n", recvBuf);
    
84.                    closesocket(sockConn);
    
85. 
    
86.          }
    $ H4 x- p4 X$ j1 H5 v# g) @  R
87. }
      W5 _6 |5 ?3 {& q  l3 O
88. 
    7 V9 N2 N2 a8 g5 f
89. 
    # [; {( n- I7 A8 `; w. c* W
90. Client：
    
91. 
    
92. #include <winsock2.H>
    
93. #pragma comment(lib, "Ws2_32.lib")
    4 Y! t7 @7 k1 q; _: Y5 d  w) B
94. #include <stdio.h>
    
95. #include <string.h>
    
96. 
    , e8 H2 b- W0 W6 x8 ~; D% S: N
97. void main()
    
98. {   
    
99.     WORD wVersionRequested;
    $ ?) U5 d5 m2 n+ R! {6 n# }
100.     WSADATA wsaData;
     , o# W$ {! T" r* K
101.     int err;
     ) S1 C& A1 N* g& ^) T& d4 V
102.      
     3 y7 r0 \% q% \
103.     wVersionRequested = MAKEWORD( 2, 2 );
     
104.      
     
105.     err = WSAStartup( wVersionRequested, &wsaData );
     
106.     if ( err != 0 ) {
     0 c( v+ {% G8 l  y. }$ `
107.          
     
108.         return;
     9 B! m, k* m5 D6 m- n  E: z! m
109.     }
     , ]4 p3 i# ~3 w% A$ Z
110.      
     
111.      
     ( q3 ]! L2 j* ^# `
112.     if ( LOBYTE( wsaData.wVersion ) != 2 ||
     
113.         HIBYTE( wsaData.wVersion ) != 2 )
     
114.     {
     
115.          
     , m/ r- K9 `. A( z% u- G) @
116.         WSACleanup( );
     
117.         return;
     
118.     }
     4 s& `9 D3 @! @$ X# z7 z6 _
119.     SOCKET socketClient = socket(AF_INET, SOCK_STREAM, 0);
     
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地址
     
124.      
     
125.     connect(socketClient, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
     
126.     char recvBuf[256];
     9 j; k% z/ K& l" K! B' p  z
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);
     
131.     closesocket(socketClient);
     
132.     WSACleanup();
     
133.      
     2 z" P  k' U/ \$ c5 s: ?
134. }

复制代码

5 {- Q1 V. |2 {: k  |