Linux网络套接字socket
网络套接字：socket
socket是一个文件描述符-伪文件
一个文件描述符（fd）指向一个套接字（该套接字内部由内核借助两个缓冲区实现）
在网络通信中，套接字一定是成对出现的
1）网络字节序
小端法：（pc 本地存储）高位存高地址、低位存低地址
大端法：（网络存储）高位存低地址、低位存低地址
二进制比特位左边认为是高位，右边认为是低位。
TCP/IP 协议规定：网络数据流应采用大端字节序
htonl --> 本地 --> 网络（IP） //将主机的无符号长整形数转换成网络字节顺序。
htons --> 本地 --> 网络（port）
ntohl --> 网络 --> 本地（IP）
ntohs --> 网络 --> 本地（port）
//htons() host to network short
//htonl() host to network long
//ntohl() network to host long
//ntohs() network to host short
//h表示host, n表示network, l表示32位长整数, s表示16位短整数
2）IP地址转换函数
//本地字节序（string IP）-->网络字节序
int inet_pton(int af, const char *src, void *dst);
//af: AF_INET、AF_INET6 ipv4 ipv6
//src: IP地址（点分十进制）
//dst: 传出，转换后的 网络字节序的 IP地址
//①返回值：成功 1 ②异常 0，说明src指向的不是一个有效的ip地址 ③失败 -1
//网络字节序-->本地字节序（string IP）
const char* *inet_ntop(int af, const void *src, char *dst, socklen_t size);
//af: AF_INET、AF_INET6 ipv4 ipv6
//src: 网络字节序IP地址
//dst: 本地字节序（string IP）
//size: dst 的大小
//①返回值：成功 dst ②失败 NULL
3）socketaddr 数据结构
socketaddr 地址结构
struct sockaddr_in addr;
addr.sin_family = AF_INET / AF_INET6;
addr.sin_port = hton(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_in addr *)&addr, size);
//成员查看：man 7 ip
4）网络套接字函数
//服务端
bind() //绑定IP+port
listen() //设置监听上限（同时），而不是设置监听
accept() //阻塞监听客户端连接。创建成功会返回一个socket
//客户端
connect() //绑定IP+port
toupper(int c) //小写转大写
①socket()函数
#intclude <sys/socket.h>
int socket(int domain, int type, int protocol); //创建一个套接字
//domain：AF_INET、AF_INET6、AF_UNIX
//type：SOCK_STREAM、SOCK_DGRAM 流式套接字（TCP）/数据报格式(UDP)套接字
//protocol:0
//返回值：成功：新套接字所对应的文件描述符 失败：-1 error
②bind()函数
#include <arpa/inet.h>
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 = hton(9527);
addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr：(struct sockaddr *)&addr 传入参数
addrlen：sizeof(addr); //地址结构大小
//返回值 成功：0 失败：-1
③listen()函数
int listen(int sockfd, int backlog); //设置同时与服务器建立连接的上限数（同时进行3次握手的客户端数量）
sockfd：socket //函数返回值
backlog： //上限数值 最大值128
//返回值 成功：0 失败：-1
④accept()函数
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
⑤connect()函数
int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
//使用现有的socket与服务器建立连接
sockfd：socket //函数返回值
struck socketaddr_in serv_addr; //服务器地址结构
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = 9527 ; //跟服务器bind时设定的port完全一致
inet_pton(AF_INET, "服务器地址", &serv_addr.sin_addr.s_addr);
addr： //传入参数 服务器地址结构
addrlen： //服务器的地址结构的大小
//返回值： 成功 0 失败 -1 error
//如果不使用bind绑定客户端地址结构，采用“隐式绑定”
TCP通信流程分析
server:
1.socket() //创建socket
2.bind() //绑定服务器地址
3.listen() //设置监听上限
4.accept() //阻塞监听客户端连接
5.read() //读socket获取客户端数据
6.小--大写 // toupper()
7.write()
8.close()
client：
1.socket() //创建socket
2.connect() //与服务器建立连接
3.write() //写数据到socket
4.read() //读转换后的数据
5.显示读取结果
6.close()
（实际上流程中有三个套接字产生：客户端socket-服务器socket（通信+监听））
5）TCP通信简单实现
服务端实现：
#include <stdio.h>
#include <ctype.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#define SERV_PORT 9527
void sys_err(const char *str)
{
perror(str);
exit(1);
}
int main(){
int lfd = 0, cfd = 0;
int ret, i;
char buf[BUFSIZ], client_IP[1024];
struct sockaddr_in serv_addr, clit_addr;
socklen_t clit_addr_len;
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(SERV_PORT);
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
lfd = socket(AF_INET,SOCK_STREAM,0);
if(lfd == -1)
{
sys_err("socket error");
}
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");
printf("client ip:%s port:%d\n", inet_ntop(AF_INET, &clit_addr.sin_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 <ctype.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.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", 5);
ret = read(cfd, buf, sizeof(buf));
write(STDOUT_FILENO, buf, ret);
sleep(1);
}
close(cfd);
return 0;
}
基于TCP协议的client / server 程序的一般流程
- accept返回表示三次握手建立连接成功
- read返回0则表示半关闭成功
流程：
服务器调用
socket()、bind()、listen()、完成初始化后，调用accept()阻塞监听，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后，从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。
6）错误处理函数
上面的例子不仅功能简单，而且简单到几乎没有什么错误处理，我们知道，系统调用不能保证每次都成功，必须进行出错处理，这样一方面可以保证程序逻辑正常，另一方面可以迅速得到故障信息。
为使错误处理的代码不影响主程序的可读性，我们把与socket相关的一些系统函数加上错误处理代码包装成新的函数，做成一个模块wrap.c
封装目的：
在server.c编程中突出逻辑，将错位处理与逻辑分开，可以直接跳转man手册
同时也有代码复用的一个思想，比如可以制作成动态库，下次直接链接即可
①wrap.h
存放 网络通信相关常用 自定义函数原型（声明）
增添错误处理函数后的 S/C通信：
#ifndef __WRAP_H_
#define __WRAP_H_
void sys_err(const char *s);
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr);
int Bind(int fd, const struct sockaddr *sa, socklen_t salen);
int Connect(int fd, const struct sockaddr *sa, socklen_t salen);
int Listen(int fd, int backlog);
int Socket(int family, int type, int protocol);
ssize_t Read(int fd, void *ptr, size_t nbytes);
ssize_t Write(int fd, const void *ptr, size_t nbytes);
int Close(int fd);
ssize_t Readn(int fd, void *vptr, size_t n);
ssize_t Writen(int fd, const void *vptr, size_t n);
ssize_t my_read(int fd, char *ptr);
ssize_t Readline(int fd, void *vptr, size_t maxlen);
#endif
②wrap.c
存放网络通信相关常用 自定义函数
命名方式：系统调用函数首字符大写，方便查看man手册
如：Listen（）、Accept（）；
函数功能：调用系统调用函数，处理出错场景
在server.c 和 client.c 中调用 自定义函数
#include <stdio.h>
#include <ctype.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <unistd.h>
#include <pthread.h>
#include <signal.h>
#include <errno.h>
#include "wrap.h"
void sys_err(const char *s)
{
perror(s);
exit(1);
}
int Socket(int family, int type, int protocol)
{
int n;
if ( (n = socket(family, type, protocol)) < 0)
sys_err("socket error");
return n;
}
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)
{
int n;
again:
if ( (n = accept(fd, sa, salenptr)) < 0) {
if ((errno == ECONNABORTED) || (errno == EINTR))
goto again;
else
sys_err("accept error");
}
return n;
}
int Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
int n;
if ((n = bind(fd, sa, salen)) < 0)
sys_err("bind error");
return n;
}
int Connect(int fd, const struct sockaddr *sa, socklen_t salen)
{
int n;
if ((n = connect(fd, sa, salen)) < 0)
sys_err("connect error");
return n;
}
int Listen(int fd, int backlog)
{
int n;
if ((n = listen(fd, backlog)) < 0)
sys_err("listen error");
return n;
}
ssize_t Read(int fd, void *ptr, size_t nbytes)
{
ssize_t n;
again:
if ( (n = read(fd, ptr, nbytes)) == -1) {
if (errno == EINTR)
goto again;
else
return -1;
}
return n;
}
ssize_t Write(int fd, const void *ptr, size_t nbytes)
{
ssize_t n;
again:
if ( (n = write(fd, ptr, nbytes)) == -1) {
if (errno == EINTR)
goto again;
else
return -1;
}
return n;
}
int Close(int fd)
{
int n;
if ((n = close(fd)) == -1)
sys_err("close error");
return n;
}
ssize_t Readn(int fd, void *vptr, size_t n)
{
size_t nleft;
ssize_t nread;
char *ptr;
ptr = vptr;
nleft = 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;
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;
}
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) {
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;
}
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++ = c;
if (c == '\n')
break;
} else if (rc == 0) {
*ptr = 0;
return n - 1;
} else
return -1;
}
*ptr = 0;
return n;
}
③server.c
#include <stdio.h>
#include <ctype.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include "wrap.h"
#define SERV_PORT 9527
int main(int argc, char *argv[])
{
//创建socket
int lfd = 0;
lfd = Socket(AF_INET, SOCK_STREAM, 0);
//bind绑定ip和端口
struct sockaddr_in serv_addr;
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(SERV_PORT);
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
Bind(lfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
//设置监听个数
Listen(lfd, 128);
//accept
struct sockaddr_in clit_addr;
socklen_t clit_addr_len = sizeof(clit_addr); //创建客户端地址
int cfd = 0;
cfd = Accept(lfd, (struct sockaddr *)&clit_addr, &clit_addr_len);
char client_IP[1024];
printf("client ip:%s port:%d\n",
inet_ntop(AF_INET, &clit_addr.sin_addr, client_IP,sizeof(client_IP)),
ntohs(clit_addr.sin_port)
);
char buf[BUFSIZ];
while(1){
int ret = read(cfd, buf, sizeof(buf)); //读客户端数据
write(STDOUT_FILENO, buf, ret); //写到屏幕查看
for(int i = 0; i < ret; i++) //小写---大写
buf[i] = toupper(buf[i]);
write(cfd, buf, ret); //将大写，写回给客户端
}
close(lfd);
close(cfd);
return 0;
}
④client.c
#include <stdio.h>
#include <ctype.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include "wrap.h"
#define SERV_PORT 9527
int main(int argc, char *argv[])
{
int cfd, ret;
cfd = Socket(AF_INET, SOCK_STREAM, 0);
//创建服务器地址结构
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, "服务器ip", &serv_addr.sin_addr.s_addr);
//连接服务端
Connect(cfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
//与服务端通信逻辑
int conter = 10;
char buf[BUFSIZ];
while(--conter)
{
write(cfd, "hello\n", 6);
ret = read(cfd, buf, sizeof(buf));
write(STDOUT_FILENO, buf, ret);
sleep(1);
}
close(cfd);
return 0;
}
联合编译：
- server.c 和 wrap.c 生成 server
- client.c 和 wrap.c 生成 client
readn、readline ： 读N个字节，读一行（这里未使用）
浙公网安备 33010602011771号