套接字编程实例
‘壹’ 套接字是什么
套接字（socket）是一个抽象层，应用程序可以通过它发送或接收数据，可对其进行像对文件一样的打开、读写和关闭等操作。套接字允许应用程序将I/O插入到网络中，并与网络中的其他应用程序进行通信。网络套接字是IP地址与端口的组合。
总之，套接字Socket=（IP地址：端口号），套接字的表示方法是点分十进制的IP地址后面写上端口号，中间用冒号或逗号隔开。每一个传输层连接唯一地被通信两端的两个端点（即两个套接字）所确定。
(1)套接字编程实例扩展阅读
Socket最初是加利福尼亚大学Berkeley分校为Unix系统开发的网络通信接口。后来随着TCP/IP网络的发展，Socket成为最为通用的应用程序接口，也是在Internet上进行应用开发最为通用的API。
Windows系统流行起来之后，由Microsoft联合了其他几家公司在Berkeley Sockets的基础之上进行了扩充，共同制定了一套Windows下的网络编程接口，即Windows Sockets规范。
Windows Sockets规范是一套开放的、支持多种协议的Windows下的网络编程接口，包括1.1版和2.0版两个版本。
参考资料来源：网络-套接字
‘贰’ 基于Linux的远程指令系统（使用udp而不是tcp）
一. Linux下UDP编程框架
使用UDP进行程序设计可以分为客户端和服务器端两部分。
1.服务器端程序包括：
? 建立套接字
? 将套接字地址结构进行绑定
? 读写数据
? 关闭套接字
2.客户端程序包括：
? 建立套接字
? 读写数据
? 关闭套接字
3.服务器端和客户端程序之间的差别
服务器端和客户端两个流程之间的主要差别在于对地址的绑定函数（bind()函数），而客户端可以不用进行地址和端口的绑定操作。
二.Linux中UDP套接字函数
从图可知，UDP协议的服务端程序设计的流程分为套接字建立，套接字与地址结构进行绑定，收发数据，关闭套接字;客户端程序流程为套接字建立，收发数据，关闭套接字等过程。它们分别对应socket(),bind(),sendto(),recvfrom(),和close()函数。
网络程序通过调用socket（）函数，会返回一个用于通信的套接字描述符。Linux应用程序在执行任何形式的I/O操作的时候，程序是在读或者写一个文件描述符。因此，可以把创建的套接字描述符看成普通的描述符来操作，并通过读写套接字描述符来实现网络之间的数据交流。
1. socket
1> 函数原型:
int socket(int domain,int type,int protocol)
2> 函数功能：
函数socket()用于创建一个套接字描述符。
3> 形参：
? domain:用于指定创建套接字所使用的协议族，在头文件
中定义。
常见的协议族如下：
AF_UNIX:创建只在本机内进行通信的套接字。
AF_INET:使用IPv4 TCP/IP协议
AF_INET6:使用IPv6 TCP/IP协议
说明：
AF_UNIX只能用于单一的UNIX系统进程间通信，而AF_INET是针对Interne的，因而可以允许在远程主机之间通信。一般把它赋为AF_INET。
? type:指明套接的类型，对应的参数如下
SOCK_STREAM:创建TCP流套接字
SOCK_DGRAM:创建UDP数据报套接字
SOCK_RAW:创建原始套接字
? protocol:
参数protocol通常设置为0，表示通过参数domain指定的协议族和参数type指定的套接字类型来确定使用的协议。当为原始套接字时，系统无法唯一的确定协议，此时就需要使用使用该参数指定所使用的协议。
4> 返回值：执行成功后返回一个新创建的套接字；若有错误发生则返回一个-1，错误代码存入errno中。
5> 举例：调用socket函数创建一个UDP套接字
int sock_fd;
sock_fd = socket(AF_INET,SOCK_DGRAM,0);
if(sock_fd < 0){
perror(“socket”);
exit(1);
}
2. bind
1> 函数原型：
int bind(int sockfd,struct sockaddr *my_addr,socklen_taddrlen)
2> 函数功能
函数bind()的作用是将一个套接字文件描述符与一个本地地址绑定在一起。
3> 形参：
? sockfd:sockfd是调用socket函数返回的文件描述符；
? addrlen是sockaddr结构的长度。
? my_addr: 是一个指向sockaddr结构的指针，它保存着本地套接字的地址（即端口和IP地址）信息。不过由于系统兼容性的问题，一般不使用这个结构，而使用另外一个结构(struct sockaddr_in)来代替
4> 套接字地址结构：
(1)structsockaddr:
结构struct sockaddr定义了一种通用的套接字地址，它在
Linux/socket.h 中定义。
struct sockaddr{
unsigned short sa_family;/*地址类型，AF_XXX*/
char sa_data[14];/*14字节的协议地址*/
}
a. sin_family：表示地址类型，对于使用TCP/IP协议进行的网络编程，该值只能是AF_INET.
b. sa_data：存储具体的协议地址。
(2)sockaddr_in
每种协议族都有自己的协议地址格式，TCP/IP协议组的地址格式为结构体struct sockaddr_in,它在netinet/in.h头文件中定义。
struct sockaddr_in{
unsigned short sin_family;/*地址类型*/
unsigned short sin_port;/*端口号*/
struct in_addr sin_addr;/*IP地址*/
unsigned char sin_zero[8];/*填充字节，一般赋值为0*/
}
a. sin_family：表示地址类型，对于使用TCP/IP协议进行的网络编程，该值只能是AF_INET.
b. sin_port:是端口号
c. sin_addr:用来存储32位的IP地址。
d. 数组sin_zero为填充字段，一般赋值为0.
e. structin_addr的定义如下：
struct in_addr{
unsignedlong s_addr;
}
结构体sockaddr的长度为16字节，结构体sockaddr_in的长度为16字节。可以将参数my_addr的sin_addr设置为INADDR_ANY而不是某个确定的IP地址就可以绑定到任何网络接口。对于只有一IP地址的计算机，INADDR_ANY对应的就是它的IP地址；对于多宿主主机(拥有多个网卡)，INADDR_ANY表示本服务器程序将处理来自所有网络接口上相应端口的连接请求
5> 返回值：
函数成功后返回0，当有错误发生时则返回-1，错误代码存入errno中。
6>举例：调用socket函数创建一个UDP套接字
struct sockaddr_in addr_serv,addr_client;/*本地的地址信息*/
memset(&serv_addr,0,sizeof(struct sockaddr_in));
addr_serv.sin_family = AF_INET;/*协议族*/
addr_serv.sin_port = htons(SERV_PORT);/*本地端口号*/
addr_serv.sin_addr.s_addr = htonl(INADDR_ANY); /*任意本地地址*/
/*套接字绑定*/
if(bind(sock_fd,(struct sockaddr *)&addr_serv),sizeof(structsockaddr_in)) <0)
{
perror(“bind”);
exit(1);
}
3.close
1>函数原型：
int close(intfd);
2>函数功能：
函数close用来关闭一个套接字描述符。
3>函数形参：
? 参数fd为一个套接字描述符。
4>返回值：
执行成功返回0，出错则返回-1.错误代码存入errno中。
说明：
以上三个函数中，前两个要包含头文件
#include
#include
后一个包含：
#include
4.sendto
1>函数原型：
#include
#include
ssize_t sendo(ints,const void *msg,size_t len,int flags,const struct sockaddr *to,socklen_ttolen);
2>函数功能：
向目标主机发送消息
3>函数形参：
? s:套接字描述符。
? *msg:发送缓冲区
? len:待发送数据的长度
? flags:控制选项，一般设置为0或取下面的值
(1)MSG_OOB:在指定的套接字上发送带外数据(out-of-band data),该类型的套接字必须支持带外数据（eg:SOCK_STREAM）.
(2)MSG_DONTROUTE:通过最直接的路径发送数据，而忽略下层协议的路由设置。
? to:用于指定目的地址
? tolen:目的地址的长度。
4>函数返回值：
执行成功后返回实际发送数据的字节数，出错返回-1，错误代码存入errno中。
5>函数举例：
char send_buf[BUFFERSIZE];
struct sockaddr_in addr_client;
memset(&addr_client,0,sizeof(struct sockaddr_in));
addr_client.sin_family = AF_INET;
addr_client.sin_port = htons(DEST_PORT);
if(inet_aton(“172.17.242.131”,&addr_client.sin_addr)<0){
perror(“inet_aton”);
exit(1);
}
if(sendto(sock_fd,send_buf,len,0,(strut sockaddr*)&addr_client,sizeof(struct sockaddr_in)) <0){
perror(“sendto”);
exit(1);
}
5.recvfrom
1>函数原型：
#include
#include
ssize_t recvfrom(int s,void *buf,size_t len,intflags,struct sockaddr *from,socklen_t *fromlen);
2>函数功能：接收数据
3>函数形参：
? int s:套接字描述符
? buf:指向接收缓冲区，接收到的数据将放在这个指针所指向的内存空间。
? len:指定了缓冲区的大小。
? flags:控制选项,一般设置为0或取以下值
(1)MSG_OOB:请求接收带外数据
(2)MSG_PEEK:只查看数据而不读出
(3)MSG_WAITALL:只在接收缓冲区时才返回。
? *from:保存了接收数据报的源地址。
? *fromlen:参数fromlen在调用recvfrom前为参数from的长度，调用recvfrom后将保存from的实际大小。
4>函数返回值：
执行成功后返回实际接收到数据的字节数，出错时则返回-1，错误代码存入errno中。
5>函数实例：
char recv_buf[BUFFERSIZE];
struct sockaddr_in addr_client;
int src_len;
src_len = sizeof(struct sockaddr_in);
int src_len;
src_len = sizeof(struct sockaddr_in);
if(recvfrom(sock_fd,recv_buf,sizeof(recv_buf),0,(structsockaddr *)&src_addr,&src_len)<0){
perror(“again_recvfrom”);
exit(1);
}
三.UDP编程实例
客户端向服务器发送字符串Hello tiger,服务器接收到数据后将接收到字符串发送回客户端。
1.服务器端程序
1 #include
2 #include
3 #include
4 #include
5 #include
6 #include
7 #include
8 #include
9
10 #define SERV_PORT 3000
11
12 int main()
13 {
14 int sock_fd; //套接子描述符号
15 int recv_num;
16 int send_num;
17 int client_len;
18 char recv_buf[20];
19 struct sockaddr_in addr_serv;
20 struct sockaddr_in addr_client;//服务器和客户端地址
21 sock_fd = socket(AF_INET,SOCK_DGRAM,0);
22 if(sock_fd < 0){
23 perror("socket");
24 exit(1);
25 } else{
26
27 printf("sock sucessful\n");
28 }
29 //初始化服务器断地址
30 memset(&addr_serv,0,sizeof(struct sockaddr_in));
31 addr_serv.sin_family = AF_INET;//协议族
32 addr_serv.sin_port = htons(SERV_PORT);
33 addr_serv.sin_addr.s_addr = htonl(INADDR_ANY);//任意本地址
34
35 client_len = sizeof(struct sockaddr_in);
36 /*绑定套接子*/
37 if(bind(sock_fd,(struct sockaddr *)&addr_serv,sizeof(struct sockaddr_in))<0 ){
38 perror("bind");
39 exit(1);
40 } else{
41
42 printf("bind sucess\n");
43 }
44 while(1){
45 printf("begin recv:\n");
46 recv_num = recvfrom(sock_fd,recv_buf,sizeof(recv_buf),0,(struct sockaddr *)&addr_client,&client_len);
47 if(recv_num < 0){
48 printf("bad\n");
49 perror("again recvfrom");
50 exit(1);
51 } else{
52 recv_buf[recv_num]='\0';
53 printf("recv sucess:%s\n",recv_buf);
54 }
55 printf("begin send:\n");
56 send_num = sendto(sock_fd,recv_buf,recv_num,0,(struct sockaddr *)&addr_client,client_len);
57 if(send_num < 0){
58 perror("sendto");
59 exit(1);
60 } else{
61 printf("send sucessful\n");
62 }
63 }
64 close(sock_fd);
65 return 0;
66 }
2.客户端程序
1 #include
2 #include
3 #include
4 #include
5 #include
6
7 #include
8 #include
9 #include
10
11 #define DEST_PORT 3000
12 #define DSET_IP_ADDRESS "192.168.1.103"
13
14 int main()
15 {
16 int sock_fd;/*套接字文件描述符*/
17 int send_num;
18 int recv_num;
19 int dest_len;
20 char send_buf[20]={"hello tiger"};
21 char recv_buf[20];
22 struct sockaddr_in addr_serv;/*服务端地址，客户端地址*/
23
24 sock_fd = socket(AF_INET,SOCK_DGRAM,0);//创建套接子
25 //初始化服务器端地址
26 memset(&addr_serv,0,sizeof(addr_serv));
27 addr_serv.sin_family = AF_INET;
28 addr_serv.sin_addr.s_addr = inet_addr(DSET_IP_ADDRESS);
29 addr_serv.sin_port = htons(DEST_PORT);
30
31 dest_len = sizeof(struct sockaddr_in);
32 printf("begin send:\n");
33 send_num = sendto(sock_fd,send_buf,sizeof(send_buf),0,(struct sockaddr *)&addr_serv,dest_len);
34 if(send_num < 0){
35 perror("sendto");
36 exit(1);
37 } else{
38
39 printf("send sucessful:%s\n",send_buf);
40 }
41 recv_num = recvfrom(sock_fd,recv_buf,sizeof(recv_buf),0,(struct sockaddr *)&addr_serv,&dest_len);
42 if(recv_num <0 ){
43
44 perror("recv_from");
45 exit(1);
46 } else{
47 printf("recv sucessful\n");
48 }
49 recv_buf[recv_num]='\0';
50 printf("the receive:%s\n",recv_buf);
51 close(sock_fd);
52 return 0;
53 }
‘叁’ UDP和Socket通信步骤
这是在网上找到的，希望对你有所帮助。
sockets（套接字）编程有三种，流式套接字（SOCK_STREAM），数据报套接字（SOCK_DGRAM），原始套接字（SOCK_RAW）；
WINDOWS环境下TCP/UDP编程步骤：
1. 基于TCP的socket编程是采用的流式套接字。
在这个程序中，将两个工程添加到一个工作区。要链接一个ws2_32.lib的库文件。
服务器端编程的步骤：
1：加载套接字库，创建套接字(WSAStartup()/socket())；
2：绑定套接字到一个IP地址和一个端口上(bind())；
3：将套接字设置为监听模式等待连接请求(listen())；
4：请求到来后，接受连接请求，返回一个新的对应于此次连接的套接字(accept())；
5：用返回的套接字和客户端进行通信(send()/recv())；
6：返回，等待另一连接请求；
7：关闭套接字，关闭加载的套接字库(closesocket()/WSACleanup())。
服务器端代码如下：
#include <stdio.h>
#include <Winsock2.h>
void main()
{
WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD( 1, 1 );
err = WSAStartup( wVersionRequested, &wsaData );
if ( err != 0 ) {
return;
}
if ( LOBYTE( wsaData.wVersion ) != 1 ||
HIBYTE( wsaData.wVersion ) != 1 ) {
WSACleanup( );
return;
}
SOCKET sockSrv=socket(AF_INET,SOCK_STREAM,0);
SOCKADDR_IN addrSrv;
addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY);
addrSrv.sin_family=AF_INET;
addrSrv.sin_port=htons(6000);
bind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));
listen(sockSrv,5);
SOCKADDR_IN addrClient;
int len=sizeof(SOCKADDR);
while(1)
{
SOCKET sockConn=accept(sockSrv,(SOCKADDR*)&addrClient,&len);
char sendBuf[50];
sprintf(sendBuf,"Welcome %s to here!",inet_ntoa(addrClient.sin_addr));
send(sockConn,sendBuf,strlen(sendBuf)+1,0);
char recvBuf[50];
recv(sockConn,recvBuf,50,0);
printf("%s\n",recvBuf);
closesocket(sockConn);
}
}
客户端编程的步骤：
1：加载套接字库，创建套接字(WSAStartup()/socket())；
2：向服务器发出连接请求(connect())；
3：和服务器端进行通信(send()/recv())；
4：关闭套接字，关闭加载的套接字库(closesocket()/WSACleanup())。
客户端的代码如下：
#include <stdio.h>
#include <Winsock2.h>
void main()
{
WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD( 1, 1 );
err = WSAStartup( wVersionRequested, &wsaData );
if ( err != 0 ) {
return;
}
if ( LOBYTE( wsaData.wVersion ) != 1 ||
HIBYTE( wsaData.wVersion ) != 1 ) {
WSACleanup( );
return;
}
SOCKET sockClient=socket(AF_INET,SOCK_STREAM,0);
SOCKADDR_IN addrSrv;
addrSrv.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");
addrSrv.sin_family=AF_INET;
addrSrv.sin_port=htons(6000);
connect(sockClient,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));
char recvBuf[50];
recv(sockClient,recvBuf,50,0);
printf("%s\n",recvBuf);
send(sockClient,"hello",strlen("hello")+1,0);
closesocket(sockClient);
WSACleanup();
}
2.基于UDP的socket编程是采用的数据报套接字。
在这个程序中，将两个工程添加到一个工作区。同时还要链接一个ws2_32.lib的库文件。
服务器端编程的步骤：
1：加载套接字库，创建套接字(WSAStartup()/socket())；
2：绑定套接字到一个IP地址和一个端口上(bind())；
3：等待和接收数据(sendto()/recvfrom())；
4：关闭套接字，关闭加载的套接字库(closesocket()/WSACleanup())。
服务器端代码如下：
#include <winsock2.h>
#include <stdio.h>
void main()
{
WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD( 1, 1 );
err = WSAStartup( wVersionRequested, &wsaData );
if ( err != 0 )
{
return;
}
if ( LOBYTE( wsaData.wVersion ) != 1 ||
HIBYTE( wsaData.wVersion ) != 1 )
{
WSACleanup( );
return;
}
SOCKET sockSrv=socket(AF_INET,SOCK_DGRAM,0);
SOCKADDR_IN addrSrv;
addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY);
addrSrv.sin_family=AF_INET;
addrSrv.sin_port=htons(7003);
bind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));
char recvBuf[50];
SOCKADDR addrClient;
int len=sizeof(SOCKADDR);
recvfrom(sockSrv,recvBuf,50,0,(SOCKADDR*)&addrClient,&len);
printf("%s\n",recvBuf);
closesocket(sockSrv);
WSACleanup();
}
对于基于UDP的socket客户端来说，要进行如下步骤：
1：创建一个套接字(socket)；
2：向服务器发送数据(sendto);
3：关闭套接字；
代码如下：
#include <winsock2.h>
#include <stdio.h>
void main()
{
WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD( 2, 2 );
err = WSAStartup( wVersionRequested, &wsaData );
if ( err != 0 ) {
return;
}
if ( LOBYTE( wsaData.wVersion ) != 2 ||
HIBYTE( wsaData.wVersion ) != 2 ) {
WSACleanup( );
return;
}
SOCKET sockClient=socket(AF_INET,SOCK_DGRAM,0);
SOCKADDR_IN addrClient;
addrClient.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");
addrClient.sin_family=AF_INET;
addrClient.sin_port=htons(8889);
SOCKADDR_IN addrSrv;
sendto(sockClient,"hi",3,0,(SOCKADDR*)&addrClient,sizeof(SOCKADDR));
}
LINUX环境下TCP/UDP编程步骤：
TCP编程步骤：
一. 服务端：
1.socket(int domain,int type,int protocol):建立套接字；
2 .bind(int sockid,struct sockaddr *addrp,socklen_t addrlen):把本机地址和端口跟上一步建立的socket绑定在一起；
3.listen(int sockid,int qsize):监听某套接字;
4.fd=accept(int sockid,struct sockaddr *callerid,socklen_t *addrlenp):等待某套接字接收信息；
5.recv(int fd,void *buf,size_t nbytes,int flags):从套接字接收数据;
6.close(fd) 和close(sockid)
二.客户端：
1. socket():建立套接字；
2.connect(int sockid,struct sockaddr *serv_addrp,socklen_t addrlen):连接到服务器；
3. send(int sockfd,const void *buf,size_t nbytes,int flags):发送数据到服务器.
4. close(sockid);
UDP编程步骤：
一，服务端：
1. socket():同上；
2. bind():同上；
3. recvfrom(int sockfd,void*buff,size_t nbytes,int flags,struct sockaddr*from,socklen_t*addrlen):在套接字口接收数据，并且记录下接收到的数据来源;一定要注意这里的参数addrlen，它不仅是函数的输出，也是函数的输入！所以要在调用该函数之前对addrlen赋值sizeof(struct sockaddr)。否则返回的地址from将会出错！
4. close(sockfd);
二. 客户端：
1. socket();同上；
2. sendto(int sockfd,const void*buff,size_t nbytes,int flags,const struct sockaddr*to,socklen_t addrlen):往指定的地址发送数据；
3. close(sockfd);
‘肆’ Socket编程
最近也在学 还有一个自己写的C++聊天程序 有点大 下面是C写的
sockets（套接字）编程有三种，流式套接字（SOCK_STREAM），数据报套接字 （SOCK_DGRAM），原始套接字（SOCK_RAW）；基于TCP的socket编程是采用的流式套接字(SOCK_STREAM)。基于UDP采 用的数据报套接字(SOCK_DGRAM).
1.TCP流式套接字的编程步骤
在使用之前须链接库函数：工程->设置->Link->输入ws2_32.lib，OK！
服务器端程序：
1、加载套接字库
2、创建套接字（socket）。
3、将套接字绑定到一个本地地址和端口上（bind）。
4、将套接字设为监听模式，准备接收客户请求（listen）。
5、等待客户请求到来；当请求到来后，接受连接请求，返回一个新的对应于此次连接的套接字（accept）。
6、用返回的套接字和客户端进行通信（send/recv）。
7、返回，等待另一客户请求。
8、关闭套接字。
客户端程序：
1、加载套接字库
2、创建套接字（socket）。
3、向服务器发出连接请求（connect）。
4、和服务器端进行通信（send/recv）。
5、关闭套接字
服务器端代码如下：
#include <Winsock2.h>//加裁头文件
#include <stdio.h>//加载标准输入输出头文件
void main()
{
WORD wVersionRequested;//版本号
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD( 1, 1 );//1.1版本的套接字
err = WSAStartup( wVersionRequested, &wsaData );
if ( err != 0 ) {
return;
}//加载套接字库，加裁失败则返回
if ( LOBYTE( wsaData.wVersion ) != 1 ||
HIBYTE( wsaData.wVersion ) != 1 ) {
WSACleanup( );
return;
}//如果不是1.1的则退出
SOCKET sockSrv=socket(AF_INET,SOCK_STREAM,0);//创建套接字（socket）。
SOCKADDR_IN addrSrv;
addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY);//转换Unsigned short为网络字节序的格式
addrSrv.sin_family=AF_INET;
addrSrv.sin_port=htons(6000);
bind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));
//将套接字绑定到一个本地地址和端口上（bind）
listen(sockSrv,5);//将套接字设为监听模式，准备接收客户请求（listen）。
SOCKADDR_IN addrClient;//定义地址族
int len=sizeof(SOCKADDR);//初始化这个参数，这个参数必须被初始化
while(1)
{
SOCKET sockConn=accept(sockSrv,(SOCKADDR*)&addrClient,&len);//accept的第三个参数一定要有初始值。
//等待客户请求到来；当请求到来后，接受连接请求，返回一个新的对应于此次连接的套接字（accept）。
//此时程序在此发生阻塞
char sendBuf[100];
sprintf(sendBuf,"Welcome %s to http://www.sunxin.org",
inet_ntoa(addrClient.sin_addr));
//用返回的套接字和客户端进行通信（send/recv）。
send(sockConn,sendBuf,strlen(sendBuf)+1,0);
char recvBuf[100];
recv(sockConn,recvBuf,100,0);
printf("%s\n",recvBuf);
closesocket(sockConn);//关闭套接字。等待另一个用户请求
}
}
客户端代码如下：
#include <Winsock2.h>
#include <stdio.h>
void main()
{
WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD( 1, 1 );
err = WSAStartup( wVersionRequested, &wsaData );加载套接字库
if ( err != 0 ) {
return;
}
if ( LOBYTE( wsaData.wVersion ) != 1 ||
HIBYTE( wsaData.wVersion ) != 1 ) {
WSACleanup( );
return;
}
SOCKET sockClient=socket(AF_INET,SOCK_STREAM,0);创建套接字（socket）。
SOCKADDR_IN addrSrv;
addrSrv.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");
addrSrv.sin_family=AF_INET;
addrSrv.sin_port=htons(6000);
connect(sockClient,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));向服务器发出连接请求（connect）。
char recvBuf[100];和服务器端进行通信（send/recv）。
recv(sockClient,recvBuf,100,0);
printf("%s\n",recvBuf);
send(sockClient,"This is lisi",strlen("This is lisi")+1,0);
closesocket(sockClient);关闭套接字。
WSACleanup();//必须调用这个函数清除参数
}