提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
提示：这里可以添加本文要记录的大概内容：
网络编程
提示：以下是本篇文章正文内容，下面案例可供参考
//man 7 ip
struct sockaddr_in {
sa_family_t sin_family; /* address family: AF_INET */
in_port_t sin_port; /* port in network byte order */
struct in_addr sin_addr; /* internet address */
};
/* Internet address. */
struct in_addr {
uint32_t s_addr; /* address in network byte order */
};
#include <arpa/inet.h>
//h --> host n --> net l --> 32bit s --> 16bit
uint32_t htonl(uint32_t hostlong);
uint16_t htons(uint16_t hostshort);
uint32_t ntohl(uint32_t netlong);
uint16_t ntohs(uint16_t netshort);
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
int inet_aton(const char *cp, struct in_addr *inp);
char *inet_ntoa(struct in_addr in);
//线程安全版本是inet_atop inet_ptoa
#include <netdb.h>
struct hostent *gethostbyname(const char *name);
struct hostent {
char *h_name; /* official name of host */
char **h_aliases; /* alias list */
int h_addrtype; /* host address type */
int h_length; /* length of address */
char **h_addr_list; /* list of addresses */
}
char * 不是字符串，是一片ip地址的内存首地址
使用hostent需要包含#include<netdb.h>和#include<sys/socket.h>等头文件.
结构体hostent有五个元素，即h_name，它是一个字符指针，指向主机名；
h_aliases是一个二重指针，指向主机的别名，一个主机可以有多个别名，
h_aliases可以用下标的方式访问不同的主机别名；
h_addrtype，为int型数据，指定主机使用的IP地址类型；
length指定IP地址长度；
h_addr_list也是一个二重指针，与h_aliases一样，也可以通过下标进行访问。
这个结构体指定主机的不同IP地址，在实际的应用中，一台服务器往往有好几个IP地址，而域名只有一个，这样设计的好处是，可以使系统分布设计，提升服务器的稳定性和抗灾难能力。
一般对服务器的访问，则是先经过DNS服务器，DNS通过均衡设计，返回合适的IP与客户端进行交互，避免客户端只连接一个IP，导致网络拥堵。
下面是使用TCP通信的流程图:
#include <sys/socket.h>
int socket(int domain, int type, int protocol);
//domain AF_INET --> IPv4 AF_INET6 --> IPv6
//type SOCK_STREAM --> TCP SOCK_DGRAM --> UDP
//protocol IPPROTO_TCP --> TCP IPPROTO_UDP -->UDP
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
客户端在调用 connect 可以不使用 bind 来指定本地的端口信息，这客户端就会随机选择一个临时端口号来作为源端口。
调用 connect 预期是完成TCP建立连接的三次握手。
如果服务端未开启对应的端口号或者未监听，则只能收到一个RST回复，并且报错返回的内容是"Connection refused"。
完成第一次和第三次
int main(int argc,char* argv[])
{
ARGS_CHECK(argc,3);
int sfd = socket(AF_INET,SOCK_STREAM,0);
ERROR_CHECK(sfd,-1,"socket");
struct sockaddr_in serAddr;
memset(&serAddr,0,sizeof(serAddr));
serAddr.sin_family = AF_INET;
//把淀粉十进制的ip地址转换成32位大端存储的地址
serAddr.sin_addr.s_addr = inet_addr(argv[1]);
//端口用大端存储
serAddr.sin_port = htons(atoi(argv[2]));
int ret = connect(sfd,(struct sockaddr*)&serAddr,sizeof(serAddr));
ERROR_CHECK(ret,-1,"connect");
return 0;
}
#tcpdump -i any port 2778
-an 列出所有网络
-ntlp 列出所有的监听
int bind(int sockfd, const struct sockaddr *addr,
socklen_t addrlen);
int main(int argc,char* argv[])
{
ARGS_CHECK(argc,3);
//创建监听套接字
int sfd = socket(AF_INET,SOCK_STREAM,0);
ERROR_CHECK(sfd,-1,"socket");
struct sockaddr_in serAddr;
memset(&serAddr,0,sizeof(serAddr));
serAddr.sin_family = AF_INET;
serAddr.sin_addr.s_addr = inet_addr(argv[1]);//如果赋值为INADDR_ANY，表示选择本机
IP地址
serAddr.sin_port = htons(atoi(argv[2]));
int ret = bind(sfd,(struct sockaddr*)&serAddr,sizeof(serAddr));
ERROR_CHECK(ret,-1,"bind");
return 0;
}
int listen(int sockfd, int backlog);
一旦启用了 listen 之后，操作系统就知道该套接字是服务端的套接字，操作系统内核就不再启用其发送和接收缓冲区，转而在内核区维护两个队列结构：半连接队列和全连接队列。
半连接队列用于管理成功第一次握手的连接，全连接队列用于管理已经完成三次握手的队列。
backlog 在有些操作系统用来指明半连接队列和全连接队列的长度之和，一般填一个正数即可。如果队列已经满了，那么服务端受到任何再发起的连接都会直接丢弃（大部分操作系统中服务端不会回复RST，以方便客户端自动重传）
使用 netstat -an 命令可以查看主机上某个端口的监听情况。
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
ret = listen(sfd,10);
ERROR_CHECK(ret,-1,"listen");
//newFd代表的是跟客户端的TCP连接
socklen_t len;
len = sizeof(struct sockaddr)
int newFd = accept(sfd,NULL, &len);
ERROR_CHECK(newFd,-1,"accept");
printf("newFd = %d\n", newFd);
send的本质是write，recv的本质是read。
数据的实机发送过程，由内核缓冲区处理。
当接收缓冲区为空时，recv会阻塞
多次send，可能一次性recv出来（消息没有边界）。
recv 不一定能把数据全部取完。
send 把数据拷贝到发送缓冲区
recv把数据从接收缓冲区拷贝出来
send 和 recv 用于将数据在用户态空间和内核态的缓冲区之间进行传输，无论是客户端还是服务端均可使用，但是只能用于TCP连接。
将数据拷贝到内核态并不意味着会马上传输，而是会根据时机再由内核协议栈按照协议的规范进行分节，通常缓冲区如果数据过多会分节成MSS的大小，然后根据窗口条件传输到网络层之中。
//将buf的数据拷贝到发送缓冲区
ssize_t send(int sockfd, const void *buf, size_t len, int flags);
//将接收缓冲区的数据拷贝打buf
ssize_t recv(int sockfd, void *buf, size_t len, int flags);
//clinet.c
int main(int argc,char* argv[])
{
ARGS_CHECK(argc,3);
int sfd = socket(AF_INET,SOCK_STREAM,0);
ERROR_CHECK(sfd,-1,"socket");
struct sockaddr_in serAddr;
memset(&serAddr,0,sizeof(serAddr));
serAddr.sin_family = AF_INET;
serAddr.sin_addr.s_addr = inet_addr(argv[1]);
serAddr.sin_port = htons(atoi(argv[2]));
int ret = connect(sfd,(struct sockaddr*)&serAddr,sizeof(serAddr));
ERROR_CHECK(ret,-1,"connect");
char buf[64]={0};
ret = recv(sfd,buf,sizeof(buf),0);
printf("buf=%s\n",buf);
send(sfd,"helloserver",11,0);
close(sfd);
return 0;
}
//server.c
int main(int argc,char* argv[])
{
ARGS_CHECK(argc,3);
//创建监听套接字
int sfd = socket(AF_INET,SOCK_STREAM,0);
ERROR_CHECK(sfd,-1,"socket");
struct sockaddr_in serAddr;
memset(&serAddr,0,sizeof(serAddr));
serAddr.sin_family = AF_INET;
serAddr.sin_addr.s_addr = inet_addr(argv[1]);
serAddr.sin_port = htons(atoi(argv[2]));
int ret = bind(sfd,(struct sockaddr*)&serAddr,sizeof(serAddr));
ERROR_CHECK(ret,-1,"bind");
ret = listen(sfd,10);
ERROR_CHECK(ret,-1,"listen");
//newFd代表的是跟客户端的TCP连接
socklen_t len;
len = sizeof(struct sockaddr);
int newFd = accept(sfd,NULL,&len);
ERROR_CHECK(newFd,-1,"accept");
ret = send(newFd,"helloclient",11,0);
ERROR_CHECK(ret,-1,"send");
char buf[64]={0};
ret = recv(newFd,buf,sizeof(buf),0);
printf("buf=%s\n",buf);
close(newFd);
close(sfd);
return 0;
}
netstat -an|grep 1234
int setsockopt(int sockfd, int level, int optname,const void *optval, socklen_t optlen);
//...
int reuse = 1;
ret = setsockopt(sfd,SOL_SOCKET,SO_REUSEADDR,&reuse,sizeof(reuse));
ERROR_CHECK(ret,-1,"setsockopt");
//...后续再执行bind等操作
服务端除了接收缓冲区和标准输入以外，还有一个操作也会造成阻塞，那就是 accept 操作。
accept是读行为。
服务端sockfd可以被select监听
有连接的情况下，sockfd就绪，accept不会阻塞
实际上服务端可以使用 select 管理监听套接字，检查其全连接队列是否存在已经建好的连接，如果存在连接，那么其读事件即 accept 操作便就绪。将监听套接字加入监听会导致服务端的代码发生一个结构变化：
int main(int argc,char* argv[])
{
ARGS_CHECK(argc,3);
int sfd = socket(AF_INET,SOCK_STREAM,0);
ERROR_CHECK(sfd,-1,"socket");
struct sockaddr_in serAddr;
memset(&serAddr,0,sizeof(serAddr));
serAddr.sin_family = AF_INET;
serAddr.sin_addr.s_addr = inet_addr(argv[1]);
serAddr.sin_port = htons(atoi(argv[2]));
int ret = bind(sfd,(struct sockaddr*)&serAddr,sizeof(serAddr));
ERROR_CHECK(ret,-1,"bind");
ret = listen(sfd,10);
ERROR_CHECK(ret,-1,"listen");
int newFd=0;
char buf[64]={0};
fd_set rdset;
//记录的是需要监听的文件描述符的集合
fd_set needMonitorSet;
FD_ZERO(&rdset);
FD_ZERO(&needMonitorSet);
FD_SET(STDIN_FILENO,&needMonitorSet);
FD_SET(sfd,&needMonitorSet);
while(1)
{
memcpy(&rdset,&needMonitorSet,sizeof(fd_set));
ret = select(10,&rdset,NULL,NULL,NULL);
ERROR_CHECK(ret,-1,"readyNum");
//select的rdset是一个传入传出参数，select成功返回的时候
//rdset里保存的是就绪的描述符
printf("select return\n");
if(FD_ISSET(STDIN_FILENO,&rdset))
{
memset(buf,0,sizeof(buf));
read(STDIN_FILENO,buf,sizeof(buf));
send(newFd,buf,strlen(buf)-1,0);
}
else if(FD_ISSET(newFd,&rdset))
{
memset(buf,0,sizeof(buf));
ret = recv(newFd,buf,sizeof(buf),0);
//对端断开的时候，newFd一直可读
//recv读数据的返回值是0
if(0 == ret)
{
printf("byebye\n");
close(newFd);
FD_CLR(newFd,&needMonitorSet);
continue;
}
printf("buf=%s\n",buf);
}
else if(FD_ISSET(sfd,&rdset))
{
//sfd可读，表示客户端连接我们
//newFd代表的是跟客户端的TCP连接
printf("accpet\n");
struct sockaddr_in cliAddr
socklen_t sockLen = sizeof(cliAddr);
printf("sockLen=%d\n",sockLen);
/* socklen_t sockLen = 0; */
newFd = accept(sfd,(struct sockaddr*)&cliAddr,&sockLen);
ERROR_CHECK(newFd,-1,"accept");
FD_SET(newFd,&needMonitorSet);
printf("sockLen=%d\n",sockLen);
printf("newFd=%d\n",newFd);
printf("addr=%s,port=%d\n",inet_ntoa(cliAddr.sin_addr),ntohs(cliAddr.sin_port))
;
}
}
close(newFd);
close(sfd);
return 0;
}
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
const struct sockaddr *dest_addr, socklen_t addrlen);
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
struct sockaddr *src_addr, socklen_t *addrlen);
下面是使用UDP通信的一个例子：
//client.c
int main(int argc,char* argv[]){
ARGS_CHECK(argc,3);
int sfd = socket(AF_INET,SOCK_DGRAM,0);
ERROR_CHECK(sfd,-1,"socket");
struct sockaddr_in serAddr;
memset(&serAddr,0,sizeof(serAddr));
serAddr.sin_family = AF_INET;
serAddr.sin_addr.s_addr = inet_addr(argv[1]);
serAddr.sin_port = htons(atoi(argv[2]));
char buf[64]={0};
socklen_t len = sizeof(serAddr);
sendto(sfd,"hello udp",9,0,(struct sockaddr*)&serAddr,len);
sendto(sfd,"hello server",12,0,(struct sockaddr*)&serAddr,len);
recvfrom(sfd,buf,sizeof(buf),0,(struct sockaddr*)&serAddr,&len);
printf("buf=%s\n",buf);
close(sfd);
return 0;
}
//server.c
int main(int argc,char* argv[]){
ARGS_CHECK(argc,3);
int sfd = socket(AF_INET,SOCK_DGRAM,0);
ERROR_CHECK(sfd,-1,"socket");
struct sockaddr_in serAddr;
memset(&serAddr,0,sizeof(serAddr));
serAddr.sin_family = AF_INET;
serAddr.sin_addr.s_addr = inet_addr(argv[1]);
serAddr.sin_port = htons(atoi(argv[2]));
int ret = bind(sfd,(struct sockaddr*)&serAddr,sizeof(serAddr));
ERROR_CHECK(ret,-1,"bind");
char buf[4]={0};
struct sockaddr_in cliAddr;
memset(&cliAddr,0,sizeof(cliAddr));
socklen_t len = sizeof(cliAddr);
recvfrom(sfd,buf,sizeof(buf),0,(struct sockaddr*)&cliAddr,&len);
printf("buf=%s\n",buf);
recvfrom(sfd,buf,sizeof(buf),0,(struct sockaddr*)&cliAddr,&len);
printf("buf=%s\n",buf);
sendto(sfd,"hello client",12,0,(struct sockaddr*)&cliAddr,len);
close(sfd);
return 0;
}
select 的缺陷：
① 存在大量的用户态-》内核态的拷贝
② fdset底层是位图（1024）文件限制
③ 监听和就绪耦合
④ 就绪判断不合理 select();
导致海量连接 少量就绪
优势：
① 除了水平触发，还支持边缘触发。
② 监听事件集合容量很大，有多少内存就能放下多少文件描述符。
③ 监听事件集合常驻内核态，调用 epoll_wait 函数不会修改监听性质，不需要每次将集合从用户态
拷贝到内核态。
④ 监听事件和就绪事件的状态分为两个数据结构存储，当 epoll_wait 就绪之后，用户可以直接遍历就绪事件队列，而不需要在所有事件当中进行轮询。
使用流程：
① 创建epoll文件对象
② 设置监听集合
③ 等待，直到任意监听的事件就绪
④ 遍历就绪集合。
int epoll_create(int size);
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
int epoll_wait(int epfd, struct epoll_event *events,
int maxevents, int timeout);
typedef union epoll_data {
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};
使用 epoll 主要有这样几个函数：
提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。