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

admin

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

1. #include <winsock2.h>
   4 i$ b( }1 U/ @& \& M8 g& J3 k
2. #include <stdio.h>
   % l+ i* k4 Y) V$ K8 ~
3. #include <stdlib.h>
   
4. 
   
5. #define DEFAULT_PORT       5150
   . B( z% q' n8 m; b3 F& L1 }) [0 ~7 Q
6. #define DEFAULT_BUFFER     2048
   , @4 T9 z, u" t  g3 H/ K& L+ n
7. 
   
8. char  szServer[128],
   5 J0 S/ W0 {) e. O  I
9.      szMessage[1024];
   ; U/ [' `! X& T! s2 x- G( |
10. int  iPort    = DEFAULT_PORT;
    
11. 
    ) I- _9 Y9 h! G! k6 F
12. int main()
    ! X4 y+ d5 }; Y' v3 Z, l$ G0 D3 X
13. {
    
14.    WSADATA      wsd;
    
15.    SOCKET       sClient;
    4 B8 M9 b# `. H. Z% E3 e7 o+ N
16.    char         szBuffer[DEFAULT_BUFFER];
    
17.    int          ret;
    3 l2 t& t2 @3 w: N
18.     struct sockaddr_in server;
    
19.     struct hostent    *host = NULL;
    
20.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    
21.     {
    ! R/ D% n3 H" s, L1 ^4 l
22.        printf("Failed to load Winsock library!\n");
    ' X1 o' A3 M) g; F# E
23.        return 1;
    % q+ \9 X- b( s& v& g7 \7 v
24.     }
    7 e  i/ ~5 |1 ?+ E" ?8 v
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);
    / M3 h$ T0 I& j! T7 B( E% L- T* O
29.     if (sClient == INVALID_SOCKET)
    
30.     {
    3 J! Z  i* r3 y- D0 h+ f* `5 P
31.        printf("socket() failed: %d\n", WSAGetLastError());
    
32.        return 1;
    
33.     }
    
34.    server.sin_family = AF_INET;
    ; H/ H! t4 ?7 I* h; G- n2 a
35.    server.sin_port = htons(iPort);
    
36.    server.sin_addr.s_addr = inet_addr("127.0.0.1");
    9 i" H1 |1 Y# i) i: T
37. 
    1 L  a7 A3 |' }
38.     if (connect(sClient, (struct sockaddr *)&server,
    & n+ b: L( X& h0 D/ S  y3 l
39.        sizeof(server)) == SOCKET_ERROR)
    
40.     {
    * ^; P# Y1 N8 e! C5 N2 P6 T
41.        printf("connect() failed: %d\n", WSAGetLastError());
    
42.        return 1;
    + T) G3 j: |) g/ F: v' B. O
43.     }
    ) ~# `$ R" ]1 F5 S# b2 M/ Z- x/ H
44.     // Send and receive data
    , M2 M; c# b' l2 R7 r
45.     ret = send(sClient, szMessage, strlen(szMessage), 0);
    
46.     if (ret == SOCKET_ERROR)
    
47.     {
    8 d8 P! K; A6 w
48.        printf("send() failed: %d\n", WSAGetLastError());
    
49.     }
    
50.     else{
    
51.        printf("Send '%s' \n", szMessage);
    0 Z  ]& x. y7 T" i7 F
52.        ret = recv(sClient, szBuffer, DEFAULT_BUFFER, 0);
    
53.        if (ret == SOCKET_ERROR){
    
54.          printf("recv() failed: %d\n", WSAGetLastError());
    0 v; E* {2 k, e6 `& x! Z
55.        }
    5 F' ^+ c! O1 @/ Y% L: [: p4 w& ^
56.        else{
    # N* q- e! O$ ?% n! J# i# x8 c
57.          szBuffer[ret] = '\0';
    4 Q0 Y$ k: p$ @7 C0 s/ v
58.          printf("RECV: '%s'\n",szBuffer);
    
59.        }
    
60.     }
    
61.    closesocket(sClient);
    
62. 
    & o7 K: f7 V8 l
63.    WSACleanup();
    4 J5 f0 q$ I/ ^
64.     return 0;
    
65. }

复制代码

服务器程序:server.cpp
! m: g/ H4 Q( T  v

1. #include <winsock2.h>
   , i, |' m  W8 ^  L) j! }2 h6 p
2. #include <stdio.h>
   
3. #include <stdlib.h>
   6 N7 O$ O: c) o7 F4 a+ [0 N: ]
4. 
   4 I8 u' o9 L; C  t* X$ R" W: k
5. #define DEFAULT_PORT       5150
   # I; j6 p, ^4 N6 G& K  {
6. #define DEFAULT_BUFFER     4096
   - u/ h# c( q% G; k/ n
7. 
   8 v% O! \5 I* j, ^. w, X& s* n
8. int   iPort     = DEFAULT_PORT;
   
9. char   szAddress[128];
   9 I5 z' J) Q) \
10. 
    
11. DWORD WINAPI ClientThread(LPVOID lpParam)
    7 x6 w; h# t7 j/ e; X! Y8 N
12. {
    " a" ~/ i; s, s; n  ^- f! b! R" q
13.    SOCKET       sock=(SOCKET)lpParam;
    ) w9 T" V7 V) [- Y
14.    char         szBuff[DEFAULT_BUFFER];
    
15.    int          ret;
    
16. 
    2 g! A$ l2 P6 M1 C$ C! `
17.    while(1)
    
18.     {
    8 }' ]1 a/ i9 m* f4 S: c
19.        ret = recv(sock, szBuff, DEFAULT_BUFFER, 0);
    
20.        if (ret == 0)
    
21.            break;
    
22.        else if (ret == SOCKET_ERROR)
    * f2 {" H  L- x& i0 z; ^( J4 s
23.        {
    5 y/ u; y8 h6 _) Q
24.            printf("recv() failed: %d\n", WSAGetLastError());
    2 V1 L& ?; k1 w8 g# k/ n3 e
25.            break;
    2 [4 y' n' z5 l9 C2 y: R9 F
26.        }
    
27.        szBuff[ret] = '\0';
    
28.        printf("RECV: '%s'\n", szBuff);
    . J4 \4 Q7 @) [* n
29.       if(strcmp(szBuff,"abc")==0){
    7 ^1 \# Z( m- U% r2 ^
30.          memcpy(szBuff,"Send the correct string!",25);
    
31.        }
    0 u6 j  p3 C5 f. N2 ~
32.        else{
    1 j. l7 S: W* k( G
33.          memcpy(szBuff,"Send the wrong string!",23);
    
34.        }
    
35.        ret = send(sock, szBuff, strlen(szBuff), 0);
    ; t( Y) H* D1 N, c
36.        if (ret == SOCKET_ERROR){
    ) G7 ^3 h# j; Q7 u* ~- g
37.          printf("send() failed: %d\n", WSAGetLastError());
    , E/ d3 ~/ U& ?& S" Y  ]% U2 r
38.        }
    
39.     }
    # [0 J3 q  Z/ m8 @+ P0 _! U5 S: T
40.     return 0;
    
41. }
    
42. 
    8 K- A1 a' Z& l3 _
43. int main()
    7 h2 y( |3 @2 i. q# s' R0 c1 M8 s
44. {
    
45.    WSADATA      wsd;
    2 |, G$ B) c; `7 D: }5 l
46.    SOCKET       sListen,
    # u' c0 Y- n4 ?, F- \6 H
47.                  sClient;
    
48.    int          iAddrSize;
    1 ?$ q! i+ o! k. A
49.    HANDLE       hThread;
    
50.    DWORD        dwThreadId;
    
51.     struct sockaddr_in local,
    1 F; B4 G! o4 w
52.                       client;
    % H! A- P5 f2 q) Q/ C: g
53. 
    
54.     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
    
55.     {
    & X* C. D. t/ n  W* }
56.        printf("Failed to load Winsock!\n");
    
57.        return 1;
      w4 {. k, G6 z) f
58.     }
    
59.     // Create our listening socket
    
60.     sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
    
61.     if (sListen == SOCKET_ERROR)
    ) T" A/ a* t- K
62.     {
    
63.        printf("socket() failed: %d\n", WSAGetLastError());
    3 y% G: q2 r: {; m7 S, G  A/ D0 n
64.        return 1;
    
65.     }
    
66.    local.sin_addr.s_addr = htonl(INADDR_ANY);
    
67.    local.sin_family = AF_INET;
    5 G3 ?! b! I  I
68.    local.sin_port = htons(iPort);
    + b/ D" E% P, a  h1 T) e+ D
69. 
    ; \+ [: Y3 W# q8 F* g5 ^
70.     if (bind(sListen, (struct sockaddr *)&local,
    
71.            sizeof(local)) == SOCKET_ERROR)
    ; |; \: Z5 T! M+ y" v  t+ D
72.     {
    7 [0 \3 }2 i+ M3 g! a
73.        printf("bind() failed: %d\n", WSAGetLastError());
    : O- y$ Y' c5 l5 }# `8 d5 F
74.        return 1;
    . u; Q$ T: ~2 }! ~0 c
75.     }
    
76.    listen(sListen, 8);
    
77.     // In a continous loop, wait for incoming clients. Once one
    2 u+ |& J; C7 J0 X
78.     // is detected, create a thread and pass the handle off to it.
    , f* F' R! P2 c
79.     while (1)
    
80.     {
    
81.        iAddrSize = sizeof(client);
    
82.        sClient = accept(sListen, (struct sockaddr *)&client,
    $ S4 ^3 p4 h# Q' x  O
83.                        &iAddrSize);      
    4 O; J: O0 M3 z
84.        if (sClient == INVALID_SOCKET)
    & Q$ n9 I7 H3 A" G) ~# T3 {6 q
85.        {      
    
86.            printf("accept() failed: %d\n", WSAGetLastError());
    
87.            break;
    ) ]4 z7 y* n& E, {- r, q
88.        }
    
89.        printf("Accepted client: %s:%d\n",
    
90.            inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    ) g" l5 ?. S. H- O
91. 
    7 N$ N' _4 w& u3 @
92.        hThread = CreateThread(NULL, 0, ClientThread,
    
93.                    (LPVOID)sClient, 0, &dwThreadId);
    
94.        if (hThread == NULL)
    $ [0 I2 y* a0 Q" f
95.        {
    % s  N% y& Q; E9 w1 \, L
96.            printf("CreateThread() failed: %d\n", GetLastError());
    
97.            break;
    0 r: T0 b/ P: `& X
98.        }
    1 W) r# F& l( A  K& y
99.        CloseHandle(hThread);
    
100.     }
     
101.    closesocket(sListen);
       F  j8 b9 c; d% m9 U/ m' C* @
102.    
     
103.    WSACleanup();
     
104.     return 0;
     2 a/ D) r6 X* E; F) U% U5 t/ M
105. }

复制代码

5 s6 X: M# t( Z" {

, g: @  K/ P, v' x

: P9 e* E) Y$ s9 o. Z

admin

1. 作为服务器，你要绑定【bind】到本地的IP地址上进行监听【listen】，但是你的机器上可能有多块网卡，也就有多个IP地址，这时候你要选择绑定在哪个IP上面，如果指定为INADDR_ANY，那么系统将绑定默认的网卡【即IP地址】。
   8 W  u& a) a4 P5 ]$ x  {0 @( {' _
2. 
   
3. 作为客户端，你要连接【connect】到远端的服务器，也是要指定远端服务器的（ip, port）对。
   
4. 当然，在这种情况下，不可能将IP地址指定为INADDR_ANY，系统会疯掉的。
   
5. 
   
6. Server：
   $ R8 O/ {# m- e$ s
7. #include <winsock2.h>
   
8. #pragma comment(lib, "WS2_32.lib")
   , W) s8 G$ j  ?( i) h$ _7 ?* A6 g
9. 
   8 M  q4 g9 g! ~8 j' y
10. #include <stdio.h>
    
11. void main()
    * N+ |/ p0 s) u: f$ M1 A
12. {
    
13.     WORD wVersionRequested;//版本号
    ( i( k& J# |5 W+ l
14.     WSADATA wsaData;
    
15.     int err;
    
16. 
    
17.     wVersionRequested = MAKEWORD(2, 2);//2.2版本的套接字
    - U( {$ ^0 o) X( P* n
18.     //加载套接字库,如果失败返回
    
19.     err = WSAStartup(wVersionRequested, &wsaData);
    8 w* m0 e* B# m1 G
20.     if (err != 0)
    7 d+ t' |/ Y: S; ~  |/ E8 F
21.     {
    $ l9 L& s, L& r# O) ^
22.         return;
    
23.     }
    " e+ D+ K' k; l1 h& }7 L- Y
24. 
    . a, `' H7 W5 T7 m8 O
25.     //判断高低字节是不是2,如果不是2.2的版本则退出
    
26.     if (LOBYTE(wsaData.wVersion) != 2 ||
    
27.          
    
28.         HIBYTE(wsaData.wVersion) != 2)
    ( v) \- J0 i& E1 y1 {4 d; u7 G5 [. |
29.          
    
30.     {
    
31.         return;
    
32.     }
    ( s* b* l3 |- v7 f
33.      
    % l# S' R3 q2 q- `! S* l6 h! n
34.          //创建流式套接字,基于TCP(SOCK_STREAM)
    
35. 
    
36.          SOCKET socSrv = socket(AF_INET, SOCK_STREAM, 0);
    
37. 
    
38.          //Socket地址结构体的创建
      I# Q+ r( c( N9 d- l6 j, Y
39. 
    
40.          SOCKADDR_IN addrSrv;
    
41. 
    : u# r, y5 y: V% d& Z0 Z
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);
    
45.         //指定端口号,除sin_family参数外,其它参数都是网络字节序,因此需要转换
    
46. 
    
47.          //将套接字绑定到一个端口号和本地地址上
    
48.          bind(socSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));//必须用sizeof，strlen不行
    
49. 
    
50.          listen(socSrv, 5);
    
51.          
    
52.          SOCKADDR_IN addrClient;//字义用来接收客户端Socket的结构体
    
53. 
    - ^7 |8 t/ _7 L7 v
54.          int len = sizeof(SOCKADDR);//初始化参数,这个参数必须进行初始化，sizeof
    
55. 
    6 N  y4 N5 E# U7 H3 z4 y9 H
56.          //循环等待接受客户端发送请求
    
57. 
    6 b0 b/ k" U0 f" M
58.          while (1)
    0 u5 O! y8 [+ P& l
59.          {
    
60.                    //等待客户请求到来；当请求到来后，接受连接请求，
    
61. 
    / l0 A0 g/ N7 \% G0 G
62.                    //返回一个新的对应于此次连接的套接字（accept）。
    
63.                    //此时程序在此发生阻塞
    
64. 
    
65.                    SOCKET sockConn = accept(socSrv, (SOCKADDR*)&addrClient, &len);
    - x* A/ N2 K% L, ^4 A
66. 
    
67.                    char sendBuf[100];
    
68. 
    
69.                    sprintf(sendBuf, "Welcome %s to JoyChou",
    
70. 
    - o( E$ o' v- Q
71.                             inet_ntoa(addrClient.sin_addr));//格式化输出
    ) d4 W) b$ }% h& }
72. 
    
73.                    //用返回的套接字和客户端进行通信
    
74. 
    " }5 K5 j( {+ }) W1 v
75.                    send(sockConn, sendBuf, strlen(sendBuf)+1, 0);//多发送一个字节
    
76. 
    # C4 b% C# c  M
77.                    //接收数据
    % u6 O+ {3 Q/ y5 @; P7 T
78. 
    / e$ Y9 K% K$ ?2 u1 y
79.                    char recvBuf[100];
    
80. 
    4 Z( v  t5 Q1 _9 e* {0 t1 O
81.                    recv(sockConn, recvBuf, 100, 0);
      u9 a5 k* o  w" d% q6 C! n; h. \
82. 
    
83.                    printf("%s\n", recvBuf);
    
84.                    closesocket(sockConn);
    
85. 
    ' K. s7 t: X. l+ a  ~: j
86.          }
    
87. }
    
88. 
    5 U: g- h+ Y* F* K# d
89. 
    
90. Client：
    
91. 
    
92. #include <winsock2.H>
    
93. #pragma comment(lib, "Ws2_32.lib")
    
94. #include <stdio.h>
    
95. #include <string.h>
    + u; U6 [# v9 @, H2 J
96. 
    * ]! D7 i9 `) ?  O
97. void main()
    
98. {   
    & N# l2 R- Y% b" H. v# @# Q
99.     WORD wVersionRequested;
    / f! I7 W/ h; T; |: `
100.     WSADATA wsaData;
     + Q) ]. l! q2 E' q5 {  z6 w4 h
101.     int err;
     
102.      
     
103.     wVersionRequested = MAKEWORD( 2, 2 );
     
104.      
     ) L6 i7 k6 k& D; }2 [
105.     err = WSAStartup( wVersionRequested, &wsaData );
     ) }! d6 j* y$ w; C& R
106.     if ( err != 0 ) {
     
107.          
     
108.         return;
     ( ^1 J# g+ Q( `
109.     }
     
110.      
     
111.      
     # M+ T) E# H4 Q# X& d' ~
112.     if ( LOBYTE( wsaData.wVersion ) != 2 ||
     5 T3 p2 Q1 g& I) q( B- `
113.         HIBYTE( wsaData.wVersion ) != 2 )
     . G$ `, k* x/ T6 a0 x
114.     {
     5 R, D& m0 e* O. m% Y# ]* t% _
115.          
     2 w7 e  N5 A, p& r' I
116.         WSACleanup( );
     - K) P4 _7 J% y$ N* C5 n$ r. k
117.         return;
     
118.     }
     
119.     SOCKET socketClient = socket(AF_INET, SOCK_STREAM, 0);
     / \! s: b% j8 L; v1 c% o- y9 C
120.     SOCKADDR_IN addrSrv;
     
121.     addrSrv.sin_family = AF_INET;
     
122.     addrSrv.sin_port = htons(6000);
     & s9 b$ f# v2 i2 A5 N& V
123.     addrSrv.sin_addr.S_un.S_addr = inet_addr("192.168.1.101");//服务器端的IP地址
     9 k; G/ f3 r6 P  f
124.      
     
125.     connect(socketClient, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
     
126.     char recvBuf[256];
     8 {$ m$ X! J6 }: y
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();
     # _2 P4 f, C# f: S1 e
133.      
     ( b' ]$ P$ y1 s8 D
134. }

复制代码

8 f! Z2 G$ {6 _0 R7 \5 D