常用API总结

1. 多进程/多线程

1.1 进程

创建进程

/*在当前的进程中创建一个子进程*/
pid_t fork(void);
//返回值：父进程>0,子进程==0

获取进程ID

/*获取当前进程ID*/
pid_t getpid(void); 

/*获取当前父进程ID*/
pid_t getppid(void);

退出进程

/*退出当前进程，并返回status*/
void exit(int status);

回收进程

/*回收所有子进程*/
pid_t wait(int *status);
//参数：status-记录了子进程退出的状态;
//返回值：成功被回收进程ID；失败-1；

/*回收指定进程*/
pid_t waitpid(pid_t pid, int *status, int options);
//参数：pid-要回收的进程id；status-回收进程退出状态；options-是否阻塞:0阻塞WNOHANG非阻塞。
//返回值：>0回收进程id; =0:options=WNOHANG时子进程还在运行; -1已无子进程待回收。

1.2 线程

创建线程

/*创建一个子线程*/
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
//参数：thread-传出被创建的线程ID；attr- 设置线程属性, 一般 NULL；start_routine-函数指针，子线程的处理逻辑；arg-start_routine的参数。
//返回值：成功0；失败错误号:打印错误信息char *strerror(int errnum);

获取线程ID

/*返回线程id*/
pthread_t pthread_self(void);

退出线程

/*当前线程退出, 不会影响其他线程的正常运行*/
void pthread_exit(void *retval);
//参数: retval-退出时要返回的值

结束线程

/*在父线程中指定指定的子线程*/
int pthread_cancel(pthread_t thread);
//参数：thread-取消线程的id
//返回值：成功0，失败错误值。

回收线程

/*这是阻塞函数, 调用一次回收一个子线程，要在主线程(父线程)中使用*/
int pthread_join(pthread_t thread, void **retval);
//参数：pthread-线程id；retval-接收被回收线程的返回值。
//返回值：成功0，失败错误值。 

线程分离

/*在父线程中分离指定的子线程*/
int pthread_detach(pthread_t thread);
//参数：thread-分离线程的id
//返回值：成功0，失败错误值。

比较线程ID

/*在某些平台下的线程ID可能时接口提类型，需要该函数来比较*/
int pthread_equal(pthread_t t1, pthread_t t2);
//返回值：相同非0，不同0；

线程属性

/*通过线程属性来设置线程分离*/
//1.创建属性变量所需的内存
pthread_attr_t t;
//2.初始化申请的内存
int pthread_attr_init(pthread_attr_t *attr);
//3.设置属性实现线程分离
int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
	//参数：detachstate：PTHREAD_CREATE_DETACHED-设置线程分离，PTHREAD_CREATE_JOINABLE: 设置父子线程不分离
//4.释放属性变量的内存
int pthread_attr_destroy(pthread_attr_t *attr);

2. 网络通信

2.2 TCP函数

字节序转换

/*主机字节序转换到网络字节序*/
uint16_t htons(uint16_t hostshort);
uint32_t htonl(uint32_t hostlong);
//参数：hostshort/hostlong - 主机字节序的short/long型数值
//返回值：uint16_t/uint32_t - 网络字节序的short/long型数值

/*网络字节序转到主机字节序*/
uint16_t ntohs(uint16_t hostshort);
uint32_t ntohl(uint32_t hostlong);
//参数：hostshort/hostlong - 网络字节序的short/long型数值
//返回值：uint16_t/uint32_t - 主机字节序的short/long型数值

//h-host; n-network; s-short; l-long;

IP地址转换

/*主机字节序的IP地址 -> 网络字节序的整型数*/
int inet_pton(int af, const char *src, void *dst);
//参数：af-地址组协议,AF_INET-ipv4/AF_INET6-ipv6; src-IP地址的点分十进制字符串; dest-存储转换结果的内存地址
//返回值：成功1，失败-1；

/*网络字节序的整形IP -> 点分十进制字符串IP*/
const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
//参数：af-地址族协议；src-存储要转换的网络字节序ip的地址；dst-转换后的存储地址；size-dst大小
//返回值：成功-指向转换后的存储地址；失败NULL

sockaddr数据结构

typedef unsigned short  uint16_t;
typedef unsigned int   uint32_t;
typedef uint16_t in_port_t;
typedef uint32_t in_addr_t;
typedef unsigned short int sa_family_t;
#define __SOCKADDR_COMMON_SIZE (sizeof (unsigned short int))

/*该结构体用来存储连接时的IP和端口*/
struct sockaddr 
{
    sa_family_t sa_family;		// 地址族协议, ipv4, ipv6
    char     sa_data[14];		// 传输的数据
}

struct sockaddr_in
{
    sa_family_t sin_family; 	// 地址族协议，ipv4，ipv6
    in_port_t sin_port;			// 端口 
    struct in_addr sin_addr;	// IP地址
    unsigned char sin_zero[sizeof (struct sockaddr) - (__SOCKADDR_COMMON_SIZE) - sizeof (in_port_t) - sizeof (struct in_addr)];		//填充字节
}; 

2.2 套接字函数

创建套接字

/*创建监听的文件描述符*/
int socket(int domain, int type, int protocol);
//参数：
	//domain-地址族协议: IF_INET-ipv4,IF_INET6-ipv6
	//type-通信协议: SOCK_STREAM-流式协议，SOCK_DGRAM-报式协议
	//protocol-type协议中的具体通信协议，默认0为流式tcp/报式udp
//返回值：监听的文件描述符fd

绑定ip和端口

/*将监听的文件描述符与本地IP和端口绑定*/
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
//参数：sockfd-监听文件描述符；addr-存储ip和port的结构体；addrlen-addr的大小
//返回值：成功0，失败错误值

设置监听

/*设置开始监听连接*/
int listen(int sockfd, int backlog);
//参数：sockfd-监听的文件描述符；backlog-连接成功但尚未被处理的连接，默认128；
//返回值：成功0，失败错误值

等待连接

/*阻塞等待客户端连接请求，请求到达返回一个通信文件描述符*/
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
//参数：sockfd-监听的文件描述符；addr-传出连接成功的客户端ip和端口信息；addrlen-addr的大小
//返回值：成功-通信的文件描述符，失败-1；

客户端连接函数

/*客户端向服务器发送请求的函数*/
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
//参数：sockfd-socked()得到的通信文件描述符；addr-要连接的服务器ip和端口信息；addrlen-addr大小
//返回值：成功0，失败-1

读写数据

/*写数据*/
ssize_t write(int fd, const void *buf, size_t count);
//参数：fd-通信的文件描述符，即缓存区；buf-将此处数据写到fd；count-写入的大小
//返回值：成功：写入的byte数，失败-1；

/*读数据*/
ssize_t read(int fd, void *buf, size_t count);
//参数：fd-通信的文件描述符，即缓存区；buf-将fd数据读到此处；count-读出的大小
//返回值：成功：读出的byte数，失败-1；

3. 多路IO转接

3.1 select函数

select

/*委托内核检测指定的文件描述符读写异常操作*/
int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
//参数：nfds-委托内核检测的最大文件描述符+1；readfds-委托内核检测读操作的文件描述符集合；writefds-写集合；excepfds-异常集合；timeout-阻塞时间，不阻塞0，一直阻塞至文件描述符变化NULL
//返回值：成功-被改写的文件描述符数，失败-1

struct timeval
{
	long tv_sec;	//秒
    long tv_usec;	//微秒
};

文件描述符表设置函数

/*清零该标志位*/
void FD_CLR(int fd, fd_set *set);

/*判断该标志位是0/1*/
int FD_ISSET(int fd, fd_set *set);

/*置1该标志位*/
void FD_SET(int fd, fd_set *set);

/*清零文件描述符表*/
void FD_ZERO(fd_set *set);epoll

3.2 epoll函数

创建epoll树

/*创建一颗红黑树*/
int epoll_create(int size);
//参数：size-无意义，因为二叉树不限制大小。
//返回值：成功-epoll树的根节点，失败--1；

管理epoll树

/*向epoll树增改删点*/
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
//参数：epfd-epoll树根节点；op-EPOLL_CTL_ADD/MOD/DEL向epfd增/改/删节点；fd-要检测的文件描述符；event-要检测fd的什么事件
//返回值：成功0，失败-1

/*struct epoll_event结构体*/
struct epoll_event
{
    uint32_t events;	//监测的事件
    epoll_data_t data;	//监测的数据类型
};
//参数：
//events选项
    EPOLLIN - 读事件;
    EPOLLOUT - 写事件;
    EPOLLERR - 异常事件;
//epill_data_t共同体
    typedef union epoll_data
    {
        void *ptr;	// 复杂
        int fd;	 	// 简单
        uint32_t u32;
        uint64_t u64;
    } epoll_data_t;

监测epoll树

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
//参数：epfd-epoll树根节点；events-传出保存的已发生变化的fd信息；maxevents-events的数量；timeout->0阻塞时间，0不阻塞，-1一直阻塞
//返回值：成功-发生状态的fd数量；失败-1；被信号打断-0；

4. openssl加密

4.1 哈希算法

散列值变量

//获取散列值需要的变量
int MD5_Init(MD5_CTX *c);
//参数：c-传出参数，生成的变量
//返回值：成功 - 1；失败 - 其他；

哈希运算

int MD5_Update(MD5_CTX *c, const void *data, unsigned long len);
//参数：c-散列值变量；data-进行哈希运算的数据；len-data的长度；
//返回值：成功 - 1； 失败 - 其他；

生成散列值

int MD5_Final(unsigned char *md, MD5_CTX *c);
//参数：md-传出参数，得到的散列值，长度为MD5_DIGEST_LENGTH
//返回值：成功 - 1， 失败 - 其他；

一次性哈希运算

unsigned char *MD5(const unsigned char *d, unsigned long n, unsigned char *md);
//参数：d-进行哈希运算的字符串；n-d的长度；md-传出参数，得到的散列值
//返回值：得到的散列值

4.2 非对称加密

生成RSA密钥对

//申请存储密钥对的内存
RSA *RSA_new(void);
BIGNUM *BN_new(void);
//初始化BN_new()申请的空间；
int BN_set_word(BIGNUM *e, unsigned int v);
//参数：e-BN_new()申请的空间；v-无限制，随便填写，一般大于10；


//生成密钥对，存储到申请的内存中
int RSA_generate_key_ex(RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb);
//参数：rsa-RSA_new()申请的内存，存放密钥对；bits-密钥长度，单位bit；e-BN_new()申请的内存；cb—函数指针，一般为NULL;

提取密钥

//提取密钥对的公钥
RSA *RSAPublicKey_dup(RSA *rsa);
//提取密钥对的私钥
RSA *RSAPrivateKey_dup(RSA *rsa);
//参数：rsa-要提取的密钥对
//返回值：提取的公钥/私钥

密钥存到磁盘

//通过fopen方式
int PEM_write_RSAPublicKey(FILE *fp, const RSA *r);
int PEM_write_RSAPrivateKey(FILE *fp, const RSA *r, const EVP_CIPHER* enc,  unsigned char* kstr, int klen, pem_password_cb *cb, void* u);
//参数：fp-通过fopen打开的文件；r-密钥对；enc-对私钥数据加密使用的加密算法，不加密为NULL；kstr-对称加密算法的密钥，NULL；klen-对称加密的密钥长度，0；cb-回调函数，NULL；u-回调函数参数，NULL；

//通过BIO方式
//打开文件
BIO *BIO_new_file(const char *filename, const char *mode);
//参数：filename-文件名；mode-对磁盘文件的操作方式，r/w/r+/w+
//返回值：用于操作文件的变量
int PEM_write_bio_RSAPublicKey(BIO* bp, const RSA* r);
int PEM_write_bio_RSAPrivateKey(BIO* bp, const RSA* r, const EVP_CIPHER* enc, unsigned char* kstr, int klen, pem_password_cb *cb, void* u);
//参数：bp-BIO_new_file()得到的变量；r-磁盘文件；

磁盘提取密钥

RSA* PEM_read_RSAPublicKey(FILE* fp, RSA** r, pem_password_cb *cb, void* u);
RSA* PEM_read_RSAPrivateKey(FILE* fp, RSA** r, pem_password_cb *cb, void* u);

BIO *BIO_new_file(const char *filename, const char *mode);
RSA* PEM_read_bio_RSAPublicKey(BIO* bp, RSA** r, pem_password_cb *cb, void* u);
RSA* PEM_read_bio_RSAPrivateKey(BIO* bp, RSA** r, pem_password_cb *cb, void* u);
//参数：cb-回调函数，NULL；u-cb的参数
//返回值：成功-指向r的地址；失败-NULL

非对称加密

int RSA_public_encrypt(int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding);
int RSA_private_decrypt(int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding);
int RSA_private_encrypt(int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding);
int RSA_public_decrypt(int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding);
//参数：flen-要加密数据的长度，最大长度为密钥长度-11；from-传入参数，要加密的数据；to-传出参数，存储加密后的密文；rsa-公钥/私钥；padding-填充，一般RSA_PKCS1_PADDING, 占11字节

签名验证

//签名函数
int RSA_sign(int type, const unsigned char *m, unsigned int m_length, unsigned char *sigret, unsigned int *siglen, RSA *rsa);

//校验函数
int RSA_verify(int type, const unsigned char *m, unsigned int m_length, const unsigned char *sigbuf, unsigned int siglen, RSA *rsa);
//参数：type-指定哈希算法,NID_MD5/NID_SH1...；m-要签名的数据；m_length-m的长度；sigret-传出参数，存储签名之后的数据；sigbuf-传入参数，要校验的数据；siglen-得到的签名长度/要校验的签名长度；rsa-私钥/公钥；
//返回值：成功 - 1；失败 - !=1；

4.3 对称加密

生成Key

//生成加密密钥
int AES_set_encrypt_key(const unsigned char *userKey, const int bits, AES_KEY *key);
//生成解密密钥
int AES_set_decrypt_key(const unsigned char *userKey, const int bits, AES_KEY *key);
//参数：userKey-密钥字符串，长度16/24/32byte；bits-密钥长度；bits-userKey的长度, 单位bit；key-传出参数，生成的Key；

CBC加密

void AES_cbc_encrypt(const unsigned char *in, unsigned char *out, size_t length, const AES_KEY *key, unsigned char *ivec, const int enc);
/*参数：
in - 要加密/解密的明文/密文；
out - 加/解密得到的密/明文；
length - in的长度，必须是16的整数倍 (strlen(in)+1) % 16 == 0，若不够需要填充length = ((stlen(in)+1) / 16 +1) * 16；
key - 密钥生成的key;
ivec - 初始化字符串，取16个字符与第一个明文进行位运算，加解密时要保证16字符相同；
enc-加密AES_ENCRYPT(实际1), 解密AES_DECRYTO(实际0);
*/