socket编译

❶ 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();//必须调用这个函数清除参数
}

❷ linux下C语言socket编程

socket编程一般是基于tcp或者udp协议来写的，你的问题很抽象，我不知道你要的是基于tcp还是udp的socket编译。我把相对难的基于tcp协议的socket编译给你吧。你想看懂我的代码需要知道tcp的三次握手机制。否则我写了注释，你看代码也有点困难。 ////服务端的代码
1 #include <stdio.h>
2 #include <string.h>
3 #include <sys/socket.h>
4 #include <unistd.h>
5 #include <netinet/in.h>
6 #include <sys/stat.h>
7 #include <stdlib.h>
8 #include <arpa/inet.h>
9
10 #define LOCAL_PORT 1234
11 #define MAX_LEN 512
12 #define MAX_NUM 5
13
14 int main(int argc, char *argv[])
15 {
16 int sock_fd, sock_data;
17 int ret, len_addr;
18 char buf[MAX_LEN];
19 ssize_t len;
20 struct sockaddr_in local_addr, remote_addr;
21
22 sock_fd = socket(AF_INET, SOCK_STREAM, 0); //创建套接字，sock_fd是套接字描述符，类似我们的身份证号码
23 if (sock_fd < 0)
24 {
25 perror("socket()");
26 return sock_fd;
27 }
28
29 local_addr.sin_family = AF_INET;// 协议族，ipv4
30 local_addr.sin_port = htons(LOCAL_PORT);// 把服务器端口转换成网络字节序
31 local_addr.sin_addr.s_addr = inet_addr("127.0.0.1");//把字符串形式的ip转换成网络字节序
32
33 ret = bind(sock_fd, (struct sockaddr *)&local_addr, (size_t)sizeof(local_addr));// 把sock_fd和本机ip，端口邦定
34 if (ret < 0)
35 {
36 perror("bind()");
37 close(sock_fd);
38 return ret;
39 }
40
41 ret = listen(sock_fd, MAX_NUM);//监听socket
42 if (ret)
43 {
44 perror("listen()");
45 close(sock_fd);
46 return ret;
47 }
48
49 memset(buf, 0, MAX_LEN);
50
51 len_addr = sizeof(remote_addr);
52
53 sock_data = accept(sock_fd, (struct sockaddr *)&remote_addr, (socklen_t *)&len_addr);//接受客户端的连接
54 if (ret < 0)
55 {
56 perror("accept()");
57 close(sock_fd);
58 return ret;
59 }
60
61 while (1)
62 {
63 int slen;
64 len = recv(sock_data, buf, MAX_LEN, 0);//接受客户端的数据
65 if (len < 0)
66 {
67 perror("recv()");
68 close(sock_data);
69 close(sock_fd);
70 return len;
71 }
72 printf("%s\n", buf);
73
74 slen = send(sock_data, "congratulation!", 15, 0);//向客户端发送数据
75 if (slen <= 0)
76 {
77 printf("slen = %d\n", slen);
78 perror("send()");
79 close(sock_data);
80 close(sock_fd);
81 return slen;
82 }
83 sleep(1);
84 }
85
86 close(sock_data);
87 close(sock_fd);
88
89 return 0;
90 }
////////////客户端的代码 1 #include <stdio.h>
2 #include <string.h>
3 #include <sys/socket.h>
4 #include <unistd.h>
5 #include <netinet/in.h>
6 #include <sys/stat.h>
7 #include <stdlib.h>
8 #include <arpa/inet.h>
9
10 #define REMOTE_PORT 1234
11 #define MAX_LEN 512
12
13 int main(int argc, char *argv[])
14 {
15 int sock_fd, ret;
16 int len;
17 char buf[MAX_LEN];
18 struct sockaddr_in local_addr, remote_addr;
19
20 sock_fd = socket(AF_INET, SOCK_STREAM, 0);
21 if (sock_fd < 0)
22 {
23 perror("socket()");
24 return sock_fd;
25 }
26
28 local_addr.sin_family = AF_INET;
29 local_addr.sin_addr.s_addr = htonl(INADDR_ANY); //自动获取本机的ip地址
30 local_addr.sin_port = htons(0); //随机选取可用的端口，并不是指定端口为0
31
33 remote_addr.sin_family= AF_INET;
34 remote_addr.sin_port = htons(REMOTE_PORT);
35 ret = inet_aton("127.0.0.1", &remote_addr.sin_addr);
36
38 ret = bind(sock_fd, (struct sockaddr *)&local_addr, sizeof(local_addr)); //把本机的ip,port和socket绑定
39 if (ret < 0)
40 {
41 perror("bind() !");
42 close(sock_fd);
43 return ret;
44 }
45
47 ret = connect(sock_fd, (struct sockaddr *)&remote_addr, (socklen_t)sizeof(remote_addr)); //把本机的socket和对方的port，ip建立连接
48 if (ret < 0)
49 {
50 perror("connect()");
51 close(sock_fd);
52 return ret;
53 }
54
55 memset(buf, 0, MAX_LEN);
56
57 while (1)
58 {
59 int i;
60 // len = send(sock_fd, buf, (size_t)MAX_LEN, 0);
61 len = send(sock_fd, "hello", 6, 0);
62 if (len <= 0)
63 {
64 perror("send()");
65 close(sock_fd);
66 return ret;
67 }
68
69 // printf("%d-->bytes send!\n", len);
70 sleep(1);
71
72 len = recv(sock_fd, buf, MAX_LEN, 0);
73 if (len <= 0)
74 {
75 perror("recv()");
76 close(sock_fd);
77 return ret;
78 }
79
80 for (i = 0; i < len; i++)
81 {
82 printf("%c", buf[i]);
83 }
84 printf("\n");
85 }
86
87 close(sock_fd);
88
89 return 0;
90 }
你把服务端和客户端这两个程序分别保存为server.c和client.c。然后编译gcc server.c -o server，gcc client .c -o client。运行时先运行服务端，用命令./server，再运行客户端，用命令./client。 注意运行命令是“点 斜杠”，“点”表示当前目录。

❸ linux下socket编译时出现绑定错误

教你个调试方法，你把printf("bind error");换成printf("bind error: %s\n", strerror(errno)); 这样可以看出哪里出错了.

我没猜错的话错误信息应该是"Address already in use." ,如果是这个错误的话，你再等一会从新运行server就可以了.

❹ C语言Socket编程编译错误是怎么回事

鼠标右键 项目->属性->配置属性->C/C++ -> 预处理器 -> 预处理器定义，增加：

_CRT_SECURE_NO_DEPRECATE

❺ socket编程到底是什么

socket 其实就是操作系统提供给程序员操作“网络协议栈”的接口，说人话就是，你能通过socket 的接口，来控制协议找工作，从而实现网络通信，达到跨主机通信。

协议栈的上半部分有两块，分别是负责收发数据的 TCP 和 UDP 协议，它们两会接受应用层的委托执行收发数据的操作。

协议栈的下面一半是用 IP 协议控制网络包收发操作，在互联网上传数据时，数据会被切分成一块块的网络包，而将网络包发送给对方的操作就是由 IP 负责的。这里需要注意的是，服务端调用 accept 时，连接成功了会返回一个已完成连接的 socket，后续用来传输数据。

所以，监听的 socket 和真正用来传送数据的 socket，是“两个” socket，一个叫作监听 socket，一个叫作已完成连接 socket。成功连接建立之后，双方开始通过 read 和 write 函数来读写数据，就像往一个文件流里面写东西一样。

❻ 在windows下用C语言如何实现socket网络编程，需要用到哪些头文件或者库

需要用到的头文件包含：

#include <winsock2.h>

#include <windows.h>

与Linux环境下socket编程相比，windows环境多了一个步骤：启动或者初始化winsock库

Winsock，一种标准API，一种网络编程接口，用于两个或多个应用程序（或进程）之间通过网络进行数据通信。具有两个版本：

Winsock 1:

Windows CE平台支持。

头文件：WinSock.h

库：wsock32.lib

Winsock 2:

部分平台如Windows CE貌似不支持。通过前缀WSA可以区别于Winsock 1版本。个别函数如WSAStartup、WSACleanup、WSARecvEx、WSAGetLastError都属于Winsock 1.1规范的函数；

头文件：WinSock2.h

库：ws2_32.lib

mswsock.h用于编程扩展，使用时必须链接mswsock.dll

(6)socket编译扩展阅读

winsock库的加载与卸载：

加载：int WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData);

加载成功，返回值为0。

WORD wVersionRequested：加载的winsock版本，使用宏MAKEWORD(x, y)，x表示高字节,y表示低字节。然而使用时MAKEWORD(2, 2)。高字节与低字节相同~~

LPWSADATA lpWSAData：WSADATA结构的指针，传入参数后，系统帮助我们填充版本信息。有兴趣的可以看看结构体内容，不过基本用不着。

卸载：int WSACleanup(void);比起加载，卸载的函数真是轻松愉快。

❼ linux socket 的程序如何在windows下编译并运行

本质区别是这样的，linux下用的是伯克利socket，windows底下用的WinSocket.
两者其实是大同小异的，不同的地方在以下几点：
1 头文件不同，在linux下用到的关键头文件<sys/socket.h>
windows下用到的是 <Winsock2.h>

2 socket的初始化不一样，在windows下要有一个WSAStartup，而linux 下没有。

3 具体的细节不一样，linux下的c和windows下的c的一些语法有些出入，你自己找找。

下面我把windows下的socket通讯的最基本的结构给你，你对照着修改就可以了，一下的程序我调试了一下，编译过了。
客户端
#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);

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[100];
recv(sockClient,recvBuf,100,0);
printf("%s\n",recvBuf);
send(sockClient,"This is lisi",strlen("This is lisi")+1,0);

closesocket(sockClient);
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_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[100];
sprintf(sendBuf,"来自服务器端",
inet_ntoa(addrClient.sin_addr));
send(sockConn,sendBuf,strlen(sendBuf)+1,0);
char recvBuf[100];
recv(sockConn,recvBuf,100,0);
printf("%s\n",recvBuf);
closesocket(sockConn);
}
}

❽ Socket编程的几种模式

其基本原理是：首先建立一个socket连接，然后对其进行操作，比如，从该socket读数据。因为网络传输是要一定的时间的，即使网络通畅的情况下，接受数据的操作也要花费时间。对于一个简单的单线程程序，接收数据的过程是无法处理其他操作的。比如一个窗口程序，当你接收数据时，点击按钮或关闭窗口操作都不会有效。它的缺点显而易见，一个线程你只能处理一个 socket，用来教课还行，实际使用效果就不行了。select模型 为了处理多个socket连接，聪明的人们发明了select模型。该模型以集合来管理socket连接，每次去查询集合中的socket状态，从而达到处理多连接的能力，其函数原型是int select(int nfds, fd_set FAR * readfds, fd_set FAR * writefds, fd_set FAR * exceptfds, const struct timeval FAR * timeout)。比如我们判断某个socket是否有数据可读，我们首先将一个fdread集合置空，然后将socket加入到该集合，调用 select(0,&fdread,NULL,NULL,NULL)，之后我们判断socket是否还在fdread中，如果还在，则说明有数据可读。数据的读取和阻塞模型相同，调用recv函数。但是每个集合容量都有一个限值，默认情况下是64个，当然你可以重新定义它的大小，但还是有一个最上限，自己设置也不能超过该值，一般情况下是1024。尽管select模型可以处理多连接，但集合的管理多少让人感到繁琐。异步选择模型 熟悉windows操作系统的都知道，其窗口处理是基于消息的。人们又发明了一种新的网络模型——WSAAsyncSelect模型，即异步选择模型。该模型为每个socket绑定一个消息，当socket上出现事先设置的socket事件时，操作系统就会给应用程序发送这个消息，从而对该 socket事件进行处理，其函数原型是int WSAAsynSelect(SOCKET s, HWND hWnd, unsigned int wMsg, long lEvent)。hWnd指明接收消息的句柄，wMsg指定消息ID，lEvent按位设置感兴趣的网络事件，入 WSAAsyncSelect(s,hwnd,WM_SOCKET, FD_CONNECT | FD_READ | FD_CLOSE)。该模型的优点是在系统开销不大的情况下同时处理许多连接，也不需要什么集合管理。缺点很明显，即使你的程序不需要窗口，也要专门为 WSAAsyncSelect模型定义一个窗口。另外，让单个窗口去处理成千上万的socket操作事件，很可能成为性能瓶颈。事件选择模型 与WSAAsynSelect模型类似，人们还发明了WSAEventSelect模型，即事件选择模型。看名字就可以猜测出来，它是基于事件的。WSAAsynSelect模型在出现感兴趣的socket事件时，系统会发一个相应的消息。而WSAEventSelect模型在出现感兴趣的socket事件时，系统会将相应WSAEVENT事件设为传信。可能你现在对sokect事件和普通WSAEVENT事件还不是很清楚。 socket事件是与socket操作相关的一些事件，如FD_READ,FD_WRITE,FD_ACCEPT等。而WSAEVENT事件是传统的事件，该事件有两种状态，传信（signaled)和未传信(non-signaled）。所谓传信，就是事件发生了，未传信就是还没有发生。我们每次建立一个连接，都为其绑定一个事件，等到该连接变化时，事件就会变为传信状态。那么，谁去接受这个事件变化呢？我们通过一个 WSAWaitForMultipleEvents（...）函数来等待事件发生，传入参数中的事件数组中，只有有一个事件发生，该函数就会返回（也可以设置为所有事件发生才返回，在这里没用），返回值为事件的数组序号，这样我们就知道了哪个事件发生了，也就是该事件对应的socket有了socket操作事件。该模型比起WSAAsynSelect模型的优势很明显，不需要窗口。唯一缺点是，该模型每次只能等待64个事件，这一限制使得在处理多 socket时，有必要组织一个线程池，伸缩性不如后面要讲的重叠模型。重叠I/O（Overlapped I/O）模型重叠I/O（Overlapped I/O）模型使应用程序达到更佳的系统性能。重叠模型的基本设计原理是让应用程序使用重叠数据结构，一次投递一个或多个Winsock I/O请求。重叠模型到底是什么东西呢？可以与WSAEventSelect模型做类比（其实不恰当，后面再说），事件选择模型为每个socket连接绑定了一个事件，而重叠模型为每个socket连接绑定了一个重叠。当连接上发生socket事件时，对应的重叠就会被更新。其实重叠的高明之处在于，它在更新重叠的同时，还把网络数据传到了实现指定的缓存区中。我们知道，前面的网络模型都要用户自己通过recv函数来接受数据，这样就降低了效率。我们打个比方，WSAEventSelect模型就像邮局的包裹通知，用户收到通知后要自己去邮局取包裹。而重叠模型就像送货上门，邮递员发给你通知时，也把包裹放到了你事先指定的仓库中。 重叠模型又分为事件通知和完成例程两种模式。在分析这两种模式之前，我们还是来看看重叠数据结构： typedef struct WSAOVERLAPPED{DWORD Internal; DWORD InternalHigh; DWORD Offset; DWORD OffsetHigh; WSAEVENT hEvent; }WSAOVERLAPPED, FAR * LPWSAOVERLAPPED; 该数据结构中，Internal、InternalHigh、Offset、OffsetHigh都是系统使用的，用户不用去管，唯一关注的就是 hEvent。如果使用事件通知模式，那么hEvent就指向相应的事件句柄。如果是完成例程模式，hEvent设为NULL。我们现在来看事件通知模式，首先创建一个事件hEvent，并创建一个重叠结构AcceptOverlapped，并设置AcceptOverlapped.hEvent = hEvent，DataBuf是我们事先设置的数据缓存区。调用 WSARecv(AcceptSocket,&DataBuf,1,&RecvBytes,&Flags,&AcceptOverlapped,NULL)，则将AcceptSocket与AcceptOverlapped重叠绑定在了一起。当接收到数据以后，hEvent就会设为传信，而数据就会放到 DataBuf中。我们再通过WSAWaitForMultipleEvents（...）接收到该事件通知。这里我们要注意，既然是基于事件通知的，那它就有一个事件处理上限，一般为64。 完成例程和事件通知模式的区别在于，当相应的socket事件出现时，系统会调用用户事先指定的回调函数，而不是设置事件。其实就是将WSARecv的最后一个参数设为函数指针。该回调函数的原型如下： void CALLBACK CompletionROUTINE( DWORD dwError, DWORD cbTransferred, LPWSAOVERLAPPED lpOverlapped, DWORD dwFlags);其中，cbTransferred表示传输的字节数，lpOverlapped是发生socket事件的重叠指针。我们调用 WSARecv(AcceptSocket,&DataBuf,1,&RecvBytes,&Flags,&AcceptOverlapped,WorkerRoutine) 将AcceptSocket与WorkRoutine例程绑定。这里有一点小提示，当我们创建多个socket的连接时，最好把重叠与相应的数据缓存区用一个大的数据结构放到一块，这样，我们在例程中通过lpOverlapped指针就可以直接找到相应的数据缓存区。这里要注意，不能将多个重叠使用同一个数据缓存区，这样在多个重叠都在处理时，就会出现数据混乱。完成端口模型 下面我们来介绍专门用于处理为数众多socket连接的网络模型——完成端口。因为需要做出大量的工作以便将socket添加到一个完成端口，而其他方法的初始化步骤则省事多了，所以对新手来说，完成端口模型好像过于复杂了。然而，一旦弄明白是怎么回事，就会发现步骤其实并非那么复杂。所谓完成端口，实际是Windows采用的一种I/O构造机制，除套接字句柄之外，还可以接受其他东西。使用这种模式之前，首先要创建一个I/O完成端口对象，该函数定义如下： HANDLE CreateIoCompletionPort( HANDLE FileHandle, HANDLE ExistingCompletionPort, DWORD CompletionKey, DWORD NumberOfConcurrentThreads);该函数用于两个截然不同的目的：1）用于创建一个完成端口对象。2）将一个句柄同完成端口关联到一起。 通过参数NumberOfConcurrentThreads，我们可以指定同时运行的线程数。理想状态下，我们希望每个处理器各自负责一个线程的运行，为完成端口提供服务，避免过于频繁的线程任务切换。对于一个socket连接，我们通过 CreateIoCompletionPort((HANDLE)Accept,CompletionPort, (DWORD)PerHandleData,0)将Accept连接与CompletionPort完成端口绑定到一起，CompetionPort对应的那些线程不断通过GetQueuedCompletionStatus来查询与其关联的socket连接是否有I/O操作完成，如果有，则做相应的数据处理，然后通过WSARecv将该socket连接再次投递，继续工作。完成端口在性能和伸缩性方面表现都很好，相关联的socket连接数目没有限制。

❾ socket编程是什么。

socket编程一种独立于协议的网络编程接口，应用程序可以通过它发送或接收数据，可对其进行像对文件一样的打开、读写和关闭等操作。

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

(9)socket编译扩展阅读

套接字可以看成是两个网络应用程序进行通信时，各自通信连接中的一个端点。通信时，其中的一个网络应用程序将要传输的一段信息写入它所在主机的Socket中，该Socket通过网络接口卡的传输介质将这段信息发送给另一台主机的Socket中，使这段信息能传送到其他程序中。

在网络应用程序设计时，由于TCP/IP的核心内容被封装在操作系统中，如果应用程序要使用TCP/IP，可以通过系统提供的TCP/IP的编程接口来实现。

参考资料来源：网络-socket

❿ 请教：一般的SOCKET在AIX中如何编译

开源的gcc自然可以算是最佳选择。在64位平台的AIX中，如果选择运用 gcc来编译perl源代码，默认情况下是编译成32位的版本。这样在编译DBD::Oracle的时候也须要选择正确的32位库，否则不能编译成功。