『Linux高性能服务器编程』读书笔记

//1. 主机序和网络字节序转换
#include <netinet/in.h>
unsigned long int htonl (unsigned long int hostlong); // host to network long
unsigned short int htons (unsigned short int hostlong); // host to network short

unsigned long int ntonhl (unsigned long int netlong);//network to host long 
unsigned short int ntohs (unsigned short int netlong);//network to host short 
  
//2. socket地址
//2.1 通用socket结构 sockaddr
struct sockaddr
  {
    sa_family_t sa_family;	/* 地址族，AF_XXX  */
    char sa_data[14];		/* Address data.包含目的地址和端口信息  */
  };
/*
  sa_family: 2字节地址族：
    AF_UNIX :UNIX本地地址族
    AF_INET :TCP/IPv4地址族
    AF_INET6:TCP/IPv6地址族
*/

//2.2 专用socket结构 sockaddr_in，与前者相比把port和addr分开存储到了两个变量中
struct sockaddr_in
  {
    sa_family_t sin_family;     /* 地址族，AF_XXX  */
    in_port_t sin_port;			/* 端口号，要用网络字节序*/
    struct in_addr sin_addr;	/* IPv4地址结构体，见↓ */
  };
//存储IPv4的数据结构
struct in_addr
  {
    uint32_t s_addr; /* IPv4地址，要用网络字节序表示*/
  };


//3. IP地址转换函数
#include <arpa/inet.h>
// 将点分十进制字符串的IPv4地址, 转换为网络字节序整数表示的IPv4地址. 失败返回INADDR_NONE
in_addr_t inet_addr( const char* strptr);
/*例如：*/ sockaddr_in.sin_addr.s_addr=inet_addr("127.0.0.1");
 
// 功能相同不过转换结果存在 inp指向的结构体中. 成功返回1 反之返回0
int inet_aton( const char* cp, struct in_addr* inp);

//将IPv4地址转化为点分十进制IP地址字符串，和上述两个函数功能相反
//该函数使用一个内部静态存储转化结果，函数返回值指向该静态内存，所以此函数是不可重入的！
char* inet_ntoa(struct in_addr in); 

//以下函数也能完成前面3个函数同样的功能，并且同时适用于IPv4和IPv6
//将点分十进制或者十六进制IP地址转化为网络字节序表示的地址
int inet_pton(int af, const char * src, void* dst);
/*
  af:地址族 AF_INET or AF_INET6
  src:IP地址
  dst:转化的地址
  成功返回1，失败返回0并设置errno
*/
//和上述功能相反
const char* inet_ntop(int af, const void*  src, char* dst, socklen_t cnt);
/*
  前三者和inet_pton一样，src和dst交换了顺序
  cnt指定目标存储单元大小，可用INET_ADDRSTRLEN, INET6_ADDRSTRLEN表示
*/

//4. 创建socket
int socket(int domain, int type, int protocol);
/*
  domain:底层协议族
    PF_UNIX :UNIX本地协议族
    PF_INET :TCP/IPv4协议族
    PF_INET6:TCP/IPv6协议族
    (地址族和协议族事实上是一一对应的，在前UNIX时代有所区分，在Linux上已完全兼容，不过为了规范区分一下也行)
  type:通讯类型(服务类型)
    SOCK_STREAM(流服务，TCP协议)
    SOCK_DGRAM(数据报服务，UDP类型)
  protocol:通常为0
  socket调用成功时返回一个socket文件描述符，失败返回-1并设置errno
*/

//5. 命名socket
//作用于服务端，将一个socket和socket地址进行绑定称为给socket命名
int bind(int socket, const struct sockaddr* my_addr, socklen_t addrlen);
/*
  socket:创建socket返回的文件描述符
  my_addr:my_addr所指的socket地址
  addrlen:socket结构长度
  成功返回0，失败返回-1
*/

//6. 监听socket
//作用于服务端，监听socket所绑定的套接字
int listen(int socket, int backlog);
/*
  socket:创建socket返回的文件描述符
  backlog表示队列最大的长度
  如果长度超过backlog，客户端会受到ECONNREFUSED错误信息
*/ok'l'l

//7. 接受连接
//作用于服务端，响应连接请求，建立与Client连接
int accept(int sockfd, struct sockaddr* addr, socklen_t* addrlen)
/*
  sockdf:创建socket返回的文件描述符
  addr:获取被接收的远程socket地址
  addrlen：addr长度
  成功返回用于和Client数据传输的文件描述符
*/

//8. 发起连接
//作用于Client程序，连接到某个服务端
int connect(int sockfd, const struct sockaddr * serv_addr, socklen_t addrlen);
/*
  sockdf:创建socket返回的文件描述符
  serv_addr:被连接服务器信息
  addrlen:serv_addr长度
  成功返回0 失败返回-1
*/

//9. 关闭socket
#include <unistd.h>
int close(int fd);
//并非立即关闭, 将socket的引用计数-1, 当fd的引用计数为0, 才是真正的关闭。(多进程fork调用会是父进程socket引用+1)

// 立即关闭
#include <sys/socket.h>
int shutdown(int sockfd, int howto)
/*
第二个参数为可选值 
  SHUT_RD 关闭读, socket的接收缓冲区的数据全部丢弃
  SHUT_WR 关闭写 socket的发送缓冲区全部在关闭前发送出去
  SHUT_RDWR 同时关闭读和写
  成功返回0 失败为-1 设置errno
*/

//1. TCP数据读写
#include<sys/socket.h>
ssize_t recv(int sockfd, void *buf, size_t len, int flags);
/*
  buf:指向接受信息的缓冲区指针
  len:buf缓冲区大小
  flags:一般设置为0，特殊情况查表
  返回成功接受的字节，0表示已关闭，失败返回-1
*/
ssize_t send(int sockfd, const void *buf, size_t len, int flags);
/*
  buf:指向需要发送信息的缓冲区指针
  len:buf缓冲区大小
  flags:一般设置为0，特殊情况查表
  返回成功发送的字节数，失败返回-1
*/

//2. UDP数据读写  
#include <sys/socket.h>
// 由于UDP不保存状态, 每次发送数据都需要 加入目标地址.
// 如果实现有建立连接，把最后两项设为null，等同于TCP数据读写
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr* src_addr, socklen_t* addrlen);
ssize_t sendto(int sockfd, const void* buf, size_t len, ing flags, const struct sockaddr* dest_addr, socklen_t addrlen);

//3. 通用数据读写
#inclued <sys/socket.h>
ssize_t recvmsg(int sockfd, struct msghdr* msg, int flags);
ssize_t sendmsg(int sockfd, struct msghdr* msg, int flags);
//msg参数是msghdr结构体类型的指针，msghdr结构体类型定义如下：
struct msghdr
{
  //指向socket地址结构变量, 对于TCP连接需要设置为NULL
  void* msg_name;                                            
  socklen_t msg_namelen;
	
/*
  分散的内存块
  对于 recvmsg来说数据被读取后将存放在这里的块内存中, 内存的位置和长度由msg_iov指向的数组指定, 称为分散读(scatter read)
  对于sendmsg而言, msg_iovlen块的分散内存中的数据将一并发送称为集中写(gather write);
*/
  struct iovec* msg_iov;
  int msg_iovlen; /* 分散内存块的数量*/
  void* msg_control; /* 指向辅助数据的起始位置*/
  socklen_t msg_controllen; /* 辅助数据的大小*/
  int msg_flags; /* 复制函数的flags参数, 并在调用过程中更新*/
};

struct iovec
{
  void* iov_base /* 内存起始地址*/
  size_t iov_len /* 这块内存长度*/
}

//1. 获取主机信息
#include <netdb.h>
//1.1 通过主机名获取主机信息
struct hostent* gethostbyname(const char* name);

//1.2 通过ip获取主机完整信息 
struct hostent* gethostbyaddr(const void* addr, size_t len, int type);
// type为IP地址类型 AF_INET和AF_INET6

struct hostent
{
  char *h_name;			//主机名
  char **h_aliases;		//主机别名 可能有多个
  int h_addrtype;		//地址组
  int h_length;			//地址长度
  char **h_addr_list;		//按网络字节序列出的主机IP地址列表
}

//2. 获取服务信息
#include <netdb.h>
//2.1 根据名称获取某个服务的完整信息
struct servent getservbyname(const char* name, const char* proto);
//2.2 根据端口号获取服务信息
struct servent getservbyport(int port, const char* proto);

struct servent
{
	char* s_name; /* 服务名称*/
	char ** s_aliases; /* 服务的别名列表*/
	int s_port; /* 端口号*/
	char* s_proto; /* 服务类型, 通常为TCP或UDP*/
}

//创建管道，实现进程间通讯
#include <unistd.h>
//从fd[1]写入的数据可以从fd[0]读出
int pipe(int fd[2]);

//双向管道
#include <sys/socket.h>
int socketpair(int domain, int type, int protocol, int fd[2]);

//输入重定向
//复制一个现有的文件描述符，返回的文件描述符总是取系统当前可用的最小整数值
#include <unistd.h>
int dup(int oldfd);

//分散读和集中写
ssize_t readv(int fd, const struct iovec* vector, int count);
ssize_t writev(int fd, const struct iovec* vector, int count);

struct iovec {
	void* iov_base /* 内存起始地址*/
	size_t iov_len /* 这块内存长度*/
}

//传输文件
#include <sys/sendfile.h>
// offset为指定输入流从哪里开始读, 如果为NULL 则从开头读取
ssize_t sendfile(int out_fd, int in_fd, off_t* offset, size_t count);
//可以使用writev发送文件，但是sendfile没有分配用户空间的缓存，也没有执行读取文件的操作，效率会高一些。

//两个文件描述符之间移动数据,零拷贝
#include <fcntl.h>
ssize_t splice(int fd_in, loff_t* off_in, int fd_out, loff_t* off_out, size_t len, unsigned int flags);
//举个例子 echo服务器
int connfd = accept......;
int pipefd[2];
//把connfd上流入的客户端数据定向到管道
splice( connfd, NULL, pipefd[1], NULL, 32768, SPLICE_F_MORE | SPLICE_F_MOVE );
//把管道的输出数据定向到connfd客户连接文件描述符
splice( pipefd[0], NULL, connfd, NULL, 32768, SPLICE_F_MORE | SPLICE_F_MOVE );

//tee也可以用作数据复制，不过只能用于管道文件描述符
ssize_t tee(int fd_in, loff_t* off_in, int fd_out, loff_t* off_out, size_t len, unsigned int flags);

...
	int connfd = accept(...);
    fd_set read_fds;
    fd_set exception_fds;

    FD_ZERO( &read_fds );
    FD_ZERO( &exception_fds );
    while( 1 )
    {
        memset( buf, '\0', sizeof( buf ) );
        //每次select前为什么都要重新设置文件描述符
        FD_SET( connfd, &read_fds );
        FD_SET( connfd, &exception_fds );

        ret = select( connfd + 1, &read_fds, NULL, &exception_fds, NULL );
        printf( "select one\n" );
        if ( ret < 0 )
        {
            printf( "selection failure\n" );
            break;
        }
		//可读模式
        if ( FD_ISSET( connfd, &read_fds ) )
        {
            ret = recv( connfd, buf, sizeof( buf )-1, 0 );
            if( ret <= 0 )
            {
                break;
            }
            printf( "get %d bytes of normal data: %s\n", ret, buf );
        }
        //异常模式
        else if( FD_ISSET( connfd, &exception_fds ) )
        {
            //使用外带数据的读取函数
            ret = recv( connfd, buf, sizeof( buf )-1, MSG_OOB );
            if( ret <= 0 )
            {
                break;
            }
            printf( "get %d bytes of oob data: %s\n", ret, buf );
        }

    }

//select调用原型
#include <sys/select.h>
int select (int nfds, fd_set* readfds, fd_set* writefds, fd_set* exceptfds, struct timeval* timeout);
/*
  nfds:被监听的文件描述符总数，通常是select监听的文件描述符最大值+1
  后三者分别对应可读、可写、异常文件描述符合集，内核通过修改它们来通知哪些文件描述符已就绪。
  timeval：select超时时间 如果传递0 则为非阻塞, 设置为NULL则为阻塞
*/

//fd_set结构体仅仅包含一个整形数组，该数组每个元素的每一位标记一个文件描述符
#include <sys/select.h>
FD_ZERO(fd_set *fdset);        //清除fdset的所有位
FD_SET(int fd,fd_set *fdset);  //设置fdset的fd位
FD_CLR(int fd,fd_set *fdset);  //清除fdset的fd位
int FD_ISSET(int fd,fd_set *fdset));、//检查fdset的fd位是否被设置

FD_ZERO(&readset);
FD_ZERO(&writeset);
FD_SET(0, &readset);
FD_SET(3, &readset);
FD_SET(1, &writeset);
FD_SET(2, &writeset);
select(4, &readset, &writeset, NULL, NULL);

#include <poll.h>
int poll(struct pollfd* fds, nfds_t nfds, int timeout);
/*
  fds: pollfd 结构体类型数组,指定文件描述符上发生的可读可写和异常事件
  nfds：被监听集合fds大小
  timeout 单位为毫秒 -1 为阻塞, 0 为立即返回
*/
struct pollfd
{
	int fd;
	short events;  //注册的事件, 告知poll监听fd上的哪些事件
	short revents; // 实际发生的事件
}

//1. 创建epoll实例，在内核中注册一个数据
//失败返回-1，成功返回epoll实例描述符
int epoll_create(int size); //自从Linux 2.6.8 size参数没有意义，但不能设置为0

//2. 操作epoll实例，对内核时间表进行增添、删除、修改操作
int epoll_ctl(int epfd,int op,int fd,struct epoll_event *event);
/*
  epfd：epoll实例描述符
  fd: 要检测的文件描述符
  op：需要进行的操作：
  	EPOLL_CTL_ADD：添加
  	EPOLL_CTL_DEL：删除
  	EPOLL_CTL_MOD：修改
  event：检测文件描述符的具体事件
*/
struct epoll_events
{
    _uint32_t events; //epoll事件类型，和poll基本上类似，需要在poll的对应宏基础上加上‘E’，两个额外的事件类型EPOLLET和EPOLLONESHOT
    epoll_data_t data;//union类型，其中的fd需要设置
}

//3. 检测epoll实例
//成功已就绪的文件描述符个数，失败返回-1
int epoll_wait(int epfd, struct epoll_event *events,int maxevents, int timeout);
/*
  epfd:epoll实例的文件描述符
  events：传出参数，根据epfd从内核事件表中把所有已就绪的事件复制到events结构体数组中
  maxevents：events结构体数组大小
  timeout：-1堵塞，大于等于0表示堵塞时间
*/

// 索引poll返回的就绪文件描述符
int ret = poll(fds, MAX_EVENT_NUMBER - 1);
// 遍历
for(int i = 0; i < MAX_EVENT_NUMBER; ++i) {
	if(fds[i].revents & POLLIN) {
		int sockfd = fds[i].fd;
	}
}

// 索引epoll返回的就绪文件描述符
int ret = epoll_wait(epoll_fd, events, MAX_EVENT_NUMBER,  -1);
for(int i = 0; i < ret; i++) {
	int sockfd = events[i].data.fd;
}

#include <signal.h>
int kill(pid_t pid, int sig);
/*
  pid > 0 发送给PID为pid标识的进程
  0 发送给本进程组的其他进程
  -1 发送给进程以外的所有进程, 但发送者需要有对目标进程发送信号的权限
  < -1 发送给组ID为 -pid 的进程组中的所有成员

   出错信息 EINVAL 无效信号, EPERM 该进程没有权限给任何一个目标进程 ESRCH 目标进程(组) 不存在
   sig具体在bits/signum.h中
*/

#include <unistd.h>
unsigned int alarm(unsigned int seconds);

// 忽略目标信号
#define SIG_DFL ((_sighandler_t) 0)
// 使用信号的默认处理方式
#define SIG_IGN ((_sighandler_t) 1)

//为单独的信号设置处理函数
#include <signal.h>
// _handler 指定sig的处理函数
_sighandler_t signal(int sig, __sighandler_t _handler)

int sigaction(int sig, struct sigaction* act, struct sigaction* oact);
//一个例子
void addsig( int sig )
{
    struct sigaction sa;
    memset( &sa, '\0', sizeof( sa ) );
    sa.sa_handler = sig_handler;
    sa.sa_flags |= SA_RESTART;
    sigfillset( &sa.sa_mask );
    assert( sigaction( sig, &sa, NULL ) != -1 );
}

fork;
exec;
exit;
wait;
waitpid;
chdir;//修改当前工作目录

//1. 创建信号量
//创建一个全局唯一的信号量集, 或者获取一个已经存在的信号量集
int semget(key_t key, int num_sems, int sem_flags);
/*
  key:所创建信号集的键值，需要时唯一的非整数
  num_sens:创建的信号集中的信号量个数，一般为1，若是获取一个已经存在的集合，则为0
  sem_flags:0666|IPC_CREAT、 IPC_EXCL
*/

//2. 信号量初始化
int semctl(int sem_id, int sem_num, int command, ...);
/*
  sem_id:semget所返回的信号量标识符
  sem_num:被操作信号量在信号集中的编号
  command:如下图
  ...:command所需的参数，联合数据类型
*/
union semun
{
	int              val;    /* Value for SETVAL */
	struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
	unsigned short  *array;  /* Array for GETALL, SETALL */
	struct seminfo  *__buf;  /* Buffer for IPC_INFO
								(Linux-specific) */
};

//3. 操作信号量(PV)
void pv(int sem_id,int op){
    struct sembuf sem_b;
    sem_b.sem_num=0;//信号量编号
    sem_b.sem_op=op; //-1为P操作，1为V操作
    sem_b.sem_flg=SEM_UNDO;
    // IPC_NOWAIT 无论信号量操作是否成功, 都立即返回
	// SEM_UNDO当进程退出的时候, 取消正在进行的semop操作 PV操作系统更新进程的semadj变量
    semop(sem_id,&sem_b,1) m
}

//1. 创建消息队列
int msgget(key_t key, int msgflg);//和semget类似，成功返回标识符

//2. 发送消息
//成功返回0，失败返回-1
int msgsnd(int msqid, const void *msg_ptr, size_t msg_sz, int msgflg);
/*
  msqid:消息队列标识符
  msg_ptr:将发往消息队列的消息结构体指针，结构为：
  struct msg_st{
    long  msg_type;     //消息类型，用户自定义,接收方会根据类型选择接受
    char text[BUFSIZ];  //发送的消息，不一定是char
};
  msg_sz:消息结构体中待传输数据的大小
  msgflag:IPC_NOTWAIT(消息队列满时返回-1)、0(消息队列满时堵塞)
  
*/
//3. 接受消息
int msgrcv(int msqid, void *msg_ptr, size_t msg_sz, long int msgtype, int msgflg);
/*
  除了msgtype，其他四个参数同msgsnd
  msgtype：
    msgtype = 0 读取消息队列第一个消息
    msgtype > 0 读取消息队列第一个类型是msgtype的消息 除非标志了MSG_EXCEPT
    msgtype < 0 读取第一个 类型值 < abs(msgtype)的消息
*/

//4. 控制消息队列
int msgctl(int msqid, int command, struct msqid_ds *buf);
/*
  msqid:消息队列标识符
  command:
    PC_STAT 复制消息队列关联的数据结构存储在buf中
    IPC_SET 将buf中的部分成员更新到目标的内核数据
    IPC_RMID 立即移除消息队列, 唤醒所有等待读消息和写消息的进程
  msqid_ds:如下图
*/

//1. 创建线程
成功返回0，失败返回错误码
int pthread_create(pthread_t* thread, const pthread_attr_t* attr, void* (*start_routine)(void*), void* arg);

//2. 退出线程
void pthread_exit(void* retval);

//3. 回收(等待)线程，类似进程中的waitpid
//成功时返回0, 失败返回错误码
int pthread_join(pthread_t thread, void** retval);

//4. 终止线程
//成功时返回0, 失败返回错误码
int pthread_cancel(pthread_t thread)

// 初始化互斥锁
// 第一个参数指向目标互斥锁, 第二个参数指定属性 nullptr则为默认
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);

// 销毁目标互斥锁
int pthread_mutex_destory(pthread_mutex_t *mutex);

// 针对普通锁加锁
int pthread_mutex_lock(pthread_mutex_t *mutex);

// 针对普通锁立即返回 目标未加锁则加锁 如果已经加锁则返回错误码EBUSY
int pthread_mutex_trylock(pthread_mutex_t *mutex);

// 解锁 如果有其他线程在等待这个互斥锁, 则其中之一获得
int pthread_mutex_unlock(pthread_mutex_t *mutex);

//初始化条件变量
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr *cond_attr);
//下述相当于初始化一个字段全为空的条件变量
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

// 销毁一个正在被等待的条件变量 将会失败并返回EBUSY
int pthread_cont_destory(pthread_cond_t *cond);

// 广播式的唤醒所有等待目标条件变量的线程
int pthread_cont_broadcast(pthread_cond_t *cond);

// 唤醒一个等待目标条件变量的线程
int pthread_cond_signal(pthread_cond_t *cond);

// 等待目标条件变量
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

#include<semaphore>
//创建信号量
int sem_init(sem_t* sem, int pshared, unsigned int value)
/*
  sem:初始化的信号量
  pshared为0表示是当前进程的局部信号量, 否则信号量可以在多个进程间共享
  value:信号量的初始值，设置为1可以当锁使用
*/
// 销毁信号量, 释放其占用的系统资源
int sem_destory(sem_t* sem)

// 以原子操作的形式将信号量的值 -1, 如果信号量的值为0, 则sem_wait将被阻塞直到sem_wait具有非0值 p操作
int sem_wait(sem_t* sem)

// 跟上面的函数相同不过不会阻塞. 信号量不为0则减一操作, 为0则返回-1 errno
int sem_trywait(sem_t* sem)

// 原子操作将信号量的值 +1 v操作
int sem_post(sem_t* sem)