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()
![[Cortex-M3]-5-cache uncache](https://img-blog.csdnimg.cn/d8f74ce4d8ca4131990dd2dc4c34d21b.png)
