Linux网络编程之socket通信

一、socket相关函数使用

1.1 IP地址转换函数：

小端法：（pc本地存储） 高位存高地址，低位存低地址。

大端法：（网络存储） 高位存低地址，低位存高地址。

htonl --> 本地 -->> 网络 （IP）

htons --> 本地 -->> 网络 (port)

ntohl --> 网络 -->> 本地（IP）

ntohs --> 网络 -->> 本地（Port）

1.int inet_pton(int af, const char *src, void *dst);
本地字节序（string IP） ---> 网络字节序
af：AF_INET、AF_INET6
src：传入，IP地址（点分十进制）
dst：传出，转换后的 网络字节序的 IP地址。 
返回值：
成功： 1
异常： 0 说明src指向的不是一个有效的ip地址。
失败：-1

2.const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
网络字节序 ---> 本地字节序（string IP）
af：AF_INET、AF_INET6
src：网络字节序IP地址
dst：本地字节序（string IP）
size：dst 的大小
返回值： 成功 dst	
失败：NULL

sockaddr地址结构: IP + port	--> 在网络环境中唯一标识一个进程。
struct sockaddr_in addr;
addr.sin_family = AF_INET/AF_INET6
addr.sin_port = htons(9527);
int dst;
inet_pton(AF_INET, "192.157.22.45", (void *)&dst);
addr.sin_addr.s_addr = dst;
【*】addr.sin_addr.s_addr = htonl(INADDR_ANY); 取出系统中有效的任意IP地址，二进制类型。
bind(fd, (struct sockaddr *)&addr, size);

1.2 socket函数：

#include <sys/socket.h>
1.int socket(int domain, int type, int protocol);
创建一个套接字
domain：AF_INET、AF_INET6、AF_UNIX
type：SOCK_STREAM、SOCK_DGRAM
protocol：0 使用type对应的典型协议
返回值：
成功： 新套接字所对应文件描述符
失败： -1 errno

#include <arpa/inet.h>
2.int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
给socket绑定一个地址结构 (IP+port)
sockfd：socket 函数返回值

struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(8888);
addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr: 传入参数(struct sockaddr *)&addr

addrlen: sizeof(addr) 地址结构的大小。
返回值：
成功：0
失败：-1 errno

3.int listen(int sockfd, int backlog);
设置同时与服务器建立连接的上限数（同时进行3次握手的客户端数量）
sockfd：socket 函数返回值
backlog：上限数值，最大值 128
返回值：
成功：0
失败：-1 errno	

4.int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
阻塞等待客户端建立连接，成功的话，返回一个与客户端成功连接的socket文件描述符。
sockfd：socket 函数返回值
addr：传出参数。成功与服务器建立连接的那个客户端的地址结构（IP+port）

socklen_t clit_addr_len = sizeof(addr);
addrlen：传入传出参数，&clit_addr_len
入：addr的大小。 出：客户端addr实际大小。

返回值：
成功：能与客户端进行数据通信的 socket 对应的文件描述。
失败： -1 ， errno

5.int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
使用现有的 socket 与服务器建立连接
sockfd： socket 函数返回值

struct sockaddr_in srv_addr; // 服务器地址结构
srv_addr.sin_family = AF_INET;
srv_addr.sin_port = 9527 	// 跟服务器bind时设定的 port 完全一致。
inet_pton(AF_INET, "服务器的IP地址"，&srv_adrr.sin_addr.s_addr);
addr：传入参数,服务器的地址结构
addrlen：服务器的地址结构的大小

返回值：
成功：0
失败：-1 errno
如果不使用bind绑定客户端地址结构, 采用"隐式绑定"。

二、客户端服务端socket通信

服务端：

#include <stdio.h>
#include <ctype.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>

// 端口号
#define SERV_PORT 9527


void sys_err(const char *str)
{
    perror(str);
    exit(1);
}

int main(int argc, char *argv[])
{
	// lfd为监听socket句柄 cfd为与客户端建立服务socket句柄 在accept函数中生成
    int lfd = 0, cfd = 0;
    int ret, i;
    // BUFSIZ为系统宏
    char buf[BUFSIZ], client_IP[1024];

	// 定义服务器地址结构 和 客户端地址结构
    struct sockaddr_in serv_addr, clit_addr;
    // 客户端地址结构大小
    socklen_t clit_addr_len;

	// IPv4
    serv_addr.sin_family = AF_INET;
    // 转为网络字节序的 端口号	
    serv_addr.sin_port = htons(SERV_PORT);
    // 获取本机任意有效IP
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);

    lfd = socket(AF_INET, SOCK_STREAM, 0);		//创建一个 socket
    if (lfd == -1) {
        sys_err("socket error");
    }

	// 给服务器socket绑定地址结构（IP+port)
    bind(lfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
	// 设置监听上限
    listen(lfd, 128);
	// 获取客户端地址结构大小
    clit_addr_len = sizeof(clit_addr);
	// 阻塞等待客户端连接请求
    cfd = accept(lfd, (struct sockaddr *)&clit_addr, &clit_addr_len);
    if (cfd == -1)
        sys_err("accept error");

	// 根据accept传出参数，获取客户端 ip 和 port
    printf("client ip:%s port:%d\n", 
            inet_ntop(AF_INET, &clit_addr.sin_addr.s_addr, client_IP, sizeof(client_IP)), 
            ntohs(clit_addr.sin_port));

    while (1) {
    	// 读客户端数据
        ret = read(cfd, buf, sizeof(buf));
        // 写到屏幕查看
        write(STDOUT_FILENO, buf, ret);
		// 小写 -- 大写
        for (i = 0; i < ret; i++)
            buf[i] = toupper(buf[i]);
		// 将大写 写回给客户端
        write(cfd, buf, ret);
    }

    close(lfd);
    close(cfd);

    return 0;
}

客户端：

#include <stdio.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>

#define SERV_PORT 9527

void sys_err(const char *str)
{
	perror(str);
	exit(1);
}

int main(int argc, char *argv[])
{
    int cfd;
    int conter = 10;
    char buf[BUFSIZ];
    //服务器地址结构
    struct sockaddr_in serv_addr;

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(SERV_PORT);
    //inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr.s_addr);
    inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr);

    cfd = socket(AF_INET, SOCK_STREAM, 0);
    if (cfd == -1)
        sys_err("socket error");

    int ret = connect(cfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
    if (ret != 0)
        sys_err("connect err");

    while (--conter) {
        write(cfd, "hello\n", 6);
        ret = read(cfd, buf, sizeof(buf));
        write(STDOUT_FILENO, buf, ret);
        sleep(1);
    }

    close(cfd);

	return 0;
}

三、通信时序与代码对应关系

通信时序总结：
三次握手：

主动发起连接请求端，发送 SYN 标志位，请求建立连接。 携带序号号、数据字节数(0)、滑动窗口大小。

被动接受连接请求端，发送 ACK 标志位，同时携带 SYN 请求标志位。携带序号、确认序号、数据字节数(0)、滑动窗口大小。

主动发起连接请求端，发送 ACK 标志位，应答服务器连接请求。携带确认序号。

四次挥手：

主动关闭连接请求端， 发送 FIN 标志位。 

被动关闭连接请求端， 应答 ACK 标志位。 		 ----- 半关闭完成。


被动关闭连接请求端， 发送 FIN 标志位。

主动关闭连接请求端， 应答 ACK 标志位。		 ----- 连接全部关闭

滑动窗口：

发送给连接对端，本端的缓冲区大小（实时），保证数据不会丢失。

四、socket通信封装接口

// 读取固定的长度
ssize_t Readn(int fd, void *vptr, size_t n)
{
	size_t  nleft;              //usigned 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
				return -1;
		} else if (nread == 0)
			break;

		nleft -= nread;   //nleft = nleft - nread 
		ptr += nread;
	}
	return n - nleft;
}

// 写固定长度
ssize_t Writen(int fd, const void *vptr, size_t n)
{
	size_t nleft;
	ssize_t nwritten;
	const char *ptr;

	ptr = vptr;
	nleft = n;
	while (nleft > 0) {
		if ( (nwritten = write(fd, ptr, nleft)) <= 0) {
			if (nwritten < 0 && errno == EINTR)
				nwritten = 0;
			else
				return -1;
		}
		nleft -= nwritten;
		ptr += nwritten;
	}
	return n;
}

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) {   //"hello\n"
			if (errno == EINTR)
				goto again;
			return -1;
		} else if (read_cnt == 0)
			return 0;

		read_ptr = read_buf;
	}
	read_cnt--;
	*ptr = *read_ptr++;

	return 1;
}

/*readline --- fgets*/    
//读一行 传出参数 vptr
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[] = hello\n
			*ptr++ = c;
			if (c == '\n')
				break;
		} else if (rc == 0) {
			*ptr = 0;
			return n-1;
		} else
			return -1;
	}
	*ptr = 0;

	return n;
}

五、TCP通信流程分析

server:
	1. socket()	           创建socket
	2. bind()	           绑定服务器地址结构
	3. listen()	           设置监听上限
	4. accept()	           阻塞监听客户端连接
	5. read(fd)	           读socket获取客户端数据
	6. toupper()           小--大写
	7. write(fd)
	8. close()

client:
	1. socket()	            创建socket
	2. connect()	        与服务器建立连接
	3. write()	            写数据到 socket
	4. read()	            读转换后的数据。
	5. write(STDOUT_FILENO) 显示读取结果
	6. close()