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

admin

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

1. #include <winsock2.h>
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. 
   
5. #define DEFAULT_PORT       5150
   
6. #define DEFAULT_BUFFER     2048
   
7. 
   4 r, j# Z7 K9 M
8. char  szServer[128],
   
9.      szMessage[1024];
   + |6 w% \& M$ W/ C( x/ n
10. int  iPort    = DEFAULT_PORT;
    $ v/ S1 i$ y, @. f( O9 ?4 p0 k
11. 
    / C3 b  y9 o- Q8 V, q
12. int main()
    
13. {
    7 V9 Z4 O+ t# o( C  L" ]! n
14.    WSADATA      wsd;
    4 Y& F8 M* {0 ^& X
15.    SOCKET       sClient;
    
16.    char         szBuffer[DEFAULT_BUFFER];
    $ R8 _8 m# k2 b, f- k0 H9 A
17.    int          ret;
    
18.     struct sockaddr_in server;
    
19.     struct hostent    *host = NULL;
    
20.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    
21.     {
    
22.        printf("Failed to load Winsock library!\n");
    3 J" @( n; F5 a9 n! i" W* e
23.        return 1;
    + t0 U$ p1 Z; t
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);
    
29.     if (sClient == INVALID_SOCKET)
    
30.     {
    
31.        printf("socket() failed: %d\n", WSAGetLastError());
    
32.        return 1;
    
33.     }
    
34.    server.sin_family = AF_INET;
    , `$ w7 S7 W6 C
35.    server.sin_port = htons(iPort);
    
36.    server.sin_addr.s_addr = inet_addr("127.0.0.1");
    
37. 
    8 {! {% h0 e* e2 K: F3 a
38.     if (connect(sClient, (struct sockaddr *)&server,
    
39.        sizeof(server)) == SOCKET_ERROR)
    
40.     {
    $ B; p; `: H; k. E3 h3 O  N
41.        printf("connect() failed: %d\n", WSAGetLastError());
    7 ?  T& h4 B0 q9 O9 J
42.        return 1;
    ' {/ z- P4 \- i" ~# m
43.     }
    
44.     // Send and receive data
    
45.     ret = send(sClient, szMessage, strlen(szMessage), 0);
    - v) u* Y$ X: P0 i/ J  {
46.     if (ret == SOCKET_ERROR)
    9 f; D9 y  J3 ]! O
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);
    3 m! K- l' d& y/ ^( E  A8 s1 t# m" G
53.        if (ret == SOCKET_ERROR){
    
54.          printf("recv() failed: %d\n", WSAGetLastError());
    
55.        }
    3 w4 o# U. k7 J; {
56.        else{
    
57.          szBuffer[ret] = '\0';
    0 }7 ]0 u, E! O( X
58.          printf("RECV: '%s'\n",szBuffer);
    3 I0 `1 D  f9 Y1 g2 |
59.        }
      k( [4 G! j8 t  V/ _4 b  Y- y1 R5 R
60.     }
    
61.    closesocket(sClient);
    2 J2 f- Q9 V& J2 P2 v1 w8 l& N% j) t( g
62. 
    
63.    WSACleanup();
    ' o9 v$ L& m1 T
64.     return 0;
    1 P' \- E- e7 ^1 ^; }0 I1 r
65. }

复制代码

服务器程序:server.cpp
. w( [3 g7 R' |( Z! l

1. #include <winsock2.h>
   0 w# Q$ c" m/ Z% M. Y: g$ O& {
2. #include <stdio.h>
   
3. #include <stdlib.h>
   ! F+ A1 L+ p; B( Q0 [# L
4. 
   
5. #define DEFAULT_PORT       5150
   8 w# u# e6 P# J! c0 Y2 L
6. #define DEFAULT_BUFFER     4096
   ( T7 B% o: s. z, c6 U' Z: c
7. 
   
8. int   iPort     = DEFAULT_PORT;
   
9. char   szAddress[128];
   3 g6 H8 I- }* C5 [2 }6 Z
10. 
    ( z3 L- n- w7 {+ m3 i) l& T
11. DWORD WINAPI ClientThread(LPVOID lpParam)
    
12. {
    4 E6 G9 H% @) Y1 S+ U
13.    SOCKET       sock=(SOCKET)lpParam;
    . Y* [, x1 q2 E, c5 k' s! B: d
14.    char         szBuff[DEFAULT_BUFFER];
    - A- j9 M! N+ g) u; z
15.    int          ret;
    
16. 
    
17.    while(1)
    5 q( {$ ?; J9 ]0 I! j& G
18.     {
    
19.        ret = recv(sock, szBuff, DEFAULT_BUFFER, 0);
    . [1 ~* S' ^! ?
20.        if (ret == 0)
    
21.            break;
    
22.        else if (ret == SOCKET_ERROR)
    & t9 T. y3 I" Y# b% `
23.        {
    ' W- C& i2 h) F  a/ G
24.            printf("recv() failed: %d\n", WSAGetLastError());
    6 k+ K  A1 v- k3 h! F$ v0 z
25.            break;
    
26.        }
    . ~9 m6 {) {7 _. @/ Y
27.        szBuff[ret] = '\0';
    , O3 {0 @8 \; ]7 _6 @( J
28.        printf("RECV: '%s'\n", szBuff);
    # l. Z/ h: _: V/ a7 t$ |# _$ N
29.       if(strcmp(szBuff,"abc")==0){
    
30.          memcpy(szBuff,"Send the correct string!",25);
    4 a, s" c% @! Q/ j" c+ k9 B0 [. V
31.        }
    7 ]; v6 X# ]; G: \3 R3 H! g+ I
32.        else{
    9 c( x/ Z  r! N% s2 Z% Y; p5 b
33.          memcpy(szBuff,"Send the wrong string!",23);
      J& u5 a6 h  S- P0 a
34.        }
    
35.        ret = send(sock, szBuff, strlen(szBuff), 0);
    9 t; D: z' A/ I
36.        if (ret == SOCKET_ERROR){
    ; ]# l7 \3 ^3 s6 Q- H2 i# `6 r
37.          printf("send() failed: %d\n", WSAGetLastError());
    
38.        }
    
39.     }
    0 t5 v: x5 t5 v! |, d' L% D
40.     return 0;
    ' ^! Z/ U6 s) t! @5 O
41. }
    ' \; J! C3 Q3 A5 d$ ?# N0 H
42. 
    
43. int main()
    . K: G" f$ A5 e+ g
44. {
    
45.    WSADATA      wsd;
    
46.    SOCKET       sListen,
    
47.                  sClient;
    
48.    int          iAddrSize;
    . Z. F" ~, q  V: g# w" ]" {
49.    HANDLE       hThread;
    + C6 B' k8 d8 Q4 h4 x) q
50.    DWORD        dwThreadId;
    0 ~3 S3 h7 ]' F  d' i. u- \
51.     struct sockaddr_in local,
    
52.                       client;
    
53. 
    
54.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    
55.     {
    
56.        printf("Failed to load Winsock!\n");
    
57.        return 1;
    
58.     }
    1 `' j0 R0 B8 b$ J
59.     // Create our listening socket
    
60.     sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
    ( L1 Y9 s9 h) R7 s9 {
61.     if (sListen == SOCKET_ERROR)
    6 ~! Q1 W( v: T( a3 ~9 G  g" ]
62.     {
    7 h2 C% s( m( s; [7 E3 `
63.        printf("socket() failed: %d\n", WSAGetLastError());
    " H/ I* i* T: c
64.        return 1;
    5 z3 o8 c+ O3 D) d+ r) f
65.     }
    % y0 a& a$ N. |# m4 P. |7 b4 f/ M
66.    local.sin_addr.s_addr = htonl(INADDR_ANY);
    " ~' Y( |) s) Z; j; _  f& g' e- Z
67.    local.sin_family = AF_INET;
    1 ?6 y0 t7 R& W# n( e+ O6 l
68.    local.sin_port = htons(iPort);
    
69. 
    
70.     if (bind(sListen, (struct sockaddr *)&local,
    
71.            sizeof(local)) == SOCKET_ERROR)
    * [1 W, F! d# t' B9 h. A3 S4 B/ o) M
72.     {
    # g/ w1 L6 B4 r0 c" H. }5 K
73.        printf("bind() failed: %d\n", WSAGetLastError());
    # w& u  i" t5 T1 w9 [
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)
    
80.     {
    # X; w3 T  y' h+ u
81.        iAddrSize = sizeof(client);
    0 {) l2 R* c3 x- y$ J
82.        sClient = accept(sListen, (struct sockaddr *)&client,
    ; A* I) s1 N" V* m* x# Y3 ?
83.                        &iAddrSize);      
    3 P8 W- S. }0 y3 E( t: a8 B( x
84.        if (sClient == INVALID_SOCKET)
    ! n1 g& w% B9 W6 z" H7 {9 h
85.        {      
    
86.            printf("accept() failed: %d\n", WSAGetLastError());
    
87.            break;
    5 I* j: c9 b4 p) L  F& a
88.        }
    
89.        printf("Accepted client: %s:%d\n",
    
90.            inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    ( A7 @# [! V5 s- n4 q
91. 
    $ a0 d3 P0 B0 C! t
92.        hThread = CreateThread(NULL, 0, ClientThread,
    7 }$ Z' \& G) O( L! r
93.                    (LPVOID)sClient, 0, &dwThreadId);
    " P3 t/ B, D; d2 Y
94.        if (hThread == NULL)
    . ?$ T) `( {% z7 z# {9 ]7 q
95.        {
    " J8 H3 z% N2 m4 _" Y, @& e
96.            printf("CreateThread() failed: %d\n", GetLastError());
    & [  R/ \3 I& M0 O; ~" h
97.            break;
    
98.        }
    
99.        CloseHandle(hThread);
    - y1 o( H5 K* E9 f
100.     }
     
101.    closesocket(sListen);
     
102.    
     ( J% y: N6 x5 m1 T
103.    WSACleanup();
     
104.     return 0;
     
105. }

复制代码

* S0 \& w- S5 D9 h
5 ?$ p7 h: x9 F+ q# A( a5 G

) l7 n- F. s# U7 W6 k  t7 x8 Z

admin

1. 作为服务器，你要绑定【bind】到本地的IP地址上进行监听【listen】，但是你的机器上可能有多块网卡，也就有多个IP地址，这时候你要选择绑定在哪个IP上面，如果指定为INADDR_ANY，那么系统将绑定默认的网卡【即IP地址】。
   
2. 
   
3. 作为客户端，你要连接【connect】到远端的服务器，也是要指定远端服务器的（ip, port）对。
   
4. 当然，在这种情况下，不可能将IP地址指定为INADDR_ANY，系统会疯掉的。
   5 Y. H/ v$ z) d( I
5. 
   6 V1 X1 c: s2 z
6. Server：
   3 `6 _+ Z& x! Z# l( }% b
7. #include <winsock2.h>
   
8. #pragma comment(lib, "WS2_32.lib")
   ; t( k+ s+ {* n- V6 V* \
9. 
   
10. #include <stdio.h>
    
11. void main()
    
12. {
    3 A! C4 D1 T+ s/ z
13.     WORD wVersionRequested;//版本号
    / k& F( F$ C8 L+ r9 }
14.     WSADATA wsaData;
    
15.     int err;
    % f' D6 Q# m2 B* T
16. 
    
17.     wVersionRequested = MAKEWORD(2, 2);//2.2版本的套接字
    
18.     //加载套接字库,如果失败返回
    
19.     err = WSAStartup(wVersionRequested, &wsaData);
    
20.     if (err != 0)
    
21.     {
    6 W" V3 Y& J5 p3 _
22.         return;
    4 ?2 ]6 F- A4 D& S0 ^
23.     }
    
24. 
    
25.     //判断高低字节是不是2,如果不是2.2的版本则退出
    ! C* h  c5 g) U. w( z# L* ?1 S
26.     if (LOBYTE(wsaData.wVersion) != 2 ||
    
27.          
    6 i3 `. Y9 Q. Y, J4 a, y, E
28.         HIBYTE(wsaData.wVersion) != 2)
    
29.          
    
30.     {
    
31.         return;
    0 d9 t5 l& }: h! k
32.     }
    0 S( F" L) G0 }( j* \
33.      
    
34.          //创建流式套接字,基于TCP(SOCK_STREAM)
    ! n# W" r4 h2 d; B9 N! s  x
35. 
    
36.          SOCKET socSrv = socket(AF_INET, SOCK_STREAM, 0);
    2 \4 \; @" p) A. `
37. 
    
38.          //Socket地址结构体的创建
    & U! n# \3 \; t7 |# H
39. 
    6 O/ T9 K! e0 I( C3 ^
40.          SOCKADDR_IN addrSrv;
    
41. 
    
42.          addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);//转换Unsigned long型为网络字节序格
    2 S: q# X. p, d& B' h/ |: z
43.          addrSrv.sin_family = AF_INET;//指定地址簇
    * t  R9 S( o9 j% ]& }
44.          addrSrv.sin_port = htons(6000);
    : [' f% u2 D, ~7 I$ b7 k8 a4 s
45.         //指定端口号,除sin_family参数外,其它参数都是网络字节序,因此需要转换
    
46. 
    
47.          //将套接字绑定到一个端口号和本地地址上
    
48.          bind(socSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));//必须用sizeof，strlen不行
    
49. 
    6 l" z1 X& O  k
50.          listen(socSrv, 5);
    ( G" Q0 F2 J$ G
51.          
    
52.          SOCKADDR_IN addrClient;//字义用来接收客户端Socket的结构体
    4 D' D( n9 q# k% q
53. 
    8 ^0 m! `- F1 }
54.          int len = sizeof(SOCKADDR);//初始化参数,这个参数必须进行初始化，sizeof
    $ T, h5 q. m2 |6 R8 R5 ?
55. 
    3 x8 \/ f* _$ T- D2 J7 V" s' ^
56.          //循环等待接受客户端发送请求
    # x: ?7 B$ e& y$ ~/ y
57. 
    0 Q; E& s3 _6 r2 H/ E
58.          while (1)
    3 M2 n# [, L+ \6 s( h: H! v$ b$ _
59.          {
    - C( l1 T) t& P9 _9 I
60.                    //等待客户请求到来；当请求到来后，接受连接请求，
    % z7 r# e2 b' N" i
61. 
    0 K8 m$ b* f0 Z  \
62.                    //返回一个新的对应于此次连接的套接字（accept）。
    
63.                    //此时程序在此发生阻塞
    
64. 
    4 w, _* A7 @& U
65.                    SOCKET sockConn = accept(socSrv, (SOCKADDR*)&addrClient, &len);
    
66. 
    5 p, g3 _$ g' K4 q9 [
67.                    char sendBuf[100];
    
68. 
    8 n/ ~4 G( P5 X
69.                    sprintf(sendBuf, "Welcome %s to JoyChou",
    5 ]7 g: _& P. C! M# M$ i
70. 
    ! I7 X& T* a6 r2 G7 b* x* X
71.                             inet_ntoa(addrClient.sin_addr));//格式化输出
    ! ?/ {6 g' o" u( V- k0 O
72. 
    
73.                    //用返回的套接字和客户端进行通信
    
74. 
    
75.                    send(sockConn, sendBuf, strlen(sendBuf)+1, 0);//多发送一个字节
    5 Y: T1 c, d- c% o9 s
76. 
    / g9 p& ]; v& r# }. q0 C) J
77.                    //接收数据
    
78. 
    2 f' _3 [$ @4 O6 }4 h, `( G/ B7 n  B
79.                    char recvBuf[100];
    
80. 
    . t9 {( T$ n2 d0 L
81.                    recv(sockConn, recvBuf, 100, 0);
    
82. 
    : s9 F% l4 S* ?
83.                    printf("%s\n", recvBuf);
    
84.                    closesocket(sockConn);
    1 D. O$ j, |* X) [- O
85. 
    
86.          }
    + X" x) h- e, j, [
87. }
    0 j7 H# z) Z: n# e
88. 
    
89. 
    0 A- B1 M# G; q* _
90. Client：
    + g; ^: r+ j* H+ |6 ?- g9 {' G
91. 
    + i$ {' B7 {, c" P% D0 E+ t5 J
92. #include <winsock2.H>
    9 w% o+ A! L0 m1 @) L
93. #pragma comment(lib, "Ws2_32.lib")
    # o2 I) X7 Y" G  Q: I! |
94. #include <stdio.h>
    
95. #include <string.h>
    $ Z+ H  e# u: A/ R& ~) J& e+ f$ n
96. 
    4 l1 w8 t, x8 K: U
97. void main()
    
98. {   
    " e: d2 O1 \% n
99.     WORD wVersionRequested;
    
100.     WSADATA wsaData;
     
101.     int err;
     
102.      
     % g/ T9 F8 v- z' f9 \
103.     wVersionRequested = MAKEWORD( 2, 2 );
     ) {( q- Q# o0 c
104.      
     - B: A4 X# z$ P& h' ^( U" |6 ~
105.     err = WSAStartup( wVersionRequested, &wsaData );
     
106.     if ( err != 0 ) {
     
107.          
     . h* G1 x) C: T1 |
108.         return;
     . ~0 D* o# A, j/ T3 {+ m$ \
109.     }
     
110.      
     
111.      
     & |+ x! ?; T* }0 H" |
112.     if ( LOBYTE( wsaData.wVersion ) != 2 ||
     3 c0 J7 N' |' q; G& C6 l4 U
113.         HIBYTE( wsaData.wVersion ) != 2 )
     0 P4 Q/ y3 T! D8 Q* i: f/ R. E' E
114.     {
     
115.          
     8 P# N) S% X1 C" O* z) c! H
116.         WSACleanup( );
     * k; V& N& d  Q$ i' @
117.         return;
     
118.     }
     
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);
     # Z; C3 _6 V* I; _1 @9 c* |! ?
123.     addrSrv.sin_addr.S_un.S_addr = inet_addr("192.168.1.101");//服务器端的IP地址
     
124.      
     % s2 }4 P/ m5 ]$ S( u) ^* _3 M' `; \
125.     connect(socketClient, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
     
126.     char recvBuf[256];
     4 @' M! C/ c# L$ g& E1 t4 V% [0 A) I
127.     char sendBuf[] = "This is Joychou";
     ; t, ~" y/ t' O# R# }0 H6 k# _. L
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.      
     
134. }

复制代码

5 p' _$ Y2 Y3 R