linux学习笔记--网络编程
目录
- 概念
-
- 协议
- 网络应用设计模式
- 分层模型
- 协议格式
-
- TCP状态
- 网络名词
- socket编程
-
- 套接字
- 字节序
- 函数
-
- socket
- bind
- listen
- accept
- connect
- C/S模型
-
- server
- client
- 封装
- 高并发服务器
-
-
- 进程方式
- 线程方式
- 多路io
-
- select
- poll
- epoll
- 线程池
-
- UDP
-
- CS模型
- 广播
- 组播
- 本地套接字domain socket
黑马教程的视频学习记录
概念
协议
网络应用设计模式
B/S C/S
分层模型
OSI七层，TCP/IP四层
协议格式
数据包
以太网帧
ARP数据
IP
UDP: 无连接的不可靠报文传输
TCP状态
TCP：面向连接的可靠数据包传输
三次握手和四次握手标志位（主要是存在半关闭状态，所以断开连接时，收到确认断开和发起断开请求不一定在一起）
请求连接SYN，应答ACK，请求断开FIN
状态转换图：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UYju395O-1642467862986)(G:\学习资料\linux服务器开发三-网络编程\image-20220104192118868.png)]
实线（客户端流程）：客户端主动发起连接，客户端变为SYN_SENT，等待对端SYN,ACK，然后发送ACK，状态变成数据传输状态ESTABLISHED，关闭连接时，客户端发送FIN，状态变成FIN_WAIT_1；服务端闲时回复ACK，客户端变成FIN_WAIT_2，半关闭状态；服务端发送FIN到客户端，客户端发送ACK后，客户端变成TIME_WAIT状态，此时客户端等待2MSL超时时长（linux一般一分钟左右），确保服务端可以接受到ACK；
虚线（服务端流程）：服务端调用accept，状态由CLOSE变成LISTEN，客户端发送请求，服务端回复SYN+ACK，状态变成SYN_RCVD，客户端回复一个ACK，服务端接收到了后变成ESTABLISHED状态；关闭时，接受到客户端FIN并回复ACK，状态变成CLOSE_WAIT；服务端准备好了，发送FIN，状态变为LAST_ACK；
细线：客户端处于SYN_SENT时，发送连接请求并且服务端很快回复了SYN+ACK，基本同时发生；当两端同时关闭时，即同时发送FIN和ACK，可能进入CLOSING，更接近时可能直接进入TIME_WAIT阶段。
网络名词
路由
路由表
hub工作原理
MTU
socket编程
套接字
字节序
一般主机使用的是小端字节序，即低地址存储地位字节，高地址存储高位字节，而网络传输使用的大端字节序刚好相反；如十六进制数 0x03e8需要两个字节存储，03为高位，e8为地位，在小端字节序中，03存储到地址1，e8存储到地址0。
所以发送和接收网络数据时都应该进行字节序的转换。
#include h表示host，n表示network，l表示32位长整数，s表示16位短整数。
如果主机是小端字节序，这些函数将参数做相应的大小端转换然后返回，如果主机是大端字节序，这些函数不做转换，将参数原封不动地返回。
ip地址的转换还可以使用inet_pton函数：
#include 网络套接字函数使用的结构体sockaddr和sockaddr_in
struct sockaddr {
sa_family_t sa_family; /* address family, AF_xxx */
char sa_data[14]; /* 14 bytes of protocol address */
};
struct sockaddr_in {
__kernel_sa_family_t sin_family; /* Address family */ 地址结构类型
__be16 sin_port; /* Port number */ 端口号
struct in_addr sin_addr; /* Internet address */ IP地址
};
struct in_addr { /* Internet address. */
__be32 s_addr;
};
历史原因，函数使用的结构体为sockaddr，但是我们只能定义sockaddr_in；所以需要在使用函数时转换类型。
函数
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZPnUtd7S-1642467862987)(G:\学习资料\linux服务器开发三-网络编程\image-20211228193356349.png)]
socket
#include socket()打开一个网络通讯端口，如果成功的话，就像open()一样返回一个文件描述符，应用程序可以像读写文件一样用read/write在网络上收发数据，如果socket()调用出错则返回-1。
对于IPv4，domain参数指定为AF_INET。对于TCP协议，type参数指定为SOCK_STREAM，表示面向流的传输协议。如果是UDP协议，则type参数指定为SOCK_DGRAM，表示面向数据报的传输协议。
protocol参数的介绍从略，指定为0即可。
bind
#include 服务器程序所监听的网络地址和端口号通常是固定不变的，客户端程序得知服务器程序的地址和端口号后就可以向服务器发起连接，因此服务器需要调用bind绑定一个固定的网络地址和端口号。
bind()的作用是将参数sockfd和addr绑定在一起，使sockfd这个用于网络通讯的文件描述符监听addr所描述的地址和端口号。前面讲过，struct sockaddr *是一个通用指针类型，addr参数实际上可以接受多种协议的sockaddr结构体，而它们的长度各不相同，所以需要第三个参数addrlen指定结构体的长度。如:
struct sockaddr_in servaddr;
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(6666);
首先将整个结构体清零，然后设置地址类型为AF_INET，网络地址为INADDR_ANY，这个宏表示本地的任意IP地址，因为服务器可能有多个网卡，每个网卡也可能绑定多个IP地址，这样设置可以在所有的IP地址上监听，直到与某个客户端建立了连接时才确定下来到底用哪个IP地址，端口号为6666。
listen
#include 典型的服务器程序可以同时服务于多个客户端，当有客户端发起连接时，服务器调用的accept()返回并接受这个连接，如果有大量的客户端发起连接而服务器来不及处理，尚未accept的客户端就处于连接等待状态，listen()声明sockfd处于监听状态，并且最多允许有backlog个客户端处于连接待状态，如果接收到更多的连接请求就忽略。listen()成功返回0，失败返回-1。
listen函数并不是监听，而是设置允许同时建立连接的个数。
accept
#include 三方握手完成后，服务器调用accept()接受连接，如果服务器调用accept()时还没有客户端的连接请求，就阻塞等待直到有客户端连接上来。addr是一个传出参数，accept()返回时传出客户端的地址和端口号。addrlen参数是一个传入传出参数（value-result argument），传入的是调用者提供的缓冲区addr的长度以避免缓冲区溢出问题，传出的是客户端地址结构体的实际长度（有可能没有占满调用者提供的缓冲区）。如果给addr参数传NULL，表示不关心客户端的地址。
程序的结果如下：
while (1) {
cliaddr_len = sizeof(cliaddr);
connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);
n = read(connfd, buf, MAXLINE);
......
close(connfd);
}
整个是一个while死循环，每次循环处理一个客户端连接。由于cliaddr_len是传入传出参数，每次调用accept()之前应该重新赋初值。accept()的参数listenfd是先前的监听文件描述符，而accept()的返回值是另外一个文件描述符connfd，之后与客户端之间就通过这个connfd通讯，最后关闭connfd断开连接，而不关闭listenfd，再次回到循环开头listenfd仍然用作accept的参数。accept()成功返回一个文件描述符，出错返回-1。
connect
#include 客户端需要调用connect()连接服务器，connect和bind的参数形式一致，区别在于bind的参数是自己的地址，而connect的参数是对方的地址。connect()成功返回0，出错返回-1。
C/S模型
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yKwr1SOs-1642467862987)(G:\学习资料\linux服务器开发三-网络编程\image-20211228200554919.png)]
服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。
数据传输的过程：
建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，服务器被动处理请求，一问一答的方式。因此，服务器从accept()返回后立刻调用read()，读socket就像读管道一样，如果没有数据到达就阻塞等待，这时客户端调用write()发送请求给服务器，服务器收到后从read()返回，对客户端的请求进行处理，在此期间客户端调用read()阻塞等待服务器的应答，服务器调用write()将处理结果发回给客户端，再次调用read()阻塞等待下一条请求，客户端收到后从read()返回，发送下一条请求，如此循环下去。
如果客户端没有更多的请求了，就调用close()关闭连接，就像写端关闭的管道一样，服务器的read()返回0，这样服务器就知道客户端关闭了连接，也调用close()关闭连接。注意，任何一方调用close()后，连接的两个传输方向都关闭，不能再发送数据了。如果一方调用shutdown()则连接处于半关闭状态，仍可接收对方发来的数据。
在学习socket API时要注意应用程序和TCP协议层是如何交互的： 应用程序调用某个socket函数时TCP协议层完成什么动作，比如调用connect()会发出SYN段 应用程序如何知道TCP协议层的状态变化，比如从某个阻塞的socket函数返回就表明TCP协议收到了某些段，再比如read()返回0就表明收到了FIN段
server
server.c的作用是从客户端读字符，然后将每个字符转换为大写并回送给客户端。
#include 下面是自己测试的
#include通过另外一个cmd控制台输入命令nc 127.0.0.1 666进行通讯连接，发送数据，返回大写。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZetdQk1S-1642467862987)(G:\学习资料\linux服务器开发三-网络编程\image-20211229082245968.png)]
client
客户端可以不调用bind，系统会隐式绑定。
#include封装
读指定字节数，每次发送的帧可能不够数组的总长度，需要多次读，这样就需要拼接了，如，数据长度为4096个字节，但是每次数据发送的最大长度限制到了1500字节，那么就需要读四次。
ssize_t是有符号整型；
//socket套接字，接收存储的缓存区指针，接收缓存区的大小
ssize_t Readn(int fd, void *vptr, size_t n)
{
size_t nleft; // unsigned int 剩余的未读取的字节数
ssize_t nread; // int 实际读到的字节数
char *ptr;
ptr = vptr;
nleft = n; //n 未读取的字节数，初始化为缓存区大小
while(nleft > 0)
{
if ((nread = read(fd, ptr, nleft)) < 0)
{
if(errno == EINTR)
{
nread = 0;
} else if (nread == 0)
break;
}
nleft -= nread;//记录剩余 空间 大小
ptr += nread;//指针先后移，继续下次向后面 读取完存储
}
return n - nleft;
}
读取一行
//因为是静态声明，所以局部变量可以保持不变，不清空？
static ssize_t my_read(int fd, char *ptr)
{
static int read_cnt;//可以没有初始值吗
static char *read_ptr;
static char read_buf[100];
if (read_cnt <= 0)
{
again:
if((read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0)
{//错误处理
if (errno == EINTER)
goto again;
return -1;
} else if (read_cnt == 0)
return 0;
read_ptr = read_buf;
}
read_cnt--;
*ptr = *read_ptr++;//每次调用取出一个字节数据，没有了再read
return 1;
}
ssize_t readline(int fd, void *vptr, size_t maxlen)
{
ssize_t n, rc;
char c,*ptr;
ptr = vptr;
for(n = 1; n <maxlen; n++)
{
if ((rc = my_read(fd, &c)) == 1)
{
*ptr++ = c;
if(c == '\n')//读取结束
{
break;
}
}
else if (rc == 0) //读取结束
{
*ptr = 0;
return n - 1;
}
else // 错误
{
return -1;
}
}
*ptr = 0;
return n;
}
高并发服务器
进程方式
//hserver.c
#includefork时的fd是有关联的，但fork之后各自再新建的fd，即使值相同，也是相互没有关联的。 所以fork之后，创建其他fd之前，应该马上对各自的fd进行处理，父进程关闭accept到的fd，子进程关闭listen的fd；至于每次都是相同fd，这个没关系的，不同的进程，相同的fd是相互不会影响的，进程是相互隔离的
以下为封装后的socket函数
//wrap.c
#include 头文件
wrap.h
#ifndef __WRAP_H_
#define __WRAP_H_
void perr_exit(const char *s);
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr);
int Bind(int fd, const struct sockaddr *sa, socklen_t salen);
int Connect(int fd, const struct sockaddr *sa, socklen_t salen);
int Listen(int fd, int backlog);
int Socket(int family, int type, int protocol);
ssize_t Read(int fd, void *ptr, size_t nbytes);
ssize_t Write(int fd, const void *ptr, size_t nbytes);
int Close(int fd);
ssize_t Readn(int fd, void *vptr, size_t n);
ssize_t Writen(int fd, const void *vptr, size_t n);
ssize_t my_read(int fd, char *ptr);
ssize_t Readline(int fd, void *vptr, size_t maxlen);
#endif
编译
gcc wrap.c -c -Wall
gcc hserver.c -c -Wall
gcc wrap.o hserver.o -o -Wall
线程方式
//hservert.c
#include 多路io
多线程与多进程处理连接请求，全部由用户程序执行，消耗cpu比较严重。
select
最大监听1024个文件描述符。
#includepoll
针对linux系统，文件描述符上限可以大于1024（相较于select）
#includeepoll
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);
#include非阻塞io边沿触发示例
read时不进行阻塞，epoll_wait当接收数据时才返回
/*
*epoll基于非阻塞I/O事件驱动
*/
#include 线程池
thread_poll.h
#ifndef __THREADPOOL_H_
#define __THREADPOOL_H_
typedef struct threadpool_t threadpool_t;
/**
* @function threadpool_create
* @descCreates a threadpool_t object.
* @param thr_num thread num
* @param max_thr_num max thread size
* @param queue_max_size size of the queue.
* @return a newly created thread pool or NULL
*/
threadpool_t *threadpool_create(int min_thr_num, int max_thr_num, int queue_max_size);
/**
* @function threadpool_add
* @desc add a new task in the queue of a thread pool
* @param pool Thread pool to which add the task.
* @param function Pointer to the function that will perform the task.
* @param argument Argument to be passed to the function.
* @return 0 if all goes well,else -1
*/
int threadpool_add(threadpool_t *pool, void*(*function)(void *arg), void *arg);
/**
* @function threadpool_destroy
* @desc Stops and destroys a thread pool.
* @param pool Thread pool to destroy.
* @return 0 if destory success else -1
*/
int threadpool_destroy(threadpool_t *pool);
/**
* @desc get the thread num
* @pool pool threadpool
* @return # of the thread
*/
int threadpool_all_threadnum(threadpool_t *pool);
/**
* desc get the busy thread num
* @param pool threadpool
* return # of the busy thread
*/
int threadpool_busy_threadnum(threadpool_t *pool);
#endif
pthread_poll.c
#include UDP
CS模型
server
#include client
#include 广播
IP：172.30.10.255（广播地址）
IP：172.30.10.1（网关）
使用setsockopt设置权限
server
#include client
#include 组播
server
#include client
#include 本地套接字domain socket
server
#include client
#include