1. 通用 - socket
2. 客户端 - connect
3. 服务端 - bind
4. 服务端 - listen
5. 服务端 - accept
6. getaddrinfo
7. getnameinfo
8. open_clientfd
9. open_listenfd

socket

#include <sys/types.h>
#include <sys/socket.h>

int socket(int domain, int type, int protocol);

1. domain 表示主机名称, AF_INET表示使用32位IP地址. 之前的Head First C 中使用了PF_INET. 这个见下边详述.
2. type 表示套接字类型, 每个协议支持的套接字类型不同, 对于TCP/IP的连接固定使用 SOCK_STREAM 这个宏定义.
3. protocol 是协议编号.

客户端 - connect

#include <sys/socket.h>

int connect(int sockfd, conststruct sockaddr *addr, socklen_t addrlen);

1. sockfd, 指的是套接字描述符, 即刚才使用socket函数的返回值.
2. addr, 指向服务器套接字地址数据结构的指针, 注意这是通用的 sockaddr 类型的指针, 具体使用的时候需要转换成 sockaddr_in 类型的指针.
3. addrlen, 这个指的是前边套接字地址数据结构的大小, 就是 sizeof(sockaddr_in)

服务端 - bind

#include <sys/socket.h>

int bind(int sockfd, const struct sockaddr* myaddr, socklen_t addrlen)

1. sockfd, 服务器调用 socket 函数创建的套接字描述符.
2. myaddr, 指向服务器自己的套接字地址数据结构的指针.
3. addrlen, 是 sizeof(myaddr)

服务端 - listen

#include <sys/socket.h>

int listen(int sockfd, int backlog)

1. sockfd, 经过socket和bind调用之后的套接字描述符
2. backlog, 排队等待的连接数量

服务端 - accept

#include <sys/socket.h>

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)

1. sockfd, 经过socket, bind, listen 之后的套接字描述符
2. addr, 注意, 这个指针不再是读取数据只用, 而是将客户端的套接字地址数据写入到指针指向的 sockaddr 结构中.
3. addrlen, 注意, 这不像上边几个函数是int, 而是int指针, 是将客户端的套接字地址结构的长度写入到这个指针指向的int变量中.

getaddrinfo

#include <sys/types.h>
#include <sys/socket.h>
@include <netdb.h>

int getaddrinfo(const char *hostname, const char *service, const struct addrinfo *hints, struct addrinfo **result);

void freeaddrinfo(struct addrinfo *result);         //释放result指向的指针

const char *gai_strerror(int errcode);  //辅助函数,用于打印getaddrinfo的错误信息

1. hostname, 是一个字符串, 是主机名称(域名或者host文件中的对应名称)或者IP地址.
2. service, 是一个字符串, 可以是端口号, 也可以是知名服务名称, 比如ftp, http. 一般使用端口号, 和 hostname 参数一起组成套接字地址.
3. hints, 顾名思义, 这其实是一个提示, 是一个指向addrinfo结构的指针, 调用者需要在指针指向的结构里填上一些必要数据, 来指示这个函数的工作. 详情要和最后一个参数结合起来看.
4. result, 指向addrinfo类型的指针的指针. 这个函数会在result变量中填入一个指针, 指针指向一个指向addrinfo的指针.

struct addrinfo
{ 　　　　　　　
	int ai_flags;               //一个位掩码, 用于一些设置, 可以用 OR 运算符连接
	int ai_family;              //AF_INET 或者 AF_INET6
	int ai_socktype;            //详述
	int ai_protocol;            //设置为0
	size_t ai_addrlen;
	struct sockaddr *ai_addr;   //指向套接字地址结构的指针
	char *ai_canonname;
	struct addrinfo *ai_next;   //指向下一个addrinfo的指针, 所以这是一个链表
};

1. ai_flags, 这个是用于控制的位掩码, 有如下设置:
   1. AI_ADDRCONFIG, 当本地主机被配置为IPV4的时候, 就返回IPV4地址, 配置为IPV6就返回IPV6地址. 如果要使用 connect 函数, 就设置这个.
   2. AI_CANONNAME, 不设置该标记则 char *ai_canonname 默认为 NULL, 设置了就会将链表中第一个addrinfo结构的ai_canonname指向host的名称.
   3. AI_NUMBERICSERV, 设置该标记强制指定getaddrinfo的第二个参数service为端口号的字符串.
   4. AI_PASSIVE, getaddrinfo默认返回主动套接字, 设置这个标记可以返回被动套接字用于服务端, 设置这个标记同时还约束了 getaddrinfo 的第一个参数hostname必须为NULL. 这样返回的套接字地址内是通配符.
2. ai_socktype, 这个可以设置成TCP连接(SOCK_STREAM, 此时result 对于每个地址只有一个只有头节点的链表对应, 有几个地址就有几个节点. 默认是最多返回3个节点的链表.), 还可以设置成数据报或者原始套接字.
3. protocol, 这个就是协议号, 设置成0即可. 一般清零之后就无需特意设置了.

1. 客户端调用, 则必须知道 hostname 和 service. addrinfo 结构中的 ai_flags 可以不设置. ai_family 则是AF_INET(IPV6就是AF_INET6), ai_protocol是0.
2. 服务端调用, hostname设置为NULL, 表示接受所有的地址访问. service必须设置成指定的端口. ai_flags设置成AI_PASSIVE.

1. 客户端, 会依次尝试在每个套接字地址上调用 socket 和 connect, 直到成功.
2. 服务端, 会尝试在套接字地址上调用 socket 和bind ,直到成功.

1. 如果与hostname参数关联的地址有多个，那么适用于所请求地址簇的每个地址都返回一个对应的结构。
2. 如果service参数指定的服务支持多个套接口类型，那么每个套接口类型都可能返回一个对应的结构，具体取决于hints结构的ai_socktype成员

getnameinfo

#include <sys/socket.h>
#include <netdb.h>

int getnameinfo(const struct sockaddr *sa, socklen_t salen, char *host, size_t hostlen, char *service, size_t servlen, int flags);

1. sa, 要转换的套接字地址结构, 这个结构可以由accept函数返回.
2. salen, 套接字地址的长度, 也可以由accept函数返回.
3. host, 存放转换出来的主机名称的字符串
4. hostlen, 主机名字符串长度
5. service, 存放转换后端口号字符串
6. servlen, 字符串长度
7. flags, 控制掩码. 设置为NI_NUMBERICHOST表示返回一个数字地址字符串, 而不是默认的域名. NI_NUMERICSERV会返回端口号, 如果不设置, 默认是根据/etc/services返回服务名.

#include <stdio.h>
#include <sys/socket.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXLINE 8192


int main(int argc, char **argv) {
    //声明所需的一批变量
    struct addrinfo *p, *listp, hints;
    char buf[MAXLINE];
    int rc, flags;

    //判断命令行是否正确
    if (argc != 2) {
        fprintf(stderr, "usage: %s <domain name>\n", argv[0]);
        exit(0);
    }

    //清空hints结构
    memset(&hints, 0, sizeof(struct addrinfo));

    //设置hints的参数, 由于这里要把域名换成地址, 所以是主动socket, 要去连接指定的地址
    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_STREAM;

    //判断 getaddrinfo 是否出错
    if ((rc = getaddrinfo(argv[1], NULL, &hints, &listp)) != 0) {
        fprintf(stderr, "GETADDRINFO ERROR: %s\n", gai_strerror(rc));
        exit(1);
    }

    //设置调用getnameinfo的flags, 返回IP地址而不是域名
    flags = NI_NUMERICHOST;

    //遍历listp结构, 对于其中的每个节点的 ai_addr, 转换成域名放在buf里, 然后打印出来
    for (p = listp; p; p = p->ai_next) {
        getnameinfo(p->ai_addr, p->ai_addrlen, buf, MAXLINE, NULL, 0, flags);
        printf("%s\n", buf);
    }

    //释放完无需再使用的listp
    freeaddrinfo(listp);

    exit(0);
}

练习11.4 使用inet_pton 而不是 getnameinfo 来转换套接字地址为IP地址字符串

#include <stdio.h>
#include <sys/socket.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXLINE 8192

int main(int argc, char **argv) {
    struct addrinfo *p, *listp, hints;
    //定义从 addrinfo 中获取 ai_addr 指针的变量
    struct sockaddr * middleaddr;
    //定义将 sockaddr 结构转换成 sockaddr_in 结构的指针
    struct sockaddr_in *targetaddr;
    char buf[MAXLINE];
    int rc;
    //定义无符号地址整数的变量
    unsigned int addr;


    if (argc != 2) {
        fprintf(stderr, "usage: %s <domain name>\n", argv[0]);
    }

    memset(&hints, 0, sizeof(struct addrinfo));

    hints.ai_family = AF_INET;

    hints.ai_socktype = SOCK_STREAM;

    if ((rc = getaddrinfo(argv[1], NULL, &hints, &listp)) != 0) {
        fprintf(stderr, "GETADDRINFO ERROR: %s\n", gai_strerror(rc));
        exit(1);
    }

    //此时获取了每个节点里的 ai_addr 就是 sockaddr 结构, 将其转换为 sockaddr_in 之后, 其中的 in_addr 结构就是IP地址结构, 其中的 s_addr 就是IP地址的无符号整数了

    for (p = listp; p; p = p->ai_next) {

        // middleaddr 是指向 sockaddr 结构的指针
        middleaddr = (p->ai_addr);

        //强制类型转换成 sockaddr_in 类型的指针
        targetaddr = (struct sockaddr_in *) middleaddr;

        //获取无符号32位整数的地址表示, 注意, 已经是经过了网络字节顺序变化的了, 因为是 getaddrinfo 设置的
        addr = targetaddr->sin_addr.s_addr;

        //转换成字符串写入buf中
        inet_ntop(AF_INET, &addr, buf, 16);

        printf("%s\n", buf);
    }
    freeaddrinfo(listp);
    exit(0);
}

open_clientfd

#include <stdio.h>
#include <sys/socket.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int open_clientfd2(char *hostname, char *port){

    //要返回的套接字描述符
    int clientfd;
    //是否成功解析了地址
    int is_getaddrinfo;
    //调用 getaddrinfo 所需要准备的变量
    struct addrinfo hints, *listp, *p;

    //调用 getaddrinfo , 获取成功的链表
    memset(&hints, 0, sizeof(struct addrinfo));
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_family = AF_INET;
    //设置FLAG为要使用connect , 以及强制使用端口号作为参数
    hints.ai_flags = AI_ADDRCONFIG|AI_NUMERICSERV;
    //这里需要判断一下是否能够解析
    if ((is_getaddrinfo = getaddrinfo(hostname, port, &hints, &listp)) != 0) {
        printf("解析地址错误: %s\n", gai_strerror(is_getaddrinfo));
        exit(0);
    }

    //遍历链表
    for (p = listp; p; p = p->ai_next) {
        //尝试调用socket返回描述符
        if ((clientfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) < 0) {
            //失败就继续下一个
            continue;
        }

        //连接成功就直接退出循环
        if ((connect(clientfd, p->ai_addr, p->ai_addrlen)) != -1) {
            break;
        }

        //执行到这里说明连接失败, 要关闭这个描述符. 下一次循环中再尝试打开
        close(clientfd);
    }

    //执行到这里已经获取了clientfd或者遍历完了链表, 可以释放链表
    Freeaddrinfo(listp);

    //如果p为空, 则说明遍历了所有节点都连接失败, 就返回-1. 如果p不为空说明在p处连接成功并break出来, 就返回clientfd描述符
    if(!p) {
        return -1;
    } else {
        return clientfd;
    }
}

int main(int argc, char **argv){

    int fd = open_clientfd2(argv[1], argv[2]);

    printf("获得的套接字是 %d \n", fd);
}

open_listenfd

#include <stdio.h>
#include <sys/socket.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//创建服务端, 只需要端口, 无需地址
int open_serverfd2(char *port){

    //要返回的监听套接字描述符
    int listenfd;
    //是否成功解析了地址
    int is_getaddrinfo;
    //调用 getaddrinfo 所需要准备的变量
    struct addrinfo hints, *listp, *p;
    //重用套接字的设置
    int reuse = 1;

    //调用 getaddrinfo , 获取成功的链表
    memset(&hints, 0, sizeof(struct addrinfo));
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_family = AF_INET;
    //注意AI_PASSIVE的设置
    hints.ai_flags = AI_ADDRCONFIG|AI_PASSIVE|AI_NUMERICSERV;
    //使用NULL来调用
    if ((is_getaddrinfo = getaddrinfo(NULL, port, &hints, &listp)) != 0) {
        printf("getaddrinfo函数出错: %s\n", gai_strerror(is_getaddrinfo));
        exit(0);
    }

    //遍历链表, 找到可以bind的地址
    for (p = listp; p; p = p->ai_next) {
        //调用 socket 函数获取描述符
        if ((listenfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) < 0) {
            //失败就继续下一个
            continue;
        }

        //由于每次循环间隔很短, 这里要对套接字描述符进行设置, 让其在关闭之后可以迅速被重用
        Setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, (const void *)&reuse, sizeof(int));


        //尝试bind, 成功绑定就跳出循环
        if ((bind(listenfd, p->ai_addr, p->ai_addrlen)) == 0) {
            break;
        }

        //执行到这里说明无法绑定, 关闭这个描述符. 下一次循环会再设置描述符
        close(listenfd);
    }

    //执行到这里已经获取了绑定成功的监听套接字或者遍历完链表, 可以释放链表
    Freeaddrinfo(listp);

    //如果p为空, 则说明遍历了所有节点都连接失败, 就返回-1. 如果p不为空说明绑定成功, 继续调用listen函数
    if(!p) {
        return -1;
    }

    //listen函数
    if (listen(listenfd, 1024) == -1) {
        Close(listenfd);
        return -1;
    }
    return listenfd;
}

int main(int argc, char **argv){

    int fd = open_serverfd2(argv[1]);

    printf("获得的监听套接字是 %d \n", fd);
}